예제 #1
0
 private function parseType($annotations, TokenReflectionClass $tokenizedClass)
 {
     $currentNamespace = $tokenizedClass->getNamespaceName();
     $currentNamespaceAliases = $tokenizedClass->getNamespaceAliases();
     foreach ($annotations as $annotation) {
         preg_match(self::TYPE_REGEXP, $annotation, $matches);
         if (!empty($matches[0])) {
             list($parsedNamespace, $parsedClassName) = $this->parseClass($matches[0]);
             if ($this->isIgnoredType($parsedClassName)) {
                 continue;
             }
             if (empty($parsedNamespace) && isset($currentNamespaceAliases[$parsedClassName])) {
                 return $currentNamespaceAliases[$parsedClassName];
             } else {
                 if (isset($currentNamespaceAliases[$parsedNamespace])) {
                     return $currentNamespaceAliases[$parsedNamespace] . '\\' . $parsedClassName;
                 } else {
                     if (class_exists($currentNamespace . '\\' . $parsedClassName)) {
                         return $currentNamespace . '\\' . $parsedClassName;
                     } else {
                         if (class_exists($parsedClassName)) {
                             return $parsedClassName;
                         }
                     }
                 }
             }
         }
     }
     return null;
 }
예제 #2
0
 /**
  * @param ParsedReflectionClass|ParsedReflectionMethod|ParsedReflectionProperty $point
  * {@inheritdoc}
  */
 public function matches($point)
 {
     $expectedClass = $this->expectedClass;
     if (!$point instanceof $expectedClass) {
         return false;
     }
     $aliases = $point->getNamespaceAliases();
     $this->annotationReader->setImports($aliases);
     $annotation = $this->annotationReader->{$this->annotationMethod}($point, $this->annotationName);
     return (bool) $annotation;
 }
예제 #3
0
 /**
  * {@inheritDoc}
  */
 public function __toString()
 {
     $ctor = $this->class->getConstructor();
     if ($this->isFieldsIntercepted && (!$ctor || !$ctor->isPrivate())) {
         $this->addFieldInterceptorsCode($ctor);
     }
     $prefix = join(' ', Reflection::getModifierNames($this->class->getModifiers()));
     $classCode = $this->class->getDocComment() . "\n" . ($prefix ? "{$prefix} " : '') . 'class ' . $this->name . ' extends ' . $this->parentClassName . ($this->interfaces ? ' implements ' . join(', ', $this->interfaces) : '') . "\n" . "{\n" . ($this->traits ? $this->indent('use ' . join(', ', $this->traits) . ';' . "\n") : '') . "\n" . $this->indent(join("\n", $this->propertiesCode)) . "\n" . $this->indent(join("\n", $this->methodsCode)) . "\n" . "}";
     return $classCode . PHP_EOL . '\\' . __CLASS__ . "::injectJoinPoints('" . $this->class->name . "'," . var_export($this->advices, true) . ");";
 }
예제 #4
0
 public function getInheritanceTree()
 {
     $parent_entries = [];
     $parents = $this->reflection->getParentClassNameList();
     $currentNamespace = $this->reflection->getNamespaceName();
     if (!empty($parents)) {
         foreach ($parents as $key => $parent) {
             $string = ':ref:`';
             $string .= str_replace('\\', '-', $parent) . "`";
             $parent_entries[] = $string;
         }
     } else {
         return "";
     }
     $refs = join(' => ', $parent_entries);
     $title = "**Inheritance Hierarchy:**\n";
     return "{$title}{$refs}\n\n";
 }
예제 #5
0
 /**
  * Checks the class for possible component and register it in the container if needed
  *
  * @param ReflectionClass $class Instance of class reflection
  * @param ContainerBuilder $container
  *
  * @return bool True if component is registered
  */
 protected function checkAndRegisterComponent(ReflectionClass $class, ContainerBuilder $container)
 {
     $this->reader->setImports($class->getNamespaceAliases());
     $serviceName = str_replace('\\', '.', $class->getName());
     $annotation = $this->reader->getClassAnnotation($class, self::ANNOTATION_CLASS);
     if (!$annotation) {
         return false;
     }
     $definition = $container->register($serviceName, $class->getName());
     $constructor = $class->getConstructor();
     if ($constructor) {
         $this->bindConstructorArgs($constructor, $definition, $container);
     }
     if ((string) $annotation) {
         // Make an alias for annotation
         $container->setAlias($annotation, $serviceName);
     }
     return true;
 }
