vendor/symfony/cache/Traits/AbstractAdapterTrait.php line 52

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Symfony\Component\Cache\Traits;
  14. use Psr\Cache\CacheItemInterface;
  15. use Symfony\Component\Cache\CacheItem;
  16. use Symfony\Component\Cache\Exception\InvalidArgumentException;
  18. /**
  19.  * @author Nicolas Grekas <p@tchwork.com>
  20.  *
  21.  * @internal
  22.  */
  23. trait AbstractAdapterTrait
  24. {
  25.     use AbstractTrait;
  27.     /**
  28.      * @var \Closure needs to be set by class, signature is function(string <key>, mixed <value>, bool <isHit>)
  29.      */
  30.     private $createCacheItem;
  32.     /**
  33.      * @var \Closure needs to be set by class, signature is function(array <deferred>, string <namespace>, array <&expiredIds>)
  34.      */
  35.     private $mergeByLifetime;
  37.     /**
  38.      * {@inheritdoc}
  39.      */
  40.     public function getItem($key)
  41.     {
  42.         if ($this->deferred) {
  43.             $this->commit();
  44.         }
  45.         $id = $this->getId($key);
  47.         $f = $this->createCacheItem;
  48.         $isHit = false;
  49.         $value = null;
  51.         try {
  52.             foreach ($this->doFetch([$id]) as $value) {
  53.                 $isHit = true;
  54.             }
  56.             return $f($key, $value, $isHit);
  57.         } catch (\Exception $e) {
  58.             CacheItem::log($this->logger, 'Failed to fetch key "{key}": '.$e->getMessage(), ['key' => $key, 'exception' => $e]);
  59.         }
  61.         return $f($key, null, false);
  62.     }
  64.     /**
  65.      * {@inheritdoc}
  66.      */
  67.     public function getItems(array $keys = [])
  68.     {
  69.         if ($this->deferred) {
  70.             $this->commit();
  71.         }
  72.         $ids = [];
  74.         foreach ($keys as $key) {
  75.             $ids[] = $this->getId($key);
  76.         }
  77.         try {
  78.             $items = $this->doFetch($ids);
  79.         } catch (\Exception $e) {
  80.             CacheItem::log($this->logger, 'Failed to fetch items: '.$e->getMessage(), ['keys' => $keys, 'exception' => $e]);
  81.             $items = [];
  82.         }
  83.         $ids = array_combine($ids, $keys);
  85.         return $this->generateItems($items, $ids);
  86.     }
  88.     /**
  89.      * {@inheritdoc}
  90.      *
  91.      * @return bool
  92.      */
  93.     public function save(CacheItemInterface $item)
  94.     {
  95.         if (!$item instanceof CacheItem) {
  96.             return false;
  97.         }
  98.         $this->deferred[$item->getKey()] = $item;
  100.         return $this->commit();
  101.     }
  103.     /**
  104.      * {@inheritdoc}
  105.      *
  106.      * @return bool
  107.      */
  108.     public function saveDeferred(CacheItemInterface $item)
  109.     {
  110.         if (!$item instanceof CacheItem) {
  111.             return false;
  112.         }
  113.         $this->deferred[$item->getKey()] = $item;
  115.         return true;
  116.     }
  118.     /**
  119.      * @return array
  120.      */
  121.     public function __sleep()
  122.     {
  123.         throw new \BadMethodCallException('Cannot serialize '.__CLASS__);
  124.     }
  126.     public function __wakeup()
  127.     {
  128.         throw new \BadMethodCallException('Cannot unserialize '.__CLASS__);
  129.     }
  131.     public function __destruct()
  132.     {
  133.         if ($this->deferred) {
  134.             $this->commit();
  135.         }
  136.     }
  138.     private function generateItems(iterable $items, array &$keys): iterable
  139.     {
  140.         $f = $this->createCacheItem;
  142.         try {
  143.             foreach ($items as $id => $value) {
  144.                 if (!isset($keys[$id])) {
  145.                     throw new InvalidArgumentException(sprintf('Could not match value id "%s" to keys "%s".', $id, implode('", "', $keys)));
  146.                 }
  147.                 $key = $keys[$id];
  148.                 unset($keys[$id]);
  149.                 yield $key => $f($key, $value, true);
  150.             }
  151.         } catch (\Exception $e) {
  152.             CacheItem::log($this->logger, 'Failed to fetch items: '.$e->getMessage(), ['keys' => array_values($keys), 'exception' => $e]);
  153.         }
  155.         foreach ($keys as $key) {
  156.             yield $key => $f($key, null, false);
  157.         }
  158.     }
  159. }