vendor/doctrine/cache/lib/Doctrine/Common/Cache/CacheProvider.php line 133

Open in your IDE?
  1. <?php
  2. /*
  3.  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  4.  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  5.  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  6.  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  7.  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  8.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  9.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  10.  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  11.  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  12.  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  13.  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  14.  *
  15.  * This software consists of voluntary contributions made by many individuals
  16.  * and is licensed under the MIT license. For more information, see
  17.  * <http://www.doctrine-project.org>.
  18.  */
  20. namespace Doctrine\Common\Cache;
  22. /**
  23.  * Base class for cache provider implementations.
  24.  *
  25.  * @since  2.2
  26.  * @author Benjamin Eberlei <kontakt@beberlei.de>
  27.  * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
  28.  * @author Jonathan Wage <jonwage@gmail.com>
  29.  * @author Roman Borschel <roman@code-factory.org>
  30.  * @author Fabio B. Silva <fabio.bat.silva@gmail.com>
  31.  * @author Benoit Burnichon <bburnichon@gmail.com>
  32.  */
  33. abstract class CacheProvider implements Cache, FlushableCache, ClearableCache, MultiOperationCache
  34. {
  35.     const DOCTRINE_NAMESPACE_CACHEKEY = 'DoctrineNamespaceCacheKey[%s]';
  37.     /**
  38.      * The namespace to prefix all cache ids with.
  39.      *
  40.      * @var string
  41.      */
  42.     private $namespace = '';
  44.     /**
  45.      * The namespace version.
  46.      *
  47.      * @var integer|null
  48.      */
  49.     private $namespaceVersion;
  51.     /**
  52.      * Sets the namespace to prefix all cache ids with.
  53.      *
  54.      * @param string $namespace
  55.      *
  56.      * @return void
  57.      */
  58.     public function setNamespace($namespace)
  59.     {
  60.         $this->namespace        = (string) $namespace;
  61.         $this->namespaceVersion = null;
  62.     }
  64.     /**
  65.      * Retrieves the namespace that prefixes all cache ids.
  66.      *
  67.      * @return string
  68.      */
  69.     public function getNamespace()
  70.     {
  71.         return $this->namespace;
  72.     }
  74.     /**
  75.      * {@inheritdoc}
  76.      */
  77.     public function fetch($id)
  78.     {
  79.         return $this->doFetch($this->getNamespacedId($id));
  80.     }
  82.     /**
  83.      * {@inheritdoc}
  84.      */
  85.     public function fetchMultiple(array $keys)
  86.     {
  87.         if (empty($keys)) {
  88.             return [];
  89.         }
  91.         // note: the array_combine() is in place to keep an association between our $keys and the $namespacedKeys
  92.         $namespacedKeys = array_combine($keys, array_map([$this, 'getNamespacedId'], $keys));
  93.         $items          = $this->doFetchMultiple($namespacedKeys);
  94.         $foundItems     = [];
  96.         // no internal array function supports this sort of mapping: needs to be iterative
  97.         // this filters and combines keys in one pass
  98.         foreach ($namespacedKeys as $requestedKey => $namespacedKey) {
  99.             if (isset($items[$namespacedKey]) || array_key_exists($namespacedKey, $items)) {
  100.                 $foundItems[$requestedKey] = $items[$namespacedKey];
  101.             }
  102.         }
  104.         return $foundItems;
  105.     }
  107.     /**
  108.      * {@inheritdoc}
  109.      */
  110.     public function saveMultiple(array $keysAndValues, $lifetime = 0)
  111.     {
  112.         $namespacedKeysAndValues = [];
  113.         foreach ($keysAndValues as $key => $value) {
  114.             $namespacedKeysAndValues[$this->getNamespacedId($key)] = $value;
  115.         }
  117.         return $this->doSaveMultiple($namespacedKeysAndValues, $lifetime);
  118.     }
  120.     /**
  121.      * {@inheritdoc}
  122.      */
  123.     public function contains($id)
  124.     {
  125.         return $this->doContains($this->getNamespacedId($id));
  126.     }
  128.     /**
  129.      * {@inheritdoc}
  130.      */
  131.     public function save($id, $data, $lifeTime = 0)
  132.     {
  133.         return $this->doSave($this->getNamespacedId($id), $data, $lifeTime);
  134.     }
  136.     /**
  137.      * {@inheritdoc}
  138.      */
  139.     public function deleteMultiple(array $keys)
  140.     {
  141.         return $this->doDeleteMultiple(array_map(array($this, 'getNamespacedId'), $keys));
  142.     }
  144.     /**
  145.      * {@inheritdoc}
  146.      */
  147.     public function delete($id)
  148.     {
  149.         return $this->doDelete($this->getNamespacedId($id));
  150.     }
  152.     /**
  153.      * {@inheritdoc}
  154.      */
  155.     public function getStats()
  156.     {
  157.         return $this->doGetStats();
  158.     }
  160.     /**
  161.      * {@inheritDoc}
  162.      */
  163.     public function flushAll()
  164.     {
  165.         return $this->doFlush();
  166.     }
  168.     /**
  169.      * {@inheritDoc}
  170.      */
  171.     public function deleteAll()
  172.     {
  173.         $namespaceCacheKey = $this->getNamespaceCacheKey();
  174.         $namespaceVersion  = $this->getNamespaceVersion() + 1;
  176.         if ($this->doSave($namespaceCacheKey, $namespaceVersion)) {
  177.             $this->namespaceVersion = $namespaceVersion;
  179.             return true;
  180.         }
  182.         return false;
  183.     }
  185.     /**
  186.      * Prefixes the passed id with the configured namespace value.
  187.      *
  188.      * @param string $id The id to namespace.
  189.      *
  190.      * @return string The namespaced id.
  191.      */
  192.     private function getNamespacedId(string $id) : string
  193.     {
  194.         $namespaceVersion  = $this->getNamespaceVersion();
  196.         return sprintf('%s[%s][%s]', $this->namespace, $id, $namespaceVersion);
  197.     }
  199.     /**
  200.      * Returns the namespace cache key.
  201.      *
  202.      * @return string
  203.      */
  204.     private function getNamespaceCacheKey() : string
  205.     {
  206.         return sprintf(self::DOCTRINE_NAMESPACE_CACHEKEY, $this->namespace);
  207.     }
  209.     /**
  210.      * Returns the namespace version.
  211.      *
  212.      * @return integer
  213.      */
  214.     private function getNamespaceVersion() : int
  215.     {
  216.         if (null !== $this->namespaceVersion) {
  217.             return $this->namespaceVersion;
  218.         }
  220.         $namespaceCacheKey      = $this->getNamespaceCacheKey();
  221.         $this->namespaceVersion = (int) $this->doFetch($namespaceCacheKey) ?: 1;
  223.         return $this->namespaceVersion;
  224.     }
  226.     /**
  227.      * Default implementation of doFetchMultiple. Each driver that supports multi-get should owerwrite it.
  228.      *
  229.      * @param array $keys Array of keys to retrieve from cache
  230.      * @return array Array of values retrieved for the given keys.
  231.      */
  232.     protected function doFetchMultiple(array $keys)
  233.     {
  234.         $returnValues = [];
  236.         foreach ($keys as $key) {
  237.             if (false !== ($item = $this->doFetch($key)) || $this->doContains($key)) {
  238.                 $returnValues[$key] = $item;
  239.             }
  240.         }
  242.         return $returnValues;
  243.     }
  245.     /**
  246.      * Fetches an entry from the cache.
  247.      *
  248.      * @param string $id The id of the cache entry to fetch.
  249.      *
  250.      * @return mixed|false The cached data or FALSE, if no cache entry exists for the given id.
  251.      */
  252.     abstract protected function doFetch($id);
  254.     /**
  255.      * Tests if an entry exists in the cache.
  256.      *
  257.      * @param string $id The cache id of the entry to check for.
  258.      *
  259.      * @return bool TRUE if a cache entry exists for the given cache id, FALSE otherwise.
  260.      */
  261.     abstract protected function doContains($id);
  263.     /**
  264.      * Default implementation of doSaveMultiple. Each driver that supports multi-put should override it.
  265.      *
  266.      * @param array $keysAndValues  Array of keys and values to save in cache
  267.      * @param int   $lifetime       The lifetime. If != 0, sets a specific lifetime for these
  268.      *                              cache entries (0 => infinite lifeTime).
  269.      *
  270.      * @return bool TRUE if the operation was successful, FALSE if it wasn't.
  271.      */
  272.     protected function doSaveMultiple(array $keysAndValues, $lifetime = 0)
  273.     {
  274.         $success = true;
  276.         foreach ($keysAndValues as $key => $value) {
  277.             if (!$this->doSave($key, $value, $lifetime)) {
  278.                 $success = false;
  279.             }
  280.         }
  282.         return $success;
  283.     }
  285.     /**
  286.      * Puts data into the cache.
  287.      *
  288.      * @param string $id       The cache id.
  289.      * @param string $data     The cache entry/data.
  290.      * @param int    $lifeTime The lifetime. If != 0, sets a specific lifetime for this
  291.      *                           cache entry (0 => infinite lifeTime).
  292.      *
  293.      * @return bool TRUE if the entry was successfully stored in the cache, FALSE otherwise.
  294.      */
  295.     abstract protected function doSave($id, $data, $lifeTime = 0);
  297.     /**
  298.      * Default implementation of doDeleteMultiple. Each driver that supports multi-delete should override it.
  299.      *
  300.      * @param array $keys Array of keys to delete from cache
  301.      *
  302.      * @return bool TRUE if the operation was successful, FALSE if it wasn't
  303.      */
  304.     protected function doDeleteMultiple(array $keys)
  305.     {
  306.         $success = true;
  308.         foreach ($keys as $key) {
  309.             if (! $this->doDelete($key)) {
  310.                 $success = false;
  311.             }
  312.         }
  314.         return $success;
  315.     }
  317.     /**
  318.      * Deletes a cache entry.
  319.      *
  320.      * @param string $id The cache id.
  321.      *
  322.      * @return bool TRUE if the cache entry was successfully deleted, FALSE otherwise.
  323.      */
  324.     abstract protected function doDelete($id);
  326.     /**
  327.      * Flushes all cache entries.
  328.      *
  329.      * @return bool TRUE if the cache entries were successfully flushed, FALSE otherwise.
  330.      */
  331.     abstract protected function doFlush();
  333.     /**
  334.      * Retrieves cached information from the data store.
  335.      *
  336.      * @since 2.2
  337.      *
  338.      * @return array|null An associative array with server's statistics if available, NULL otherwise.
  339.      */
  340.     abstract protected function doGetStats();
  341. }