예제 #6
0
 public function getNamespaceElement()
 {
     return '.. php:namespace: ' . str_replace('\\', '\\\\', $this->reflection->getNamespaceName()) . "\n\n";
 }
 /**
  * Parses child reflection objects from the token stream.
  *
  * @param \TokenReflection\Stream\StreamBase $tokenStream Token substream
  * @param \TokenReflection\IReflection $parent Parent reflection object
  * @return \TokenReflection\ReflectionFileNamespace
  * @throws \TokenReflection\Exception\ParseException If child elements could not be parsed.
  */
 protected function parseChildren(Stream $tokenStream, IReflection $parent)
 {
     static $skipped = array(T_WHITESPACE => true, T_COMMENT => true, T_DOC_COMMENT => true);
     $depth = 0;
     $firstChild = null;
     while (true) {
         switch ($tokenStream->getType()) {
             case T_USE:
                 while (true) {
                     $namespaceName = '';
                     $alias = null;
                     $tokenStream->skipWhitespaces(true);
                     while (true) {
                         switch ($tokenStream->getType()) {
                             case T_STRING:
                             case T_NS_SEPARATOR:
                                 $namespaceName .= $tokenStream->getTokenValue();
                                 break;
                             case T_FUNCTION:
                                 // "use function" in 5.6+
                                 break;
                             default:
                                 break 2;
                         }
                         $tokenStream->skipWhitespaces(true);
                     }
                     $namespaceName = ltrim($namespaceName, '\\');
                     if (empty($namespaceName)) {
                         throw new Exception\ParseException($this, $tokenStream, 'Imported namespace name could not be determined.', Exception\ParseException::LOGICAL_ERROR);
                     } elseif ('\\' === substr($namespaceName, -1)) {
                         throw new Exception\ParseException($this, $tokenStream, sprintf('Invalid namespace name "%s".', $namespaceName), Exception\ParseException::LOGICAL_ERROR);
                     }
                     if ($tokenStream->is(T_AS)) {
                         // Alias defined
                         $tokenStream->skipWhitespaces(true);
                         if (!$tokenStream->is(T_STRING)) {
                             throw new Exception\ParseException($this, $tokenStream, sprintf('The imported namespace "%s" seems aliased but the alias name could not be determined.', $namespaceName), Exception\ParseException::LOGICAL_ERROR);
                         }
                         $alias = $tokenStream->getTokenValue();
                         $tokenStream->skipWhitespaces(true);
                     } else {
                         // No explicit alias
                         if (false !== ($pos = strrpos($namespaceName, '\\'))) {
                             $alias = substr($namespaceName, $pos + 1);
                         } else {
                             $alias = $namespaceName;
                         }
                     }
                     if (isset($this->aliases[$alias])) {
                         throw new Exception\ParseException($this, $tokenStream, sprintf('Namespace alias "%s" already defined.', $alias), Exception\ParseException::LOGICAL_ERROR);
                     }
                     $this->aliases[$alias] = $namespaceName;
                     $type = $tokenStream->getType();
                     if (';' === $type) {
                         $tokenStream->skipWhitespaces();
                         break 2;
                     } elseif (',' === $type) {
                         // Next namespace in the current "use" definition
                         continue;
                     }
                     throw new Exception\ParseException($this, $tokenStream, 'Unexpected token found.', Exception\ParseException::UNEXPECTED_TOKEN);
                 }
             case T_COMMENT:
             case T_DOC_COMMENT:
                 $docblock = $tokenStream->getTokenValue();
                 if (preg_match('~^' . preg_quote(self::DOCBLOCK_TEMPLATE_START, '~') . '~', $docblock)) {
                     array_unshift($this->docblockTemplates, new ReflectionAnnotation($this, $docblock));
                 } elseif (self::DOCBLOCK_TEMPLATE_END === $docblock) {
                     array_shift($this->docblockTemplates);
                 }
                 $tokenStream->next();
                 break;
             case '{':
                 $tokenStream->next();
                 $depth++;
                 break;
             case '}':
                 if (0 === $depth--) {
                     break 2;
                 }
                 $tokenStream->next();
                 break;
             case null:
             case T_NAMESPACE:
                 break 2;
             case T_ABSTRACT:
             case T_FINAL:
             case T_CLASS:
             case T_TRAIT:
             case T_INTERFACE:
                 $class = new ReflectionClass($tokenStream, $this->getBroker(), $this);
                 $firstChild = $firstChild ?: $class;
                 $className = $class->getName();
                 if (isset($this->classes[$className])) {
                     if (!$this->classes[$className] instanceof Invalid\ReflectionClass) {
                         $this->classes[$className] = new Invalid\ReflectionClass($className, $this->classes[$className]->getFileName(), $this->getBroker());
                     }
                     if (!$this->classes[$className]->hasReasons()) {
                         $this->classes[$className]->addReason(new Exception\ParseException($this, $tokenStream, sprintf('Class %s is defined multiple times in the file.', $className), Exception\ParseException::ALREADY_EXISTS));
                     }
                 } else {
                     $this->classes[$className] = $class;
                 }
                 $tokenStream->next();
                 break;
             case T_CONST:
                 $tokenStream->skipWhitespaces(true);
                 do {
                     $constant = new ReflectionConstant($tokenStream, $this->getBroker(), $this);
                     $firstChild = $firstChild ?: $constant;
                     $constantName = $constant->getName();
                     if (isset($this->constants[$constantName])) {
                         if (!$this->constants[$constantName] instanceof Invalid\ReflectionConstant) {
                             $this->constants[$constantName] = new Invalid\ReflectionConstant($constantName, $this->constants[$constantName]->getFileName(), $this->getBroker());
                         }
                         if (!$this->constants[$constantName]->hasReasons()) {
                             $this->constants[$constantName]->addReason(new Exception\ParseException($this, $tokenStream, sprintf('Constant %s is defined multiple times in the file.', $constantName), Exception\ParseException::ALREADY_EXISTS));
                         }
                     } else {
                         $this->constants[$constantName] = $constant;
                     }
                     if ($tokenStream->is(',')) {
                         $tokenStream->skipWhitespaces(true);
                     } else {
                         $tokenStream->next();
                     }
                 } while ($tokenStream->is(T_STRING));
                 break;
             case T_STRING:
                 switch ($tokenStream->getTokenValue()) {
                     case 'define':
                         // definition case
                     // definition case
                     default:
                         break;
                 }
                 $tokenStream->next();
                 break;
             case T_FUNCTION:
                 $position = $tokenStream->key() + 1;
                 while (isset($skipped[$type = $tokenStream->getType($position)])) {
                     $position++;
                 }
                 if ('(' === $type) {
                     // Skipping anonymous functions
                     $tokenStream->seek($position)->findMatchingBracket()->skipWhiteSpaces(true);
                     if ($tokenStream->is(T_USE)) {
                         $tokenStream->skipWhitespaces(true)->findMatchingBracket()->skipWhitespaces(true);
                     }
                     $tokenStream->findMatchingBracket()->next();
                     continue;
                 }
                 $function = new ReflectionFunction($tokenStream, $this->getBroker(), $this);
                 $firstChild = $firstChild ?: $function;
                 $functionName = $function->getName();
                 if (isset($this->functions[$functionName])) {
                     if (!$this->functions[$functionName] instanceof Invalid\ReflectionFunction) {
                         $this->functions[$functionName] = new Invalid\ReflectionFunction($functionName, $this->functions[$functionName]->getFileName(), $this->getBroker());
                     }
                     if (!$this->functions[$functionName]->hasReasons()) {
                         $this->functions[$functionName]->addReason(new Exception\ParseException($this, $tokenStream, sprintf('Function %s is defined multiple times in the file.', $functionName), Exception\ParseException::ALREADY_EXISTS));
                     }
                 } else {
                     $this->functions[$functionName] = $function;
                 }
                 $tokenStream->next();
                 break;
             default:
                 $tokenStream->next();
                 break;
         }
     }
     if ($firstChild) {
         $this->startPosition = min($this->startPosition, $firstChild->getStartPosition());
     }
     return $this;
 }
