PHP Configuration::getMetadataDriverImpl方法代码示例

 /**
  * @param OrmConfiguration $configuration
  */
 public function addEntityNamespaces(OrmConfiguration $configuration)
 {
     $this->knownNamespaceAlias = array_merge($this->knownNamespaceAlias, $configuration->getEntityNamespaces());
     if ($configuration->getMetadataDriverImpl()) {
         $this->entityClassnames = array_merge($this->entityClassnames, $configuration->getMetadataDriverImpl()->getAllClassNames());
     }
 }

 public function testSetGetMetadataDriverImpl()
 {
     $this->assertSame(null, $this->configuration->getMetadataDriverImpl());
     // defaults
     $metadataDriver = $this->getMock('Doctrine\\Common\\Persistence\\Mapping\\Driver\\MappingDriver');
     $this->configuration->setMetadataDriverImpl($metadataDriver);
     $this->assertSame($metadataDriver, $this->configuration->getMetadataDriverImpl());
 }

 /**
  * Set the association mappings of a metadata.
  *
  * @param ClassMetadataInfo $metadata
  * @param Configuration     $configuration
  */
 protected function setAssociationMappings(ClassMetadataInfo $metadata, Configuration $configuration)
 {
     $supportedClasses = $configuration->getMetadataDriverImpl()->getAllClassNames();
     foreach (class_parents($metadata->getName()) as $parent) {
         if (in_array($parent, $supportedClasses)) {
             $parentMetadata = new OrmClassMetadata($parent, $configuration->getNamingStrategy());
             $configuration->getMetadataDriverImpl()->loadMetadataForClass($parent, $parentMetadata);
             foreach ($parentMetadata->getAssociationMappings() as $key => $value) {
                 if ($this->hasRelation($value['type'])) {
                     $metadata->associationMappings[$key] = $value;
                 }
             }
         }
     }
 }

 /**
  * {@inheritdoc}
  */
 public static function create($conn, Configuration $config, EventManager $eventManager = null)
 {
     if (!$config->getMetadataDriverImpl()) {
         throw ORMException::missingMappingDriverImpl();
     }
     switch (true) {
         case is_array($conn):
             if (!$eventManager) {
                 $eventManager = new EventManager();
             }
             if (isset($conn['prefix']) && $conn['prefix']) {
                 $eventManager->addEventListener(Events::loadClassMetadata, new TablePrefix($conn['prefix']));
             }
             $conn = \Doctrine\DBAL\DriverManager::getConnection($conn, $config, $eventManager);
             break;
         case $conn instanceof Connection:
             if ($eventManager !== null && $conn->getEventManager() !== $eventManager) {
                 throw ORMException::mismatchedEventManager();
             }
             break;
         default:
             throw new \InvalidArgumentException("Invalid argument: " . $conn);
     }
     return new self($conn, $config, $conn->getEventManager());
 }

 /**
  * @param ClassMetadataInfo           $metadata
  * @param \Doctrine\ORM\Configuration $configuration
  */
 private function setAssociationMappings(ClassMetadataInfo $metadata, $configuration)
 {
     foreach (class_parents($metadata->getName()) as $parent) {
         $parentMetadata = new ClassMetadata($parent, $configuration->getNamingStrategy());
         if (in_array($parent, $configuration->getMetadataDriverImpl()->getAllClassNames())) {
             $configuration->getMetadataDriverImpl()->loadMetadataForClass($parent, $parentMetadata);
             if ($parentMetadata->isMappedSuperclass) {
                 foreach ($parentMetadata->getAssociationMappings() as $key => $value) {
                     if ($this->hasRelation($value['type'])) {
                         $metadata->associationMappings[$key] = $value;
                     }
                 }
             }
         }
     }
 }

 /**
  * @param                        $connection
  * @param Extension              $extension
  * @param EntityManagerInterface $em
  * @param EventManager           $evm
  * @param Configuration          $configuration
  */
 protected function bootExtension($connection, Extension $extension, EntityManagerInterface $em, EventManager $evm, Configuration $configuration)
 {
     $extension->addSubscribers($evm, $em, $configuration->getMetadataDriverImpl()->getReader());
     if (is_array($extension->getFilters())) {
         foreach ($extension->getFilters() as $name => $filter) {
             $configuration->addFilter($name, $filter);
             $em->getFilters()->enable($name);
         }
     }
     $this->markAsBooted($connection, $extension);
 }

 /**
  * Enable Gedmo Doctrine Extensions
  *
  * @param array $namespaces
  * @param bool  $all
  */
 public function bootGedmoExtensions($namespaces = ['App'], $all = true)
 {
     if ($all) {
         DoctrineExtensions::registerMappingIntoDriverChainORM($this->chain, $this->reader);
     } else {
         DoctrineExtensions::registerAbstractMappingIntoDriverChainORM($this->chain, $this->reader);
     }
     $driver = $this->metadata->getMetadataDriverImpl();
     foreach ($namespaces as $namespace) {
         $this->chain->addDriver($driver, $namespace);
     }
     $this->metadata->setMetadataDriverImpl($this->chain);
     $this->dispatcher->fire('doctrine.driver-chain::booted', [$driver, $this->chain]);
 }

 public function testLoadClassMetadataWithoutParent()
 {
     $this->loadClassMetadataEvent->getClassMetadata()->willReturn($this->classMetadata->reveal());
     $this->classMetadata->getName()->willReturn(get_class($this->object->reveal()));
     $this->classMetadata->setCustomRepositoryClass('Sulu\\Bundle\\ContactBundle\\Entity\\ContactRepository')->shouldNotBeCalled();
     $this->loadClassMetadataEvent->getEntityManager()->willReturn($this->entityManager->reveal());
     $this->entityManager->getConfiguration()->willReturn($this->configuration->reveal());
     $this->configuration->getNamingStrategy()->willReturn(null);
     /** @var \Doctrine\Common\Persistence\Mapping\Driver\MappingDriver $mappingDriver */
     $mappingDriver = $this->prophesize('Doctrine\\Common\\Persistence\\Mapping\\Driver\\MappingDriver');
     $this->configuration->getMetadataDriverImpl()->willReturn($mappingDriver->reveal());
     $mappingDriver->getAllClassNames()->willReturn([get_class($this->parentObject->reveal())]);
     $mappingDriver->loadMetadataForClass(get_class($this->parentObject->reveal()), Argument::type('Doctrine\\ORM\\Mapping\\ClassMetadata'))->shouldBeCalled();
     $this->subscriber->loadClassMetadata($this->loadClassMetadataEvent->reveal());
 }

 public static function create($conn, Configuration $config, EventManager $eventManager = null)
 {
     if (!$config->getMetadataDriverImpl()) {
         throw ORMException::missingMappingDriverImpl();
     }
     if (is_array($conn)) {
         $conn = \Doctrine\DBAL\DriverManager::getConnection($conn, $config, $eventManager ?: new EventManager());
     } elseif ($conn instanceof Connection) {
         if ($eventManager !== null && $conn->getEventManager() !== $eventManager) {
             throw ORMException::mismatchedEventManager();
         }
     } else {
         throw new \InvalidArgumentException("Invalid argument: " . $conn);
     }
     return new OroEntityManager($conn, $config, $conn->getEventManager());
 }

 /**
  * Factory method to create EntityManager instances.
  *
  * @param \Doctrine\DBAL\Connection|array $conn
  * @param \Doctrine\ORM\Configuration $config
  * @param \Doctrine\Common\EventManager $eventManager
  * @throws \Doctrine\ORM\ORMException
  * @throws InvalidArgumentException
  * @throws \Doctrine\ORM\ORMException
  * @return EntityManager
  */
 public static function create($conn, Doctrine\ORM\Configuration $config, Doctrine\Common\EventManager $eventManager = NULL)
 {
     if (!$config->getMetadataDriverImpl()) {
         throw ORMException::missingMappingDriverImpl();
     }
     switch (TRUE) {
         case is_array($conn):
             $conn = DriverManager::getConnection($conn, $config, $eventManager ?: new Doctrine\Common\EventManager());
             break;
         case $conn instanceof Doctrine\DBAL\Connection:
             if ($eventManager !== NULL && $conn->getEventManager() !== $eventManager) {
                 throw ORMException::mismatchedEventManager();
             }
             break;
         default:
             throw new InvalidArgumentException("Invalid connection");
     }
     return new EntityManager($conn, $config, $conn->getEventManager());
 }

 /**
  * Copied from Doctrine\ORM\EntityManager, cause return use new EntityManager() instead of new static()
  *
  * @param mixed $conn
  * @param Configuration $config
  * @param EventManager|null $eventManager
  * @return EntityManager
  * @throws ORMException
  * @throws \Doctrine\DBAL\DBALException
  */
 public static function create($conn, Configuration $config, EventManager $eventManager = null)
 {
     if (!$config->getMetadataDriverImpl()) {
         throw ORMException::missingMappingDriverImpl();
     }
     switch (true) {
         case is_array($conn):
             $conn = \Doctrine\DBAL\DriverManager::getConnection($conn, $config, $eventManager ?: new EventManager());
             break;
         case $conn instanceof Connection:
             if ($eventManager !== null && $conn->getEventManager() !== $eventManager) {
                 throw ORMException::mismatchedEventManager();
             }
             break;
         default:
             throw new \InvalidArgumentException("Invalid argument: " . $conn);
     }
     return new static($conn, $config, $conn->getEventManager());
 }

 /**
  * @param array         $settings
  * @param Configuration $configuration
  */
 protected function setCustomMappingDriverChain(array $settings = [], Configuration $configuration)
 {
     $chain = new MappingDriverChain($configuration->getMetadataDriverImpl(), 'LaravelDoctrine');
     foreach (array_get($settings, 'namespaces', []) as $alias => $namespace) {
         if (is_string($alias)) {
             $configuration->addEntityNamespace($alias, $namespace);
         }
         $chain->addNamespace($namespace);
     }
     $configuration->setMetadataDriverImpl($chain);
 }

 /**
  * @param Configuration $configuration
  *
  * @return array
  */
 private function getAllClassNames(Configuration $configuration)
 {
     if (!$this->classNames) {
         $this->classNames = $configuration->getMetadataDriverImpl()->getAllClassNames();
     }
     return $this->classNames;
 }

 public function __construct(\Doctrine\ORM\Configuration $Configuration)
 {
     $this->driver = $Configuration->getMetadataDriverImpl();
     $this->cachedMap = array();
 }

 /**
  * Factory method to create EntityManager instances.
  *
  * @param array|Connection $connection   An array with the connection parameters or an existing Connection instance.
  * @param Configuration    $config       The Configuration instance to use.
  * @param EventManager     $eventManager The EventManager instance to use.
  *
  * @return EntityManager The created EntityManager.
  *
  * @throws \InvalidArgumentException
  * @throws ORMException
  */
 public static function create($connection, Configuration $config, EventManager $eventManager = null)
 {
     if (!$config->getMetadataDriverImpl()) {
         throw ORMException::missingMappingDriverImpl();
     }
     $connection = static::createConnection($connection, $config, $eventManager);
     return new EntityManager($connection, $config, $connection->getEventManager());
 }