/** * (non-PHPdoc) * @see \PHPFluent\EventManager\Listener::execute() */ public function execute(Event $event, array $context = array()) { $arguments = array($event, $context); $parameters = $this->reflection->getParameters(); $firstParameter = array_shift($parameters); if ($firstParameter instanceof \ReflectionParameter && $firstParameter->isArray()) { $arguments = array_reverse($arguments); } return $this->reflection->invokeArgs($arguments); }
public function getResponse($method, $uri) { foreach ($this->routes as $route) { if ($match = $route($method, $uri)) { if (is_callable($match[0])) { if (empty($match[1])) { return $match[0](); } // http://www.creapptives.com/post/26272336268/calling-php-functions-with-named-parameters $ref = new \ReflectionFunction($match[0]); $this->params = []; foreach ($ref->getParameters() as $p) { if (!$p->isOptional() and !isset($match[1][$p->name])) { throw new \Exception("Missing parameter {$p->name}"); } if (!isset($match[1][$p->name])) { $this->params[$p->name] = $p->getDefaultValue(); } else { $this->params[$p->name] = $match[1][$p->name]; } } return $ref->invokeArgs($this->params); } return $match[0]; } } throw new \Exception($method . ':' . $uri . ' not found'); }
function exec_function_array($o, array $B = array()) { switch (count($B)) { case 0: return $o(); case 1: return $o($B[0]); case 2: return $o($B[0], $B[1]); case 3: return $o($B[0], $B[1], $B[2]); case 4: return $o($B[0], $B[1], $B[2], $B[3]); case 5: return $o($B[0], $B[1], $B[2], $B[3], $B[4]); default: if (is_object($o)) { $v = new ReflectionMethod($o, '__invoke'); return $v->invokeArgs($o, $B); } else { if (is_callable($o)) { $v = new ReflectionFunction($o); return $v->invokeArgs($B); } } } }
/** * Runs all the middlewares of given type. */ public static function runMiddlewares($type = self::BEFORE_REQUEST) { $apricot = static::getInstance(); $middlewares = $apricot->middlewares; /** @var \Exception */ $error = null; foreach ($middlewares as $key => $middleware) { $hasNextMiddleware = array_key_exists($key + 1, $middlewares); if ($type !== $middleware['type']) { continue; } $r = new \ReflectionFunction($middleware['callback']); $parameters = $r->getParameters(); $next = $hasNextMiddleware ? $middlewares[$key + 1] : function () { }; try { $r->invokeArgs(array($error, $next)); } catch (\Exception $e) { // If there is no more middleware to run, throw the exception. if (!$hasNextMiddleware) { throw $e; } $error = $e; } } }
public function exec($key) { //匿名函数 if ($this->route[$key]['callback'] instanceof Closure) { //反射分析闭包 $reflectionFunction = new \ReflectionFunction($this->route[$key]['callback']); $gets = $this->route[$key]['get']; $args = []; foreach ($reflectionFunction->getParameters() as $k => $p) { if (isset($gets[$p->name])) { //如果GET变量中存在则将GET变量值赋予,也就是说GET优先级高 $args[$p->name] = $gets[$p->name]; } else { //如果类型为类时分析类 if ($dependency = $p->getClass()) { $args[$p->name] = App::build($dependency->name); } else { //普通参数时获取默认值 $args[$p->name] = App::resolveNonClass($p); } } } echo $reflectionFunction->invokeArgs($args); } else { //设置控制器与方法 Request::set('get.' . c('http.url_var'), $this->route[$key]['callback']); Controller::run($this->route[$key]['get']); } }
/** * * @param array $arguments * * @return mixed */ public function invoke($arguments = array()) { if ($this->isMethod) { return $this->reflection->invokeArgs($this->thisObject, $arguments); } return $this->reflection->invokeArgs($arguments); }
/** * Packs 8-bit integers into a binary string * * @since 1.0 * * @param int $ascii,... 8-bit unsigned integer * @return binary */ public static function pack($ascii) { $packer = new \ReflectionFunction('pack'); $args = func_get_args(); array_unshift($args, 'C*'); return $packer->invokeArgs($args); }
/** * @param \Closure $closure * @return mixed */ public function call($closure) { $reflect = new \ReflectionFunction($closure); $parameters = $reflect->getParameters(); $dependencies = $this->getDependencies($parameters); return $reflect->invokeArgs($dependencies); }
function XLLoop_reflection_handler() { try { $input = file_get_contents('php://input'); $value = json_decode($input); if ($value != NULL) { $argc = count($value->args); $args = array(); for ($i = 0; $i < $argc; $i++) { $args[$i] = XLLoop_decode($value->args[$i]); } $function = new ReflectionFunction($value->name); if ($function->isUserDefined()) { $reqArgc = $function->getNumberOfParameters(); for ($i = $argc; $i < $reqArgc; $i++) { $args[$i] = 0; } $result = $function->invokeArgs($args); $enc = XLLoop_encode($result); print json_encode($enc); } else { print json_encode(XLLoop_encode("#Function " . $value->name . "() does not exist")); } } else { print "<html><body><code>XLLoop function handler alive</code></body></html>"; } } catch (Exception $e) { print json_encode(XLLoop_encode("#" . $e->getMessage())); } }
/** * Asserts that a function is implemented and returns the expected result * * @param String $function The function name * @param Array $params The parameters * @param Mixed $result The expected result * * @dataProvider provideTestCheckAPI * @return void */ public function testCheckAPI($function, array $params, $result) { $api = new OldPHPAPI_Test(); $api->checkAPI(); $this->assertTrue(function_exists($function), "Function {$function} is not defined."); $reflection = new ReflectionFunction($function); $this->assertEquals($result, $reflection->invokeArgs($params)); }
public function callFunction($function) { /** @var \ReflectionFunction $reflectionFunction */ $reflectionFunction = new \ReflectionFunction($function); $signatureParams = $reflectionFunction->getParameters(); $calledFunctionArgs = $this->resolveParams($signatureParams); $reflectionFunction->invokeArgs($calledFunctionArgs); }
/** * @param $method * @param array $args * @param bool $singleton * @return mixed * @throws \Exception */ public function execute($method, array $args = array(), $singleton = true) { if (is_array($method) && count($method) >= 2) { list($class, $name) = $method; $reflection = new \ReflectionMethod($class, $name); } elseif (is_callable($method)) { $reflection = new \ReflectionFunction($method); } else { throw new \RuntimeException(); } $parameters = $reflection->getParameters(); $args = $this->getReflectionValues($parameters, $args, $singleton); if ($reflection instanceof \ReflectionFunction) { return $reflection->invokeArgs($args); } else { return $reflection->invokeArgs($class, $args); } }
private function prepareArgs($sql, $arguments = null) { if ($arguments != null && count($arguments) > 0) { $sprintfargs = array_merge(array($sql), $arguments); $sprintf = new \ReflectionFunction('sprintf'); $sql = $sprintf->invokeArgs($sprintfargs); } return $sql; }
/** * * @param string $callback * @param array $params * @return mixed */ public static function invoke_function($callback, array $params = NULL) { $class = new ReflectionFunction($callback); if (empty($params)) { return $class->invoke(); } else { return $class->invokeArgs($params); } }
/** * Execute the active controller */ public function processController() { // closure if (is_callable($this->controller)) { $func = new \ReflectionFunction($this->controller); return $func->invokeArgs($this->controller_args); } else { return Controller::execute($this->controller, $this->controller_args); } }
protected function invokeClosure($targetValue) { if (is_callable($this->condition)) { $reflection = new \ReflectionFunction($this->condition); if (!$reflection->isClosure()) { throw new Exceptions\NotCallable("Specified condition is not closure, can't proceed"); } return $reflection->invokeArgs(array($targetValue)); } return false; }
/** * @param string $type * @param callable $callback * @param array $arguments * * @return bool|mixed */ private function isType($type, callable $callback = null, array $arguments = array()) { if ($type != $this->current) { return false; } elseif (is_callable($callback)) { $closure = new \ReflectionFunction($callback); return $closure->invokeArgs($arguments); } else { return true; } }
/** * Invokes the function and allows to pass its arguments as an array * * @param array<integer,mixed> $arguments * Arguments * @return mixed * Return value of the function invocation * @since PHP 5.1.0 */ public function invokeArgs(array $arguments) { /* return $this->forwardCallToReflectionSource( __FUNCTION__, array( $arguments ) ); /*/ if ($this->reflectionSource instanceof ReflectionFunction) { return $this->reflectionSource->invokeArgs($arguments); } else { return parent::invokeArgs($arguments); } //*/ }
/** * Receive Message * * @param ConnectionInterface $from * @param string $message */ public function onMessage(ConnectionInterface $from, $message) { $decrypted = $this->crypt->decrypt($message, $this->config['key'], $this->config['passphrase']); $msg = $this->decode($decrypted); if (is_array($msg)) { $lambda = new \ReflectionFunction($this->closure); $lambda->invokeArgs([$msg, $this->logger]); } if ($msg === false) { $this->logger->error('Message from ' . $from->remoteAddress . ' is invalid.'); } }
function nativeToFunction($f) { $reflection = new \ReflectionFunction($f); $args = array(); foreach ($reflection->getParameters() as $param) { $args[] = new RVar($param->getName()); } $result = $reflection->invokeArgs($args); if (!(is_object($result) && is_subclass_of($result, "\\r\\Query"))) { throw new RqlDriverError("The function did not evaluate to a query (missing return? missing rxpr(...)?)."); } return new RFunction($args, $result); }
/** * {@inheritDoc} */ public function apply(array $arguments = []) { if ($this->isFunction()) { return $this->reflection->invokeArgs($arguments); } elseif ($this->isMethodStatic()) { return $this->reflection->invokeArgs(null, $arguments); } elseif ($this->isMethod()) { if (!$this->object) { throw new \RuntimeException('The object is required for invoke method (ReflectionMethod::invokeArgs)'); } return $this->reflection->invokeArgs($this->object, $arguments); } else { throw new \RuntimeException(sprintf('The reflection "%s" not supported.', get_class($this->getReflection()))); } }
function andThen($f) { if (!is_callable($f)) { throw new Error('$f must be a function'); } $new_cases = array(); foreach ($this->cases as $k => $v) { $new_cases[] = new BFCase($v->condition, function () use($f, $v) { $args = func_get_args(); $vf = new \ReflectionFunction($v->f); return $f($vf->invokeArgs($args)); }); } return new PartialFunction($new_cases); }
/** * @param $callable * @return mixed * @throws \Exception */ public function call($callable) { if (is_callable($callable) && is_array($callable)) { $reflection = new \ReflectionClass($callable[0]); $method = $reflection->getMethod($callable[1]); return $method->invokeArgs($callable[0], $this->injectByFunctionArguments($method->getParameters())); } else { if (is_callable($callable)) { $reflection = new \ReflectionFunction($callable); return $reflection->invokeArgs($this->injectByFunctionArguments($reflection->getParameters())); } else { throw new InjectorException("Wrong type of argument"); } } }
private function executeOperation(ImageInterface $image, string $operationName, array $args) { $operation = new \ReflectionFunction($this->getOperation($operationName)); $callArgs = []; foreach ($operation->getParameters() as $parameter) { if ($parameter->getName() === 'image') { $callArgs[] = $image; } elseif (array_key_exists($parameter->getName(), $args)) { $callArgs[] = $args[$parameter->getName()]; } else { throw new \RuntimeException('Parameter ' . $parameter->getName() . ' missing for image operation ' . $operationName); } } return $operation->invokeArgs($callArgs); }
public function route($method, $path) { $parser = new UriTemplate(); $results = []; $routes = $this->table[strtoupper($method)]; foreach ($routes as $route) { $args = $parser->extract($route[0], $path, true); if (isset($args)) { // reflect this function as late as possible, since *most* routes shouldn't be called $ref = new \ReflectionFunction($route[1]); $results[] = \Closure::bind(function () use($ref, $args) { return $ref->invokeArgs($args); }, null); } } // always return a callable function inside an array return empty($results) ? [$this->emptyRoute] : $results; }
public function handle(Request $request, $type = HttpKernelInterface::MASTER_REQUEST, $catch = true) { // создаем контекст, используя данные запроса $context = new RequestContext(); $context->fromRequest($request); $matcher = new UrlMatcher($this->routes, $context); try { $attributes = $matcher->match($request->getPathInfo()); $arguments = $attributes; unset($arguments['_route']); unset($arguments['controller']); $controller = $attributes['controller']; $function = new \ReflectionFunction($controller); $response = $function->invokeArgs($arguments); } catch (ResourceNotFoundException $e) { $response = new Response('Не найден!', Response::HTTP_NOT_FOUND); } return $response; }
static function call_user_func_named_array($method, $normal_arr, $named_att, $inlineContent) { $ref = new \ReflectionFunction($method); $params = []; foreach ($ref->getParameters() as $p) { $name = $p->name; if (isset($named_att[$name])) { $params[] = $named_att[$name]; } elseif ($inlineContent && isset($inlineContent[$name]) && is_string($inlineContent[$name])) { $params[] = $inlineContent[$name]; } elseif (!empty($normal_arr)) { $params[] = array_shift($normal_arr); } elseif ($p->isOptional()) { $params[] = $p->getDefaultValue(); } else { throw new \Exception("Missing parameter {$p->name}"); } } return $ref->invokeArgs($params); }
/** * @param string $alias * @param array $arguments * * @throws MethodNotFoundException * @throws InvalidArgumentException * @throws RuntimeException * * @return mixed */ public function invoke($alias, $arguments) { // if the method requested is available if (!isset($this->methodMap[$alias])) { throw new MethodNotFoundException($alias); } try { // reflect the global function $reflection = new \ReflectionFunction($this->methodMap[$alias]); // check the parameters in the reflection against what was sent in the request $arguments = $this->checkParams($reflection->getParameters(), $arguments); // return the result as an invoked call return $reflection->invokeArgs($arguments); } catch (\ReflectionException $rex) { // Propagate an appropriate exception throw new RuntimeException("Reflections failed on alias: {$alias}", 0, $rex); } catch (\Exception $ex) { throw new RuntimeException("Execution of method '{$alias}' failed.", 0, $ex); } }
/** * 调用全局函数 * * @param string $method * 函数名称 * @param array $arr * @throws MissingArgumentException */ static function call_user_func_named_array($method, array $arr = []) { $ref = new \ReflectionFunction($method); $params = []; foreach ($ref->getParameters() as $p) { if ($p->isOptional()) { if (isset($arr[$p->name])) { $params[] = $arr[$p->name]; } else { $params[] = $p->getDefaultValue(); } } else { if (isset($arr[$p->name])) { $params[] = $arr[$p->name]; } else { throw new MissingArgumentException("Missing parameter {$p->name}"); } } } return $ref->invokeArgs($params); }
function nativeToFunction($f) { if (is_object($f) && is_subclass_of($f, "\\r\\Query")) { return wrapImplicitVar($f); } $reflection = new \ReflectionFunction($f); $args = array(); foreach ($reflection->getParameters() as $param) { $args[] = new RVar($param->getName()); } $result = $reflection->invokeArgs($args); if (!(is_object($result) && is_subclass_of($result, "\\r\\Query"))) { if (!isset($result)) { // In case of null, assume that the user forgot to add a return. // If null is the intended value, r\expr() should be wrapped around the return value. throw new RqlDriverError("The function did not evaluate to a query (missing return?)."); } else { $result = nativeToDatum($result); } } return new RFunction($args, $result); }