PHP ReflectionMethod::isProtected方法代码示例

 public function __construct(PropertyAnnotation $annotation, \ReflectionMethod $reflection)
 {
     $this->reflection = $reflection;
     $this->annotation = $annotation;
     if ($this->reflection->isPrivate() || $this->reflection->isProtected()) {
         $this->reflection->setAccessible(true);
     }
 }

/**
 * Prints warning about any hooked method with bad visibility (that are either protected or private)
 * @return void
 */
function appthemes_bad_method_visibility()
{
    global $wp_filter;
    $arguments = func_get_args();
    $tag = array_shift($arguments);
    $errors = new WP_Error();
    if (!isset($wp_filter[$tag])) {
        return;
    }
    foreach ($wp_filter[$tag] as $prioritized_callbacks) {
        foreach ($prioritized_callbacks as $callback) {
            $function = $callback['function'];
            if (is_array($function)) {
                try {
                    $method = new ReflectionMethod($function[0], $function[1]);
                    if ($method->isPrivate() || $method->isProtected()) {
                        $class = get_class($function[0]);
                        if (!$class) {
                            $class = $function[0];
                        }
                        $errors->add('visiblity', $class . '::' . $function[1] . ' was hooked into "' . $tag . '", but is either protected or private.');
                    }
                } catch (Exception $e) {
                    // Failure to replicate method. Might be magic method. Fail silently
                }
            }
        }
    }
    if ($errors->get_error_messages()) {
        foreach ($errors->get_error_messages() as $message) {
            echo $message;
        }
    }
}

 private function _invoke($clz = '', $act = '', $param, $namespace = 'Home\\Controller\\')
 {
     $clz = ucwords($clz);
     $clz_name = $namespace . $clz . 'Controller';
     try {
         $ref_clz = new \ReflectionClass($clz_name);
         if ($ref_clz->hasMethod($act)) {
             $ref_fun = new \ReflectionMethod($clz_name, $act);
             if ($ref_fun->isPrivate() || $ref_fun->isProtected()) {
                 $ref_fun->setAccessible(true);
             }
             if ($ref_fun->isStatic()) {
                 $ref_fun->invoke(null);
             } else {
                 $ref_fun_par = $ref_fun->getParameters();
                 if (!empty($param) && is_array($param)) {
                     if (is_array($ref_fun_par) && count($ref_fun_par) == count($param)) {
                         $ref_fun->invokeArgs(new $clz_name(), $param);
                     } else {
                         $ref_fun->invoke(new $clz_name());
                     }
                 } else {
                     $ref_fun->invoke(new $clz_name());
                 }
             }
         }
     } catch (\LogicException $le) {
         $this->ajaxReturn(array('status' => '500', 'info' => '服务器内部发生严重错误'));
     } catch (\ReflectionException $re) {
         $this->ajaxReturn(array('status' => '404', 'info' => '访问' . $clz . '控制器下的非法操作', 'data' => array('code' => $re->getCode())));
     }
 }

 protected function _checkProtection($protectionType)
 {
     // Check type
     if (!is_string($protectionType) || $protectionType != self::PROTECTION_CSRF && $protectionType != self::PROTECTION_CAPTCHA && $protectionType != self::PROTECTION_BRUTEFORCE && $protectionType != self::PROTECTION_XSS) {
         throw new \Exception('Invalid protection type : "' . $protectionType . '"');
     }
     // Check class
     if (class_exists('framework\\security\\form\\' . ucfirst($protectionType))) {
         $className = 'framework\\security\\form\\' . ucfirst($protectionType);
     } else {
         $className = $protectionType;
     }
     $class = new \ReflectionClass($className);
     if (!in_array('framework\\security\\IForm', $class->getInterfaceNames())) {
         throw new \Exception('Form protection drivers must be implement framework\\security\\IForm');
     }
     if ($class->isAbstract()) {
         throw new \Exception('Form protection drivers must be not abstract class');
     }
     if ($class->isInterface()) {
         throw new \Exception('Form protection drivers must be not interface');
     }
     $classInstance = $class->newInstanceWithoutConstructor();
     $constuctor = new \ReflectionMethod($classInstance, '__construct');
     if ($constuctor->isPrivate() || $constuctor->isProtected()) {
         throw new \Exception('Protection constructor must be public');
     }
     return $className;
 }

 /**
  * Returns whether this method is protected
  *
  * @return boolean TRUE if this method is protected
  */
 public function isProtected()
 {
     if ($this->reflectionSource instanceof ReflectionMethod) {
         return $this->reflectionSource->isProtected();
     } else {
         return parent::isProtected();
     }
 }

 public function testPublicize_with_protected_static_method()
 {
     $className = __FUNCTION__ . md5(uniqid());
     eval(sprintf('class %s { protected static function foo() { return true; } }', $className));
     $reflectionMethod = new ReflectionMethod($className, 'foo');
     $this->assertTrue($reflectionMethod->isProtected());
     $this->assertTrue($reflectionMethod->isStatic());
     $this->assertSame($reflectionMethod, $reflectionMethod->publicize());
     $this->assertSame(true, $reflectionMethod->invoke($className));
 }

 /**
  * Get output style for the given method's visibility.
  *
  * @param \ReflectionMethod $method
  *
  * @return string
  */
 private function getVisibilityStyle(\ReflectionMethod $method)
 {
     if ($method->isPublic()) {
         return self::IS_PUBLIC;
     } elseif ($method->isProtected()) {
         return self::IS_PROTECTED;
     } else {
         return self::IS_PRIVATE;
     }
 }

 /**
  * @param \ReflectionMethod $reflection
  */
 public function setVisibilityFromReflection(\ReflectionMethod $reflection)
 {
     if ($reflection->isPublic()) {
         $this->setVisibility('public');
     }
     if ($reflection->isProtected()) {
         $this->setVisibility('protected');
     }
     if ($reflection->isPrivate()) {
         $this->setVisibility('private');
     }
 }

 /**
  * @param object $object
  * @param string $method
  * @param array  $args
  *
  * @return mixed
  */
 protected function callPrivateMethod($object, $method, $args = array())
 {
     $reflectionMethod = new \ReflectionMethod($object, $method);
     if ($reflectionMethod->isPrivate() || $reflectionMethod->isProtected()) {
         $reflectionMethod->setAccessible(true);
         $result = $reflectionMethod->invokeArgs($reflectionMethod->isStatic() ? null : $object, $args);
         $reflectionMethod->setAccessible(false);
         return $result;
     } else {
         return call_user_func_array(array($object, $method), $args);
     }
 }

 /**
  * @dataProvider templateDataProvider
  */
 public function testGetVariable($data)
 {
     $method = new ReflectionMethod($this->parser, 'getVariable');
     $this->assertTrue($method->isProtected());
     $method->setAccessible(true);
     $this->assertEquals('Lex', $method->invoke($this->parser, 'name', $data));
     $this->assertEquals(null, $method->invoke($this->parser, 'age', $data));
     $this->assertEquals(false, $method->invoke($this->parser, 'age', $data, false));
     $this->assertEquals(true, $method->invoke($this->parser, 'filters.enable', $data));
     $this->assertEquals(null, $method->invoke($this->parser, 'filters.name', $data));
     $this->assertEquals(false, $method->invoke($this->parser, 'filters.name', $data, false));
 }

 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;
 }

 /**
  * {@inheritdoc}
  */
 public function execute(MetaModel $metaModel)
 {
     $object = $this->subNode->execute($metaModel);
     if (is_null($object)) {
         throw new ExecutionException("Calling method '{$this->method}' on null");
     }
     $reflectionMethod = new \ReflectionMethod($object, $this->method);
     // God mode
     if ($reflectionMethod->isPrivate() || $reflectionMethod->isProtected()) {
         $reflectionMethod->setAccessible(true);
     }
     return $reflectionMethod->invoke($object);
 }

 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;
 }

 protected function assertIsSingleton($class, $instance = null)
 {
     foreach (array('__construct', '__clone') as $methodName) {
         $method = new \ReflectionMethod($class, $methodName);
         $this->assertTrue($method->isProtected() || $method->isPrivate());
     }
     $getInstance = function () use($class) {
         return call_user_func(array($class, 'getInstance'));
     };
     if ($instance) {
         $this->assertEquals(spl_object_hash($instance), spl_object_hash($getInstance()));
     }
     $this->assertEquals(spl_object_hash($getInstance()), spl_object_hash($getInstance()));
 }

 public static final function getService()
 {
     $class = get_called_class();
     if (($rc = new ReflectionClass($class)) && $rc->isAbstract()) {
         throw new Exception('Class "' . $class . '", extending "Clap_ServiceInstance", cannot be called as a "Service" if it is "Abstract"');
     }
     if (!method_exists($class, '__construct')) {
         throw new Exception('Class "' . $class . '" extending "Clap_ServiceInstance", require "' . $class . '" to implement the method  "protected function __construct()"');
     }
     if (($rm = new ReflectionMethod($class, '__construct')) && !$rm->isProtected()) {
         throw new Exception('Access type for method "' . $class . '::__construct()" must be declared as "protected" to be compatible with "Clap_ServiceInstance", in "' . $rm->getFileName() . '" on line "' . $rm->getStartLine() . '"');
     }
     return new self($class);
 }