vendor/doctrine/orm/lib/Doctrine/ORM/Mapping/Driver/AttributeReader.php line 106

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. namespace Doctrine\ORM\Mapping\Driver;
  7. use Attribute;
  8. use Doctrine\ORM\Mapping\Annotation;
  9. use LogicException;
  10. use ReflectionAttribute;
  11. use ReflectionClass;
  12. use ReflectionMethod;
  13. use ReflectionProperty;
  15. use function assert;
  16. use function is_string;
  17. use function is_subclass_of;
  18. use function sprintf;
  20. /**
  21.  * @internal
  22.  */
  23. final class AttributeReader
  24. {
  25.     /** @var array<class-string<Annotation>,bool> */
  26.     private array $isRepeatableAttribute = [];
  28.     /**
  29.      * @psalm-return class-string-map<T, T|RepeatableAttributeCollection<T>>
  30.      *
  31.      * @template T of Annotation
  32.      */
  33.     public function getClassAnnotations(ReflectionClass $class): array
  34.     {
  35.         return $this->convertToAttributeInstances($class->getAttributes());
  36.     }
  38.     /**
  39.      * @return class-string-map<T, T|RepeatableAttributeCollection<T>>
  40.      *
  41.      * @template T of Annotation
  42.      */
  43.     public function getMethodAnnotations(ReflectionMethod $method): array
  44.     {
  45.         return $this->convertToAttributeInstances($method->getAttributes());
  46.     }
  48.     /**
  49.      * @return class-string-map<T, T|RepeatableAttributeCollection<T>>
  50.      *
  51.      * @template T of Annotation
  52.      */
  53.     public function getPropertyAnnotations(ReflectionProperty $property): array
  54.     {
  55.         return $this->convertToAttributeInstances($property->getAttributes());
  56.     }
  58.     /**
  59.      * @param class-string<T> $annotationName The name of the annotation.
  60.      *
  61.      * @return T|null
  62.      *
  63.      * @template T of Annotation
  64.      */
  65.     public function getPropertyAnnotation(ReflectionProperty $property, $annotationName)
  66.     {
  67.         if ($this->isRepeatable($annotationName)) {
  68.             throw new LogicException(sprintf(
  69.                 'The attribute "%s" is repeatable. Call getPropertyAnnotationCollection() instead.',
  70.                 $annotationName
  71.             ));
  72.         }
  74.         return $this->getPropertyAnnotations($property)[$annotationName]
  75.             ?? ($this->isRepeatable($annotationName) ? new RepeatableAttributeCollection() : null);
  76.     }
  78.     /**
  79.      * @param class-string<T> $annotationName The name of the annotation.
  80.      *
  81.      * @return RepeatableAttributeCollection<T>
  82.      *
  83.      * @template T of Annotation
  84.      */
  85.     public function getPropertyAnnotationCollection(
  86.         ReflectionProperty $property,
  87.         string $annotationName
  88.     ): RepeatableAttributeCollection {
  89.         if (! $this->isRepeatable($annotationName)) {
  90.             throw new LogicException(sprintf(
  91.                 'The attribute "%s" is not repeatable. Call getPropertyAnnotation() instead.',
  92.                 $annotationName
  93.             ));
  94.         }
  96.         return $this->getPropertyAnnotations($property)[$annotationName] ?? new RepeatableAttributeCollection();
  97.     }
  99.     /**
  100.      * @param array<ReflectionAttribute> $attributes
  101.      *
  102.      * @return class-string-map<T, T|RepeatableAttributeCollection<T>>
  103.      *
  104.      * @template T of Annotation
  105.      */
  106.     private function convertToAttributeInstances(array $attributes): array
  107.     {
  108.         $instances = [];
  110.         foreach ($attributes as $attribute) {
  111.             $attributeName = $attribute->getName();
  112.             assert(is_string($attributeName));
  113.             // Make sure we only get Doctrine Annotations
  114.             if (! is_subclass_of($attributeName, Annotation::class)) {
  115.                 continue;
  116.             }
  118.             $instance = $attribute->newInstance();
  119.             assert($instance instanceof Annotation);
  121.             if ($this->isRepeatable($attributeName)) {
  122.                 if (! isset($instances[$attributeName])) {
  123.                     $instances[$attributeName] = new RepeatableAttributeCollection();
  124.                 }
  126.                 $collection = $instances[$attributeName];
  127.                 assert($collection instanceof RepeatableAttributeCollection);
  128.                 $collection[] = $instance;
  129.             } else {
  130.                 $instances[$attributeName] = $instance;
  131.             }
  132.         }
  134.         return $instances;
  135.     }
  137.     /**
  138.      * @param class-string<Annotation> $attributeClassName
  139.      */
  140.     private function isRepeatable(string $attributeClassName): bool
  141.     {
  142.         if (isset($this->isRepeatableAttribute[$attributeClassName])) {
  143.             return $this->isRepeatableAttribute[$attributeClassName];
  144.         }
  146.         $reflectionClass = new ReflectionClass($attributeClassName);
  147.         $attribute       = $reflectionClass->getAttributes()[0]->newInstance();
  149.         return $this->isRepeatableAttribute[$attributeClassName] = ($attribute->flags & Attribute::IS_REPEATABLE) > 0;
  150.     }
  151. }