interface/modules/zend_modules/library/Zend/Cache/Pattern/ClassCache.php

   1 <?php
   2 /**
   3  * Zend Framework (http://framework.zend.com/)
   4  *
   5  * @link      http://github.com/zendframework/zf2 for the canonical source repository
   6  * @copyright Copyright (c) 2005-2013 Zend Technologies USA Inc. (http://www.zend.com)
   7  * @license   http://framework.zend.com/license/new-bsd New BSD License
   8  */
   9
  10 namespace Zend\Cache\Pattern;
  11
  12 use Zend\Cache;
  13 use Zend\Cache\Exception;
  14
  15 class ClassCache extends CallbackCache
  16 {
  17     /**
  18      * Set options
  19      *
  20      * @param  PatternOptions $options
  21      * @return ClassCache
  22      * @throws Exception\InvalidArgumentException if missing 'class' or 'storage' options
  23      */
  24     public function setOptions(PatternOptions $options)
  25     {
  26         parent::setOptions($options);
  27
  28         if (!$options->getClass()) {
  29             throw new Exception\InvalidArgumentException("Missing option 'class'");
  30         } elseif (!$options->getStorage()) {
  31             throw new Exception\InvalidArgumentException("Missing option 'storage'");
  32         }
  33         return $this;
  34     }
  35
  36     /**
  37      * Call and cache a class method
  38      *
  39      * @param  string $method  Method name to call
  40      * @param  array  $args    Method arguments
  41      * @return mixed
  42      * @throws Exception\RuntimeException
  43      * @throws \Exception
  44      */
  45     public function call($method, array $args = array())
  46     {
  47         $options   = $this->getOptions();
  48         $classname = $options->getClass();
  49         $method    = strtolower($method);
  50         $callback  = $classname . '::' . $method;
  51
  52         $cache = $options->getCacheByDefault();
  53         if ($cache) {
  54             $cache = !in_array($method, $options->getClassNonCacheMethods());
  55         } else {
  56             $cache = in_array($method, $options->getClassCacheMethods());
  57         }
  58
  59         if (!$cache) {
  60             if ($args) {
  61                 return call_user_func_array($callback, $args);
  62             } else {
  63                 return $classname::$method();
  64             }
  65         }
  66
  67         return parent::call($callback, $args);
  68     }
  69
  70     /**
  71      * Generate a unique key in base of a key representing the callback part
  72      * and a key representing the arguments part.
  73      *
  74      * @param  string     $method  The method
  75      * @param  array      $args    Callback arguments
  76      * @return string
  77      * @throws Exception\RuntimeException
  78      */
  79     public function generateKey($method, array $args = array())
  80     {
  81         return $this->generateCallbackKey(
  82             $this->getOptions()->getClass() . '::' . $method,
  83             $args
  84         );
  85     }
  86
  87     /**
  88      * Generate a unique key in base of a key representing the callback part
  89      * and a key representing the arguments part.
  90      *
  91      * @param  callable   $callback  A valid callback
  92      * @param  array      $args      Callback arguments
  93      * @return string
  94      * @throws Exception\RuntimeException
  95      */
  96     protected function generateCallbackKey($callback, array $args)
  97     {
  98         $callbackKey = md5(strtolower($callback));
  99         $argumentKey = $this->generateArgumentsKey($args);
 100         return $callbackKey . $argumentKey;
 101     }
 102
 103     /**
 104      * Calling a method of the entity.
 105      *
 106      * @param  string $method  Method name to call
 107      * @param  array  $args    Method arguments
 108      * @return mixed
 109      * @throws Exception\RuntimeException
 110      * @throws \Exception
 111      */
 112     public function __call($method, array $args)
 113     {
 114         return $this->call($method, $args);
 115     }
 116
 117     /**
 118      * Set a static property
 119      *
 120      * @param  string $name
 121      * @param  mixed  $value
 122      * @return void
 123      * @see   http://php.net/manual/language.oop5.overloading.php#language.oop5.overloading.members
 124      */
 125     public function __set($name, $value)
 126     {
 127         $class = $this->getOptions()->getClass();
 128         $class::$name = $value;
 129     }
 130
 131     /**
 132      * Get a static property
 133      *
 134      * @param  string $name
 135      * @return mixed
 136      * @see    http://php.net/manual/language.oop5.overloading.php#language.oop5.overloading.members
 137      */
 138     public function __get($name)
 139     {
 140         $class = $this->getOptions()->getClass();
 141         return $class::$name;
 142     }
 143
 144     /**
 145      * Is a static property exists.
 146      *
 147      * @param  string $name
 148      * @return bool
 149      */
 150     public function __isset($name)
 151     {
 152         $class = $this->getOptions()->getClass();
 153         return isset($class::$name);
 154     }
 155
 156     /**
 157      * Unset a static property
 158      *
 159      * @param  string $name
 160      * @return void
 161      */
 162     public function __unset($name)
 163     {
 164         $class = $this->getOptions()->getClass();
 165         unset($class::$name);
 166     }
 167 }