moodle/cache/classes/dummystore.php

<?php
// This file is part of Moodle - http://moodle.org/
//
// Moodle is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Moodle is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.

/**
 * Cache dummy store.
 *
 * This dummy store is used when a load has no other stores that it can make use of.
 * This shouldn't happen in normal operation... I think.
 *
 * This file is part of Moodle's cache API, affectionately called MUC.
 * It contains the components that are requried in order to use caching.
 *
 * @package    core
 * @category   cache
 * @copyright  2012 Sam Hemelryk
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */

defined('MOODLE_INTERNAL') || die();

/**
 * The cache dummy store.
 *
 * @copyright  2012 Sam Hemelryk
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */
class cachestore_dummy extends cache_store {

    /**
     * The name of this store.
     * @var string
     */
    protected $name;

    /**
     * Gets set to true if this store is going to store data.
     * This happens when the definition doesn't require static acceleration as the loader will not be storing information and
     * something has to.
     * @var bool
     */
    protected $persist = false;

    /**
     * The stored data array
     * @var array
     */
    protected $store = array();

    /**
     * Constructs a dummy store instance.
     * @param string $name
     * @param array $configuration
     */
    public function __construct($name = 'Dummy store', array $configuration = array()) {
        $this->name = $name;
    }

    /**
     * Returns true if this store plugin is usable.
     * @return bool
     */
    public static function are_requirements_met() {
        return true;
    }

    /**
     * Returns true if the user can add an instance.
     * @return bool
     */
    public static function can_add_instance() {
        return false;
    }

    /**
     * Returns the supported features.
     * @param array $configuration
     * @return int
     */
    public static function get_supported_features(array $configuration = array()) {
        return self::SUPPORTS_NATIVE_TTL;
    }

    /**
     * Returns the supported mode.
     * @param array $configuration
     * @return int
     */
    public static function get_supported_modes(array $configuration = array()) {
        return self::MODE_APPLICATION + self::MODE_REQUEST + self::MODE_SESSION;
    }

    /**
     * Initialises the store instance for a definition.
     * @param cache_definition $definition
     */
    public function initialise(cache_definition $definition) {
        // If the definition isn't using static acceleration then we need to be store data here.
        // The reasoning behind this is that:
        //   - If the definition is using static acceleration then the cache loader is going to
        //     store things in its static array.
        //   - If the definition is not using static acceleration then the cache loader won't try to store anything
        //     and we will need to store it here in order to make sure it is accessible.
        if ($definition->get_mode() !== self::MODE_APPLICATION) {
            // Neither the request cache nor the session cache provide static acceleration.
            $this->persist = true;
        } else {
            $this->persist = !$definition->use_static_acceleration();
        }
    }

    /**
     * Returns true if this has been initialised.
     * @return bool
     */
    public function is_initialised() {
        return (!empty($this->definition));
    }

    /**
     * Returns true the given mode is supported.
     * @param int $mode
     * @return bool
     */
    public static function is_supported_mode($mode) {
        return true;
    }

    /**
     * Returns the data for the given key
     * @param string $key
     * @return string|false
     */
    public function get($key) {
        if ($this->persist && array_key_exists($key, $this->store)) {
            return $this->store[$key];
        }
        return false;
    }

    /**
     * Gets' the values for many keys
     * @param array $keys
     * @return bool
     */
    public function get_many($keys) {
        $return = array();
        foreach ($keys as $key) {
            if ($this->persist && array_key_exists($key, $this->store)) {
                $return[$key] = $this->store[$key];
            } else {
                $return[$key] = false;
            }
        }
        return $return;
    }

    /**
     * Sets an item in the cache
     * @param string $key
     * @param mixed $data
     * @return bool
     */
    public function set($key, $data) {
        if ($this->persist) {
            $this->store[$key] = $data;
        }
        return true;
    }

    /**
     * Sets many items in the cache
     * @param array $keyvaluearray
     * @return int
     */
    public function set_many(array $keyvaluearray) {
        if ($this->persist) {
            foreach ($keyvaluearray as $pair) {
                $this->store[$pair['key']] = $pair['value'];
            }

        }
        return count($keyvaluearray);
    }

    /**
     * Deletes an item from the cache
     * @param string $key
     * @return bool
     */
    public function delete($key) {
        unset($this->store[$key]);
        return true;
    }
    /**
     * Deletes many items from the cache
     * @param array $keys
     * @return bool
     */
    public function delete_many(array $keys) {
        if ($this->persist) {
            foreach ($keys as $key) {
                unset($this->store[$key]);
            }
        }
        return count($keys);
    }

    /**
     * Deletes all of the items from the cache.
     * @return bool
     */
    public function purge() {
        $this->store = array();
        return true;
    }

    /**
     * Performs any necessary clean up when the store instance is being deleted.
     *
     * @deprecated since 3.2
     * @see cachestore_dummy::instance_deleted()
     */
    public function cleanup() {
        debugging('cachestore_dummy::cleanup() is deprecated. Please use cachestore_dummy::instance_deleted() instead.',
            DEBUG_DEVELOPER);
        $this->instance_deleted();
    }

    /**
     * Performs any necessary operation when the store instance is being deleted.
     *
     * This method may be called before the store has been initialised.
     *
     * @since Moodle 3.2
     */
    public function instance_deleted() {
        $this->purge();
    }

    /**
     * Generates an instance of the cache store that can be used for testing.
     *
     * @param cache_definition $definition
     * @return false
     */
    public static function initialise_test_instance(cache_definition $definition) {
        $cache = new cachestore_dummy('Dummy store test');
        if ($cache->is_ready()) {
            $cache->initialise($definition);
        }
        return $cache;
    }

    /**
     * Generates the appropriate configuration required for unit testing.
     *
     * @return array Array of unit test configuration data to be used by initialise().
     */
    public static function unit_test_configuration() {
        return [];
    }

    /**
     * Returns the name of this instance.
     * @return string
     */
    public function my_name() {
        return $this->name;
    }
}