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