PHP MappingException::reflectionFailure方法代码示例

 /**
  * {@inheritDoc}
  */
 protected function doLoadMetadata($class, $parent, $rootEntityFound, array $nonSuperclassParents)
 {
     /* @var $class ClassMetadata */
     /* @var $parent ClassMetadata */
     if ($parent) {
         $class->setInheritanceType($parent->inheritanceType);
         $class->setDiscriminatorColumn($parent->discriminatorColumn);
         $class->setIdGeneratorType($parent->generatorType);
         $this->addInheritedFields($class, $parent);
         $this->addInheritedRelations($class, $parent);
         $this->addInheritedEmbeddedClasses($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);
         if (!empty($parent->customGeneratorDefinition)) {
             $class->setCustomGeneratorDefinition($parent->customGeneratorDefinition);
         }
         if ($parent->isMappedSuperclass) {
             $class->setCustomRepositoryClass($parent->customRepositoryClassName);
         }
     }
     // Invoke driver
     try {
         $this->driver->loadMetadataForClass($class->getName(), $class);
     } catch (ReflectionException $e) {
         throw MappingException::reflectionFailure($class->getName(), $e);
     }
     // If this class has a parent the id generator strategy is inherited.
     // However this is only true if the hierarchy of parents contains the root entity,
     // if it consists 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->tableGeneratorDefinition = $parent->tableGeneratorDefinition;
             }
         }
         if ($parent->generatorType) {
             $class->setIdGeneratorType($parent->generatorType);
         }
         if ($parent->idGenerator) {
             $class->setIdGenerator($parent->idGenerator);
         }
     } else {
         $this->completeIdGeneratorMapping($class);
     }
     if (!$class->isMappedSuperclass) {
         foreach ($class->embeddedClasses as $property => $embeddableClass) {
             if (isset($embeddableClass['inherited'])) {
                 continue;
             }
             if (isset($this->embeddablesActiveNesting[$embeddableClass['class']])) {
                 throw MappingException::infiniteEmbeddableNesting($class->name, $property);
             }
             $this->embeddablesActiveNesting[$class->name] = true;
             $embeddableMetadata = $this->getMetadataFor($embeddableClass['class']);
             if ($embeddableMetadata->isEmbeddedClass) {
                 $this->addNestedEmbeddedClasses($embeddableMetadata, $class, $property);
             }
             $class->inlineEmbeddable($property, $embeddableMetadata);
             unset($this->embeddablesActiveNesting[$class->name]);
         }
     }
     if ($parent && $parent->isInheritanceTypeSingleTable()) {
         $class->setPrimaryTable($parent->table);
     }
     if ($parent && $parent->cache) {
         $class->cache = $parent->cache;
     }
     if ($parent && $parent->containsForeignIdentifier) {
         $class->containsForeignIdentifier = true;
     }
     if ($parent && !empty($parent->namedQueries)) {
         $this->addInheritedNamedQueries($class, $parent);
     }
     if ($parent && !empty($parent->namedNativeQueries)) {
         $this->addInheritedNamedNativeQueries($class, $parent);
     }
     if ($parent && !empty($parent->sqlResultSetMappings)) {
         $this->addInheritedSqlResultSetMappings($class, $parent);
     }
     if ($parent && !empty($parent->entityListeners) && empty($class->entityListeners)) {
         $class->entityListeners = $parent->entityListeners;
     }
     $class->setParentClasses($nonSuperclassParents);
     if ($class->isRootEntity() && !$class->isInheritanceTypeNone() && !$class->discriminatorMap) {
         $this->addDefaultDiscriminatorMap($class);
     }
     if ($this->evm->hasListeners(Events::loadClassMetadata)) {
         $eventArgs = new LoadClassMetadataEventArgs($class, $this->em);
         $this->evm->dispatchEvent(Events::loadClassMetadata, $eventArgs);
     }
     $this->validateRuntimeMetadata($class, $parent);
