vendor/doctrine/persistence/lib/Doctrine/Persistence/Mapping/Driver/MappingDriverChain.php line 97

Open in your IDE?
  1. <?php
  3. namespace Doctrine\Persistence\Mapping\Driver;
  5. use Doctrine\Persistence\Mapping\ClassMetadata;
  6. use Doctrine\Persistence\Mapping\MappingException;
  7. use function array_keys;
  8. use function class_exists;
  9. use function interface_exists;
  10. use function spl_object_hash;
  11. use function strpos;
  13. /**
  14.  * The DriverChain allows you to add multiple other mapping drivers for
  15.  * certain namespaces.
  16.  */
  17. class MappingDriverChain implements MappingDriver
  18. {
  19.     /**
  20.      * The default driver.
  21.      *
  22.      * @var MappingDriver|null
  23.      */
  24.     private $defaultDriver;
  26.     /** @var MappingDriver[] */
  27.     private $drivers = [];
  29.     /**
  30.      * Gets the default driver.
  31.      *
  32.      * @return MappingDriver|null
  33.      */
  34.     public function getDefaultDriver()
  35.     {
  36.         return $this->defaultDriver;
  37.     }
  39.     /**
  40.      * Set the default driver.
  41.      *
  42.      * @return void
  43.      */
  44.     public function setDefaultDriver(MappingDriver $driver)
  45.     {
  46.         $this->defaultDriver = $driver;
  47.     }
  49.     /**
  50.      * Adds a nested driver.
  51.      *
  52.      * @param string $namespace
  53.      *
  54.      * @return void
  55.      */
  56.     public function addDriver(MappingDriver $nestedDriver, $namespace)
  57.     {
  58.         $this->drivers[$namespace] = $nestedDriver;
  59.     }
  61.     /**
  62.      * Gets the array of nested drivers.
  63.      *
  64.      * @return MappingDriver[] $drivers
  65.      */
  66.     public function getDrivers()
  67.     {
  68.         return $this->drivers;
  69.     }
  71.     /**
  72.      * {@inheritDoc}
  73.      */
  74.     public function loadMetadataForClass($className, ClassMetadata $metadata)
  75.     {
  76.         /** @var MappingDriver $driver */
  77.         foreach ($this->drivers as $namespace => $driver) {
  78.             if (strpos($className, $namespace) === 0) {
  79.                 $driver->loadMetadataForClass($className, $metadata);
  81.                 return;
  82.             }
  83.         }
  85.         if ($this->defaultDriver !== null) {
  86.             $this->defaultDriver->loadMetadataForClass($className, $metadata);
  88.             return;
  89.         }
  91.         throw MappingException::classNotFoundInNamespaces($className, array_keys($this->drivers));
  92.     }
  94.     /**
  95.      * {@inheritDoc}
  96.      */
  97.     public function getAllClassNames()
  98.     {
  99.         $classNames    = [];
  100.         $driverClasses = [];
  102.         /** @var MappingDriver $driver */
  103.         foreach ($this->drivers as $namespace => $driver) {
  104.             $oid = spl_object_hash($driver);
  106.             if (! isset($driverClasses[$oid])) {
  107.                 $driverClasses[$oid] = $driver->getAllClassNames();
  108.             }
  110.             foreach ($driverClasses[$oid] as $className) {
  111.                 if (strpos($className, $namespace) !== 0) {
  112.                     continue;
  113.                 }
  115.                 $classNames[$className] = true;
  116.             }
  117.         }
  119.         if ($this->defaultDriver !== null) {
  120.             foreach ($this->defaultDriver->getAllClassNames() as $className) {
  121.                 $classNames[$className] = true;
  122.             }
  123.         }
  125.         return array_keys($classNames);
  126.     }
  128.     /**
  129.      * {@inheritDoc}
  130.      */
  131.     public function isTransient($className)
  132.     {
  133.         /** @var MappingDriver $driver */
  134.         foreach ($this->drivers as $namespace => $driver) {
  135.             if (strpos($className, $namespace) === 0) {
  136.                 return $driver->isTransient($className);
  137.             }
  138.         }
  140.         if ($this->defaultDriver !== null) {
  141.             return $this->defaultDriver->isTransient($className);
  142.         }
  144.         return true;
  145.     }
  146. }
  148. class_exists(\Doctrine\Common\Persistence\Mapping\Driver\MappingDriverChain::class);
  149. interface_exists(ClassMetadata::class);