Namespaces

  • Nette
    • Application
      • Diagnostics
      • Responses
      • Routers
      • UI
    • Caching
      • Storages
    • ComponentModel
    • Database
      • Diagnostics
      • Drivers
      • Reflection
      • Table
    • DI
      • Config
        • Adapters
      • Diagnostics
      • Extensions
    • Diagnostics
    • Forms
      • Controls
      • Rendering
    • Http
      • Diagnostics
    • Iterators
    • Latte
      • Macros
    • Loaders
    • Localization
    • Mail
    • PhpGenerator
    • Reflection
    • Security
      • Diagnostics
    • Templating
    • Utils
  • NetteModule
  • none

Classes

  • Cache
  • OutputHelper

Interfaces

  • IStorage
  • Overview
  • Namespace
  • Class
  • Tree
  • Deprecated
  1: <?php
  2: 
  3: /**
  4:  * This file is part of the Nette Framework (http://nette.org)
  5:  * Copyright (c) 2004 David Grudl (http://davidgrudl.com)
  6:  */
  7: 
  8: namespace Nette\Caching;
  9: 
 10: use Nette,
 11:     Nette\Utils\Callback;
 12: 
 13: 
 14: /**
 15:  * Implements the cache for a application.
 16:  *
 17:  * @author     David Grudl
 18:  *
 19:  * @property-read IStorage $storage
 20:  * @property-read string $namespace
 21:  */
 22: class Cache extends Nette\Object implements \ArrayAccess
 23: {
 24:     /** dependency */
 25:     const PRIORITY = 'priority',
 26:         EXPIRATION = 'expire',
 27:         EXPIRE = 'expire',
 28:         SLIDING = 'sliding',
 29:         TAGS = 'tags',
 30:         FILES = 'files',
 31:         ITEMS = 'items',
 32:         CONSTS = 'consts',
 33:         CALLBACKS = 'callbacks',
 34:         ALL = 'all';
 35: 
 36:     /** @internal */
 37:     const NAMESPACE_SEPARATOR = "\x00";
 38: 
 39:     /** @var IStorage */
 40:     private $storage;
 41: 
 42:     /** @var string */
 43:     private $namespace;
 44: 
 45:     /** @var string  last query cache used by offsetGet() */
 46:     private $key;
 47: 
 48:     /** @var mixed  last query cache used by offsetGet()  */
 49:     private $data;
 50: 
 51: 
 52:     public function __construct(IStorage $storage, $namespace = NULL)
 53:     {
 54:         $this->storage = $storage;
 55:         $this->namespace = $namespace . self::NAMESPACE_SEPARATOR;
 56:     }
 57: 
 58: 
 59:     /**
 60:      * Returns cache storage.
 61:      * @return IStorage
 62:      */
 63:     public function getStorage()
 64:     {
 65:         return $this->storage;
 66:     }
 67: 
 68: 
 69:     /**
 70:      * Returns cache namespace.
 71:      * @return string
 72:      */
 73:     public function getNamespace()
 74:     {
 75:         return (string) substr($this->namespace, 0, -1);
 76:     }
 77: 
 78: 
 79:     /**
 80:      * Returns new nested cache object.
 81:      * @param  string
 82:      * @return Cache
 83:      */
 84:     public function derive($namespace)
 85:     {
 86:         $derived = new static($this->storage, $this->namespace . $namespace);
 87:         return $derived;
 88:     }
 89: 
 90: 
 91:     /**
 92:      * Reads the specified item from the cache or generate it.
 93:      * @param  mixed key
 94:      * @param  callable
 95:      * @return mixed|NULL
 96:      */
 97:     public function load($key, $fallback = NULL)
 98:     {
 99:         $data = $this->storage->read($this->generateKey($key));
100:         if ($data === NULL && $fallback) {
101:             return $this->save($key, Callback::closure($fallback));
102:         }
103:         return $data;
104:     }
105: 
106: 
107:     /**
108:      * Writes item into the cache.
109:      * Dependencies are:
110:      * - Cache::PRIORITY => (int) priority
111:      * - Cache::EXPIRATION => (timestamp) expiration
112:      * - Cache::SLIDING => (bool) use sliding expiration?
113:      * - Cache::TAGS => (array) tags
114:      * - Cache::FILES => (array|string) file names
115:      * - Cache::ITEMS => (array|string) cache items
116:      * - Cache::CONSTS => (array|string) cache items
117:      *
118:      * @param  mixed  key
119:      * @param  mixed  value
120:      * @param  array  dependencies
121:      * @return mixed  value itself
122:      * @throws Nette\InvalidArgumentException
123:      */
124:     public function save($key, $data, array $dependencies = NULL)
125:     {
126:         $this->release();
127:         $key = $this->generateKey($key);
128: 
129:         if ($data instanceof Nette\Callback || $data instanceof \Closure) {
130:             $this->storage->lock($key);
131:             $data = call_user_func_array($data, array(& $dependencies));
132:         }
133: 
134:         if ($data === NULL) {
135:             $this->storage->remove($key);
136:         } else {
137:             $this->storage->write($key, $data, $this->completeDependencies($dependencies, $data));
138:             return $data;
139:         }
140:     }
141: 
142: 
143:     private function completeDependencies($dp, $data)
144:     {
145:         if (is_object($data)) {
146:             $dp[self::CALLBACKS][] = array(array(__CLASS__, 'checkSerializationVersion'), get_class($data),
147:                 Nette\Reflection\ClassType::from($data)->getAnnotation('serializationVersion'));
148:         }
149: 
150:         // convert expire into relative amount of seconds
151:         if (isset($dp[Cache::EXPIRATION])) {
152:             $dp[Cache::EXPIRATION] = Nette\DateTime::from($dp[Cache::EXPIRATION])->format('U') - time();
153:         }
154: 
155:         // convert FILES into CALLBACKS
156:         if (isset($dp[self::FILES])) {
157:             foreach (array_unique((array) $dp[self::FILES]) as $item) {
158:                 $dp[self::CALLBACKS][] = array(array(__CLASS__, 'checkFile'), $item, @filemtime($item)); // @ - stat may fail
159:             }
160:             unset($dp[self::FILES]);
161:         }
162: 
163:         // add namespaces to items
164:         if (isset($dp[self::ITEMS])) {
165:             $dp[self::ITEMS] = array_unique(array_map(array($this, 'generateKey'), (array) $dp[self::ITEMS]));
166:         }
167: 
168:         // convert CONSTS into CALLBACKS
169:         if (isset($dp[self::CONSTS])) {
170:             foreach (array_unique((array) $dp[self::CONSTS]) as $item) {
171:                 $dp[self::CALLBACKS][] = array(array(__CLASS__, 'checkConst'), $item, constant($item));
172:             }
173:             unset($dp[self::CONSTS]);
174:         }
175: 
176:         if (!is_array($dp)) {
177:             $dp = array();
178:         }
179:         return $dp;
180:     }
181: 
182: 
183:     /**
184:      * Removes item from the cache.
185:      * @param  mixed  key
186:      * @return void
187:      */
188:     public function remove($key)
189:     {
190:         $this->save($key, NULL);
191:     }
192: 
193: 
194:     /**
195:      * Removes items from the cache by conditions.
196:      * Conditions are:
197:      * - Cache::PRIORITY => (int) priority
198:      * - Cache::TAGS => (array) tags
199:      * - Cache::ALL => TRUE
200:      * @return void
201:      */
202:     public function clean(array $conditions = NULL)
203:     {
204:         $this->release();
205:         $this->storage->clean((array) $conditions);
206:     }
207: 
208: 
209:     /**
210:      * Caches results of function/method calls.
211:      * @param  mixed
212:      * @return mixed
213:      */
214:     public function call($function)
215:     {
216:         $key = func_get_args();
217:         $key[0] = Callback::toReflection($function);
218:         return $this->load($key, function() use ($function, $key) {
219:             return Callback::invokeArgs($function, array_slice($key, 1));
220:         });
221:     }
222: 
223: 
224:     /**
225:      * Caches results of function/method calls.
226:      * @param  mixed
227:      * @param  array  dependencies
228:      * @return Closure
229:      */
230:     public function wrap($function, array $dependencies = NULL)
231:     {
232:         $cache = $this;
233:         return function() use ($cache, $function, $dependencies) {
234:             $key = array(Callback::toReflection($function), func_get_args());
235:             $data = $cache->load($key);
236:             if ($data === NULL) {
237:                 $data = $cache->save($key, Callback::invokeArgs($function, $key[1]), $dependencies);
238:             }
239:             return $data;
240:         };
241:     }
242: 
243: 
244:     /**
245:      * Starts the output cache.
246:      * @param  mixed  key
247:      * @return OutputHelper|NULL
248:      */
249:     public function start($key)
250:     {
251:         $data = $this->load($key);
252:         if ($data === NULL) {
253:             return new OutputHelper($this, $key);
254:         }
255:         echo $data;
256:     }
257: 
258: 
259:     /**
260:      * Generates internal cache key.
261:      *
262:      * @param  string
263:      * @return string
264:      */
265:     protected function generateKey($key)
266:     {
267:         return $this->namespace . md5(is_scalar($key) ? $key : serialize($key));
268:     }
269: 
270: 
271:     /********************* interface ArrayAccess ****************d*g**/
272: 
273: 
274:     /**
275:      * Inserts (replaces) item into the cache (\ArrayAccess implementation).
276:      * @param  mixed key
277:      * @param  mixed
278:      * @return void
279:      * @throws Nette\InvalidArgumentException
280:      */
281:     public function offsetSet($key, $data)
282:     {
283:         $this->save($key, $data);
284:     }
285: 
286: 
287:     /**
288:      * Retrieves the specified item from the cache or NULL if the key is not found (\ArrayAccess implementation).
289:      * @param  mixed key
290:      * @return mixed|NULL
291:      * @throws Nette\InvalidArgumentException
292:      */
293:     public function offsetGet($key)
294:     {
295:         $key = is_scalar($key) ? (string) $key : serialize($key);
296:         if ($this->key !== $key) {
297:             $this->key = $key;
298:             $this->data = $this->load($key);
299:         }
300:         return $this->data;
301:     }
302: 
303: 
304:     /**
305:      * Exists item in cache? (\ArrayAccess implementation).
306:      * @param  mixed key
307:      * @return bool
308:      * @throws Nette\InvalidArgumentException
309:      */
310:     public function offsetExists($key)
311:     {
312:         $this->release();
313:         return $this->offsetGet($key) !== NULL;
314:     }
315: 
316: 
317:     /**
318:      * Removes the specified item from the cache.
319:      * @param  mixed key
320:      * @return void
321:      * @throws Nette\InvalidArgumentException
322:      */
323:     public function offsetUnset($key)
324:     {
325:         $this->save($key, NULL);
326:     }
327: 
328: 
329:     /**
330:      * Discards the internal cache used by ArrayAccess.
331:      * @return void
332:      */
333:     public function release()
334:     {
335:         $this->key = $this->data = NULL;
336:     }
337: 
338: 
339:     /********************* dependency checkers ****************d*g**/
340: 
341: 
342:     /**
343:      * Checks CALLBACKS dependencies.
344:      * @param  array
345:      * @return bool
346:      */
347:     public static function checkCallbacks($callbacks)
348:     {
349:         foreach ($callbacks as $callback) {
350:             if (!call_user_func_array(array_shift($callback), $callback)) {
351:                 return FALSE;
352:             }
353:         }
354:         return TRUE;
355:     }
356: 
357: 
358:     /**
359:      * Checks CONSTS dependency.
360:      * @param  string
361:      * @param  mixed
362:      * @return bool
363:      */
364:     private static function checkConst($const, $value)
365:     {
366:         return defined($const) && constant($const) === $value;
367:     }
368: 
369: 
370:     /**
371:      * Checks FILES dependency.
372:      * @param  string
373:      * @param  int
374:      * @return bool
375:      */
376:     private static function checkFile($file, $time)
377:     {
378:         return @filemtime($file) == $time; // @ - stat may fail
379:     }
380: 
381: 
382:     /**
383:      * Checks object @serializationVersion label.
384:      * @param  string
385:      * @param  mixed
386:      * @return bool
387:      */
388:     private static function checkSerializationVersion($class, $value)
389:     {
390:         return Nette\Reflection\ClassType::from($class)->getAnnotation('serializationVersion') === $value;
391:     }
392: 
393: }
394: 
Nette Framework 2.1.8 API API documentation generated by ApiGen 2.8.0