PHP ReflectionParameter::isDefaultValueConstant方法代码示例

 /**
  * Check whether a parameter's default value is a constant.
  *
  * This is only supported in PHP >= 5.4.3, and currently unimplemented in
  * HHVM.
  *
  * @param \ReflectionParameter $param
  *
  * @return boolean
  */
 protected static function isParamDefaultValueConstant(\ReflectionParameter $param)
 {
     // HHVM doesn't currently support `isDefaultValueConstant`, skip for now
     // see https://github.com/facebook/hhvm/issues/3812
     if (defined('HHVM_VERSION')) {
         return false;
     }
     return version_compare(PHP_VERSION, '5.4.3', '>=') && $param->isDefaultValueConstant();
 }

 /**
  * Format an individual Closure parameter.
  *
  * @param \ReflectionParameter $param
  *
  * @return string
  */
 protected function formatParam(\ReflectionParameter $param, $color = false)
 {
     $ret = '$' . $param->name;
     if ($color) {
         $ret = '<strong>' . $ret . '</strong>';
     }
     if ($param->isOptional()) {
         $ret .= ' = ';
         if (version_compare(PHP_VERSION, '5.4.3', '>=') && $param->isDefaultValueConstant()) {
             $name = $param->getDefaultValueConstantName();
             if ($color) {
                 $ret .= '<const>' . $name . '</const>';
             } else {
                 $ret .= $name;
             }
         } elseif ($param->isDefaultValueAvailable()) {
             $ret .= $this->manager->presentRef($param->getDefaultValue(), $color);
         } else {
             if ($color) {
                 $ret .= '<urgent>?</urgent>';
             } else {
                 $ret .= '?';
             }
         }
     }
     return $ret;
 }

 /**
  * Format an individual Closure parameter.
  *
  * @param \ReflectionParameter $param
  *
  * @return string
  */
 protected function formatParam(\ReflectionParameter $param)
 {
     $ret = $this->formatParamName($param->name);
     if ($param->isOptional()) {
         $ret .= ' = ';
         if (version_compare(PHP_VERSION, '5.4.3', '>=') && $param->isDefaultValueConstant()) {
             $name = $param->getDefaultValueConstantName();
             $ret .= '<const>' . $name . '</const>';
         } elseif ($param->isDefaultValueAvailable()) {
             $ret .= $this->manager->presentRef($param->getDefaultValue());
         } else {
             $ret .= '<urgent>?</urgent>';
         }
     }
     return $ret;
 }

 public function matchReflector(\ReflectionParameter $reflector)
 {
     $this->setReference($reflector->isPassedByReference());
     // Match the reflector's type hint.
     if ($reflector->isArray()) {
         $this->setTypeHint('array');
     } elseif ($reflector->isCallable()) {
         $this->setTypeHint('callable');
     } elseif ($class = $reflector->getClass()) {
         $this->setTypeHint($class->getName());
     }
     // Match the reflector's default value, if there is one. It will be a
     // scalar value, an array of scalar values, or a constant.
     if ($reflector->isDefaultValueAvailable()) {
         if ($reflector->isDefaultValueConstant()) {
             $this->setValue(ConstantNode::create($reflector->getDefaultValueConstantName()));
         } else {
             $this->setValue(Node::fromValue($reflector->getDefaultValue()));
         }
     }
     return $this;
 }

 /**
  * Get a declaration of the param for cli command;
  * @param \ReflectionParameter $param
  * @return string
  */
 protected function paramDetails(\ReflectionParameter $param)
 {
     return ' ' . ($param->isOptional() ? '[' : '') . '--' . $param->getName() . ($param->isOptional() ? '=' . ($param->isDefaultValueConstant() ? $param->getDefaultValueConstantName() : '"' . $param->getDefaultValue() . '"') : '') . ($param->isOptional() ? ']' : '');
 }

 /**
  * @param \ReflectionParameter $r
  *
  * @return string
  */
 protected function getParameterDefinition(\ReflectionParameter $r)
 {
     $type = '';
     if ($r->isArray()) {
         $type = 'array';
     } elseif ($r->isCallable()) {
         $type = 'callable';
     } elseif ($r->getClass()) {
         $type = '\\' . $r->getClass()->getName();
     }
     $name = $r->getName();
     $default = '';
     if ($r->isDefaultValueAvailable() and $r->isDefaultValueConstant()) {
         $default = ' = \\' . $r->getDefaultValueConstantName();
     } elseif ($r->isDefaultValueAvailable()) {
         $default = ' = ' . var_export($r->getDefaultValue(), true);
     }
     $definition = trim($type . ' $' . $name . $default);
     return $definition;
 }

 /**
  * @param \ReflectionParameter $parameter
  * @return string
  */
 protected function getPhpForParameter(\ReflectionParameter $parameter)
 {
     $php = null;
     if ($parameter->getClass() instanceof \ReflectionClass) {
         $php .= '\\' . $parameter->getClass()->name . ' ';
     } elseif ($parameter->isCallable()) {
         $php .= 'callable ';
     } elseif ($parameter->isArray()) {
         $php .= 'array ';
     }
     if ($parameter->isPassedByReference()) {
         $php .= '&';
     }
     $php .= '$' . $parameter->name;
     if ($parameter->isDefaultValueAvailable()) {
         $parameterDefaultValue = $parameter->getDefaultValue();
         if ($parameter->isDefaultValueConstant()) {
             $defaultValue = $parameter->getDefaultValueConstantName();
         } elseif ($parameterDefaultValue === null) {
             $defaultValue = 'null';
         } elseif (is_bool($parameterDefaultValue)) {
             $defaultValue = $parameterDefaultValue === true ? 'true' : 'false';
         } elseif (is_string($parameterDefaultValue)) {
             $defaultValue = '\'' . $parameterDefaultValue . '\'';
         } elseif (is_array($parameterDefaultValue)) {
             $defaultValue = 'array()';
         } else {
             $defaultValue = $parameterDefaultValue;
         }
         $php .= ' = ' . $defaultValue;
     }
     return $php;
 }

 /**
  * Set dependency value by reflection
  *
  * @param ParameterDefinition $parameterDefinition
  * @param \ReflectionParameter $reflectionParameter
  * @throws \InvalidArgumentException
  * @throws ReferenceNotImplementsException
  */
 public function setDependencyByReflection(ParameterDefinition $parameterDefinition, \ReflectionParameter $reflectionParameter)
 {
     // If default value available
     if ($reflectionParameter->isDefaultValueAvailable()) {
         // There is a constant
         if ($reflectionParameter->isDefaultValueConstant()) {
             $parameterDefinition->setDependency(new ConstantReference($reflectionParameter->getDefaultValueConstantName()));
         } else {
             // There is some php types
             $parameterDefinition->setDependency(CollectionReference::convertValueToReference($reflectionParameter->getDefaultValue()));
         }
         // There is class dependency
     } elseif ($this->checkIfTypeHingIsClass($parameterDefinition)) {
         $class = (string) $parameterDefinition->getTypeHint();
         $parameterDefinition->setDependency(new ClassReference($class));
     }
 }

function getParamStr(ReflectionParameter $param)
{
    $name = $param->getName();
    //support variable-length argument lists
    if ($name == '...') {
        return '$_ = null';
    }
    $str = '$' . $name;
    if ($param->isPassedByReference()) {
        $str = '&' . $str;
    }
    if ($param->isArray()) {
        $str = 'array ' . $str;
    } else {
        if ($param->isCallable()) {
            $str = 'callable ' . $str;
        }
    }
    //it's impossible to get default value of build-in function's parameter, just for forward compatible
    if ($param->isOptional() && $param->isDefaultValueAvailable()) {
        if ($param->isDefaultValueConstant()) {
            $default = $param->getDefaultValueConstantName();
        } else {
            $default = $param->getDefaultValue();
        }
        $str .= ' = ' . $default;
    }
    return $str;
}