Current Path : C:/Users/Mahmood/Desktop/moodle/cache/classes/ |
Current File : C:/Users/Mahmood/Desktop/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; } }