interface/modules/zend_modules/library/Zend/Session/Storage/AbstractSessionArrayStorage.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\Session\Storage;
  11
  12 use ArrayIterator;
  13 use IteratorAggregate;
  14 use Zend\Session\Exception;
  15
  16 /**
  17  * Session storage in $_SESSION
  18  *
  19  * Replaces the $_SESSION superglobal with an ArrayObject that allows for
  20  * property access, metadata storage, locking, and immutability.
  21  */
  22 abstract class AbstractSessionArrayStorage implements
  23     IteratorAggregate,
  24     StorageInterface,
  25     StorageInitializationInterface
  26 {
  27     /**
  28      * Constructor
  29      *
  30      * @param array|null $input
  31      */
  32     public function __construct($input = null)
  33     {
  34         // this is here for B.C.
  35         $this->init($input);
  36     }
  37
  38
  39     /**
  40      * Initialize Storage
  41      *
  42      * @param  array $input
  43      * @return void
  44      */
  45     public function init($input = null)
  46     {
  47         if ((null === $input) && isset($_SESSION)) {
  48             $input = $_SESSION;
  49             if (is_object($input) && !$_SESSION instanceof \ArrayObject) {
  50                 $input = (array) $input;
  51             }
  52         } elseif (null === $input) {
  53             $input = array();
  54         }
  55         $_SESSION = $input;
  56         $this->setRequestAccessTime(microtime(true));
  57     }
  58
  59     /**
  60      * Get Offset
  61      *
  62      * @param  mixed $key
  63      * @return mixed
  64      */
  65     public function __get($key)
  66     {
  67         return $this->offsetGet($key);
  68     }
  69
  70     /**
  71      * Set Offset
  72      *
  73      * @param  mixed $key
  74      * @param  mixed $value
  75      * @return void
  76      */
  77     public function __set($key, $value)
  78     {
  79         return $this->offsetSet($key, $value);
  80     }
  81
  82     /**
  83      * Isset Offset
  84      *
  85      * @param  mixed   $key
  86      * @return bool
  87      */
  88     public function __isset($key)
  89     {
  90         return $this->offsetExists($key);
  91     }
  92
  93     /**
  94      * Unset Offset
  95      *
  96      * @param  mixed $key
  97      * @return void
  98      */
  99     public function __unset($key)
 100     {
 101         return $this->offsetUnset($key);
 102     }
 103
 104     /**
 105      * Destructor
 106      *
 107      * @return void
 108      */
 109     public function __destruct()
 110     {
 111         return ;
 112     }
 113
 114     /**
 115      * Offset Exists
 116      *
 117      * @param  mixed   $key
 118      * @return bool
 119      */
 120     public function offsetExists($key)
 121     {
 122         return isset($_SESSION[$key]);
 123     }
 124
 125     /**
 126      * Offset Get
 127      *
 128      * @param  mixed $key
 129      * @return mixed
 130      */
 131     public function offsetGet($key)
 132     {
 133         if (isset($_SESSION[$key])) {
 134             return $_SESSION[$key];
 135         }
 136
 137         return null;
 138     }
 139
 140     /**
 141      * Offset Set
 142      *
 143      * @param  mixed $key
 144      * @param  mixed $value
 145      * @return void
 146      */
 147     public function offsetSet($key, $value)
 148     {
 149         $_SESSION[$key] = $value;
 150     }
 151
 152     /**
 153      * Offset Unset
 154      *
 155      * @param  mixed $key
 156      * @return void
 157      */
 158     public function offsetUnset($key)
 159     {
 160         unset($_SESSION[$key]);
 161     }
 162
 163     /**
 164      * Count
 165      *
 166      * @return int
 167      */
 168     public function count()
 169     {
 170         return count($_SESSION);
 171     }
 172
 173     /**
 174      * Seralize
 175      *
 176      * @return string
 177      */
 178     public function serialize()
 179     {
 180         return serialize($_SESSION);
 181     }
 182
 183     /**
 184      * Unserialize
 185      *
 186      * @param  string $session
 187      * @return mixed
 188      */
 189     public function unserialize($session)
 190     {
 191         return unserialize($session);
 192     }
 193
 194     /**
 195      * Get Iterator
 196      *
 197      * @return ArrayIterator
 198      */
 199     public function getIterator()
 200     {
 201         return new ArrayIterator($_SESSION);
 202     }
 203
 204     /**
 205      * Load session object from an existing array
 206      *
 207      * Ensures $_SESSION is set to an instance of the object when complete.
 208      *
 209      * @param  array          $array
 210      * @return SessionStorage
 211      */
 212     public function fromArray(array $array)
 213     {
 214         $ts = $this->getRequestAccessTime();
 215         $_SESSION = $array;
 216         $this->setRequestAccessTime($ts);
 217
 218         return $this;
 219     }
 220
 221     /**
 222      * Mark object as isImmutable
 223      *
 224      * @return SessionStorage
 225      */
 226     public function markImmutable()
 227     {
 228         $_SESSION['_IMMUTABLE'] = true;
 229
 230         return $this;
 231     }
 232
 233     /**
 234      * Determine if this object is isImmutable
 235      *
 236      * @return bool
 237      */
 238     public function isImmutable()
 239     {
 240         return (isset($_SESSION['_IMMUTABLE']) && $_SESSION['_IMMUTABLE']);
 241     }
 242
 243     /**
 244      * Lock this storage instance, or a key within it
 245      *
 246      * @param  null|int|string $key
 247      * @return ArrayStorage
 248      */
 249     public function lock($key = null)
 250     {
 251         if (null === $key) {
 252             $this->setMetadata('_READONLY', true);
 253
 254             return $this;
 255         }
 256         if (isset($_SESSION[$key])) {
 257             $this->setMetadata('_LOCKS', array($key => true));
 258         }
 259
 260         return $this;
 261     }
 262
 263     /**
 264      * Is the object or key marked as locked?
 265      *
 266      * @param  null|int|string $key
 267      * @return bool
 268      */
 269     public function isLocked($key = null)
 270     {
 271         if ($this->isImmutable()) {
 272             // isImmutable trumps all
 273             return true;
 274         }
 275
 276         if (null === $key) {
 277             // testing for global lock
 278             return $this->getMetadata('_READONLY');
 279         }
 280
 281         $locks    = $this->getMetadata('_LOCKS');
 282         $readOnly = $this->getMetadata('_READONLY');
 283
 284         if ($readOnly && !$locks) {
 285             // global lock in play; all keys are locked
 286             return true;
 287         }
 288         if ($readOnly && $locks) {
 289             return array_key_exists($key, $locks);
 290         }
 291
 292         // test for individual locks
 293         if (!$locks) {
 294             return false;
 295         }
 296
 297         return array_key_exists($key, $locks);
 298     }
 299
 300     /**
 301      * Unlock an object or key marked as locked
 302      *
 303      * @param  null|int|string $key
 304      * @return ArrayStorage
 305      */
 306     public function unlock($key = null)
 307     {
 308         if (null === $key) {
 309             // Unlock everything
 310             $this->setMetadata('_READONLY', false);
 311             $this->setMetadata('_LOCKS', false);
 312
 313             return $this;
 314         }
 315
 316         $locks = $this->getMetadata('_LOCKS');
 317         if (!$locks) {
 318             if (!$this->getMetadata('_READONLY')) {
 319                 return $this;
 320             }
 321             $array = $this->toArray();
 322             $keys  = array_keys($array);
 323             $locks = array_flip($keys);
 324             unset($array, $keys);
 325         }
 326
 327         if (array_key_exists($key, $locks)) {
 328             unset($locks[$key]);
 329             $this->setMetadata('_LOCKS', $locks, true);
 330         }
 331
 332         return $this;
 333     }
 334
 335     /**
 336      * Set storage metadata
 337      *
 338      * Metadata is used to store information about the data being stored in the
 339      * object. Some example use cases include:
 340      * - Setting expiry data
 341      * - Maintaining access counts
 342      * - localizing session storage
 343      * - etc.
 344      *
 345      * @param  string                     $key
 346      * @param  mixed                      $value
 347      * @param  bool                       $overwriteArray Whether to overwrite or merge array values; by default, merges
 348      * @return ArrayStorage
 349      * @throws Exception\RuntimeException
 350      */
 351     public function setMetadata($key, $value, $overwriteArray = false)
 352     {
 353         if ($this->isImmutable()) {
 354             throw new Exception\RuntimeException(sprintf(
 355                 'Cannot set key "%s" as storage is marked isImmutable', $key
 356             ));
 357         }
 358
 359         if (!isset($_SESSION['__ZF'])) {
 360             $_SESSION['__ZF'] = array();
 361         }
 362         if (isset($_SESSION['__ZF'][$key]) && is_array($value)) {
 363             if ($overwriteArray) {
 364                 $_SESSION['__ZF'][$key] = $value;
 365             } else {
 366                 $_SESSION['__ZF'][$key] = array_replace_recursive($_SESSION['__ZF'][$key], $value);
 367             }
 368         } else {
 369             if ((null === $value) && isset($_SESSION['__ZF'][$key])) {
 370                 $array = $_SESSION['__ZF'];
 371                 unset($array[$key]);
 372                 $_SESSION['__ZF'] = $array;
 373                 unset($array);
 374             } elseif (null !== $value) {
 375                 $_SESSION['__ZF'][$key] = $value;
 376             }
 377         }
 378
 379         return $this;
 380     }
 381
 382     /**
 383      * Retrieve metadata for the storage object or a specific metadata key
 384      *
 385      * Returns false if no metadata stored, or no metadata exists for the given
 386      * key.
 387      *
 388      * @param  null|int|string $key
 389      * @return mixed
 390      */
 391     public function getMetadata($key = null)
 392     {
 393         if (!isset($_SESSION['__ZF'])) {
 394             return false;
 395         }
 396
 397         if (null === $key) {
 398             return $_SESSION['__ZF'];
 399         }
 400
 401         if (!array_key_exists($key, $_SESSION['__ZF'])) {
 402             return false;
 403         }
 404
 405         return $_SESSION['__ZF'][$key];
 406     }
 407
 408     /**
 409      * Clear the storage object or a subkey of the object
 410      *
 411      * @param  null|int|string            $key
 412      * @return ArrayStorage
 413      * @throws Exception\RuntimeException
 414      */
 415     public function clear($key = null)
 416     {
 417         if ($this->isImmutable()) {
 418             throw new Exception\RuntimeException('Cannot clear storage as it is marked immutable');
 419         }
 420         if (null === $key) {
 421             $this->fromArray(array());
 422
 423             return $this;
 424         }
 425
 426         if (!isset($_SESSION[$key])) {
 427             return $this;
 428         }
 429
 430         // Clear key data
 431         unset($_SESSION[$key]);
 432
 433         // Clear key metadata
 434         $this->setMetadata($key, null)
 435              ->unlock($key);
 436
 437         return $this;
 438     }
 439
 440     /**
 441      * Retrieve the request access time
 442      *
 443      * @return float
 444      */
 445     public function getRequestAccessTime()
 446     {
 447         return $this->getMetadata('_REQUEST_ACCESS_TIME');
 448     }
 449
 450     /**
 451      * Set the request access time
 452      *
 453      * @param  float        $time
 454      * @return ArrayStorage
 455      */
 456     protected function setRequestAccessTime($time)
 457     {
 458         $this->setMetadata('_REQUEST_ACCESS_TIME', $time);
 459
 460         return $this;
 461     }
 462
 463     /**
 464      * Cast the object to an array
 465      *
 466      * @param  bool $metaData Whether to include metadata
 467      * @return array
 468      */
 469     public function toArray($metaData = false)
 470     {
 471         if (isset($_SESSION)) {
 472             $values = $_SESSION;
 473         } else {
 474             $values = array();
 475         }
 476
 477         if ($metaData) {
 478             return $values;
 479         }
 480
 481         if (isset($values['__ZF'])) {
 482             unset($values['__ZF']);
 483         }
 484
 485         return $values;
 486     }
 487 }