/** * * @global array $config * @param string $class naziv kotrolera koji se instancira * @param string $method metod koji se poziva * @param array $params parametri metode */ public static function loadController($controller, $method, $params = array()) { global $config; $path_to_controller = realpath("controllers/" . strtolower($controller) . "Controller.php"); if (file_exists($path_to_controller)) { include_once $path_to_controller; $controller = strtolower($controller) . "Controller"; $controller_instance = new $controller(); if (!is_subclass_of($controller_instance, 'baseController')) { echo $config['Poruke']['noBaseCont']; die; } if (method_exists($controller_instance, $method)) { $refl = new ReflectionMethod(get_class($controller_instance), $method); $numParams = $refl->getNumberOfParameters(); if ($numParams > 0 && count($params) < $numParams) { echo $config['Poruke']['noParams']; die; } call_user_func_array(array($controller_instance, $method), $params); } else { echo $config['Poruke']['noMethod']; } } else { echo $config['Poruke']['error404']; } }
public function dispatch() { $acao = self::sulfixo_controle . $this->paginaSolicitada; if (method_exists($this, $acao)) { $reflection = new ReflectionMethod($this, $acao); $qtdArgumentos = $reflection->getNumberOfParameters(); $parametros = array(); $i = 0; foreach ($_GET as $key => $value) { if (!empty($value) && $key != 'a' && $i <= $qtdArgumentos) { $parametros[$i] = $value; } $i++; } if (count($parametros) < $qtdArgumentos) { $i = $qtdArgumentos - count($parametros); for ($index = 0; $index < $i; $index++) { $parametros[$index + count($parametros) + 1] = ''; } } call_user_func_array(array($this, $acao), $parametros); } else { $this->erro_404(); } }
public static function run() { $currentPath = substr($_SERVER['REQUEST_URI'], 44); $currentMethod = $_SERVER['REQUEST_METHOD']; if (strpos($currentPath, '?') !== false) { $currentPath = explode('?', $currentPath); $currentPath = $currentPath[0]; } foreach (static::$routes as $value) { $matches[] = array(); if (preg_match($value['path'], $currentPath, $matches) === 0) { continue; } if ($currentMethod !== $value['method']) { continue; } unset($matches[0]); $controller = new $value['class'](); $info = new \ReflectionMethod($controller, $value['function']); if ($info->getNumberOfParameters() !== count($matches)) { throw new \Exception('Numero de parametros incorrecto: ' . $value['class'] . '::' . $value['function']); } $response = $info->invokeArgs($controller, $matches); if (is_null($response)) { return; } if ($response instanceof View) { Response::view($response); } return; } // Lanzar 404 App::abort(404, 'No se encuentra la ruta'); }
/** * @param \ReflectionMethod $method * @return bool */ private function isAutoloadMethod(\ReflectionMethod $method) { if (strpos($method->getName(), KnotConsts::AUTOLOAD_METHOD_PREFIX) !== 0 || $method->getNumberOfParameters() != 1 || $method->getNumberOfRequiredParameters() != 1 || $method->isStatic() || $method->isAbstract() || !Extractor::instance()->has($method, KnotConsts::AUTOLOAD_ANNOTATIONS)) { return false; } return true; }
/** * Runs the action. * The action method defined in the controller is invoked. * This method is required by {@link CAction}. */ public function run() { $controller = $this->getController(); $methodName = 'action' . $this->getId(); $method = new ReflectionMethod($controller, $methodName); if (($n = $method->getNumberOfParameters()) > 0) { $params = array(); foreach ($method->getParameters() as $i => $param) { $name = $param->getName(); if (isset($_GET[$name])) { if ($param->isArray()) { $params[] = is_array($_GET[$name]) ? $_GET[$name] : array($_GET[$name]); } else { if (!is_array($_GET[$name])) { $params[] = $_GET[$name]; } else { throw new CHttpException(400, Yii::t('yii', 'Your request is invalid.')); } } } else { if ($param->isDefaultValueAvailable()) { $params[] = $param->getDefaultValue(); } else { throw new CHttpException(400, Yii::t('yii', 'Your request is invalid.')); } } } $method->invokeArgs($controller, $params); } else { $controller->{$methodName}(); } }
/** * Call this method to load all rules */ public function loadRules() { $this->rules = []; foreach (get_class_methods($this) as $rule) { if (mb_substr($rule, 0, 6) === 'rule__') { $name = mb_substr($rule, 6); $method = new \ReflectionMethod($this, $rule); if (!$method->getNumberOfParameters() === 3) { //the method expects too much/less arguments $this->errorHandler->log('methods', "The method \"{$name}\" expects " . $method->getNumberOfParameters() . " but it should expect 3 arguments."); continue; } $this->rules[] = ['name' => $name, 'class' => $method]; } } }
public static function gettersToArray($object) { if (!is_object($object)) { throw new \InvalidArgumentException('$object must be an object.'); } $result = []; // Iterate over all getters. foreach (get_class_methods($object) as $method) { if (strncmp('get', $method, 3) == 0) { $reflector = new \ReflectionMethod($object, $method); if ($reflector->isPublic() && $reflector->getNumberOfParameters() == 0) { $key = lcfirst(substr($method, 3)); $value = $object->{$method}(); if (is_array($value)) { foreach ($value as &$entry) { if (is_object($entry)) { $entry = static::gettersToArray($entry); } } } $result[$key] = is_object($value) ? static::gettersToArray($value) : $value; } elseif ($object instanceof Question && $method === 'getQuestions') { for ($i = 0; $i < $object->getDimensions(); $i++) { foreach ($object->getQuestions($i) as $question) { $result['questions'][$i][] = self::gettersToArray($question); } } } } } return $result; }
public function __construct($class, $method) { parent::__construct(); $ref = new ReflectionMethod($class, $method); $this->_ref = $ref; $this->_args = $ref->getParameters(); $this->_args_cnt = $ref->getNumberOfParameters(); }
public function testSearchMethod() { $et = new ExactTarget("", ""); $this->assertTrue(method_exists('ExactTarget', 'search'), "search method exists"); $method = new ReflectionMethod('ExactTarget', 'search'); $num = $method->getNumberOfParameters(); $this->assertEquals(2, $num, "has 2 function argument"); }
/** * Returns the number of parameters * * @return integer The number of parameters * @since PHP 5.0.3 */ public function getNumberOfParameters() { if ($this->reflectionSource instanceof ReflectionMethod) { return $this->reflectionSource->getNumberOfParameters(); } else { return parent::getNumberOfParameters(); } }
/** * @return Method[] */ public static function methodListFromReflectionClassAndMethod(Context $context, CodeBase $code_base, \ReflectionClass $class, \ReflectionMethod $reflection_method) : array { $reflection_method = new \ReflectionMethod($class->getName(), $reflection_method->name); $method = new Method($context, $reflection_method->name, new UnionType(), $reflection_method->getModifiers()); $method->setNumberOfRequiredParameters($reflection_method->getNumberOfRequiredParameters()); $method->setNumberOfOptionalParameters($reflection_method->getNumberOfParameters() - $reflection_method->getNumberOfRequiredParameters()); $method->setFQSEN(FullyQualifiedMethodName::fromStringInContext($method->getName(), $context)); return self::functionListFromFunction($method, $code_base); }
public function runWithParams($params) { $method = new ReflectionMethod($this, 'run'); if ($method->getNumberOfParameters() > 0) { return $this->runWithParamsInternal($this, $method, $params); } else { return $this->run(); } }
public function setDefaultOptions(OptionsResolverInterface $resolver) { $resolver->setRequired(array('fields')); $reflection = new \ReflectionMethod($resolver, 'setAllowedTypes'); if ($reflection->getNumberOfParameters() === 2) { $resolver->setAllowedTypes('fields', 'array'); } else { $resolver->setAllowedTypes(array('fields' => 'array')); } }
function resolve2($context, array $path) { $original_path = $path; $head = array_shift($path); $args = $path; $head = $this->translate($head); // If the head is empty, then the URL ended in a slash (/), assume // the index is implied if (!$head) { $head = 'index'; } try { $method = new \ReflectionMethod($context, $head); // Ensure that the method is visible if (!$method->isPublic()) { return false; } // Check if argument count matches the rest of the URL if (count($args) < $method->getNumberOfRequiredParameters()) { // Not enough parameters in the URL return false; } if (count($args) > ($C = $method->getNumberOfParameters())) { // Too many parameters in the URL — pass as many as possible to the function $path = array_slice($args, $C); $args = array_slice($args, 0, $C); } // Try to call the method and see what kind of response we get $result = $method->invokeArgs($context, $args); if ($result instanceof View\BaseView) { return $result; } elseif (is_callable($result)) { // We have a callable to be considered the view. We're done. return new View\BoundView($result, $args); } elseif ($result instanceof Dispatcher) { // Delegate to a sub dispatcher return $result->resolve(implode('/', $path)); } elseif (is_object($result)) { // Recurse forward with the remainder of the path return $this->resolve2($result, $path); } // From here, we assume that the call failed } catch (\ReflectionException $ex) { // No such method, try def() or recurse backwards } catch (Exception\ConditionFailed $ex) { // The matched method refused the request — recurse backwards } // Not able to dispatch the method. Try def() if ($head != 'def') { $path = array_merge(['def'], $original_path); return $this->resolve2($context, $path); } // Unable to dispatch the request return false; }
/** * Выполняет действие с переданными параметрами запроса. Данный метод * вызывается методом {@link CController::runAction()} * @param array $params параметры запроса (имя => значение) * @return boolean верны ли параметры запроса * @since 1.1.7 */ public function runWithParams($params) { $methodName = 'action' . $this->getId(); $controller = $this->getController(); $method = new ReflectionMethod($controller, $methodName); if ($method->getNumberOfParameters() > 0) { return $this->runWithParamsInternal($controller, $method, $params); } else { return $controller->{$methodName}(); } }
private function _execute_add_action_methods() { foreach (get_class_methods($this) as $method) { if (Strings::position($method, 'add_action_') === 0 || Strings::position($method, 'add_filter_') === 0) { $action_name = str_replace(['add_filter_', 'add_action_'], '', $method); $reflection = new \ReflectionMethod($this, $method); $params_count = $reflection->getNumberOfParameters(); add_filter($action_name, [$this, $method], 10, $params_count); } } }
public function _empty($name, $args) { require_once APP_PATH . CONTROLLER_NAME . '/' . 'Controller' . '/' . CONTROLLER_NAME . 'Controller.class.php'; $controller = A('Admin/' . CONTROLLER_NAME); $action = ACTION_NAME; try { $method = new \ReflectionMethod($controller, $name); // URL参数绑定检测 if ($method->getNumberOfParameters() > 0 && C('URL_PARAMS_BIND')) { switch ($_SERVER['REQUEST_METHOD']) { case 'POST': $vars = array_merge($_GET, $_POST); break; case 'PUT': parse_str(file_get_contents('php://input'), $vars); break; default: $vars = $_GET; } $params = $method->getParameters(); $paramsBindType = C('URL_PARAMS_BIND_TYPE'); foreach ($params as $param) { $name = $param->getName(); if (1 == $paramsBindType && !empty($vars)) { $args[] = array_shift($vars); } elseif (0 == $paramsBindType && isset($vars[$name])) { $args[] = $vars[$name]; } elseif ($param->isDefaultValueAvailable()) { $args[] = $param->getDefaultValue(); } else { E(L('_PARAM_ERROR_') . ':' . $name); } } // 开启绑定参数过滤机制 if (C('URL_PARAMS_SAFE')) { array_walk_recursive($args, 'filter_exp'); $filters = C('URL_PARAMS_FILTER') ?: C('DEFAULT_FILTER'); if ($filters) { $filters = explode(',', $filters); foreach ($filters as $filter) { $args = array_map_recursive($filter, $args); // 参数过滤 } } } $method->invokeArgs($controller, $args); } else { $method->invoke($controller); } } catch (\ReflectionException $e) { $this->error('404,您访问的页面不存在。'); } }
/** * Hydrate an entity object from a source * * @param type $entity is the entity we want to populate * @param \stdClass $object is the source of datas * @param EntityManager $em The entity manager * * @return \PhraseanetSDK\Entity\EntityInterface */ public static function hydrate(EntityInterface $entity, \stdClass $object, EntityManager $em) { $className = get_class($entity); $reflectionClass = new \ReflectionClass($className); foreach (get_object_vars($object) as $propertyName => $propertyValue) { $methodName = self::camelize(sprintf('set%s', ucfirst($propertyName))); if ($reflectionClass->hasMethod($methodName)) { $reflectionMethod = new \ReflectionMethod($className, $methodName); if ($reflectionMethod->getNumberOfParameters() > 0) { $parameters = $reflectionMethod->getParameters(); if (is_scalar($propertyValue)) { foreach ($parameters as $parameter) { /* @var $parameter \ReflectionParameter */ if (null === $parameter->getClass()) { $entity->{$methodName}($propertyValue); } elseif ('DateTime' === $parameter->getClass()->getName()) { $date = \DateTime::createFromFormat(\DateTime::ATOM, $propertyValue, new \DateTimeZone(date_default_timezone_get())); $entity->{$methodName}($date); } } } elseif (is_array($propertyValue)) { $entityCollection = new ArrayCollection(); foreach ($propertyValue as $object) { if (is_object($object)) { $subEntity = self::hydrate($em->getEntity($propertyName), $object, $em); $entityCollection->add($subEntity); } elseif (is_scalar($object)) { $entityCollection->add($object); } } foreach ($parameters as $parameter) { /* @var $parameter \ReflectionParameter */ if ($parameter->getClass() && $parameter->getClass()->isInstance($entityCollection)) { $entity->{$methodName}($entityCollection); } } } elseif (is_object($propertyValue)) { if (!ctype_digit($propertyName)) { $subEntity = self::hydrate($em->getEntity($propertyName), $propertyValue, $em); foreach ($parameters as $parameter) { /* @var $parameter \ReflectionParameter */ if ($parameter->getClass() && $parameter->getClass()->isInstance($subEntity)) { $entity->{$methodName}($subEntity); } } } } } } } return $entity; }
private function _callmethod($controller, $method, $args = array()) { if (is_callable(array($controller, $method))) { $reflection = new ReflectionMethod($controller, $method); $argnum = $reflection->getNumberOfParameters(); if ($argnum > count($args) + 1) { throw new Exception("not_found call method failed [ method name: {$method} ]."); } $reflection->invokeArgs($controller, $args); return true; } return false; }
private static function validateCall() { $controller = 'application\\controllers\\' . ucfirst(self::$request->controller); $reflection = new \ReflectionMethod($controller, ucfirst(self::$request->action)); $countWaitingParams = $reflection->getNumberOfParameters(); $countWaitingRequiredParams = $reflection->getNumberOfRequiredParameters(); $countComingParams = count(self::$request->params); if ($countComingParams > $countWaitingParams || $countComingParams < $countWaitingRequiredParams) { throw new InvalidException("Passed wrong number of arguments to the method", 404); } else { return $controller; } }
/** * Realiza el dispatch de una ruta * * @return Object */ public static function execute($route) { extract($route, EXTR_OVERWRITE); if (!(include_once APP_PATH . "controllers/{$controller_path}" . '_controller.php')) { throw new KumbiaException(NULL, 'no_controller'); } //Asigna el controlador activo $app_controller = Util::camelcase($controller) . 'Controller'; $cont = self::$_controller = new $app_controller($module, $controller, $action, $parameters); View::select($action); View::setPath($controller_path); // Se ejecutan los filtros before if ($cont->k_callback('initialize') === FALSE) { return $cont; } if ($cont->k_callback('before_filter') === FALSE) { return $cont; } //Se ejecuta el metodo con el nombre de la accion //en la clase de acuerdo al convenio if (!method_exists($cont, $action)) { throw new KumbiaException(NULL, 'no_action'); } //Obteniendo el metodo $reflectionMethod = new ReflectionMethod($cont, $action); //k_callback y __constructor metodo reservado if ($reflectionMethod->name == 'k_callback' || $reflectionMethod->isConstructor()) { throw new KumbiaException('Esta intentando ejecutar un método reservado de KumbiaPHP'); } //se verifica que el metodo sea public if (!$reflectionMethod->isPublic()) { throw new KumbiaException(NULL, 'no_action'); } //se verifica que los parametros que recibe //la action sea la cantidad correcta $num_params = count($parameters); if ($cont->limit_params && ($num_params < $reflectionMethod->getNumberOfRequiredParameters() || $num_params > $reflectionMethod->getNumberOfParameters())) { throw new KumbiaException("Número de parámetros erroneo para ejecutar la acción \"{$action}\" en el controlador \"{$controller}\""); } $reflectionMethod->invokeArgs($cont, $parameters); //Corre los filtros after $cont->k_callback('after_filter'); $cont->k_callback('finalize'); //Si esta routed volver a ejecutar if (Router::getRouted()) { Router::setRouted(FALSE); return Dispatcher::execute(Router::get()); // Vuelve a ejecutar el dispatcher } return $cont; }
/** * @param string $context * @param string $controller * @param string $action * @param array|string|null $params * @return string $controller * @throws \Exception */ private static function validateCall($context, $controller, $action, $params = null) { $controller = 'App\\' . ucfirst($context) . '\\Controller\\' . ucfirst($controller) . "Controller"; $action = 'action' . ucfirst($action); $rFunction = new \ReflectionMethod($controller, $action); $countParams = $rFunction->getNumberOfParameters(); $countRequiredParams = $rFunction->getNumberOfRequiredParameters(); $countArgs = count($params); if ($countArgs > $countParams || $countArgs < $countRequiredParams) { throw new HttpException("Passed wrong number of arguments to the method", 404); } else { return $controller; } }
/** * Runs worker action. * * @throws CException * @return array hash array(controllerId, actionName) */ public function run() { if (!$this->getJob() instanceof IWorkerJob) { throw new CException(Yii::t("worker", "Gearman job object not setted to controller action")); } $controller = $this->getController(); $methodName = 'action' . $this->getId(); $method = new ReflectionMethod($controller, $methodName); if ($method->getNumberOfParameters() == 1) { return $method->invokeArgs($controller, array($this->getJob())); } else { throw new CException("Controller action must contains 1 parameter"); } }
/** * 执行请求 * @param array $params 请求的参数数组 * @throws \Sky\base\HttpException */ public function run($params) { $controller = $this->getController(); if (isset($_REQUEST['ws'])) { $methodName = 'action' . $this->getId(); $method = new \ReflectionMethod($controller, $methodName); $useParamName = \Sky\Sky::$app->getUrlManager()->useParamName; if ($method->getNumberOfParameters() > 0) { if (isset($useParamName) && $useParamName === true) { $result = $this->runWithParamsInternal($controller, $method, $params); } else { $result = $this->runWithParamsOuter($controller, $method, $params); } } else { $result = $this->runInternal($controller, $methodName); } return $result; // if($result==false){ // throw new \Sky\base\HttpException(400,'Your request is invalid.'/*.ob_get_clean()*/); // }else{ // if ($controller->rawOutput) { // echo self::encode($this->getActionOutput()); // }else{ // if(!headers_sent()) // header('Content-Type: application/json;charset=utf-8'); // echo \Sky\help\JSON::encode($this->getActionOutput()); // } // } } else { if ($this->id === $this->wsdl) { $_REQUEST['IsWsdlRequest'] = true; } $provider = $controller; // $namespace=\Sky\Sky::$app->getRequest()->getBaseUrl(); if (($module = \Sky\Sky::$app->controller->module) === null) { $namespace = ltrim(\Sky\Sky::$app->getRequest()->getBaseUrl(), '\\/'); } else { $namespace = $module->name; if (($pos = strrpos($module->name, '\\')) !== false) { $namespace = substr($module->name, $pos + 1); } } $this->_service = new WebService($provider, $namespace); $this->_service->renderWsdl(); } if (function_exists('fastcgi_finish_request')) { fastcgi_finish_request(); } \Sky\Sky::$app->end(); }
/** * Runs handler action. * * @throws CException * @return array hash array(handlerId, actionName) */ public function run() { if (!$this->getJob() instanceof IGearmanJob) { throw new CException(Yii::t('gearman', 'Gearman job object not setted to handler action')); } $handler = $this->getHandler(); $methodName = 'action' . $this->getId(); $method = new ReflectionMethod($handler, $methodName); if ($method->getNumberOfParameters() == 1) { return $method->invokeArgs($handler, array($this->getJob())); } else { throw new CException('Handler action must contains 1 parameter'); } }
public static function exec() { $module = A(MODULE_NAME); $action = ACTION_NAME; try { if (!preg_match('/^[A-Za-z](\\w)*$/', $action)) { throw new ReflectionException(); } $method = new ReflectionMethod($module, $action); if ($method->isPublic()) { // $class = new ReflectionClass($module); switch (REQUEST_METHOD) { case 'post': $vars = array_merge($_POST, $_GET); break; case 'put': parse_str(file_get_contents('php://input'), $vars); break; default: $vars = $_GET; break; } $_REQUEST = $vars; if ($method->getNumberOfParameters() > 0) { $params = $method->getParameters(); foreach ($params as $param) { $name = $param->getName(); if (isset($vars[$name])) { $args[] = $vars[$name]; } elseif ($param->isDefaultValueAvailable()) { $args[] = $param->getDefaultValue(); } else { echo 'Error'; } } $method->invokeArgs($module, $args); } else { $method->invoke($module); } } else { // 非public方法 throw new ReflectionException(); } } catch (ReflectionException $e) { // 引导到_call $method = new ReflectionMethod($module, '__call'); $method->invokeArgs($module, array($action, '')); // print_r($e); } }
/** * Search for public methods on an Object for display in template * @author Fabien Potencier * @author Hélio Costa e Silva <*****@*****.**> * @param stdObject $object * @param mixed $item * @param array $arguments * @param boolean $arrayOnly */ protected function getAttribute($object, $item, array $arguments = array(), $arrayOnly = false) { if (is_object($object)) { $arrAllowedPrefixes = array('get', 'has', 'is', 'match', 'contain'); $reflection = new ReflectionObject($object); foreach ($arrAllowedPrefixes as $prefix) { if (strpos($item, $prefix) !== 0) { /* if isn't at first position, try next */ continue; } if ($reflection->hasMethod($item)) { $reflectionMethod = new ReflectionMethod($object, $item); if ($reflectionMethod->isPublic()) { if ($reflectionMethod->getNumberOfParameters() > 0) { return $reflectionMethod->invokeArgs($object, $arguments); } else { return $object->{$item}(); } } else { return null; } } } } $item = (string) $item; if ((is_array($object) || is_object($object) && $object instanceof ArrayAccess) && isset($object[$item])) { return $object[$item]; } if ($arrayOnly) { return null; } if (is_object($object) && isset($object->{$item})) { if ($this->env->hasExtension('sandbox')) { $this->env->getExtension('sandbox')->checkPropertyAllowed($object, $item); } return $object->{$item}; } /* @todo helio.costa __get __isset * __get() __isset() support. Still here for a while */ if (!is_object($object) || !method_exists($object, $method = $item) && !method_exists($object, $method = 'get' . $item)) { return null; } if ($this->env->hasExtension('sandbox')) { $this->env->getExtension('sandbox')->checkMethodAllowed($object, $method); } $reflection = new ReflectionObject($object); if ($reflection->hasMethod('__get')) { return call_user_func_array(array($object, $method), $arguments); } }
public function injectDependences(\ReflectionMethod $method, array $args = [], $byServiceKey = false) : array { $arguments = []; if ($method->getNumberOfParameters() > 0) { // Inject dependences foreach ($method->getParameters() as $parameter) { if ($byServiceKey === true) { $parameterNameAsSnake = strtolower(preg_replace('/(?<=\\w)(?=[A-Z])/', "_\$1", $parameter->getName())); } $key = $parameter->getPosition(); // Add parameter if they are given as default arguments. if (isset($args[$parameter->getName()]) === true) { $arguments[$key] = $args[$parameter->getName()]; } else { if (isset($args[$key]) === true) { $arguments[$key] = $args[$key]; } else { if ($byServiceKey === true && $this->servicesChain->has($parameterNameAsSnake) === true) { $value = $this->servicesChain->get($parameterNameAsSnake); $typeReturned = gettype($value) === 'object' ? get_class($value) : gettype($value); $typeExpected = (string) $parameter->getType(); if ($parameter->hasType() === true && $value instanceof $typeExpected === false) { throw new Exception($parameterNameAsSnake . " expects a '" . $typeExpected . "' type. Services has given a '" . $typeReturned . "' type"); } $arguments[$key] = $value; } else { if ($parameter->hasType() === true && $parameter->getType()->isBuiltin() === false && $this->servicesChain->has($parameter->getClass()->name) === true) { $arguments[$key] = $this->servicesChain->get($parameter->getClass()->name); } else { if ($parameter->isDefaultValueAvailable() === true) { if ($parameter->isDefaultValueConstant() === true) { $arguments[$key] = $parameter->getDefaultValueConstantName(); } else { $arguments[$key] = $parameter->getDefaultValue(); } } else { if ($parameter->isOptional() === true) { $arguments[$key] = null; } else { throw new \Exception("Required parameter is needed. Parameter: '" . $parameter->getName() . "' instance of '" . $parameter->getClass()->name . "'"); } } } } } } } } return $arguments; }
private function _call_method($class, $method, $args = array()) { if (is_callable(array($class, $method))) { $reflection = new ReflectionMethod($class, $method); $argnum = $reflection->getNumberOfParameters(); if ($argnum > count($args)) { throw new Exception('api.err reflection args not match', 1012); } //公共方法才允许被调用 $reflection->invokeArgs($class, $args); return true; } return false; }
protected function switch_off_user() { // Verify the integrity of our wrapper methods $target = new ReflectionFunction('switch_off_user'); $wrapper = new ReflectionMethod(__METHOD__); $this->assertSame($wrapper->getNumberOfParameters(), $target->getNumberOfParameters()); /* * `switch_off_user()` and the functions it subsequently calls will trigger "headers already sent" PHP errors, so * we need to mute them in order to avoid phpunit throwing an exception. */ $this->silence(); $user = switch_off_user(); $this->go_forth(); return $user; }