vendor/doctrine/persistence/src/Persistence/AbstractManagerRegistry.php line 229

  1. <?php
  3. declare(strict_types=1);
  5. namespace Doctrine\Persistence;
  7. use InvalidArgumentException;
  8. use ReflectionClass;
  10. use function sprintf;
  12. /**
  13.  * Abstract implementation of the ManagerRegistry contract.
  14.  */
  15. abstract class AbstractManagerRegistry implements ManagerRegistry
  16. {
  17.     /** @var string */
  18.     private $name;
  20.     /** @var array<string, string> */
  21.     private $connections;
  23.     /** @var array<string, 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 array<string, string> $connections
  40.      * @param array<string, string> $managers
  41.      * @psalm-param class-string $proxyInterfaceName
  42.      */
  43.     public function __construct(
  44.         string $name,
  45.         array $connections,
  46.         array $managers,
  47.         string $defaultConnection,
  48.         string $defaultManager,
  49.         string $proxyInterfaceName
  50.     ) {
  51.         $this->name               = $name;
  52.         $this->connections        = $connections;
  53.         $this->managers           = $managers;
  54.         $this->defaultConnection  = $defaultConnection;
  55.         $this->defaultManager     = $defaultManager;
  56.         $this->proxyInterfaceName = $proxyInterfaceName;
  57.     }
  59.     /**
  60.      * Fetches/creates the given services.
  61.      *
  62.      * A service in this context is connection or a manager instance.
  63.      *
  64.      * @param string $name The name of the service.
  65.      *
  66.      * @return ObjectManager The instance of the given service.
  67.      */
  68.     abstract protected function getService(string $name);
  70.     /**
  71.      * Resets the given services.
  72.      *
  73.      * A service in this context is connection or a manager instance.
  74.      *
  75.      * @param string $name The name of the service.
  76.      *
  77.      * @return void
  78.      */
  79.     abstract protected function resetService(string $name);
  81.     /**
  82.      * Gets the name of the registry.
  83.      *
  84.      * @return string
  85.      */
  86.     public function getName()
  87.     {
  88.         return $this->name;
  89.     }
  91.     /**
  92.      * {@inheritdoc}
  93.      */
  94.     public function getConnection(?string $name = null)
  95.     {
  96.         if ($name === null) {
  97.             $name = $this->defaultConnection;
  98.         }
  100.         if (! isset($this->connections[$name])) {
  101.             throw new InvalidArgumentException(
  102.                 sprintf('Doctrine %s Connection named "%s" does not exist.', $this->name, $name)
  103.             );
  104.         }
  106.         return $this->getService($this->connections[$name]);
  107.     }
  109.     /**
  110.      * {@inheritdoc}
  111.      */
  112.     public function getConnectionNames()
  113.     {
  114.         return $this->connections;
  115.     }
  117.     /**
  118.      * {@inheritdoc}
  119.      */
  120.     public function getConnections()
  121.     {
  122.         $connections = [];
  123.         foreach ($this->connections as $name => $id) {
  124.             $connections[$name] = $this->getService($id);
  125.         }
  127.         return $connections;
  128.     }
  130.     /**
  131.      * {@inheritdoc}
  132.      */
  133.     public function getDefaultConnectionName()
  134.     {
  135.         return $this->defaultConnection;
  136.     }
  138.     /**
  139.      * {@inheritdoc}
  140.      */
  141.     public function getDefaultManagerName()
  142.     {
  143.         return $this->defaultManager;
  144.     }
  146.     /**
  147.      * {@inheritdoc}
  148.      *
  149.      * @throws InvalidArgumentException
  150.      */
  151.     public function getManager(?string $name = null)
  152.     {
  153.         if ($name === null) {
  154.             $name = $this->defaultManager;
  155.         }
  157.         if (! isset($this->managers[$name])) {
  158.             throw new InvalidArgumentException(
  159.                 sprintf('Doctrine %s Manager named "%s" does not exist.', $this->name, $name)
  160.             );
  161.         }
  163.         return $this->getService($this->managers[$name]);
  164.     }
  166.     /**
  167.      * {@inheritDoc}
  168.      */
  169.     public function getManagerForClass(string $class)
  170.     {
  171.         $proxyClass = new ReflectionClass($class);
  172.         if ($proxyClass->isAnonymous()) {
  173.             return null;
  174.         }
  176.         if ($proxyClass->implementsInterface($this->proxyInterfaceName)) {
  177.             $parentClass = $proxyClass->getParentClass();
  179.             if ($parentClass === false) {
  180.                 return null;
  181.             }
  183.             $class = $parentClass->getName();
  184.         }
  186.         foreach ($this->managers as $id) {
  187.             $manager = $this->getService($id);
  189.             if (! $manager->getMetadataFactory()->isTransient($class)) {
  190.                 return $manager;
  191.             }
  192.         }
  194.         return null;
  195.     }
  197.     /**
  198.      * {@inheritdoc}
  199.      */
  200.     public function getManagerNames()
  201.     {
  202.         return $this->managers;
  203.     }
  205.     /**
  206.      * {@inheritdoc}
  207.      */
  208.     public function getManagers()
  209.     {
  210.         $managers = [];
  212.         foreach ($this->managers as $name => $id) {
  213.             $manager         = $this->getService($id);
  214.             $managers[$name] = $manager;
  215.         }
  217.         return $managers;
  218.     }
  220.     /**
  221.      * {@inheritdoc}
  222.      */
  223.     public function getRepository(
  224.         string $persistentObject,
  225.         ?string $persistentManagerName = null
  226.     ) {
  227.         return $this
  228.             ->selectManager($persistentObject, $persistentManagerName)
  229.             ->getRepository($persistentObject);
  230.     }
  232.     /**
  233.      * {@inheritdoc}
  234.      */
  235.     public function resetManager(?string $name = null)
  236.     {
  237.         if ($name === null) {
  238.             $name = $this->defaultManager;
  239.         }
  241.         if (! isset($this->managers[$name])) {
  242.             throw new InvalidArgumentException(sprintf('Doctrine %s Manager named "%s" does not exist.', $this->name, $name));
  243.         }
  245.         // force the creation of a new document manager
  246.         // if the current one is closed
  247.         $this->resetService($this->managers[$name]);
  249.         return $this->getManager($name);
  250.     }
  252.     /** @psalm-param class-string $persistentObject */
  253.     private function selectManager(
  254.         string $persistentObject,
  255.         ?string $persistentManagerName = null
  256.     ): ObjectManager {
  257.         if ($persistentManagerName !== null) {
  258.             return $this->getManager($persistentManagerName);
  259.         }
  261.         return $this->getManagerForClass($persistentObject) ?? $this->getManager();
  262.     }
  263. }