vendor/doctrine/orm/lib/Doctrine/ORM/Mapping/Driver/AnnotationDriver.php line 39

Open in your IDE?
  1. <?php
  2. /*
  3.  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  4.  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  5.  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  6.  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  7.  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  8.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  9.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  10.  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  11.  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  12.  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  13.  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  14.  *
  15.  * This software consists of voluntary contributions made by many individuals
  16.  * and is licensed under the MIT license. For more information, see
  17.  * <http://www.doctrine-project.org>.
  18.  */
  20. namespace Doctrine\ORM\Mapping\Driver;
  22. use Doctrine\Common\Annotations\AnnotationReader;
  23. use Doctrine\Common\Persistence\Mapping\ClassMetadata;
  24. use Doctrine\Common\Persistence\Mapping\Driver\AnnotationDriver as AbstractAnnotationDriver;
  25. use Doctrine\ORM\Events;
  26. use Doctrine\ORM\Mapping;
  27. use Doctrine\ORM\Mapping\Builder\EntityListenerBuilder;
  28. use Doctrine\ORM\Mapping\MappingException;
  30. /**
  31.  * The AnnotationDriver reads the mapping metadata from docblock annotations.
  32.  *
  33.  * @since 2.0
  34.  * @author Benjamin Eberlei <kontakt@beberlei.de>
  35.  * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
  36.  * @author Jonathan H. Wage <jonwage@gmail.com>
  37.  * @author Roman Borschel <roman@code-factory.org>
  38.  */
  39. class AnnotationDriver extends AbstractAnnotationDriver
  40. {
  41.     /**
  42.      * {@inheritDoc}
  43.      */
  44.     protected $entityAnnotationClasses = [
  45.         Mapping\Entity::class => 1,
  46.         Mapping\MappedSuperclass::class => 2,
  47.     ];
  49.     /**
  50.      * {@inheritDoc}
  51.      */
  52.     public function loadMetadataForClass($className, ClassMetadata $metadata)
  53.     {
  54.         /* @var $metadata \Doctrine\ORM\Mapping\ClassMetadataInfo */
  55.         $class = $metadata->getReflectionClass();
  57.         if ( ! $class) {
  58.             // this happens when running annotation driver in combination with
  59.             // static reflection services. This is not the nicest fix
  60.             $class = new \ReflectionClass($metadata->name);
  61.         }
  63.         $classAnnotations = $this->reader->getClassAnnotations($class);
  65.         if ($classAnnotations) {
  66.             foreach ($classAnnotations as $key => $annot) {
  67.                 if ( ! is_numeric($key)) {
  68.                     continue;
  69.                 }
  71.                 $classAnnotations[get_class($annot)] = $annot;
  72.             }
  73.         }
  75.         // Evaluate Entity annotation
  76.         if (isset($classAnnotations[Mapping\Entity::class])) {
  77.             $entityAnnot = $classAnnotations[Mapping\Entity::class];
  78.             if ($entityAnnot->repositoryClass !== null) {
  79.                 $metadata->setCustomRepositoryClass($entityAnnot->repositoryClass);
  80.             }
  82.             if ($entityAnnot->readOnly) {
  83.                 $metadata->markReadOnly();
  84.             }
  85.         } else if (isset($classAnnotations[Mapping\MappedSuperclass::class])) {
  86.             $mappedSuperclassAnnot = $classAnnotations[Mapping\MappedSuperclass::class];
  88.             $metadata->setCustomRepositoryClass($mappedSuperclassAnnot->repositoryClass);
  89.             $metadata->isMappedSuperclass = true;
  90.         } else if (isset($classAnnotations[Mapping\Embeddable::class])) {
  91.             $metadata->isEmbeddedClass = true;
  92.         } else {
  93.             throw MappingException::classIsNotAValidEntityOrMappedSuperClass($className);
  94.         }
  96.         // Evaluate Table annotation
  97.         if (isset($classAnnotations[Mapping\Table::class])) {
  98.             $tableAnnot   = $classAnnotations[Mapping\Table::class];
  99.             $primaryTable = [
  100.                 'name'   => $tableAnnot->name,
  101.                 'schema' => $tableAnnot->schema
  102.             ];
  104.             if ($tableAnnot->indexes !== null) {
  105.                 foreach ($tableAnnot->indexes as $indexAnnot) {
  106.                     $index = ['columns' => $indexAnnot->columns];
  108.                     if ( ! empty($indexAnnot->flags)) {
  109.                         $index['flags'] = $indexAnnot->flags;
  110.                     }
  112.                     if ( ! empty($indexAnnot->options)) {
  113.                         $index['options'] = $indexAnnot->options;
  114.                     }
  116.                     if ( ! empty($indexAnnot->name)) {
  117.                         $primaryTable['indexes'][$indexAnnot->name] = $index;
  118.                     } else {
  119.                         $primaryTable['indexes'][] = $index;
  120.                     }
  121.                 }
  122.             }
  124.             if ($tableAnnot->uniqueConstraints !== null) {
  125.                 foreach ($tableAnnot->uniqueConstraints as $uniqueConstraintAnnot) {
  126.                     $uniqueConstraint = ['columns' => $uniqueConstraintAnnot->columns];
  128.                     if ( ! empty($uniqueConstraintAnnot->options)) {
  129.                         $uniqueConstraint['options'] = $uniqueConstraintAnnot->options;
  130.                     }
  132.                     if ( ! empty($uniqueConstraintAnnot->name)) {
  133.                         $primaryTable['uniqueConstraints'][$uniqueConstraintAnnot->name] = $uniqueConstraint;
  134.                     } else {
  135.                         $primaryTable['uniqueConstraints'][] = $uniqueConstraint;
  136.                     }
  137.                 }
  138.             }
  140.             if ($tableAnnot->options) {
  141.                 $primaryTable['options'] = $tableAnnot->options;
  142.             }
  144.             $metadata->setPrimaryTable($primaryTable);
  145.         }
  147.         // Evaluate @Cache annotation
  148.         if (isset($classAnnotations[Mapping\Cache::class])) {
  149.             $cacheAnnot = $classAnnotations[Mapping\Cache::class];
  150.             $cacheMap   = [
  151.                 'region' => $cacheAnnot->region,
  152.                 'usage'  => constant('Doctrine\ORM\Mapping\ClassMetadata::CACHE_USAGE_' . $cacheAnnot->usage),
  153.             ];
  155.             $metadata->enableCache($cacheMap);
  156.         }
  158.         // Evaluate NamedNativeQueries annotation
  159.         if (isset($classAnnotations[Mapping\NamedNativeQueries::class])) {
  160.             $namedNativeQueriesAnnot = $classAnnotations[Mapping\NamedNativeQueries::class];
  162.             foreach ($namedNativeQueriesAnnot->value as $namedNativeQuery) {
  163.                 $metadata->addNamedNativeQuery(
  164.                     [
  165.                         'name'              => $namedNativeQuery->name,
  166.                         'query'             => $namedNativeQuery->query,
  167.                         'resultClass'       => $namedNativeQuery->resultClass,
  168.                         'resultSetMapping'  => $namedNativeQuery->resultSetMapping,
  169.                     ]
  170.                 );
  171.             }
  172.         }
  174.         // Evaluate SqlResultSetMappings annotation
  175.         if (isset($classAnnotations[Mapping\SqlResultSetMappings::class])) {
  176.             $sqlResultSetMappingsAnnot = $classAnnotations[Mapping\SqlResultSetMappings::class];
  178.             foreach ($sqlResultSetMappingsAnnot->value as $resultSetMapping) {
  179.                 $entities = [];
  180.                 $columns  = [];
  181.                 foreach ($resultSetMapping->entities as $entityResultAnnot) {
  182.                     $entityResult = [
  183.                         'fields'                => [],
  184.                         'entityClass'           => $entityResultAnnot->entityClass,
  185.                         'discriminatorColumn'   => $entityResultAnnot->discriminatorColumn,
  186.                     ];
  188.                     foreach ($entityResultAnnot->fields as $fieldResultAnnot) {
  189.                         $entityResult['fields'][] = [
  190.                             'name'      => $fieldResultAnnot->name,
  191.                             'column'    => $fieldResultAnnot->column
  192.                         ];
  193.                     }
  195.                     $entities[] = $entityResult;
  196.                 }
  198.                 foreach ($resultSetMapping->columns as $columnResultAnnot) {
  199.                     $columns[] = [
  200.                         'name' => $columnResultAnnot->name,
  201.                     ];
  202.                 }
  204.                 $metadata->addSqlResultSetMapping(
  205.                     [
  206.                         'name'          => $resultSetMapping->name,
  207.                         'entities'      => $entities,
  208.                         'columns'       => $columns
  209.                     ]
  210.                 );
  211.             }
  212.         }
  214.         // Evaluate NamedQueries annotation
  215.         if (isset($classAnnotations[Mapping\NamedQueries::class])) {
  216.             $namedQueriesAnnot = $classAnnotations[Mapping\NamedQueries::class];
  218.             if ( ! is_array($namedQueriesAnnot->value)) {
  219.                 throw new \UnexpectedValueException("@NamedQueries should contain an array of @NamedQuery annotations.");
  220.             }
  222.             foreach ($namedQueriesAnnot->value as $namedQuery) {
  223.                 if ( ! ($namedQuery instanceof Mapping\NamedQuery)) {
  224.                     throw new \UnexpectedValueException("@NamedQueries should contain an array of @NamedQuery annotations.");
  225.                 }
  226.                 $metadata->addNamedQuery(
  227.                     [
  228.                         'name'  => $namedQuery->name,
  229.                         'query' => $namedQuery->query
  230.                     ]
  231.                 );
  232.             }
  233.         }
  235.         // Evaluate InheritanceType annotation
  236.         if (isset($classAnnotations[Mapping\InheritanceType::class])) {
  237.             $inheritanceTypeAnnot = $classAnnotations[Mapping\InheritanceType::class];
  239.             $metadata->setInheritanceType(
  240.                 constant('Doctrine\ORM\Mapping\ClassMetadata::INHERITANCE_TYPE_' . $inheritanceTypeAnnot->value)
  241.             );
  243.             if ($metadata->inheritanceType != Mapping\ClassMetadata::INHERITANCE_TYPE_NONE) {
  244.                 // Evaluate DiscriminatorColumn annotation
  245.                 if (isset($classAnnotations[Mapping\DiscriminatorColumn::class])) {
  246.                     $discrColumnAnnot = $classAnnotations[Mapping\DiscriminatorColumn::class];
  248.                     $metadata->setDiscriminatorColumn(
  249.                         [
  250.                             'name'             => $discrColumnAnnot->name,
  251.                             'type'             => $discrColumnAnnot->type ?: 'string',
  252.                             'length'           => $discrColumnAnnot->length ?: 255,
  253.                             'columnDefinition' => $discrColumnAnnot->columnDefinition,
  254.                         ]
  255.                     );
  256.                 } else {
  257.                     $metadata->setDiscriminatorColumn(['name' => 'dtype', 'type' => 'string', 'length' => 255]);
  258.                 }
  260.                 // Evaluate DiscriminatorMap annotation
  261.                 if (isset($classAnnotations[Mapping\DiscriminatorMap::class])) {
  262.                     $discrMapAnnot = $classAnnotations[Mapping\DiscriminatorMap::class];
  263.                     $metadata->setDiscriminatorMap($discrMapAnnot->value);
  264.                 }
  265.             }
  266.         }
  269.         // Evaluate DoctrineChangeTrackingPolicy annotation
  270.         if (isset($classAnnotations[Mapping\ChangeTrackingPolicy::class])) {
  271.             $changeTrackingAnnot = $classAnnotations[Mapping\ChangeTrackingPolicy::class];
  272.             $metadata->setChangeTrackingPolicy(constant('Doctrine\ORM\Mapping\ClassMetadata::CHANGETRACKING_' . $changeTrackingAnnot->value));
  273.         }
  275.         // Evaluate annotations on properties/fields
  276.         /* @var $property \ReflectionProperty */
  277.         foreach ($class->getProperties() as $property) {
  278.             if ($metadata->isMappedSuperclass && ! $property->isPrivate()
  279.                 ||
  280.                 $metadata->isInheritedField($property->name)
  281.                 ||
  282.                 $metadata->isInheritedAssociation($property->name)
  283.                 ||
  284.                 $metadata->isInheritedEmbeddedClass($property->name)) {
  285.                 continue;
  286.             }
  288.             $mapping = [];
  289.             $mapping['fieldName'] = $property->getName();
  291.             // Evaluate @Cache annotation
  292.             if (($cacheAnnot = $this->reader->getPropertyAnnotation($property, Mapping\Cache::class)) !== null) {
  293.                 $mapping['cache'] = $metadata->getAssociationCacheDefaults(
  294.                     $mapping['fieldName'],
  295.                     [
  296.                         'usage'  => constant('Doctrine\ORM\Mapping\ClassMetadata::CACHE_USAGE_' . $cacheAnnot->usage),
  297.                         'region' => $cacheAnnot->region,
  298.                     ]
  299.                 );
  300.             }
  301.             // Check for JoinColumn/JoinColumns annotations
  302.             $joinColumns = [];
  304.             if ($joinColumnAnnot = $this->reader->getPropertyAnnotation($property, Mapping\JoinColumn::class)) {
  305.                 $joinColumns[] = $this->joinColumnToArray($joinColumnAnnot);
  306.             } else if ($joinColumnsAnnot = $this->reader->getPropertyAnnotation($property, Mapping\JoinColumns::class)) {
  307.                 foreach ($joinColumnsAnnot->value as $joinColumn) {
  308.                     $joinColumns[] = $this->joinColumnToArray($joinColumn);
  309.                 }
  310.             }
  312.             // Field can only be annotated with one of:
  313.             // @Column, @OneToOne, @OneToMany, @ManyToOne, @ManyToMany
  314.             if ($columnAnnot = $this->reader->getPropertyAnnotation($property, Mapping\Column::class)) {
  315.                 if ($columnAnnot->type == null) {
  316.                     throw MappingException::propertyTypeIsRequired($className, $property->getName());
  317.                 }
  319.                 $mapping = $this->columnToArray($property->getName(), $columnAnnot);
  321.                 if ($idAnnot = $this->reader->getPropertyAnnotation($property, Mapping\Id::class)) {
  322.                     $mapping['id'] = true;
  323.                 }
  325.                 if ($generatedValueAnnot = $this->reader->getPropertyAnnotation($property, Mapping\GeneratedValue::class)) {
  326.                     $metadata->setIdGeneratorType(constant('Doctrine\ORM\Mapping\ClassMetadata::GENERATOR_TYPE_' . $generatedValueAnnot->strategy));
  327.                 }
  329.                 if ($this->reader->getPropertyAnnotation($property, Mapping\Version::class)) {
  330.                     $metadata->setVersionMapping($mapping);
  331.                 }
  333.                 $metadata->mapField($mapping);
  335.                 // Check for SequenceGenerator/TableGenerator definition
  336.                 if ($seqGeneratorAnnot = $this->reader->getPropertyAnnotation($property, Mapping\SequenceGenerator::class)) {
  337.                     $metadata->setSequenceGeneratorDefinition(
  338.                         [
  339.                             'sequenceName' => $seqGeneratorAnnot->sequenceName,
  340.                             'allocationSize' => $seqGeneratorAnnot->allocationSize,
  341.                             'initialValue' => $seqGeneratorAnnot->initialValue
  342.                         ]
  343.                     );
  344.                 } else if ($this->reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\TableGenerator')) {
  345.                     throw MappingException::tableIdGeneratorNotImplemented($className);
  346.                 } else if ($customGeneratorAnnot = $this->reader->getPropertyAnnotation($property, Mapping\CustomIdGenerator::class)) {
  347.                     $metadata->setCustomGeneratorDefinition(
  348.                         [
  349.                             'class' => $customGeneratorAnnot->class
  350.                         ]
  351.                     );
  352.                 }
  353.             } else if ($oneToOneAnnot = $this->reader->getPropertyAnnotation($property, Mapping\OneToOne::class)) {
  354.                 if ($idAnnot = $this->reader->getPropertyAnnotation($property, Mapping\Id::class)) {
  355.                     $mapping['id'] = true;
  356.                 }
  358.                 $mapping['targetEntity'] = $oneToOneAnnot->targetEntity;
  359.                 $mapping['joinColumns'] = $joinColumns;
  360.                 $mapping['mappedBy'] = $oneToOneAnnot->mappedBy;
  361.                 $mapping['inversedBy'] = $oneToOneAnnot->inversedBy;
  362.                 $mapping['cascade'] = $oneToOneAnnot->cascade;
  363.                 $mapping['orphanRemoval'] = $oneToOneAnnot->orphanRemoval;
  364.                 $mapping['fetch'] = $this->getFetchMode($className, $oneToOneAnnot->fetch);
  365.                 $metadata->mapOneToOne($mapping);
  366.             } else if ($oneToManyAnnot = $this->reader->getPropertyAnnotation($property, Mapping\OneToMany::class)) {
  367.                 $mapping['mappedBy'] = $oneToManyAnnot->mappedBy;
  368.                 $mapping['targetEntity'] = $oneToManyAnnot->targetEntity;
  369.                 $mapping['cascade'] = $oneToManyAnnot->cascade;
  370.                 $mapping['indexBy'] = $oneToManyAnnot->indexBy;
  371.                 $mapping['orphanRemoval'] = $oneToManyAnnot->orphanRemoval;
  372.                 $mapping['fetch'] = $this->getFetchMode($className, $oneToManyAnnot->fetch);
  374.                 if ($orderByAnnot = $this->reader->getPropertyAnnotation($property, Mapping\OrderBy::class)) {
  375.                     $mapping['orderBy'] = $orderByAnnot->value;
  376.                 }
  378.                 $metadata->mapOneToMany($mapping);
  379.             } else if ($manyToOneAnnot = $this->reader->getPropertyAnnotation($property, Mapping\ManyToOne::class)) {
  380.                 if ($idAnnot = $this->reader->getPropertyAnnotation($property, Mapping\Id::class)) {
  381.                     $mapping['id'] = true;
  382.                 }
  384.                 $mapping['joinColumns'] = $joinColumns;
  385.                 $mapping['cascade'] = $manyToOneAnnot->cascade;
  386.                 $mapping['inversedBy'] = $manyToOneAnnot->inversedBy;
  387.                 $mapping['targetEntity'] = $manyToOneAnnot->targetEntity;
  388.                 $mapping['fetch'] = $this->getFetchMode($className, $manyToOneAnnot->fetch);
  389.                 $metadata->mapManyToOne($mapping);
  390.             } else if ($manyToManyAnnot = $this->reader->getPropertyAnnotation($property, Mapping\ManyToMany::class)) {
  391.                 $joinTable = [];
  393.                 if ($joinTableAnnot = $this->reader->getPropertyAnnotation($property, Mapping\JoinTable::class)) {
  394.                     $joinTable = [
  395.                         'name' => $joinTableAnnot->name,
  396.                         'schema' => $joinTableAnnot->schema
  397.                     ];
  399.                     foreach ($joinTableAnnot->joinColumns as $joinColumn) {
  400.                         $joinTable['joinColumns'][] = $this->joinColumnToArray($joinColumn);
  401.                     }
  403.                     foreach ($joinTableAnnot->inverseJoinColumns as $joinColumn) {
  404.                         $joinTable['inverseJoinColumns'][] = $this->joinColumnToArray($joinColumn);
  405.                     }
  406.                 }
  408.                 $mapping['joinTable'] = $joinTable;
  409.                 $mapping['targetEntity'] = $manyToManyAnnot->targetEntity;
  410.                 $mapping['mappedBy'] = $manyToManyAnnot->mappedBy;
  411.                 $mapping['inversedBy'] = $manyToManyAnnot->inversedBy;
  412.                 $mapping['cascade'] = $manyToManyAnnot->cascade;
  413.                 $mapping['indexBy'] = $manyToManyAnnot->indexBy;
  414.                 $mapping['orphanRemoval'] = $manyToManyAnnot->orphanRemoval;
  415.                 $mapping['fetch'] = $this->getFetchMode($className, $manyToManyAnnot->fetch);
  417.                 if ($orderByAnnot = $this->reader->getPropertyAnnotation($property, Mapping\OrderBy::class)) {
  418.                     $mapping['orderBy'] = $orderByAnnot->value;
  419.                 }
  421.                 $metadata->mapManyToMany($mapping);
  422.             } else if ($embeddedAnnot = $this->reader->getPropertyAnnotation($property, Mapping\Embedded::class)) {
  423.                 $mapping['class'] = $embeddedAnnot->class;
  424.                 $mapping['columnPrefix'] = $embeddedAnnot->columnPrefix;
  426.                 $metadata->mapEmbedded($mapping);
  427.             }
  428.         }
  430.         // Evaluate AssociationOverrides annotation
  431.         if (isset($classAnnotations[Mapping\AssociationOverrides::class])) {
  432.             $associationOverridesAnnot = $classAnnotations[Mapping\AssociationOverrides::class];
  434.             foreach ($associationOverridesAnnot->value as $associationOverride) {
  435.                 $override   = [];
  436.                 $fieldName  = $associationOverride->name;
  438.                 // Check for JoinColumn/JoinColumns annotations
  439.                 if ($associationOverride->joinColumns) {
  440.                     $joinColumns = [];
  442.                     foreach ($associationOverride->joinColumns as $joinColumn) {
  443.                         $joinColumns[] = $this->joinColumnToArray($joinColumn);
  444.                     }
  446.                     $override['joinColumns'] = $joinColumns;
  447.                 }
  449.                 // Check for JoinTable annotations
  450.                 if ($associationOverride->joinTable) {
  451.                     $joinTableAnnot = $associationOverride->joinTable;
  452.                     $joinTable      = [
  453.                         'name'      => $joinTableAnnot->name,
  454.                         'schema'    => $joinTableAnnot->schema
  455.                     ];
  457.                     foreach ($joinTableAnnot->joinColumns as $joinColumn) {
  458.                         $joinTable['joinColumns'][] = $this->joinColumnToArray($joinColumn);
  459.                     }
  461.                     foreach ($joinTableAnnot->inverseJoinColumns as $joinColumn) {
  462.                         $joinTable['inverseJoinColumns'][] = $this->joinColumnToArray($joinColumn);
  463.                     }
  465.                     $override['joinTable'] = $joinTable;
  466.                 }
  468.                 // Check for inversedBy
  469.                 if ($associationOverride->inversedBy) {
  470.                     $override['inversedBy'] = $associationOverride->inversedBy;
  471.                 }
  473.                 // Check for `fetch`
  474.                 if ($associationOverride->fetch) {
  475.                     $override['fetch'] = constant(Mapping\ClassMetadata::class . '::FETCH_' . $associationOverride->fetch);
  476.                 }
  478.                 $metadata->setAssociationOverride($fieldName, $override);
  479.             }
  480.         }
  482.         // Evaluate AttributeOverrides annotation
  483.         if (isset($classAnnotations[Mapping\AttributeOverrides::class])) {
  484.             $attributeOverridesAnnot = $classAnnotations[Mapping\AttributeOverrides::class];
  486.             foreach ($attributeOverridesAnnot->value as $attributeOverrideAnnot) {
  487.                 $attributeOverride = $this->columnToArray($attributeOverrideAnnot->name, $attributeOverrideAnnot->column);
  489.                 $metadata->setAttributeOverride($attributeOverrideAnnot->name, $attributeOverride);
  490.             }
  491.         }
  493.         // Evaluate EntityListeners annotation
  494.         if (isset($classAnnotations[Mapping\EntityListeners::class])) {
  495.             $entityListenersAnnot = $classAnnotations[Mapping\EntityListeners::class];
  497.             foreach ($entityListenersAnnot->value as $item) {
  498.                 $listenerClassName = $metadata->fullyQualifiedClassName($item);
  500.                 if ( ! class_exists($listenerClassName)) {
  501.                     throw MappingException::entityListenerClassNotFound($listenerClassName, $className);
  502.                 }
  504.                 $hasMapping     = false;
  505.                 $listenerClass  = new \ReflectionClass($listenerClassName);
  507.                 /* @var $method \ReflectionMethod */
  508.                 foreach ($listenerClass->getMethods(\ReflectionMethod::IS_PUBLIC) as $method) {
  509.                     // find method callbacks.
  510.                     $callbacks  = $this->getMethodCallbacks($method);
  511.                     $hasMapping = $hasMapping ?: ( ! empty($callbacks));
  513.                     foreach ($callbacks as $value) {
  514.                         $metadata->addEntityListener($value[1], $listenerClassName, $value[0]);
  515.                     }
  516.                 }
  518.                 // Evaluate the listener using naming convention.
  519.                 if ( ! $hasMapping ) {
  520.                     EntityListenerBuilder::bindEntityListener($metadata, $listenerClassName);
  521.                 }
  522.             }
  523.         }
  525.         // Evaluate @HasLifecycleCallbacks annotation
  526.         if (isset($classAnnotations[Mapping\HasLifecycleCallbacks::class])) {
  527.             /* @var $method \ReflectionMethod */
  528.             foreach ($class->getMethods(\ReflectionMethod::IS_PUBLIC) as $method) {
  529.                 foreach ($this->getMethodCallbacks($method) as $value) {
  530.                     $metadata->addLifecycleCallback($value[0], $value[1]);
  531.                 }
  532.             }
  533.         }
  534.     }
  536.     /**
  537.      * Attempts to resolve the fetch mode.
  538.      *
  539.      * @param string $className The class name.
  540.      * @param string $fetchMode The fetch mode.
  541.      *
  542.      * @return integer The fetch mode as defined in ClassMetadata.
  543.      *
  544.      * @throws MappingException If the fetch mode is not valid.
  545.      */
  546.     private function getFetchMode($className, $fetchMode)
  547.     {
  548.         if ( ! defined('Doctrine\ORM\Mapping\ClassMetadata::FETCH_' . $fetchMode)) {
  549.             throw MappingException::invalidFetchMode($className, $fetchMode);
  550.         }
  552.         return constant('Doctrine\ORM\Mapping\ClassMetadata::FETCH_' . $fetchMode);
  553.     }
  555.     /**
  556.      * Parses the given method.
  557.      *
  558.      * @param \ReflectionMethod $method
  559.      *
  560.      * @return array
  561.      */
  562.     private function getMethodCallbacks(\ReflectionMethod $method)
  563.     {
  564.         $callbacks   = [];
  565.         $annotations = $this->reader->getMethodAnnotations($method);
  567.         foreach ($annotations as $annot) {
  568.             if ($annot instanceof Mapping\PrePersist) {
  569.                 $callbacks[] = [$method->name, Events::prePersist];
  570.             }
  572.             if ($annot instanceof Mapping\PostPersist) {
  573.                 $callbacks[] = [$method->name, Events::postPersist];
  574.             }
  576.             if ($annot instanceof Mapping\PreUpdate) {
  577.                 $callbacks[] = [$method->name, Events::preUpdate];
  578.             }
  580.             if ($annot instanceof Mapping\PostUpdate) {
  581.                 $callbacks[] = [$method->name, Events::postUpdate];
  582.             }
  584.             if ($annot instanceof Mapping\PreRemove) {
  585.                 $callbacks[] = [$method->name, Events::preRemove];
  586.             }
  588.             if ($annot instanceof Mapping\PostRemove) {
  589.                 $callbacks[] = [$method->name, Events::postRemove];
  590.             }
  592.             if ($annot instanceof Mapping\PostLoad) {
  593.                 $callbacks[] = [$method->name, Events::postLoad];
  594.             }
  596.             if ($annot instanceof Mapping\PreFlush) {
  597.                 $callbacks[] = [$method->name, Events::preFlush];
  598.             }
  599.         }
  601.         return $callbacks;
  602.     }
  604.     /**
  605.      * Parse the given JoinColumn as array
  606.      *
  607.      * @param Mapping\JoinColumn $joinColumn
  608.      * @return array
  609.      */
  610.     private function joinColumnToArray(Mapping\JoinColumn $joinColumn)
  611.     {
  612.         return [
  613.             'name' => $joinColumn->name,
  614.             'unique' => $joinColumn->unique,
  615.             'nullable' => $joinColumn->nullable,
  616.             'onDelete' => $joinColumn->onDelete,
  617.             'columnDefinition' => $joinColumn->columnDefinition,
  618.             'referencedColumnName' => $joinColumn->referencedColumnName,
  619.         ];
  620.     }
  622.     /**
  623.      * Parse the given Column as array
  624.      *
  625.      * @param string $fieldName
  626.      * @param Mapping\Column $column
  627.      *
  628.      * @return array
  629.      */
  630.     private function columnToArray($fieldName, Mapping\Column $column)
  631.     {
  632.         $mapping = [
  633.             'fieldName' => $fieldName,
  634.             'type'      => $column->type,
  635.             'scale'     => $column->scale,
  636.             'length'    => $column->length,
  637.             'unique'    => $column->unique,
  638.             'nullable'  => $column->nullable,
  639.             'precision' => $column->precision
  640.         ];
  642.         if ($column->options) {
  643.             $mapping['options'] = $column->options;
  644.         }
  646.         if (isset($column->name)) {
  647.             $mapping['columnName'] = $column->name;
  648.         }
  650.         if (isset($column->columnDefinition)) {
  651.             $mapping['columnDefinition'] = $column->columnDefinition;
  652.         }
  654.         return $mapping;
  655.     }
  657.     /**
  658.      * Factory method for the Annotation Driver.
  659.      *
  660.      * @param array|string          $paths
  661.      * @param AnnotationReader|null $reader
  662.      *
  663.      * @return AnnotationDriver
  664.      */
  665.     static public function create($paths = [], AnnotationReader $reader = null)
  666.     {
  667.         if ($reader == null) {
  668.             $reader = new AnnotationReader();
  669.         }
  671.         return new self($reader, $paths);
  672.     }
  673. }