interface/modules/zend_modules/library/Zend/Cache/Storage/Plugin/Serializer.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\Storage\Plugin;
  11
  12 use stdClass;
  13 use Zend\Cache\Exception;
  14 use Zend\Cache\Storage\Capabilities;
  15 use Zend\Cache\Storage\Event;
  16 use Zend\Cache\Storage\PostEvent;
  17 use Zend\EventManager\EventManagerInterface;
  18
  19 class Serializer extends AbstractPlugin
  20 {
  21     /**
  22      * @var array
  23      */
  24     protected $capabilities = array();
  25
  26     /**
  27      * {@inheritDoc}
  28      */
  29     public function attach(EventManagerInterface $events, $priority = 1)
  30     {
  31         // The higher the priority the sooner the plugin will be called on pre events
  32         // but the later it will be called on post events.
  33         $prePriority  = $priority;
  34         $postPriority = -$priority;
  35
  36         // read
  37         $this->listeners[] = $events->attach('getItem.post',  array($this, 'onReadItemPost'), $postPriority);
  38         $this->listeners[] = $events->attach('getItems.post', array($this, 'onReadItemsPost'), $postPriority);
  39
  40         // write
  41         $this->listeners[] = $events->attach('setItem.pre',  array($this, 'onWriteItemPre'), $prePriority);
  42         $this->listeners[] = $events->attach('setItems.pre', array($this, 'onWriteItemsPre'), $prePriority);
  43
  44         $this->listeners[] = $events->attach('addItem.pre',  array($this, 'onWriteItemPre'), $prePriority);
  45         $this->listeners[] = $events->attach('addItems.pre', array($this, 'onWriteItemsPre'), $prePriority);
  46
  47         $this->listeners[] = $events->attach('replaceItem.pre',  array($this, 'onWriteItemPre'), $prePriority);
  48         $this->listeners[] = $events->attach('replaceItems.pre', array($this, 'onWriteItemsPre'), $prePriority);
  49
  50         $this->listeners[] = $events->attach('checkAndSetItem.pre', array($this, 'onWriteItemPre'), $prePriority);
  51
  52         // increment / decrement item(s)
  53         $this->listeners[] = $events->attach('incrementItem.pre', array($this, 'onIncrementItemPre'), $prePriority);
  54         $this->listeners[] = $events->attach('incrementItems.pre', array($this, 'onIncrementItemsPre'), $prePriority);
  55
  56         $this->listeners[] = $events->attach('decrementItem.pre', array($this, 'onDecrementItemPre'), $prePriority);
  57         $this->listeners[] = $events->attach('decrementItems.pre', array($this, 'onDecrementItemsPre'), $prePriority);
  58
  59         // overwrite capabilities
  60         $this->listeners[] = $events->attach('getCapabilities.post',  array($this, 'onGetCapabilitiesPost'), $postPriority);
  61     }
  62
  63     /**
  64      * On read item post
  65      *
  66      * @param  PostEvent $event
  67      * @return void
  68      */
  69     public function onReadItemPost(PostEvent $event)
  70     {
  71         $serializer = $this->getOptions()->getSerializer();
  72         $result     = $event->getResult();
  73         $result     = $serializer->unserialize($result);
  74         $event->setResult($result);
  75     }
  76
  77     /**
  78      * On read items post
  79      *
  80      * @param  PostEvent $event
  81      * @return void
  82      */
  83     public function onReadItemsPost(PostEvent $event)
  84     {
  85         $serializer = $this->getOptions()->getSerializer();
  86         $result     = $event->getResult();
  87         foreach ($result as &$value) {
  88             $value = $serializer->unserialize($value);
  89         }
  90         $event->setResult($result);
  91     }
  92
  93     /**
  94      * On write item pre
  95      *
  96      * @param  Event $event
  97      * @return void
  98      */
  99     public function onWriteItemPre(Event $event)
 100     {
 101         $serializer = $this->getOptions()->getSerializer();
 102         $params     = $event->getParams();
 103         $params['value'] = $serializer->serialize($params['value']);
 104     }
 105
 106     /**
 107      * On write items pre
 108      *
 109      * @param  Event $event
 110      * @return void
 111      */
 112     public function onWriteItemsPre(Event $event)
 113     {
 114         $serializer = $this->getOptions()->getSerializer();
 115         $params     = $event->getParams();
 116         foreach ($params['keyValuePairs'] as &$value) {
 117             $value = $serializer->serialize($value);
 118         }
 119     }
 120
 121     /**
 122      * On increment item pre
 123      *
 124      * @param  Event $event
 125      * @return mixed
 126      */
 127     public function onIncrementItemPre(Event $event)
 128     {
 129         $storage  = $event->getTarget();
 130         $params   = $event->getParams();
 131         $casToken = null;
 132         $success  = null;
 133         $oldValue = $storage->getItem($params['key'], $success, $casToken);
 134         $newValue = $oldValue + $params['value'];
 135
 136         if ($success) {
 137             $storage->checkAndSetItem($casToken, $params['key'], $oldValue + $params['value']);
 138             $result = $newValue;
 139         } else {
 140             $result = false;
 141         }
 142
 143         $event->stopPropagation(true);
 144         return $result;
 145     }
 146
 147     /**
 148      * On increment items pre
 149      *
 150      * @param  Event $event
 151      * @return mixed
 152      */
 153     public function onIncrementItemsPre(Event $event)
 154     {
 155         $storage       = $event->getTarget();
 156         $params        = $event->getParams();
 157         $keyValuePairs = $storage->getItems(array_keys($params['keyValuePairs']));
 158         foreach ($params['keyValuePairs'] as $key => & $value) {
 159             if (isset($keyValuePairs[$key])) {
 160                 $keyValuePairs[$key]+= $value;
 161             } else {
 162                 $keyValuePairs[$key] = $value;
 163             }
 164         }
 165
 166         $failedKeys = $storage->setItems($keyValuePairs);
 167         foreach ($failedKeys as $failedKey) {
 168             unset($keyValuePairs[$failedKey]);
 169         }
 170
 171         $event->stopPropagation(true);
 172         return $keyValuePairs;
 173     }
 174
 175     /**
 176      * On decrement item pre
 177      *
 178      * @param  Event $event
 179      * @return mixed
 180      */
 181     public function onDecrementItemPre(Event $event)
 182     {
 183         $storage  = $event->getTarget();
 184         $params   = $event->getParams();
 185         $success  = null;
 186         $casToken = null;
 187         $oldValue = $storage->getItem($params['key'], $success, $casToken);
 188         $newValue = $oldValue - $params['value'];
 189
 190         if ($success) {
 191             $storage->checkAndSetItem($casToken, $params['key'], $oldValue + $params['value']);
 192             $result = $newValue;
 193         } else {
 194             $result = false;
 195         }
 196
 197         $event->stopPropagation(true);
 198         return $result;
 199     }
 200
 201     /**
 202      * On decrement items pre
 203      *
 204      * @param  Event $event
 205      * @return mixed
 206      */
 207     public function onDecrementItemsPre(Event $event)
 208     {
 209         $storage       = $event->getTarget();
 210         $params        = $event->getParams();
 211         $keyValuePairs = $storage->getItems(array_keys($params['keyValuePairs']));
 212         foreach ($params['keyValuePairs'] as $key => &$value) {
 213             if (isset($keyValuePairs[$key])) {
 214                 $keyValuePairs[$key]-= $value;
 215             } else {
 216                 $keyValuePairs[$key] = -$value;
 217             }
 218         }
 219
 220         $failedKeys = $storage->setItems($keyValuePairs);
 221         foreach ($failedKeys as $failedKey) {
 222             unset($keyValuePairs[$failedKey]);
 223         }
 224
 225         $event->stopPropagation(true);
 226         return $keyValuePairs;
 227     }
 228
 229     /**
 230      * On get capabilities
 231      *
 232      * @param  PostEvent $event
 233      * @return void
 234      */
 235     public function onGetCapabilitiesPost(PostEvent $event)
 236     {
 237         $baseCapabilities = $event->getResult();
 238         $index = spl_object_hash($baseCapabilities);
 239
 240         if (!isset($this->capabilities[$index])) {
 241             $this->capabilities[$index] = new Capabilities(
 242                 $baseCapabilities->getAdapter(),
 243                 new stdClass(), // marker
 244                 array('supportedDatatypes' => array(
 245                     'NULL'     => true,
 246                     'boolean'  => true,
 247                     'integer'  => true,
 248                     'double'   => true,
 249                     'string'   => true,
 250                     'array'    => true,
 251                     'object'   => 'object',
 252                     'resource' => false,
 253                 )),
 254                 $baseCapabilities
 255             );
 256         }
 257
 258         $event->setResult($this->capabilities[$index]);
 259     }
 260 }