PHP ReflectionMethod::__construct方法代码示例

 /**
  * Constructor
  *
  * @param mixed $class Classname or object (object of the class) that contains the method.
  * @param string $name Name of the method
  * @access public
  * @return void
  */
 public function __construct($class, $name)
 {
     parent::__construct($class, $name);
     // get the annotations
     $parser = new AnnotationParser($this->getDocComment());
     $this->annotations = $parser->getAnnotationArray();
 }

 /**
  * Construct a new reflection method object
  * @param mixed $classOrName
  * @param string $name name of the class
  * @return null
  */
 public function __construct($classOrName = null, $name = null)
 {
     parent::__construct($classOrName, $name);
     if ($name) {
         $this->className = $classOrName;
     }
 }

 /**
  * Constructs a new ReflectionMethod object.
  *
  * @param string|object $class
  * @param string $name
  * @throws ReflectionException
  * @return ReflectionMethod
  */
 public final function __construct($class, $name)
 {
     $bt = debug_backtrace();
     if (!isset($bt[1]['class']) || $bt[1]['class'] !== __CLASS__) {
         throw new ReflectionException('ReflectionClass\' constructor cannot be called from outside the class');
     }
     parent::__construct($class, $name);
 }

 /**
  * @param mixed $class
  * @param string $name
  *
  * @throws \LogicException
  */
 public function __construct($class, $name)
 {
     parent::__construct($class, $name);
     if (!$this->getDocComment()) {
         throw new \LogicException(sprintf("Missing phpdoc on method '%s::%s()'", $this->getDeclaringClass()->getName(), $this->getName()));
     }
     $this->parsePhpDoc($this->getDocComment(), $this->getDeclaringClass()->getName(), $this->getName());
 }

 public function __construct($class, $name)
 {
     if (self::$adapterClass !== null) {
         $this->adapter = new self::$adapterClass($class, $name);
     } else {
         parent::__construct($class, $name);
     }
 }

 public function __construct($class, $name, $object, array $arguments = array())
 {
     parent::__construct($class, $name);
     if (!is_object($object)) {
         throw new \InvalidArgumentException('$object must be an object.');
     }
     $this->arguments = $arguments;
     $this->object = $object;
 }

 /**
  * Called when the object is constructed
  *
  * @param   object  $instance  the method's instance
  * @param   string  $name      the method's name
  * @return  self
  * @throws  InvalidArgumentException  if $instance is not an object
  * @throws  InvalidArgumentException  if $name is not a string
  * @throws  OutOfBoundsException      if method does not exist
  * @throws  OutOfBoundsException      if method does exist but is not visible
  * @throws  ReflectionException       if something else goes wrong
  * @since   0.1.0
  */
 public function __construct($instance, $name)
 {
     // if $instance is not an object, short-circuit
     if (!is_object($instance)) {
         throw new \InvalidArgumentException(__METHOD__ . "() expects parameter one, instance, to be an object");
     }
     // if $name is not a string, short-circuit
     if (!is_string($name)) {
         throw new \InvalidArgumentException(__METHOD__ . "() expects parameter two, name, to be a string");
     }
     // try to get the method
     try {
         $method = (new \ReflectionClass($instance))->getMethod($name);
         // try to finish constructing the object
         try {
             // if the method is not visible, short-circuit
             if ($method->isPrivate() && $method->class !== get_class($instance)) {
                 throw new \OutOfBoundsException("Method {$name}() is defined but not visible to " . get_class($instance));
             }
             // otherwise, chain the parent's constructor
             parent::__construct($instance, $name);
             // set the method's accessibility
             // keep in mind, the method maintains its original visibility outside
             //     of this object's scope
             //
             $this->setAccessible(true);
             // save the method's instance
             $this->instance = $instance;
             return;
         } catch (\ReflectionException $e) {
             // otherwise, something else went wrong
             // re-throw the original ReflectionException
             //
             throw $e;
         }
     } catch (\ReflectionException $e) {
         // otherwise, the method does not exist
         // throw an OutOfBoundsException
         //
         throw new \OutOfBoundsException("Method {$name}() must be defined in class " . get_class($instance));
     }
 }

 /**
  * Constructs an new ezcReflectionMethod
  *
  * Usage Examples:
  * <code>
  * new ezcReflectionMethod( 'SomeClass',                        'someMethod' );
  * new ezcReflectionMethod( new ReflectionClass( 'SomeClass' ), 'someMethod' );
  * new ezcReflectionMethod( 'SomeClass',                        new ReflectionMethod( 'SomeClass', 'someMethod' ) );
  * new ezcReflectionMethod( new ReflectionClass( 'SomeClass' ), new ReflectionMethod( 'SomeClass', 'someMethod' ) );
  * </code>
  * 
  * The following way of creating an ezcReflectionMethod results in the
  * current class being the declaring class, i.e., isInherited() and
  * isIntroduced() may not return the expected results:
  * <code>
  * new ezcReflectionMethod( new ReflectionMethod( 'SomeClass', 'someMethod' ) );
  * </code>
  * 
  * @param string|ReflectionClass|ReflectionMethod $classOrSource
  *        Name of class, ReflectionClass, or ReflectionMethod of the method
  *        to be reflected
  * @param string|ReflectionMethod $nameOrSource
  *        Name or ReflectionMethod instance of the method to be reflected
  *        Optional if $classOrSource is an instance of ReflectionMethod
  */
 public function __construct($classOrSource, $nameOrSource = null)
 {
     if ($nameOrSource instanceof parent) {
         $this->reflectionSource = $nameOrSource;
         if ($classOrSource instanceof ReflectionClass) {
             $this->currentClass = $classOrSource;
         } else {
             $this->currentClass = new ReflectionClass((string) $classOrSource);
         }
     } elseif ($classOrSource instanceof parent) {
         $this->reflectionSource = $classOrSource;
         $this->currentClass = new ReflectionClass($this->reflectionSource->class);
     } elseif ($classOrSource instanceof ReflectionClass) {
         parent::__construct($classOrSource->getName(), $nameOrSource);
         $this->currentClass = $classOrSource;
     } else {
         parent::__construct($classOrSource, $nameOrSource);
         $this->currentClass = new ReflectionClass((string) $classOrSource);
     }
     $this->docParser = ezcReflection::getDocCommentParser();
     $this->docParser->parse($this->getDocComment());
 }

 public function __construct($name, $class)
 {
     parent::__construct($name, $class);
 }

 function __construct($c, $m)
 {
     echo __METHOD__ . "\n";
     parent::__construct($c, $m);
 }

 public function __construct($class, $name)
 {
     parent::__construct($class, $name);
     $this->annotations = $this->createParser()->parse(AddendumCompatibility::getDocComment($this));
 }

 /**
  * inits model
  * @param string $class parsed class classname
  * @param string $name parsed class methodname
  */
 public function __construct($class, $name)
 {
     parent::__construct($class, $name);
     $this->processComment();
 }

 public function __construct($name, $class)
 {
     parent::__construct($name, $class);
     $this->annotation = Notoj::parseDocComment($this);
 }

 public function __construct(Type $type, $method, Reflection $reflection)
 {
     parent::__construct($type->name, $method);
     $this->type = $type;
     $this->reflection = $reflection;
 }

 /**
  * Constructor.
  *
  * @param string|\TokenReflection\Php\ReflectionClass|\ReflectionClass $class      Defining class
  * @param string                                                       $methodName Method name
  * @param \TokenReflection\Broker                                      $broker     Reflection broker
  */
 public function __construct($class, $methodName, Broker $broker)
 {
     parent::__construct($class, $methodName);
     $this->broker = $broker;
 }