vendor/pimcore/pimcore/lib/Cache.php line 59

Open in your IDE?
  1. <?php
  3. /**
  4.  * Pimcore
  5.  *
  6.  * This source file is available under two different licenses:
  7.  * - GNU General Public License version 3 (GPLv3)
  8.  * - Pimcore Commercial License (PCL)
  9.  * Full copyright and license information is available in
  10.  * LICENSE.md which is distributed with this source code.
  11.  *
  12.  *  @copyright  Copyright (c) Pimcore GmbH (http://www.pimcore.org)
  13.  *  @license    http://www.pimcore.org/license     GPLv3 and PCL
  14.  */
  16. namespace Pimcore;
  18. use Pimcore\Cache\Core\CoreHandlerInterface;
  19. use Pimcore\Event\CoreCacheEvents;
  20. use Symfony\Component\EventDispatcher\Event;
  22. /**
  23.  * This acts as facade for the actual cache implementation and exists primarily for BC reasons.
  24.  */
  25. class Cache
  26. {
  27.     /**
  28.      * @var CoreHandlerInterface
  29.      */
  30.     protected static $handler;
  32.     public static function getInstance()
  33.     {
  34.         throw new \RuntimeException('getInstance() is not supported anymore');
  35.     }
  37.     /**
  38.      * Get the cache handler implementation
  39.      *
  40.      * @return CoreHandlerInterface
  41.      */
  42.     public static function getHandler()
  43.     {
  44.         if (null === static::$handler) {
  45.             static::$handler = \Pimcore::getContainer()->get('pimcore.cache.core.handler');
  46.         }
  48.         return static::$handler;
  49.     }
  51.     /**
  52.      * Initialize the cache. This acts mainly as integration point with legacy caches.
  53.      */
  54.     public static function init()
  55.     {
  56.         if (\Pimcore::hasKernel()) {
  57.             \Pimcore::getContainer()
  58.                 ->get('event_dispatcher')
  59.                 ->dispatch(CoreCacheEvents::INIT, new Event());
  61.             if (isset($_REQUEST['pimcore_nocache']) && \Pimcore::inDebugMode()) {
  62.                 self::getHandler()->disable();
  63.             }
  64.         }
  65.     }
  67.     /**
  68.      * Returns the content of the requested cache entry
  69.      *
  70.      * @param string $key
  71.      *
  72.      * @return mixed
  73.      */
  74.     public static function load($key)
  75.     {
  76.         return static::getHandler()->load($key);
  77.     }
  79.     /**
  80.      * Save an item to the cache (deferred to shutdown if force is false and forceImmediateWrite is not set)
  81.      *
  82.      * @param mixed $data
  83.      * @param string $key
  84.      * @param array $tags
  85.      * @param int|\DateInterval|null $lifetime
  86.      * @param int $priority
  87.      * @param bool $force
  88.      *
  89.      * @return bool
  90.      */
  91.     public static function save($data, $key, $tags = [], $lifetime = null, $priority = 0, $force = false)
  92.     {
  93.         return static::getHandler()->save($key, $data, $tags, $lifetime, $priority, $force);
  94.     }
  96.     /**
  97.      * Remove an item from the cache
  98.      *
  99.      * @param string $key
  100.      *
  101.      * @return bool
  102.      */
  103.     public static function remove($key)
  104.     {
  105.         return static::getHandler()->remove($key);
  106.     }
  108.     /**
  109.      * Empty the cache
  110.      *
  111.      * @return bool
  112.      */
  113.     public static function clearAll()
  114.     {
  115.         return static::getHandler()->clearAll();
  116.     }
  118.     /**
  119.      * Removes entries from the cache matching the given tag
  120.      *
  121.      * @param string $tag
  122.      *
  123.      * @return bool
  124.      */
  125.     public static function clearTag($tag)
  126.     {
  127.         return static::getHandler()->clearTag($tag);
  128.     }
  130.     /**
  131.      * Removes entries from the cache matching the given tags
  132.      *
  133.      * @param array $tags
  134.      *
  135.      * @return bool
  136.      */
  137.     public static function clearTags($tags = [])
  138.     {
  139.         if (!empty($tags) && !is_array($tags)) {
  140.             $tags = [$tags];
  141.         }
  143.         return static::getHandler()->clearTags($tags);
  144.     }
  146.     /**
  147.      * Adds a tag to the shutdown queue
  148.      *
  149.      * @param string $tag
  150.      */
  151.     public static function addClearTagOnShutdown($tag)
  152.     {
  153.         static::getHandler()->addTagClearedOnShutdown($tag);
  154.     }
  156.     /**
  157.      * Add tag to the list ignored on save. Items with this tag won't be saved to cache.
  158.      *
  159.      * @param string $tag
  160.      */
  161.     public static function addIgnoredTagOnSave($tag)
  162.     {
  163.         static::getHandler()->addTagIgnoredOnSave($tag);
  164.     }
  166.     /**
  167.      * Remove tag from the list ignored on save
  168.      *
  169.      * @param string $tag
  170.      */
  171.     public static function removeIgnoredTagOnSave($tag)
  172.     {
  173.         static::getHandler()->removeTagIgnoredOnSave($tag);
  174.     }
  176.     /**
  177.      * Add tag to the list ignored on clear. Tags in this list won't be cleared via clearTags()
  178.      *
  179.      * @param string $tag
  180.      */
  181.     public static function addIgnoredTagOnClear($tag)
  182.     {
  183.         static::getHandler()->addTagIgnoredOnClear($tag);
  184.     }
  186.     /**
  187.      * Remove tag from the list ignored on clear
  188.      *
  189.      * @param string $tag
  190.      */
  191.     public static function removeIgnoredTagOnClear($tag)
  192.     {
  193.         static::getHandler()->removeTagIgnoredOnClear($tag);
  194.     }
  196.     /**
  197.      * Write and clean up cache
  198.      *
  199.      * @param bool $forceWrite
  200.      */
  201.     public static function shutdown($forceWrite = false)
  202.     {
  203.         static::getHandler()->shutdown($forceWrite);
  204.     }
  206.     /**
  207.      * Disables the complete pimcore cache
  208.      */
  209.     public static function disable()
  210.     {
  211.         static::getHandler()->disable();
  212.     }
  214.     /**
  215.      * Enables the pimcore cache
  216.      */
  217.     public static function enable()
  218.     {
  219.         static::getHandler()->enable();
  220.     }
  222.     /**
  223.      * @return bool
  224.      */
  225.     public static function isEnabled()
  226.     {
  227.         return static::getHandler()->isEnabled();
  228.     }
  230.     /**
  231.      * @param bool $forceImmediateWrite
  232.      */
  233.     public static function setForceImmediateWrite($forceImmediateWrite)
  234.     {
  235.         static::getHandler()->setForceImmediateWrite($forceImmediateWrite);
  236.     }
  238.     /**
  239.      * @return bool
  240.      */
  241.     public static function getForceImmediateWrite()
  242.     {
  243.         return static::getHandler()->getForceImmediateWrite();
  244.     }
  245. }