← Back to branch summary

~pvigo/+junk/owncloud-14.04

« back to all changes in this revision

Viewing changes to share/owncloud/3rdparty/PHPExcel/Classes/PHPExcel/CachedObjectStorageFactory.php

  • Committer: Pablo Vigo
  • Date: 2014-12-15 13:36:46 UTC
  • Revision ID: pvigo@xtec.cat-20141215133646-7d6it90e1dbsijc2
2

Show diffs side-by-side

added added

removed removed

Lines of Context:
share/owncloud/3rdparty/PHPExcel/Classes/PHPExcel/CachedObjectStorageFactory.php
 
1
<?php
 
2
 
 
3
/**
 
4
 * PHPExcel
 
5
 *
 
6
 * Copyright (c) 2006 - 2013 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 - 2013 PHPExcel (http://www.codeplex.com/PHPExcel)
 
25
 * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt    LGPL
 
26
 * @version    1.7.9, 2013-06-02
 
27
 */
 
28
 
 
29
 
 
30
/**
 
31
 * PHPExcel_CachedObjectStorageFactory
 
32
 *
 
33
 * @category    PHPExcel
 
34
 * @package        PHPExcel_CachedObjectStorage
 
35
 * @copyright    Copyright (c) 2006 - 2013 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
}