예제 #8
0
 /**
  * Exports a reflected object.
  *
  * @param \TokenReflection\Broker $broker Broker instance
  * @param string|object $className Class name or class instance
  * @param boolean $return Return the export instead of outputting it
  * @return string|null
  * @throws \TokenReflection\Exception\RuntimeException If requested parameter doesn't exist.
  */
 public static function export(Broker $broker, $className, $return = false)
 {
     TokenReflection\ReflectionClass::export($broker, $className, $return);
 }
 /**
  * Tests if method is defined in class in namespace.
  */
 public function testInNamespace()
 {
     require_once $this->getFilePath('inNamespace');
     $this->getBroker()->processFile($this->getFilePath('inNamespace'));
     $rfl = new \stdClass();
     $class = new \ReflectionClass('TokenReflection\\Test\\MethodInNamespace');
     $rfl->internal = $class->getMethod('inNamespace');
     $rfl->token = $this->getBroker()->getClass('TokenReflection\\Test\\MethodInNamespace')->getMethod('inNamespace');
     $this->assertSame($rfl->internal->inNamespace(), $rfl->token->inNamespace());
     $this->assertFalse($rfl->token->inNamespace());
     $this->assertSame($rfl->internal->getNamespaceName(), $rfl->token->getNamespaceName());
     $this->assertSame('', $rfl->token->getNamespaceName());
     $this->assertSame($rfl->internal->getName(), $rfl->token->getName());
     $this->assertSame('inNamespace', $rfl->token->getName());
     $this->assertSame($rfl->internal->getShortName(), $rfl->token->getShortName());
     $this->assertSame('inNamespace', $rfl->token->getShortName());
     $rfl = $this->getMethodReflection('noNamespace');
     $this->assertSame($rfl->internal->inNamespace(), $rfl->token->inNamespace());
     $this->assertFalse($rfl->token->inNamespace());
     $this->assertSame($rfl->internal->getNamespaceName(), $rfl->token->getNamespaceName());
     $this->assertSame('', $rfl->token->getNamespaceName());
     $this->assertSame($rfl->internal->getName(), $rfl->token->getName());
     $this->assertSame($this->getMethodName('noNamespace'), $rfl->token->getName());
     $this->assertSame($rfl->internal->getShortName(), $rfl->token->getShortName());
     $this->assertSame($this->getMethodName('noNamespace'), $rfl->token->getShortName());
 }
