4888f60700168a0d0dd9a295f89749feaf8e273e
[moodle.git] / 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/>.
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  */
32 defined('MOODLE_INTERNAL') || die();
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 {
42     /**
43      * The name of this store.
44      * @var string
45      */
46     protected $name;
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;
55     /**
56      * The persistent store array
57      * @var array
58      */
59     protected $store = array();
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     }
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     }
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     }
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     }
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     }
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     }
113     /**
114      * Returns true if this has been initialised.
115      * @return bool
116      */
117     public function is_initialised() {
118         return (!empty($this->definition));
119     }
121     /**
122      * Returns true if this is ready.
123      * @return bool
124      */
125     public function is_ready() {
126         return true;
127     }
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     }
138     /**
139      * Returns true if this store supports data guarantee.
140      * @return bool
141      */
142     public function supports_data_guarantee() {
143         return false;
144     }
146     /**
147      * Returns true if this store supports multiple identifiers.
148      * @return bool
149      */
150     public function supports_multiple_identifiers() {
151         return false;
152     }
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     }
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     }
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     }
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     }
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     }
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     }
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     }
251     /**
252      * Performs any necessary clean up when the store instance is being deleted.
253      */
254     public function cleanup() {
255         $this->purge();
256     }
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     }
270     /**
271      * Returns the name of this instance.
272      * @return string
273      */
274     public function my_name() {
275         return $this->name;
276     }