vendor/phpoffice/phpexcel/Classes/PHPExcel/CachedObjectStorageFactory.php

   1 <?php
   2
   3 /**
   4  * PHPExcel
   5  *
   6  * Copyright (c) 2006 - 2014 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 - 2014 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
  29
  30 /**
  31  * PHPExcel_CachedObjectStorageFactory
  32  *
  33  * @category    PHPExcel
  34  * @package        PHPExcel_CachedObjectStorage
  35  * @copyright    Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
  36  */
  37 class PHPExcel_CachedObjectStorageFactory
  38 {
  39     const cache_in_memory               = 'Memory';
  40     const cache_in_memory_gzip          = 'MemoryGZip';
  41     const cache_in_memory_serialized    = 'MemorySerialized';
  42     const cache_igbinary                = 'Igbinary';
  43     const cache_to_discISAM             = 'DiscISAM';
  44     const cache_to_apc                  = 'APC';
  45     const cache_to_memcache             = 'Memcache';
  46     const cache_to_phpTemp              = 'PHPTemp';
  47     const cache_to_wincache             = 'Wincache';
  48     const cache_to_sqlite               = 'SQLite';
  49     const cache_to_sqlite3              = 'SQLite3';
  50
  51
  52     /**
  53      * Name of the method used for cell cacheing
  54      *
  55      * @var string
  56      */
  57     private static $_cacheStorageMethod = NULL;
  58
  59     /**
  60      * Name of the class used for cell cacheing
  61      *
  62      * @var string
  63      */
  64     private static $_cacheStorageClass = NULL;
  65
  66
  67     /**
  68      * List of all possible cache storage methods
  69      *
  70      * @var string[]
  71      */
  72     private static $_storageMethods = array(
  73         self::cache_in_memory,
  74         self::cache_in_memory_gzip,
  75         self::cache_in_memory_serialized,
  76         self::cache_igbinary,
  77         self::cache_to_phpTemp,
  78         self::cache_to_discISAM,
  79         self::cache_to_apc,
  80         self::cache_to_memcache,
  81         self::cache_to_wincache,
  82         self::cache_to_sqlite,
  83         self::cache_to_sqlite3,
  84     );
  85
  86
  87     /**
  88      * Default arguments for each cache storage method
  89      *
  90      * @var array of mixed array
  91      */
  92     private static $_storageMethodDefaultParameters = array(
  93         self::cache_in_memory               => array(
  94                                                     ),
  95         self::cache_in_memory_gzip          => array(
  96                                                     ),
  97         self::cache_in_memory_serialized    => array(
  98                                                     ),
  99         self::cache_igbinary                => array(
 100                                                     ),
 101         self::cache_to_phpTemp              => array( 'memoryCacheSize' => '1MB'
 102                                                     ),
 103         self::cache_to_discISAM             => array( 'dir'             => NULL
 104                                                     ),
 105         self::cache_to_apc                  => array( 'cacheTime'       => 600
 106                                                     ),
 107         self::cache_to_memcache             => array( 'memcacheServer'  => 'localhost',
 108                                                       'memcachePort'    => 11211,
 109                                                       'cacheTime'       => 600
 110                                                     ),
 111         self::cache_to_wincache             => array( 'cacheTime'       => 600
 112                                                     ),
 113         self::cache_to_sqlite               => array(
 114                                                     ),
 115         self::cache_to_sqlite3              => array(
 116                                                     ),
 117     );
 118
 119
 120     /**
 121      * Arguments for the active cache storage method
 122      *
 123      * @var array of mixed array
 124      */
 125     private static $_storageMethodParameters = array();
 126
 127
 128     /**
 129      * Return the current cache storage method
 130      *
 131      * @return string|NULL
 132      **/
 133     public static function getCacheStorageMethod()
 134     {
 135         return self::$_cacheStorageMethod;
 136     }   //    function getCacheStorageMethod()
 137
 138
 139     /**
 140      * Return the current cache storage class
 141      *
 142      * @return PHPExcel_CachedObjectStorage_ICache|NULL
 143      **/
 144     public static function getCacheStorageClass()
 145     {
 146         return self::$_cacheStorageClass;
 147     }   //    function getCacheStorageClass()
 148
 149
 150     /**
 151      * Return the list of all possible cache storage methods
 152      *
 153      * @return string[]
 154      **/
 155     public static function getAllCacheStorageMethods()
 156     {
 157         return self::$_storageMethods;
 158     }   //    function getCacheStorageMethods()
 159
 160
 161     /**
 162      * Return the list of all available cache storage methods
 163      *
 164      * @return string[]
 165      **/
 166     public static function getCacheStorageMethods()
 167     {
 168         $activeMethods = array();
 169         foreach(self::$_storageMethods as $storageMethod) {
 170             $cacheStorageClass = 'PHPExcel_CachedObjectStorage_' . $storageMethod;
 171             if (call_user_func(array($cacheStorageClass, 'cacheMethodIsAvailable'))) {
 172                 $activeMethods[] = $storageMethod;
 173             }
 174         }
 175         return $activeMethods;
 176     }   //    function getCacheStorageMethods()
 177
 178
 179     /**
 180      * Identify the cache storage method to use
 181      *
 182      * @param    string            $method        Name of the method to use for cell cacheing
 183      * @param    array of mixed    $arguments    Additional arguments to pass to the cell caching class
 184      *                                        when instantiating
 185      * @return boolean
 186      **/
 187     public static function initialize($method = self::cache_in_memory, $arguments = array())
 188     {
 189         if (!in_array($method,self::$_storageMethods)) {
 190             return FALSE;
 191         }
 192
 193         $cacheStorageClass = 'PHPExcel_CachedObjectStorage_'.$method;
 194         if (!call_user_func(array( $cacheStorageClass,
 195                                    'cacheMethodIsAvailable'))) {
 196             return FALSE;
 197         }
 198
 199         self::$_storageMethodParameters[$method] = self::$_storageMethodDefaultParameters[$method];
 200         foreach($arguments as $k => $v) {
 201             if (array_key_exists($k, self::$_storageMethodParameters[$method])) {
 202                 self::$_storageMethodParameters[$method][$k] = $v;
 203             }
 204         }
 205
 206         if (self::$_cacheStorageMethod === NULL) {
 207             self::$_cacheStorageClass = 'PHPExcel_CachedObjectStorage_' . $method;
 208             self::$_cacheStorageMethod = $method;
 209         }
 210         return TRUE;
 211     }   //    function initialize()
 212
 213
 214     /**
 215      * Initialise the cache storage
 216      *
 217      * @param    PHPExcel_Worksheet     $parent        Enable cell caching for this worksheet
 218      * @return    PHPExcel_CachedObjectStorage_ICache
 219      **/
 220     public static function getInstance(PHPExcel_Worksheet $parent)
 221     {
 222         $cacheMethodIsAvailable = TRUE;
 223         if (self::$_cacheStorageMethod === NULL) {
 224             $cacheMethodIsAvailable = self::initialize();
 225         }
 226
 227         if ($cacheMethodIsAvailable) {
 228             $instance = new self::$_cacheStorageClass( $parent,
 229                                                        self::$_storageMethodParameters[self::$_cacheStorageMethod]
 230                                                      );
 231             if ($instance !== NULL) {
 232                 return $instance;
 233             }
 234         }
 235
 236         return FALSE;
 237     }   //    function getInstance()
 238
 239
 240     /**
 241      * Clear the cache storage
 242      *
 243      **/
 244         public static function finalize()
 245         {
 246                 self::$_cacheStorageMethod = NULL;
 247                 self::$_cacheStorageClass = NULL;
 248                 self::$_storageMethodParameters = array();
 249         }
 250
 251 }