//.........这里部分代码省略.........

 /**
  * @SuppressWarnings(PHPMD.ExcessiveMethodLength)
  */
 protected function initialize($metadata)
 {
     $dict1GrpCfg = $this->createEntityConfig('grouping', 'Acme\\TestBundle\\Entity\\Dictionary1', ['groups' => [GroupingScope::GROUP_DICTIONARY]]);
     $dict1Cfg = $this->createEntityConfig('dictionary', 'Acme\\TestBundle\\Entity\\Dictionary1', ['virtual_fields' => ['name']]);
     $dict2GrpCfg = $this->createEntityConfig('grouping', 'Acme\\TestBundle\\Entity\\Dictionary2', ['groups' => [GroupingScope::GROUP_DICTIONARY]]);
     $dict2Cfg = $this->createEntityConfig('dictionary', 'Acme\\TestBundle\\Entity\\Dictionary2', ['virtual_fields' => ['id', 'name']]);
     $dict3GrpCfg = $this->createEntityConfig('grouping', 'Acme\\TestBundle\\Entity\\Dictionary3', ['groups' => [GroupingScope::GROUP_DICTIONARY]]);
     $dict3Cfg = $this->createEntityConfig('dictionary', 'Acme\\TestBundle\\Entity\\Dictionary3');
     $dict4GrpCfg = $this->createEntityConfig('grouping', 'Acme\\TestBundle\\Entity\\Dictionary4', ['groups' => [GroupingScope::GROUP_DICTIONARY]]);
     $dict4Cfg = $this->createEntityConfig('dictionary', 'Acme\\TestBundle\\Entity\\Dictionary4');
     $this->groupingConfigProvider->expects($this->any())->method('getConfigs')->will($this->returnValue([$dict1GrpCfg, $dict2GrpCfg, $dict3GrpCfg, $dict4GrpCfg]));
     $this->dictionaryConfigProvider->expects($this->any())->method('hasConfig')->will($this->returnCallback(function ($className, $fieldName) {
         return in_array($className, ['Acme\\TestBundle\\Entity\\Dictionary1', 'Acme\\TestBundle\\Entity\\Dictionary2', 'Acme\\TestBundle\\Entity\\Dictionary3', 'Acme\\TestBundle\\Entity\\Dictionary4']);
     }));
     $this->dictionaryConfigProvider->expects($this->any())->method('getConfig')->will($this->returnCallback(function ($className, $fieldName) use(&$dict1Cfg, &$dict2Cfg, &$dict3Cfg, &$dict4Cfg) {
         switch ($className) {
             case 'Acme\\TestBundle\\Entity\\Dictionary1':
                 return $dict1Cfg;
             case 'Acme\\TestBundle\\Entity\\Dictionary2':
                 return $dict2Cfg;
             case 'Acme\\TestBundle\\Entity\\Dictionary3':
                 return $dict3Cfg;
             case 'Acme\\TestBundle\\Entity\\Dictionary4':
                 return $dict4Cfg;
             default:
                 throw new RuntimeException(sprintf('Entity "%s" is not configurable', $className));
         }
     }));
     $mDataDict1 = $this->createDictionaryMetadata();
     $mDataDict2 = $this->createDictionaryMetadata();
     $mDataDict3 = $this->createDictionaryMetadata();
     $mDataDict4 = $this->createDictionaryMetadata(['name' => 'string', 'code' => 'string', 'label' => 'string'], 'name');
     $this->em->expects($this->any())->method('getClassMetadata')->will($this->returnCallback(function ($className) use(&$metadata, &$mDataDict1, &$mDataDict2, &$mDataDict3, &$mDataDict4) {
         switch ($className) {
             case 'Acme\\TestBundle\\Entity\\Dictionary1':
                 return $mDataDict1;
             case 'Acme\\TestBundle\\Entity\\Dictionary2':
                 return $mDataDict2;
             case 'Acme\\TestBundle\\Entity\\Dictionary3':
                 return $mDataDict3;
             case 'Acme\\TestBundle\\Entity\\Dictionary4':
                 return $mDataDict4;
             default:
                 if (isset($metadata[$className])) {
                     return $metadata[$className];
                 }
                 throw MappingException::reflectionFailure($className, new \ReflectionException());
         }
     }));
 }

 /**
  * 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);
             }
//.........这里部分代码省略.........

 /**
  * 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);
         }
         if ($parent && $parent->containsForeignIdentifier) {
             $class->containsForeignIdentifier = true;
         }
         $class->setParentClasses($visited);
         if ($this->evm->hasListeners(Events::loadClassMetadata)) {
             $eventArgs = new \Doctrine\ORM\Event\LoadClassMetadataEventArgs($class, $this->em);
             $this->evm->dispatchEvent(Events::loadClassMetadata, $eventArgs);
         }
         $this->validateRuntimeMetadata($class, $parent);
         $this->loadedMetadata[$className] = $class;
         $parent = $class;
         if (!$class->isMappedSuperclass) {
             $rootEntityFound = true;
             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();
     $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;
 }