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

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\Persistence\Mapping\ClassMetadata;
  23. use Doctrine\ORM\Mapping\Builder\EntityListenerBuilder;
  24. use Doctrine\Common\Persistence\Mapping\Driver\FileDriver;
  25. use Doctrine\ORM\Mapping\ClassMetadata as Metadata;
  26. use Doctrine\ORM\Mapping\MappingException;
  27. use Symfony\Component\Yaml\Yaml;
  28. use function trigger_error;
  30. /**
  31.  * The YamlDriver reads the mapping metadata from yaml schema files.
  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.  * @deprecated 2.7 This class is being removed from the ORM and won't have any replacement
  40.  */
  41. class YamlDriver extends FileDriver
  42. {
  43.     const DEFAULT_FILE_EXTENSION = '.dcm.yml';
  45.     /**
  46.      * {@inheritDoc}
  47.      */
  48.     public function __construct($locator, $fileExtension = self::DEFAULT_FILE_EXTENSION)
  49.     {
  50.         @trigger_error(
  51.             'YAML mapping driver is deprecated and will be removed in Doctrine ORM 3.0, please migrate to annotation or XML driver.',
  52.             E_USER_DEPRECATED
  53.         );
  55.         parent::__construct($locator, $fileExtension);
  56.     }
  58.     /**
  59.      * {@inheritDoc}
  60.      */
  61.     public function loadMetadataForClass($className, ClassMetadata $metadata)
  62.     {
  63.         /* @var $metadata \Doctrine\ORM\Mapping\ClassMetadataInfo */
  64.         $element = $this->getElement($className);
  66.         if ($element['type'] == 'entity') {
  67.             if (isset($element['repositoryClass'])) {
  68.                 $metadata->setCustomRepositoryClass($element['repositoryClass']);
  69.             }
  70.             if (isset($element['readOnly']) && $element['readOnly'] == true) {
  71.                 $metadata->markReadOnly();
  72.             }
  73.         } else if ($element['type'] == 'mappedSuperclass') {
  74.             $metadata->setCustomRepositoryClass(
  75.                 $element['repositoryClass'] ?? null
  76.             );
  77.             $metadata->isMappedSuperclass = true;
  78.         } else if ($element['type'] == 'embeddable') {
  79.             $metadata->isEmbeddedClass = true;
  80.         } else {
  81.             throw MappingException::classIsNotAValidEntityOrMappedSuperClass($className);
  82.         }
  84.         // Evaluate root level properties
  85.         $primaryTable = [];
  87.         if (isset($element['table'])) {
  88.             $primaryTable['name'] = $element['table'];
  89.         }
  91.         if (isset($element['schema'])) {
  92.             $primaryTable['schema'] = $element['schema'];
  93.         }
  95.         // Evaluate second level cache
  96.         if (isset($element['cache'])) {
  97.             $metadata->enableCache($this->cacheToArray($element['cache']));
  98.         }
  100.         $metadata->setPrimaryTable($primaryTable);
  102.         // Evaluate named queries
  103.         if (isset($element['namedQueries'])) {
  104.             foreach ($element['namedQueries'] as $name => $queryMapping) {
  105.                 if (is_string($queryMapping)) {
  106.                     $queryMapping = ['query' => $queryMapping];
  107.                 }
  109.                 if ( ! isset($queryMapping['name'])) {
  110.                     $queryMapping['name'] = $name;
  111.                 }
  113.                 $metadata->addNamedQuery($queryMapping);
  114.             }
  115.         }
  117.         // Evaluate named native queries
  118.         if (isset($element['namedNativeQueries'])) {
  119.             foreach ($element['namedNativeQueries'] as $name => $mappingElement) {
  120.                 if (!isset($mappingElement['name'])) {
  121.                     $mappingElement['name'] = $name;
  122.                 }
  123.                 $metadata->addNamedNativeQuery(
  124.                     [
  125.                         'name'              => $mappingElement['name'],
  126.                         'query'             => $mappingElement['query'] ?? null,
  127.                         'resultClass'       => $mappingElement['resultClass'] ?? null,
  128.                         'resultSetMapping'  => $mappingElement['resultSetMapping'] ?? null,
  129.                     ]
  130.                 );
  131.             }
  132.         }
  134.         // Evaluate sql result set mappings
  135.         if (isset($element['sqlResultSetMappings'])) {
  136.             foreach ($element['sqlResultSetMappings'] as $name => $resultSetMapping) {
  137.                 if (!isset($resultSetMapping['name'])) {
  138.                     $resultSetMapping['name'] = $name;
  139.                 }
  141.                 $entities = [];
  142.                 $columns  = [];
  143.                 if (isset($resultSetMapping['entityResult'])) {
  144.                     foreach ($resultSetMapping['entityResult'] as $entityResultElement) {
  145.                         $entityResult = [
  146.                             'fields'                => [],
  147.                             'entityClass'           => $entityResultElement['entityClass'] ?? null,
  148.                             'discriminatorColumn'   => $entityResultElement['discriminatorColumn'] ?? null,
  149.                         ];
  151.                         if (isset($entityResultElement['fieldResult'])) {
  152.                             foreach ($entityResultElement['fieldResult'] as $fieldResultElement) {
  153.                                 $entityResult['fields'][] = [
  154.                                     'name'      => $fieldResultElement['name'] ?? null,
  155.                                     'column'    => $fieldResultElement['column'] ?? null,
  156.                                 ];
  157.                             }
  158.                         }
  160.                         $entities[] = $entityResult;
  161.                     }
  162.                 }
  165.                 if (isset($resultSetMapping['columnResult'])) {
  166.                     foreach ($resultSetMapping['columnResult'] as $columnResultAnnot) {
  167.                         $columns[] = [
  168.                             'name' => $columnResultAnnot['name'] ?? null,
  169.                         ];
  170.                     }
  171.                 }
  173.                 $metadata->addSqlResultSetMapping(
  174.                     [
  175.                         'name'          => $resultSetMapping['name'],
  176.                         'entities'      => $entities,
  177.                         'columns'       => $columns
  178.                     ]
  179.                 );
  180.             }
  181.         }
  183.         if (isset($element['inheritanceType'])) {
  184.             $metadata->setInheritanceType(constant('Doctrine\ORM\Mapping\ClassMetadata::INHERITANCE_TYPE_' . strtoupper($element['inheritanceType'])));
  186.             if ($metadata->inheritanceType != Metadata::INHERITANCE_TYPE_NONE) {
  187.                 // Evaluate discriminatorColumn
  188.                 if (isset($element['discriminatorColumn'])) {
  189.                     $discrColumn = $element['discriminatorColumn'];
  190.                     $metadata->setDiscriminatorColumn(
  191.                         [
  192.                             'name' => isset($discrColumn['name']) ? (string) $discrColumn['name'] : null,
  193.                             'type' => isset($discrColumn['type']) ? (string) $discrColumn['type'] : 'string',
  194.                             'length' => isset($discrColumn['length']) ? (string) $discrColumn['length'] : 255,
  195.                             'columnDefinition' => isset($discrColumn['columnDefinition']) ? (string) $discrColumn['columnDefinition'] : null
  196.                         ]
  197.                     );
  198.                 } else {
  199.                     $metadata->setDiscriminatorColumn(['name' => 'dtype', 'type' => 'string', 'length' => 255]);
  200.                 }
  202.                 // Evaluate discriminatorMap
  203.                 if (isset($element['discriminatorMap'])) {
  204.                     $metadata->setDiscriminatorMap($element['discriminatorMap']);
  205.                 }
  206.             }
  207.         }
  210.         // Evaluate changeTrackingPolicy
  211.         if (isset($element['changeTrackingPolicy'])) {
  212.             $metadata->setChangeTrackingPolicy(constant('Doctrine\ORM\Mapping\ClassMetadata::CHANGETRACKING_'
  213.                 . strtoupper($element['changeTrackingPolicy'])));
  214.         }
  216.         // Evaluate indexes
  217.         if (isset($element['indexes'])) {
  218.             foreach ($element['indexes'] as $name => $indexYml) {
  219.                 if ( ! isset($indexYml['name'])) {
  220.                     $indexYml['name'] = $name;
  221.                 }
  223.                 if (is_string($indexYml['columns'])) {
  224.                     $index = ['columns' => array_map('trim', explode(',', $indexYml['columns']))];
  225.                 } else {
  226.                     $index = ['columns' => $indexYml['columns']];
  227.                 }
  229.                 if (isset($indexYml['flags'])) {
  230.                     if (is_string($indexYml['flags'])) {
  231.                         $index['flags'] = array_map('trim', explode(',', $indexYml['flags']));
  232.                     } else {
  233.                         $index['flags'] = $indexYml['flags'];
  234.                     }
  235.                 }
  237.                 if (isset($indexYml['options'])) {
  238.                     $index['options'] = $indexYml['options'];
  239.                 }
  241.                 $metadata->table['indexes'][$indexYml['name']] = $index;
  242.             }
  243.         }
  245.         // Evaluate uniqueConstraints
  246.         if (isset($element['uniqueConstraints'])) {
  247.             foreach ($element['uniqueConstraints'] as $name => $uniqueYml) {
  248.                 if ( ! isset($uniqueYml['name'])) {
  249.                     $uniqueYml['name'] = $name;
  250.                 }
  252.                 if (is_string($uniqueYml['columns'])) {
  253.                     $unique = ['columns' => array_map('trim', explode(',', $uniqueYml['columns']))];
  254.                 } else {
  255.                     $unique = ['columns' => $uniqueYml['columns']];
  256.                 }
  258.                 if (isset($uniqueYml['options'])) {
  259.                     $unique['options'] = $uniqueYml['options'];
  260.                 }
  262.                 $metadata->table['uniqueConstraints'][$uniqueYml['name']] = $unique;
  263.             }
  264.         }
  266.         if (isset($element['options'])) {
  267.             $metadata->table['options'] = $element['options'];
  268.         }
  270.         $associationIds = [];
  271.         if (isset($element['id'])) {
  272.             // Evaluate identifier settings
  273.             foreach ($element['id'] as $name => $idElement) {
  274.                 if (isset($idElement['associationKey']) && $idElement['associationKey'] == true) {
  275.                     $associationIds[$name] = true;
  276.                     continue;
  277.                 }
  279.                 $mapping = [
  280.                     'id' => true,
  281.                     'fieldName' => $name
  282.                 ];
  284.                 if (isset($idElement['type'])) {
  285.                     $mapping['type'] = $idElement['type'];
  286.                 }
  288.                 if (isset($idElement['column'])) {
  289.                     $mapping['columnName'] = $idElement['column'];
  290.                 }
  292.                 if (isset($idElement['length'])) {
  293.                     $mapping['length'] = $idElement['length'];
  294.                 }
  296.                 if (isset($idElement['columnDefinition'])) {
  297.                     $mapping['columnDefinition'] = $idElement['columnDefinition'];
  298.                 }
  300.                 if (isset($idElement['options'])) {
  301.                     $mapping['options'] = $idElement['options'];
  302.                 }
  304.                 $metadata->mapField($mapping);
  306.                 if (isset($idElement['generator'])) {
  307.                     $metadata->setIdGeneratorType(constant('Doctrine\ORM\Mapping\ClassMetadata::GENERATOR_TYPE_'
  308.                         . strtoupper($idElement['generator']['strategy'])));
  309.                 }
  310.                 // Check for SequenceGenerator/TableGenerator definition
  311.                 if (isset($idElement['sequenceGenerator'])) {
  312.                     $metadata->setSequenceGeneratorDefinition($idElement['sequenceGenerator']);
  313.                 } else if (isset($idElement['customIdGenerator'])) {
  314.                     $customGenerator = $idElement['customIdGenerator'];
  315.                     $metadata->setCustomGeneratorDefinition(
  316.                         [
  317.                             'class' => (string) $customGenerator['class']
  318.                         ]
  319.                     );
  320.                 } else if (isset($idElement['tableGenerator'])) {
  321.                     throw MappingException::tableIdGeneratorNotImplemented($className);
  322.                 }
  323.             }
  324.         }
  326.         // Evaluate fields
  327.         if (isset($element['fields'])) {
  328.             foreach ($element['fields'] as $name => $fieldMapping) {
  330.                 $mapping = $this->columnToArray($name, $fieldMapping);
  332.                 if (isset($fieldMapping['id'])) {
  333.                     $mapping['id'] = true;
  334.                     if (isset($fieldMapping['generator']['strategy'])) {
  335.                         $metadata->setIdGeneratorType(constant('Doctrine\ORM\Mapping\ClassMetadata::GENERATOR_TYPE_'
  336.                             . strtoupper($fieldMapping['generator']['strategy'])));
  337.                     }
  338.                 }
  340.                 if (isset($mapping['version'])) {
  341.                     $metadata->setVersionMapping($mapping);
  342.                     unset($mapping['version']);
  343.                 }
  345.                 $metadata->mapField($mapping);
  346.             }
  347.         }
  349.         if (isset($element['embedded'])) {
  350.             foreach ($element['embedded'] as $name => $embeddedMapping) {
  351.                 $mapping = [
  352.                     'fieldName' => $name,
  353.                     'class' => $embeddedMapping['class'],
  354.                     'columnPrefix' => $embeddedMapping['columnPrefix'] ?? null,
  355.                 ];
  356.                 $metadata->mapEmbedded($mapping);
  357.             }
  358.         }
  360.         // Evaluate oneToOne relationships
  361.         if (isset($element['oneToOne'])) {
  362.             foreach ($element['oneToOne'] as $name => $oneToOneElement) {
  363.                 $mapping = [
  364.                     'fieldName' => $name,
  365.                     'targetEntity' => $oneToOneElement['targetEntity']
  366.                 ];
  368.                 if (isset($associationIds[$mapping['fieldName']])) {
  369.                     $mapping['id'] = true;
  370.                 }
  372.                 if (isset($oneToOneElement['fetch'])) {
  373.                     $mapping['fetch'] = constant('Doctrine\ORM\Mapping\ClassMetadata::FETCH_' . $oneToOneElement['fetch']);
  374.                 }
  376.                 if (isset($oneToOneElement['mappedBy'])) {
  377.                     $mapping['mappedBy'] = $oneToOneElement['mappedBy'];
  378.                 } else {
  379.                     if (isset($oneToOneElement['inversedBy'])) {
  380.                         $mapping['inversedBy'] = $oneToOneElement['inversedBy'];
  381.                     }
  383.                     $joinColumns = [];
  385.                     if (isset($oneToOneElement['joinColumn'])) {
  386.                         $joinColumns[] = $this->joinColumnToArray($oneToOneElement['joinColumn']);
  387.                     } else if (isset($oneToOneElement['joinColumns'])) {
  388.                         foreach ($oneToOneElement['joinColumns'] as $joinColumnName => $joinColumnElement) {
  389.                             if ( ! isset($joinColumnElement['name'])) {
  390.                                 $joinColumnElement['name'] = $joinColumnName;
  391.                             }
  393.                             $joinColumns[] = $this->joinColumnToArray($joinColumnElement);
  394.                         }
  395.                     }
  397.                     $mapping['joinColumns'] = $joinColumns;
  398.                 }
  400.                 if (isset($oneToOneElement['cascade'])) {
  401.                     $mapping['cascade'] = $oneToOneElement['cascade'];
  402.                 }
  404.                 if (isset($oneToOneElement['orphanRemoval'])) {
  405.                     $mapping['orphanRemoval'] = (bool) $oneToOneElement['orphanRemoval'];
  406.                 }
  408.                 // Evaluate second level cache
  409.                 if (isset($oneToOneElement['cache'])) {
  410.                     $mapping['cache'] = $metadata->getAssociationCacheDefaults($mapping['fieldName'], $this->cacheToArray($oneToOneElement['cache']));
  411.                 }
  413.                 $metadata->mapOneToOne($mapping);
  414.             }
  415.         }
  417.         // Evaluate oneToMany relationships
  418.         if (isset($element['oneToMany'])) {
  419.             foreach ($element['oneToMany'] as $name => $oneToManyElement) {
  420.                 $mapping = [
  421.                     'fieldName' => $name,
  422.                     'targetEntity' => $oneToManyElement['targetEntity'],
  423.                     'mappedBy' => $oneToManyElement['mappedBy']
  424.                 ];
  426.                 if (isset($oneToManyElement['fetch'])) {
  427.                     $mapping['fetch'] = constant('Doctrine\ORM\Mapping\ClassMetadata::FETCH_' . $oneToManyElement['fetch']);
  428.                 }
  430.                 if (isset($oneToManyElement['cascade'])) {
  431.                     $mapping['cascade'] = $oneToManyElement['cascade'];
  432.                 }
  434.                 if (isset($oneToManyElement['orphanRemoval'])) {
  435.                     $mapping['orphanRemoval'] = (bool) $oneToManyElement['orphanRemoval'];
  436.                 }
  438.                 if (isset($oneToManyElement['orderBy'])) {
  439.                     $mapping['orderBy'] = $oneToManyElement['orderBy'];
  440.                 }
  442.                 if (isset($oneToManyElement['indexBy'])) {
  443.                     $mapping['indexBy'] = $oneToManyElement['indexBy'];
  444.                 }
  447.                 // Evaluate second level cache
  448.                 if (isset($oneToManyElement['cache'])) {
  449.                     $mapping['cache'] = $metadata->getAssociationCacheDefaults($mapping['fieldName'], $this->cacheToArray($oneToManyElement['cache']));
  450.                 }
  452.                 $metadata->mapOneToMany($mapping);
  453.             }
  454.         }
  456.         // Evaluate manyToOne relationships
  457.         if (isset($element['manyToOne'])) {
  458.             foreach ($element['manyToOne'] as $name => $manyToOneElement) {
  459.                 $mapping = [
  460.                     'fieldName' => $name,
  461.                     'targetEntity' => $manyToOneElement['targetEntity']
  462.                 ];
  464.                 if (isset($associationIds[$mapping['fieldName']])) {
  465.                     $mapping['id'] = true;
  466.                 }
  468.                 if (isset($manyToOneElement['fetch'])) {
  469.                     $mapping['fetch'] = constant('Doctrine\ORM\Mapping\ClassMetadata::FETCH_' . $manyToOneElement['fetch']);
  470.                 }
  472.                 if (isset($manyToOneElement['inversedBy'])) {
  473.                     $mapping['inversedBy'] = $manyToOneElement['inversedBy'];
  474.                 }
  476.                 $joinColumns = [];
  478.                 if (isset($manyToOneElement['joinColumn'])) {
  479.                     $joinColumns[] = $this->joinColumnToArray($manyToOneElement['joinColumn']);
  480.                 } else if (isset($manyToOneElement['joinColumns'])) {
  481.                     foreach ($manyToOneElement['joinColumns'] as $joinColumnName => $joinColumnElement) {
  482.                         if ( ! isset($joinColumnElement['name'])) {
  483.                             $joinColumnElement['name'] = $joinColumnName;
  484.                         }
  486.                         $joinColumns[] = $this->joinColumnToArray($joinColumnElement);
  487.                     }
  488.                 }
  490.                 $mapping['joinColumns'] = $joinColumns;
  492.                 if (isset($manyToOneElement['cascade'])) {
  493.                     $mapping['cascade'] = $manyToOneElement['cascade'];
  494.                 }
  496.                 // Evaluate second level cache
  497.                 if (isset($manyToOneElement['cache'])) {
  498.                     $mapping['cache'] = $metadata->getAssociationCacheDefaults($mapping['fieldName'], $this->cacheToArray($manyToOneElement['cache']));
  499.                 }
  501.                 $metadata->mapManyToOne($mapping);
  502.             }
  503.         }
  505.         // Evaluate manyToMany relationships
  506.         if (isset($element['manyToMany'])) {
  507.             foreach ($element['manyToMany'] as $name => $manyToManyElement) {
  508.                 $mapping = [
  509.                     'fieldName' => $name,
  510.                     'targetEntity' => $manyToManyElement['targetEntity']
  511.                 ];
  513.                 if (isset($manyToManyElement['fetch'])) {
  514.                     $mapping['fetch'] = constant('Doctrine\ORM\Mapping\ClassMetadata::FETCH_' . $manyToManyElement['fetch']);
  515.                 }
  517.                 if (isset($manyToManyElement['mappedBy'])) {
  518.                     $mapping['mappedBy'] = $manyToManyElement['mappedBy'];
  519.                 } else if (isset($manyToManyElement['joinTable'])) {
  521.                     $joinTableElement = $manyToManyElement['joinTable'];
  522.                     $joinTable = [
  523.                         'name' => $joinTableElement['name']
  524.                     ];
  526.                     if (isset($joinTableElement['schema'])) {
  527.                         $joinTable['schema'] = $joinTableElement['schema'];
  528.                     }
  530.                     if (isset($joinTableElement['joinColumns'])) {
  531.                         foreach ($joinTableElement['joinColumns'] as $joinColumnName => $joinColumnElement) {
  532.                             if ( ! isset($joinColumnElement['name'])) {
  533.                                 $joinColumnElement['name'] = $joinColumnName;
  534.                             }
  535.                             $joinTable['joinColumns'][] = $this->joinColumnToArray($joinColumnElement);
  536.                         }
  537.                     }
  539.                     if (isset($joinTableElement['inverseJoinColumns'])) {
  540.                         foreach ($joinTableElement['inverseJoinColumns'] as $joinColumnName => $joinColumnElement) {
  541.                             if ( ! isset($joinColumnElement['name'])) {
  542.                                 $joinColumnElement['name'] = $joinColumnName;
  543.                             }
  544.                             $joinTable['inverseJoinColumns'][] = $this->joinColumnToArray($joinColumnElement);
  545.                         }
  546.                     }
  548.                     $mapping['joinTable'] = $joinTable;
  549.                 }
  551.                 if (isset($manyToManyElement['inversedBy'])) {
  552.                     $mapping['inversedBy'] = $manyToManyElement['inversedBy'];
  553.                 }
  555.                 if (isset($manyToManyElement['cascade'])) {
  556.                     $mapping['cascade'] = $manyToManyElement['cascade'];
  557.                 }
  559.                 if (isset($manyToManyElement['orderBy'])) {
  560.                     $mapping['orderBy'] = $manyToManyElement['orderBy'];
  561.                 }
  563.                 if (isset($manyToManyElement['indexBy'])) {
  564.                     $mapping['indexBy'] = $manyToManyElement['indexBy'];
  565.                 }
  567.                 if (isset($manyToManyElement['orphanRemoval'])) {
  568.                     $mapping['orphanRemoval'] = (bool) $manyToManyElement['orphanRemoval'];
  569.                 }
  571.                 // Evaluate second level cache
  572.                 if (isset($manyToManyElement['cache'])) {
  573.                     $mapping['cache'] = $metadata->getAssociationCacheDefaults($mapping['fieldName'], $this->cacheToArray($manyToManyElement['cache']));
  574.                 }
  576.                 $metadata->mapManyToMany($mapping);
  577.             }
  578.         }
  580.         // Evaluate associationOverride
  581.         if (isset($element['associationOverride']) && is_array($element['associationOverride'])) {
  583.             foreach ($element['associationOverride'] as $fieldName => $associationOverrideElement) {
  584.                 $override   = [];
  586.                 // Check for joinColumn
  587.                 if (isset($associationOverrideElement['joinColumn'])) {
  588.                     $joinColumns = [];
  589.                     foreach ($associationOverrideElement['joinColumn'] as $name => $joinColumnElement) {
  590.                         if ( ! isset($joinColumnElement['name'])) {
  591.                             $joinColumnElement['name'] = $name;
  592.                         }
  593.                         $joinColumns[] = $this->joinColumnToArray($joinColumnElement);
  594.                     }
  595.                     $override['joinColumns'] = $joinColumns;
  596.                 }
  598.                 // Check for joinTable
  599.                 if (isset($associationOverrideElement['joinTable'])) {
  601.                     $joinTableElement   = $associationOverrideElement['joinTable'];
  602.                     $joinTable          =  [
  603.                         'name' => $joinTableElement['name']
  604.                     ];
  606.                     if (isset($joinTableElement['schema'])) {
  607.                         $joinTable['schema'] = $joinTableElement['schema'];
  608.                     }
  610.                     foreach ($joinTableElement['joinColumns'] as $name => $joinColumnElement) {
  611.                         if ( ! isset($joinColumnElement['name'])) {
  612.                             $joinColumnElement['name'] = $name;
  613.                         }
  615.                         $joinTable['joinColumns'][] = $this->joinColumnToArray($joinColumnElement);
  616.                     }
  618.                     foreach ($joinTableElement['inverseJoinColumns'] as $name => $joinColumnElement) {
  619.                         if ( ! isset($joinColumnElement['name'])) {
  620.                             $joinColumnElement['name'] = $name;
  621.                         }
  623.                         $joinTable['inverseJoinColumns'][] = $this->joinColumnToArray($joinColumnElement);
  624.                     }
  626.                     $override['joinTable'] = $joinTable;
  627.                 }
  629.                 // Check for inversedBy
  630.                 if (isset($associationOverrideElement['inversedBy'])) {
  631.                     $override['inversedBy'] = (string) $associationOverrideElement['inversedBy'];
  632.                 }
  634.                 // Check for `fetch`
  635.                 if (isset($associationOverrideElement['fetch'])) {
  636.                     $override['fetch'] = constant(Metadata::class . '::FETCH_' . $associationOverrideElement['fetch']);
  637.                 }
  639.                 $metadata->setAssociationOverride($fieldName, $override);
  640.             }
  641.         }
  643.         // Evaluate associationOverride
  644.         if (isset($element['attributeOverride']) && is_array($element['attributeOverride'])) {
  646.             foreach ($element['attributeOverride'] as $fieldName => $attributeOverrideElement) {
  647.                 $mapping = $this->columnToArray($fieldName, $attributeOverrideElement);
  648.                 $metadata->setAttributeOverride($fieldName, $mapping);
  649.             }
  650.         }
  652.         // Evaluate lifeCycleCallbacks
  653.         if (isset($element['lifecycleCallbacks'])) {
  654.             foreach ($element['lifecycleCallbacks'] as $type => $methods) {
  655.                 foreach ($methods as $method) {
  656.                     $metadata->addLifecycleCallback($method, constant('Doctrine\ORM\Events::' . $type));
  657.                 }
  658.             }
  659.         }
  661.         // Evaluate entityListeners
  662.         if (isset($element['entityListeners'])) {
  663.             foreach ($element['entityListeners'] as $className => $entityListener) {
  664.                 // Evaluate the listener using naming convention.
  665.                 if (empty($entityListener)) {
  666.                     EntityListenerBuilder::bindEntityListener($metadata, $className);
  668.                     continue;
  669.                 }
  671.                 foreach ($entityListener as $eventName => $callbackElement) {
  672.                     foreach ($callbackElement as $methodName) {
  673.                         $metadata->addEntityListener($eventName, $className, $methodName);
  674.                     }
  675.                 }
  676.             }
  677.         }
  678.     }
  680.     /**
  681.      * Constructs a joinColumn mapping array based on the information
  682.      * found in the given join column element.
  683.      *
  684.      * @param array $joinColumnElement The array join column element.
  685.      *
  686.      * @return array The mapping array.
  687.      */
  688.     private function joinColumnToArray($joinColumnElement)
  689.     {
  690.         $joinColumn = [];
  691.         if (isset($joinColumnElement['referencedColumnName'])) {
  692.             $joinColumn['referencedColumnName'] = (string) $joinColumnElement['referencedColumnName'];
  693.         }
  695.         if (isset($joinColumnElement['name'])) {
  696.             $joinColumn['name'] = (string) $joinColumnElement['name'];
  697.         }
  699.         if (isset($joinColumnElement['fieldName'])) {
  700.             $joinColumn['fieldName'] = (string) $joinColumnElement['fieldName'];
  701.         }
  703.         if (isset($joinColumnElement['unique'])) {
  704.             $joinColumn['unique'] = (bool) $joinColumnElement['unique'];
  705.         }
  707.         if (isset($joinColumnElement['nullable'])) {
  708.             $joinColumn['nullable'] = (bool) $joinColumnElement['nullable'];
  709.         }
  711.         if (isset($joinColumnElement['onDelete'])) {
  712.             $joinColumn['onDelete'] = $joinColumnElement['onDelete'];
  713.         }
  715.         if (isset($joinColumnElement['columnDefinition'])) {
  716.             $joinColumn['columnDefinition'] = $joinColumnElement['columnDefinition'];
  717.         }
  719.         return $joinColumn;
  720.     }
  722.     /**
  723.      * Parses the given column as array.
  724.      *
  725.      * @param string $fieldName
  726.      * @param array  $column
  727.      *
  728.      * @return  array
  729.      */
  730.     private function columnToArray($fieldName, $column)
  731.     {
  732.         $mapping = [
  733.             'fieldName' => $fieldName
  734.         ];
  736.         if (isset($column['type'])) {
  737.             $params = explode('(', $column['type']);
  739.             $column['type']  = $params[0];
  740.             $mapping['type'] = $column['type'];
  742.             if (isset($params[1])) {
  743.                 $column['length'] = (integer) substr($params[1], 0, strlen($params[1]) - 1);
  744.             }
  745.         }
  747.         if (isset($column['column'])) {
  748.             $mapping['columnName'] = $column['column'];
  749.         }
  751.         if (isset($column['length'])) {
  752.             $mapping['length'] = $column['length'];
  753.         }
  755.         if (isset($column['precision'])) {
  756.             $mapping['precision'] = $column['precision'];
  757.         }
  759.         if (isset($column['scale'])) {
  760.             $mapping['scale'] = $column['scale'];
  761.         }
  763.         if (isset($column['unique'])) {
  764.             $mapping['unique'] = (bool) $column['unique'];
  765.         }
  767.         if (isset($column['options'])) {
  768.             $mapping['options'] = $column['options'];
  769.         }
  771.         if (isset($column['nullable'])) {
  772.             $mapping['nullable'] = $column['nullable'];
  773.         }
  775.         if (isset($column['version']) && $column['version']) {
  776.             $mapping['version'] = $column['version'];
  777.         }
  779.         if (isset($column['columnDefinition'])) {
  780.             $mapping['columnDefinition'] = $column['columnDefinition'];
  781.         }
  783.         return $mapping;
  784.     }
  786.     /**
  787.      * Parse / Normalize the cache configuration
  788.      *
  789.      * @param array $cacheMapping
  790.      *
  791.      * @return array
  792.      */
  793.     private function cacheToArray($cacheMapping)
  794.     {
  795.         $region = isset($cacheMapping['region']) ? (string) $cacheMapping['region'] : null;
  796.         $usage  = isset($cacheMapping['usage']) ? strtoupper($cacheMapping['usage']) : null;
  798.         if ($usage && ! defined('Doctrine\ORM\Mapping\ClassMetadata::CACHE_USAGE_' . $usage)) {
  799.             throw new \InvalidArgumentException(sprintf('Invalid cache usage "%s"', $usage));
  800.         }
  802.         if ($usage) {
  803.             $usage = constant('Doctrine\ORM\Mapping\ClassMetadata::CACHE_USAGE_' . $usage);
  804.         }
  806.         return [
  807.             'usage'  => $usage,
  808.             'region' => $region,
  809.         ];
  810.     }
  812.     /**
  813.      * {@inheritDoc}
  814.      */
  815.     protected function loadMappingFile($file)
  816.     {
  817.         return Yaml::parse(file_get_contents($file));
  818.     }
  819. }