vendor/doctrine/orm/src/Mapping/Driver/AttributeDriver.php line 113

  1. <?php
  3. declare(strict_types=1);
  5. namespace Doctrine\ORM\Mapping\Driver;
  7. use Doctrine\Deprecations\Deprecation;
  8. use Doctrine\ORM\Events;
  9. use Doctrine\ORM\Mapping;
  10. use Doctrine\ORM\Mapping\Builder\EntityListenerBuilder;
  11. use Doctrine\ORM\Mapping\ClassMetadata;
  12. use Doctrine\ORM\Mapping\MappingAttribute;
  13. use Doctrine\ORM\Mapping\MappingException;
  14. use Doctrine\Persistence\Mapping\ClassMetadata as PersistenceClassMetadata;
  15. use Doctrine\Persistence\Mapping\Driver\ColocatedMappingDriver;
  16. use LogicException;
  17. use ReflectionClass;
  18. use ReflectionMethod;
  19. use ReflectionProperty;
  21. use function assert;
  22. use function class_exists;
  23. use function constant;
  24. use function defined;
  25. use function get_class;
  27. use const PHP_VERSION_ID;
  29. class AttributeDriver extends CompatibilityAnnotationDriver
  30. {
  31.     use ColocatedMappingDriver;
  32.     use ReflectionBasedDriver;
  34.     private const ENTITY_ATTRIBUTE_CLASSES = [
  35.         Mapping\Entity::class => 1,
  36.         Mapping\MappedSuperclass::class => 2,
  37.     ];
  39.     /**
  40.      * @deprecated override isTransient() instead of overriding this property
  41.      *
  42.      * @var array<class-string<MappingAttribute>, int>
  43.      */
  44.     protected $entityAnnotationClasses = self::ENTITY_ATTRIBUTE_CLASSES;
  46.     /**
  47.      * The attribute reader.
  48.      *
  49.      * @internal this property will be private in 3.0
  50.      *
  51.      * @var AttributeReader
  52.      */
  53.     protected $reader;
  55.     /** @param array<string> $paths */
  56.     public function __construct(array $paths, bool $reportFieldsWhereDeclared = false)
  57.     {
  58.         if (PHP_VERSION_ID < 80000) {
  59.             throw new LogicException(
  60.                 'The attribute metadata driver cannot be enabled on PHP 7. Please upgrade to PHP 8 or choose a different'
  61.                 . ' metadata driver.'
  62.             );
  63.         }
  65.         $this->reader = new AttributeReader();
  66.         $this->addPaths($paths);
  68.         if ($this->entityAnnotationClasses !== self::ENTITY_ATTRIBUTE_CLASSES) {
  69.             Deprecation::trigger(
  70.                 'doctrine/orm',
  71.                 'https://github.com/doctrine/orm/pull/10204',
  72.                 'Changing the value of %s::$entityAnnotationClasses is deprecated and will have no effect in Doctrine ORM 3.0.',
  73.                 self::class
  74.             );
  75.         }
  77.         if (! $reportFieldsWhereDeclared) {
  78.             Deprecation::trigger(
  79.                 'doctrine/orm',
  80.                 'https://github.com/doctrine/orm/pull/10455',
  81.                 'In ORM 3.0, the AttributeDriver will report fields for the classes where they are declared. This may uncover invalid mapping configurations. To opt into the new mode today, set the "reportFieldsWhereDeclared" constructor parameter to true.',
  82.                 self::class
  83.             );
  84.         }
  86.         $this->reportFieldsWhereDeclared = $reportFieldsWhereDeclared;
  87.     }
  89.     /**
  90.      * Retrieve the current annotation reader
  91.      *
  92.      * @deprecated no replacement planned.
  93.      *
  94.      * @return AttributeReader
  95.      */
  96.     public function getReader()
  97.     {
  98.         Deprecation::trigger(
  99.             'doctrine/orm',
  100.             'https://github.com/doctrine/orm/pull/9587',
  101.             '%s is deprecated with no replacement',
  102.             __METHOD__
  103.         );
  105.         return $this->reader;
  106.     }
  108.     /**
  109.      * {@inheritDoc}
  110.      */
  111.     public function isTransient($className)
  112.     {
  113.         $classAttributes = $this->reader->getClassAttributes(new ReflectionClass($className));
  115.         foreach ($classAttributes as $a) {
  116.             $attr = $a instanceof RepeatableAttributeCollection ? $a[0] : $a;
  117.             if (isset($this->entityAnnotationClasses[get_class($attr)])) {
  118.                 return false;
  119.             }
  120.         }
  122.         return true;
  123.     }
  125.     /**
  126.      * {@inheritDoc}
  127.      *
  128.      * @psalm-param class-string<T> $className
  129.      * @psalm-param ClassMetadata<T> $metadata
  130.      *
  131.      * @template T of object
  132.      */
  133.     public function loadMetadataForClass($className, PersistenceClassMetadata $metadata): void
  134.     {
  135.         $reflectionClass = $metadata->getReflectionClass()
  136.             // this happens when running attribute driver in combination with
  137.             // static reflection services. This is not the nicest fix
  138.             ?? new ReflectionClass($metadata->name);
  140.         $classAttributes = $this->reader->getClassAttributes($reflectionClass);
  142.         // Evaluate Entity attribute
  143.         if (isset($classAttributes[Mapping\Entity::class])) {
  144.             $entityAttribute = $classAttributes[Mapping\Entity::class];
  145.             if ($entityAttribute->repositoryClass !== null) {
  146.                 $metadata->setCustomRepositoryClass($entityAttribute->repositoryClass);
  147.             }
  149.             if ($entityAttribute->readOnly) {
  150.                 $metadata->markReadOnly();
  151.             }
  152.         } elseif (isset($classAttributes[Mapping\MappedSuperclass::class])) {
  153.             $mappedSuperclassAttribute = $classAttributes[Mapping\MappedSuperclass::class];
  155.             $metadata->setCustomRepositoryClass($mappedSuperclassAttribute->repositoryClass);
  156.             $metadata->isMappedSuperclass = true;
  157.         } elseif (isset($classAttributes[Mapping\Embeddable::class])) {
  158.             $metadata->isEmbeddedClass = true;
  159.         } else {
  160.             throw MappingException::classIsNotAValidEntityOrMappedSuperClass($className);
  161.         }
  163.         $primaryTable = [];
  165.         if (isset($classAttributes[Mapping\Table::class])) {
  166.             $tableAnnot             = $classAttributes[Mapping\Table::class];
  167.             $primaryTable['name']   = $tableAnnot->name;
  168.             $primaryTable['schema'] = $tableAnnot->schema;
  170.             if ($tableAnnot->options) {
  171.                 $primaryTable['options'] = $tableAnnot->options;
  172.             }
  173.         }
  175.         if (isset($classAttributes[Mapping\Index::class])) {
  176.             foreach ($classAttributes[Mapping\Index::class] as $idx => $indexAnnot) {
  177.                 $index = [];
  179.                 if (! empty($indexAnnot->columns)) {
  180.                     $index['columns'] = $indexAnnot->columns;
  181.                 }
  183.                 if (! empty($indexAnnot->fields)) {
  184.                     $index['fields'] = $indexAnnot->fields;
  185.                 }
  187.                 if (
  188.                     isset($index['columns'], $index['fields'])
  189.                     || (
  190.                         ! isset($index['columns'])
  191.                         && ! isset($index['fields'])
  192.                     )
  193.                 ) {
  194.                     throw MappingException::invalidIndexConfiguration(
  195.                         $className,
  196.                         (string) ($indexAnnot->name ?? $idx)
  197.                     );
  198.                 }
  200.                 if (! empty($indexAnnot->flags)) {
  201.                     $index['flags'] = $indexAnnot->flags;
  202.                 }
  204.                 if (! empty($indexAnnot->options)) {
  205.                     $index['options'] = $indexAnnot->options;
  206.                 }
  208.                 if (! empty($indexAnnot->name)) {
  209.                     $primaryTable['indexes'][$indexAnnot->name] = $index;
  210.                 } else {
  211.                     $primaryTable['indexes'][] = $index;
  212.                 }
  213.             }
  214.         }
  216.         if (isset($classAttributes[Mapping\UniqueConstraint::class])) {
  217.             foreach ($classAttributes[Mapping\UniqueConstraint::class] as $idx => $uniqueConstraintAnnot) {
  218.                 $uniqueConstraint = [];
  220.                 if (! empty($uniqueConstraintAnnot->columns)) {
  221.                     $uniqueConstraint['columns'] = $uniqueConstraintAnnot->columns;
  222.                 }
  224.                 if (! empty($uniqueConstraintAnnot->fields)) {
  225.                     $uniqueConstraint['fields'] = $uniqueConstraintAnnot->fields;
  226.                 }
  228.                 if (
  229.                     isset($uniqueConstraint['columns'], $uniqueConstraint['fields'])
  230.                     || (
  231.                         ! isset($uniqueConstraint['columns'])
  232.                         && ! isset($uniqueConstraint['fields'])
  233.                     )
  234.                 ) {
  235.                     throw MappingException::invalidUniqueConstraintConfiguration(
  236.                         $className,
  237.                         (string) ($uniqueConstraintAnnot->name ?? $idx)
  238.                     );
  239.                 }
  241.                 if (! empty($uniqueConstraintAnnot->options)) {
  242.                     $uniqueConstraint['options'] = $uniqueConstraintAnnot->options;
  243.                 }
  245.                 if (! empty($uniqueConstraintAnnot->name)) {
  246.                     $primaryTable['uniqueConstraints'][$uniqueConstraintAnnot->name] = $uniqueConstraint;
  247.                 } else {
  248.                     $primaryTable['uniqueConstraints'][] = $uniqueConstraint;
  249.                 }
  250.             }
  251.         }
  253.         $metadata->setPrimaryTable($primaryTable);
  255.         // Evaluate #[Cache] attribute
  256.         if (isset($classAttributes[Mapping\Cache::class])) {
  257.             $cacheAttribute = $classAttributes[Mapping\Cache::class];
  258.             $cacheMap       = [
  259.                 'region' => $cacheAttribute->region,
  260.                 'usage'  => constant('Doctrine\ORM\Mapping\ClassMetadata::CACHE_USAGE_' . $cacheAttribute->usage),
  261.             ];
  263.             $metadata->enableCache($cacheMap);
  264.         }
  266.         // Evaluate InheritanceType attribute
  267.         if (isset($classAttributes[Mapping\InheritanceType::class])) {
  268.             $inheritanceTypeAttribute = $classAttributes[Mapping\InheritanceType::class];
  270.             $metadata->setInheritanceType(
  271.                 constant('Doctrine\ORM\Mapping\ClassMetadata::INHERITANCE_TYPE_' . $inheritanceTypeAttribute->value)
  272.             );
  274.             if ($metadata->inheritanceType !== ClassMetadata::INHERITANCE_TYPE_NONE) {
  275.                 // Evaluate DiscriminatorColumn attribute
  276.                 if (isset($classAttributes[Mapping\DiscriminatorColumn::class])) {
  277.                     $discrColumnAttribute = $classAttributes[Mapping\DiscriminatorColumn::class];
  279.                     $columnDef = [
  280.                         'name' => isset($discrColumnAttribute->name) ? (string) $discrColumnAttribute->name : null,
  281.                         'type' => isset($discrColumnAttribute->type) ? (string) $discrColumnAttribute->type : 'string',
  282.                         'length' => isset($discrColumnAttribute->length) ? (int) $discrColumnAttribute->length : 255,
  283.                         'columnDefinition' => isset($discrColumnAttribute->columnDefinition) ? (string) $discrColumnAttribute->columnDefinition : null,
  284.                         'enumType' => isset($discrColumnAttribute->enumType) ? (string) $discrColumnAttribute->enumType : null,
  285.                     ];
  287.                     if ($discrColumnAttribute->options) {
  288.                         $columnDef['options'] = (array) $discrColumnAttribute->options;
  289.                     }
  291.                     $metadata->setDiscriminatorColumn($columnDef);
  292.                 } else {
  293.                     $metadata->setDiscriminatorColumn(['name' => 'dtype', 'type' => 'string', 'length' => 255]);
  294.                 }
  296.                 // Evaluate DiscriminatorMap attribute
  297.                 if (isset($classAttributes[Mapping\DiscriminatorMap::class])) {
  298.                     $discrMapAttribute = $classAttributes[Mapping\DiscriminatorMap::class];
  299.                     $metadata->setDiscriminatorMap($discrMapAttribute->value);
  300.                 }
  301.             }
  302.         }
  304.         // Evaluate DoctrineChangeTrackingPolicy attribute
  305.         if (isset($classAttributes[Mapping\ChangeTrackingPolicy::class])) {
  306.             $changeTrackingAttribute = $classAttributes[Mapping\ChangeTrackingPolicy::class];
  307.             $metadata->setChangeTrackingPolicy(constant('Doctrine\ORM\Mapping\ClassMetadata::CHANGETRACKING_' . $changeTrackingAttribute->value));
  308.         }
  310.         foreach ($reflectionClass->getProperties() as $property) {
  311.             assert($property instanceof ReflectionProperty);
  313.             if ($this->isRepeatedPropertyDeclaration($property, $metadata)) {
  314.                 continue;
  315.             }
  317.             $mapping              = [];
  318.             $mapping['fieldName'] = $property->name;
  320.             // Evaluate #[Cache] attribute
  321.             $cacheAttribute = $this->reader->getPropertyAttribute($property, Mapping\Cache::class);
  322.             if ($cacheAttribute !== null) {
  323.                 assert($cacheAttribute instanceof Mapping\Cache);
  325.                 $mapping['cache'] = $metadata->getAssociationCacheDefaults(
  326.                     $mapping['fieldName'],
  327.                     [
  328.                         'usage'  => (int) constant('Doctrine\ORM\Mapping\ClassMetadata::CACHE_USAGE_' . $cacheAttribute->usage),
  329.                         'region' => $cacheAttribute->region,
  330.                     ]
  331.                 );
  332.             }
  334.             // Check for JoinColumn/JoinColumns attributes
  335.             $joinColumns = [];
  337.             $joinColumnAttributes = $this->reader->getPropertyAttributeCollection($property, Mapping\JoinColumn::class);
  339.             foreach ($joinColumnAttributes as $joinColumnAttribute) {
  340.                 $joinColumns[] = $this->joinColumnToArray($joinColumnAttribute);
  341.             }
  343.             // Field can only be attributed with one of:
  344.             // Column, OneToOne, OneToMany, ManyToOne, ManyToMany, Embedded
  345.             $columnAttribute     = $this->reader->getPropertyAttribute($property, Mapping\Column::class);
  346.             $oneToOneAttribute   = $this->reader->getPropertyAttribute($property, Mapping\OneToOne::class);
  347.             $oneToManyAttribute  = $this->reader->getPropertyAttribute($property, Mapping\OneToMany::class);
  348.             $manyToOneAttribute  = $this->reader->getPropertyAttribute($property, Mapping\ManyToOne::class);
  349.             $manyToManyAttribute = $this->reader->getPropertyAttribute($property, Mapping\ManyToMany::class);
  350.             $embeddedAttribute   = $this->reader->getPropertyAttribute($property, Mapping\Embedded::class);
  352.             if ($columnAttribute !== null) {
  353.                 $mapping = $this->columnToArray($property->name, $columnAttribute);
  355.                 if ($this->reader->getPropertyAttribute($property, Mapping\Id::class)) {
  356.                     $mapping['id'] = true;
  357.                 }
  359.                 $generatedValueAttribute = $this->reader->getPropertyAttribute($property, Mapping\GeneratedValue::class);
  361.                 if ($generatedValueAttribute !== null) {
  362.                     $metadata->setIdGeneratorType(constant('Doctrine\ORM\Mapping\ClassMetadata::GENERATOR_TYPE_' . $generatedValueAttribute->strategy));
  363.                 }
  365.                 if ($this->reader->getPropertyAttribute($property, Mapping\Version::class)) {
  366.                     $metadata->setVersionMapping($mapping);
  367.                 }
  369.                 $metadata->mapField($mapping);
  371.                 // Check for SequenceGenerator/TableGenerator definition
  372.                 $seqGeneratorAttribute    = $this->reader->getPropertyAttribute($property, Mapping\SequenceGenerator::class);
  373.                 $customGeneratorAttribute = $this->reader->getPropertyAttribute($property, Mapping\CustomIdGenerator::class);
  375.                 if ($seqGeneratorAttribute !== null) {
  376.                     $metadata->setSequenceGeneratorDefinition(
  377.                         [
  378.                             'sequenceName' => $seqGeneratorAttribute->sequenceName,
  379.                             'allocationSize' => $seqGeneratorAttribute->allocationSize,
  380.                             'initialValue' => $seqGeneratorAttribute->initialValue,
  381.                         ]
  382.                     );
  383.                 } elseif ($customGeneratorAttribute !== null) {
  384.                     $metadata->setCustomGeneratorDefinition(
  385.                         [
  386.                             'class' => $customGeneratorAttribute->class,
  387.                         ]
  388.                     );
  389.                 }
  390.             } elseif ($oneToOneAttribute !== null) {
  391.                 if ($this->reader->getPropertyAttribute($property, Mapping\Id::class)) {
  392.                     $mapping['id'] = true;
  393.                 }
  395.                 $mapping['targetEntity']  = $oneToOneAttribute->targetEntity;
  396.                 $mapping['joinColumns']   = $joinColumns;
  397.                 $mapping['mappedBy']      = $oneToOneAttribute->mappedBy;
  398.                 $mapping['inversedBy']    = $oneToOneAttribute->inversedBy;
  399.                 $mapping['cascade']       = $oneToOneAttribute->cascade;
  400.                 $mapping['orphanRemoval'] = $oneToOneAttribute->orphanRemoval;
  401.                 $mapping['fetch']         = $this->getFetchMode($className, $oneToOneAttribute->fetch);
  402.                 $metadata->mapOneToOne($mapping);
  403.             } elseif ($oneToManyAttribute !== null) {
  404.                 $mapping['mappedBy']      = $oneToManyAttribute->mappedBy;
  405.                 $mapping['targetEntity']  = $oneToManyAttribute->targetEntity;
  406.                 $mapping['cascade']       = $oneToManyAttribute->cascade;
  407.                 $mapping['indexBy']       = $oneToManyAttribute->indexBy;
  408.                 $mapping['orphanRemoval'] = $oneToManyAttribute->orphanRemoval;
  409.                 $mapping['fetch']         = $this->getFetchMode($className, $oneToManyAttribute->fetch);
  411.                 $orderByAttribute = $this->reader->getPropertyAttribute($property, Mapping\OrderBy::class);
  413.                 if ($orderByAttribute !== null) {
  414.                     $mapping['orderBy'] = $orderByAttribute->value;
  415.                 }
  417.                 $metadata->mapOneToMany($mapping);
  418.             } elseif ($manyToOneAttribute !== null) {
  419.                 $idAttribute = $this->reader->getPropertyAttribute($property, Mapping\Id::class);
  421.                 if ($idAttribute !== null) {
  422.                     $mapping['id'] = true;
  423.                 }
  425.                 $mapping['joinColumns']  = $joinColumns;
  426.                 $mapping['cascade']      = $manyToOneAttribute->cascade;
  427.                 $mapping['inversedBy']   = $manyToOneAttribute->inversedBy;
  428.                 $mapping['targetEntity'] = $manyToOneAttribute->targetEntity;
  429.                 $mapping['fetch']        = $this->getFetchMode($className, $manyToOneAttribute->fetch);
  430.                 $metadata->mapManyToOne($mapping);
  431.             } elseif ($manyToManyAttribute !== null) {
  432.                 $joinTable          = [];
  433.                 $joinTableAttribute = $this->reader->getPropertyAttribute($property, Mapping\JoinTable::class);
  435.                 if ($joinTableAttribute !== null) {
  436.                     $joinTable = [
  437.                         'name' => $joinTableAttribute->name,
  438.                         'schema' => $joinTableAttribute->schema,
  439.                     ];
  441.                     if ($joinTableAttribute->options) {
  442.                         $joinTable['options'] = $joinTableAttribute->options;
  443.                     }
  445.                     foreach ($joinTableAttribute->joinColumns as $joinColumn) {
  446.                         $joinTable['joinColumns'][] = $this->joinColumnToArray($joinColumn);
  447.                     }
  449.                     foreach ($joinTableAttribute->inverseJoinColumns as $joinColumn) {
  450.                         $joinTable['inverseJoinColumns'][] = $this->joinColumnToArray($joinColumn);
  451.                     }
  452.                 }
  454.                 foreach ($this->reader->getPropertyAttributeCollection($property, Mapping\JoinColumn::class) as $joinColumn) {
  455.                     $joinTable['joinColumns'][] = $this->joinColumnToArray($joinColumn);
  456.                 }
  458.                 foreach ($this->reader->getPropertyAttributeCollection($property, Mapping\InverseJoinColumn::class) as $joinColumn) {
  459.                     $joinTable['inverseJoinColumns'][] = $this->joinColumnToArray($joinColumn);
  460.                 }
  462.                 $mapping['joinTable']     = $joinTable;
  463.                 $mapping['targetEntity']  = $manyToManyAttribute->targetEntity;
  464.                 $mapping['mappedBy']      = $manyToManyAttribute->mappedBy;
  465.                 $mapping['inversedBy']    = $manyToManyAttribute->inversedBy;
  466.                 $mapping['cascade']       = $manyToManyAttribute->cascade;
  467.                 $mapping['indexBy']       = $manyToManyAttribute->indexBy;
  468.                 $mapping['orphanRemoval'] = $manyToManyAttribute->orphanRemoval;
  469.                 $mapping['fetch']         = $this->getFetchMode($className, $manyToManyAttribute->fetch);
  471.                 $orderByAttribute = $this->reader->getPropertyAttribute($property, Mapping\OrderBy::class);
  473.                 if ($orderByAttribute !== null) {
  474.                     $mapping['orderBy'] = $orderByAttribute->value;
  475.                 }
  477.                 $metadata->mapManyToMany($mapping);
  478.             } elseif ($embeddedAttribute !== null) {
  479.                 $mapping['class']        = $embeddedAttribute->class;
  480.                 $mapping['columnPrefix'] = $embeddedAttribute->columnPrefix;
  482.                 $metadata->mapEmbedded($mapping);
  483.             }
  484.         }
  486.         // Evaluate AssociationOverrides attribute
  487.         if (isset($classAttributes[Mapping\AssociationOverrides::class])) {
  488.             $associationOverride = $classAttributes[Mapping\AssociationOverrides::class];
  490.             foreach ($associationOverride->overrides as $associationOverride) {
  491.                 $override  = [];
  492.                 $fieldName = $associationOverride->name;
  494.                 // Check for JoinColumn/JoinColumns attributes
  495.                 if ($associationOverride->joinColumns) {
  496.                     $joinColumns = [];
  498.                     foreach ($associationOverride->joinColumns as $joinColumn) {
  499.                         $joinColumns[] = $this->joinColumnToArray($joinColumn);
  500.                     }
  502.                     $override['joinColumns'] = $joinColumns;
  503.                 }
  505.                 if ($associationOverride->inverseJoinColumns) {
  506.                     $joinColumns = [];
  508.                     foreach ($associationOverride->inverseJoinColumns as $joinColumn) {
  509.                         $joinColumns[] = $this->joinColumnToArray($joinColumn);
  510.                     }
  512.                     $override['inverseJoinColumns'] = $joinColumns;
  513.                 }
  515.                 // Check for JoinTable attributes
  516.                 if ($associationOverride->joinTable) {
  517.                     $joinTableAnnot = $associationOverride->joinTable;
  518.                     $joinTable      = [
  519.                         'name'      => $joinTableAnnot->name,
  520.                         'schema'    => $joinTableAnnot->schema,
  521.                         'joinColumns' => $override['joinColumns'] ?? [],
  522.                         'inverseJoinColumns' => $override['inverseJoinColumns'] ?? [],
  523.                     ];
  525.                     unset($override['joinColumns'], $override['inverseJoinColumns']);
  527.                     $override['joinTable'] = $joinTable;
  528.                 }
  530.                 // Check for inversedBy
  531.                 if ($associationOverride->inversedBy) {
  532.                     $override['inversedBy'] = $associationOverride->inversedBy;
  533.                 }
  535.                 // Check for `fetch`
  536.                 if ($associationOverride->fetch) {
  537.                     $override['fetch'] = constant(ClassMetadata::class . '::FETCH_' . $associationOverride->fetch);
  538.                 }
  540.                 $metadata->setAssociationOverride($fieldName, $override);
  541.             }
  542.         }
  544.         // Evaluate AttributeOverrides attribute
  545.         if (isset($classAttributes[Mapping\AttributeOverrides::class])) {
  546.             $attributeOverridesAnnot = $classAttributes[Mapping\AttributeOverrides::class];
  548.             foreach ($attributeOverridesAnnot->overrides as $attributeOverride) {
  549.                 $mapping = $this->columnToArray($attributeOverride->name, $attributeOverride->column);
  551.                 $metadata->setAttributeOverride($attributeOverride->name, $mapping);
  552.             }
  553.         }
  555.         // Evaluate EntityListeners attribute
  556.         if (isset($classAttributes[Mapping\EntityListeners::class])) {
  557.             $entityListenersAttribute = $classAttributes[Mapping\EntityListeners::class];
  559.             foreach ($entityListenersAttribute->value as $item) {
  560.                 $listenerClassName = $metadata->fullyQualifiedClassName($item);
  562.                 if (! class_exists($listenerClassName)) {
  563.                     throw MappingException::entityListenerClassNotFound($listenerClassName, $className);
  564.                 }
  566.                 $hasMapping    = false;
  567.                 $listenerClass = new ReflectionClass($listenerClassName);
  569.                 foreach ($listenerClass->getMethods(ReflectionMethod::IS_PUBLIC) as $method) {
  570.                     assert($method instanceof ReflectionMethod);
  571.                     // find method callbacks.
  572.                     $callbacks  = $this->getMethodCallbacks($method);
  573.                     $hasMapping = $hasMapping ?: ! empty($callbacks);
  575.                     foreach ($callbacks as $value) {
  576.                         $metadata->addEntityListener($value[1], $listenerClassName, $value[0]);
  577.                     }
  578.                 }
  580.                 // Evaluate the listener using naming convention.
  581.                 if (! $hasMapping) {
  582.                     EntityListenerBuilder::bindEntityListener($metadata, $listenerClassName);
  583.                 }
  584.             }
  585.         }
  587.         // Evaluate #[HasLifecycleCallbacks] attribute
  588.         if (isset($classAttributes[Mapping\HasLifecycleCallbacks::class])) {
  589.             foreach ($reflectionClass->getMethods(ReflectionMethod::IS_PUBLIC) as $method) {
  590.                 assert($method instanceof ReflectionMethod);
  591.                 foreach ($this->getMethodCallbacks($method) as $value) {
  592.                     $metadata->addLifecycleCallback($value[0], $value[1]);
  593.                 }
  594.             }
  595.         }
  596.     }
  598.     /**
  599.      * Attempts to resolve the fetch mode.
  600.      *
  601.      * @param class-string $className The class name.
  602.      * @param string       $fetchMode The fetch mode.
  603.      *
  604.      * @return ClassMetadata::FETCH_* The fetch mode as defined in ClassMetadata.
  605.      *
  606.      * @throws MappingException If the fetch mode is not valid.
  607.      */
  608.     private function getFetchMode(string $className, string $fetchMode): int
  609.     {
  610.         if (! defined('Doctrine\ORM\Mapping\ClassMetadata::FETCH_' . $fetchMode)) {
  611.             throw MappingException::invalidFetchMode($className, $fetchMode);
  612.         }
  614.         return constant('Doctrine\ORM\Mapping\ClassMetadata::FETCH_' . $fetchMode);
  615.     }
  617.     /**
  618.      * Attempts to resolve the generated mode.
  619.      *
  620.      * @throws MappingException If the fetch mode is not valid.
  621.      */
  622.     private function getGeneratedMode(string $generatedMode): int
  623.     {
  624.         if (! defined('Doctrine\ORM\Mapping\ClassMetadata::GENERATED_' . $generatedMode)) {
  625.             throw MappingException::invalidGeneratedMode($generatedMode);
  626.         }
  628.         return constant('Doctrine\ORM\Mapping\ClassMetadata::GENERATED_' . $generatedMode);
  629.     }
  631.     /**
  632.      * Parses the given method.
  633.      *
  634.      * @return list<array{string, string}>
  635.      * @psalm-return list<array{string, (Events::*)}>
  636.      */
  637.     private function getMethodCallbacks(ReflectionMethod $method): array
  638.     {
  639.         $callbacks  = [];
  640.         $attributes = $this->reader->getMethodAttributes($method);
  642.         foreach ($attributes as $attribute) {
  643.             if ($attribute instanceof Mapping\PrePersist) {
  644.                 $callbacks[] = [$method->name, Events::prePersist];
  645.             }
  647.             if ($attribute instanceof Mapping\PostPersist) {
  648.                 $callbacks[] = [$method->name, Events::postPersist];
  649.             }
  651.             if ($attribute instanceof Mapping\PreUpdate) {
  652.                 $callbacks[] = [$method->name, Events::preUpdate];
  653.             }
  655.             if ($attribute instanceof Mapping\PostUpdate) {
  656.                 $callbacks[] = [$method->name, Events::postUpdate];
  657.             }
  659.             if ($attribute instanceof Mapping\PreRemove) {
  660.                 $callbacks[] = [$method->name, Events::preRemove];
  661.             }
  663.             if ($attribute instanceof Mapping\PostRemove) {
  664.                 $callbacks[] = [$method->name, Events::postRemove];
  665.             }
  667.             if ($attribute instanceof Mapping\PostLoad) {
  668.                 $callbacks[] = [$method->name, Events::postLoad];
  669.             }
  671.             if ($attribute instanceof Mapping\PreFlush) {
  672.                 $callbacks[] = [$method->name, Events::preFlush];
  673.             }
  674.         }
  676.         return $callbacks;
  677.     }
  679.     /**
  680.      * Parse the given JoinColumn as array
  681.      *
  682.      * @param Mapping\JoinColumn|Mapping\InverseJoinColumn $joinColumn
  683.      *
  684.      * @return mixed[]
  685.      * @psalm-return array{
  686.      *                   name: string|null,
  687.      *                   unique: bool,
  688.      *                   nullable: bool,
  689.      *                   onDelete: mixed,
  690.      *                   columnDefinition: string|null,
  691.      *                   referencedColumnName: string,
  692.      *                   options?: array<string, mixed>
  693.      *               }
  694.      */
  695.     private function joinColumnToArray($joinColumn): array
  696.     {
  697.         $mapping = [
  698.             'name' => $joinColumn->name,
  699.             'unique' => $joinColumn->unique,
  700.             'nullable' => $joinColumn->nullable,
  701.             'onDelete' => $joinColumn->onDelete,
  702.             'columnDefinition' => $joinColumn->columnDefinition,
  703.             'referencedColumnName' => $joinColumn->referencedColumnName,
  704.         ];
  706.         if ($joinColumn->options) {
  707.             $mapping['options'] = $joinColumn->options;
  708.         }
  710.         return $mapping;
  711.     }
  713.     /**
  714.      * Parse the given Column as array
  715.      *
  716.      * @return mixed[]
  717.      * @psalm-return array{
  718.      *                   fieldName: string,
  719.      *                   type: mixed,
  720.      *                   scale: int,
  721.      *                   length: int,
  722.      *                   unique: bool,
  723.      *                   nullable: bool,
  724.      *                   precision: int,
  725.      *                   enumType?: class-string,
  726.      *                   options?: mixed[],
  727.      *                   columnName?: string,
  728.      *                   columnDefinition?: string
  729.      *               }
  730.      */
  731.     private function columnToArray(string $fieldName, Mapping\Column $column): array
  732.     {
  733.         $mapping = [
  734.             'fieldName' => $fieldName,
  735.             'type'      => $column->type,
  736.             'scale'     => $column->scale,
  737.             'length'    => $column->length,
  738.             'unique'    => $column->unique,
  739.             'nullable'  => $column->nullable,
  740.             'precision' => $column->precision,
  741.         ];
  743.         if ($column->options) {
  744.             $mapping['options'] = $column->options;
  745.         }
  747.         if (isset($column->name)) {
  748.             $mapping['columnName'] = $column->name;
  749.         }
  751.         if (isset($column->columnDefinition)) {
  752.             $mapping['columnDefinition'] = $column->columnDefinition;
  753.         }
  755.         if ($column->updatable === false) {
  756.             $mapping['notUpdatable'] = true;
  757.         }
  759.         if ($column->insertable === false) {
  760.             $mapping['notInsertable'] = true;
  761.         }
  763.         if ($column->generated !== null) {
  764.             $mapping['generated'] = $this->getGeneratedMode($column->generated);
  765.         }
  767.         if ($column->enumType) {
  768.             $mapping['enumType'] = $column->enumType;
  769.         }
  771.         return $mapping;
  772.     }
  773. }