PHP ReflectionMethod::returnsReference方法代码示例

 public function writeMethod(\ReflectionMethod $method)
 {
     $args = [];
     foreach ($method->getParameters() as $parameter) {
         $arg = '';
         if ($parameter->isArray()) {
             $arg .= 'array ';
         } else {
             if ($parameter->getClass()) {
                 $arg .= '\\' . $parameter->getClass()->getName() . ' ';
             }
         }
         if ($parameter->isPassedByReference()) {
             $arg .= '&';
         }
         $arg .= '$' . $parameter->getName();
         try {
             $defaultValue = $parameter->getDefaultValue();
             $arg .= ' = ' . var_export($defaultValue, true);
         } catch (ReflectionException $e) {
             if ($parameter->isOptional()) {
                 $arg .= ' = null';
             }
         }
         $args[] = $arg;
     }
     $modifiers = array_diff(\Reflection::getModifierNames($method->getModifiers()), ['abstract']);
     $methodName = ($method->returnsReference() ? '&' : '') . $method->getName();
     $this->code[] = '  ' . implode(' ', $modifiers) . ' function ' . $methodName . '(' . implode(', ', $args) . ') {';
     $this->code[] = '    $result = $this->' . $this->propertyName . '->invoke($this, \'' . $method->getName() . '\', func_get_args());';
     $this->code[] = '    return $result;';
     $this->code[] = '  }';
 }

 /**
  * Returns whether this method returns a reference
  *
  * @return boolean True if this method returns a reference
  */
 public function returnsReference()
 {
     if ($this->reflectionSource instanceof ReflectionMethod) {
         return $this->reflectionSource->returnsReference();
     } else {
         return parent::returnsReference();
     }
 }

 public static function fromReflection(\ReflectionMethod $ref)
 {
     $method = new static();
     $method->setFinal($ref->isFinal())->setAbstract($ref->isAbstract())->setStatic($ref->isStatic())->setVisibility($ref->isPublic() ? self::VISIBILITY_PUBLIC : ($ref->isProtected() ? self::VISIBILITY_PROTECTED : self::VISIBILITY_PRIVATE))->setReferenceReturned($ref->returnsReference())->setName($ref->name);
     if ($docComment = $ref->getDocComment()) {
         $method->setDocblock(ReflectionUtils::getUnindentedDocComment($docComment));
     }
     foreach ($ref->getParameters() as $param) {
         $method->addParameter(static::createParameter($param));
     }
     // FIXME: Extract body?
     return $method;
 }

 public static function fromReflection(\ReflectionMethod $ref)
 {
     $method = new static($ref->name);
     $method->setFinal($ref->isFinal())->setAbstract($ref->isAbstract())->setStatic($ref->isStatic())->setVisibility($ref->isPublic() ? self::VISIBILITY_PUBLIC : ($ref->isProtected() ? self::VISIBILITY_PROTECTED : self::VISIBILITY_PRIVATE))->setReferenceReturned($ref->returnsReference())->setBody(ReflectionUtils::getFunctionBody($ref));
     $docblock = new Docblock($ref);
     $method->setDocblock($docblock);
     $method->setDescription($docblock->getShortDescription());
     $method->setLongDescription($docblock->getLongDescription());
     foreach ($ref->getParameters() as $param) {
         $method->addParameter(static::createParameter($param));
     }
     return $method;
 }

 /**
  * @param \ReflectionMethod $reflectionMethod
  * @param \Donquixote\HastyReflectionCommon\Reflection\FunctionLike\MethodReflectionInterface $methodReflection
  */
 private function assertEqualMethods(\ReflectionMethod $reflectionMethod, MethodReflectionInterface $methodReflection)
 {
     $this->assertEquals($reflectionMethod->isAbstract(), $methodReflection->isAbstract());
     $this->assertEquals($reflectionMethod->getDeclaringClass()->getName(), $methodReflection->getDeclaringClassName());
     $this->assertEquals($reflectionMethod->getDocComment(), $methodReflection->getDocComment());
     $this->assertEquals($reflectionMethod->getShortName(), $methodReflection->getName());
     $this->assertEquals($reflectionMethod->getName(), $methodReflection->getName());
     $this->assertEquals($reflectionMethod->class . '::' . $reflectionMethod->getName(), $methodReflection->getQualifiedName());
     $this->assertEquals($reflectionMethod->returnsReference(), $methodReflection->isByReference());
     $this->assertEquals($reflectionMethod->isPrivate(), $methodReflection->isPrivate());
     $this->assertEquals($reflectionMethod->isProtected(), $methodReflection->isProtected());
     $this->assertEquals($reflectionMethod->isPublic(), $methodReflection->isPublic());
     $this->assertEquals($reflectionMethod->isStatic(), $methodReflection->isStatic());
 }

 public final function generate(\ReflectionMethod $method)
 {
     $name = $method->getName();
     $output = ' public function ';
     if ($method->returnsReference()) {
         $output .= '&';
     }
     $output .= $method->getName() . '(';
     $separator = '';
     foreach ($method->getParameters() as $param) {
         $output .= $separator . $this->generateParameterDeclaration($param);
         $separator = ', ';
     }
     $output .= ") { " . $this->generateBody($name) . " }\n";
     return $output;
 }

 protected function canRedirected(\ReflectionMethod $source, \ReflectionMethod $target)
 {
     if ($target->isPublic() && !preg_match('#^__#', $source->getName()) && $source->returnsReference() == $target->returnsReference()) {
         $sourceParam = $source->getParameters();
         $targetParam = $target->getParameters();
         // check parameters
         if (count($targetParam) != count($sourceParam)) {
             return false;
         }
         foreach ($targetParam as $idx => $to) {
             $from = $sourceParam[$idx];
             if ($to->isArray() != $from->isArray() || $to->getClass() != $from->getClass() || $to->isCallable() != $from->isCallable() || $to->isPassedByReference() != $from->isPassedByReference()) {
                 return false;
             }
         }
         // all ok returns true
         return true;
     }
     return false;
 }

