abstract class AbstractManagerRegistry

Abstract implementation of the ManagerRegistry contract.

@license http://www.opensource.org/licenses/lgpl-license.php LGPL @link www.doctrine-project.org @since 2.2 @author Fabien Potencier <fabien@symfony.com> @author Benjamin Eberlei <kontakt@beberlei.de> @author Lukas Kahwe Smith <smith@pooteeweet.org>

Hierarchy

Expanded class hierarchy of AbstractManagerRegistry

File

drupal/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/AbstractManagerRegistry.php, line 35

Namespace

Doctrine\Common\Persistence
View source
abstract class AbstractManagerRegistry implements ManagerRegistry {

  /**
   * @var string
   */
  private $name;

  /**
   * @var array
   */
  private $connections;

  /**
   * @var array
   */
  private $managers;

  /**
   * @var string
   */
  private $defaultConnection;

  /**
   * @var string
   */
  private $defaultManager;

  /**
   * @var string
   */
  private $proxyInterfaceName;

  /**
   * Constructor
   *
   * @param string $name
   * @param array $connections
   * @param array $managers
   * @param string $defaultConnection
   * @param string $defaultManager
   * @param string $proxyInterfaceName
   */
  public function __construct($name, array $connections, array $managers, $defaultConnection, $defaultManager, $proxyInterfaceName) {
    $this->name = $name;
    $this->connections = $connections;
    $this->managers = $managers;
    $this->defaultConnection = $defaultConnection;
    $this->defaultManager = $defaultManager;
    $this->proxyInterfaceName = $proxyInterfaceName;
  }

  /**
   * Fetches/creates the given services
   *
   * A service in this context is connection or a manager instance
   *
   * @param string $name name of the service
   * @return object instance of the given service
   */
  protected abstract function getService($name);

  /**
   * Resets the given services
   *
   * A service in this context is connection or a manager instance
   *
   * @param string $name name of the service
   * @return void
   */
  protected abstract function resetService($name);

  /**
   * Get the name of the registry
   *
   * @return string
   */
  public function getName() {
    return $this->name;
  }

  /**
   * {@inheritdoc}
   */
  public function getConnection($name = null) {
    if (null === $name) {
      $name = $this->defaultConnection;
    }
    if (!isset($this->connections[$name])) {
      throw new \InvalidArgumentException(sprintf('Doctrine %s Connection named "%s" does not exist.', $this->name, $name));
    }
    return $this
      ->getService($this->connections[$name]);
  }

  /**
   * {@inheritdoc}
   */
  public function getConnectionNames() {
    return $this->connections;
  }

  /**
   * {@inheritdoc}
   */
  public function getConnections() {
    $connections = array();
    foreach ($this->connections as $name => $id) {
      $connections[$name] = $this
        ->getService($id);
    }
    return $connections;
  }

  /**
   * {@inheritdoc}
   */
  public function getDefaultConnectionName() {
    return $this->defaultConnection;
  }

  /**
   * {@inheritdoc}
   */
  public function getDefaultManagerName() {
    return $this->defaultManager;
  }

  /**
   * {@inheritdoc}
   *
   * @throws \InvalidArgumentException
   */
  public function getManager($name = null) {
    if (null === $name) {
      $name = $this->defaultManager;
    }
    if (!isset($this->managers[$name])) {
      throw new \InvalidArgumentException(sprintf('Doctrine %s Manager named "%s" does not exist.', $this->name, $name));
    }
    return $this
      ->getService($this->managers[$name]);
  }

  /**
   * {@inheritdoc}
   */
  public function getManagerForClass($class) {

    // Check for namespace alias
    if (strpos($class, ':') !== false) {
      list($namespaceAlias, $simpleClassName) = explode(':', $class);
      $class = $this
        ->getAliasNamespace($namespaceAlias) . '\\' . $simpleClassName;
    }
    $proxyClass = new \ReflectionClass($class);
    if ($proxyClass
      ->implementsInterface($this->proxyInterfaceName)) {
      $class = $proxyClass
        ->getParentClass()
        ->getName();
    }
    foreach ($this->managers as $id) {
      $manager = $this
        ->getService($id);
      if (!$manager
        ->getMetadataFactory()
        ->isTransient($class)) {
        return $manager;
      }
    }
  }

  /**
   * {@inheritdoc}
   */
  public function getManagerNames() {
    return $this->managers;
  }

  /**
   * {@inheritdoc}
   */
  public function getManagers() {
    $dms = array();
    foreach ($this->managers as $name => $id) {
      $dms[$name] = $this
        ->getService($id);
    }
    return $dms;
  }

  /**
   * {@inheritdoc}
   */
  public function getRepository($persistentObjectName, $persistentManagerName = null) {
    return $this
      ->getManager($persistentManagerName)
      ->getRepository($persistentObjectName);
  }

  /**
   * {@inheritdoc}
   */
  public function resetManager($name = null) {
    if (null === $name) {
      $name = $this->defaultManager;
    }
    if (!isset($this->managers[$name])) {
      throw new \InvalidArgumentException(sprintf('Doctrine %s Manager named "%s" does not exist.', $this->name, $name));
    }

    // force the creation of a new document manager
    // if the current one is closed
    $this
      ->resetService($this->managers[$name]);
  }

}

Members

Namesort descending Modifiers Type Description Overrides
AbstractManagerRegistry::$connections private property
AbstractManagerRegistry::$defaultConnection private property
AbstractManagerRegistry::$defaultManager private property
AbstractManagerRegistry::$managers private property
AbstractManagerRegistry::$name private property
AbstractManagerRegistry::$proxyInterfaceName private property
AbstractManagerRegistry::getConnection public function Gets the named connection. Overrides ConnectionRegistry::getConnection
AbstractManagerRegistry::getConnectionNames public function Gets all connection names. Overrides ConnectionRegistry::getConnectionNames
AbstractManagerRegistry::getConnections public function Gets an array of all registered connections Overrides ConnectionRegistry::getConnections
AbstractManagerRegistry::getDefaultConnectionName public function Gets the default connection name. Overrides ConnectionRegistry::getDefaultConnectionName
AbstractManagerRegistry::getDefaultManagerName public function Gets the default object manager name. Overrides ManagerRegistry::getDefaultManagerName
AbstractManagerRegistry::getManager public function Overrides ManagerRegistry::getManager
AbstractManagerRegistry::getManagerForClass public function Gets the object manager associated with a given class. Overrides ManagerRegistry::getManagerForClass
AbstractManagerRegistry::getManagerNames public function Gets all connection names. Overrides ManagerRegistry::getManagerNames
AbstractManagerRegistry::getManagers public function Gets an array of all registered object managers Overrides ManagerRegistry::getManagers
AbstractManagerRegistry::getName public function Get the name of the registry
AbstractManagerRegistry::getRepository public function Gets the ObjectRepository for an persistent object. Overrides ManagerRegistry::getRepository
AbstractManagerRegistry::getService abstract protected function Fetches/creates the given services
AbstractManagerRegistry::resetManager public function Resets a named object manager. Overrides ManagerRegistry::resetManager
AbstractManagerRegistry::resetService abstract protected function Resets the given services
AbstractManagerRegistry::__construct public function Constructor
ManagerRegistry::getAliasNamespace function Resolves a registered namespace alias to the full namespace.