PHP MappingException::identifierRequired方法代码示例

 /**
  * Validate Identifier
  *
  * @throws MappingException
  * @return void
  */
 public function validateIdentifier()
 {
     // Verify & complete identifier mapping
     if (!$this->identifier && !$this->isMappedSuperclass) {
         throw MappingException::identifierRequired($this->name);
     }
     if ($this->usesIdGenerator() && $this->isIdentifierComposite) {
         throw MappingException::compositeKeyAssignedIdGeneratorRequired($this->name);
     }
 }

 /**
  * Loads the metadata of the class in question and all it's ancestors whose metadata
  * is still not loaded.
  *
  * @param string $name The name of the class for which the metadata should get loaded.
  * @param array  $tables The metadata collection to which the loaded metadata is added.
  */
 protected function loadMetadata($name)
 {
     if (!$this->initialized) {
         $this->initialize();
     }
     $loaded = array();
     $parentClasses = $this->getParentClasses($name);
     $parentClasses[] = $name;
     // Move down the hierarchy of parent classes, starting from the topmost class
     $parent = null;
     $rootEntityFound = false;
     $visited = array();
     foreach ($parentClasses as $className) {
         if (isset($this->loadedMetadata[$className])) {
             $parent = $this->loadedMetadata[$className];
             if (!$parent->isMappedSuperclass) {
                 $rootEntityFound = true;
                 array_unshift($visited, $className);
             }
             continue;
         }
         $class = $this->newClassMetadataInstance($className);
         if ($parent) {
             $class->setInheritanceType($parent->inheritanceType);
             $class->setDiscriminatorColumn($parent->discriminatorColumn);
             $class->setIdGeneratorType($parent->generatorType);
             $this->addInheritedFields($class, $parent);
             $this->addInheritedRelations($class, $parent);
             $class->setIdentifier($parent->identifier);
             $class->setVersioned($parent->isVersioned);
             $class->setVersionField($parent->versionField);
             $class->setDiscriminatorMap($parent->discriminatorMap);
             $class->setLifecycleCallbacks($parent->lifecycleCallbacks);
             $class->setChangeTrackingPolicy($parent->changeTrackingPolicy);
         }
         // Invoke driver
         try {
             $this->driver->loadMetadataForClass($className, $class);
         } catch (ReflectionException $e) {
             throw MappingException::reflectionFailure($className, $e);
         }
         // If this class has a parent the id generator strategy is inherited.
         // However this is only true if the hierachy of parents contains the root entity,
         // if it consinsts of mapped superclasses these don't necessarily include the id field.
         if ($parent && $rootEntityFound) {
             if ($parent->isIdGeneratorSequence()) {
                 $class->setSequenceGeneratorDefinition($parent->sequenceGeneratorDefinition);
             } else {
                 if ($parent->isIdGeneratorTable()) {
                     $class->getTableGeneratorDefinition($parent->tableGeneratorDefinition);
                 }
             }
             if ($parent->generatorType) {
                 $class->setIdGeneratorType($parent->generatorType);
             }
             if ($parent->idGenerator) {
                 $class->setIdGenerator($parent->idGenerator);
             }
         } else {
             $this->completeIdGeneratorMapping($class);
         }
         if ($parent && $parent->isInheritanceTypeSingleTable()) {
             $class->setPrimaryTable($parent->table);
         }
         $class->setParentClasses($visited);
         if ($this->evm->hasListeners(Events::loadClassMetadata)) {
             $eventArgs = new \Doctrine\ORM\Event\LoadClassMetadataEventArgs($class, $this->em);
             $this->evm->dispatchEvent(Events::loadClassMetadata, $eventArgs);
         }
         // Verify & complete identifier mapping
         if (!$class->identifier && !$class->isMappedSuperclass) {
             throw MappingException::identifierRequired($className);
         }
         // verify inheritance
         if (!$class->isMappedSuperclass && !$class->isInheritanceTypeNone()) {
             if (!$parent) {
                 if (count($class->discriminatorMap) == 0) {
                     throw MappingException::missingDiscriminatorMap($class->name);
                 }
                 if (!$class->discriminatorColumn) {
                     throw MappingException::missingDiscriminatorColumn($class->name);
                 }
             } else {
                 if ($parent && !$class->reflClass->isAbstract() && !in_array($class->name, array_values($class->discriminatorMap))) {
                     // enforce discriminator map for all entities of an inheritance hierachy, otherwise problems will occur.
                     throw MappingException::mappedClassNotPartOfDiscriminatorMap($class->name, $class->rootEntityName);
                 }
             }
         } else {
             if ($class->isMappedSuperclass && $class->name == $class->rootEntityName && (count($class->discriminatorMap) || $class->discriminatorColumn)) {
                 // second condition is necessary for mapped superclasses in the middle of an inheritance hierachy
                 throw MappingException::noInheritanceOnMappedSuperClass($class->name);
             }
//.........这里部分代码省略.........

 /**
  * Validate runtime metadata is correctly defined.
  *
  * @param ClassMetadata $class
  * @param ClassMetadata $parent
  */
 protected function validateRuntimeMetadata($class, $parent)
 {
     // Verify & complete identifier mapping
     if (!$class->identifier && !$class->isMappedSuperclass) {
         throw MappingException::identifierRequired($class->name);
     }
     // verify inheritance
     if (!$class->isMappedSuperclass && !$class->isInheritanceTypeNone()) {
         if (!$parent) {
             if (count($class->discriminatorMap) == 0) {
                 throw MappingException::missingDiscriminatorMap($class->name);
             }
             if (!$class->discriminatorColumn) {
                 throw MappingException::missingDiscriminatorColumn($class->name);
             }
         } else {
             if ($parent && !$class->reflClass->isAbstract() && !in_array($class->name, array_values($class->discriminatorMap))) {
                 // enforce discriminator map for all entities of an inheritance hierachy, otherwise problems will occur.
                 throw MappingException::mappedClassNotPartOfDiscriminatorMap($class->name, $class->rootEntityName);
             }
         }
     } else {
         if ($class->isMappedSuperclass && $class->name == $class->rootEntityName && (count($class->discriminatorMap) || $class->discriminatorColumn)) {
             // second condition is necessary for mapped superclasses in the middle of an inheritance hierachy
             throw MappingException::noInheritanceOnMappedSuperClass($class->name);
         }
     }
 }

 /**
  * Loads the metadata of the class in question and all it's ancestors whose metadata
  * is still not loaded.
  *
  * @param string $name The name of the class for which the metadata should get loaded.
  * @param array  $tables The metadata collection to which the loaded metadata is added.
  */
 protected function loadMetadata($name)
 {
     if (!$this->initialized) {
         $this->initialize();
     }
     $loaded = array();
     $parentClasses = $this->getParentClasses($name);
     $parentClasses[] = $name;
     // Move down the hierarchy of parent classes, starting from the topmost class
     $parent = null;
     $visited = array();
     foreach ($parentClasses as $className) {
         if (isset($this->loadedMetadata[$className])) {
             $parent = $this->loadedMetadata[$className];
             if (!$parent->isMappedSuperclass) {
                 array_unshift($visited, $className);
             }
             continue;
         }
         $class = $this->newClassMetadataInstance($className);
         if ($parent) {
             $class->setInheritanceType($parent->inheritanceType);
             $class->setDiscriminatorColumn($parent->discriminatorColumn);
             $class->setIdGeneratorType($parent->generatorType);
             $this->addInheritedFields($class, $parent);
             $this->addInheritedRelations($class, $parent);
             $class->setIdentifier($parent->identifier);
             $class->setVersioned($parent->isVersioned);
             $class->setVersionField($parent->versionField);
             $class->setDiscriminatorMap($parent->discriminatorMap);
             $class->setLifecycleCallbacks($parent->lifecycleCallbacks);
             $class->setChangeTrackingPolicy($parent->changeTrackingPolicy);
         }
         // Invoke driver
         try {
             $this->driver->loadMetadataForClass($className, $class);
         } catch (ReflectionException $e) {
             throw MappingException::reflectionFailure($className, $e);
         }
         // Verify & complete identifier mapping
         if (!$class->identifier && !$class->isMappedSuperclass) {
             throw MappingException::identifierRequired($className);
         }
         if ($parent && !$parent->isMappedSuperclass) {
             if ($parent->isIdGeneratorSequence()) {
                 $class->setSequenceGeneratorDefinition($parent->sequenceGeneratorDefinition);
             } else {
                 if ($parent->isIdGeneratorTable()) {
                     $class->getTableGeneratorDefinition($parent->tableGeneratorDefinition);
                 }
             }
             if ($parent->generatorType) {
                 $class->setIdGeneratorType($parent->generatorType);
             }
             if ($parent->idGenerator) {
                 $class->setIdGenerator($parent->idGenerator);
             }
         } else {
             $this->completeIdGeneratorMapping($class);
         }
         if ($parent && $parent->isInheritanceTypeSingleTable()) {
             $class->setPrimaryTable($parent->table);
         }
         $class->setParentClasses($visited);
         if ($this->evm->hasListeners(Events::loadClassMetadata)) {
             $eventArgs = new \Doctrine\ORM\Event\LoadClassMetadataEventArgs($class);
             $this->evm->dispatchEvent(Events::loadClassMetadata, $eventArgs);
         }
         // verify inheritance
         if (!$parent && !$class->isMappedSuperclass && !$class->isInheritanceTypeNone()) {
             if (count($class->discriminatorMap) == 0) {
                 throw MappingException::missingDiscriminatorMap($class->name);
             }
             if (!$class->discriminatorColumn) {
                 throw MappingException::missingDiscriminatorColumn($class->name);
             }
         }
         $this->loadedMetadata[$className] = $class;
         $parent = $class;
         if (!$class->isMappedSuperclass) {
             array_unshift($visited, $className);
         }
         $loaded[] = $className;
     }
     return $loaded;
 }

 /**
  * Loads the metadata of the class in question and all it's ancestors whose metadata
  * is still not loaded.
  *
  * @param string $name The name of the class for which the metadata should get loaded.
  * @param array  $tables The metadata collection to which the loaded metadata is added.
  */
 protected function _loadMetadata($name)
 {
     if (!$this->_initialized) {
         $this->_initialize();
     }
     $loaded = array();
     // Collect parent classes, ignoring transient (not-mapped) classes.
     //TODO: Evaluate whether we can use class_parents() here.
     $parentClass = $name;
     $parentClasses = array();
     while ($parentClass = get_parent_class($parentClass)) {
         if (!$this->_driver->isTransient($parentClass)) {
             $parentClasses[] = $parentClass;
         }
     }
     $parentClasses = array_reverse($parentClasses);
     $parentClasses[] = $name;
     // Move down the hierarchy of parent classes, starting from the topmost class
     $parent = null;
     $visited = array();
     foreach ($parentClasses as $className) {
         if (isset($this->_loadedMetadata[$className])) {
             $parent = $this->_loadedMetadata[$className];
             if (!$parent->isMappedSuperclass) {
                 array_unshift($visited, $className);
             }
             continue;
         }
         $class = $this->_newClassMetadataInstance($className);
         if ($parent) {
             $class->setInheritanceType($parent->inheritanceType);
             $class->setDiscriminatorColumn($parent->discriminatorColumn);
             $class->setIdGeneratorType($parent->generatorType);
             $this->_addInheritedFields($class, $parent);
             $this->_addInheritedRelations($class, $parent);
             $class->setIdentifier($parent->identifier);
             $class->setVersioned($parent->isVersioned);
             $class->setVersionField($parent->versionField);
             $class->setDiscriminatorMap($parent->discriminatorMap);
             $class->setLifecycleCallbacks($parent->lifecycleCallbacks);
         }
         // Invoke driver
         try {
             $this->_driver->loadMetadataForClass($className, $class);
         } catch (\ReflectionException $e) {
             throw MappingException::reflectionFailure($className, $e);
         }
         // Verify & complete identifier mapping
         if (!$class->identifier && !$class->isMappedSuperclass) {
             throw MappingException::identifierRequired($className);
         }
         if ($parent && !$parent->isMappedSuperclass) {
             if ($parent->isIdGeneratorSequence()) {
                 $class->setSequenceGeneratorDefinition($parent->sequenceGeneratorDefinition);
             } else {
                 if ($parent->isIdGeneratorTable()) {
                     $class->getTableGeneratorDefinition($parent->tableGeneratorDefinition);
                 }
             }
             if ($generatorType = $parent->generatorType) {
                 $class->setIdGeneratorType($generatorType);
             }
             if ($parent->idGenerator) {
                 $class->setIdGenerator($parent->idGenerator);
             }
         } else {
             $this->_completeIdGeneratorMapping($class);
         }
         if ($parent && $parent->isInheritanceTypeSingleTable()) {
             $class->setTableName($parent->getTableName());
         }
         $class->setParentClasses($visited);
         if ($this->_evm->hasListeners(Events::loadClassMetadata)) {
             $eventArgs = new \Doctrine\ORM\Event\LoadClassMetadataEventArgs($class);
             $this->_evm->dispatchEvent(Events::loadClassMetadata, $eventArgs);
         }
         $this->_loadedMetadata[$className] = $class;
         $parent = $class;
         if (!$class->isMappedSuperclass) {
             array_unshift($visited, $className);
         }
         $loaded[] = $className;
     }
     return $loaded;
 }

 /**
  * Loads the metadata of the class in question and all it's ancestors whose metadata
  * is still not loaded.
  *
  * @param string $name The name of the class for which the metadata should get loaded.
  * @param array  $tables The metadata collection to which the loaded metadata is added.
  */
 protected function _loadMetadata($name)
 {
     // Collect parent classes, ignoring transient (not-mapped) classes.
     $parentClass = $name;
     $parentClasses = array();
     while ($parentClass = get_parent_class($parentClass)) {
         if (!$this->_driver->isTransient($parentClass)) {
             $parentClasses[] = $parentClass;
         }
     }
     $parentClasses = array_reverse($parentClasses);
     $parentClasses[] = $name;
     // Move down the hierarchy of parent classes, starting from the topmost class
     $parent = null;
     $visited = array();
     foreach ($parentClasses as $className) {
         if (isset($this->_loadedMetadata[$className])) {
             $parent = $this->_loadedMetadata[$className];
             array_unshift($visited, $className);
             continue;
         }
         $class = $this->_newClassMetadataInstance($className);
         if ($parent) {
             $class->setInheritanceType($parent->inheritanceType);
             $class->setDiscriminatorColumn($parent->discriminatorColumn);
             $class->setIdGeneratorType($parent->generatorType);
             $this->_addInheritedFields($class, $parent);
             $this->_addInheritedRelations($class, $parent);
             $class->setIdentifier($parent->identifier);
         }
         // Invoke driver
         $this->_driver->loadMetadataForClass($className, $class);
         // Verify & complete identifier mapping
         if (!$class->identifier) {
             throw MappingException::identifierRequired($className);
         }
         if ($parent) {
             if ($parent->isIdGeneratorSequence()) {
                 $class->setSequenceGeneratorDefinition($parent->getSequenceGeneratorDefinition());
             } else {
                 if ($parent->isIdGeneratorTable()) {
                     $class->getTableGeneratorDefinition($parent->getTableGeneratorDefinition());
                 }
             }
             $class->setIdGeneratorType($parent->generatorType);
             $class->setidGenerator($parent->getIdGenerator());
         } else {
             $this->_completeIdGeneratorMapping($class);
         }
         if ($parent && $parent->isInheritanceTypeSingleTable()) {
             $class->setTableName($parent->getTableName());
         }
         $class->setParentClasses($visited);
         $this->_generateStaticSql($class);
         $this->_loadedMetadata[$className] = $class;
         $parent = $class;
         array_unshift($visited, $className);
     }
 }