ManagedStorage.php in Drupal 9

Namespace

Drupal\Core\Config

File

core/lib/Drupal/Core/Config/ManagedStorage.php

<?php

namespace Drupal\Core\Config;


/**
 * The managed storage defers all the storage method calls to the manager.
 *
 * The reason for deferring all the method calls is that the storage interface
 * is the API but we potentially need to do an expensive transformation before
 * the storage can be used so we can't do it in the constructor but we also
 * don't know which method is called first.
 *
 * This class is not meant to be extended and is final to make sure the
 * assumptions that the storage is retrieved only once are upheld.
 */
final class ManagedStorage implements StorageInterface {

  /**
   * The decorated storage.
   *
   * @var \Drupal\Core\Config\StorageInterface
   */
  protected $storage;

  /**
   * The storage manager to get the storage to decorate.
   *
   * @var \Drupal\Core\Config\StorageManagerInterface
   */
  protected $manager;

  /**
   * ManagedStorage constructor.
   *
   * @param \Drupal\Core\Config\StorageManagerInterface $manager
   *   The storage manager.
   */
  public function __construct(StorageManagerInterface $manager) {
    $this->manager = $manager;
  }

  /**
   * {@inheritdoc}
   */
  public function exists($name) {
    return $this
      ->getStorage()
      ->exists($name);
  }

  /**
   * {@inheritdoc}
   */
  public function read($name) {
    return $this
      ->getStorage()
      ->read($name);
  }

  /**
   * {@inheritdoc}
   */
  public function readMultiple(array $names) {
    return $this
      ->getStorage()
      ->readMultiple($names);
  }

  /**
   * {@inheritdoc}
   */
  public function write($name, array $data) {
    return $this
      ->getStorage()
      ->write($name, $data);
  }

  /**
   * {@inheritdoc}
   */
  public function delete($name) {
    return $this
      ->getStorage()
      ->delete($name);
  }

  /**
   * {@inheritdoc}
   */
  public function rename($name, $new_name) {
    return $this
      ->getStorage()
      ->rename($name, $new_name);
  }

  /**
   * {@inheritdoc}
   */
  public function encode($data) {
    return $this
      ->getStorage()
      ->encode($data);
  }

  /**
   * {@inheritdoc}
   */
  public function decode($raw) {
    return $this
      ->getStorage()
      ->decode($raw);
  }

  /**
   * {@inheritdoc}
   */
  public function listAll($prefix = '') {
    return $this
      ->getStorage()
      ->listAll($prefix);
  }

  /**
   * {@inheritdoc}
   */
  public function deleteAll($prefix = '') {
    return $this
      ->getStorage()
      ->deleteAll($prefix);
  }

  /**
   * {@inheritdoc}
   */
  public function createCollection($collection) {

    // We return the collection directly.
    // This means that the collection will not be an instance of ManagedStorage
    // But this doesn't matter because the storage is retrieved from the
    // manager only the first time it is accessed.
    return $this
      ->getStorage()
      ->createCollection($collection);
  }

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

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

  /**
   * Get the decorated storage from the manager if necessary.
   *
   * @return \Drupal\Core\Config\StorageInterface
   *   The config storage.
   */
  protected function getStorage() {

    // Get the storage from the manager the first time it is needed.
    if (!isset($this->storage)) {
      $this->storage = $this->manager
        ->getStorage();
    }
    return $this->storage;
  }

}

Classes

Name	Description
ManagedStorage	The managed storage defers all the storage method calls to the manager.