Support Joomla!

Joomla! 1.5 Documentation

Packages

Package: Cache_Lite

Developer Network License

The Joomla! Developer Network content is © copyright 2006 by the individual contributors and can be used in accordance with the Creative Commons License, Attribution- NonCommercial- ShareAlike 2.5
Source code for file /pear/cache/lite/Function.php

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