function methodData(ReflectionMethod $method)
{
    $details = "";
    $name = $method->getName();
    if ($method->isUserDefined()) {
        $details .= "{$name} is user defined\n";
    }
    if ($method->isInternal()) {
        $details .= "{$name} is built-in\n";
    }
    if ($method->isAbstract()) {
        $details .= "{$name} is abstract\n";
    }
    if ($method->isPublic()) {
        $details .= "{$name} is public\n";
    }
    if ($method->isProtected()) {
        $details .= "{$name} is protected\n";
    }
    if ($method->isPrivate()) {
        $details .= "{$name} is private\n";
    }
    if ($method->isStatic()) {
        $details .= "{$name} is static\n";
    }
    if ($method->isFinal()) {
        $details .= "{$name} is final\n";
    }
    if ($method->isConstructor()) {
        $details .= "{$name} is the constructor\n";
    }
    if ($method->returnsReference()) {
        $details .= "{$name} returns a reference (as opposed to a value)\n";
    }
    return $details;
}

 /**
  * Creates a method code from Reflection
  *
  * @param Method|ParsedMethod $method Reflection for method
  * @param string $body Body of method
  *
  * @return string
  */
 protected function getOverriddenMethod($method, $body)
 {
     $code = preg_replace('/ {4}|\\t/', '', $method->getDocComment()) . "\n" . join(' ', Reflection::getModifierNames($method->getModifiers())) . ' function ' . ($method->returnsReference() ? '&' : '') . $method->name . '(' . join(', ', $this->getParameters($method->getParameters())) . ")\n" . "{\n" . $this->indent($body) . "\n" . "}\n";
     return $code;
 }

 private function GenerateOverridingMethodTemplate(\ReflectionMethod $EntityMethod)
 {
     $MethodTemplate = self::OverriddenMethodTemplate;
     $Modifiers = \Reflection::getModifierNames($EntityMethod->getModifiers());
     $Modifiers[] = 'function';
     if ($EntityMethod->returnsReference()) {
         $Modifiers[] = '&';
     }
     $Modifiers = implode(' ', $Modifiers);
     $Name = $EntityMethod->getName();
     $Parameters = [];
     $ParameterVariables = [];
     foreach ($EntityMethod->getParameters() as $Parameter) {
         $ParameterVariables[] = '$' . $Parameter->getName();
         $Parameters[] = $this->GenerateMethodParameter($Parameter);
     }
     $Parameters = implode(', ', $Parameters);
     $ParameterVariables = implode(', ', $ParameterVariables);
     $MethodTemplate = str_replace('<Modifiers>', $Modifiers, $MethodTemplate);
     $MethodTemplate = str_replace('<Name>', $Name, $MethodTemplate);
     $MethodTemplate = str_replace('<Parameters>', $Parameters, $MethodTemplate);
     $MethodTemplate = str_replace('<ParameterVariables>', $ParameterVariables, $MethodTemplate);
     return $MethodTemplate;
 }

    /**
     * Generates the string representation of a single method: signature, body.
     *
     * @param \ReflectionMethod $reflection_method
     *   A reflection method for the method.
     *
     * @return string
     */
    protected function buildMethod(\ReflectionMethod $reflection_method)
    {
        $parameters = [];
        foreach ($reflection_method->getParameters() as $parameter) {
            $parameters[] = $this->buildParameter($parameter);
        }
        $function_name = $reflection_method->getName();
        $reference = '';
        if ($reflection_method->returnsReference()) {
            $reference = '&';
        }
        $signature_line = <<<'EOS'
/**
 * {@inheritdoc}
 */

EOS;
        if ($reflection_method->isStatic()) {
            $signature_line .= 'public static function ' . $reference . $function_name . '(';
        } else {
            $signature_line .= 'public function ' . $reference . $function_name . '(';
        }
        $signature_line .= implode(', ', $parameters);
        $signature_line .= ')';
        $output = $signature_line . "\n{\n";
        $output .= $this->buildMethodBody($reflection_method);
        $output .= "\n" . '}';
        return $output;
    }

 protected function buildMethodSignature(\ReflectionMethod $method, bool $skipAbstract = false, bool $skipDefaultValues = false) : string
 {
     if ($method->isProtected()) {
         $code = 'protected ';
     } elseif ($method->isPrivate()) {
         $code = 'private ';
     } else {
         $code = 'public ';
     }
     if ($method->isAbstract()) {
         if (!$skipAbstract) {
             $code .= 'abstract ';
         }
     } elseif ($method->isFinal()) {
         $code .= 'final ';
     }
     if ($method->isStatic()) {
         $code .= 'static ';
     }
     $code .= 'function ';
     if ($method->returnsReference()) {
         $code .= '& ';
     }
     $code .= $method->getName() . '(';
     foreach ($method->getParameters() as $i => $param) {
         if ($i > 0) {
             $code .= ', ';
         }
         $code .= $this->buildParameterSignature($param, $skipDefaultValues);
     }
     $code .= ')';
     if ($method->hasReturnType()) {
         $type = $method->getReturnType();
         if ($type->isBuiltin) {
             $code .= ': ' . $type;
         } else {
             $code .= ': \\' . $type;
         }
     }
     return $code;
 }

 /**
  * Test that the proxy behaves in regard to methods like &foo() correctly
  */
 public function testProxyRespectsMethodsWhichReturnValuesByReference()
 {
     $proxy = $this->_proxyFactory->getProxy('Doctrine\\Tests\\Models\\Forum\\ForumEntry', null);
     $method = new \ReflectionMethod(get_class($proxy), 'getTopicByReference');
     $this->assertTrue($method->returnsReference());
 }

 /**
  * __get() implementation.
  * @param  object
  * @param  string  property name
  * @return mixed   property value
  * @throws MemberAccessException if the property is not defined.
  */
 public static function &get($_this, $name)
 {
     $class = get_class($_this);
     $uname = ucfirst($name);
     $methods =& self::getMethods($class);
     if ($name === '') {
         throw new MemberAccessException("Cannot read a class '{$class}' property without name.");
     } elseif (isset($methods[$m = 'get' . $uname]) || isset($methods[$m = 'is' . $uname])) {
         // property getter
         if ($methods[$m] === 0) {
             $rm = new \ReflectionMethod($class, $m);
             $methods[$m] = $rm->returnsReference();
         }
         if ($methods[$m] === TRUE) {
             return $_this->{$m}();
         } else {
             $val = $_this->{$m}();
             return $val;
         }
     } elseif (isset($methods[$name])) {
         // public method as closure getter
         if (PHP_VERSION_ID >= 50400) {
             $rm = new \ReflectionMethod($class, $name);
             $val = $rm->getClosure($_this);
         } else {
             $val = Nette\Utils\Callback::closure($_this, $name);
         }
         return $val;
     } else {
         // strict class
         $type = isset($methods['set' . $uname]) ? 'a write-only' : 'an undeclared';
         throw new MemberAccessException("Cannot read {$type} property {$class}::\${$name}.");
     }
 }

 /**
  * @param string           $templateDir
  * @param ReflectionMethod $method
  * @param bool             $cloneArguments
  * @param bool             $callOriginalMethods
  *
  * @return string
  */
 private function generateMockedMethodDefinitionFromExisting($templateDir, ReflectionMethod $method, $cloneArguments, $callOriginalMethods)
 {
     if ($method->isPrivate()) {
         $modifier = 'private';
     } elseif ($method->isProtected()) {
         $modifier = 'protected';
     } else {
         $modifier = 'public';
     }
     if ($method->isStatic()) {
         $modifier .= ' static';
     }
     if ($method->returnsReference()) {
         $reference = '&';
     } else {
         $reference = '';
     }
     if ($this->hasReturnType($method)) {
         $returnType = (string) $method->getReturnType();
     } else {
         $returnType = '';
     }
     if (preg_match('#\\*[ \\t]*+@deprecated[ \\t]*+(.*?)\\r?+\\n[ \\t]*+\\*(?:[ \\t]*+@|/$)#s', $method->getDocComment(), $deprecation)) {
         $deprecation = trim(preg_replace('#[ \\t]*\\r?\\n[ \\t]*+\\*[ \\t]*+#', ' ', $deprecation[1]));
     } else {
         $deprecation = false;
     }
     return $this->generateMockedMethodDefinition($templateDir, $method->getDeclaringClass()->getName(), $method->getName(), $cloneArguments, $modifier, $this->getMethodParameters($method), $this->getMethodParameters($method, true), $returnType, $reference, $callOriginalMethods, $method->isStatic(), $deprecation);
 }