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

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