vendor/doctrine/persistence/lib/Doctrine/Persistence/AbstractManagerRegistry.php line 167

Open in your IDE?
  1. <?php
  3. namespace Doctrine\Persistence;
  5. use InvalidArgumentException;
  6. use ReflectionClass;
  8. use function explode;
  9. use function sprintf;
  10. use function strpos;
  12. /**
  13.  * Abstract implementation of the ManagerRegistry contract.
  14.  */
  15. abstract class AbstractManagerRegistry implements ManagerRegistry
  16. {
  17.     /** @var string */
  18.     private $name;
  20.     /** @var string[] */
  21.     private $connections;
  23.     /** @var string[] */
  24.     private $managers;
  26.     /** @var string */
  27.     private $defaultConnection;
  29.     /** @var string */
  30.     private $defaultManager;
  32.     /**
  33.      * @var string
  34.      * @psalm-var class-string
  35.      */
  36.     private $proxyInterfaceName;
  38.     /**
  39.      * @param string   $name
  40.      * @param string[] $connections
  41.      * @param string[] $managers
  42.      * @param string   $defaultConnection
  43.      * @param string   $defaultManager
  44.      * @param string   $proxyInterfaceName
  45.      * @psalm-param class-string $proxyInterfaceName
  46.      */
  47.     public function __construct($name, array $connections, array $managers, $defaultConnection, $defaultManager, $proxyInterfaceName)
  48.     {
  49.         $this->name               = $name;
  50.         $this->connections        = $connections;
  51.         $this->managers           = $managers;
  52.         $this->defaultConnection  = $defaultConnection;
  53.         $this->defaultManager     = $defaultManager;
  54.         $this->proxyInterfaceName = $proxyInterfaceName;
  55.     }
  57.     /**
  58.      * Fetches/creates the given services.
  59.      *
  60.      * A service in this context is connection or a manager instance.
  61.      *
  62.      * @param string $name The name of the service.
  63.      *
  64.      * @return ObjectManager The instance of the given service.
  65.      */
  66.     abstract protected function getService($name);
  68.     /**
  69.      * Resets the given services.
  70.      *
  71.      * A service in this context is connection or a manager instance.
  72.      *
  73.      * @param string $name The name of the service.
  74.      *
  75.      * @return void
  76.      */
  77.     abstract protected function resetService($name);
  79.     /**
  80.      * Gets the name of the registry.
  81.      *
  82.      * @return string
  83.      */
  84.     public function getName()
  85.     {
  86.         return $this->name;
  87.     }
  89.     /**
  90.      * {@inheritdoc}
  91.      */
  92.     public function getConnection($name = null)
  93.     {
  94.         if ($name === null) {
  95.             $name = $this->defaultConnection;
  96.         }
  98.         if (! isset($this->connections[$name])) {
  99.             throw new InvalidArgumentException(sprintf('Doctrine %s Connection named "%s" does not exist.', $this->name, $name));
  100.         }
  102.         return $this->getService($this->connections[$name]);
  103.     }
  105.     /**
  106.      * {@inheritdoc}
  107.      */
  108.     public function getConnectionNames()
  109.     {
  110.         return $this->connections;
  111.     }
  113.     /**
  114.      * {@inheritdoc}
  115.      */
  116.     public function getConnections()
  117.     {
  118.         $connections = [];
  119.         foreach ($this->connections as $name => $id) {
  120.             $connections[$name] = $this->getService($id);
  121.         }
  123.         return $connections;
  124.     }
  126.     /**
  127.      * {@inheritdoc}
  128.      */
  129.     public function getDefaultConnectionName()
  130.     {
  131.         return $this->defaultConnection;
  132.     }
  134.     /**
  135.      * {@inheritdoc}
  136.      */
  137.     public function getDefaultManagerName()
  138.     {
  139.         return $this->defaultManager;
  140.     }
  142.     /**
  143.      * {@inheritdoc}
  144.      *
  145.      * @throws InvalidArgumentException
  146.      */
  147.     public function getManager($name = null)
  148.     {
  149.         if ($name === null) {
  150.             $name = $this->defaultManager;
  151.         }
  153.         if (! isset($this->managers[$name])) {
  154.             throw new InvalidArgumentException(sprintf('Doctrine %s Manager named "%s" does not exist.', $this->name, $name));
  155.         }
  157.         return $this->getService($this->managers[$name]);
  158.     }
  160.     /**
  161.      * {@inheritdoc}
  162.      */
  163.     public function getManagerForClass($class)
  164.     {
  165.         $className = $this->getRealClassName($class);
  167.         $proxyClass = new ReflectionClass($className);
  169.         if ($proxyClass->implementsInterface($this->proxyInterfaceName)) {
  170.             $parentClass = $proxyClass->getParentClass();
  172.             if (! $parentClass) {
  173.                 return null;
  174.             }
  176.             $className = $parentClass->getName();
  177.         }
  179.         foreach ($this->managers as $id) {
  180.             $manager = $this->getService($id);
  182.             if (! $manager->getMetadataFactory()->isTransient($className)) {
  183.                 return $manager;
  184.             }
  185.         }
  187.         return null;
  188.     }
  190.     /**
  191.      * {@inheritdoc}
  192.      */
  193.     public function getManagerNames()
  194.     {
  195.         return $this->managers;
  196.     }
  198.     /**
  199.      * {@inheritdoc}
  200.      */
  201.     public function getManagers()
  202.     {
  203.         $dms = [];
  204.         foreach ($this->managers as $name => $id) {
  205.             $dms[$name] = $this->getService($id);
  206.         }
  208.         return $dms;
  209.     }
  211.     /**
  212.      * {@inheritdoc}
  213.      */
  214.     public function getRepository($persistentObject, $persistentManagerName = null)
  215.     {
  216.         return $this
  217.             ->selectManager($persistentObject, $persistentManagerName)
  218.             ->getRepository($persistentObject);
  219.     }
  221.     /**
  222.      * {@inheritdoc}
  223.      */
  224.     public function resetManager($name = null)
  225.     {
  226.         if ($name === null) {
  227.             $name = $this->defaultManager;
  228.         }
  230.         if (! isset($this->managers[$name])) {
  231.             throw new InvalidArgumentException(sprintf('Doctrine %s Manager named "%s" does not exist.', $this->name, $name));
  232.         }
  234.         // force the creation of a new document manager
  235.         // if the current one is closed
  236.         $this->resetService($this->managers[$name]);
  238.         return $this->getManager($name);
  239.     }
  241.     /**
  242.      * @psalm-param class-string $persistentObjectName
  243.      */
  244.     private function selectManager(string $persistentObjectName, ?string $persistentManagerName = null): ObjectManager
  245.     {
  246.         if ($persistentManagerName !== null) {
  247.             return $this->getManager($persistentManagerName);
  248.         }
  250.         return $this->getManagerForClass($persistentObjectName) ?? $this->getManager();
  251.     }
  253.     /**
  254.      * @psalm-return class-string
  255.      */
  256.     private function getRealClassName(string $classNameOrAlias): string
  257.     {
  258.         // Check for namespace alias
  259.         if (strpos($classNameOrAlias, ':') !== false) {
  260.             [$namespaceAlias, $simpleClassName] = explode(':', $classNameOrAlias, 2);
  262.             /** @psalm-var class-string */
  263.             return $this->getAliasNamespace($namespaceAlias) . '\\' . $simpleClassName;
  264.         }
  266.         /** @psalm-var class-string */
  267.         return $classNameOrAlias;
  268.     }
  269. }