MDL-41997 cache: dummy store now uses static acceleration for session + request
[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 extends 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 store data.
50      * This happens when the definition doesn't require static acceleration as the loader will not be storing information and
51      * something has to.
52      * @var bool
53      */
54     protected $persist = false;
56     /**
57      * The stored data array
58      * @var array
59      */
60     protected $store = array();
62     /**
63      * Constructs a dummy store instance.
64      * @param string $name
65      * @param array $configuration
66      */
67     public function __construct($name = 'Dummy store', array $configuration = array()) {
68         $this->name = $name;
69     }
71     /**
72      * Returns true if this store plugin is usable.
73      * @return bool
74      */
75     public static function are_requirements_met() {
76         return true;
77     }
79     /**
80      * Returns true if the user can add an instance.
81      * @return bool
82      */
83     public static function can_add_instance() {
84         return false;
85     }
87     /**
88      * Returns the supported features.
89      * @param array $configuration
90      * @return int
91      */
92     public static function get_supported_features(array $configuration = array()) {
93         return self::SUPPORTS_NATIVE_TTL;
94     }
96     /**
97      * Returns the supported mode.
98      * @param array $configuration
99      * @return int
100      */
101     public static function get_supported_modes(array $configuration = array()) {
102         return self::MODE_APPLICATION + self::MODE_REQUEST + self::MODE_SESSION;
103     }
105     /**
106      * Initialises the store instance for a definition.
107      * @param cache_definition $definition
108      */
109     public function initialise(cache_definition $definition) {
110         // If the definition isn't using static acceleration then we need to be store data here.
111         // The reasoning behind this is that:
112         //   - If the definition is using static acceleration then the cache loader is going to
113         //     store things in its static array.
114         //   - If the definition is not using static acceleration then the cache loader won't try to store anything
115         //     and we will need to store it here in order to make sure it is accessible.
116         if ($definition->get_mode() !== self::MODE_APPLICATION) {
117             // Neither the request cache nor the session cache provide static acceleration.
118             $this->persist = true;
119         } else {
120             $this->persist = !$definition->use_static_acceleration();
121         }
122     }
124     /**
125      * Returns true if this has been initialised.
126      * @return bool
127      */
128     public function is_initialised() {
129         return (!empty($this->definition));
130     }
132     /**
133      * Returns true if this is ready.
134      * @return bool
135      */
136     public function is_ready() {
137         return true;
138     }
140     /**
141      * Returns true the given mode is supported.
142      * @param int $mode
143      * @return bool
144      */
145     public static function is_supported_mode($mode) {
146         return true;
147     }
149     /**
150      * Returns the data for the given key
151      * @param string $key
152      * @return string|false
153      */
154     public function get($key) {
155         if ($this->persist && array_key_exists($key, $this->store)) {
156             return $this->store[$key];
157         }
158         return false;
159     }
161     /**
162      * Gets' the values for many keys
163      * @param array $keys
164      * @return bool
165      */
166     public function get_many($keys) {
167         $return = array();
168         foreach ($keys as $key) {
169             if ($this->persist && array_key_exists($key, $this->store)) {
170                 $return[$key] = $this->store[$key];
171             } else {
172                 $return[$key] = false;
173             }
174         }
175         return $return;
176     }
178     /**
179      * Sets an item in the cache
180      * @param string $key
181      * @param mixed $data
182      * @return bool
183      */
184     public function set($key, $data) {
185         if ($this->persist) {
186             $this->store[$key] = $data;
187         }
188         return true;
189     }
191     /**
192      * Sets many items in the cache
193      * @param array $keyvaluearray
194      * @return int
195      */
196     public function set_many(array $keyvaluearray) {
197         if ($this->persist) {
198             foreach ($keyvaluearray as $pair) {
199                 $this->store[$pair['key']] = $pair['value'];
200             }
201             return count($keyvaluearray);
202         }
203         return 0;
204     }
206     /**
207      * Deletes an item from the cache
208      * @param string $key
209      * @return bool
210      */
211     public function delete($key) {
212         unset($this->store[$key]);
213         return true;
214     }
215     /**
216      * Deletes many items from the cache
217      * @param array $keys
218      * @return bool
219      */
220     public function delete_many(array $keys) {
221         if ($this->persist) {
222             foreach ($keys as $key) {
223                 unset($this->store[$key]);
224             }
225         }
226         return count($keys);
227     }
229     /**
230      * Deletes all of the items from the cache.
231      * @return bool
232      */
233     public function purge() {
234         $this->store = array();
235         return true;
236     }
238     /**
239      * Performs any necessary clean up when the store instance is being deleted.
240      */
241     public function cleanup() {
242         $this->purge();
243     }
245     /**
246      * Generates an instance of the cache store that can be used for testing.
247      *
248      * @param cache_definition $definition
249      * @return false
250      */
251     public static function initialise_test_instance(cache_definition $definition) {
252         $cache = new cachestore_dummy('Dummy store test');
253         $cache->initialise($definition);
254         return $cache;
255     }
257     /**
258      * Returns the name of this instance.
259      * @return string
260      */
261     public function my_name() {
262         return $this->name;
263     }