[Summary view] [Print] [Text view]

   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  }