1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
|
<?php
/**
* This program 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 2 of the License, or
* (at your option) any later version.
*
* This program 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 this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
* http://www.gnu.org/copyleft/gpl.html
*
* @file
*/
use Wikimedia\ObjectCache\BagOStuff;
/**
* Store an arbitrary value whilst representing several CacheDependency objects as one.
*
* You should typically only use DependencyWrapper::getValueFromCache(),
* rather than instantiating one of these objects directly.
*
* @ingroup Language
*/
class DependencyWrapper {
/** @var mixed */
private $value;
/** @var CacheDependency[] */
private $deps;
/**
* @param mixed $value The user-supplied value
* @param CacheDependency|CacheDependency[] $deps A dependency or dependency
* array. All dependencies must be objects implementing CacheDependency.
*/
public function __construct( $value = false, $deps = [] ) {
$this->value = $value;
if ( !is_array( $deps ) ) {
$deps = [ $deps ];
}
$this->deps = $deps;
}
/**
* Returns true if any of the dependencies have expired
*
* @return bool
*/
public function isExpired() {
foreach ( $this->deps as $dep ) {
if ( $dep->isExpired() ) {
return true;
}
}
return false;
}
/**
* Initialise dependency values in preparation for storing. This must be
* called before serialization.
*/
public function initialiseDeps() {
foreach ( $this->deps as $dep ) {
$dep->loadDependencyValues();
}
}
/**
* Get the user-defined value
* @return bool|mixed
*/
public function getValue() {
return $this->value;
}
/**
* Store the wrapper to a cache
*
* @param BagOStuff $cache
* @param string $key
* @param int $expiry
*/
public function storeToCache( $cache, $key, $expiry = 0 ) {
$this->initialiseDeps();
$cache->set( $key, $this, $expiry );
}
/**
* Attempt to get a value from the cache. If the value is expired or missing,
* it will be generated with the callback function (if present), and the newly
* calculated value will be stored to the cache in a wrapper.
*
* @param BagOStuff $cache
* @param string $key The cache key
* @param int $expiry The expiry timestamp or interval in seconds
* @param callable|false $callback The callback for generating the value, or false
* @param array $callbackParams The function parameters for the callback
* @param array $deps The dependencies to store on a cache miss. Note: these
* are not the dependencies used on a cache hit! Cache hits use the stored
* dependency array.
*
* @return mixed The value, or null if it was not present in the cache and no
* callback was defined.
*/
public static function getValueFromCache( $cache, $key, $expiry = 0, $callback = false,
$callbackParams = [], $deps = []
) {
$obj = $cache->get( $key );
if ( is_object( $obj ) && $obj instanceof DependencyWrapper && !$obj->isExpired() ) {
$value = $obj->value;
} elseif ( $callback ) {
$value = $callback( ...$callbackParams );
# Cache the newly-generated value
$wrapper = new DependencyWrapper( $value, $deps );
$wrapper->storeToCache( $cache, $key, $expiry );
} else {
$value = null;
}
return $value;
}
}
|
