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

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.         $id = $this->getId($key);
  44.         if (isset($this->deferred[$key])) {
  45.             $this->commit();
  46.         }
  48.         $f = $this->createCacheItem;
  49.         $isHit = false;
  50.         $value = null;
  52.         try {
  53.             foreach ($this->doFetch([$id]) as $value) {
  54.                 $isHit = true;
  55.             }
  57.             return $f($key, $value, $isHit);
  58.         } catch (\Exception $e) {
  59.             CacheItem::log($this->logger, 'Failed to fetch key "{key}": '.$e->getMessage(), ['key' => $key, 'exception' => $e]);
  60.         }
  62.         return $f($key, null, false);
  63.     }
  65.     /**
  66.      * {@inheritdoc}
  67.      */
  68.     public function getItems(array $keys = [])
  69.     {
  70.         $ids = [];
  71.         $commit = false;
  73.         foreach ($keys as $key) {
  74.             $ids[] = $this->getId($key);
  75.             $commit = $commit || isset($this->deferred[$key]);
  76.         }
  78.         if ($commit) {
  79.             $this->commit();
  80.         }
  82.         try {
  83.             $items = $this->doFetch($ids);
  84.         } catch (\Exception $e) {
  85.             CacheItem::log($this->logger, 'Failed to fetch items: '.$e->getMessage(), ['keys' => $keys, 'exception' => $e]);
  86.             $items = [];
  87.         }
  88.         $ids = array_combine($ids, $keys);
  90.         return $this->generateItems($items, $ids);
  91.     }
  93.     /**
  94.      * {@inheritdoc}
  95.      *
  96.      * @return bool
  97.      */
  98.     public function save(CacheItemInterface $item)
  99.     {
  100.         if (!$item instanceof CacheItem) {
  101.             return false;
  102.         }
  103.         $this->deferred[$item->getKey()] = $item;
  105.         return $this->commit();
  106.     }
  108.     /**
  109.      * {@inheritdoc}
  110.      *
  111.      * @return bool
  112.      */
  113.     public function saveDeferred(CacheItemInterface $item)
  114.     {
  115.         if (!$item instanceof CacheItem) {
  116.             return false;
  117.         }
  118.         $this->deferred[$item->getKey()] = $item;
  120.         return true;
  121.     }
  123.     /**
  124.      * @return array
  125.      */
  126.     public function __sleep()
  127.     {
  128.         throw new \BadMethodCallException('Cannot serialize '.__CLASS__);
  129.     }
  131.     public function __wakeup()
  132.     {
  133.         throw new \BadMethodCallException('Cannot unserialize '.__CLASS__);
  134.     }
  136.     public function __destruct()
  137.     {
  138.         if ($this->deferred) {
  139.             $this->commit();
  140.         }
  141.     }
  143.     private function generateItems(iterable $items, array &$keys): iterable
  144.     {
  145.         $f = $this->createCacheItem;
  147.         try {
  148.             foreach ($items as $id => $value) {
  149.                 if (!isset($keys[$id])) {
  150.                     throw new InvalidArgumentException(sprintf('Could not match value id "%s" to keys "%s".', $id, implode('", "', $keys)));
  151.                 }
  152.                 $key = $keys[$id];
  153.                 unset($keys[$id]);
  154.                 yield $key => $f($key, $value, true);
  155.             }
  156.         } catch (\Exception $e) {
  157.             CacheItem::log($this->logger, 'Failed to fetch items: '.$e->getMessage(), ['keys' => array_values($keys), 'exception' => $e]);
  158.         }
  160.         foreach ($keys as $key) {
  161.             yield $key => $f($key, null, false);
  162.         }
  163.     }
  164. }