예제 #10
0
 /**
  * Save AOP proxy to the separate file anr returns the php source code for inclusion
  *
  * @param ParsedClass $class Original class reflection
  * @param string|ClassProxy $child
  *
  * @return string
  */
 private function saveProxyToCache($class, $child)
 {
     // Without cache we should rewrite original file
     if (empty($this->options['cacheDir'])) {
         return $child;
     }
     $cacheDirSuffix = '/_proxies/';
     $cacheDir = $this->options['cacheDir'] . $cacheDirSuffix;
     $fileName = str_replace('\\', '/', $class->getName()) . '.php';
     $proxyFileName = $cacheDir . $fileName;
     $dirname = dirname($proxyFileName);
     if (!file_exists($dirname)) {
         mkdir($dirname, 0770, true);
     }
     $body = '<?php' . PHP_EOL;
     $namespace = $class->getNamespaceName();
     if ($namespace) {
         $body .= "namespace {$namespace};" . PHP_EOL . PHP_EOL;
     }
     foreach ($class->getNamespaceAliases() as $alias => $fqdn) {
         $body .= "use {$fqdn} as {$alias};" . PHP_EOL;
     }
     $body .= $child;
     file_put_contents($proxyFileName, $body);
     return 'include_once AOP_CACHE_DIR . ' . var_export($cacheDirSuffix . $fileName, true) . ';' . PHP_EOL;
 }
예제 #11
0
 protected function getParser()
 {
     return new CommentParser($this->reflection->getDocComment());
 }
