vendor/zendframework/zend-cache/src/Storage/Adapter/BlackHole.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-2016 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\Adapter;
  11
  12 use stdClass;
  13 use Zend\Cache\Storage\AvailableSpaceCapableInterface;
  14 use Zend\Cache\Storage\Capabilities;
  15 use Zend\Cache\Storage\ClearByNamespaceInterface;
  16 use Zend\Cache\Storage\ClearByPrefixInterface;
  17 use Zend\Cache\Storage\ClearExpiredInterface;
  18 use Zend\Cache\Storage\FlushableInterface;
  19 use Zend\Cache\Storage\IterableInterface;
  20 use Zend\Cache\Storage\OptimizableInterface;
  21 use Zend\Cache\Storage\StorageInterface;
  22 use Zend\Cache\Storage\TaggableInterface;
  23 use Zend\Cache\Storage\TotalSpaceCapableInterface;
  24
  25 class BlackHole implements
  26     StorageInterface,
  27     AvailableSpaceCapableInterface,
  28     ClearByNamespaceInterface,
  29     ClearByPrefixInterface,
  30     ClearExpiredInterface,
  31     FlushableInterface,
  32     IterableInterface,
  33     OptimizableInterface,
  34     TaggableInterface,
  35     TotalSpaceCapableInterface
  36 {
  37     /**
  38      * Capabilities of this adapter
  39      *
  40      * @var null|Capabilities
  41      */
  42     protected $capabilities = null;
  43
  44     /**
  45      * Marker to change capabilities
  46      *
  47      * @var null|object
  48      */
  49     protected $capabilityMarker;
  50
  51     /**
  52      * options
  53      *
  54      * @var null|AdapterOptions
  55      */
  56     protected $options;
  57
  58     /**
  59      * Constructor
  60      *
  61      * @param  null|array|\Traversable|AdapterOptions $options
  62      */
  63     public function __construct($options = null)
  64     {
  65         if ($options) {
  66             $this->setOptions($options);
  67         }
  68     }
  69
  70     /**
  71      * Set options.
  72      *
  73      * @param array|\Traversable|AdapterOptions $options
  74      * @return BlackHole Provides a fluent interface
  75      */
  76     public function setOptions($options)
  77     {
  78         if ($this->options !== $options) {
  79             if (! $options instanceof AdapterOptions) {
  80                 $options = new AdapterOptions($options);
  81             }
  82
  83             if ($this->options) {
  84                 $this->options->setAdapter(null);
  85             }
  86             $options->setAdapter($this);
  87             $this->options = $options;
  88         }
  89         return $this;
  90     }
  91
  92     /**
  93      * Get options
  94      *
  95      * @return AdapterOptions
  96      */
  97     public function getOptions()
  98     {
  99         if (! $this->options) {
 100             $this->setOptions(new AdapterOptions());
 101         }
 102         return $this->options;
 103     }
 104
 105     /**
 106      * Get an item.
 107      *
 108      * @param  string  $key
 109      * @param  bool $success
 110      * @param  mixed   $casToken
 111      * @return mixed Data on success, null on failure
 112      */
 113     public function getItem($key, & $success = null, & $casToken = null)
 114     {
 115         $success = false;
 116         return;
 117     }
 118
 119     /**
 120      * Get multiple items.
 121      *
 122      * @param  array $keys
 123      * @return array Associative array of keys and values
 124      */
 125     public function getItems(array $keys)
 126     {
 127         return [];
 128     }
 129
 130     /**
 131      * Test if an item exists.
 132      *
 133      * @param  string $key
 134      * @return bool
 135      */
 136     public function hasItem($key)
 137     {
 138         return false;
 139     }
 140
 141     /**
 142      * Test multiple items.
 143      *
 144      * @param  array $keys
 145      * @return array Array of found keys
 146      */
 147     public function hasItems(array $keys)
 148     {
 149         return [];
 150     }
 151
 152     /**
 153      * Get metadata of an item.
 154      *
 155      * @param  string $key
 156      * @return array|bool Metadata on success, false on failure
 157      */
 158     public function getMetadata($key)
 159     {
 160         return false;
 161     }
 162
 163     /**
 164      * Get multiple metadata
 165      *
 166      * @param  array $keys
 167      * @return array Associative array of keys and metadata
 168      */
 169     public function getMetadatas(array $keys)
 170     {
 171         return [];
 172     }
 173
 174     /**
 175      * Store an item.
 176      *
 177      * @param  string $key
 178      * @param  mixed  $value
 179      * @return bool
 180      */
 181     public function setItem($key, $value)
 182     {
 183         return false;
 184     }
 185
 186     /**
 187      * Store multiple items.
 188      *
 189      * @param  array $keyValuePairs
 190      * @return array Array of not stored keys
 191      */
 192     public function setItems(array $keyValuePairs)
 193     {
 194         return array_keys($keyValuePairs);
 195     }
 196
 197     /**
 198      * Add an item.
 199      *
 200      * @param  string $key
 201      * @param  mixed  $value
 202      * @return bool
 203      */
 204     public function addItem($key, $value)
 205     {
 206         return false;
 207     }
 208
 209     /**
 210      * Add multiple items.
 211      *
 212      * @param  array $keyValuePairs
 213      * @return array Array of not stored keys
 214      */
 215     public function addItems(array $keyValuePairs)
 216     {
 217         return array_keys($keyValuePairs);
 218     }
 219
 220     /**
 221      * Replace an existing item.
 222      *
 223      * @param  string $key
 224      * @param  mixed  $value
 225      * @return bool
 226      */
 227     public function replaceItem($key, $value)
 228     {
 229         return false;
 230     }
 231
 232     /**
 233      * Replace multiple existing items.
 234      *
 235      * @param  array $keyValuePairs
 236      * @return array Array of not stored keys
 237      */
 238     public function replaceItems(array $keyValuePairs)
 239     {
 240         return array_keys($keyValuePairs);
 241     }
 242
 243     /**
 244      * Set an item only if token matches
 245      *
 246      * It uses the token received from getItem() to check if the item has
 247      * changed before overwriting it.
 248      *
 249      * @param  mixed  $token
 250      * @param  string $key
 251      * @param  mixed  $value
 252      * @return bool
 253      */
 254     public function checkAndSetItem($token, $key, $value)
 255     {
 256         return false;
 257     }
 258
 259     /**
 260      * Reset lifetime of an item
 261      *
 262      * @param  string $key
 263      * @return bool
 264      */
 265     public function touchItem($key)
 266     {
 267         return false;
 268     }
 269
 270     /**
 271      * Reset lifetime of multiple items.
 272      *
 273      * @param  array $keys
 274      * @return array Array of not updated keys
 275      */
 276     public function touchItems(array $keys)
 277     {
 278         return $keys;
 279     }
 280
 281     /**
 282      * Remove an item.
 283      *
 284      * @param  string $key
 285      * @return bool
 286      */
 287     public function removeItem($key)
 288     {
 289         return false;
 290     }
 291
 292     /**
 293      * Remove multiple items.
 294      *
 295      * @param  array $keys
 296      * @return array Array of not removed keys
 297      */
 298     public function removeItems(array $keys)
 299     {
 300         return $keys;
 301     }
 302
 303     /**
 304      * Increment an item.
 305      *
 306      * @param  string $key
 307      * @param  int    $value
 308      * @return int|bool The new value on success, false on failure
 309      */
 310     public function incrementItem($key, $value)
 311     {
 312         return false;
 313     }
 314
 315     /**
 316      * Increment multiple items.
 317      *
 318      * @param  array $keyValuePairs
 319      * @return array Associative array of keys and new values
 320      */
 321     public function incrementItems(array $keyValuePairs)
 322     {
 323         return [];
 324     }
 325
 326     /**
 327      * Decrement an item.
 328      *
 329      * @param  string $key
 330      * @param  int    $value
 331      * @return int|bool The new value on success, false on failure
 332      */
 333     public function decrementItem($key, $value)
 334     {
 335         return false;
 336     }
 337
 338     /**
 339      * Decrement multiple items.
 340      *
 341      * @param  array $keyValuePairs
 342      * @return array Associative array of keys and new values
 343      */
 344     public function decrementItems(array $keyValuePairs)
 345     {
 346         return [];
 347     }
 348
 349     /**
 350      * Capabilities of this storage
 351      *
 352      * @return Capabilities
 353      */
 354     public function getCapabilities()
 355     {
 356         if ($this->capabilities === null) {
 357             // use default capabilities only
 358             $this->capabilityMarker = new stdClass();
 359             $this->capabilities     = new Capabilities($this, $this->capabilityMarker);
 360         }
 361         return $this->capabilities;
 362     }
 363
 364     /* AvailableSpaceCapableInterface */
 365
 366     /**
 367      * Get available space in bytes
 368      *
 369      * @return int|float
 370      */
 371     public function getAvailableSpace()
 372     {
 373         return 0;
 374     }
 375
 376     /* ClearByNamespaceInterface */
 377
 378     /**
 379      * Remove items of given namespace
 380      *
 381      * @param string $namespace
 382      * @return bool
 383      */
 384     public function clearByNamespace($namespace)
 385     {
 386         return false;
 387     }
 388
 389     /* ClearByPrefixInterface */
 390
 391     /**
 392      * Remove items matching given prefix
 393      *
 394      * @param string $prefix
 395      * @return bool
 396      */
 397     public function clearByPrefix($prefix)
 398     {
 399         return false;
 400     }
 401
 402     /* ClearExpiredInterface */
 403
 404     /**
 405      * Remove expired items
 406      *
 407      * @return bool
 408      */
 409     public function clearExpired()
 410     {
 411         return false;
 412     }
 413
 414     /* FlushableInterface */
 415
 416     /**
 417      * Flush the whole storage
 418      *
 419      * @return bool
 420      */
 421     public function flush()
 422     {
 423         return false;
 424     }
 425
 426     /* IterableInterface */
 427
 428     /**
 429      * Get the storage iterator
 430      *
 431      * @return KeyListIterator
 432      */
 433     public function getIterator()
 434     {
 435         return new KeyListIterator($this, []);
 436     }
 437
 438     /* OptimizableInterface */
 439
 440     /**
 441      * Optimize the storage
 442      *
 443      * @return bool
 444      */
 445     public function optimize()
 446     {
 447         return false;
 448     }
 449
 450     /* TaggableInterface */
 451
 452     /**
 453      * Set tags to an item by given key.
 454      * An empty array will remove all tags.
 455      *
 456      * @param string   $key
 457      * @param string[] $tags
 458      * @return bool
 459      */
 460     public function setTags($key, array $tags)
 461     {
 462         return false;
 463     }
 464
 465     /**
 466      * Get tags of an item by given key
 467      *
 468      * @param string $key
 469      * @return string[]|FALSE
 470      */
 471     public function getTags($key)
 472     {
 473         return false;
 474     }
 475
 476     /**
 477      * Remove items matching given tags.
 478      *
 479      * If $disjunction only one of the given tags must match
 480      * else all given tags must match.
 481      *
 482      * @param string[] $tags
 483      * @param  bool  $disjunction
 484      * @return bool
 485      */
 486     public function clearByTags(array $tags, $disjunction = false)
 487     {
 488         return false;
 489     }
 490
 491     /* TotalSpaceCapableInterface */
 492
 493     /**
 494      * Get total space in bytes
 495      *
 496      * @return int|float
 497      */
 498     public function getTotalSpace()
 499     {
 500         return 0;
 501     }
 502 }