1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
|
<?php
/**
* @file
* The extension registry.
*/
namespace QueryPath;
/**
* A registry for QueryPath extensions.
*
* QueryPath extensions should call the QueryPath::ExtensionRegistry::extend()
* function to register their extension classes. The QueryPath library then
* uses this information to determine what QueryPath extensions should be loaded and
* executed.
*
* Extensions are attached to a Query object.
*
* To enable an extension (the easy way), use QueryPath::enable().
*
* This class provides lower-level interaction with the extension
* mechanism.
*
* @ingroup querypath_extensions
*/
class ExtensionRegistry {
/**
* Internal flag indicating whether or not the registry should
* be used for automatic extension loading. If this is false, then
* implementations should not automatically load extensions.
*/
public static $useRegistry = TRUE;
/**
* The extension registry. This should consist of an array of class
* names.
*/
protected static $extensionRegistry = array();
protected static $extensionMethodRegistry = array();
/**
* Extend a Query with the given extension class.
*/
public static function extend($classname) {
self::$extensionRegistry[] = $classname;
$class = new \ReflectionClass($classname);
$methods = $class->getMethods();
foreach ($methods as $method) {
self::$extensionMethodRegistry[$method->getName()] = $classname;
}
}
/**
* Check to see if a method is known.
* This checks to see if the given method name belongs to one of the
* registered extensions. If it does, then this will return TRUE.
*
* @param string $name
* The name of the method to search for.
* @return boolean
* TRUE if the method exists, false otherwise.
*/
public static function hasMethod($name) {
return isset(self::$extensionMethodRegistry[$name]);
}
/**
* Check to see if the given extension class is registered.
* Given a class name for a QueryPath::Extension class, this
* will check to see if that class is registered. If so, it will return
* TRUE.
*
* @param string $name
* The name of the class.
* @return boolean
* TRUE if the class is registered, FALSE otherwise.
*/
public static function hasExtension($name) {
return in_array($name, self::$extensionRegistry);
}
/**
* Get the class that a given method belongs to.
* Given a method name, this will check all registered extension classes
* to see if any of them has the named method. If so, this will return
* the classname.
*
* Note that if two extensions are registered that contain the same
* method name, the last one registred will be the only one recognized.
*
* @param string $name
* The name of the method.
* @return string
* The name of the class.
*/
public static function getMethodClass($name) {
return self::$extensionMethodRegistry[$name];
}
/**
* Get extensions for the given Query object.
*
* Given a Query object, this will return
* an associative array of extension names to (new) instances.
* Generally, this is intended to be used internally.
*
* @param Query $qp
* The Query into which the extensions should be registered.
* @return array
* An associative array of classnames to instances.
*/
public static function getExtensions(Query $qp) {
$extInstances = array();
foreach (self::$extensionRegistry as $ext) {
$extInstances[$ext] = new $ext($qp);
}
return $extInstances;
}
public static function extensionNames() {
return self::$extensionRegistry;
}
/**
* Enable or disable automatic extension loading.
*
* If extension autoloading is disabled, then QueryPath will not
* automatically load all registred extensions when a new Query
* object is created using qp().
*/
public static function autoloadExtensions($boolean = TRUE) {
self::$useRegistry = $boolean;
}
}
|
