/**
* 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();
}
public function __construct($class)
{
if (self::$adapterClass !== null) {
$this->adapter = new self::$adapterClass($class);
} elseif ($class instanceof OriginReflectionClass) {
$this->adapter = $class;
self::$adapterClass = get_class($class);
} else {
parent::__construct($class);
}
}
/**
* @param mixed $classNameOrObject the name of the class or the object to be reflected.
* @throws Exception\ClassLoadingForReflectionFailedException
*/
public function __construct($classNameOrObject)
{
$throwExceptionOnUnloadedClasses = function ($className) {
throw new Exception\ClassLoadingForReflectionFailedException(sprintf('Required class "%s" could not be loaded properly for reflection.%2$s%2$sPossible reasons are:%2$s%2$s * Requiring non-existent classes%2$s * Using non-supported annotations%2$s * Class-/filename missmatch.%2$s%2$sThe "TYPO3.Flow.object.excludeClasses" setting can be used to skip classes from being reflected.', $className, chr(10)));
};
spl_autoload_register($throwExceptionOnUnloadedClasses);
try {
parent::__construct($classNameOrObject);
} catch (Exception\ClassLoadingForReflectionFailedException $exception) {
spl_autoload_unregister($throwExceptionOnUnloadedClasses);
throw $exception;
}
spl_autoload_unregister($throwExceptionOnUnloadedClasses);
}
/**
* Constructor
*
* @param mixed $classNameOrObject the name of the class or the object to be reflected.
* @throws \TYPO3\Flow\Reflection\Exception\ClassLoadingForReflectionFailedException
*/
public function __construct($classNameOrObject)
{
$throwExceptionOnUnloadedClasses = function ($className) {
throw new Exception\ClassLoadingForReflectionFailedException('Required class "' . $className . '" could not be loaded properly for reflection, possibly requiring non-existent classes or using non-supported annotations.');
};
spl_autoload_register($throwExceptionOnUnloadedClasses);
try {
parent::__construct($classNameOrObject);
} catch (\TYPO3\Flow\Reflection\Exception\ClassLoadingForReflectionFailedException $exception) {
spl_autoload_unregister($throwExceptionOnUnloadedClasses);
throw $exception;
}
spl_autoload_unregister($throwExceptionOnUnloadedClasses);
}
/**
* Constructs a new ReflectionClass.
*
* @param string $classname
* The fully-qualified class name (FQCN) to reflect.
* @param string $pathname
* The pathname of the file containing $classname. If omitted, a native
* \ReflectionClass will be instantiated.
*
* @throws \ReflectionException
* If the given $classname is not located in the given $pathname, or if
* $pathname does not exist.
*/
public function __construct($classname, $pathname = NULL)
{
// If the pathname is unknown, it must be retrieved from \ReflectionClass.
// If a class instance was passed then there's no point in omitting
// \ReflectionClass, since code has been loaded already.
if (!isset($pathname) || !is_string($classname)) {
parent::__construct($classname);
$this->classname = is_object($classname) ? get_class($classname) : $classname;
$this->pathname = parent::getFileName();
} else {
$this->classname = $classname;
$this->pathname = $pathname;
}
// Instantiating \ReflectionClass immediately triggers reflection; resemble
// that.
$this->info = $this->reflect();
}
/**
* Return new ReflectionClass object
* @param string|object $argument
*/
public function __construct($argument)
{
parent::__construct($argument);
$this->klass = $argument;
}
public function __construct($class)
{
parent::__construct($class);
$this->annotations = $this->createAnnotationBuilder()->build($this);
}
public function __construct($class)
{
parent::__construct($class);
$this->annotations = $this->createParser()->parse(AddendumCompatibility::getDocComment($this));
}
public function __construct($name)
{
parent::__construct($name);
}
/**
* Constructor.
*
* @param string $className Class name
* @param \TokenReflection\Broker $broker Reflection broker
*/
public function __construct($className, Broker $broker)
{
parent::__construct($className);
$this->broker = $broker;
}
/**
* Implementation of internal reflection initialization
*
* @return void
*/
protected function __initialize()
{
parent::__construct($this->getName());
}
function __construct($name, $args = array())
{
parent::__construct($name);
$this->ConstructorArgs = $args;
}
/**
* Initializes the timed object with the passed data.
*
* @param object $object The object to create the reflection object for
* @param array $annotationsToIgnore An array with annotations names we want to ignore when loaded
* @param array $annotationAliases An array with annotation aliases used when create annotation instances
*/
public function __construct($object, array $annotationsToIgnore = array(), array $annotationAliases = array())
{
parent::__construct(get_class($object), $annotationsToIgnore, $annotationAliases);
}
/**
* Constructor
*
* sets the class name and calls the constructor of the reflectionClass
*
* @param string The class name
* @return void
*/
public function __construct($classname)
{
parent::__construct($classname);
$this->classname = $classname;
$this->parseComment();
}
/**
* Constructor
*
* @param mixed $class Either a string containing the name of the class to reflect, or an object.
* @access public
* @return void
*/
public function __construct($object)
{
parent::__construct($object);
$parser = new AnnotationParser($this->getDocComment());
$this->annotations = $parser->getAnnotationArray();
}
/**
* Constructor
*
* Instantiate the code reflection object
*
* @param string $code
* @return \Pop\Code\Reflection
*/
public function __construct($code)
{
$this->code = $code;
parent::__construct($code);
$this->buildGenerator();
}