FM / Adapter

/var/www/flurhymez/vendor/symfony/cache/Adapter/

/var/www/flurhymez/vendor/symfony/cache/Adapter

Name	Size	Mode	Actions
AbstractAdapter.php	8330	0644	edit dl rm
AbstractTagAwareAdapter.php	12531	0644	edit dl rm
AdapterInterface.php	993	0644	edit dl rm
ApcuAdapter.php	3959	0644	edit dl rm
ArrayAdapter.php	11305	0644	edit dl rm
ChainAdapter.php	9063	0644	edit dl rm
CouchbaseBucketAdapter.php	7729	0644	edit dl rm
CouchbaseCollectionAdapter.php	6705	0644	edit dl rm
DoctrineAdapter.php	2845	0644	edit dl rm
DoctrineDbalAdapter.php	15355	0644	edit dl rm
FilesystemAdapter.php	933	0644	edit dl rm
FilesystemTagAwareAdapter.php	7584	0644	edit dl rm
MemcachedAdapter.php	13749	0644	edit dl rm
NullAdapter.php	2770	0644	edit dl rm
ParameterNormalizer.php	898	0644	edit dl rm
PdoAdapter.php	20331	0644	edit dl rm
PhpArrayAdapter.php	12607	0644	edit dl rm
PhpFilesAdapter.php	10260	0644	edit dl rm
ProxyAdapter.php	8462	0644	edit dl rm
Psr16Adapter.php	1901	0644	edit dl rm
RedisAdapter.php	1200	0644	edit dl rm
RedisTagAwareAdapter.php	12218	0644	edit dl rm
TagAwareAdapter.php	11482	0644	edit dl rm
TagAwareAdapterInterface.php	769	0644	edit dl rm
TraceableAdapter.php	6926	0644	edit dl rm
TraceableTagAwareAdapter.php	926	0644	edit dl rm

Edit: /var/www/flurhymez/vendor/symfony/cache/Adapter/ChainAdapter.php (9063B)

<?php

/*
 * This file is part of the Symfony package.
 *
 * (c) Fabien Potencier <fabien@symfony.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Symfony\Component\Cache\Adapter;

use Psr\Cache\CacheItemInterface;
use Psr\Cache\CacheItemPoolInterface;
use Symfony\Component\Cache\CacheItem;
use Symfony\Component\Cache\Exception\InvalidArgumentException;
use Symfony\Component\Cache\PruneableInterface;
use Symfony\Component\Cache\ResettableInterface;
use Symfony\Component\Cache\Traits\ContractsTrait;
use Symfony\Contracts\Cache\CacheInterface;
use Symfony\Contracts\Service\ResetInterface;

/**
 * Chains several adapters together.
 *
 * Cached items are fetched from the first adapter having them in its data store.
 * They are saved and deleted in all adapters at once.
 *
 * @author Kévin Dunglas <dunglas@gmail.com>
 */
