vendor/doctrine/orm/lib/Doctrine/ORM/Mapping/Driver/YamlDriver.php line 53

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\ORM\Mapping\Builder\EntityListenerBuilder;
  23. use Doctrine\ORM\Mapping\ClassMetadata as Metadata;
  24. use Doctrine\ORM\Mapping\MappingException;
  25. use Doctrine\Persistence\Mapping\ClassMetadata;
  26. use Doctrine\Persistence\Mapping\Driver\FileDriver;
  27. use Symfony\Component\Yaml\Yaml;
  28. use function interface_exists;
  29. use function trigger_error;
  31. /**
  32.  * The YamlDriver reads the mapping metadata from yaml schema files.
  33.  *
  34.  * @since 2.0
  35.  * @author Benjamin Eberlei <[email protected]>
  36.  * @author Guilherme Blanco <[email protected]>
  37.  * @author Jonathan H. Wage <[email protected]>
  38.  * @author Roman Borschel <[email protected]>
  39.  *
  40.  * @deprecated 2.7 This class is being removed from the ORM and won't have any replacement
  41.  */
  42. class YamlDriver extends FileDriver
  43. {
  44.     const DEFAULT_FILE_EXTENSION = '.dcm.yml';
  46.     /**
  47.      * {@inheritDoc}
  48.      */
  49.     public function __construct($locator, $fileExtension = self::DEFAULT_FILE_EXTENSION)
  50.     {
  51.         @trigger_error(
  52.             'YAML mapping driver is deprecated and will be removed in Doctrine ORM 3.0, please migrate to annotation or XML driver.',
  53.             E_USER_DEPRECATED
  54.         );
  56.         parent::__construct($locator, $fileExtension);
  57.     }
  59.     /**
  60.      * {@inheritDoc}
  61.      */
  62.     public function loadMetadataForClass($className, ClassMetadata $metadata)
  63.     {
  64.         /* @var $metadata \Doctrine\ORM\Mapping\ClassMetadataInfo */
  65.         $element = $this->getElement($className);
  67.         if ($element['type'] == 'entity') {
  68.             if (isset($element['repositoryClass'])) {
  69.                 $metadata->setCustomRepositoryClass($element['repositoryClass']);
  70.             }
  71.             if (isset($element['readOnly']) && $element['readOnly'] == true) {
  72.                 $metadata->markReadOnly();
  73.             }
  74.         } else if ($element['type'] == 'mappedSuperclass') {
  75.             $metadata->setCustomRepositoryClass(
  76.                 $element['repositoryClass'] ?? null
  77.             );
  78.             $metadata->isMappedSuperclass = true;
  79.         } else if ($element['type'] == 'embeddable') {
  80.             $metadata->isEmbeddedClass = true;
  81.         } else {
  82.             throw MappingException::classIsNotAValidEntityOrMappedSuperClass($className);
  83.         }
  85.         // Evaluate root level properties
  86.         $primaryTable = [];
  88.         if (isset($element['table'])) {
  89.             $primaryTable['name'] = $element['table'];
  90.         }
  92.         if (isset($element['schema'])) {
  93.             $primaryTable['schema'] = $element['schema'];
  94.         }
  96.         // Evaluate second level cache
  97.         if (isset($element['cache'])) {
  98.             $metadata->enableCache($this->cacheToArray($element['cache']));
  99.         }
  101.         $metadata->setPrimaryTable($primaryTable);
  103.         // Evaluate named queries
  104.         if (isset($element['namedQueries'])) {
  105.             foreach ($element['namedQueries'] as $name => $queryMapping) {
  106.                 if (is_string($queryMapping)) {
  107.                     $queryMapping = ['query' => $queryMapping];
  108.                 }
  110.                 if ( ! isset($queryMapping['name'])) {
  111.                     $queryMapping['name'] = $name;
  112.                 }
  114.                 $metadata->addNamedQuery($queryMapping);
  115.             }
  116.         }
  118.         // Evaluate named native queries
  119.         if (isset($element['namedNativeQueries'])) {
  120.             foreach ($element['namedNativeQueries'] as $name => $mappingElement) {
  121.                 if (!isset($mappingElement['name'])) {
  122.                     $mappingElement['name'] = $name;
  123.                 }
  124.                 $metadata->addNamedNativeQuery(
  125.                     [
  126.                         'name'              => $mappingElement['name'],
  127.                         'query'             => $mappingElement['query'] ?? null,
  128.                         'resultClass'       => $mappingElement['resultClass'] ?? null,
  129.                         'resultSetMapping'  => $mappingElement['resultSetMapping'] ?? null,
  130.                     ]
  131.                 );
  132.             }
  133.         }
  135.         // Evaluate sql result set mappings
  136.         if (isset($element['sqlResultSetMappings'])) {
  137.             foreach ($element['sqlResultSetMappings'] as $name => $resultSetMapping) {
  138.                 if (!isset($resultSetMapping['name'])) {
  139.                     $resultSetMapping['name'] = $name;
  140.                 }
  142.                 $entities = [];
  143.                 $columns  = [];
  144.                 if (isset($resultSetMapping['entityResult'])) {
  145.                     foreach ($resultSetMapping['entityResult'] as $entityResultElement) {
  146.                         $entityResult = [
  147.                             'fields'                => [],
  148.                             'entityClass'           => $entityResultElement['entityClass'] ?? null,
  149.                             'discriminatorColumn'   => $entityResultElement['discriminatorColumn'] ?? null,
  150.                         ];
  152.                         if (isset($entityResultElement['fieldResult'])) {
  153.                             foreach ($entityResultElement['fieldResult'] as $fieldResultElement) {
  154.                                 $entityResult['fields'][] = [
  155.                                     'name'      => $fieldResultElement['name'] ?? null,
  156.                                     'column'    => $fieldResultElement['column'] ?? null,
  157.                                 ];
  158.                             }
  159.                         }
  161.                         $entities[] = $entityResult;
  162.                     }
  163.                 }
  166.                 if (isset($resultSetMapping['columnResult'])) {
  167.                     foreach ($resultSetMapping['columnResult'] as $columnResultAnnot) {
  168.                         $columns[] = [
  169.                             'name' => $columnResultAnnot['name'] ?? null,
  170.                         ];
  171.                     }
  172.                 }
  174.                 $metadata->addSqlResultSetMapping(
  175.                     [
  176.                         'name'          => $resultSetMapping['name'],
  177.                         'entities'      => $entities,
  178.                         'columns'       => $columns
  179.                     ]
  180.                 );
  181.             }
  182.         }
  184.         if (isset($element['inheritanceType'])) {
  185.             $metadata->setInheritanceType(constant('Doctrine\ORM\Mapping\ClassMetadata::INHERITANCE_TYPE_' . strtoupper($element['inheritanceType'])));
  187.             if ($metadata->inheritanceType != Metadata::INHERITANCE_TYPE_NONE) {
  188.                 // Evaluate discriminatorColumn
  189.                 if (isset($element['discriminatorColumn'])) {
  190.                     $discrColumn = $element['discriminatorColumn'];
  191.                     $metadata->setDiscriminatorColumn(
  192.                         [
  193.                             'name' => isset($discrColumn['name']) ? (string) $discrColumn['name'] : null,
  194.                             'type' => isset($discrColumn['type']) ? (string) $discrColumn['type'] : 'string',
  195.                             'length' => isset($discrColumn['length']) ? (string) $discrColumn['length'] : 255,
  196.                             'columnDefinition' => isset($discrColumn['columnDefinition']) ? (string) $discrColumn['columnDefinition'] : null
  197.                         ]
  198.                     );
  199.                 } else {
  200.                     $metadata->setDiscriminatorColumn(['name' => 'dtype', 'type' => 'string', 'length' => 255]);
  201.                 }
  203.                 // Evaluate discriminatorMap
  204.                 if (isset($element['discriminatorMap'])) {
  205.                     $metadata->setDiscriminatorMap($element['discriminatorMap']);
  206.                 }
  207.             }
  208.         }
  211.         // Evaluate changeTrackingPolicy
  212.         if (isset($element['changeTrackingPolicy'])) {
  213.             $metadata->setChangeTrackingPolicy(constant('Doctrine\ORM\Mapping\ClassMetadata::CHANGETRACKING_'
  214.                 . strtoupper($element['changeTrackingPolicy'])));
  215.         }
  217.         // Evaluate indexes
  218.         if (isset($element['indexes'])) {
  219.             foreach ($element['indexes'] as $name => $indexYml) {
  220.                 if ( ! isset($indexYml['name'])) {
  221.                     $indexYml['name'] = $name;
  222.                 }
  224.                 if (is_string($indexYml['columns'])) {
  225.                     $index = ['columns' => array_map('trim', explode(',', $indexYml['columns']))];
  226.                 } else {
  227.                     $index = ['columns' => $indexYml['columns']];
  228.                 }
  230.                 if (isset($indexYml['flags'])) {
  231.                     if (is_string($indexYml['flags'])) {
  232.                         $index['flags'] = array_map('trim', explode(',', $indexYml['flags']));
  233.                     } else {
  234.                         $index['flags'] = $indexYml['flags'];
  235.                     }
  236.                 }
  238.                 if (isset($indexYml['options'])) {
  239.                     $index['options'] = $indexYml['options'];
  240.                 }
  242.                 $metadata->table['indexes'][$indexYml['name']] = $index;
  243.             }
  244.         }
  246.         // Evaluate uniqueConstraints
  247.         if (isset($element['uniqueConstraints'])) {
  248.             foreach ($element['uniqueConstraints'] as $name => $uniqueYml) {
  249.                 if ( ! isset($uniqueYml['name'])) {
  250.                     $uniqueYml['name'] = $name;
  251.                 }
  253.                 if (is_string($uniqueYml['columns'])) {
  254.                     $unique = ['columns' => array_map('trim', explode(',', $uniqueYml['columns']))];
  255.                 } else {
  256.                     $unique = ['columns' => $uniqueYml['columns']];
  257.                 }
  259.                 if (isset($uniqueYml['options'])) {
  260.                     $unique['options'] = $uniqueYml['options'];
  261.                 }
  263.                 $metadata->table['uniqueConstraints'][$uniqueYml['name']] = $unique;
  264.             }
  265.         }
  267.         if (isset($element['options'])) {
  268.             $metadata->table['options'] = $element['options'];
  269.         }
  271.         $associationIds = [];
  272.         if (isset($element['id'])) {
  273.             // Evaluate identifier settings
  274.             foreach ($element['id'] as $name => $idElement) {
  275.                 if (isset($idElement['associationKey']) && $idElement['associationKey'] == true) {
  276.                     $associationIds[$name] = true;
  277.                     continue;
  278.                 }
  280.                 $mapping = [
  281.                     'id' => true,
  282.                     'fieldName' => $name
  283.                 ];
  285.                 if (isset($idElement['type'])) {
  286.                     $mapping['type'] = $idElement['type'];
  287.                 }
  289.                 if (isset($idElement['column'])) {
  290.                     $mapping['columnName'] = $idElement['column'];
  291.                 }
  293.                 if (isset($idElement['length'])) {
  294.                     $mapping['length'] = $idElement['length'];
  295.                 }
  297.                 if (isset($idElement['columnDefinition'])) {
  298.                     $mapping['columnDefinition'] = $idElement['columnDefinition'];
  299.                 }
  301.                 if (isset($idElement['options'])) {
  302.                     $mapping['options'] = $idElement['options'];
  303.                 }
  305.                 $metadata->mapField($mapping);
  307.                 if (isset($idElement['generator'])) {
  308.                     $metadata->setIdGeneratorType(constant('Doctrine\ORM\Mapping\ClassMetadata::GENERATOR_TYPE_'
  309.                         . strtoupper($idElement['generator']['strategy'])));
  310.                 }
  311.                 // Check for SequenceGenerator/TableGenerator definition
  312.                 if (isset($idElement['sequenceGenerator'])) {
  313.                     $metadata->setSequenceGeneratorDefinition($idElement['sequenceGenerator']);
  314.                 } else if (isset($idElement['customIdGenerator'])) {
  315.                     $customGenerator = $idElement['customIdGenerator'];
  316.                     $metadata->setCustomGeneratorDefinition(
  317.                         [
  318.                             'class' => (string) $customGenerator['class']
  319.                         ]
  320.                     );
  321.                 } else if (isset($idElement['tableGenerator'])) {
  322.                     throw MappingException::tableIdGeneratorNotImplemented($className);
  323.                 }
  324.             }
  325.         }
  327.         // Evaluate fields
  328.         if (isset($element['fields'])) {
  329.             foreach ($element['fields'] as $name => $fieldMapping) {
  331.                 $mapping = $this->columnToArray($name, $fieldMapping);
  333.                 if (isset($fieldMapping['id'])) {
  334.                     $mapping['id'] = true;
  335.                     if (isset($fieldMapping['generator']['strategy'])) {
  336.                         $metadata->setIdGeneratorType(constant('Doctrine\ORM\Mapping\ClassMetadata::GENERATOR_TYPE_'
  337.                             . strtoupper($fieldMapping['generator']['strategy'])));
  338.                     }
  339.                 }
  341.                 if (isset($mapping['version'])) {
  342.                     $metadata->setVersionMapping($mapping);
  343.                     unset($mapping['version']);
  344.                 }
  346.                 $metadata->mapField($mapping);
  347.             }
  348.         }
  350.         if (isset($element['embedded'])) {
  351.             foreach ($element['embedded'] as $name => $embeddedMapping) {
  352.                 $mapping = [
  353.                     'fieldName' => $name,
  354.                     'class' => $embeddedMapping['class'],
  355.                     'columnPrefix' => $embeddedMapping['columnPrefix'] ?? null,
  356.                 ];
  357.                 $metadata->mapEmbedded($mapping);
  358.             }
  359.         }
  361.         // Evaluate oneToOne relationships
  362.         if (isset($element['oneToOne'])) {
  363.             foreach ($element['oneToOne'] as $name => $oneToOneElement) {
  364.                 $mapping = [
  365.                     'fieldName' => $name,
  366.                     'targetEntity' => $oneToOneElement['targetEntity']
  367.                 ];
  369.                 if (isset($associationIds[$mapping['fieldName']])) {
  370.                     $mapping['id'] = true;
  371.                 }
  373.                 if (isset($oneToOneElement['fetch'])) {
  374.                     $mapping['fetch'] = constant('Doctrine\ORM\Mapping\ClassMetadata::FETCH_' . $oneToOneElement['fetch']);
  375.                 }
  377.                 if (isset($oneToOneElement['mappedBy'])) {
  378.                     $mapping['mappedBy'] = $oneToOneElement['mappedBy'];
  379.                 } else {
  380.                     if (isset($oneToOneElement['inversedBy'])) {
  381.                         $mapping['inversedBy'] = $oneToOneElement['inversedBy'];
  382.                     }
  384.                     $joinColumns = [];
  386.                     if (isset($oneToOneElement['joinColumn'])) {
  387.                         $joinColumns[] = $this->joinColumnToArray($oneToOneElement['joinColumn']);
  388.                     } else if (isset($oneToOneElement['joinColumns'])) {
  389.                         foreach ($oneToOneElement['joinColumns'] as $joinColumnName => $joinColumnElement) {
  390.                             if ( ! isset($joinColumnElement['name'])) {
  391.                                 $joinColumnElement['name'] = $joinColumnName;
  392.                             }
  394.                             $joinColumns[] = $this->joinColumnToArray($joinColumnElement);
  395.                         }
  396.                     }
  398.                     $mapping['joinColumns'] = $joinColumns;
  399.                 }
  401.                 if (isset($oneToOneElement['cascade'])) {
  402.                     $mapping['cascade'] = $oneToOneElement['cascade'];
  403.                 }
  405.                 if (isset($oneToOneElement['orphanRemoval'])) {
  406.                     $mapping['orphanRemoval'] = (bool) $oneToOneElement['orphanRemoval'];
  407.                 }
  409.                 // Evaluate second level cache
  410.                 if (isset($oneToOneElement['cache'])) {
  411.                     $mapping['cache'] = $metadata->getAssociationCacheDefaults($mapping['fieldName'], $this->cacheToArray($oneToOneElement['cache']));
  412.                 }
  414.                 $metadata->mapOneToOne($mapping);
  415.             }
  416.         }
  418.         // Evaluate oneToMany relationships
  419.         if (isset($element['oneToMany'])) {
  420.             foreach ($element['oneToMany'] as $name => $oneToManyElement) {
  421.                 $mapping = [
  422.                     'fieldName' => $name,
  423.                     'targetEntity' => $oneToManyElement['targetEntity'],
  424.                     'mappedBy' => $oneToManyElement['mappedBy']
  425.                 ];
  427.                 if (isset($oneToManyElement['fetch'])) {
  428.                     $mapping['fetch'] = constant('Doctrine\ORM\Mapping\ClassMetadata::FETCH_' . $oneToManyElement['fetch']);
  429.                 }
  431.                 if (isset($oneToManyElement['cascade'])) {
  432.                     $mapping['cascade'] = $oneToManyElement['cascade'];
  433.                 }
  435.                 if (isset($oneToManyElement['orphanRemoval'])) {
  436.                     $mapping['orphanRemoval'] = (bool) $oneToManyElement['orphanRemoval'];
  437.                 }
  439.                 if (isset($oneToManyElement['orderBy'])) {
  440.                     $mapping['orderBy'] = $oneToManyElement['orderBy'];
  441.                 }
  443.                 if (isset($oneToManyElement['indexBy'])) {
  444.                     $mapping['indexBy'] = $oneToManyElement['indexBy'];
  445.                 }
  448.                 // Evaluate second level cache
  449.                 if (isset($oneToManyElement['cache'])) {
  450.                     $mapping['cache'] = $metadata->getAssociationCacheDefaults($mapping['fieldName'], $this->cacheToArray($oneToManyElement['cache']));
  451.                 }
  453.                 $metadata->mapOneToMany($mapping);
  454.             }
  455.         }
  457.         // Evaluate manyToOne relationships
  458.         if (isset($element['manyToOne'])) {
  459.             foreach ($element['manyToOne'] as $name => $manyToOneElement) {
  460.                 $mapping = [
  461.                     'fieldName' => $name,
  462.                     'targetEntity' => $manyToOneElement['targetEntity']
  463.                 ];
  465.                 if (isset($associationIds[$mapping['fieldName']])) {
  466.                     $mapping['id'] = true;
  467.                 }
  469.                 if (isset($manyToOneElement['fetch'])) {
  470.                     $mapping['fetch'] = constant('Doctrine\ORM\Mapping\ClassMetadata::FETCH_' . $manyToOneElement['fetch']);
  471.                 }
  473.                 if (isset($manyToOneElement['inversedBy'])) {
  474.                     $mapping['inversedBy'] = $manyToOneElement['inversedBy'];
  475.                 }
  477.                 $joinColumns = [];
  479.                 if (isset($manyToOneElement['joinColumn'])) {
  480.                     $joinColumns[] = $this->joinColumnToArray($manyToOneElement['joinColumn']);
  481.                 } else if (isset($manyToOneElement['joinColumns'])) {
  482.                     foreach ($manyToOneElement['joinColumns'] as $joinColumnName => $joinColumnElement) {
  483.                         if ( ! isset($joinColumnElement['name'])) {
  484.                             $joinColumnElement['name'] = $joinColumnName;
  485.                         }
  487.                         $joinColumns[] = $this->joinColumnToArray($joinColumnElement);
  488.                     }
  489.                 }
  491.                 $mapping['joinColumns'] = $joinColumns;
  493.                 if (isset($manyToOneElement['cascade'])) {
  494.                     $mapping['cascade'] = $manyToOneElement['cascade'];
  495.                 }
  497.                 // Evaluate second level cache
  498.                 if (isset($manyToOneElement['cache'])) {
  499.                     $mapping['cache'] = $metadata->getAssociationCacheDefaults($mapping['fieldName'], $this->cacheToArray($manyToOneElement['cache']));
  500.                 }
  502.                 $metadata->mapManyToOne($mapping);
  503.             }
  504.         }
  506.         // Evaluate manyToMany relationships
  507.         if (isset($element['manyToMany'])) {
  508.             foreach ($element['manyToMany'] as $name => $manyToManyElement) {
  509.                 $mapping = [
  510.                     'fieldName' => $name,
  511.                     'targetEntity' => $manyToManyElement['targetEntity']
  512.                 ];
  514.                 if (isset($manyToManyElement['fetch'])) {
  515.                     $mapping['fetch'] = constant('Doctrine\ORM\Mapping\ClassMetadata::FETCH_' . $manyToManyElement['fetch']);
  516.                 }
  518.                 if (isset($manyToManyElement['mappedBy'])) {
  519.                     $mapping['mappedBy'] = $manyToManyElement['mappedBy'];
  520.                 } else if (isset($manyToManyElement['joinTable'])) {
  522.                     $joinTableElement = $manyToManyElement['joinTable'];
  523.                     $joinTable = [
  524.                         'name' => $joinTableElement['name']
  525.                     ];
  527.                     if (isset($joinTableElement['schema'])) {
  528.                         $joinTable['schema'] = $joinTableElement['schema'];
  529.                     }
  531.                     if (isset($joinTableElement['joinColumns'])) {
  532.                         foreach ($joinTableElement['joinColumns'] as $joinColumnName => $joinColumnElement) {
  533.                             if ( ! isset($joinColumnElement['name'])) {
  534.                                 $joinColumnElement['name'] = $joinColumnName;
  535.                             }
  536.                             $joinTable['joinColumns'][] = $this->joinColumnToArray($joinColumnElement);
  537.                         }
  538.                     }
  540.                     if (isset($joinTableElement['inverseJoinColumns'])) {
  541.                         foreach ($joinTableElement['inverseJoinColumns'] as $joinColumnName => $joinColumnElement) {
  542.                             if ( ! isset($joinColumnElement['name'])) {
  543.                                 $joinColumnElement['name'] = $joinColumnName;
  544.                             }
  545.                             $joinTable['inverseJoinColumns'][] = $this->joinColumnToArray($joinColumnElement);
  546.                         }
  547.                     }
  549.                     $mapping['joinTable'] = $joinTable;
  550.                 }
  552.                 if (isset($manyToManyElement['inversedBy'])) {
  553.                     $mapping['inversedBy'] = $manyToManyElement['inversedBy'];
  554.                 }
  556.                 if (isset($manyToManyElement['cascade'])) {
  557.                     $mapping['cascade'] = $manyToManyElement['cascade'];
  558.                 }
  560.                 if (isset($manyToManyElement['orderBy'])) {
  561.                     $mapping['orderBy'] = $manyToManyElement['orderBy'];
  562.                 }
  564.                 if (isset($manyToManyElement['indexBy'])) {
  565.                     $mapping['indexBy'] = $manyToManyElement['indexBy'];
  566.                 }
  568.                 if (isset($manyToManyElement['orphanRemoval'])) {
  569.                     $mapping['orphanRemoval'] = (bool) $manyToManyElement['orphanRemoval'];
  570.                 }
  572.                 // Evaluate second level cache
  573.                 if (isset($manyToManyElement['cache'])) {
  574.                     $mapping['cache'] = $metadata->getAssociationCacheDefaults($mapping['fieldName'], $this->cacheToArray($manyToManyElement['cache']));
  575.                 }
  577.                 $metadata->mapManyToMany($mapping);
  578.             }
  579.         }
  581.         // Evaluate associationOverride
  582.         if (isset($element['associationOverride']) && is_array($element['associationOverride'])) {
  584.             foreach ($element['associationOverride'] as $fieldName => $associationOverrideElement) {
  585.                 $override   = [];
  587.                 // Check for joinColumn
  588.                 if (isset($associationOverrideElement['joinColumn'])) {
  589.                     $joinColumns = [];
  590.                     foreach ($associationOverrideElement['joinColumn'] as $name => $joinColumnElement) {
  591.                         if ( ! isset($joinColumnElement['name'])) {
  592.                             $joinColumnElement['name'] = $name;
  593.                         }
  594.                         $joinColumns[] = $this->joinColumnToArray($joinColumnElement);
  595.                     }
  596.                     $override['joinColumns'] = $joinColumns;
  597.                 }
  599.                 // Check for joinTable
  600.                 if (isset($associationOverrideElement['joinTable'])) {
  602.                     $joinTableElement   = $associationOverrideElement['joinTable'];
  603.                     $joinTable          =  [
  604.                         'name' => $joinTableElement['name']
  605.                     ];
  607.                     if (isset($joinTableElement['schema'])) {
  608.                         $joinTable['schema'] = $joinTableElement['schema'];
  609.                     }
  611.                     foreach ($joinTableElement['joinColumns'] as $name => $joinColumnElement) {
  612.                         if ( ! isset($joinColumnElement['name'])) {
  613.                             $joinColumnElement['name'] = $name;
  614.                         }
  616.                         $joinTable['joinColumns'][] = $this->joinColumnToArray($joinColumnElement);
  617.                     }
  619.                     foreach ($joinTableElement['inverseJoinColumns'] as $name => $joinColumnElement) {
  620.                         if ( ! isset($joinColumnElement['name'])) {
  621.                             $joinColumnElement['name'] = $name;
  622.                         }
  624.                         $joinTable['inverseJoinColumns'][] = $this->joinColumnToArray($joinColumnElement);
  625.                     }
  627.                     $override['joinTable'] = $joinTable;
  628.                 }
  630.                 // Check for inversedBy
  631.                 if (isset($associationOverrideElement['inversedBy'])) {
  632.                     $override['inversedBy'] = (string) $associationOverrideElement['inversedBy'];
  633.                 }
  635.                 // Check for `fetch`
  636.                 if (isset($associationOverrideElement['fetch'])) {
  637.                     $override['fetch'] = constant(Metadata::class . '::FETCH_' . $associationOverrideElement['fetch']);
  638.                 }
  640.                 $metadata->setAssociationOverride($fieldName, $override);
  641.             }
  642.         }
  644.         // Evaluate associationOverride
  645.         if (isset($element['attributeOverride']) && is_array($element['attributeOverride'])) {
  647.             foreach ($element['attributeOverride'] as $fieldName => $attributeOverrideElement) {
  648.                 $mapping = $this->columnToArray($fieldName, $attributeOverrideElement);
  649.                 $metadata->setAttributeOverride($fieldName, $mapping);
  650.             }
  651.         }
  653.         // Evaluate lifeCycleCallbacks
  654.         if (isset($element['lifecycleCallbacks'])) {
  655.             foreach ($element['lifecycleCallbacks'] as $type => $methods) {
  656.                 foreach ($methods as $method) {
  657.                     $metadata->addLifecycleCallback($method, constant('Doctrine\ORM\Events::' . $type));
  658.                 }
  659.             }
  660.         }
  662.         // Evaluate entityListeners
  663.         if (isset($element['entityListeners'])) {
  664.             foreach ($element['entityListeners'] as $className => $entityListener) {
  665.                 // Evaluate the listener using naming convention.
  666.                 if (empty($entityListener)) {
  667.                     EntityListenerBuilder::bindEntityListener($metadata, $className);
  669.                     continue;
  670.                 }
  672.                 foreach ($entityListener as $eventName => $callbackElement) {
  673.                     foreach ($callbackElement as $methodName) {
  674.                         $metadata->addEntityListener($eventName, $className, $methodName);
  675.                     }
  676.                 }
  677.             }
  678.         }
  679.     }
  681.     /**
  682.      * Constructs a joinColumn mapping array based on the information
  683.      * found in the given join column element.
  684.      *
  685.      * @param array $joinColumnElement The array join column element.
  686.      *
  687.      * @return mixed[] The mapping array.
  688.      *
  689.      * @psalm-return array{
  690.      *                   referencedColumnName?: string,
  691.      *                   name?: string,
  692.      *                   fieldName?: string,
  693.      *                   unique?: bool,
  694.      *                   nullable?: bool,
  695.      *                   onDelete?: mixed,
  696.      *                   columnDefinition?: mixed
  697.      *               }
  698.      */
  699.     private function joinColumnToArray($joinColumnElement)
  700.     {
  701.         $joinColumn = [];
  702.         if (isset($joinColumnElement['referencedColumnName'])) {
  703.             $joinColumn['referencedColumnName'] = (string) $joinColumnElement['referencedColumnName'];
  704.         }
  706.         if (isset($joinColumnElement['name'])) {
  707.             $joinColumn['name'] = (string) $joinColumnElement['name'];
  708.         }
  710.         if (isset($joinColumnElement['fieldName'])) {
  711.             $joinColumn['fieldName'] = (string) $joinColumnElement['fieldName'];
  712.         }
  714.         if (isset($joinColumnElement['unique'])) {
  715.             $joinColumn['unique'] = (bool) $joinColumnElement['unique'];
  716.         }
  718.         if (isset($joinColumnElement['nullable'])) {
  719.             $joinColumn['nullable'] = (bool) $joinColumnElement['nullable'];
  720.         }
  722.         if (isset($joinColumnElement['onDelete'])) {
  723.             $joinColumn['onDelete'] = $joinColumnElement['onDelete'];
  724.         }
  726.         if (isset($joinColumnElement['columnDefinition'])) {
  727.             $joinColumn['columnDefinition'] = $joinColumnElement['columnDefinition'];
  728.         }
  730.         return $joinColumn;
  731.     }
  733.     /**
  734.      * Parses the given column as array.
  735.      *
  736.      * @param string $fieldName
  737.      * @param array  $column
  738.      *
  739.      * @return mixed[]
  740.      *
  741.      * @psalm-return array{
  742.      *                   fieldName: string,
  743.      *                   type?: string,
  744.      *                   columnName?: mixed,
  745.      *                   length?: mixed,
  746.      *                   precision?: mixed,
  747.      *                   scale?: mixed,
  748.      *                   unique?: bool,
  749.      *                   options?: mixed,
  750.      *                   nullable?: mixed,
  751.      *                   version?: mixed,
  752.      *                   columnDefinition?: mixed
  753.      *               }
  754.      */
  755.     private function columnToArray($fieldName, $column)
  756.     {
  757.         $mapping = [
  758.             'fieldName' => $fieldName
  759.         ];
  761.         if (isset($column['type'])) {
  762.             $params = explode('(', $column['type']);
  764.             $column['type']  = $params[0];
  765.             $mapping['type'] = $column['type'];
  767.             if (isset($params[1])) {
  768.                 $column['length'] = (integer) substr($params[1], 0, strlen($params[1]) - 1);
  769.             }
  770.         }
  772.         if (isset($column['column'])) {
  773.             $mapping['columnName'] = $column['column'];
  774.         }
  776.         if (isset($column['length'])) {
  777.             $mapping['length'] = $column['length'];
  778.         }
  780.         if (isset($column['precision'])) {
  781.             $mapping['precision'] = $column['precision'];
  782.         }
  784.         if (isset($column['scale'])) {
  785.             $mapping['scale'] = $column['scale'];
  786.         }
  788.         if (isset($column['unique'])) {
  789.             $mapping['unique'] = (bool) $column['unique'];
  790.         }
  792.         if (isset($column['options'])) {
  793.             $mapping['options'] = $column['options'];
  794.         }
  796.         if (isset($column['nullable'])) {
  797.             $mapping['nullable'] = $column['nullable'];
  798.         }
  800.         if (isset($column['version']) && $column['version']) {
  801.             $mapping['version'] = $column['version'];
  802.         }
  804.         if (isset($column['columnDefinition'])) {
  805.             $mapping['columnDefinition'] = $column['columnDefinition'];
  806.         }
  808.         return $mapping;
  809.     }
  811.     /**
  812.      * Parse / Normalize the cache configuration
  813.      *
  814.      * @param mixed[] $cacheMapping
  815.      *
  816.      * @return mixed[]
  817.      *
  818.      * @psalm-param array{usage: mixed, region: null|string} $cacheMapping
  819.      * @psalm-return array{usage: mixed, region: null|string}
  820.      */
  821.     private function cacheToArray($cacheMapping)
  822.     {
  823.         $region = isset($cacheMapping['region']) ? (string) $cacheMapping['region'] : null;
  824.         $usage  = isset($cacheMapping['usage']) ? strtoupper($cacheMapping['usage']) : null;
  826.         if ($usage && ! defined('Doctrine\ORM\Mapping\ClassMetadata::CACHE_USAGE_' . $usage)) {
  827.             throw new \InvalidArgumentException(sprintf('Invalid cache usage "%s"', $usage));
  828.         }
  830.         if ($usage) {
  831.             $usage = constant('Doctrine\ORM\Mapping\ClassMetadata::CACHE_USAGE_' . $usage);
  832.         }
  834.         return [
  835.             'usage'  => $usage,
  836.             'region' => $region,
  837.         ];
  838.     }
  840.     /**
  841.      * {@inheritDoc}
  842.      */
  843.     protected function loadMappingFile($file)
  844.     {
  845.         return Yaml::parse(file_get_contents($file));
  846.     }
  847. }
  849. interface_exists(ClassMetadata::class);