You are here

Home » API reference » Zircon Profile 8.0 » MemoryBackend.php

class MemoryBackend in Zircon Profile 8.0

Same name in this branch
  1. 8.0 core/lib/Drupal/Core/Flood/MemoryBackend.php \Drupal\Core\Flood\MemoryBackend
  2. 8.0 core/lib/Drupal/Core/Cache/MemoryBackend.php \Drupal\Core\Cache\MemoryBackend
Same name and namespace in other branches
  1. 8 core/lib/Drupal/Core/Cache/MemoryBackend.php \Drupal\Core\Cache\MemoryBackend

Defines a memory cache implementation.

Stores cache items in memory using a PHP array.

Should be used for unit tests and specialist use-cases only, does not store cached items between requests.

Hierarchy

Expanded class hierarchy of MemoryBackend

Related topics

Cache API
Information about the Drupal Cache API
12 files declare their use of MemoryBackend
AssetResolverTest.php in core/tests/Drupal/Tests/Core/Asset/AssetResolverTest.php
Contains \Drupal\Tests\Core\Asset\AssetResolverTest.
BackendChainImplementationUnitTest.php in core/tests/Drupal/Tests/Core/Cache/BackendChainImplementationUnitTest.php
Contains \Drupal\Tests\Core\Cache\BackendChainImplementationUnitTest.
BackendChainUnitTest.php in core/modules/system/src/Tests/Cache/BackendChainUnitTest.php
Contains \Drupal\system\Tests\Cache\BackendChainUnitTest.
ChainedFastBackendTest.php in core/tests/Drupal/Tests/Core/Cache/ChainedFastBackendTest.php
Contains \Drupal\Tests\Core\Cache\ChainedFastBackendTest.
FileNormalizeTest.php in core/modules/hal/src/Tests/FileNormalizeTest.php
Contains \Drupal\hal\Tests\FileNormalizeTest.

... See full list

File

core/lib/Drupal/Core/Cache/MemoryBackend.php, line 20
Contains \Drupal\Core\Cache\MemoryBackend.

Namespace

Drupal\Core\Cache
View source 
class MemoryBackend implements CacheBackendInterface, CacheTagsInvalidatorInterface {

  /**
   * Array to store cache objects.
   */
  protected $cache = array();

  /**
   * Constructs a MemoryBackend object.
   *
   * @param string $bin
   *   The cache bin for which the object is created.
   */
  public function __construct($bin) {
  }

  /**
   * {@inheritdoc}
   */
  public function get($cid, $allow_invalid = FALSE) {
    if (isset($this->cache[$cid])) {
      return $this
        ->prepareItem($this->cache[$cid], $allow_invalid);
    }
    else {
      return FALSE;
    }
  }

  /**
   * {@inheritdoc}
   */
  public function getMultiple(&$cids, $allow_invalid = FALSE) {
    $ret = array();
    $items = array_intersect_key($this->cache, array_flip($cids));
    foreach ($items as $item) {
      $item = $this
        ->prepareItem($item, $allow_invalid);
      if ($item) {
        $ret[$item->cid] = $item;
      }
    }
    $cids = array_diff($cids, array_keys($ret));
    return $ret;
  }

  /**
   * Prepares a cached item.
   *
   * Checks that items are either permanent or did not expire, and returns data
   * as appropriate.
   *
   * @param object $cache
   *   An item loaded from cache_get() or cache_get_multiple().
   * @param bool $allow_invalid
   *   (optional) If TRUE, cache items may be returned even if they have expired
   *   or been invalidated.
   *
   * @return mixed
   *   The item with data as appropriate or FALSE if there is no
   *   valid item to load.
   */
  protected function prepareItem($cache, $allow_invalid) {
    if (!isset($cache->data)) {
      return FALSE;
    }

    // The object passed into this function is the one stored in $this->cache.
    // We must clone it as part of the preparation step so that the actual
    // cache object is not affected by the unserialize() call or other
    // manipulations of the returned object.
    $prepared = clone $cache;
    $prepared->data = unserialize($prepared->data);

    // Check expire time.
    $prepared->valid = $prepared->expire == Cache::PERMANENT || $prepared->expire >= $this
      ->getRequestTime();
    if (!$allow_invalid && !$prepared->valid) {
      return FALSE;
    }
    return $prepared;
  }

  /**
   * {@inheritdoc}
   */
  public function set($cid, $data, $expire = Cache::PERMANENT, array $tags = array()) {
    assert('\\Drupal\\Component\\Assertion\\Inspector::assertAllStrings($tags)', 'Cache Tags must be strings.');
    $tags = array_unique($tags);

    // Sort the cache tags so that they are stored consistently in the database.
    sort($tags);
    $this->cache[$cid] = (object) array(
      'cid' => $cid,
      'data' => serialize($data),
      'created' => $this
        ->getRequestTime(),
      'expire' => $expire,
      'tags' => $tags,
    );
  }

