PHP ClassMetadata::mapOneToMany方法代码示例

 /**
  * Add mapping data to a translatable entity.
  *
  * @param ClassMetadata $metadata
  */
 private function mapTranslatable(ClassMetadata $metadata)
 {
     // In the case A -> B -> TranslatableInterface, B might not have mapping defined as it
     // is probably defined in A, so in that case, we just return.
     if (!isset($this->configs[$metadata->name])) {
         return;
     }
     $metadata->mapOneToMany(array('fieldName' => 'translations', 'targetEntity' => $this->configs[$metadata->name]['translation']['model'], 'mappedBy' => 'translatable', 'fetch' => ClassMetadataInfo::FETCH_EXTRA_LAZY, 'indexBy' => 'locale', 'cascade' => array('persist', 'merge', 'remove'), 'orphanRemoval' => true));
 }

 /**
  * @return ClassMetadata
  */
 public static function getMetadata()
 {
     $metadata = new ClassMetadata(static::class);
     $metadata->setIdentifier(['id']);
     $metadata->mapField(['fieldName' => 'id']);
     $metadata->mapField(['fieldName' => 'a']);
     $metadata->mapField(['fieldName' => 'b']);
     $metadata->mapField(['fieldName' => 'c']);
     $metadata->mapEmbedded(['fieldName' => 'd', 'class' => DummyEmbeddable::class, 'columnPrefix' => 'd']);
     $metadata->mapManyToOne(['fieldName' => 'parent', 'targetEntity' => self::class, 'inversedBy' => 'children']);
     $metadata->mapOneToMany(['fieldName' => 'children', 'targetEntity' => self::class, 'mappedBy' => 'parent']);
     $metadata->wakeupReflection(new RuntimeReflectionService());
     return $metadata;
 }

 /**
  * Add mapping data to a translatable entity.
  *
  * @param ClassMetadata $metadata
  */
 private function mapTranslatable(ClassMetadata $metadata)
 {
     $className = $metadata->name;
     try {
         $resourceMetadata = $this->registry->getByClass($className);
     } catch (\InvalidArgumentException $exception) {
         return;
     }
     if (!$resourceMetadata->hasParameter('translation')) {
         return;
     }
     $translationResourceMetadata = $this->registry->get($resourceMetadata->getAlias() . '_translation');
     $metadata->mapOneToMany(['fieldName' => 'translations', 'targetEntity' => $translationResourceMetadata->getClass('model'), 'mappedBy' => 'translatable', 'fetch' => ClassMetadataInfo::FETCH_EXTRA_LAZY, 'indexBy' => 'locale', 'cascade' => ['persist', 'merge', 'remove'], 'orphanRemoval' => true]);
 }

 private function mapTranslatable(ClassMetadata $classMetadata)
 {
     if (!$classMetadata->hasAssociation('translations')) {
         $classMetadata->mapOneToMany(['fieldName' => 'translations', 'mappedBy' => 'translatable', 'indexBy' => 'locale', 'cascade' => ['persist', 'merge', 'remove'], 'fetch' => $this->translatableFetchMode, 'targetEntity' => $classMetadata->getReflectionClass()->getMethod('getTranslationEntityClass')->invoke(null), 'orphanRemoval' => true]);
     }
 }

 /**
  * Add mapping data to a translatable entity
  *
  * @param ClassMetadata $mapping
  * @return void
  */
 private function mapTranslatable(ClassMetadata $mapping)
 {
     $metadata = $this->getTranslatableMetadata($mapping->name);
     if (!$mapping->hasAssociation($metadata->translations->name)) {
         $targetMetadata = $this->getTranslatableMetadata($metadata->targetEntity);
         $mapping->mapOneToMany(array('fieldName' => $metadata->translations->name, 'targetEntity' => $metadata->targetEntity, 'mappedBy' => $targetMetadata->translatable->name, 'fetch' => ClassMetadataInfo::FETCH_EXTRA_LAZY, 'indexBy' => $targetMetadata->locale->name, 'cascade' => array('persist', 'merge', 'remove'), 'orphanRemoval' => true));
     }
 }

 /**
  * @param ClassMetadata $classMetadata
  */
 private function mapTranslatable(ClassMetadata $classMetadata)
 {
     if (!$classMetadata->hasAssociation('translations')) {
         $classMetadata->mapOneToMany(array('fieldName' => 'translations', 'mappedBy' => 'translatable', 'indexBy' => 'locale', 'cascade' => array('all'), 'fetch' => $this->translatableFetchMode, 'targetEntity' => $this->getClassName($classMetadata), 'orphanRemoval' => true));
     }
 }

 /**
  * Adds post vote association mapping to User class
  * 
  * @param ClassMetadata $classMetadata
  */
 protected function setPostVoteAssociation(ClassMetadata $classMetadata)
 {
     $classMetadata->mapOneToMany(array('targetEntity' => 'Valantir\\ForumBundle\\Entity\\PostVote', 'fieldName' => 'postsVotes', 'mappedBy' => 'user'));
 }

 protected function updateTranslatableMetadata(ClassMetadata $metadata)
 {
     if (!$metadata->hasAssociation('translations')) {
         $metadata->mapOneToMany(['fieldName' => 'translations', 'mappedBy' => 'translatable', 'indexBy' => 'locale', 'cascade' => ['persist', 'merge', 'remove'], 'fetch' => $this->translatableFetchMode, 'targetEntity' => $metadata->name . 'Translation', 'orphanRemoval' => true]);
     }
 }

 private function mapUserAccessible(ClassMetadata $classMetadata)
 {
     if (!$classMetadata->hasAssociation('userAccesses')) {
         $classMetadata->mapOneToMany(['fieldName' => 'userAccesses', 'mappedBy' => 'userAccessible', 'cascade' => ['persist', 'merge', 'remove'], 'targetEntity' => $classMetadata->name . 'UserAccess', 'orphanRemoval' => true]);
     }
 }

 private function mapTranslatable(ClassMetadata $classMetadata)
 {
     if (!$classMetadata->hasAssociation('translations')) {
         $classMetadata->mapOneToMany(['fieldName' => 'translations', 'mappedBy' => 'translatable', 'cascade' => ['persist', 'merge', 'remove'], 'targetEntity' => $classMetadata->name . 'Translation']);
     }
 }

 private function setServerMetaData(ClassMetadata $metadata)
 {
     $metadata->mapOneToMany(['targetEntity' => ServerModule::class, 'fieldName' => 'modules', 'mappedBy' => 'server']);
 }

 /**
  * Map Translatable
  *
  * @param ClassMetadata $classMetadata
  */
 protected function mapTranslatable(ClassMetadata $classMetadata)
 {
     if (!$classMetadata->hasAssociation('translations')) {
         $classMetadata->mapOneToMany(['fieldName' => 'translations', 'mappedBy' => 'translatable', 'indexBy' => 'locale', 'cascade' => ['persist', 'merge', 'remove'], 'targetEntity' => $classMetadata->name . 'Translation', 'orphanRemoval' => true]);
     }
 }

 /**
  * Add mapping data to a translatable entity
  *
  * @param ClassMetadata $mapping
  * @return void
  */
 private function mapTranslatable(ClassMetadata $mapping)
 {
     $metadata = $this->getTranslatableMetadata($mapping->name);
     if (!$mapping->hasAssociation($metadata->translations->name)) {
         $targetMetadata = $this->getTranslatableMetadata($metadata->targetEntity);
         $mapping->mapOneToMany(array('fieldName' => $metadata->translations->name, 'targetEntity' => $metadata->targetEntity, 'mappedBy' => $targetMetadata->translatable->name, 'fetch' => ClassMetadataInfo::FETCH_LAZY, 'indexBy' => $targetMetadata->locale->name, 'cascade' => array('persist', 'merge', 'remove'), 'orphanRemoval' => true));
         $cacheMap = array('usage' => constant('Doctrine\\ORM\\Mapping\\ClassMetadata::CACHE_USAGE_' . 'NONSTRICT_READ_WRITE'));
         $mapping->enableAssociationCache($metadata->translations->name, $cacheMap);
     }
 }

 /**
  * Loads the metadata for the specified class into the provided container.
  */
 public function loadMetadataForClass($className, ClassMetadata $metadata)
 {
     $annotClass = new \Addendum\ReflectionAnnotatedClass($className);
     // Evaluate DoctrineEntity annotation
     if (($entityAnnot = $annotClass->getAnnotation('DoctrineEntity')) === false) {
         throw DoctrineException::updateMe("{$className} is no entity.");
     }
     $metadata->setCustomRepositoryClass($entityAnnot->repositoryClass);
     // Evaluate DoctrineTable annotation
     if ($tableAnnot = $annotClass->getAnnotation('DoctrineTable')) {
         $metadata->setPrimaryTable(array('name' => $tableAnnot->name, 'schema' => $tableAnnot->schema, 'catalog' => $tableAnnot->catalog));
     }
     // Evaluate DoctrineInheritanceType annotation
     if ($inheritanceTypeAnnot = $annotClass->getAnnotation('DoctrineInheritanceType')) {
         $metadata->setInheritanceType($inheritanceTypeAnnot->value);
     }
     // Evaluate DoctrineDiscriminatorColumn annotation
     if ($discrColumnAnnot = $annotClass->getAnnotation('DoctrineDiscriminatorColumn')) {
         $metadata->setDiscriminatorColumn(array('name' => $discrColumnAnnot->name, 'type' => $discrColumnAnnot->type, 'length' => $discrColumnAnnot->length));
     }
     // Evaluate DoctrineDiscriminatorMap annotation
     if ($discrValueAnnot = $annotClass->getAnnotation('DoctrineDiscriminatorValue')) {
         $metadata->setDiscriminatorValue($discrValueAnnot->value);
     }
     // Evaluate DoctrineSubClasses annotation
     if ($subClassesAnnot = $annotClass->getAnnotation('DoctrineSubClasses')) {
         $metadata->setSubclasses($subClassesAnnot->value);
     }
     // Evaluate DoctrineChangeTrackingPolicy annotation
     if ($changeTrackingAnnot = $annotClass->getAnnotation('DoctrineChangeTrackingPolicy')) {
         $metadata->setChangeTrackingPolicy($changeTrackingAnnot->value);
     }
     // Evaluate annotations on properties/fields
     foreach ($annotClass->getProperties() as $property) {
         if ($metadata->hasField($property->getName())) {
             continue;
         }
         $mapping = array();
         $mapping['fieldName'] = $property->getName();
         // Check for DoctrineJoinColummn/DoctrineJoinColumns annotations
         $joinColumns = array();
         if ($joinColumnAnnot = $property->getAnnotation('DoctrineJoinColumn')) {
             $joinColumns[] = array('name' => $joinColumnAnnot->name, 'referencedColumnName' => $joinColumnAnnot->referencedColumnName, 'unique' => $joinColumnAnnot->unique, 'nullable' => $joinColumnAnnot->nullable, 'onDelete' => $joinColumnAnnot->onDelete, 'onUpdate' => $joinColumnAnnot->onUpdate);
         } else {
             if ($joinColumnsAnnot = $property->getAnnotation('DoctrineJoinColumns')) {
                 $joinColumns = $joinColumnsAnnot->value;
             }
         }
         // Field can only be annotated with one of: DoctrineColumn,
         // DoctrineOneToOne, DoctrineOneToMany, DoctrineManyToOne, DoctrineManyToMany
         if ($columnAnnot = $property->getAnnotation('DoctrineColumn')) {
             if ($columnAnnot->type == null) {
                 throw DoctrineException::updateMe("Missing type on property " . $property->getName());
             }
             $mapping['type'] = $columnAnnot->type;
             $mapping['length'] = $columnAnnot->length;
             $mapping['nullable'] = $columnAnnot->nullable;
             if ($idAnnot = $property->getAnnotation('DoctrineId')) {
                 $mapping['id'] = true;
             }
             if ($generatedValueAnnot = $property->getAnnotation('DoctrineGeneratedValue')) {
                 $metadata->setIdGeneratorType($generatedValueAnnot->strategy);
             }
             $metadata->mapField($mapping);
             // Check for SequenceGenerator/TableGenerator definition
             if ($seqGeneratorAnnot = $property->getAnnotation('DoctrineSequenceGenerator')) {
                 $metadata->setSequenceGeneratorDefinition(array('sequenceName' => $seqGeneratorAnnot->sequenceName, 'allocationSize' => $seqGeneratorAnnot->allocationSize, 'initialValue' => $seqGeneratorAnnot->initialValue));
             } else {
                 if ($tblGeneratorAnnot = $property->getAnnotation('DoctrineTableGenerator')) {
                     throw new DoctrineException("DoctrineTableGenerator not yet implemented.");
                 }
             }
         } else {
             if ($oneToOneAnnot = $property->getAnnotation('DoctrineOneToOne')) {
                 $mapping['targetEntity'] = $oneToOneAnnot->targetEntity;
                 $mapping['joinColumns'] = $joinColumns;
                 $mapping['mappedBy'] = $oneToOneAnnot->mappedBy;
                 $mapping['cascade'] = $oneToOneAnnot->cascade;
                 $metadata->mapOneToOne($mapping);
             } else {
                 if ($oneToManyAnnot = $property->getAnnotation('DoctrineOneToMany')) {
                     $mapping['mappedBy'] = $oneToManyAnnot->mappedBy;
                     $mapping['targetEntity'] = $oneToManyAnnot->targetEntity;
                     $mapping['cascade'] = $oneToManyAnnot->cascade;
                     $metadata->mapOneToMany($mapping);
                 } else {
                     if ($manyToOneAnnot = $property->getAnnotation('DoctrineManyToOne')) {
                         $mapping['joinColumns'] = $joinColumns;
                         $mapping['cascade'] = $manyToOneAnnot->cascade;
                         $mapping['targetEntity'] = $manyToOneAnnot->targetEntity;
                         $metadata->mapManyToOne($mapping);
                     } else {
                         if ($manyToManyAnnot = $property->getAnnotation('DoctrineManyToMany')) {
                             $joinTable = array();
                             if ($joinTableAnnot = $property->getAnnotation('DoctrineJoinTable')) {
                                 $joinTable = array('name' => $joinTableAnnot->name, 'schema' => $joinTableAnnot->schema, 'catalog' => $joinTableAnnot->catalog, 'joinColumns' => $joinTableAnnot->joinColumns, 'inverseJoinColumns' => $joinTableAnnot->inverseJoinColumns);
                             }
//.........这里部分代码省略.........