/** * {@inheritdoc} */ public function loadMetadataForClass(\ReflectionClass $class) { $actionMetadata = new ActionMetadata($class->name); $actionMetadata->fileResources[] = $class->getFilename(); $actionAnnotation = $this->reader->getClassAnnotation($class, Action::class); /** @var Action $actionAnnotation */ if ($actionAnnotation !== null) { $actionMetadata->isAction = true; $actionMetadata->serviceId = $actionAnnotation->serviceId ?: null; $actionMetadata->alias = $actionAnnotation->alias ?: null; } else { return null; } /** @var Security $securityAnnotation */ $securityAnnotation = $this->reader->getClassAnnotation($class, Security::class); if ($securityAnnotation) { $actionMetadata->authorizationExpression = $securityAnnotation->expression; } $methodCount = 0; foreach ($class->getMethods() as $method) { if (!$method->isPublic()) { continue; } $methodMetadata = $this->loadMetadataForMethod($class, $method); if ($methodMetadata) { $actionMetadata->addMethodMetadata($methodMetadata); $methodCount++; } } if ($methodCount < 1) { return null; } return $actionMetadata; }
/** * Modifies the Request object to apply configuration information found in * controllers annotations like the template to render or HTTP caching * configuration. * * @param FilterControllerEvent $event A FilterControllerEvent instance * * @return void */ public function onKernelController(FilterControllerEvent $event) { if (!is_array($controller = $event->getController())) { return; } $className = class_exists('Doctrine\\Common\\Util\\ClassUtils') ? ClassUtils::getClass($controller[0]) : get_class($controller[0]); $object = new \ReflectionClass($className); $transactional = $this->reader->getClassAnnotation($object, Transactional::NAME); if (!$transactional instanceof Transactional) { return; } $avoidTransaction = $this->reader->getMethodAnnotation($object->getMethod($controller[1]), AvoidTransaction::NAME); if (!is_null($avoidTransaction)) { return; } $request = $event->getRequest(); $modelName = $transactional->model; $model = new $modelName(); $this->transactionBuilder->setRequestMethod($request->getRealMethod()); $this->transactionBuilder->setRequestSource(Transaction::SOURCE_REST); $this->transactionBuilder->setRelatedRoute($transactional->relatedRoute); $ids = []; foreach ($model->getIds() as $field => $value) { $ids[$field] = $request->attributes->get($field); } $this->transactionBuilder->setRelatedIds($ids); $this->transactionBuilder->setModel($transactional->model); $transaction = $this->transactionBuilder->build(); $request->attributes->set('transaction', $transaction); }
/** * Attempts to read the uploadable annotation. * * @param \ReflectionClass $class The reflection class. * @return null|\Iphp\FileStoreBundle\Annotation\Uploadable The annotation. */ public function readUploadable(\ReflectionClass $class) { $baseClassName = $className = $class->getNamespaceName() . '\\' . $class->getName(); do { if (isset($this->uploadedClass[$className])) { if ($baseClassName != $className) { $this->uploadedClass[$baseClassName] = $this->uploadedClass[$className]; } return $this->uploadedClass[$baseClassName]; } $annotation = $this->reader->getClassAnnotation($class, 'Iphp\\FileStoreBundle\\Mapping\\Annotation\\Uploadable'); if ($annotation) { $this->uploadedClass[$baseClassName] = $annotation; if ($baseClassName != $className) { $this->uploadedClass[$className] = $annotation; } return $annotation; } $class = $class->getParentClass(); if ($class) { $className = $class->getNamespaceName() . '\\' . $class->getName(); } } while ($class); return $annotation; }
/** * @param \ReflectionClass $class * * @return \Metadata\ClassMetadata */ public function loadMetadataForClass(\ReflectionClass $class) { $metadata = new ClassMetadata($class->getName()); // Resource annotation $annotation = $this->reader->getClassAnnotation($class, 'Conjecto\\Nemrod\\ResourceManager\\Annotation\\Resource'); if (null !== $annotation) { $types = $annotation->types; $pattern = $annotation->uriPattern; if (!is_array($types)) { $types = array($types); } $metadata->types = $types; $metadata->uriPattern = $pattern; } foreach ($class->getProperties() as $reflectionProperty) { $propMetadata = new PropertyMetadata($class->getName(), $reflectionProperty->getName()); // Property annotation $annotation = $this->reader->getPropertyAnnotation($reflectionProperty, 'Conjecto\\Nemrod\\ResourceManager\\Annotation\\Property'); if (null !== $annotation) { $propMetadata->value = $annotation->value; $propMetadata->cascade = $annotation->cascade; } $metadata->addPropertyMetadata($propMetadata); } return $metadata; }
/** * @param string $className * * @return array */ public function processClass($className, $path) { $reflection = new \ReflectionClass($className); if (null === $this->reader->getClassAnnotation($reflection, $this->annotationClass)) { return array(); } $mappings = array(); $this->output->writeln("Found class: {$className}"); foreach ($reflection->getMethods() as $method) { /** @var Method[] $annotations */ $annotations = $this->reader->getMethodAnnotations($method); if (0 == count($annotations)) { continue; } $this->output->writeln(sprintf("Found annotations for method %s::%s.", $method->class, $method->getName())); foreach ($annotations as $annotation) { if (!$annotation instanceof Method) { continue; } $this->output->writeln(sprintf("Found mapping: %s::%s --> %s::%s", $method->class, $method->getName(), $annotation->getClass(), $annotation->getMethod())); $mapping = new Mapping(); $moduleFile = $reflection->getFileName(); $moduleFile = substr($moduleFile, strpos($moduleFile, $path)); $mapping->setOxidClass($annotation->getClass())->setOxidMethod($annotation->getMethod())->setModuleClass($className)->setModuleMethod($method->getName())->setReturn($annotation->hasReturnValue())->setParentExecution($annotation->getParentExecution())->setModuleFile($moduleFile); $mappings[] = $mapping; } } return $mappings; }
/** * @param LifecycleEventArgs $args * @return bool * @throws \Exception */ public function checkBadWords(LifecycleEventArgs $args) { $entity = $args->getEntity(); if (!$entity instanceof BadWordDetectorInterface) { return true; } $badWords = $args->getEntityManager()->getRepository('RenowazeBundle:BadWord')->findAll(); /** @var BadWordDetector $annotationParams */ $annotationParams = $this->reader->getClassAnnotation(new \ReflectionClass($entity), 'RenowazeBundle\\Annotation\\BadWordDetector'); foreach ($annotationParams->fields as $field) { $methodName = 'get' . ucfirst($field); if (!method_exists($entity, $methodName)) { throw new \Exception(sprintf('Field "%s" not found in entity "%s"', $methodName, get_class($entity))); } /** @var BadWord $badWord */ foreach ($badWords as $badWord) { if (strpos($entity->{$methodName}(), $badWord->getWord()) !== false) { $entity->setHasBadWords(true); return true; } } } $entity->setHasBadWords(false); return true; }
/** * Loads ACL annotations from PHP files * * @param AclAnnotationStorage $storage */ public function load(AclAnnotationStorage $storage) { $configLoader = OroSecurityExtension::getAclAnnotationLoader(); $resources = $configLoader->load(); foreach ($resources as $resource) { foreach ($resource->data as $file) { $className = $this->getClassName($file); if ($className !== null) { $reflection = $this->getReflectionClass($className); // read annotations from class $annotation = $this->reader->getClassAnnotation($reflection, self::ANNOTATION_CLASS); if ($annotation) { $storage->add($annotation, $reflection->getName()); } else { $ancestor = $this->reader->getClassAnnotation($reflection, self::ANCESTOR_CLASS); if ($ancestor) { $storage->addAncestor($ancestor, $reflection->getName()); } } // read annotations from methods foreach ($reflection->getMethods() as $reflectionMethod) { $annotation = $this->reader->getMethodAnnotation($reflectionMethod, self::ANNOTATION_CLASS); if ($annotation) { $storage->add($annotation, $reflection->getName(), $reflectionMethod->getName()); } else { $ancestor = $this->reader->getMethodAnnotation($reflectionMethod, self::ANCESTOR_CLASS); if ($ancestor) { $storage->addAncestor($ancestor, $reflection->getName(), $reflectionMethod->getName()); } } } } } } }
/** * Load JSON API configuration from controller annotations * * @param FilterControllerEvent $event */ public function onKernelController(FilterControllerEvent $event) { $controller = $event->getController(); if (!is_array($controller)) { return; } $config = null; $refClass = new \ReflectionClass($controller[0]); if (null !== ($annotation = $this->reader->getClassAnnotation($refClass, ApiRequest::class))) { /* @var $annotation ApiRequest */ $config = $annotation->toArray(); } $refMethod = $refClass->getMethod($controller[1]); if (null !== ($annotation = $this->reader->getMethodAnnotation($refMethod, ApiRequest::class))) { if (null !== $config) { $config = array_replace($config, $annotation->toArray()); } else { $config = $annotation->toArray(); } } if (null !== $config) { if (!array_key_exists('matcher', $config)) { $config['matcher'] = $this->defMatcher; } $event->getRequest()->attributes->set('_jsonapi', $this->factory->createEnvironment($config)); } }
/** * Gets the Geograhpical annotation for the specified object. * * @param object $obj The object * @return Geographical The geographical annotation */ public function getGeographicalAnnotation($obj) { if (!is_object($obj)) { throw new \InvalidArgumentException(); } $refClass = new \ReflectionClass($obj); return $this->reader->getClassAnnotation($refClass, 'Vich\\GeographicalBundle\\Annotation\\Geographical'); }
/** * @param \ReflectionClass $classRefl * @param string $segmentCode * @throws IncorrectSegmentId */ protected function checkSegmentCode($classRefl, $segmentCode) { if ($segmentAnnotation = $this->annotationReader->getClassAnnotation($classRefl, Segment::class)) { if ($segmentCode != $segmentAnnotation->value) { throw new IncorrectSegmentId(sprintf("Expected %s segment, %s found", $segmentAnnotation->value, $segmentCode)); } } }
/** * @return boolean */ private function isProtectedByCsrfDoubleSubmit(\ReflectionClass $class, \ReflectionMethod $method) { $annotation = $this->annotationReader->getClassAnnotation($class, 'Bazinga\\Bundle\\RestExtraBundle\\Annotation\\CsrfDoubleSubmit'); if (null !== $annotation) { return true; } $annotation = $this->annotationReader->getMethodAnnotation($method, 'Bazinga\\Bundle\\RestExtraBundle\\Annotation\\CsrfDoubleSubmit'); return null !== $annotation; }
/** * @param string $nodeEntityClass * @param string $property * * @return \GraphAware\Neo4j\OGM\Metadata\NodeAnnotationMetadata */ public function create($nodeEntityClass) { $reflectionClass = new \ReflectionClass($nodeEntityClass); /** @var Node $annotation */ $annotation = $this->reader->getClassAnnotation($reflectionClass, Node::class); if (null !== $annotation) { return new NodeAnnotationMetadata($annotation->label, $annotation->repository); } throw new MappingException(sprintf('The class "%s" is missing the "%s" annotation', $nodeEntityClass, Node::class)); }
/** * @param $entityClass * @return TransformerAbstract|null */ protected function getEntityTransformer($entityClass) { $reflectionClass = new \ReflectionClass($entityClass); /** @var FractalTransformer $annotation */ $annotation = $this->annotationReader->getClassAnnotation($reflectionClass, FractalTransformer::class); if (is_null($annotation)) { return null; } $transformerClass = $annotation->value; return new $transformerClass(); }
/** * @inheritdoc */ public function loadClassMetadata(\ReflectionClass $class) { if (null !== ($resource = $this->reader->getClassAnnotation($class, ApiResource::class))) { return $this->loadResourceMetadata($resource, $class); } elseif (null !== ($document = $this->reader->getClassAnnotation($class, ApiDocument::class))) { return $this->loadDocumentMetadata($document, $class); } else { $object = $this->reader->getClassAnnotation($class, ApiObject::class); return $this->loadObjectMetadata($class, $object); } }
/** * This event will fire during any controller call */ public function onKernelController(FilterControllerEvent $event) { if (!is_array($controller = $event->getController())) { return; } $class = new \ReflectionClass(get_class($controller[0])); // get controller if (!empty($this->reader->getClassAnnotation($class, self::STATE_LESS_ANNOTATION))) { $this->handleAuthenticated($class); } }
/** * @param string $annotation * @return object */ public function getSingleClassAnnotation($annotation) { $annotation = ltrim($annotation, '\\'); $res = $this->annotationReader->getClassAnnotation($this->rClass, $annotation); if (empty($res)) { return null; } if (is_array($res)) { return array_shift($res); } return $res; }
/** * @inheritdoc */ public function supports(ParamConverter $configuration) { if ($configuration->getClass() === null) { return false; } try { $class = new \ReflectionClass($configuration->getClass()); } catch (\ReflectionException $e) { return false; } return $this->reader->getClassAnnotation($class, RequestAnnotation::class) !== null; }
/** * @param $class */ public function setWorkerAnnotation($class) { $class = new \ReflectionClass($class); $annotation = $this->reader->getClassAnnotation($class, self::WORKER_ANNOTATION_CLASS); if ($annotation) { $worker = $annotation->getWorker() ? $annotation->getWorker() : "default"; if (isset($this->workerAnnotations[$worker])) { throw new Exception("The Worker '{$worker}' has already been registered in '{$class->getName()}'. Workers can only be defined once on the Class level"); } $this->workerAnnotations[$worker] = $annotation; $this->workerAnnotationsClasses[$class->getName()] = $annotation; } }
protected function getParentAnnotations(\ReflectionClass $class) { $parents = ['method' => '', 'context' => [], 'default_context' => true]; /** @var Method $annot */ if ($annot = $this->reader->getClassAnnotation($class, Method::class)) { if (null !== $annot->getMethod()) { $parents['method'] = $annot->getMethod(); } if (null !== $annot->getContext()) { $parents['context'] = $annot->getContext(); } } return $parents; }
/** * Indicates wether the constraints validation is enabled or not for the given object. * * @param array $objectClasses The classes of the object to read. * @param \Doctrine\Common\Annotations\Reader $annotationReader The annotation reader to use. * * @return boolean True if the validation is enabled, else false. */ public static function isConstraintsValidationEnabled($objectClasses, $annotationReader) { $enabled = Configuration::isConstraintsValidationEnabled(); foreach ($objectClasses as $class) { if ($annotationReader->getClassAnnotation($class, self::$disableConstraintsValidationAnnotationClass) !== null) { $enabled = false; break; } if ($annotationReader->getClassAnnotation($class, self::$enableConstraintsValidationAnnotationClass) !== null) { $enabled = true; break; } } return $enabled; }
/** * {@inheritdoc} */ public function loadClassMetadata(ClassMetadataInterface $classMetadata, array $normalizationGroups = null, array $denormalizationGroups = null, array $validationGroups = null) { $reflectionClass = $classMetadata->getReflectionClass(); if ($iri = $this->reader->getClassAnnotation($reflectionClass, self::IRI_ANNOTATION_NAME)) { $classMetadata = $classMetadata->withIri($iri->value); } foreach ($classMetadata->getAttributesMetadata() as $attributeName => $attributeMetadata) { if ($reflectionProperty = $this->getReflectionProperty($reflectionClass, $attributeName)) { if ($iri = $this->reader->getPropertyAnnotation($reflectionProperty, self::IRI_ANNOTATION_NAME)) { $classMetadata = $classMetadata->withAttributeMetadata($attributeName, $attributeMetadata->withIri($iri->value)); } } } return $classMetadata; }
/** * Loads from annotations from a class. * * @param string $class A class name * @param string|null $type The resource type * * @return RouteCollection A RouteCollection instance * * @throws \InvalidArgumentException When route can't be parsed */ public function load($class, $type = null) { if (!class_exists($class)) { throw new \InvalidArgumentException(sprintf('Class "%s" does not exist.', $class)); } $globals = array('path' => '', 'requirements' => array(), 'options' => array(), 'defaults' => array(), 'schemes' => array(), 'methods' => array(), 'host' => ''); $class = new \ReflectionClass($class); if ($class->isAbstract()) { throw new \InvalidArgumentException(sprintf('Annotations from class "%s" cannot be read as it is abstract.', $class)); } if ($annot = $this->reader->getClassAnnotation($class, $this->routeAnnotationClass)) { // for BC reasons if (null !== $annot->getPath()) { $globals['path'] = $annot->getPath(); } elseif (null !== $annot->getPattern()) { $globals['path'] = $annot->getPattern(); } if (null !== $annot->getRequirements()) { $globals['requirements'] = $annot->getRequirements(); } if (null !== $annot->getOptions()) { $globals['options'] = $annot->getOptions(); } if (null !== $annot->getDefaults()) { $globals['defaults'] = $annot->getDefaults(); } if (null !== $annot->getSchemes()) { $globals['schemes'] = $annot->getSchemes(); } if (null !== $annot->getMethods()) { $globals['methods'] = $annot->getMethods(); } if (null !== $annot->getHost()) { $globals['host'] = $annot->getHost(); } } $collection = new RouteCollection(); $collection->addResource(new FileResource($class->getFileName())); foreach ($class->getMethods() as $method) { $this->defaultRouteIndex = 0; foreach ($this->reader->getMethodAnnotations($method) as $annot) { if ($annot instanceof $this->routeAnnotationClass) { $this->addRoute($collection, $annot, $globals, $class, $method); } } } return $collection; }
protected function getGlobals(\ReflectionClass $class) { $globals = array('path' => '', 'requirements' => array(), 'options' => array(), 'defaults' => array(), 'schemes' => array(), 'methods' => array(), 'host' => '', 'condition' => ''); if ($annot = $this->reader->getClassAnnotation($class, $this->routeAnnotationClass)) { // for BC reasons if (null !== $annot->getPath()) { $globals['path'] = $annot->getPath(); } elseif (null !== $annot->getPattern()) { $globals['path'] = $annot->getPattern(); } if (null !== $annot->getRequirements()) { $globals['requirements'] = $annot->getRequirements(); } if (null !== $annot->getOptions()) { $globals['options'] = $annot->getOptions(); } if (null !== $annot->getDefaults()) { $globals['defaults'] = $annot->getDefaults(); } if (null !== $annot->getSchemes()) { $globals['schemes'] = $annot->getSchemes(); } if (null !== $annot->getMethods()) { $globals['methods'] = $annot->getMethods(); } if (null !== $annot->getHost()) { $globals['host'] = $annot->getHost(); } if (null !== $annot->getCondition()) { $globals['condition'] = $annot->getCondition(); } } return $globals; }
public static function loadClass(ReflectionClass $refl, Reader $reader, Router $router) { $annotation = $reader->getClassAnnotation($refl, 'Destiny\\Common\\Annotation\\Controller'); if (empty($annotation)) { return; } $methods = $refl->getMethods(ReflectionMethod::IS_PUBLIC); foreach ($methods as $method) { /** @var Route[] $routes */ $routes = array(); $annotations = $reader->getMethodAnnotations($method); for ($i = 0; $i < count($annotations); ++$i) { /** @noinspection PhpUnnecessaryFullyQualifiedNameInspection */ if ($annotations[$i] instanceof \Destiny\Common\Annotation\Route) { $routes[] = $annotations[$i]; } } if (count($routes) <= 0) { continue; } /** @var \Destiny\Common\Annotation\HttpMethod $feature */ $httpMethod = $reader->getMethodAnnotation($method, 'Destiny\\Common\\Annotation\\HttpMethod'); /** @var \Destiny\Common\Annotation\Secure $feature */ $secure = $reader->getMethodAnnotation($method, 'Destiny\\Common\\Annotation\\Secure'); for ($i = 0; $i < count($routes); ++$i) { $router->addRoute(new Route(array('path' => $routes[$i]->path, 'classMethod' => $method->name, 'class' => $refl->name, 'httpMethod' => $httpMethod ? $httpMethod->allow : null, 'secure' => $secure ? $secure->roles : null))); } } }
/** * @param AnnotationReader $reader * @param string $className * @return Entity * @throws \HireVoice\Neo4j\Exception */ public static function fromClass(AnnotationReader $reader, $className) { $class = new \ReflectionClass($className); if ($class->implementsInterface('HireVoice\\Neo4j\\Proxy\\Entity')) { $class = $class->getParentClass(); $className = $class->getName(); } if (!($entity = $reader->getClassAnnotation($class, 'HireVoice\\Neo4j\\Annotation\\Entity'))) { throw new Exception("Class {$className} is not declared as an entity."); } $object = new self($class->getName()); if ($entity->repositoryClass) { $object->repositoryClass = $entity->repositoryClass; } if ($entity->labels) { $object->labels = explode(",", $entity->labels); } foreach (self::getClassProperties($class->getName()) as $prop) { $prop = new Property($reader, $prop); if ($prop->isPrimaryKey()) { $object->setPrimaryKey($prop); } elseif ($prop->isProperty($prop)) { $object->properties[] = $prop; if ($prop->isIndexed()) { $object->indexedProperties[] = $prop; } } elseif ($prop->isRelationList()) { $object->manyToManyRelations[] = $prop; } elseif ($prop->isRelation()) { $object->manyToOneRelations[] = $prop; } } $object->validate(); return $object; }
/** * The interceptor is activated for public methods in Transactional annotated components. * * {@inheritDoc} */ public function matchesMethod(ReflectionMethod $method) { $transactionalEnabled = false; if ($method->isPublic()) { // Gets method-level annotation. /** @var Transactional $annotation */ $annotation = $this->reader->getMethodAnnotation($method, Transactional::class); $transactionalEnabled = $annotation !== null; if (!$transactionalEnabled) { // If there is no method-level annotation, gets class-level annotation. $annotation = $this->reader->getClassAnnotation($method->getDeclaringClass(), Transactional::class); $transactionalEnabled = $annotation !== null; } if ($transactionalEnabled) { switch ($annotation->getPolicy()) { case Transactional::NOT_REQUIRED: $policyName = 'not required'; break; case Transactional::REQUIRED: $policyName = 'required'; break; case Transactional::NESTED: $policyName = 'nested'; break; default: $policyName = 'default'; } $methodString = $method->getDeclaringClass()->name . '::' . $method->name; $this->logger->debug('TX policy for \'' . $methodString . '\': ' . $policyName); $noRollbackExceptionsStr = implode(', ', $annotation->getNoRollbackExceptions() === null ? ['default'] : $annotation->getNoRollbackExceptions()); $this->logger->debug('TX no-rollback exceptions for \'' . $methodString . '\': ' . $noRollbackExceptionsStr); } } return $transactionalEnabled; }
/** * Reads class annotations. * * @param \ReflectionClass $reflectionClass * @param string $annotationName * * @return RouteAnnotation|null */ private function readClassAnnotation(\ReflectionClass $reflectionClass, $annotationName) { $annotationClass = "FOS\\RestBundle\\Controller\\Annotations\\{$annotationName}"; if ($annotation = $this->annotationReader->getClassAnnotation($reflectionClass, $annotationClass)) { return $annotation; } }
public static function loadClass(ReflectionClass $refl, Reader $reader) { $router = Application::instance()->getRouter(); $annotation = $reader->getClassAnnotation($refl, 'Destiny\\Common\\Annotation\\Controller'); if (empty($annotation)) { return; } $methods = $refl->getMethods(ReflectionMethod::IS_PUBLIC); foreach ($methods as $method) { // Get all the route annotations $routes = array(); $annotations = $reader->getMethodAnnotations($method); for ($i = 0; $i < count($annotations); ++$i) { if ($annotations[$i] instanceof \Destiny\Common\Annotation\Route) { $routes[] = $annotations[$i]; } } // No routes, continue if (count($routes) <= 0) { continue; } // We have 1 or many routes, add to the router $httpMethod = $reader->getMethodAnnotation($method, 'Destiny\\Common\\Annotation\\HttpMethod'); $secure = $reader->getMethodAnnotation($method, 'Destiny\\Common\\Annotation\\Secure'); $feature = $reader->getMethodAnnotation($method, 'Destiny\\Common\\Annotation\\Feature'); for ($i = 0; $i < count($routes); ++$i) { $router->addRoute(new Route(array('path' => $routes[$i]->path, 'classMethod' => $method->name, 'class' => $refl->name, 'httpMethod' => $httpMethod ? $httpMethod->allow : null, 'secure' => $secure ? $secure->roles : null, 'feature' => $feature ? $feature->features : null))); } } }
/** * @param string $presenter * @param array $routes * @return void */ private function findRoutesInPresenter($presenter, &$routes) { $r = ClassType::from($presenter); $route = $this->reader->getClassAnnotation($r, ApiRoute::class); if (!$route) { return []; } /** * Add route to priority-half-sorted list */ if (empty($routes[$route->getPriority()])) { $routes[$route->getPriority()] = []; } $route->setDescription($r->getAnnotation('description')); if (!$route->getPresenter()) { $route->setPresenter(preg_replace('/Presenter$/', '', $r->getShortName())); } /** * Find apropriate methods */ foreach ($r->getMethods() as $method_r) { $this->findPresenterMethodRoute($method_r, $routes, $route); } $routes[$route->getPriority()][] = $route; }
/** * @internal * @param Reader $annotationReader * @return string * @throws InvalidAnnotationException */ static function getEntityClassName(Reader $annotationReader) { $reflect = new ReflectionClass(get_called_class()); $annotation = $annotationReader->getClassAnnotation($reflect, Entity::class); InvalidAnnotationException::assert($annotation, Entity::class); return $annotation->className; }