vendor/phpoffice/phpexcel/Classes/PHPExcel/CachedObjectStorage/Wincache.php

   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_Wincache
  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_Wincache 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     /**
  54      * Store cell data in cache for the current cell object if it's "dirty",
  55      *     and the 'nullify' the current cell object
  56      *
  57          * @return      void
  58      * @throws  PHPExcel_Exception
  59      */
  60         protected function _storeData() {
  61                 if ($this->_currentCellIsDirty && !empty($this->_currentObjectID)) {
  62                         $this->_currentObject->detach();
  63
  64                         $obj = serialize($this->_currentObject);
  65                         if (wincache_ucache_exists($this->_cachePrefix.$this->_currentObjectID.'.cache')) {
  66                                 if (!wincache_ucache_set($this->_cachePrefix.$this->_currentObjectID.'.cache', $obj, $this->_cacheTime)) {
  67                                         $this->__destruct();
  68                                         throw new PHPExcel_Exception('Failed to store cell '.$this->_currentObjectID.' in WinCache');
  69                                 }
  70                         } else {
  71                                 if (!wincache_ucache_add($this->_cachePrefix.$this->_currentObjectID.'.cache', $obj, $this->_cacheTime)) {
  72                                         $this->__destruct();
  73                                         throw new PHPExcel_Exception('Failed to store cell '.$this->_currentObjectID.' in WinCache');
  74                                 }
  75                         }
  76                         $this->_currentCellIsDirty = false;
  77                 }
  78
  79                 $this->_currentObjectID = $this->_currentObject = null;
  80         }       //      function _storeData()
  81
  82
  83         /**
  84          * Add or Update a cell in cache identified by coordinate address
  85          *
  86          * @param       string                  $pCoord         Coordinate address of the cell to update
  87          * @param       PHPExcel_Cell   $cell           Cell to update
  88          * @return      PHPExcel_Cell
  89          * @throws      PHPExcel_Exception
  90          */
  91         public function addCacheData($pCoord, PHPExcel_Cell $cell) {
  92                 if (($pCoord !== $this->_currentObjectID) && ($this->_currentObjectID !== null)) {
  93                         $this->_storeData();
  94                 }
  95                 $this->_cellCache[$pCoord] = true;
  96
  97                 $this->_currentObjectID = $pCoord;
  98                 $this->_currentObject = $cell;
  99                 $this->_currentCellIsDirty = true;
 100
 101                 return $cell;
 102         }       //      function addCacheData()
 103
 104
 105         /**
 106          * Is a value set in the current PHPExcel_CachedObjectStorage_ICache for an indexed cell?
 107          *
 108          * @param       string          $pCoord         Coordinate address of the cell to check
 109          * @return      boolean
 110          */
 111         public function isDataSet($pCoord) {
 112                 //      Check if the requested entry is the current object, or exists in the cache
 113                 if (parent::isDataSet($pCoord)) {
 114                         if ($this->_currentObjectID == $pCoord) {
 115                                 return true;
 116                         }
 117                         //      Check if the requested entry still exists in cache
 118                         $success = wincache_ucache_exists($this->_cachePrefix.$pCoord.'.cache');
 119                         if ($success === false) {
 120                                 //      Entry no longer exists in Wincache, so clear it from the cache array
 121                                 parent::deleteCacheData($pCoord);
 122                                 throw new PHPExcel_Exception('Cell entry '.$pCoord.' no longer exists in WinCache');
 123                         }
 124                         return true;
 125                 }
 126                 return false;
 127         }       //      function isDataSet()
 128
 129
 130         /**
 131          * Get cell at a specific coordinate
 132          *
 133          * @param       string                  $pCoord         Coordinate of the cell
 134          * @throws      PHPExcel_Exception
 135          * @return      PHPExcel_Cell   Cell that was found, or null if not found
 136          */
 137         public function getCacheData($pCoord) {
 138                 if ($pCoord === $this->_currentObjectID) {
 139                         return $this->_currentObject;
 140                 }
 141                 $this->_storeData();
 142
 143                 //      Check if the entry that has been requested actually exists
 144                 $obj = null;
 145                 if (parent::isDataSet($pCoord)) {
 146                         $success = false;
 147                         $obj = wincache_ucache_get($this->_cachePrefix.$pCoord.'.cache', $success);
 148                         if ($success === false) {
 149                                 //      Entry no longer exists in WinCache, so clear it from the cache array
 150                                 parent::deleteCacheData($pCoord);
 151                                 throw new PHPExcel_Exception('Cell entry '.$pCoord.' no longer exists in WinCache');
 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 Wincache
 191                 wincache_ucache_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                                 $success = false;
 213                                 $obj = wincache_ucache_get($this->_cachePrefix.$cellID.'.cache', $success);
 214                                 if ($success === false) {
 215                                         //      Entry no longer exists in WinCache, so clear it from the cache array
 216                                         parent::deleteCacheData($cellID);
 217                                         throw new PHPExcel_Exception('Cell entry '.$cellID.' no longer exists in Wincache');
 218                                 }
 219                                 if (!wincache_ucache_add($newCachePrefix.$cellID.'.cache', $obj, $this->_cacheTime)) {
 220                                         $this->__destruct();
 221                                         throw new PHPExcel_Exception('Failed to store cell '.$cellID.' in Wincache');
 222                                 }
 223                         }
 224                 }
 225                 $this->_cachePrefix = $newCachePrefix;
 226         }       //      function copyCellCollection()
 227
 228
 229         /**
 230          * Clear the cell collection and disconnect from our parent
 231          *
 232          * @return      void
 233          */
 234         public function unsetWorksheetCells() {
 235                 if(!is_null($this->_currentObject)) {
 236                         $this->_currentObject->detach();
 237                         $this->_currentObject = $this->_currentObjectID = null;
 238                 }
 239
 240                 //      Flush the WinCache cache
 241                 $this->__destruct();
 242
 243                 $this->_cellCache = array();
 244
 245                 //      detach ourself from the worksheet, so that it can then delete this object successfully
 246                 $this->_parent = null;
 247         }       //      function unsetWorksheetCells()
 248
 249
 250         /**
 251          * Initialise this new cell collection
 252          *
 253          * @param       PHPExcel_Worksheet      $parent         The worksheet for this cell collection
 254          * @param       array of mixed          $arguments      Additional initialisation arguments
 255          */
 256         public function __construct(PHPExcel_Worksheet $parent, $arguments) {
 257                 $cacheTime      = (isset($arguments['cacheTime']))      ? $arguments['cacheTime']       : 600;
 258
 259                 if (is_null($this->_cachePrefix)) {
 260                         $baseUnique = $this->_getUniqueID();
 261                         $this->_cachePrefix = substr(md5($baseUnique),0,8).'.';
 262                         $this->_cacheTime = $cacheTime;
 263
 264                         parent::__construct($parent);
 265                 }
 266         }       //      function __construct()
 267
 268
 269         /**
 270          * Destroy this cell collection
 271          */
 272         public function __destruct() {
 273                 $cacheList = $this->getCellList();
 274                 foreach($cacheList as $cellID) {
 275                         wincache_ucache_delete($this->_cachePrefix.$cellID.'.cache');
 276                 }
 277         }       //      function __destruct()
 278
 279
 280         /**
 281          * Identify whether the caching method is currently available
 282          * Some methods are dependent on the availability of certain extensions being enabled in the PHP build
 283          *
 284          * @return      boolean
 285          */
 286         public static function cacheMethodIsAvailable() {
 287                 if (!function_exists('wincache_ucache_add')) {
 288                         return false;
 289                 }
 290
 291                 return true;
 292         }
 293
 294 }