Deprecated: Constant E_STRICT is deprecated in /home/pastorz/old-espace-client/vendor/symfony/error-handler/ErrorHandler.php on line 58

Deprecated: Constant E_STRICT is deprecated in /home/pastorz/old-espace-client/vendor/symfony/error-handler/ErrorHandler.php on line 76
Symfony Profiler

vendor/symfony/cache/Adapter/ArrayAdapter.php line 76

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\Adapter;
  14. use Psr\Cache\CacheItemInterface;
  15. use Psr\Log\LoggerAwareInterface;
  16. use Psr\Log\LoggerAwareTrait;
  17. use Symfony\Component\Cache\CacheItem;
  18. use Symfony\Component\Cache\Exception\InvalidArgumentException;
  19. use Symfony\Component\Cache\ResettableInterface;
  20. use Symfony\Contracts\Cache\CacheInterface;
  22. /**
  23.  * An in-memory cache storage.
  24.  *
  25.  * Acts as a least-recently-used (LRU) storage when configured with a maximum number of items.
  26.  *
  27.  * @author Nicolas Grekas <p@tchwork.com>
  28.  */
  29. class ArrayAdapter implements AdapterInterface, CacheInterface, LoggerAwareInterface, ResettableInterface
  30. {
  31.     use LoggerAwareTrait;
  33.     private $storeSerialized;
  34.     private $values = [];
  35.     private $expiries = [];
  36.     private $defaultLifetime;
  37.     private $maxLifetime;
  38.     private $maxItems;
  40.     private static $createCacheItem;
  42.     /**
  43.      * @param bool $storeSerialized Disabling serialization can lead to cache corruptions when storing mutable values but increases performance otherwise
  44.      */
  45.     public function __construct(int $defaultLifetime = 0, bool $storeSerialized = true, float $maxLifetime = 0, int $maxItems = 0)
  46.     {
  47.         if (0 > $maxLifetime) {
  48.             throw new InvalidArgumentException(sprintf('Argument $maxLifetime must be positive, %F passed.', $maxLifetime));
  49.         }
  51.         if (0 > $maxItems) {
  52.             throw new InvalidArgumentException(sprintf('Argument $maxItems must be a positive integer, %d passed.', $maxItems));
  53.         }
  55.         $this->defaultLifetime = $defaultLifetime;
  56.         $this->storeSerialized = $storeSerialized;
  57.         $this->maxLifetime = $maxLifetime;
  58.         $this->maxItems = $maxItems;
  59.         self::$createCacheItem ?? self::$createCacheItem = \Closure::bind(
  60.             static function ($key, $value, $isHit) {
  61.                 $item = new CacheItem();
  62.                 $item->key = $key;
  63.                 $item->value = $value;
  64.                 $item->isHit = $isHit;
  66.                 return $item;
  67.             },
  68.             null,
  69.             CacheItem::class
  70.         );
  71.     }
  73.     /**
  74.      * {@inheritdoc}
  75.      */
  76.     public function get(string $key, callable $callback, float $beta = null, array &$metadata = null)
  77.     {
  78.         $item = $this->getItem($key);
  79.         $metadata = $item->getMetadata();
  81.         // ArrayAdapter works in memory, we don't care about stampede protection
  82.         if (\INF === $beta || !$item->isHit()) {
  83.             $save = true;
  84.             $item->set($callback($item, $save));
  85.             if ($save) {
  86.                 $this->save($item);
  87.             }
  88.         }
  90.         return $item->get();
  91.     }
  93.     /**
  94.      * {@inheritdoc}
  95.      */
  96.     public function delete(string $key): bool
  97.     {
  98.         return $this->deleteItem($key);
  99.     }
  101.     /**
  102.      * {@inheritdoc}
  103.      *
  104.      * @return bool
  105.      */
  106.     public function hasItem($key)
  107.     {
  108.         if (\is_string($key) && isset($this->expiries[$key]) && $this->expiries[$key] > microtime(true)) {
  109.             if ($this->maxItems) {
  110.                 // Move the item last in the storage
  111.                 $value = $this->values[$key];
  112.                 unset($this->values[$key]);
  113.                 $this->values[$key] = $value;
  114.             }
  116.             return true;
  117.         }
  118.         \assert('' !== CacheItem::validateKey($key));
  120.         return isset($this->expiries[$key]) && !$this->deleteItem($key);
  121.     }
  123.     /**
  124.      * {@inheritdoc}
  125.      */
  126.     public function getItem($key)
  127.     {
  128.         if (!$isHit = $this->hasItem($key)) {
  129.             $value = null;
  131.             if (!$this->maxItems) {
  132.                 // Track misses in non-LRU mode only
  133.                 $this->values[$key] = null;
  134.             }
  135.         } else {
  136.             $value = $this->storeSerialized ? $this->unfreeze($key, $isHit) : $this->values[$key];
  137.         }
  139.         return (self::$createCacheItem)($key, $value, $isHit);
  140.     }
  142.     /**
  143.      * {@inheritdoc}
  144.      */
  145.     public function getItems(array $keys = [])
  146.     {
  147.         \assert(self::validateKeys($keys));
  149.         return $this->generateItems($keys, microtime(true), self::$createCacheItem);
  150.     }
  152.     /**
  153.      * {@inheritdoc}
  154.      *
  155.      * @return bool
  156.      */
  157.     public function deleteItem($key)
  158.     {
  159.         \assert('' !== CacheItem::validateKey($key));
  160.         unset($this->values[$key], $this->expiries[$key]);
  162.         return true;
  163.     }
  165.     /**
  166.      * {@inheritdoc}
  167.      *
  168.      * @return bool
  169.      */
  170.     public function deleteItems(array $keys)
  171.     {
  172.         foreach ($keys as $key) {
  173.             $this->deleteItem($key);
  174.         }
  176.         return true;
  177.     }
  179.     /**
  180.      * {@inheritdoc}
  181.      *
  182.      * @return bool
  183.      */
  184.     public function save(CacheItemInterface $item)
  185.     {
  186.         if (!$item instanceof CacheItem) {
  187.             return false;
  188.         }
  189.         $item = (array) $item;
  190.         $key = $item["\0*\0key"];
  191.         $value = $item["\0*\0value"];
  192.         $expiry = $item["\0*\0expiry"];
  194.         $now = microtime(true);
  196.         if (null !== $expiry) {
  197.             if (!$expiry) {
  198.                 $expiry = \PHP_INT_MAX;
  199.             } elseif ($expiry <= $now) {
  200.                 $this->deleteItem($key);
  202.                 return true;
  203.             }
  204.         }
  205.         if ($this->storeSerialized && null === $value = $this->freeze($value, $key)) {
  206.             return false;
  207.         }
  208.         if (null === $expiry && 0 < $this->defaultLifetime) {
  209.             $expiry = $this->defaultLifetime;
  210.             $expiry = $now + ($expiry > ($this->maxLifetime ?: $expiry) ? $this->maxLifetime : $expiry);
  211.         } elseif ($this->maxLifetime && (null === $expiry || $expiry > $now + $this->maxLifetime)) {
  212.             $expiry = $now + $this->maxLifetime;
  213.         }
  215.         if ($this->maxItems) {
  216.             unset($this->values[$key]);
  218.             // Iterate items and vacuum expired ones while we are at it
  219.             foreach ($this->values as $k => $v) {
  220.                 if ($this->expiries[$k] > $now && \count($this->values) < $this->maxItems) {
  221.                     break;
  222.                 }
  224.                 unset($this->values[$k], $this->expiries[$k]);
  225.             }
  226.         }
  228.         $this->values[$key] = $value;
  229.         $this->expiries[$key] = $expiry ?? \PHP_INT_MAX;
  231.         return true;
  232.     }
  234.     /**
  235.      * {@inheritdoc}
  236.      *
  237.      * @return bool
  238.      */
  239.     public function saveDeferred(CacheItemInterface $item)
  240.     {
  241.         return $this->save($item);
  242.     }
  244.     /**
  245.      * {@inheritdoc}
  246.      *
  247.      * @return bool
  248.      */
  249.     public function commit()
  250.     {
  251.         return true;
  252.     }
  254.     /**
  255.      * {@inheritdoc}
  256.      *
  257.      * @return bool
  258.      */
  259.     public function clear(string $prefix = '')
  260.     {
  261.         if ('' !== $prefix) {
  262.             $now = microtime(true);
  264.             foreach ($this->values as $key => $value) {
  265.                 if (!isset($this->expiries[$key]) || $this->expiries[$key] <= $now || 0 === strpos($key, $prefix)) {
  266.                     unset($this->values[$key], $this->expiries[$key]);
  267.                 }
  268.             }
  270.             if ($this->values) {
  271.                 return true;
  272.             }
  273.         }
  275.         $this->values = $this->expiries = [];
  277.         return true;
  278.     }
  280.     /**
  281.      * Returns all cached values, with cache miss as null.
  282.      *
  283.      * @return array
  284.      */
  285.     public function getValues()
  286.     {
  287.         if (!$this->storeSerialized) {
  288.             return $this->values;
  289.         }
  291.         $values = $this->values;
  292.         foreach ($values as $k => $v) {
  293.             if (null === $v || 'N;' === $v) {
  294.                 continue;
  295.             }
  296.             if (!\is_string($v) || !isset($v[2]) || ':' !== $v[1]) {
  297.                 $values[$k] = serialize($v);
  298.             }
  299.         }
  301.         return $values;
  302.     }
  304.     /**
  305.      * {@inheritdoc}
  306.      */
  307.     public function reset()
  308.     {
  309.         $this->clear();
  310.     }
  312.     private function generateItems(array $keys, float $now, \Closure $f): \Generator
  313.     {
  314.         foreach ($keys as $i => $key) {
  315.             if (!$isHit = isset($this->expiries[$key]) && ($this->expiries[$key] > $now || !$this->deleteItem($key))) {
  316.                 $value = null;
  318.                 if (!$this->maxItems) {
  319.                     // Track misses in non-LRU mode only
  320.                     $this->values[$key] = null;
  321.                 }
  322.             } else {
  323.                 if ($this->maxItems) {
  324.                     // Move the item last in the storage
  325.                     $value = $this->values[$key];
  326.                     unset($this->values[$key]);
  327.                     $this->values[$key] = $value;
  328.                 }
  330.                 $value = $this->storeSerialized ? $this->unfreeze($key, $isHit) : $this->values[$key];
  331.             }
  332.             unset($keys[$i]);
  334.             yield $key => $f($key, $value, $isHit);
  335.         }
  337.         foreach ($keys as $key) {
  338.             yield $key => $f($key, null, false);
  339.         }
  340.     }
  342.     private function freeze($value, string $key)
  343.     {
  344.         if (null === $value) {
  345.             return 'N;';
  346.         }
  347.         if (\is_string($value)) {
  348.             // Serialize strings if they could be confused with serialized objects or arrays
  349.             if ('N;' === $value || (isset($value[2]) && ':' === $value[1])) {
  350.                 return serialize($value);
  351.             }
  352.         } elseif (!\is_scalar($value)) {
  353.             try {
  354.                 $serialized = serialize($value);
  355.             } catch (\Exception $e) {
  356.                 unset($this->values[$key]);
  357.                 $type = get_debug_type($value);
  358.                 $message = sprintf('Failed to save key "{key}" of type %s: %s', $type, $e->getMessage());
  359.                 CacheItem::log($this->logger, $message, ['key' => $key, 'exception' => $e, 'cache-adapter' => get_debug_type($this)]);
  361.                 return;
  362.             }
  363.             // Keep value serialized if it contains any objects or any internal references
  364.             if ('C' === $serialized[0] || 'O' === $serialized[0] || preg_match('/;[OCRr]:[1-9]/', $serialized)) {
  365.                 return $serialized;
  366.             }
  367.         }
  369.         return $value;
  370.     }
  372.     private function unfreeze(string $key, bool &$isHit)
  373.     {
  374.         if ('N;' === $value = $this->values[$key]) {
  375.             return null;
  376.         }
  377.         if (\is_string($value) && isset($value[2]) && ':' === $value[1]) {
  378.             try {
  379.                 $value = unserialize($value);
  380.             } catch (\Exception $e) {
  381.                 CacheItem::log($this->logger, 'Failed to unserialize key "{key}": '.$e->getMessage(), ['key' => $key, 'exception' => $e, 'cache-adapter' => get_debug_type($this)]);
  382.                 $value = false;
  383.             }
  384.             if (false === $value) {
  385.                 $value = null;
  386.                 $isHit = false;
  388.                 if (!$this->maxItems) {
  389.                     $this->values[$key] = null;
  390.                 }
  391.             }
  392.         }
  394.         return $value;
  395.     }
  397.     private function validateKeys(array $keys): bool
  398.     {
  399.         foreach ($keys as $key) {
  400.             if (!\is_string($key) || !isset($this->expiries[$key])) {
  401.                 CacheItem::validateKey($key);
  402.             }
  403.         }
  405.         return true;
  406.     }
  407. }