PHP ReflectionClass::__construct方法代码示例

 /**
  * Constructs a ReflectionClass
  * @link  http://php.net/manual/en/reflectionclass.construct.php
  *
  * @param mixed $argument <p>
  *                        Either a string containing the name of the class to
  *                        reflect, or an object.
  *                        </p>
  *
  * @since 5.0
  */
 public function __construct($argument)
 {
     parent::__construct($argument);
     foreach ($this->getProperties() as $property) {
         $this->propertyMap[$property->getName()] = $property;
     }
 }

 /**
  * @param mixed $class
  *
  * @throws \LogicException
  */
 public function __construct($class)
 {
     parent::__construct($class);
     foreach ($this->getProperties(\ReflectionProperty::IS_PUBLIC) as $reflectionProperty) {
         $this->definitions[$reflectionProperty->getName()] = new Property($class, $reflectionProperty->getDocComment());
     }
 }

 /**
  * @param mixed $argument
  * @param IMapper|null $mapper
  */
 public function __construct($argument, IMapper $mapper = null)
 {
     parent::__construct($argument);
     $this->mapper = $mapper;
     $this->parseProperties();
     $this->initGettersAndSetters();
 }

 /**
  * ReflectionRegistration constructor.
  * @param mixed $argument
  * @throws InvalidRegistrationException
  */
 public function __construct($argument)
 {
     if (!is_subclass_of($argument, '\\OctoBroccoli\\ReflectionVariable\\ReflectionVariableInterface')) {
         throw new InvalidRegistrationException();
     }
     parent::__construct($argument);
 }

 function __construct($class)
 {
     is_string($class) && \Patchwork\Superloader::exists($class, false);
     // Do a lightweigh autoload
     parent::__construct($class);
     if (false !== ($parent = parent::getParentClass())) {
         $p = $parent->name;
         $top = $this->name;
         $i = strrpos($top, '__');
         if (false !== $i && isset($top[$i + 2]) && '' === trim(substr($top, $i + 2), '0123456789')) {
             $this->isTop = false;
             $top = substr($top, 0, $i);
         }
         $top .= '__';
         $i = strlen($top);
         while (isset($p[$i]) && $top === rtrim($p, '0123456789')) {
             $this->superStack[] = $parent;
             if (false === ($parent = $parent->getParentClass())) {
                 break;
             }
             $p = $parent->name;
         }
         $this->superParent = $parent;
     }
 }

 /**
  * [__construct description]
  * @param [type] $testsClass [description]
  */
 public function __construct($testsClass, array $constructor_args = null)
 {
     $this->forceCLI();
     parent::__construct($testsClass);
     $this->constructor_args = $constructor_args;
     $this->init();
 }

 /**
  * Constructs a new ReflectionClass object.
  *
  * @param string|object $class
  * @throws ReflectionException
  * @return ReflectionClass
  */
 public final function __construct($class)
 {
     $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);
 }

	/**
	 * Change the present class to be able to use reflection on it.
	 *
	 * @param string $name
	 * @return bool True if success
	 */
	public function rebuild($name) {
		try {
			parent::__construct($name);
			return true;
		} catch(Exception $e) {
			return false;
		}
	}

 public function __construct($object)
 {
     if (!is_object($object)) {
         throw new \InvalidArgumentException(sprintf('Expected "object", got "%s".', gettype($object)));
     }
     parent::__construct($object);
     $this->object = $object;
 }

 public function __construct($class)
 {
     parent::__construct($class);
     $this->annotations = array();
     $this->annotations["class"] = array();
     $this->annotations["properties"] = array();
     $this->extractAnnotations();
 }

 /**
  * Constructor
  *
  * @access public
  * @param mixed $class
  * @param string $relative
  */
 public function __construct($class, $relative)
 {
     parent::__construct($class);
     if (!is_string($relative)) {
         throw new \InvalidArgumentException('The second parameter specifying the relative position of the class must be a string.');
     }
     $this->relative = trim(preg_replace('#/{2,}#', '/', strtr($relative, '\\', '/')), '/');
 }

 /**
  * __construct(\Zend\ServiceManager\ServiceManager $ServiceManager) 
  * @param \Zend\ServiceManager\ServiceManager $ServiceManager
  * @return instance of ServiceManager, Provider Configuration
  * 
  */
 public function __construct(\Zend\ServiceManager\ServiceManager $ServiceManager)
 {
     parent::__construct(__CLASS__);
     // set ServiceManager throught constructor
     if (null === $this->_sm) {
         $this->_sm = $ServiceManager;
     }
     $this->__config = $this->_sm->get('Config')["Submissions\\Provider\\Config"][$this->getShortName()];
 }

 /**
  * Called when the object is constructed
  *
  * @param   object  $instance  the instance to refract
  * @return  self
  * @throws  InvalidArgumentException  if $instance is not an object
  * @since   0.1.0
  */
 public function __construct($instance)
 {
     if (!is_object($instance)) {
         throw new \InvalidArgumentException(__METHOD__ . "() expects parameter one, instance, to be an object");
     }
     parent::__construct($instance);
     $this->instance = $instance;
     return;
 }

 /**
  * Constructs a new ezcReflectionClass object.
  *
  * @param string|object|ReflectionClass $argument
  *        Name, instance or ReflectionClass object of the class to be
  *        reflected
  * @throws ReflectionException if the specified class doesn't exist
  */
 public function __construct($argument)
 {
     if (!$argument instanceof parent) {
         parent::__construct($argument);
     }
     $this->reflectionSource = $argument;
     // TODO: Parse comment on demand to save CPU time and memory
     $this->docParser = ezcReflection::getDocCommentParser();
     $this->docParser->parse($this->getDocComment());
 }

 /**
  * Constructor
  *
  * Instantiate the code reflection object
  *
  * @param  mixed $class
  * @return Reflection
  */
 public function __construct($class)
 {
     if (is_string($class)) {
         $this->classString = $class;
     } else {
         $this->objectInstance = $class;
         $this->classString = get_class($class);
     }
     parent::__construct($class);
     $this->buildGenerator();
 }