PHP ReflectionMethod::isPrivate方法代码示例

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

 /**
  * @param Factory $factory
  * @param string $class
  * @param string $name
  * @param array|Argument[] $arguments
  * @param array|History[] $collected
  * @throws \ReflectionException If the method cannot be stubbed
  */
 function __construct(Factory $factory, $class, $name, array $arguments = [], array $collected = [])
 {
     $this->class = $class;
     $this->name = $name;
     $this->arguments = $arguments;
     $this->reflection = new \ReflectionMethod($class, $name);
     $this->typeHint = new ReturnTypeInferer($this->reflection, $factory);
     $this->history = new History($collected);
     if ($this->reflection->isPrivate()) {
         throw new \ReflectionException("Cannot stub private methods [{$this->class}::{$name}()]");
     } else {
         if ($this->reflection->isStatic()) {
             throw new \ReflectionException("Cannot stub static methods [{$this->class}::{$name}()]");
         }
     }
 }

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

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

/**
 * 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 static function reflector($method_and_params)
 {
     $class = get_called_class();
     $method = $method_and_params[0];
     $args = $method_and_params[1];
     $reflectionMethod = new \ReflectionMethod($class, $method);
     if (!$reflectionMethod->isStatic()) {
         throw new \Exception("The method: {$class}::{$method} should be static!!");
     }
     if (!$reflectionMethod->isPrivate()) {
         throw new \Exception("The static method: {$class}::{$method} should be private!!");
     }
     $params = array();
     foreach ($reflectionMethod->getParameters() as $param) {
         if (isset($args[$param->getName()])) {
             $params[] = $args[$param->getName()];
         } else {
             if ($param->isOptional()) {
                 $params[] = $param->getDefaultValue();
             } else {
                 throw new \Exception("The method: {$class}::{$method}  signature requires a \"\${$param->getName()}\" argument!!");
             }
         }
     }
     $reflectionMethod->setAccessible(true);
     return $reflectionMethod->invokeArgs(null, $params);
 }

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

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

 /**
  * @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);
     }
 }

 /**
  * {@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);
 }

 /**
  * @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());
 }

 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 function getRunkitMethodFlags($className, $methodName)
 {
     $ref = new ReflectionMethod($className, $methodName);
     $flags = 0;
     if ($ref->isPrivate()) {
         $flags |= RUNKIT_ACC_PRIVATE;
     } elseif ($ref->isProtected()) {
         $flags |= RUNKIT_ACC_PROTECTED;
     } else {
         $flags |= RUNKIT_ACC_PUBLIC;
     }
     if ($ref->isStatic()) {
         $flags |= RUNKIT_ACC_STATIC;
     }
     return $flags;
 }

 public static function reload_method($classname, $methodname)
 {
     $method = new ReflectionMethod($classname, $methodname);
     $visibility = RUNKIT_ACC_PUBLIC;
     if ($method->isProtected()) {
         $visibility = RUNKIT_ACC_PROTECTED;
     } else {
         if ($method->isPrivate()) {
             $visibility = RUNKIT_ACC_PRIVATE;
         }
     }
     if ($method->isStatic()) {
         $visibility = $visibility | RUNKIT_ACC_STATIC;
     }
     return runkit_method_redefine($classname, $methodname, self::getMethodArguments($classname, $methodname), self::getMethodCode($classname, $methodname), $visibility);
 }