PHP ReflectionFunctionAbstract::getNumberOfParameters方法代码示例

 /**
  * Populates arguments assembled from the event and the given target function.
  * 
  * @param \ReflectionFunctionAbstract $ref
  * @param EventParamResolverInterface $resolver
  * @return array
  */
 protected function loadArguments(\ReflectionFunctionAbstract $ref, EventParamResolverInterface $resolver)
 {
     $args = [];
     if ($ref->getNumberOfParameters() > 1) {
         foreach (array_slice($ref->getParameters(), 1) as $param) {
             $args[] = $resolver->resolve($param->getClass(), $param->isDefaultValueAvailable() ? $param->getDefaultValue() : false);
         }
     }
     return $args;
 }

 /**
  * Resolves function arguments.
  *
  * @param array $parameters
  *
  * @return array
  *
  * @throws UnresolvableArgumentException
  */
 public function resolve(array $parameters)
 {
     if (!($number = $this->reflection->getNumberOfParameters())) {
         return [];
     }
     $arguments = array_fill(0, $number, null);
     foreach ($this->getParameters() as $pos => $parameter) {
         $result = $this->match($parameter, $parameters);
         if ($result) {
             $arguments[$pos] = $result[1];
             unset($parameters[$result[0]]);
             continue;
         }
         if ($parameter->isDefaultValueAvailable()) {
             $arguments[$pos] = $parameter->getDefaultValue();
             continue;
         }
         throw new UnresolvableArgumentException($parameter);
     }
     return $arguments;
 }

 /**
  *  normalize the params of the $rmethod to allow a valid call
  *
  *  @example
  *    // method signature: foo($bar = '',$baz = '',SomeClass $che);
  *    $rmethod = new ReflectionMethod($instance,'foo');
  *    $this->normalizeParams($rmethod,array('che','cha')) // retuns array('che','cha',automatically created SomeClass Instance)
  *    $this->normalizeParams($rmethod,array('che')) // retuns array('che','',automatically created SomeClass Instance)
  *    $this->normalizeParams($rmethod,array('che' => new SomeClass(),'bar' => '')) // retuns array('','',passed in SomeClass Instance)       
  *        
  *  @param  ReflectionFunctionAbstract  $rfunc  the reflection of the method/function
  *  @param  array $params any params you want to pass to override any magically
  *                        discovered params
  *  @return array the params ready to be passed to the method using something like call_user_func_array
  */
 public function normalizeParams(\ReflectionFunctionAbstract $rfunc, array $params = array())
 {
     // canary...
     if ($rfunc->getNumberOfParameters() <= 0) {
         return $params;
     }
     //if
     $ret_params = array();
     $rparams = $rfunc->getParameters();
     foreach ($rparams as $rparam) {
         $ret_params[] = $this->normalizeParam($rparam, $params);
     }
     //foreach
     return $ret_params;
 }

 /**
  * Create a string representation of the method signature.
  *
  * @param ReflectionFunctionAbstract $func The function you want a signature for.
  * @return void
  **/
 public static function makeFunctionSignature(ReflectionFunctionAbstract $func)
 {
     $signature = $func->getName() . '( ';
     foreach ($func->getParameters() as $param) {
         $signature .= '$' . $param->getName();
         if ($param->isDefaultValueAvailable()) {
             $signature .= ' = ' . var_export($param->getDefaultValue(), true);
         }
         $signature .= ', ';
     }
     if ($func->getNumberOfParameters() > 0) {
         $signature = substr($signature, 0, -2);
     }
     $signature .= ' )';
     return $signature;
 }

 private static function hashParameters(\ReflectionFunctionAbstract $method)
 {
     $res = [];
     if (PHP_VERSION_ID < 70000 && $method->getNumberOfParameters() && $method->getFileName()) {
         $res[] = file($method->getFileName())[$method->getStartLine() - 1];
     }
     foreach ($method->getParameters() as $param) {
         $res[] = [$param->getName(), PHP_VERSION_ID >= 70000 ? PhpReflection::getParameterType($param) : NULL, $param->isVariadic(), $param->isDefaultValueAvailable() ? $param->isDefaultValueConstant() ? $param->getDefaultValueConstantName() : [$param->getDefaultValue()] : NULL];
     }
     return $res;
 }

 /**
  * @param \ReflectionFunctionAbstract $func
  * @param integer                     $num
  * @return boolean
  */
 public static function matchesNumberOfArguments(\ReflectionFunctionAbstract $func, $num)
 {
     return $func->getNumberOfRequiredParameters() <= $num && $func->getNumberOfParameters() >= $num;
 }