1. sfCache.class.php
  2. /**
 * sfCache is an abstract class for all cache classes in symfony.
 *
 * @package    symfony
 * @subpackage cache
 * @author     Fabien Potencier 
 * @version    SVN: $Id: sfCache.class.php 23810 2009-11-12 11:07:44Z Kris.Wallsmith $
 */
  3. abstract class sfCache
  4. {
  5.   const OLD = 1;
  6.   const ALL = 2;
  7.   const SEPARATOR = ':';
  9.   protected
  10.     $options = array();
  12.   /**
  13.    * Class constructor.
  14.    *
  15.    * @see initialize()
  16.    */
  17.   public function __construct($options = array())
  18.   {
  19.     $this->initialize($options);
  20.   }
  22.   /**
  23.    * Initializes this sfCache instance.
  24.    *
  25.    * @param array $options An array of options.
  26.    *
  27.    * Available options:
  28.    *
  29.    * * automatic_cleaning_factor: The automatic cleaning process destroy too old (for the given life time) (default value: 1000)
  30.    *   cache files when a new cache file is written.
  31.    *     0               => no automatic cache cleaning
  32.    *     1               => systematic cache cleaning
  33.    *     x (integer) > 1 => automatic cleaning randomly 1 times on x cache write
  34.    *
  35.    * * lifetime (optional): The default life time (default value: 86400)
  36.    *
  37.    * @throws <b>sfInitializationException</b> If an error occurs while initializing this sfCache instance.
  38.    */
  39.   public function initialize($options = array())
  40.   {
  41.     $this->options = array_merge(array(
  42.       'automatic_cleaning_factor' => 1000,
  43.       'lifetime'                  => 86400,
  44.       'prefix'                    => md5(dirname(__FILE__)),
  45.     ), $options);
  47.     $this->options['prefix'] .= self::SEPARATOR;
  48.   }
  50.   /**
  51.    * Gets the cache content for a given key.
  52.    *
  53.    * @param string $key     The cache key
  54.    * @param mixed  $default The default value is the key does not exist or not valid anymore
  55.    *
  56.    * @return mixed The data of the cache
  57.    */
  58.   abstract public function get($key, $default = null);
  60.   /**
  61.    * Returns true if there is a cache for the given key.
  62.    *
  63.    * @param string $key The cache key
  64.    *
  65.    * @return Boolean true if the cache exists, false otherwise
  66.    */
  67.   abstract public function has($key);
  69.   /**
  70.    * Saves some data in the cache.
  71.    *
  72.    * @param string $key      The cache key
  73.    * @param mixed  $data     The data to put in cache
  74.    * @param int    $lifetime The lifetime
  75.    *
  76.    * @return Boolean true if no problem
  77.    */
  78.   abstract public function set($key, $data, $lifetime = null);
  80.   /**
  81.    * Removes a content from the cache.
  82.    *
  83.    * @param string $key The cache key
  84.    *
  85.    * @return Boolean true if no problem
  86.    */
  87.   abstract public function remove($key);
  89.   /**
  90.    * Removes content from the cache that matches the given pattern.
  91.    *
  92.    * @param string $pattern The cache key pattern
  93.    *
  94.    * @return Boolean true if no problem
  95.    *
  96.    * @see patternToRegexp
  97.    */
  98.   abstract public function removePattern($pattern);
  100.   /**
  101.    * Cleans the cache.
  102.    *
  103.    * @param string $mode The clean mode
  104.    *                     sfCache::ALL: remove all keys (default)
  105.    *                     sfCache::OLD: remove all expired keys
  106.    *
  107.    * @return Boolean true if no problem
  108.    */
  109.   abstract public function clean($mode = self::ALL);
  111.   /**
  112.    * Returns the timeout for the given key.
  113.    *
  114.    * @param string $key The cache key
  115.    *
  116.    * @return int The timeout time
  117.    */
  118.   abstract public function getTimeout($key);
  120.   /**
  121.    * Returns the last modification date of the given key.
  122.    *
  123.    * @param string $key The cache key
  124.    *
  125.    * @return int The last modified time
  126.    */
  127.   abstract public function getLastModified($key);
  129.   /**
  130.    * Gets many keys at once.
  131.    *
  132.    * @param array $keys An array of keys
  133.    *
  134.    * @return array An associative array of data from cache
  135.    */
  136.   public function getMany($keys)
  137.   {
  138.     $data = array();
  139.     foreach ($keys as $key)
  140.     {
  141.       $data[$key] = $this->get($key);
  142.     }
  144.     return $data;
  145.   }
  147.   /**
  148.    * Computes lifetime.
  149.    *
  150.    * @param integer $lifetime Lifetime in seconds
  151.    *
  152.    * @return integer Lifetime in seconds
  153.    */
  154.   public function getLifetime($lifetime)
  155.   {
  156.     return null === $lifetime ? $this->getOption('lifetime') : $lifetime;
  157.   }
  159.   /**
  160.    * Gets the backend object.
  161.    *
  162.    * @return object The backend object
  163.    */
  164.   public function getBackend()
  165.   {
  166.     throw new sfException('This cache class does not have a backend object.');
  167.   }
  169.   /**
  170.    * Gets an option value.
  171.    *
  172.    * @param string $name    The option name
  173.    * @param mixed  $default The default value
  174.    *
  175.    * @return mixed The option value
  176.    */
  177.   public function getOption($name, $default = null)
  178.   {
  179.     return isset($this->options[$name]) ? $this->options[$name] : $default;
  180.   }
  182.   /**
  183.    * Sets an option value.
  184.    *
  185.    * @param string $name  The option name
  186.    * @param mixed  $value The option value
  187.    */
  188.   public function setOption($name, $value)
  189.   {
  190.     return $this->options[$name] = $value;
  191.   }
  193.   /**
  194.    * Converts a pattern to a regular expression.
  195.    *
  196.    * A pattern can use some special characters:
  197.    *
  198.    *  - * Matches a namespace (foo:*:bar)
  199.    *  - ** Matches one or more namespaces (foo:**:bar)
  200.    *
  201.    * @param string $pattern A pattern
  202.    *
  203.    * @return string A regular expression
  204.    */
  205.   protected function patternToRegexp($pattern)
  206.   {
  207.     $regexp = str_replace(
  208.       array('\\*\\*', '\\*'),
  209.       array('.+?',    '[^'.preg_quote(sfCache::SEPARATOR, '#').']+'),
  210.       preg_quote($pattern, '#')
  211.     );
  213.     return '#^'.$regexp.'$#';
  214.   }
  215. }
Debug toolbar