예제 #12
0
 /**
  * Parses class modifiers (abstract, final) and class type (class, interface).
  *
  * @param \TokenReflection\Stream\StreamBase $tokenStream Token substream
  * @param \TokenReflection\ReflectionClass $class Defining class
  * @return \TokenReflection\ReflectionClass
  * @throws \TokenReflection\Exception\ParseException If the modifiers value cannot be determined.
  */
 private function parseModifiers(Stream $tokenStream, ReflectionClass $class)
 {
     while (true) {
         switch ($tokenStream->getType()) {
             case T_PUBLIC:
             case T_VAR:
                 $this->modifiers |= InternalReflectionProperty::IS_PUBLIC;
                 break;
             case T_PROTECTED:
                 $this->modifiers |= InternalReflectionProperty::IS_PROTECTED;
                 break;
             case T_PRIVATE:
                 $this->modifiers |= InternalReflectionProperty::IS_PRIVATE;
                 break;
             case T_STATIC:
                 $this->modifiers |= InternalReflectionProperty::IS_STATIC;
                 break;
             default:
                 break 2;
         }
         $tokenStream->skipWhitespaces(true);
     }
     if (InternalReflectionProperty::IS_STATIC === $this->modifiers) {
         $this->modifiers |= InternalReflectionProperty::IS_PUBLIC;
     } elseif (0 === $this->modifiers) {
         $parentProperties = $class->getOwnProperties();
         if (empty($parentProperties)) {
             throw new Exception\ParseException($this, $tokenStream, 'No access level defined and no previous defining class property present.', Exception\ParseException::LOGICAL_ERROR);
         }
         $sibling = array_pop($parentProperties);
         if ($sibling->isPublic()) {
             $this->modifiers = InternalReflectionProperty::IS_PUBLIC;
         } elseif ($sibling->isPrivate()) {
             $this->modifiers = InternalReflectionProperty::IS_PRIVATE;
         } elseif ($sibling->isProtected()) {
             $this->modifiers = InternalReflectionProperty::IS_PROTECTED;
         } else {
             throw new Exception\ParseException($this, $tokenStream, sprintf('Property sibling "%s" has no access level defined.', $sibling->getName()), Exception\Parse::PARSE_ELEMENT_ERROR);
         }
         if ($sibling->isStatic()) {
             $this->modifiers |= InternalReflectionProperty::IS_STATIC;
         }
     }
     return $this;
 }
 /**
  * Tests creating class instances without calling the constructor.
  */
 public function testNewInstanceWithoutConstructor()
 {
     require_once $this->getFilePath('newInstanceWithoutConstructor');
     $this->getBroker()->process($this->getFilePath('newInstanceWithoutConstructor'));
     $token = $this->getBroker()->getClass('TokenReflection_Test_NewInstanceWithoutConstructor1');
     $this->assertInstanceOf('TokenReflection\\ReflectionClass', $token);
     try {
         $token->newInstanceWithoutConstructor();
         $this->fail('TokenReflection\\Exception\\RuntimeException expected.');
     } catch (\Exception $e) {
         $this->assertInstanceOf('TokenReflection\\Exception\\RuntimeException', $e);
         if ($e->getCode() !== Exception\RuntimeException::UNSUPPORTED) {
             throw $e;
         }
     }
     if (PHP_VERSION_ID >= 50400) {
         // Try the internal reflection
         $internal = new \ReflectionClass('TokenReflection_Test_NewInstanceWithoutConstructor1');
         try {
             $internal->newInstanceWithoutConstructor();
             $this->fail('ReflectionException expected.');
         } catch (\Exception $e) {
             $this->assertInstanceOf('ReflectionException', $e);
         }
     }
     $token = $this->getBroker()->getClass('Exception');
     $this->assertInstanceOf('TokenReflection\\Php\\ReflectionClass', $token);
     try {
         $token->newInstanceWithoutConstructor();
         $this->fail('TokenReflection\\Exception\\RuntimeException expected.');
     } catch (\Exception $e) {
         $this->assertInstanceOf('TokenReflection\\Exception\\RuntimeException', $e);
         if ($e->getCode() !== Exception\RuntimeException::UNSUPPORTED) {
             throw $e;
         }
     }
     if (PHP_VERSION_ID >= 50400) {
         // Try the internal reflection
         $internal = new \ReflectionClass('Exception');
         try {
             $internal->newInstanceWithoutConstructor();
             $this->fail('ReflectionException expected.');
         } catch (\Exception $e) {
             $this->assertInstanceOf('ReflectionException', $e);
         }
     }
     $token = $this->getBroker()->getClass('TokenReflection_Test_NewInstanceWithoutConstructor2');
     $internal = new \ReflectionClass('TokenReflection_Test_NewInstanceWithoutConstructor2');
     $this->assertInstanceOf('TokenReflection\\ReflectionClass', $token);
     $instance = $token->newInstanceWithoutConstructor();
     $this->assertFalse($instance->check);
     $instance2 = $token->newInstanceArgs();
     $this->assertTrue($instance2->check);
     if (PHP_VERSION_ID >= 50400) {
         // Try the internal reflection
         $this->assertEquals($internal->newInstanceWithoutConstructor(), $token->newInstanceWithoutConstructor());
     }
 }
