cache/classes/dummystore.php

   1 <?php
   2 // This file is part of Moodle - http://moodle.org/
   3 //
   4 // Moodle is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU General Public License as published by
   6 // the Free Software Foundation, either version 3 of the License, or
   7 // (at your option) any later version.
   8 //
   9 // Moodle is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU General Public License
  15 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 /**
  18  * Cache dummy store.
  19  *
  20  * This dummy store is used when a load has no other stores that it can make use of.
  21  * This shouldn't happen in normal operation... I think.
  22  *
  23  * This file is part of Moodle's cache API, affectionately called MUC.
  24  * It contains the components that are requried in order to use caching.
  25  *
  26  * @package    core
  27  * @category   cache
  28  * @copyright  2012 Sam Hemelryk
  29  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  30  */
  31
  32 defined('MOODLE_INTERNAL') || die();
  33
  34 /**
  35  * The cache dummy store.
  36  *
  37  * @copyright  2012 Sam Hemelryk
  38  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  39  */
  40 class cachestore_dummy implements cache_store {
  41
  42     /**
  43      * The name of this store.
  44      * @var string
  45      */
  46     protected $name;
  47
  48     /**
  49      * Gets set to true if this store is going to persist data.
  50      * This happens when the definition doesn't require it as the loader will not be persisting information and something has to.
  51      * @var bool
  52      */
  53     protected $persist = false;
  54
  55     /**
  56      * The persistent store array
  57      * @var array
  58      */
  59     protected $store = array();
  60
  61     /**
  62      * Constructs a dummy store instance.
  63      * @param string $name
  64      * @param array $configuration
  65      */
  66     public function __construct($name = 'Dummy store', array $configuration = array()) {
  67         $this->name = $name;
  68     }
  69
  70     /**
  71      * Returns true if this store plugin is usable.
  72      * @return bool
  73      */
  74     public static function are_requirements_met() {
  75         return true;
  76     }
  77
  78     /**
  79      * Returns true if the user can add an instance.
  80      * @return bool
  81      */
  82     public static function can_add_instance() {
  83         return false;
  84     }
  85
  86     /**
  87      * Returns the supported features.
  88      * @param array $configuration
  89      * @return int
  90      */
  91     public static function get_supported_features(array $configuration = array()) {
  92         return self::SUPPORTS_NATIVE_TTL;
  93     }
  94
  95     /**
  96      * Returns the supported mode.
  97      * @param array $configuration
  98      * @return int
  99      */
 100     public static function get_supported_modes(array $configuration = array()) {
 101         return self::MODE_APPLICATION + self::MODE_REQUEST + self::MODE_SESSION;
 102     }
 103
 104     /**
 105      * Initialises the store instance for a definition.
 106      * @param cache_definition $definition
 107      */
 108     public function initialise(cache_definition $definition) {
 109         // If the definition isn't persistent then we need to be persistent here.
 110         $this->persist = !$definition->should_be_persistent();
 111     }
 112
 113     /**
 114      * Returns true if this has been initialised.
 115      * @return bool
 116      */
 117     public function is_initialised() {
 118         return (!empty($this->definition));
 119     }
 120
 121     /**
 122      * Returns true if this is ready.
 123      * @return bool
 124      */
 125     public function is_ready() {
 126         return true;
 127     }
 128
 129     /**
 130      * Returns true the given mode is supported.
 131      * @param int $mode
 132      * @return bool
 133      */
 134     public static function is_supported_mode($mode) {
 135         return true;
 136     }
 137
 138     /**
 139      * Returns true if this store supports data guarantee.
 140      * @return bool
 141      */
 142     public function supports_data_guarantee() {
 143         return false;
 144     }
 145
 146     /**
 147      * Returns true if this store supports multiple identifiers.
 148      * @return bool
 149      */
 150     public function supports_multiple_identifiers() {
 151         return false;
 152     }
 153
 154     /**
 155      * Returns true if this store supports a native ttl.
 156      * @return bool
 157      */
 158     public function supports_native_ttl() {
 159         return true;
 160     }
 161
 162     /**
 163      * Returns the data for the given key
 164      * @param string $key
 165      * @return string|false
 166      */
 167     public function get($key) {
 168         if ($this->persist && array_key_exists($key, $this->store)) {
 169             return $this->store[$key];
 170         }
 171         return false;
 172     }
 173
 174     /**
 175      * Gets' the values for many keys
 176      * @param array $keys
 177      * @return bool
 178      */
 179     public function get_many($keys) {
 180         $return = array();
 181         foreach ($keys as $key) {
 182             if ($this->persist && array_key_exists($key, $this->store)) {
 183                 $return[$key] = $this->store[$key];
 184             } else {
 185                 $return[$key] = false;
 186             }
 187         }
 188         return $return;
 189     }
 190
 191     /**
 192      * Sets an item in the cache
 193      * @param string $key
 194      * @param mixed $data
 195      * @return bool
 196      */
 197     public function set($key, $data) {
 198         if ($this->persist) {
 199             $this->store[$key] = $data;
 200         }
 201         return true;
 202     }
 203
 204     /**
 205      * Sets many items in the cache
 206      * @param array $keyvaluearray
 207      * @return int
 208      */
 209     public function set_many(array $keyvaluearray) {
 210         if ($this->persist) {
 211             foreach ($keyvaluearray as $pair) {
 212                 $this->store[$pair['key']] = $pair['value'];
 213             }
 214             return count($keyvaluearray);
 215         }
 216         return 0;
 217     }
 218
 219     /**
 220      * Deletes an item from the cache
 221      * @param string $key
 222      * @return bool
 223      */
 224     public function delete($key) {
 225         unset($this->store[$key]);
 226         return true;
 227     }
 228     /**
 229      * Deletes many items from the cache
 230      * @param array $keys
 231      * @return bool
 232      */
 233     public function delete_many(array $keys) {
 234         if ($this->persist) {
 235             foreach ($keys as $key) {
 236                 unset($this->store[$key]);
 237             }
 238         }
 239         return count($keys);
 240     }
 241
 242     /**
 243      * Deletes all of the items from the cache.
 244      * @return bool
 245      */
 246     public function purge() {
 247         $this->store = array();
 248         return true;
 249     }
 250
 251     /**
 252      * Performs any necessary clean up when the store instance is being deleted.
 253      */
 254     public function cleanup() {
 255         $this->purge();
 256     }
 257
 258     /**
 259      * Generates an instance of the cache store that can be used for testing.
 260      *
 261      * @param cache_definition $definition
 262      * @return false
 263      */
 264     public static function initialise_test_instance(cache_definition $definition) {
 265         $cache = new cachestore_dummy('Dummy store test');
 266         $cache->initialise($definition);
 267         return $cache;
 268     }
 269
 270     /**
 271      * Returns the name of this instance.
 272      * @return string
 273      */
 274     public function my_name() {
 275         return $this->name;
 276     }
 277 }