PluginProbe
Visualizer – Tables & Charts Manager with Built-in AI Generator / 3.0.10
Visualizer – Tables & Charts Manager with Built-in AI Generator v3.0.10
4.0.8 4.0.7 4.0.6 4.0.5 4.0.4 4.0.3 3.0.5 3.0.6 3.0.7 3.0.8 3.0.9 3.1.0 3.1.1 3.1.2 3.1.3 3.10.0 3.10.1 3.10.10 3.10.11 3.10.12 3.10.13 3.10.14 3.10.15 3.10.2 3.10.3 All 149 releases
← All changes | vendor/phpoffice/phpexcel/Classes/PHPExcel/CachedObjectStorage/Memcache.php +312 -308 3.1.0 → 3.0.10 View file →
@@ -1,308 +1,312 @@
1 -<?php
2 -
3 -/**
4 - * PHPExcel_CachedObjectStorage_Memcache
5 - *
6 - * Copyright (c) 2006 - 2015 PHPExcel
7 - *
8 - * This library is free software; you can redistribute it and/or
9 - * modify it under the terms of the GNU Lesser General Public
10 - * License as published by the Free Software Foundation; either
11 - * version 2.1 of the License, or (at your option) any later version.
12 - *
13 - * This library is distributed in the hope that it will be useful,
14 - * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 - * Lesser General Public License for more details.
17 - *
18 - * You should have received a copy of the GNU Lesser General Public
19 - * License along with this library; if not, write to the Free Software
20 - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 - *
22 - * @category PHPExcel
23 - * @package PHPExcel_CachedObjectStorage
24 - * @copyright Copyright (c) 2006 - 2015 PHPExcel (http://www.codeplex.com/PHPExcel)
25 - * @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
26 - * @version ##VERSION##, ##DATE##
27 - */
28 -class PHPExcel_CachedObjectStorage_Memcache extends PHPExcel_CachedObjectStorage_CacheBase implements PHPExcel_CachedObjectStorage_ICache
29 -{
30 - /**
31 - * Prefix used to uniquely identify cache data for this worksheet
32 - *
33 - * @var string
34 - */
35 - private $cachePrefix = null;
36 -
37 - /**
38 - * Cache timeout
39 - *
40 - * @var integer
41 - */
42 - private $cacheTime = 600;
43 -
44 - /**
45 - * Memcache interface
46 - *
47 - * @var resource
48 - */
49 - private $memcache = null;
50 -
51 -
52 - /**
53 - * Store cell data in cache for the current cell object if it's "dirty",
54 - * and the 'nullify' the current cell object
55 - *
56 - * @return void
57 - * @throws PHPExcel_Exception
58 - */
59 - protected function storeData()
60 - {
61 - if ($this->currentCellIsDirty && !empty($this->currentObjectID)) {
62 - $this->currentObject->detach();
63 -
64 - $obj = serialize($this->currentObject);
65 - if (!$this->memcache->replace($this->cachePrefix . $this->currentObjectID . '.cache', $obj, null, $this->cacheTime)) {
66 - if (!$this->memcache->add($this->cachePrefix . $this->currentObjectID . '.cache', $obj, null, $this->cacheTime)) {
67 - $this->__destruct();
68 - throw new PHPExcel_Exception("Failed to store cell {$this->currentObjectID} in MemCache");
69 - }
70 - }
71 - $this->currentCellIsDirty = false;
72 - }
73 - $this->currentObjectID = $this->currentObject = null;
74 - } // function _storeData()
75 -
76 -
77 - /**
78 - * Add or Update a cell in cache identified by coordinate address
79 - *
80 - * @param string $pCoord Coordinate address of the cell to update
81 - * @param PHPExcel_Cell $cell Cell to update
82 - * @return PHPExcel_Cell
83 - * @throws PHPExcel_Exception
84 - */
85 - public function addCacheData($pCoord, PHPExcel_Cell $cell)
86 - {
87 - if (($pCoord !== $this->currentObjectID) && ($this->currentObjectID !== null)) {
88 - $this->storeData();
89 - }
90 - $this->cellCache[$pCoord] = true;
91 -
92 - $this->currentObjectID = $pCoord;
93 - $this->currentObject = $cell;
94 - $this->currentCellIsDirty = true;
95 -
96 - return $cell;
97 - } // function addCacheData()
98 -
99 -
100 - /**
101 - * Is a value set in the current PHPExcel_CachedObjectStorage_ICache for an indexed cell?
102 - *
103 - * @param string $pCoord Coordinate address of the cell to check
104 - * @return boolean
105 - * @return boolean
106 - */
107 - public function isDataSet($pCoord)
108 - {
109 - // Check if the requested entry is the current object, or exists in the cache
110 - if (parent::isDataSet($pCoord)) {
111 - if ($this->currentObjectID == $pCoord) {
112 - return true;
113 - }
114 - // Check if the requested entry still exists in Memcache
115 - $success = $this->memcache->get($this->cachePrefix.$pCoord.'.cache');
116 - if ($success === false) {
117 - // Entry no longer exists in Memcache, so clear it from the cache array
118 - parent::deleteCacheData($pCoord);
119 - throw new PHPExcel_Exception('Cell entry '.$pCoord.' no longer exists in MemCache');
120 - }
121 - return true;
122 - }
123 - return false;
124 - }
125 -
126 -
127 - /**
128 - * Get cell at a specific coordinate
129 - *
130 - * @param string $pCoord Coordinate of the cell
131 - * @throws PHPExcel_Exception
132 - * @return PHPExcel_Cell Cell that was found, or null if not found
133 - */
134 - public function getCacheData($pCoord)
135 - {
136 - if ($pCoord === $this->currentObjectID) {
137 - return $this->currentObject;
138 - }
139 - $this->storeData();
140 -
141 - // Check if the entry that has been requested actually exists
142 - if (parent::isDataSet($pCoord)) {
143 - $obj = $this->memcache->get($this->cachePrefix . $pCoord . '.cache');
144 - if ($obj === false) {
145 - // Entry no longer exists in Memcache, so clear it from the cache array
146 - parent::deleteCacheData($pCoord);
147 - throw new PHPExcel_Exception("Cell entry {$pCoord} no longer exists in MemCache");
148 - }
149 - } else {
150 - // Return null if requested entry doesn't exist in cache
151 - return null;
152 - }
153 -
154 - // Set current entry to the requested entry
155 - $this->currentObjectID = $pCoord;
156 - $this->currentObject = unserialize($obj);
157 - // Re-attach this as the cell's parent
158 - $this->currentObject->attach($this);
159 -
160 - // Return requested entry
161 - return $this->currentObject;
162 - }
163 -
164 - /**
165 - * Get a list of all cell addresses currently held in cache
166 - *
167 - * @return string[]
168 - */
169 - public function getCellList()
170 - {
171 - if ($this->currentObjectID !== null) {
172 - $this->storeData();
173 - }
174 -
175 - return parent::getCellList();
176 - }
177 -
178 - /**
179 - * Delete a cell in cache identified by coordinate address
180 - *
181 - * @param string $pCoord Coordinate address of the cell to delete
182 - * @throws PHPExcel_Exception
183 - */
184 - public function deleteCacheData($pCoord)
185 - {
186 - // Delete the entry from Memcache
187 - $this->memcache->delete($this->cachePrefix . $pCoord . '.cache');
188 -
189 - // Delete the entry from our cell address array
190 - parent::deleteCacheData($pCoord);
191 - }
192 -
193 - /**
194 - * Clone the cell collection
195 - *
196 - * @param PHPExcel_Worksheet $parent The new worksheet
197 - * @return void
198 - */
199 - public function copyCellCollection(PHPExcel_Worksheet $parent)
200 - {
201 - parent::copyCellCollection($parent);
202 - // Get a new id for the new file name
203 - $baseUnique = $this->getUniqueID();
204 - $newCachePrefix = substr(md5($baseUnique), 0, 8) . '.';
205 - $cacheList = $this->getCellList();
206 - foreach ($cacheList as $cellID) {
207 - if ($cellID != $this->currentObjectID) {
208 - $obj = $this->memcache->get($this->cachePrefix.$cellID.'.cache');
209 - if ($obj === false) {
210 - // Entry no longer exists in Memcache, so clear it from the cache array
211 - parent::deleteCacheData($cellID);
212 - throw new PHPExcel_Exception("Cell entry {$cellID} no longer exists in MemCache");
213 - }
214 - if (!$this->memcache->add($newCachePrefix . $cellID . '.cache', $obj, null, $this->cacheTime)) {
215 - $this->__destruct();
216 - throw new PHPExcel_Exception("Failed to store cell {$cellID} in MemCache");
217 - }
218 - }
219 - }
220 - $this->cachePrefix = $newCachePrefix;
221 - }
222 -
223 - /**
224 - * Clear the cell collection and disconnect from our parent
225 - *
226 - * @return void
227 - */
228 - public function unsetWorksheetCells()
229 - {
230 - if (!is_null($this->currentObject)) {
231 - $this->currentObject->detach();
232 - $this->currentObject = $this->currentObjectID = null;
233 - }
234 -
235 - // Flush the Memcache cache
236 - $this->__destruct();
237 -
238 - $this->cellCache = array();
239 -
240 - // detach ourself from the worksheet, so that it can then delete this object successfully
241 - $this->parent = null;
242 - }
243 -
244 - /**
245 - * Initialise this new cell collection
246 - *
247 - * @param PHPExcel_Worksheet $parent The worksheet for this cell collection
248 - * @param array of mixed $arguments Additional initialisation arguments
249 - */
250 - public function __construct(PHPExcel_Worksheet $parent, $arguments)
251 - {
252 - $memcacheServer = (isset($arguments['memcacheServer'])) ? $arguments['memcacheServer'] : 'localhost';
253 - $memcachePort = (isset($arguments['memcachePort'])) ? $arguments['memcachePort'] : 11211;
254 - $cacheTime = (isset($arguments['cacheTime'])) ? $arguments['cacheTime'] : 600;
255 -
256 - if (is_null($this->cachePrefix)) {
257 - $baseUnique = $this->getUniqueID();
258 - $this->cachePrefix = substr(md5($baseUnique), 0, 8) . '.';
259 -
260 - // Set a new Memcache object and connect to the Memcache server
261 - $this->memcache = new Memcache();
262 - if (!$this->memcache->addServer($memcacheServer, $memcachePort, false, 50, 5, 5, true, array($this, 'failureCallback'))) {
263 - throw new PHPExcel_Exception("Could not connect to MemCache server at {$memcacheServer}:{$memcachePort}");
264 - }
265 - $this->cacheTime = $cacheTime;
266 -
267 - parent::__construct($parent);
268 - }
269 - }
270 -
271 - /**
272 - * Memcache error handler
273 - *
274 - * @param string $host Memcache server
275 - * @param integer $port Memcache port
276 - * @throws PHPExcel_Exception
277 - */
278 - public function failureCallback($host, $port)
279 - {
280 - throw new PHPExcel_Exception("memcache {$host}:{$port} failed");
281 - }
282 -
283 - /**
284 - * Destroy this cell collection
285 - */
286 - public function __destruct()
287 - {
288 - $cacheList = $this->getCellList();
289 - foreach ($cacheList as $cellID) {
290 - $this->memcache->delete($this->cachePrefix.$cellID . '.cache');
291 - }
292 - }
293 -
294 - /**
295 - * Identify whether the caching method is currently available
296 - * Some methods are dependent on the availability of certain extensions being enabled in the PHP build
297 - *
298 - * @return boolean
299 - */
300 - public static function cacheMethodIsAvailable()
301 - {
302 - if (!function_exists('memcache_add')) {
303 - return false;
304 - }
305 -
306 - return true;
307 - }
308 -}
1 +<?php
2 +/**
3 + * PHPExcel
4 + *
5 + * Copyright (c) 2006 - 2014 PHPExcel
6 + *
7 + * This library is free software; you can redistribute it and/or
8 + * modify it under the terms of the GNU Lesser General Public
9 + * License as published by the Free Software Foundation; either
10 + * version 2.1 of the License, or (at your option) any later version.
11 + *
12 + * This library is distributed in the hope that it will be useful,
13 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 + * Lesser General Public License for more details.
16 + *
17 + * You should have received a copy of the GNU Lesser General Public
18 + * License along with this library; if not, write to the Free Software
19 + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 + *
21 + * @category PHPExcel
22 + * @package PHPExcel_CachedObjectStorage
23 + * @copyright Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
24 + * @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
25 + * @version ##VERSION##, ##DATE##
26 + */
27 +
28 +
29 +/**
30 + * PHPExcel_CachedObjectStorage_Memcache
31 + *
32 + * @category PHPExcel
33 + * @package PHPExcel_CachedObjectStorage
34 + * @copyright Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
35 + */
36 +class PHPExcel_CachedObjectStorage_Memcache extends PHPExcel_CachedObjectStorage_CacheBase implements PHPExcel_CachedObjectStorage_ICache {
37 +
38 + /**
39 + * Prefix used to uniquely identify cache data for this worksheet
40 + *
41 + * @var string
42 + */
43 + private $_cachePrefix = null;
44 +
45 + /**
46 + * Cache timeout
47 + *
48 + * @var integer
49 + */
50 + private $_cacheTime = 600;
51 +
52 + /**
53 + * Memcache interface
54 + *
55 + * @var resource
56 + */
57 + private $_memcache = null;
58 +
59 +
60 + /**
61 + * Store cell data in cache for the current cell object if it's "dirty",
62 + * and the 'nullify' the current cell object
63 + *
64 + * @return void
65 + * @throws PHPExcel_Exception
66 + */
67 + protected function _storeData() {
68 + if ($this->_currentCellIsDirty && !empty($this->_currentObjectID)) {
69 + $this->_currentObject->detach();
70 +
71 + $obj = serialize($this->_currentObject);
72 + if (!$this->_memcache->replace($this->_cachePrefix.$this->_currentObjectID.'.cache',$obj,NULL,$this->_cacheTime)) {
73 + if (!$this->_memcache->add($this->_cachePrefix.$this->_currentObjectID.'.cache',$obj,NULL,$this->_cacheTime)) {
74 + $this->__destruct();
75 + throw new PHPExcel_Exception('Failed to store cell '.$this->_currentObjectID.' in MemCache');
76 + }
77 + }
78 + $this->_currentCellIsDirty = false;
79 + }
80 + $this->_currentObjectID = $this->_currentObject = null;
81 + } // function _storeData()
82 +
83 +
84 + /**
85 + * Add or Update a cell in cache identified by coordinate address
86 + *
87 + * @param string $pCoord Coordinate address of the cell to update
88 + * @param PHPExcel_Cell $cell Cell to update
89 + * @return PHPExcel_Cell
90 + * @throws PHPExcel_Exception
91 + */
92 + public function addCacheData($pCoord, PHPExcel_Cell $cell) {
93 + if (($pCoord !== $this->_currentObjectID) && ($this->_currentObjectID !== null)) {
94 + $this->_storeData();
95 + }
96 + $this->_cellCache[$pCoord] = true;
97 +
98 + $this->_currentObjectID = $pCoord;
99 + $this->_currentObject = $cell;
100 + $this->_currentCellIsDirty = true;
101 +
102 + return $cell;
103 + } // function addCacheData()
104 +
105 +
106 + /**
107 + * Is a value set in the current PHPExcel_CachedObjectStorage_ICache for an indexed cell?
108 + *
109 + * @param string $pCoord Coordinate address of the cell to check
110 + * @return boolean
111 + * @return boolean
112 + */
113 + public function isDataSet($pCoord) {
114 + // Check if the requested entry is the current object, or exists in the cache
115 + if (parent::isDataSet($pCoord)) {
116 + if ($this->_currentObjectID == $pCoord) {
117 + return true;
118 + }
119 + // Check if the requested entry still exists in Memcache
120 + $success = $this->_memcache->get($this->_cachePrefix.$pCoord.'.cache');
121 + if ($success === false) {
122 + // Entry no longer exists in Memcache, so clear it from the cache array
123 + parent::deleteCacheData($pCoord);
124 + throw new PHPExcel_Exception('Cell entry '.$pCoord.' no longer exists in MemCache');
125 + }
126 + return true;
127 + }
128 + return false;
129 + } // function isDataSet()
130 +
131 +
132 + /**
133 + * Get cell at a specific coordinate
134 + *
135 + * @param string $pCoord Coordinate of the cell
136 + * @throws PHPExcel_Exception
137 + * @return PHPExcel_Cell Cell that was found, or null if not found
138 + */
139 + public function getCacheData($pCoord) {
140 + if ($pCoord === $this->_currentObjectID) {
141 + return $this->_currentObject;
142 + }
143 + $this->_storeData();
144 +
145 + // Check if the entry that has been requested actually exists
146 + if (parent::isDataSet($pCoord)) {
147 + $obj = $this->_memcache->get($this->_cachePrefix.$pCoord.'.cache');
148 + if ($obj === false) {
149 + // Entry no longer exists in Memcache, so clear it from the cache array
150 + parent::deleteCacheData($pCoord);
151 + throw new PHPExcel_Exception('Cell entry '.$pCoord.' no longer exists in MemCache');
152 + }
153 + } else {
154 + // Return null if requested entry doesn't exist in cache
155 + return null;
156 + }
157 +
158 + // Set current entry to the requested entry
159 + $this->_currentObjectID = $pCoord;
160 + $this->_currentObject = unserialize($obj);
161 + // Re-attach this as the cell's parent
162 + $this->_currentObject->attach($this);
163 +
164 + // Return requested entry
165 + return $this->_currentObject;
166 + } // function getCacheData()
167 +
168 +
169 + /**
170 + * Get a list of all cell addresses currently held in cache
171 + *
172 + * @return string[]
173 + */
174 + public function getCellList() {
175 + if ($this->_currentObjectID !== null) {
176 + $this->_storeData();
177 + }
178 +
179 + return parent::getCellList();
180 + }
181 +
182 +
183 + /**
184 + * Delete a cell in cache identified by coordinate address
185 + *
186 + * @param string $pCoord Coordinate address of the cell to delete
187 + * @throws PHPExcel_Exception
188 + */
189 + public function deleteCacheData($pCoord) {
190 + // Delete the entry from Memcache
191 + $this->_memcache->delete($this->_cachePrefix.$pCoord.'.cache');
192 +
193 + // Delete the entry from our cell address array
194 + parent::deleteCacheData($pCoord);
195 + } // function deleteCacheData()
196 +
197 +
198 + /**
199 + * Clone the cell collection
200 + *
201 + * @param PHPExcel_Worksheet $parent The new worksheet
202 + * @return void
203 + */
204 + public function copyCellCollection(PHPExcel_Worksheet $parent) {
205 + parent::copyCellCollection($parent);
206 + // Get a new id for the new file name
207 + $baseUnique = $this->_getUniqueID();
208 + $newCachePrefix = substr(md5($baseUnique),0,8).'.';
209 + $cacheList = $this->getCellList();
210 + foreach($cacheList as $cellID) {
211 + if ($cellID != $this->_currentObjectID) {
212 + $obj = $this->_memcache->get($this->_cachePrefix.$cellID.'.cache');
213 + if ($obj === false) {
214 + // Entry no longer exists in Memcache, so clear it from the cache array
215 + parent::deleteCacheData($cellID);
216 + throw new PHPExcel_Exception('Cell entry '.$cellID.' no longer exists in MemCache');
217 + }
218 + if (!$this->_memcache->add($newCachePrefix.$cellID.'.cache',$obj,NULL,$this->_cacheTime)) {
219 + $this->__destruct();
220 + throw new PHPExcel_Exception('Failed to store cell '.$cellID.' in MemCache');
221 + }
222 + }
223 + }
224 + $this->_cachePrefix = $newCachePrefix;
225 + } // function copyCellCollection()
226 +
227 +
228 + /**
229 + * Clear the cell collection and disconnect from our parent
230 + *
231 + * @return void
232 + */
233 + public function unsetWorksheetCells() {
234 + if(!is_null($this->_currentObject)) {
235 + $this->_currentObject->detach();
236 + $this->_currentObject = $this->_currentObjectID = null;
237 + }
238 +
239 + // Flush the Memcache cache
240 + $this->__destruct();
241 +
242 + $this->_cellCache = array();
243 +
244 + // detach ourself from the worksheet, so that it can then delete this object successfully
245 + $this->_parent = null;
246 + } // function unsetWorksheetCells()
247 +
248 +
249 + /**
250 + * Initialise this new cell collection
251 + *
252 + * @param PHPExcel_Worksheet $parent The worksheet for this cell collection
253 + * @param array of mixed $arguments Additional initialisation arguments
254 + */
255 + public function __construct(PHPExcel_Worksheet $parent, $arguments) {
256 + $memcacheServer = (isset($arguments['memcacheServer'])) ? $arguments['memcacheServer'] : 'localhost';
257 + $memcachePort = (isset($arguments['memcachePort'])) ? $arguments['memcachePort'] : 11211;
258 + $cacheTime = (isset($arguments['cacheTime'])) ? $arguments['cacheTime'] : 600;
259 +
260 + if (is_null($this->_cachePrefix)) {
261 + $baseUnique = $this->_getUniqueID();
262 + $this->_cachePrefix = substr(md5($baseUnique),0,8).'.';
263 +
264 + // Set a new Memcache object and connect to the Memcache server
265 + $this->_memcache = new Memcache();
266 + if (!$this->_memcache->addServer($memcacheServer, $memcachePort, false, 50, 5, 5, true, array($this, 'failureCallback'))) {
267 + throw new PHPExcel_Exception('Could not connect to MemCache server at '.$memcacheServer.':'.$memcachePort);
268 + }
269 + $this->_cacheTime = $cacheTime;
270 +
271 + parent::__construct($parent);
272 + }
273 + } // function __construct()
274 +
275 +
276 + /**
277 + * Memcache error handler
278 + *
279 + * @param string $host Memcache server
280 + * @param integer $port Memcache port
281 + * @throws PHPExcel_Exception
282 + */
283 + public function failureCallback($host, $port) {
284 + throw new PHPExcel_Exception('memcache '.$host.':'.$port.' failed');
285 + }
286 +
287 +
288 + /**
289 + * Destroy this cell collection
290 + */
291 + public function __destruct() {
292 + $cacheList = $this->getCellList();
293 + foreach($cacheList as $cellID) {
294 + $this->_memcache->delete($this->_cachePrefix.$cellID.'.cache');
295 + }
296 + } // function __destruct()
297 +
298 + /**
299 + * Identify whether the caching method is currently available
300 + * Some methods are dependent on the availability of certain extensions being enabled in the PHP build
301 + *
302 + * @return boolean
303 + */
304 + public static function cacheMethodIsAvailable() {
305 + if (!function_exists('memcache_add')) {
306 + return false;
307 + }
308 +
309 + return true;
310 + }
311 +
312 +}