MDL-41997 cache: dummy store now uses static acceleration for session + request
[moodle.git] / cache / classes / dummystore.php
CommitLineData
8139ad13
SH
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
32defined('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 */
75cde6b9 40class cachestore_dummy extends cache_store {
170f821b 41
8139ad13
SH
42 /**
43 * The name of this store.
44 * @var string
45 */
46 protected $name;
47
48 /**
d074fb09
SH
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.
8139ad13
SH
52 * @var bool
53 */
54 protected $persist = false;
170f821b 55
8139ad13 56 /**
d074fb09 57 * The stored data array
8139ad13
SH
58 * @var array
59 */
60 protected $store = array();
61
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 }
70
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 }
78
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 }
86
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 }
95
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 }
104
105 /**
106 * Initialises the store instance for a definition.
107 * @param cache_definition $definition
108 */
109 public function initialise(cache_definition $definition) {
d074fb09 110 // If the definition isn't using static acceleration then we need to be store data here.
82afd05c 111 // The reasoning behind this is that:
d074fb09
SH
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
82afd05c 115 // and we will need to store it here in order to make sure it is accessible.
1582ee12
SH
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 }
8139ad13
SH
122 }
123
124 /**
125 * Returns true if this has been initialised.
126 * @return bool
127 */
128 public function is_initialised() {
129 return (!empty($this->definition));
130 }
131
132 /**
133 * Returns true if this is ready.
134 * @return bool
135 */
136 public function is_ready() {
137 return true;
138 }
139
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 }
148
8139ad13
SH
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 }
160
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 }
177
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 }
190
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 }
205
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 }
228
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 }
237
238 /**
239 * Performs any necessary clean up when the store instance is being deleted.
240 */
241 public function cleanup() {
242 $this->purge();
243 }
244
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) {
6fec1820 252 $cache = new cachestore_dummy('Dummy store test');
8139ad13 253 $cache->initialise($definition);
a3f3ea26 254 return $cache;
8139ad13 255 }
34c84c72
SH
256
257 /**
258 * Returns the name of this instance.
259 * @return string
260 */
261 public function my_name() {
262 return $this->name;
263 }
a3f3ea26 264}