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/PhpArrayAdapter.php line 86

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\Cache\CacheItemPoolInterface;
  16. use Symfony\Component\Cache\CacheItem;
  17. use Symfony\Component\Cache\Exception\InvalidArgumentException;
  18. use Symfony\Component\Cache\PruneableInterface;
  19. use Symfony\Component\Cache\ResettableInterface;
  20. use Symfony\Component\Cache\Traits\ContractsTrait;
  21. use Symfony\Component\Cache\Traits\ProxyTrait;
  22. use Symfony\Component\VarExporter\VarExporter;
  23. use Symfony\Contracts\Cache\CacheInterface;
  25. /**
  26.  * Caches items at warm up time using a PHP array that is stored in shared memory by OPCache since PHP 7.0.
  27.  * Warmed up items are read-only and run-time discovered items are cached using a fallback adapter.
  28.  *
  29.  * @author Titouan Galopin <galopintitouan@gmail.com>
  30.  * @author Nicolas Grekas <p@tchwork.com>
  31.  */
  32. class PhpArrayAdapter implements AdapterInterface, CacheInterface, PruneableInterface, ResettableInterface
  33. {
  34.     use ContractsTrait;
  35.     use ProxyTrait;
  37.     private $file;
  38.     private $keys;
  39.     private $values;
  41.     private static $createCacheItem;
  42.     private static $valuesCache = [];
  44.     /**
  45.      * @param string           $file         The PHP file were values are cached
  46.      * @param AdapterInterface $fallbackPool A pool to fallback on when an item is not hit
  47.      */
  48.     public function __construct(string $file, AdapterInterface $fallbackPool)
  49.     {
  50.         $this->file = $file;
  51.         $this->pool = $fallbackPool;
  52.         self::$createCacheItem ?? self::$createCacheItem = \Closure::bind(
  53.             static function ($key, $value, $isHit) {
  54.                 $item = new CacheItem();
  55.                 $item->key = $key;
  56.                 $item->value = $value;
  57.                 $item->isHit = $isHit;
  59.                 return $item;
  60.             },
  61.             null,
  62.             CacheItem::class
  63.         );
  64.     }
  66.     /**
  67.      * This adapter takes advantage of how PHP stores arrays in its latest versions.
  68.      *
  69.      * @param string                 $file         The PHP file were values are cached
  70.      * @param CacheItemPoolInterface $fallbackPool A pool to fallback on when an item is not hit
  71.      *
  72.      * @return CacheItemPoolInterface
  73.      */
  74.     public static function create(string $file, CacheItemPoolInterface $fallbackPool)
  75.     {
  76.         if (!$fallbackPool instanceof AdapterInterface) {
  77.             $fallbackPool = new ProxyAdapter($fallbackPool);
  78.         }
  80.         return new static($file, $fallbackPool);
  81.     }
  83.     /**
  84.      * {@inheritdoc}
  85.      */
  86.     public function get(string $key, callable $callback, float $beta = null, array &$metadata = null)
  87.     {
  88.         if (null === $this->values) {
  89.             $this->initialize();
  90.         }
  91.         if (!isset($this->keys[$key])) {
  92.             get_from_pool:
  93.             if ($this->pool instanceof CacheInterface) {
  94.                 return $this->pool->get($key, $callback, $beta, $metadata);
  95.             }
  97.             return $this->doGet($this->pool, $key, $callback, $beta, $metadata);
  98.         }
  99.         $value = $this->values[$this->keys[$key]];
  101.         if ('N;' === $value) {
  102.             return null;
  103.         }
  104.         try {
  105.             if ($value instanceof \Closure) {
  106.                 return $value();
  107.             }
  108.         } catch (\Throwable $e) {
  109.             unset($this->keys[$key]);
  110.             goto get_from_pool;
  111.         }
  113.         return $value;
  114.     }
  116.     /**
  117.      * {@inheritdoc}
  118.      */
  119.     public function getItem($key)
  120.     {
  121.         if (!\is_string($key)) {
  122.             throw new InvalidArgumentException(sprintf('Cache key must be string, "%s" given.', get_debug_type($key)));
  123.         }
  124.         if (null === $this->values) {
  125.             $this->initialize();
  126.         }
  127.         if (!isset($this->keys[$key])) {
  128.             return $this->pool->getItem($key);
  129.         }
  131.         $value = $this->values[$this->keys[$key]];
  132.         $isHit = true;
  134.         if ('N;' === $value) {
  135.             $value = null;
  136.         } elseif ($value instanceof \Closure) {
  137.             try {
  138.                 $value = $value();
  139.             } catch (\Throwable $e) {
  140.                 $value = null;
  141.                 $isHit = false;
  142.             }
  143.         }
  145.         return (self::$createCacheItem)($key, $value, $isHit);
  146.     }
  148.     /**
  149.      * {@inheritdoc}
  150.      */
  151.     public function getItems(array $keys = [])
  152.     {
  153.         foreach ($keys as $key) {
  154.             if (!\is_string($key)) {
  155.                 throw new InvalidArgumentException(sprintf('Cache key must be string, "%s" given.', get_debug_type($key)));
  156.             }
  157.         }
  158.         if (null === $this->values) {
  159.             $this->initialize();
  160.         }
  162.         return $this->generateItems($keys);
  163.     }
  165.     /**
  166.      * {@inheritdoc}
  167.      *
  168.      * @return bool
  169.      */
  170.     public function hasItem($key)
  171.     {
  172.         if (!\is_string($key)) {
  173.             throw new InvalidArgumentException(sprintf('Cache key must be string, "%s" given.', get_debug_type($key)));
  174.         }
  175.         if (null === $this->values) {
  176.             $this->initialize();
  177.         }
  179.         return isset($this->keys[$key]) || $this->pool->hasItem($key);
  180.     }
  182.     /**
  183.      * {@inheritdoc}
  184.      *
  185.      * @return bool
  186.      */
  187.     public function deleteItem($key)
  188.     {
  189.         if (!\is_string($key)) {
  190.             throw new InvalidArgumentException(sprintf('Cache key must be string, "%s" given.', get_debug_type($key)));
  191.         }
  192.         if (null === $this->values) {
  193.             $this->initialize();
  194.         }
  196.         return !isset($this->keys[$key]) && $this->pool->deleteItem($key);
  197.     }
  199.     /**
  200.      * {@inheritdoc}
  201.      *
  202.      * @return bool
  203.      */
  204.     public function deleteItems(array $keys)
  205.     {
  206.         $deleted = true;
  207.         $fallbackKeys = [];
  209.         foreach ($keys as $key) {
  210.             if (!\is_string($key)) {
  211.                 throw new InvalidArgumentException(sprintf('Cache key must be string, "%s" given.', get_debug_type($key)));
  212.             }
  214.             if (isset($this->keys[$key])) {
  215.                 $deleted = false;
  216.             } else {
  217.                 $fallbackKeys[] = $key;
  218.             }
  219.         }
  220.         if (null === $this->values) {
  221.             $this->initialize();
  222.         }
  224.         if ($fallbackKeys) {
  225.             $deleted = $this->pool->deleteItems($fallbackKeys) && $deleted;
  226.         }
  228.         return $deleted;
  229.     }
  231.     /**
  232.      * {@inheritdoc}
  233.      *
  234.      * @return bool
  235.      */
  236.     public function save(CacheItemInterface $item)
  237.     {
  238.         if (null === $this->values) {
  239.             $this->initialize();
  240.         }
  242.         return !isset($this->keys[$item->getKey()]) && $this->pool->save($item);
  243.     }
  245.     /**
  246.      * {@inheritdoc}
  247.      *
  248.      * @return bool
  249.      */
  250.     public function saveDeferred(CacheItemInterface $item)
  251.     {
  252.         if (null === $this->values) {
  253.             $this->initialize();
  254.         }
  256.         return !isset($this->keys[$item->getKey()]) && $this->pool->saveDeferred($item);
  257.     }
  259.     /**
  260.      * {@inheritdoc}
  261.      *
  262.      * @return bool
  263.      */
  264.     public function commit()
  265.     {
  266.         return $this->pool->commit();
  267.     }
  269.     /**
  270.      * {@inheritdoc}
  271.      *
  272.      * @return bool
  273.      */
  274.     public function clear(string $prefix = '')
  275.     {
  276.         $this->keys = $this->values = [];
  278.         $cleared = @unlink($this->file) || !file_exists($this->file);
  279.         unset(self::$valuesCache[$this->file]);
  281.         if ($this->pool instanceof AdapterInterface) {
  282.             return $this->pool->clear($prefix) && $cleared;
  283.         }
  285.         return $this->pool->clear() && $cleared;
  286.     }
  288.     /**
  289.      * Store an array of cached values.
  290.      *
  291.      * @param array $values The cached values
  292.      *
  293.      * @return string[] A list of classes to preload on PHP 7.4+
  294.      */
  295.     public function warmUp(array $values)
  296.     {
  297.         if (file_exists($this->file)) {
  298.             if (!is_file($this->file)) {
  299.                 throw new InvalidArgumentException(sprintf('Cache path exists and is not a file: "%s".', $this->file));
  300.             }
  302.             if (!is_writable($this->file)) {
  303.                 throw new InvalidArgumentException(sprintf('Cache file is not writable: "%s".', $this->file));
  304.             }
  305.         } else {
  306.             $directory = \dirname($this->file);
  308.             if (!is_dir($directory) && !@mkdir($directory, 0777, true)) {
  309.                 throw new InvalidArgumentException(sprintf('Cache directory does not exist and cannot be created: "%s".', $directory));
  310.             }
  312.             if (!is_writable($directory)) {
  313.                 throw new InvalidArgumentException(sprintf('Cache directory is not writable: "%s".', $directory));
  314.             }
  315.         }
  317.         $preload = [];
  318.         $dumpedValues = '';
  319.         $dumpedMap = [];
  320.         $dump = <<<'EOF'
  321. <?php
  323. // This file has been auto-generated by the Symfony Cache Component.
  325. return [[
  328. EOF;
  330.         foreach ($values as $key => $value) {
  331.             CacheItem::validateKey(\is_int($key) ? (string) $key : $key);
  332.             $isStaticValue = true;
  334.             if (null === $value) {
  335.                 $value = "'N;'";
  336.             } elseif (\is_object($value) || \is_array($value)) {
  337.                 try {
  338.                     $value = VarExporter::export($value, $isStaticValue, $preload);
  339.                 } catch (\Exception $e) {
  340.                     throw new InvalidArgumentException(sprintf('Cache key "%s" has non-serializable "%s" value.', $key, get_debug_type($value)), 0, $e);
  341.                 }
  342.             } elseif (\is_string($value)) {
  343.                 // Wrap "N;" in a closure to not confuse it with an encoded `null`
  344.                 if ('N;' === $value) {
  345.                     $isStaticValue = false;
  346.                 }
  347.                 $value = var_export($value, true);
  348.             } elseif (!\is_scalar($value)) {
  349.                 throw new InvalidArgumentException(sprintf('Cache key "%s" has non-serializable "%s" value.', $key, get_debug_type($value)));
  350.             } else {
  351.                 $value = var_export($value, true);
  352.             }
  354.             if (!$isStaticValue) {
  355.                 $value = str_replace("\n", "\n    ", $value);
  356.                 $value = "static function () {\n    return {$value};\n}";
  357.             }
  358.             $hash = hash('md5', $value);
  360.             if (null === $id = $dumpedMap[$hash] ?? null) {
  361.                 $id = $dumpedMap[$hash] = \count($dumpedMap);
  362.                 $dumpedValues .= "{$id} => {$value},\n";
  363.             }
  365.             $dump .= var_export($key, true)." => {$id},\n";
  366.         }
  368.         $dump .= "\n], [\n\n{$dumpedValues}\n]];\n";
  370.         $tmpFile = uniqid($this->file, true);
  372.         file_put_contents($tmpFile, $dump);
  373.         @chmod($tmpFile, 0666 & ~umask());
  374.         unset($serialized, $value, $dump);
  376.         @rename($tmpFile, $this->file);
  377.         unset(self::$valuesCache[$this->file]);
  379.         $this->initialize();
  381.         return $preload;
  382.     }
  384.     /**
  385.      * Load the cache file.
  386.      */
  387.     private function initialize()
  388.     {
  389.         if (isset(self::$valuesCache[$this->file])) {
  390.             $values = self::$valuesCache[$this->file];
  391.         } elseif (!is_file($this->file)) {
  392.             $this->keys = $this->values = [];
  394.             return;
  395.         } else {
  396.             $values = self::$valuesCache[$this->file] = (include $this->file) ?: [[], []];
  397.         }
  399.         if (2 !== \count($values) || !isset($values[0], $values[1])) {
  400.             $this->keys = $this->values = [];
  401.         } else {
  402.             [$this->keys, $this->values] = $values;
  403.         }
  404.     }
  406.     private function generateItems(array $keys): \Generator
  407.     {
  408.         $f = self::$createCacheItem;
  409.         $fallbackKeys = [];
  411.         foreach ($keys as $key) {
  412.             if (isset($this->keys[$key])) {
  413.                 $value = $this->values[$this->keys[$key]];
  415.                 if ('N;' === $value) {
  416.                     yield $key => $f($key, null, true);
  417.                 } elseif ($value instanceof \Closure) {
  418.                     try {
  419.                         yield $key => $f($key, $value(), true);
  420.                     } catch (\Throwable $e) {
  421.                         yield $key => $f($key, null, false);
  422.                     }
  423.                 } else {
  424.                     yield $key => $f($key, $value, true);
  425.                 }
  426.             } else {
  427.                 $fallbackKeys[] = $key;
  428.             }
  429.         }
  431.         if ($fallbackKeys) {
  432.             yield from $this->pool->getItems($fallbackKeys);
  433.         }
  434.     }
  435. }