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

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\CoreCacheHandler;
  19. use Pimcore\Event\CoreCacheEvents;
  20. use Symfony\Component\EventDispatcher\GenericEvent;
  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 CoreCacheHandler
  29.      */
  30.     protected static $handler;
  32.     /**
  33.      * Get the cache handler implementation
  34.      *
  35.      * @internal
  36.      *
  37.      * @return CoreCacheHandler
  38.      */
  39.     public static function getHandler()
  40.     {
  41.         if (null === static::$handler) {
  42.             static::$handler = \Pimcore::getContainer()->get(CoreCacheHandler::class);
  43.         }
  45.         return static::$handler;
  46.     }
  48.     /**
  49.      * Initialize the cache. This acts mainly as integration point with legacy caches.
  50.      *
  51.      * @internal
  52.      */
  53.     public static function init()
  54.     {
  55.         if (\Pimcore::hasKernel()) {
  56.             \Pimcore::getContainer()
  57.                 ->get('event_dispatcher')
  58.                 ->dispatch(new GenericEvent(), CoreCacheEvents::INIT);
  60.             if (isset($_REQUEST['pimcore_nocache']) && \Pimcore::inDebugMode()) {
  61.                 self::getHandler()->setPool(\Pimcore::getContainer()->get('pimcore.cache.adapter.null_tag_aware'));
  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(array $tags = []): bool
  137.     {
  138.         return static::getHandler()->clearTags($tags);
  139.     }
  141.     /**
  142.      * Adds a tag to the shutdown queue
  143.      *
  144.      * @param string $tag
  145.      */
  146.     public static function addClearTagOnShutdown($tag)
  147.     {
  148.         static::getHandler()->addTagClearedOnShutdown($tag);
  149.     }
  151.     /**
  152.      * Add tag to the list ignored on save. Items with this tag won't be saved to cache.
  153.      *
  154.      * @param string $tag
  155.      */
  156.     public static function addIgnoredTagOnSave($tag)
  157.     {
  158.         static::getHandler()->addTagIgnoredOnSave($tag);
  159.     }
  161.     /**
  162.      * Remove tag from the list ignored on save
  163.      *
  164.      * @param string $tag
  165.      */
  166.     public static function removeIgnoredTagOnSave($tag)
  167.     {
  168.         static::getHandler()->removeTagIgnoredOnSave($tag);
  169.     }
  171.     /**
  172.      * Add tag to the list ignored on clear. Tags in this list won't be cleared via clearTags()
  173.      *
  174.      * @param string $tag
  175.      */
  176.     public static function addIgnoredTagOnClear($tag)
  177.     {
  178.         static::getHandler()->addTagIgnoredOnClear($tag);
  179.     }
  181.     /**
  182.      * Remove tag from the list ignored on clear
  183.      *
  184.      * @param string $tag
  185.      */
  186.     public static function removeIgnoredTagOnClear($tag)
  187.     {
  188.         static::getHandler()->removeTagIgnoredOnClear($tag);
  189.     }
  191.     /**
  192.      * Write and clean up cache
  193.      *
  194.      * @internal
  195.      *
  196.      * @param bool $forceWrite
  197.      */
  198.     public static function shutdown($forceWrite = false)
  199.     {
  200.         static::getHandler()->shutdown($forceWrite);
  201.     }
  203.     /**
  204.      * Disables the complete pimcore cache
  205.      */
  206.     public static function disable()
  207.     {
  208.         static::getHandler()->disable();
  209.     }
  211.     /**
  212.      * Enables the pimcore cache
  213.      */
  214.     public static function enable()
  215.     {
  216.         static::getHandler()->enable();
  217.     }
  219.     /**
  220.      * @return bool
  221.      */
  222.     public static function isEnabled()
  223.     {
  224.         return static::getHandler()->isEnabled();
  225.     }
  227.     /**
  228.      * @param bool $forceImmediateWrite
  229.      */
  230.     public static function setForceImmediateWrite($forceImmediateWrite)
  231.     {
  232.         static::getHandler()->setForceImmediateWrite($forceImmediateWrite);
  233.     }
  235.     /**
  236.      * @return bool
  237.      */
  238.     public static function getForceImmediateWrite()
  239.     {
  240.         return static::getHandler()->getForceImmediateWrite();
  241.     }
  242. }