class ChainAdapter implements AdapterInterface, CacheInterface, PruneableInterface, ResettableInterface
{
    use ContractsTrait;

private $adapters = [];
    private $adapterCount;
    private $defaultLifetime;

private static $syncItem;

/**
     * @param CacheItemPoolInterface[] $adapters        The ordered list of adapters used to fetch cached items
     * @param int                      $defaultLifetime The default lifetime of items propagated from lower adapters to upper ones
     */
    public function __construct(array $adapters, int $defaultLifetime = 0)
    {
        if (!$adapters) {
            throw new InvalidArgumentException('At least one adapter must be specified.');
        }

foreach ($adapters as $adapter) {
            if (!$adapter instanceof CacheItemPoolInterface) {
                throw new InvalidArgumentException(sprintf('The class "%s" does not implement the "%s" interface.', get_debug_type($adapter), CacheItemPoolInterface::class));
            }
            if (\in_array(\PHP_SAPI, ['cli', 'phpdbg'], true) && $adapter instanceof ApcuAdapter && !filter_var(ini_get('apc.enable_cli'), \FILTER_VALIDATE_BOOLEAN)) {
                continue; // skip putting APCu in the chain when the backend is disabled
            }

if ($adapter instanceof AdapterInterface) {
                $this->adapters[] = $adapter;
            } else {
                $this->adapters[] = new ProxyAdapter($adapter);
            }
        }
        $this->adapterCount = \count($this->adapters);
        $this->defaultLifetime = $defaultLifetime;

self::$syncItem ?? self::$syncItem = \Closure::bind(
            static function ($sourceItem, $item, $defaultLifetime, $sourceMetadata = null) {
                $sourceItem->isTaggable = false;
                $sourceMetadata = $sourceMetadata ?? $sourceItem->metadata;
                unset($sourceMetadata[CacheItem::METADATA_TAGS]);

$item->value = $sourceItem->value;
                $item->isHit = $sourceItem->isHit;
                $item->metadata = $item->newMetadata = $sourceItem->metadata = $sourceMetadata;

if (isset($item->metadata[CacheItem::METADATA_EXPIRY])) {
                    $item->expiresAt(\DateTime::createFromFormat('U.u', sprintf('%.6F', $item->metadata[CacheItem::METADATA_EXPIRY])));
                } elseif (0 < $defaultLifetime) {
                    $item->expiresAfter($defaultLifetime);
                }

return $item;
            },
            null,
            CacheItem::class
        );
    }

/**
     * {@inheritdoc}
     */
    public function get(string $key, callable $callback, float $beta = null, array &$metadata = null)
    {
        $lastItem = null;
        $i = 0;
        $wrap = function (CacheItem $item = null) use ($key, $callback, $beta, &$wrap, &$i, &$lastItem, &$metadata) {
            $adapter = $this->adapters[$i];
            if (isset($this->adapters[++$i])) {
                $callback = $wrap;
                $beta = \INF === $beta ? \INF : 0;
            }
            if ($adapter instanceof CacheInterface) {
                $value = $adapter->get($key, $callback, $beta, $metadata);
            } else {
                $value = $this->doGet($adapter, $key, $callback, $beta, $metadata);
            }
            if (null !== $item) {
                (self::$syncItem)($lastItem = $lastItem ?? $item, $item, $this->defaultLifetime, $metadata);
            }

return $value;
        };

return $wrap();
    }

/**
     * {@inheritdoc}
     */
    public function getItem($key)
    {
        $syncItem = self::$syncItem;
        $misses = [];

foreach ($this->adapters as $i => $adapter) {
            $item = $adapter->getItem($key);

if ($item->isHit()) {
                while (0 <= --$i) {
                    $this->adapters[$i]->save($syncItem($item, $misses[$i], $this->defaultLifetime));
                }

return $item;
            }

$misses[$i] = $item;
        }

return $item;
    }

/**
     * {@inheritdoc}
     */
    public function getItems(array $keys = [])
    {
        return $this->generateItems($this->adapters[0]->getItems($keys), 0);
    }

private function generateItems(iterable $items, int $adapterIndex): \Generator
    {
        $missing = [];
        $misses = [];
        $nextAdapterIndex = $adapterIndex + 1;
        $nextAdapter = $this->adapters[$nextAdapterIndex] ?? null;

foreach ($items as $k => $item) {
            if (!$nextAdapter || $item->isHit()) {
                yield $k => $item;
            } else {
                $missing[] = $k;
                $misses[$k] = $item;
            }
        }

if ($missing) {
            $syncItem = self::$syncItem;
            $adapter = $this->adapters[$adapterIndex];
            $items = $this->generateItems($nextAdapter->getItems($missing), $nextAdapterIndex);

foreach ($items as $k => $item) {
                if ($item->isHit()) {
                    $adapter->save($syncItem($item, $misses[$k], $this->defaultLifetime));
                }

yield $k => $item;
            }
        }
    }

/**
     * {@inheritdoc}
     *
     * @return bool
     */
    public function hasItem($key)
    {
        foreach ($this->adapters as $adapter) {
            if ($adapter->hasItem($key)) {
                return true;
            }
        }

return false;
    }

/**
     * {@inheritdoc}
     *
     * @return bool
     */
    public function clear(string $prefix = '')
    {
        $cleared = true;
        $i = $this->adapterCount;

while ($i--) {
            if ($this->adapters[$i] instanceof AdapterInterface) {
                $cleared = $this->adapters[$i]->clear($prefix) && $cleared;
            } else {
                $cleared = $this->adapters[$i]->clear() && $cleared;
            }
        }

return $cleared;
    }

/**
     * {@inheritdoc}
     *
     * @return bool
     */
    public function deleteItem($key)
    {
        $deleted = true;
        $i = $this->adapterCount;

while ($i--) {
            $deleted = $this->adapters[$i]->deleteItem($key) && $deleted;
        }

return $deleted;
    }

/**
     * {@inheritdoc}
     *
     * @return bool
     */
    public function deleteItems(array $keys)
    {
        $deleted = true;
        $i = $this->adapterCount;

while ($i--) {
            $deleted = $this->adapters[$i]->deleteItems($keys) && $deleted;
        }

return $deleted;
    }

/**
     * {@inheritdoc}
     *
     * @return bool
     */
    public function save(CacheItemInterface $item)
    {
        $saved = true;
        $i = $this->adapterCount;

while ($i--) {
            $saved = $this->adapters[$i]->save($item) && $saved;
        }

return $saved;
    }

/**
     * {@inheritdoc}
     *
     * @return bool
     */
    public function saveDeferred(CacheItemInterface $item)
    {
        $saved = true;
        $i = $this->adapterCount;

while ($i--) {
            $saved = $this->adapters[$i]->saveDeferred($item) && $saved;
        }

return $saved;
    }

/**
     * {@inheritdoc}
     *
     * @return bool
     */
    public function commit()
    {
        $committed = true;
        $i = $this->adapterCount;

while ($i--) {
            $committed = $this->adapters[$i]->commit() && $committed;
        }

return $committed;
    }

/**
     * {@inheritdoc}
     */
    public function prune()
    {
        $pruned = true;

foreach ($this->adapters as $adapter) {
            if ($adapter instanceof PruneableInterface) {
                $pruned = $adapter->prune() && $pruned;
            }
        }

return $pruned;
    }

/**
     * {@inheritdoc}
     */
    public function reset()
    {
        foreach ($this->adapters as $adapter) {
            if ($adapter instanceof ResetInterface) {
                $adapter->reset();
            }
        }
    }
}

cmd: