vendor/pear/Cache_Lite/Lite/Function.php

   1 <?php
   2
   3 /**
   4 * This class extends Cache_Lite and can be used to cache the result and output of functions/methods
   5 *
   6 * This class is completly inspired from Sebastian Bergmann's
   7 * PEAR/Cache_Function class. This is only an adaptation to
   8 * Cache_Lite
   9 *
  10 * There are some examples in the 'docs/examples' file
  11 * Technical choices are described in the 'docs/technical' file
  12 *
  13 * @package Cache_Lite
  14 * @version $Id: Function.php,v 1.10 2006/02/04 18:36:36 fab Exp $
  15 * @author Sebastian BERGMANN <sb@sebastian-bergmann.de>
  16 * @author Fabien MARTY <fab@php.net>
  17 */
  18
  19 require_once('Cache/Lite.php');
  20
  21 class Cache_Lite_Function extends Cache_Lite
  22 {
  23
  24     // --- Private properties ---
  25
  26     /**
  27      * Default cache group for function caching
  28      *
  29      * @var string $_defaultGroup
  30      */
  31     var $_defaultGroup = 'Cache_Lite_Function';
  32
  33     /**
  34      * Don't cache the method call when its output contains the string "NOCACHE"
  35      *
  36      * if set to true, the output of the method will never be displayed (because the output is used
  37      * to control the cache)
  38      *
  39      * @var boolean $_dontCacheWhenTheOutputContainsNOCACHE
  40      */
  41     var $_dontCacheWhenTheOutputContainsNOCACHE = false;
  42
  43     /**
  44      * Don't cache the method call when its result is false
  45      *
  46      * @var boolean $_dontCacheWhenTheResultIsFalse
  47      */
  48     var $_dontCacheWhenTheResultIsFalse = false;
  49
  50     /**
  51      * Don't cache the method call when its result is null
  52      *
  53      * @var boolean $_dontCacheWhenTheResultIsNull
  54      */
  55     var $_dontCacheWhenTheResultIsNull = false;
  56
  57     /**
  58      * Debug the Cache_Lite_Function caching process
  59      *
  60      * @var boolean $_debugCacheLiteFunction
  61      */
  62     var $_debugCacheLiteFunction = false;
  63
  64     // --- Public methods ----
  65
  66     /**
  67     * Constructor
  68     *
  69     * $options is an assoc. To have a look at availables options,
  70     * see the constructor of the Cache_Lite class in 'Cache_Lite.php'
  71     *
  72     * Comparing to Cache_Lite constructor, there is another option :
  73     * $options = array(
  74     *     (...) see Cache_Lite constructor
  75     *     'debugCacheLiteFunction' => (bool) debug the caching process,
  76     *     'defaultGroup' => default cache group for function caching (string),
  77     *     'dontCacheWhenTheOutputContainsNOCACHE' => (bool) don't cache when the function output contains "NOCACHE",
  78     *     'dontCacheWhenTheResultIsFalse' => (bool) don't cache when the function result is false,
  79     *     'dontCacheWhenTheResultIsNull' => (bool don't cache when the function result is null
  80     * );
  81     *
  82     * @param array $options options
  83     * @access public
  84     */
  85     function Cache_Lite_Function($options = array(NULL))
  86     {
  87         $availableOptions = array('debugCacheLiteFunction', 'defaultGroup', 'dontCacheWhenTheOutputContainsNOCACHE', 'dontCacheWhenTheResultIsFalse', 'dontCacheWhenTheResultIsNull');
  88         while (list($name, $value) = each($options)) {
  89                 if (in_array($name, $availableOptions)) {
  90                     $property = '_'.$name;
  91                     $this->$property = $value;
  92                 }
  93         }
  94         reset($options);
  95         $this->Cache_Lite($options);
  96     }
  97
  98     /**
  99     * Calls a cacheable function or method (or not if there is already a cache for it)
 100     *
 101     * Arguments of this method are read with func_get_args. So it doesn't appear
 102     * in the function definition. Synopsis :
 103     * call('functionName', $arg1, $arg2, ...)
 104     * (arg1, arg2... are arguments of 'functionName')
 105     *
 106     * @return mixed result of the function/method
 107     * @access public
 108     */
 109     function call()
 110     {
 111         $arguments = func_get_args();
 112         $id = $this->_makeId($arguments);
 113         $data = $this->get($id, $this->_defaultGroup);
 114         if ($data !== false) {
 115             if ($this->_debugCacheLiteFunction) {
 116                 echo "Cache hit !\n";
 117             }
 118             $array = unserialize($data);
 119             $output = $array['output'];
 120             $result = $array['result'];
 121         } else {
 122             if ($this->_debugCacheLiteFunction) {
 123                 echo "Cache missed !\n";
 124             }
 125             ob_start();
 126             ob_implicit_flush(false);
 127             $target = array_shift($arguments);
 128             if (is_array($target)) {
 129                 // in this case, $target is for example array($obj, 'method')
 130                 $object = $target[0];
 131                 $method = $target[1];
 132                 $result = call_user_func_array(array(&$object, $method), $arguments);
 133             } else {
 134                     if (strstr($target, '::')) { // classname::staticMethod
 135                         list($class, $method) = explode('::', $target);
 136                         $result = call_user_func_array(array($class, $method), $arguments);
 137                     } else if (strstr($target, '->')) { // object->method
 138                         // use a stupid name ($objet_123456789 because) of problems where the object
 139                         // name is the same as this var name
 140                         list($object_123456789, $method) = explode('->', $target);
 141                         global $$object_123456789;
 142                         $result = call_user_func_array(array($$object_123456789, $method), $arguments);
 143                     } else { // function
 144                         $result = call_user_func_array($target, $arguments);
 145                     }
 146             }
 147             $output = ob_get_contents();
 148             ob_end_clean();
 149             if ($this->_dontCacheWhenTheResultIsFalse) {
 150                 if ((is_bool($result)) && (!($result))) {
 151                     echo($output);
 152                     return $result;
 153                 }
 154             }
 155             if ($this->_dontCacheWhenTheResultIsNull) {
 156                 if (is_null($result)) {
 157                     echo($output);
 158                     return $result;
 159                 }
 160             }
 161             if ($this->_dontCacheWhenTheOutputContainsNOCACHE) {
 162                 if (strpos($output, 'NOCACHE') > -1) {
 163                     return $result;
 164                 }
 165             }
 166             $array['output'] = $output;
 167             $array['result'] = $result;
 168             $this->save(serialize($array), $id, $this->_defaultGroup);
 169         }
 170         echo($output);
 171         return $result;
 172     }
 173
 174     /**
 175     * Drop a cache file
 176     *
 177     * Arguments of this method are read with func_get_args. So it doesn't appear
 178     * in the function definition. Synopsis :
 179     * remove('functionName', $arg1, $arg2, ...)
 180     * (arg1, arg2... are arguments of 'functionName')
 181     *
 182     * @return boolean true if no problem
 183     * @access public
 184     */
 185     function drop()
 186     {
 187         $id = $this->_makeId(func_get_args());
 188         $this->remove($id, $this->_defaultGroup);
 189     }
 190
 191     /**
 192     * Make an id for the cache
 193     *
 194     * @var array result of func_get_args for the call() or the remove() method
 195     * @return string id
 196     * @access private
 197     */
 198     function _makeId($arguments)
 199     {
 200         $id = serialize($arguments); // Generate a cache id
 201         if (!$this->_fileNameProtection) {
 202             $id = md5($id);
 203             // if fileNameProtection is set to false, then the id has to be hashed
 204             // because it's a very bad file name in most cases
 205         }
 206         return $id;
 207     }
 208
 209 }
 210
 211 ?>