  /**
   * {@inheritdoc}
   */
  public function setMultiple(array $items = array()) {
    foreach ($items as $cid => $item) {
      $this
        ->set($cid, $item['data'], isset($item['expire']) ? $item['expire'] : CacheBackendInterface::CACHE_PERMANENT, isset($item['tags']) ? $item['tags'] : array());
    }
  }

  /**
   * {@inheritdoc}
   */
  public function delete($cid) {
    unset($this->cache[$cid]);
  }

  /**
   * {@inheritdoc}
   */
  public function deleteMultiple(array $cids) {
    $this->cache = array_diff_key($this->cache, array_flip($cids));
  }

  /**
   * {@inheritdoc}
   */
  public function deleteAll() {
    $this->cache = array();
  }

  /**
   * {@inheritdoc}
   */
  public function invalidate($cid) {
    if (isset($this->cache[$cid])) {
      $this->cache[$cid]->expire = $this
        ->getRequestTime() - 1;
    }
  }

  /**
   * {@inheritdoc}
   */
  public function invalidateMultiple(array $cids) {
    foreach ($cids as $cid) {
      $this->cache[$cid]->expire = $this
        ->getRequestTime() - 1;
    }
  }

  /**
   * {@inheritdoc}
   */
  public function invalidateTags(array $tags) {
    foreach ($this->cache as $cid => $item) {
      if (array_intersect($tags, $item->tags)) {
        $this->cache[$cid]->expire = $this
          ->getRequestTime() - 1;
      }
    }
  }

  /**
   * {@inheritdoc}
   */
  public function invalidateAll() {
    foreach ($this->cache as $cid => $item) {
      $this->cache[$cid]->expire = $this
        ->getRequestTime() - 1;
    }
  }

  /**
   * {@inheritdoc}
   */
  public function garbageCollection() {
  }

  /**
   * {@inheritdoc}
   */
  public function removeBin() {
    $this->cache = [];
  }

  /**
   * Wrapper method for REQUEST_TIME constant.
   *
   * @return int
   */
  protected function getRequestTime() {
    return defined('REQUEST_TIME') ? REQUEST_TIME : (int) $_SERVER['REQUEST_TIME'];
  }

  /**
   * Prevents data stored in memory backends from being serialized.
   */
  public function __sleep() {
    return [];
  }

  /**
   * Reset statically cached variables.
   *
   * This is only used by tests.
   */
  public function reset() {
    $this->cache = [];
  }

}

Members

Namesort descending Modifiers Type Description Overrides
CacheBackendInterface::CACHE_PERMANENT constant Indicates that the item should never be removed unless explicitly deleted.
MemoryBackend::$cache protected property Array to store cache objects.
MemoryBackend::delete public function Deletes an item from the cache. Overrides CacheBackendInterface::delete 1
MemoryBackend::deleteAll public function Deletes all cache items in a bin. Overrides CacheBackendInterface::deleteAll
MemoryBackend::deleteMultiple public function Deletes multiple items from the cache. Overrides CacheBackendInterface::deleteMultiple
MemoryBackend::garbageCollection public function Performs garbage collection on a cache bin. Overrides CacheBackendInterface::garbageCollection
MemoryBackend::get public function Returns data from the persistent cache. Overrides CacheBackendInterface::get 1
MemoryBackend::getMultiple public function Returns data from the persistent cache when given an array of cache IDs. Overrides CacheBackendInterface::getMultiple
MemoryBackend::getRequestTime protected function Wrapper method for REQUEST_TIME constant.
MemoryBackend::invalidate public function Marks a cache item as invalid. Overrides CacheBackendInterface::invalidate
MemoryBackend::invalidateAll public function Marks all cache items as invalid. Overrides CacheBackendInterface::invalidateAll
MemoryBackend::invalidateMultiple public function Marks cache items as invalid. Overrides CacheBackendInterface::invalidateMultiple
MemoryBackend::invalidateTags public function Marks cache items with any of the specified tags as invalid. Overrides CacheTagsInvalidatorInterface::invalidateTags
MemoryBackend::prepareItem protected function Prepares a cached item.
MemoryBackend::removeBin public function Remove a cache bin. Overrides CacheBackendInterface::removeBin
MemoryBackend::reset public function Reset statically cached variables.
MemoryBackend::set public function Stores data in the persistent cache. Overrides CacheBackendInterface::set 1
MemoryBackend::setMultiple public function Store multiple items in the persistent cache. Overrides CacheBackendInterface::setMultiple
MemoryBackend::__construct public function Constructs a MemoryBackend object.
MemoryBackend::__sleep public function Prevents data stored in memory backends from being serialized.