예제 #14
0
 /**
  * Creates a new instance using an array of parameters.
  *
  * @param array $args Array of constructor parameters
  * @return object
  * @throws \TokenReflection\Exception\RuntimeException If the required class does not exist.
  */
 public function newInstanceArgs(array $args = array())
 {
     if (!class_exists($this->name, true)) {
         throw new Exception\RuntimeException('Could not create an instance; class does not exist.', Exception\RuntimeException::DOES_NOT_EXIST, $this);
     }
     $reflection = new InternalReflectionClass($this->name);
     return $reflection->newInstanceArgs($args);
 }
예제 #15
0
 /**
  * Gets the annotations applied to a class.
  *
  * @param ParsedReflectionClass $class The ReflectionClass of the class from which
  *                               the class annotations should be read.
  * @return array An array of Annotations.
  */
 public function getClassAnnotations(ParsedReflectionClass $class)
 {
     $this->parser->setTarget(Target::TARGET_CLASS);
     return $this->parser->parse($class->getDocComment(), 'class ' . $class->getName());
 }
예제 #16
0
 /**
  * Returns list of introduction advices from advisor
  *
  * @param ReflectionClass|ParsedReflectionClass $class Class to inject advices
  * @param Aop\IntroductionAdvisor $advisor Advisor for class
  * @param string $advisorId Identifier of advisor
  *
  * @return array
  */
 private function getIntroductionFromAdvisor($class, $advisor, $advisorId)
 {
     // Do not make introduction for traits
     if ($class->isTrait()) {
         return array();
     }
     /** @var $advice Aop\IntroductionInfo */
     $advice = $advisor->getAdvice();
     $classAdvices[AspectContainer::INTRODUCTION_TRAIT_PREFIX][$advisorId] = $advice;
     return $classAdvices;
 }
예제 #17
0
 /**
  * @param TokenReflection\ReflectionClass|TokenReflection\Invalid\ReflectionClass $ref
  */
 private function loadParentClassesAndInterfacesFromClassReflection($ref)
 {
     foreach (array_merge($ref->getParentClasses(), $ref->getInterfaces()) as $parentName => $parentReflection) {
         /** @var TokenReflection\ReflectionClass $parentReflection */
         if ($parentReflection->isInternal()) {
             if (!isset($this->allClasses[self::INTERNAL_CLASSES][$parentName])) {
                 $this->allClasses[self::INTERNAL_CLASSES][$parentName] = $parentReflection;
             }
         } elseif (!$parentReflection->isTokenized()) {
             if (!isset($this->allClasses[self::NONEXISTENT_CLASSES][$parentName])) {
                 $this->allClasses[self::NONEXISTENT_CLASSES][$parentName] = $parentReflection;
             }
         }
     }
 }
 /**
  * Parses internal PHP method modifiers (abstract, final, public, ...).
  *
  * @param \TokenReflection\ReflectionClass $class Parent class
  *
  * @return \TokenReflection\ReflectionMethod
  */
 private function parseInternalModifiers(ReflectionClass $class)
 {
     $name = strtolower($this->name);
     // In PHP 5.3.3+ the ctor can be named only __construct in namespaced classes
     if ('__construct' === $name || (!$class->inNamespace() || PHP_VERSION_ID < 50303) && strtolower($class->getShortName()) === $name) {
         $this->modifiers |= self::IS_CONSTRUCTOR;
     } elseif ('__destruct' === $name) {
         $this->modifiers |= self::IS_DESTRUCTOR;
     } elseif ('__clone' === $name) {
         $this->modifiers |= self::IS_CLONE;
     }
     if ($class->isInterface()) {
         $this->modifiers |= InternalReflectionMethod::IS_ABSTRACT;
     } else {
         // Can be called statically, see http://svn.php.net/viewvc/php/php-src/branches/PHP_5_3/Zend/zend_API.c?revision=309853&view=markup#l1795
         static $notAllowed = array('__clone' => true, '__tostring' => true, '__get' => true, '__set' => true, '__isset' => true, '__unset' => true);
         if (!$this->isStatic() && !$this->isConstructor() && !$this->isDestructor() && !isset($notAllowed[$name])) {
             $this->modifiers |= self::IS_ALLOWED_STATIC;
         }
     }
     return $this;
 }
예제 #19
0
 /**
  *
  * @param ReflectionClass $reflection
  * @return string
  */
 protected static function getObjectType(ReflectionClass $reflection)
 {
     return $reflection->isTrait() ? "Trait" : ($reflection->isInterface() ? "Interface" : "Class");
 }