lithium\aop\Filters::run()
Runs the chain and returns its result value. This method is used to make a method filterable.
All filters in the run will have access to given parameters. The implementation will be placed as the last item in the chain, so that effectively filters for the implementation wrap arround its implementation.
Creates Chain
objects lazily, caches and reuses them with differing
parameters for best of both worlds: lazy object construction to save
upfront memory as well as quick re-execution. This method may be called
quite often when filtered methods are executed inside a loop. Thus it
tries to reduce overhead as much as possible. Optimized for the common
case that no filters for a filtered method are present.
An example implementation function:
function($params) {
$params['foo'] = 'bar';
return $params['foo'];
}
Two examples to make a method filterable.
// Inside a static method.
Filters::run(get_called_class(), __FUNCTION__, $params, function($params) {
return 'implementation';
});
// Inside an instance method.
Filters::run($this, __FUNCTION__, $params, function($params) {
return 'implementation';
});
Parameters
-
string|object
$class
The fully namespaced name of a static class or an instance of a concrete class. Do not pass a class name for concrete classes. For instances will use a set of merged filters. First class filter, then instance filters.
-
string
$method
The method name i.e.
'bar'
. -
array
$params
-
callable
$implementation
Returns
mixedThe result of running the chain.
Source
public static function run($class, $method, array $params, $implementation) {
$implementation = static::_bcImplementation($class, $method, $params, $implementation);
if (!static::hasApplied($class, $method)) {
return $implementation($params);
}
return static::_chain($class, $method)->run($params, $implementation);
}