source/lib/simplicity/core/cache/cache.php

   1 <?php
   2
   3 /**
   4  * Cache Module
   5  *
   6  * The Simplicity Cache module is a core module providing a cache abstraction layer to Simplicity
   7  * and other modules.
   8  *
   9  * @author John Le Drew <jp@antz29.com>
  10  * @copyright Copyright (c) 2009, John Le Drew
  11  * @license http://www.opensource.org/licenses/mit-license.php MIT License
  12  * @version 2.0.0-alpha
  13  *
  14  * @smp_children smp_CacheBackend
  15  * @smp_core
  16  */
  17 class smp_CacheModule extends smp_Module
  18 {
  19
  20         private $_ns;
  21
  22         /**
  23          * smp_CacheBackend
  24          *
  25          * @var smp_CacheBackend
  26          */
  27         private $_backend;
  28
  29         /**
  30          * @inherited
  31          */
  32         public function init()
  33         {
  34                 $this->createExtensionPoint('smp_CacheBackend');
  35                 $this->registerPluginPrefix('smp_');
  36
  37                 $this->_ns = md5(smp_Enviroment::getInstance()->getServer('SCRIPT_FILENAME').__FILE__);
  38
  39                 $this->setDefault('backend.module','auto');
  40                 $this->setDefault('backend.options',array());
  41         }
  42
  43         /**
  44          * @inherited
  45          */
  46         public function exec($args=array())
  47         {
  48                 $this->loadBackend();
  49         }
  50
  51         /**
  52          * loadBackend
  53          *
  54          * Load the selected backend, or automatically load the backend module based on their loadPriority.
  55          *
  56          */
  57         private function loadBackend()
  58         {
  59                 $backend = $this->getConfig('backend.module');
  60                 $options = $this->getConfig('backend.options');
  61
  62                 if ($backend == 'auto')
  63                 {
  64                         $backends = $this->getModules();
  65                         $beds = array();
  66                         foreach ($backends as $module => $class)
  67                         {
  68                                 if ($pri = call_user_func(array($class,'loadPriority')))
  69                                 {
  70                                         $beds[$module] = $pri;
  71                                 }
  72                         }
  73
  74                         arsort($beds,SORT_NUMERIC);
  75
  76                         $backend = key($beds);
  77                 }
  78
  79                 if (!$class = $this->getModuleClass($backend)) throw new Exception("Unknown cache backend {$backend}");
  80
  81                 $this->_backend = new $class($options);
  82         }
  83
  84         /**
  85          * get
  86          *
  87          * Retrieve the given key $name from the cache.
  88          *
  89          * @param $name string
  90          * @return mixed
  91          */
  92         public function get($name)
  93         {
  94                 $name = "{$this->_ns}.$name";
  95                 return $this->_backend->get($name);
  96         }
  97
  98         /**
  99          * set
 100          *
 101          * Set the key $name to the given $value, optionally providing a timeout $ttl in seconds (defaults to 0; no timeout)
 102          *
 103          * @param $name string
 104          * @param $value mixed
 105          * @param $ttl integer
 106          */
 107         public function set($name,$value,$ttl=0)
 108         {
 109                 if (!$name) return;
 110                 $name = "{$this->_ns}.$name";
 111                 return $this->_backend->set($name,$value,$ttl);
 112         }
 113
 114         /**
 115          * add
 116          *
 117          * Set the given key only if it does not exist.
 118          *
 119          * @see set
 120          * @param $name string
 121          * @param $value mixed
 122          * @param $ttl integer
 123          */
 124         public function add($name,$value,$ttl=0)
 125         {
 126                 if (!$name) return;
 127                 $name = "{$this->_ns}.$name";
 128                 return $this->_backend->add($name,$value,$ttl);
 129         }
 130
 131         /**
 132          * del
 133          *
 134          * Delete the given key $name.
 135          *
 136          * @param $name string
 137          */
 138         public function del($name)
 139         {
 140                 if (!$name) return;
 141                 $name = "{$this->_ns}.$name";
 142                 return $this->_backend->del($name);
 143         }
 144
 145         /**
 146          * has
 147          *
 148          * Returns true or false if the given key $name is in the cache.
 149          *
 150          * @param $name string
 151          * @return boolean
 152          */
 153         public function has($name)
 154         {
 155                 $name = "{$this->_ns}.$name";
 156                 return $this->_backend->has($name);
 157         }
 158
 159         public function clear()
 160         {
 161                 return $this->_backend->clear();
 162         }
 163 }