ManagedStorage.php

Same filename in other branches
  1. 9 core/lib/Drupal/Core/Config/ManagedStorage.php
  2. 10 core/lib/Drupal/Core/Config/ManagedStorage.php
  3. 11.x core/lib/Drupal/Core/Config/ManagedStorage.php

Namespace

Drupal\Core\Config

File

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

View source
<?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

Title Deprecated Summary
ManagedStorage The managed storage defers all the storage method calls to the manager.

Buggy or inaccurate documentation? Please file an issue. Need support? Need help programming? Connect with the Drupal community.