1. sfFunctionCache.class.php
  2. /**
 * This class can be used to cache the result and output of any PHP callable (function and method calls).
 *
 * @package    symfony
 * @subpackage cache
 * @author     Fabien Potencier 
 * @version    SVN: $Id: sfFunctionCache.class.php 23939 2009-11-14 17:46:14Z fabien $
 */
  3. class sfFunctionCache
  4. {
  5.   protected $cache = null;
  7.   /**
  8.    * Constructor.
  9.    *
  10.    * @param sfCache $cache An sfCache object instance
  11.    */
  12.   public function __construct(sfCache $cache)
  13.   {
  14.     $this->cache = $cache;
  15.   }
  17.   /**
  18.    * Calls a cacheable function or method (or not if there is already a cache for it).
  19.    *
  20.    * Arguments of this method are read with func_get_args. So it doesn't appear in the function definition.
  21.    *
  22.    * The first argument can be any PHP callable:
  23.    *
  24.    * $cache->call('functionName', array($arg1, $arg2));
  25.    * $cache->call(array($object, 'methodName'), array($arg1, $arg2));
  26.    *
  27.    * @param mixed $callable  A PHP callable
  28.    * @param array $arguments An array of arguments to pass to the callable
  29.    *
  30.    * @return mixed The result of the function/method
  31.    */
  32.   public function call($callable, $arguments = array())
  33.   {
  34.     // Generate a cache id
  35.     $key = $this->computeCacheKey($callable, $arguments);
  37.     $serialized = $this->cache->get($key);
  38.     if ($serialized !== null)
  39.     {
  40.       $data = unserialize($serialized);
  41.     }
  42.     else
  43.     {
  44.       $data = array();
  46.       if (!is_callable($callable))
  47.       {
  48.         throw new sfException('The first argument to call() must be a valid callable.');
  49.       }
  51.       ob_start();
  52.       ob_implicit_flush(false);
  54.       try
  55.       {
  56.         $data['result'] = call_user_func_array($callable, $arguments);
  57.       }
  58.       catch (Exception $e)
  59.       {
  60.         ob_end_clean();
  61.         throw $e;
  62.       }
  64.       $data['output'] = ob_get_clean();
  66.       $this->cache->set($key, serialize($data));
  67.     }
  69.     echo $data['output'];
  71.     return $data['result'];
  72.   }
  74.   /**
  75.    * Returns the cache instance.
  76.    *
  77.    * @return sfCache The sfCache instance
  78.    */
  79.   public function getCache()
  80.   {
  81.     return $this->cache;
  82.   }
  84.   /**
  85.    * Computes the cache key for a given callable and the arguments.
  86.    *
  87.    * @param mixed $callable  A PHP callable
  88.    * @param array $arguments An array of arguments to pass to the callable
  89.    *
  90.    * @return string The associated cache key
  91.    */
  92.   public function computeCacheKey($callable, $arguments = array())
  93.   {
  94.     return md5(serialize($callable).serialize($arguments));
  95.   }
  96. }
Debug toolbar