home *** CD-ROM | disk | FTP | other *** search
/ PC World 2005 April / PCWorld_2005-04_cd.bin / akce / web / phptriad / phptriad2-2-1.exe / php / pear / Cache / Function.php < prev    next >
PHP Script  |  2001-08-11  |  5KB  |  160 lines
  1. <?php
  2. /**
  3. * Function_Cache
  4. *
  5. * Purpose:
  6. *
  7. *   Caching the result and output of functions.
  8. *
  9. * Example:
  10. *
  11. *   require_once 'Cache/Function.php';
  12. *
  13. *   class foo {
  14. *     function bar($test) {
  15. *       echo "foo::bar($test)<br>";
  16. *     }
  17. *   }
  18. *
  19. *   class bar {
  20. *     function foobar($object) {
  21. *       echo '$'.$object.'->foobar('.$object.')<br>';
  22. *     }
  23. *   }
  24. *
  25. *   $bar = new bar;
  26. *
  27. *   function foobar() {
  28. *     echo 'foobar()';
  29. *   }
  30. *
  31. *   $cache = new Cache_Function();
  32. *
  33. *   $cache->call('foo::bar', 'test');
  34. *   $cache->call('bar->foobar', 'bar');
  35. *   $cache->call('foobar');
  36. *
  37. * Note:
  38. * 
  39. *   You cannot cache every function. You should only cache 
  40. *   functions that only depend on their arguments and don't use
  41. *   global or static variables, don't rely on database queries or 
  42. *   files, and so on.
  43. * 
  44. * @author       Sebastian Bergmann <sb@sebastian-bergmann.de>
  45. * @module       Function_Cache
  46. * @modulegroup  Function_Cache
  47. * @package      Cache
  48. * @version      $Revision: 1.11 $
  49. * @access       public
  50. */
  51.  
  52. // +----------------------------------------------------------------------+
  53. // | PHP version 4.0                                                      |
  54. // +----------------------------------------------------------------------+
  55. // | Copyright (c) 1997, 1998, 1999, 2000, 2001 The PHP Group             |
  56. // +----------------------------------------------------------------------+
  57. // | This source file is subject to version 2.0 of the PHP license,       |
  58. // | that is bundled with this package in the file LICENSE, and is        |
  59. // | available at through the world-wide-web at                           |
  60. // | http://www.php.net/license/2_02.txt.                                 |
  61. // | If you did not receive a copy of the PHP license and are unable to   |
  62. // | obtain it through the world-wide-web, please send a note to          |
  63. // | license@php.net so we can mail you a copy immediately.               |
  64. // +----------------------------------------------------------------------+
  65. // | Authors: Sebastian Bergmann <sb@sebastian-bergmann.de>               |
  66. // +----------------------------------------------------------------------+
  67. //
  68. // $Id: Function.php,v 1.11 2001/08/11 17:04:17 sebastian Exp $
  69.  
  70. require_once 'Cache.php';
  71.  
  72. class Cache_Function extends Cache {
  73.     var $expires;
  74.  
  75.     /**
  76.     * Constructor
  77.     *
  78.     * @param    string  Name of container class
  79.     * @param    array   Array with container class options
  80.     * @param    integer Number of seconds for which to cache
  81.     */
  82.     function Cache_Function($container  = 'file',
  83.                             $container_options = array('cache_dir'       => '.',
  84.                                                        'filename_prefix' => 'cache_'
  85.                                                       ),
  86.                             $expires = 3600
  87.                            )
  88.     {
  89.       $this->Cache($container, $container_options);
  90.       $this->expires = $expires;      
  91.     }
  92.  
  93.     /**
  94.     * PEAR-Deconstructor
  95.     * Call deconstructor of parent
  96.     */
  97.     function _Cache_Function() {
  98.         $this->_Cache();
  99.     }
  100.  
  101.     /**
  102.     * Calls a cacheable function or method.
  103.     *
  104.     * @return mixed $result
  105.     * @access public
  106.     */
  107.     function call() {
  108.         // get arguments
  109.         $arguments = func_get_args();
  110.  
  111.         // generate cache id
  112.         $id = md5(serialize($arguments));
  113.  
  114.         // query cache
  115.         $cached_object = $this->get($id, 'function_cache');
  116.  
  117.         if ($cached_object != NULL) {
  118.             // cache hit: return cached output and result
  119.  
  120.             $output = $cached_object[0];
  121.             $result = $cached_object[1];
  122.  
  123.         } else {
  124.             // cache miss: call function, store output and result in cache
  125.  
  126.             ob_start();
  127.             $target = array_shift($arguments);
  128.  
  129.             // classname::staticMethod
  130.             if (strstr($target, '::')) {
  131.                 list($class, $method) = explode('::', $target);
  132.  
  133.                 $result = call_user_method_array($method, $class, $arguments);
  134.             }
  135.  
  136.             // object->method
  137.             elseif (strstr($target, '->')) {
  138.                 list($object, $method) = explode('->', $target);
  139.                 global $$object;
  140.  
  141.                 $result = call_user_method_array($method, $$object, $arguments);
  142.             }
  143.  
  144.             // function
  145.             else {
  146.                 $result = call_user_func_array($target, $arguments);
  147.             }
  148.  
  149.             $output = ob_get_contents();
  150.             ob_end_clean();
  151.  
  152.             $this->save($id, array($output, $result), $this->expires, 'function_cache');
  153.         }
  154.  
  155.         echo $output;
  156.         return $result;
  157.     }
  158. }
  159. ?>
  160.