PHP ReflectionParameter::isVariadic方法代码示例

 public function getType() : Type
 {
     if ($this->type === null) {
         $phpDocType = $this->phpDocType;
         if ($phpDocType !== null && $this->reflection->isDefaultValueAvailable() && $this->reflection->getDefaultValue() === null) {
             $phpDocType = $phpDocType->makeNullable();
         }
         $this->type = TypehintHelper::decideTypeFromReflection($this->reflection->getType(), $phpDocType, $this->reflection->getDeclaringClass() !== null ? $this->reflection->getDeclaringClass()->getName() : null, $this->reflection->isVariadic());
     }
     return $this->type;
 }

 public function testWrappedMethods()
 {
     $php_parameter = new \ReflectionParameter([$this, 'method'], 'param');
     $our_parameter = new ReflectionParameter($php_parameter);
     $this->assertSame($php_parameter->getName(), $our_parameter->getName());
     $this->assertSame($php_parameter->allowsNull(), $our_parameter->allowsNull());
     $this->assertSame($php_parameter->isOptional(), $our_parameter->isOptional());
     $this->assertSame($php_parameter->isDefaultValueAvailable(), $our_parameter->isDefaultValueAvailable());
     $this->assertSame($php_parameter->isVariadic(), $our_parameter->isVariadic());
     $this->assertSame($php_parameter->isPassedByReference(), $our_parameter->isPassedByReference());
     $this->assertSame($php_parameter->getDefaultValue(), $our_parameter->getDefaultValue());
 }

 /**
  * @param \ReflectionParameter $parameter
  * @param mixed                $value
  *
  * @return mixed
  *
  * @throws HttpException If the object cannot be instantiated.
  */
 private function getParameterValue(\ReflectionParameter $parameter, $value)
 {
     $class = $parameter->getClass();
     if ($class) {
         if ($parameter->isVariadic()) {
             $result = [];
             foreach ($value as $subValue) {
                 $result[] = $this->getObject($class->getName(), $subValue);
             }
             return $result;
         } else {
             return $this->getObject($class->getName(), $value);
         }
     }
     return $value;
 }

 /**
  * @param  ReflectionParameter $parameter
  *
  * @return boolean
  * @since  Method available since Release 2.2.1
  */
 private function isVariadic(ReflectionParameter $parameter)
 {
     return method_exists('ReflectionParameter', 'isVariadic') && $parameter->isVariadic();
 }

 /**
  * Returns whether an argument is variadic.
  *
  * @param \ReflectionParameter $parameter
  *
  * @return bool
  */
 private function isVariadic(\ReflectionParameter $parameter)
 {
     return PHP_VERSION_ID >= 50600 && $parameter->isVariadic();
 }

 private function isVariadic(\ReflectionParameter $parameter)
 {
     return $this->supportsVariadic && $parameter->isVariadic();
 }

 /**
  * @param \ReflectionParameter $reflectionParameter
  *
  * @return bool
  */
 protected function isParameterVariadic(\ReflectionParameter $reflectionParameter)
 {
     if (is_callable(array($reflectionParameter, 'isVariadic')) && $reflectionParameter->isVariadic()) {
         return true;
     }
     return false;
 }

 /**
  * Return string representation of parameter
  *
  * @param Parameter|ParsedParameter $parameter Reflection parameter
  *
  * @return string
  */
 protected function getParameterCode($parameter)
 {
     $type = '';
     if ($parameter->isArray()) {
         $type = 'array';
     } elseif ($parameter->getClass()) {
         $type = '\\' . $parameter->getClass()->name;
     }
     $defaultValue = null;
     $isDefaultValueAvailable = $parameter->isDefaultValueAvailable();
     if ($isDefaultValueAvailable) {
         if ($parameter instanceof ParsedParameter) {
             $defaultValue = $parameter->getDefaultValueDefinition();
         } else {
             $defaultValue = var_export($parameter->getDefaultValue());
         }
     } elseif ($parameter->isOptional()) {
         $defaultValue = 'null';
     }
     $code = ($type ? "{$type} " : '') . ($parameter->isPassedByReference() ? '&' : '') . ($this->useVariadics && $parameter->isVariadic() ? '...' : '') . '$' . $parameter->name . ($defaultValue !== null ? " = " . $defaultValue : '');
     return $code;
 }

 private function assertSameParameterAttributes(\ReflectionParameter $original, ReflectionParameter $stubbed)
 {
     $this->assertSame($original->getName(), $stubbed->getName());
     $this->assertSame($original->isArray(), $stubbed->isArray());
     $this->assertSame($original->isCallable(), $stubbed->isCallable());
     //$this->assertSame($original->allowsNull(), $stubbed->allowsNull()); @TODO WTF?
     $this->assertSame($original->canBePassedByValue(), $stubbed->canBePassedByValue());
     $this->assertSame($original->isOptional(), $stubbed->isOptional());
     $this->assertSame($original->isPassedByReference(), $stubbed->isPassedByReference());
     $this->assertSame($original->isVariadic(), $stubbed->isVariadic());
     if ($class = $original->getClass()) {
         $stubbedClass = $stubbed->getClass();
         $this->assertInstanceOf(ReflectionClass::class, $stubbedClass);
         $this->assertSame($class->getName(), $stubbedClass->getName());
     } else {
         $this->assertNull($stubbed->getClass());
     }
 }

 /**
  * @return bool
  */
 public function isVariadic()
 {
     return $this->parameter->isVariadic();
 }