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

  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. /** @internal */
  21. final class AttributeReader
  22. {
  23.     /** @var array<class-string<Annotation>,bool> */
  24.     private array $isRepeatableAttribute = [];
  26.     /**
  27.      * @psalm-return class-string-map<T, T|RepeatableAttributeCollection<T>>
  28.      *
  29.      * @template T of Annotation
  30.      */
  31.     public function getClassAttributes(ReflectionClass $class): array
  32.     {
  33.         return $this->convertToAttributeInstances($class->getAttributes());
  34.     }
  36.     /**
  37.      * @return class-string-map<T, T|RepeatableAttributeCollection<T>>
  38.      *
  39.      * @template T of Annotation
  40.      */
  41.     public function getMethodAttributes(ReflectionMethod $method): array
  42.     {
  43.         return $this->convertToAttributeInstances($method->getAttributes());
  44.     }
  46.     /**
  47.      * @return class-string-map<T, T|RepeatableAttributeCollection<T>>
  48.      *
  49.      * @template T of Annotation
  50.      */
  51.     public function getPropertyAttributes(ReflectionProperty $property): array
  52.     {
  53.         return $this->convertToAttributeInstances($property->getAttributes());
  54.     }
  56.     /**
  57.      * @param class-string<T> $attributeName The name of the annotation.
  58.      *
  59.      * @return T|null
  60.      *
  61.      * @template T of Annotation
  62.      */
  63.     public function getPropertyAttribute(ReflectionProperty $property, $attributeName)
  64.     {
  65.         if ($this->isRepeatable($attributeName)) {
  66.             throw new LogicException(sprintf(
  67.                 'The attribute "%s" is repeatable. Call getPropertyAttributeCollection() instead.',
  68.                 $attributeName
  69.             ));
  70.         }
  72.         return $this->getPropertyAttributes($property)[$attributeName]
  73.             ?? ($this->isRepeatable($attributeName) ? new RepeatableAttributeCollection() : null);
  74.     }
  76.     /**
  77.      * @param class-string<T> $attributeName The name of the annotation.
  78.      *
  79.      * @return RepeatableAttributeCollection<T>
  80.      *
  81.      * @template T of Annotation
  82.      */
  83.     public function getPropertyAttributeCollection(
  84.         ReflectionProperty $property,
  85.         string $attributeName
  86.     ): RepeatableAttributeCollection {
  87.         if (! $this->isRepeatable($attributeName)) {
  88.             throw new LogicException(sprintf(
  89.                 'The attribute "%s" is not repeatable. Call getPropertyAttribute() instead.',
  90.                 $attributeName
  91.             ));
  92.         }
  94.         return $this->getPropertyAttributes($property)[$attributeName] ?? new RepeatableAttributeCollection();
  95.     }
  97.     /**
  98.      * @param array<ReflectionAttribute> $attributes
  99.      *
  100.      * @return class-string-map<T, T|RepeatableAttributeCollection<T>>
  101.      *
  102.      * @template T of Annotation
  103.      */
  104.     private function convertToAttributeInstances(array $attributes): array
  105.     {
  106.         $instances = [];
  108.         foreach ($attributes as $attribute) {
  109.             $attributeName = $attribute->getName();
  110.             assert(is_string($attributeName));
  111.             // Make sure we only get Doctrine Attributes
  112.             if (! is_subclass_of($attributeName, Annotation::class)) {
  113.                 continue;
  114.             }
  116.             $instance = $attribute->newInstance();
  117.             assert($instance instanceof Annotation);
  119.             if ($this->isRepeatable($attributeName)) {
  120.                 if (! isset($instances[$attributeName])) {
  121.                     $instances[$attributeName] = new RepeatableAttributeCollection();
  122.                 }
  124.                 $collection = $instances[$attributeName];
  125.                 assert($collection instanceof RepeatableAttributeCollection);
  126.                 $collection[] = $instance;
  127.             } else {
  128.                 $instances[$attributeName] = $instance;
  129.             }
  130.         }
  132.         return $instances;
  133.     }
  135.     /** @param class-string<Annotation> $attributeClassName */
  136.     private function isRepeatable(string $attributeClassName): bool
  137.     {
  138.         if (isset($this->isRepeatableAttribute[$attributeClassName])) {
  139.             return $this->isRepeatableAttribute[$attributeClassName];
  140.         }
  142.         $reflectionClass = new ReflectionClass($attributeClassName);
  143.         $attribute       = $reflectionClass->getAttributes()[0]->newInstance();
  145.         return $this->isRepeatableAttribute[$attributeClassName] = ($attribute->flags & Attribute::IS_REPEATABLE) > 0;
  146.     }
  147. }