grommunio / grommunio-web

plugins/files/php/vendor/phpfastcache/phpfastcache/lib/Phpfastcache/Core/Item/TaggableCacheItemInterface.php

Indentation +98 added lines, -98 removed lines

@@ -21,102 +21,102 @@
 
 interface TaggableCacheItemInterface
 {
-    /**
-     * Allows you to get cache item(s) by at least **ONE** of the specified matching tag(s).
-     * Default behavior
-     */
-    public const TAG_STRATEGY_ONE = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONE;
-
-    /**
-     * Allows you to get cache item(s) by **ALL** of the specified matching tag(s)
-     * The cache item *CAN* have additional tag(s)
-     */
-    public const TAG_STRATEGY_ALL = TaggableCacheItemPoolInterface::TAG_STRATEGY_ALL;
-
-    /**
-     * Allows you to get cache item(s) by **ONLY** the specified matching tag(s)
-     * The cache item *CANNOT* have additional tag(s)
-     */
-    public const TAG_STRATEGY_ONLY = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONLY;
-
-    /**
-     * @param string $tagName
-     *
-     * @return ExtendedCacheItemInterface
-     * @throws PhpfastcacheInvalidArgumentException
-     */
-    public function addTag(string $tagName): ExtendedCacheItemInterface;
-
-    /**
-     * @param string[] $tagNames
-     *
-     * @return ExtendedCacheItemInterface
-     * @throws PhpfastcacheInvalidArgumentException
-     */
-    public function addTags(array $tagNames): ExtendedCacheItemInterface;
-
-    /**
-     * @param string $tagName
-     *
-     * @return bool
-     */
-    public function hasTag(string $tagName): bool;
-
-    /**
-     * @return bool
-     */
-    public function isTagged(): bool;
-
-    /**
-     * @param string[] $tagNames
-     * @param int $strategy
-     * @return bool
-     * @throws PhpfastcacheInvalidArgumentException
-     */
-    public function hasTags(array $tagNames, int $strategy = self::TAG_STRATEGY_ONE): bool;
-
-    /**
-     * @param string[] $tags
-     *
-     * @return ExtendedCacheItemInterface
-     * @throws PhpfastcacheInvalidArgumentException
-     */
-    public function setTags(array $tags): ExtendedCacheItemInterface;
-
-    /**
-     * @return string[]
-     */
-    public function getTags(): array;
-
-    /**
-     * @param string $separator
-     *
-     * @return string
-     */
-    public function getTagsAsString(string $separator = ', '): string;
-
-    /**
-     * @param string $tagName
-     *
-     * @return ExtendedCacheItemInterface
-     * @throws PhpfastcacheInvalidArgumentException
-     */
-    public function removeTag(string $tagName): ExtendedCacheItemInterface;
-
-    /**
-     * @param string[] $tagNames
-     *
-     * @return ExtendedCacheItemInterface
-     */
-    public function removeTags(array $tagNames): ExtendedCacheItemInterface;
-
-    /**
-     * @return string[]
-     */
-    public function getRemovedTags(): array;
-
-    /**
-     * @return ExtendedCacheItemInterface
-     */
-    public function clearRemovedTags(): ExtendedCacheItemInterface;
+	/**
+	 * Allows you to get cache item(s) by at least **ONE** of the specified matching tag(s).
+	 * Default behavior
+	 */
+	public const TAG_STRATEGY_ONE = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONE;
+
+	/**
+	 * Allows you to get cache item(s) by **ALL** of the specified matching tag(s)
+	 * The cache item *CAN* have additional tag(s)
+	 */
+	public const TAG_STRATEGY_ALL = TaggableCacheItemPoolInterface::TAG_STRATEGY_ALL;
+
+	/**
+	 * Allows you to get cache item(s) by **ONLY** the specified matching tag(s)
+	 * The cache item *CANNOT* have additional tag(s)
+	 */
+	public const TAG_STRATEGY_ONLY = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONLY;
+
+	/**
+	 * @param string $tagName
+	 *
+	 * @return ExtendedCacheItemInterface
+	 * @throws PhpfastcacheInvalidArgumentException
+	 */
+	public function addTag(string $tagName): ExtendedCacheItemInterface;
+
+	/**
+	 * @param string[] $tagNames
+	 *
+	 * @return ExtendedCacheItemInterface
+	 * @throws PhpfastcacheInvalidArgumentException
+	 */
+	public function addTags(array $tagNames): ExtendedCacheItemInterface;
+
+	/**
+	 * @param string $tagName
+	 *
+	 * @return bool
+	 */
+	public function hasTag(string $tagName): bool;
+
+	/**
+	 * @return bool
+	 */
+	public function isTagged(): bool;
+
+	/**
+	 * @param string[] $tagNames
+	 * @param int $strategy
+	 * @return bool
+	 * @throws PhpfastcacheInvalidArgumentException
+	 */
+	public function hasTags(array $tagNames, int $strategy = self::TAG_STRATEGY_ONE): bool;
+
+	/**
+	 * @param string[] $tags
+	 *
+	 * @return ExtendedCacheItemInterface
+	 * @throws PhpfastcacheInvalidArgumentException
+	 */
+	public function setTags(array $tags): ExtendedCacheItemInterface;
+
+	/**
+	 * @return string[]
+	 */
+	public function getTags(): array;
+
+	/**
+	 * @param string $separator
+	 *
+	 * @return string
+	 */
+	public function getTagsAsString(string $separator = ', '): string;
+
+	/**
+	 * @param string $tagName
+	 *
+	 * @return ExtendedCacheItemInterface
+	 * @throws PhpfastcacheInvalidArgumentException
+	 */
+	public function removeTag(string $tagName): ExtendedCacheItemInterface;
+
+	/**
+	 * @param string[] $tagNames
+	 *
+	 * @return ExtendedCacheItemInterface
+	 */
+	public function removeTags(array $tagNames): ExtendedCacheItemInterface;
+
+	/**
+	 * @return string[]
+	 */
+	public function getRemovedTags(): array;
+
+	/**
+	 * @return ExtendedCacheItemInterface
+	 */
+	public function clearRemovedTags(): ExtendedCacheItemInterface;
 }

plugins/files/php/vendor/phpfastcache/phpfastcache/lib/Phpfastcache/Core/Item/TaggableCacheItemTrait.php

Indentation +167 added lines, -167 removed lines

@@ -22,171 +22,171 @@
 
 trait TaggableCacheItemTrait
 {
-    use ExtendedCacheItemTrait;
-
-    /**
-     * @var string[]
-     */
-    protected array $tags = [];
-
-    /**
-     * @var string[]
-     */
-    protected array $removedTags = [];
-
-    /**
-     * @param string[] $tagNames
-     * @return ExtendedCacheItemInterface
-     */
-    public function addTags(array $tagNames): ExtendedCacheItemInterface
-    {
-        foreach ($tagNames as $tagName) {
-            $this->addTag($tagName);
-        }
-
-        return $this;
-    }
-
-    /**
-     * @param string $tagName
-     * @return ExtendedCacheItemInterface
-     */
-    public function addTag(string $tagName): ExtendedCacheItemInterface
-    {
-        $this->tags = \array_unique(\array_merge($this->tags, [$tagName]));
-
-        return $this;
-    }
-
-    /**
-     * @param string $tagName
-     *
-     * @return bool
-     */
-    public function hasTag(string $tagName): bool
-    {
-        return \in_array($tagName, $this->tags, true);
-    }
-
-    /**
-     * @return bool
-     */
-    public function isTagged(): bool
-    {
-        return !empty($this->tags);
-    }
-
-    /**
-     * @param string[] $tagNames
-     * @param int $strategy
-     * @return bool
-     * @throws PhpfastcacheInvalidArgumentException
-     */
-    public function hasTags(array $tagNames, int $strategy = TaggableCacheItemInterface::TAG_STRATEGY_ONE): bool
-    {
-        return match ($strategy) {
-            TaggableCacheItemInterface::TAG_STRATEGY_ONE => !empty(array_intersect($tagNames, $this->tags)),
-            TaggableCacheItemInterface::TAG_STRATEGY_ALL => empty(\array_diff($tagNames, $this->tags)),
-            TaggableCacheItemInterface::TAG_STRATEGY_ONLY => empty(\array_diff($tagNames, $this->tags)) && empty(\array_diff($this->tags, $tagNames)),
-            default => throw new PhpfastcacheInvalidArgumentException('Invalid strategy constant provided.'),
-        };
-    }
-
-
-    /**
-     * @param string[] $tags
-     * @return ExtendedCacheItemInterface
-     * @throws PhpfastcacheInvalidArgumentException
-     */
-    public function setTags(array $tags): ExtendedCacheItemInterface
-    {
-        if ($tags === [] || \array_filter($tags, 'is_string')) {
-            $this->tags = $tags;
-        } else {
-            throw new PhpfastcacheInvalidArgumentException('$tagName must be an array of string');
-        }
-
-        return $this;
-    }
-
-    /**
-     * @return string[]
-     */
-    public function getTags(): array
-    {
-        return $this->tags;
-    }
-
-    /**
-     * @param string $separator
-     * @return string
-     */
-    public function getTagsAsString(string $separator = ', '): string
-    {
-        return \implode($separator, $this->tags);
-    }
-
-    /**
-     * @param string[] $tagNames
-     * @return ExtendedCacheItemInterface
-     */
-    public function removeTags(array $tagNames): ExtendedCacheItemInterface
-    {
-        foreach ($tagNames as $tagName) {
-            $this->removeTag($tagName);
-        }
-
-        return $this;
-    }
-
-    /**
-     * @param string $tagName
-     * @return ExtendedCacheItemInterface
-     */
-    public function removeTag(string $tagName): ExtendedCacheItemInterface
-    {
-        if (($key = \array_search($tagName, $this->tags, true)) !== false) {
-            unset($this->tags[$key]);
-            $this->removedTags[] = $tagName;
-        }
-
-        return $this;
-    }
-
-    /**
-     * @return string[]
-     */
-    public function getRemovedTags(): array
-    {
-        return \array_diff($this->removedTags, $this->tags);
-    }
-
-    /**
-     * @return ExtendedCacheItemInterface
-     */
-    public function clearRemovedTags(): ExtendedCacheItemInterface
-    {
-        $this->removedTags = [];
-
-        return $this;
-    }
-
-    /**
-     * @throws PhpfastcacheLogicException
-     * @throws PhpfastcacheInvalidArgumentException
-     */
-    public function cloneInto(ExtendedCacheItemInterface $itemTarget, ?ExtendedCacheItemPoolInterface $itemPoolTarget = null): void
-    {
-        $itemTarget->setEventManager($this->getEventManager())
-            ->set($this->_getData())
-            ->setHit($this->isHit())
-            ->setTags($this->getTags())
-            ->expiresAt(clone $this->getExpirationDate())
-            ->setDriver($itemPoolTarget ?? $this->driver);
-
-        if ($this->driver->getConfig()->isItemDetailedDate()) {
-            $itemTarget->setCreationDate(clone $this->getCreationDate())
-                ->setModificationDate(clone $this->getModificationDate());
-        }
-    }
+	use ExtendedCacheItemTrait;
+
+	/**
+	 * @var string[]
+	 */
+	protected array $tags = [];
+
+	/**
+	 * @var string[]
+	 */
+	protected array $removedTags = [];
+
+	/**
+	 * @param string[] $tagNames
+	 * @return ExtendedCacheItemInterface
+	 */
+	public function addTags(array $tagNames): ExtendedCacheItemInterface
+	{
+		foreach ($tagNames as $tagName) {
+			$this->addTag($tagName);
+		}
+
+		return $this;
+	}
+
+	/**
+	 * @param string $tagName
+	 * @return ExtendedCacheItemInterface
+	 */
+	public function addTag(string $tagName): ExtendedCacheItemInterface
+	{
+		$this->tags = \array_unique(\array_merge($this->tags, [$tagName]));
+
+		return $this;
+	}
+
+	/**
+	 * @param string $tagName
+	 *
+	 * @return bool
+	 */
+	public function hasTag(string $tagName): bool
+	{
+		return \in_array($tagName, $this->tags, true);
+	}
+
+	/**
+	 * @return bool
+	 */
+	public function isTagged(): bool
+	{
+		return !empty($this->tags);
+	}
+
+	/**
+	 * @param string[] $tagNames
+	 * @param int $strategy
+	 * @return bool
+	 * @throws PhpfastcacheInvalidArgumentException
+	 */
+	public function hasTags(array $tagNames, int $strategy = TaggableCacheItemInterface::TAG_STRATEGY_ONE): bool
+	{
+		return match ($strategy) {
+			TaggableCacheItemInterface::TAG_STRATEGY_ONE => !empty(array_intersect($tagNames, $this->tags)),
+			TaggableCacheItemInterface::TAG_STRATEGY_ALL => empty(\array_diff($tagNames, $this->tags)),
+			TaggableCacheItemInterface::TAG_STRATEGY_ONLY => empty(\array_diff($tagNames, $this->tags)) && empty(\array_diff($this->tags, $tagNames)),
+			default => throw new PhpfastcacheInvalidArgumentException('Invalid strategy constant provided.'),
+		};
+	}
+
+
+	/**
+	 * @param string[] $tags
+	 * @return ExtendedCacheItemInterface
+	 * @throws PhpfastcacheInvalidArgumentException
+	 */
+	public function setTags(array $tags): ExtendedCacheItemInterface
+	{
+		if ($tags === [] || \array_filter($tags, 'is_string')) {
+			$this->tags = $tags;
+		} else {
+			throw new PhpfastcacheInvalidArgumentException('$tagName must be an array of string');
+		}
+
+		return $this;
+	}
+
+	/**
+	 * @return string[]
+	 */
+	public function getTags(): array
+	{
+		return $this->tags;
+	}
+
+	/**
+	 * @param string $separator
+	 * @return string
+	 */
+	public function getTagsAsString(string $separator = ', '): string
+	{
+		return \implode($separator, $this->tags);
+	}
+
+	/**
+	 * @param string[] $tagNames
+	 * @return ExtendedCacheItemInterface
+	 */
+	public function removeTags(array $tagNames): ExtendedCacheItemInterface
+	{
+		foreach ($tagNames as $tagName) {
+			$this->removeTag($tagName);
+		}
+
+		return $this;
+	}
+
+	/**
+	 * @param string $tagName
+	 * @return ExtendedCacheItemInterface
+	 */
+	public function removeTag(string $tagName): ExtendedCacheItemInterface
+	{
+		if (($key = \array_search($tagName, $this->tags, true)) !== false) {
+			unset($this->tags[$key]);
+			$this->removedTags[] = $tagName;
+		}
+
+		return $this;
+	}
+
+	/**
+	 * @return string[]
+	 */
+	public function getRemovedTags(): array
+	{
+		return \array_diff($this->removedTags, $this->tags);
+	}
+
+	/**
+	 * @return ExtendedCacheItemInterface
+	 */
+	public function clearRemovedTags(): ExtendedCacheItemInterface
+	{
+		$this->removedTags = [];
+
+		return $this;
+	}
+
+	/**
+	 * @throws PhpfastcacheLogicException
+	 * @throws PhpfastcacheInvalidArgumentException
+	 */
+	public function cloneInto(ExtendedCacheItemInterface $itemTarget, ?ExtendedCacheItemPoolInterface $itemPoolTarget = null): void
+	{
+		$itemTarget->setEventManager($this->getEventManager())
+			->set($this->_getData())
+			->setHit($this->isHit())
+			->setTags($this->getTags())
+			->expiresAt(clone $this->getExpirationDate())
+			->setDriver($itemPoolTarget ?? $this->driver);
+
+		if ($this->driver->getConfig()->isItemDetailedDate()) {
+			$itemTarget->setCreationDate(clone $this->getCreationDate())
+				->setModificationDate(clone $this->getModificationDate());
+		}
+	}
 }

plugins/files/php/vendor/phpfastcache/phpfastcache/lib/Phpfastcache/Core/Item/ExtendedCacheItemTrait.php

Indentation +278 added lines, -278 removed lines

@@ -26,282 +26,282 @@
 
 trait ExtendedCacheItemTrait
 {
-    use CacheItemTrait;
-
-    protected ExtendedCacheItemPoolInterface $driver;
-
-    protected string $encodedKey;
-
-    /**
-     * Item constructor.
-     * @param ExtendedCacheItemPoolInterface $driver
-     * @param string $key
-     * @param EventManagerInterface $em
-     * @throws PhpfastcacheInvalidArgumentException
-     */
-    public function __construct(ExtendedCacheItemPoolInterface $driver, string $key, EventManagerInterface $em)
-    {
-        $this->data = null;
-        $this->key = $key;
-        $this->setEventManager($em);
-        $this->setDriver($driver);
-        if ($driver->getConfig()->isUseStaticItemCaching()) {
-            $this->driver->setItem($this);
-        }
-        $this->expirationDate = new DateTime();
-        if ($this->driver->getConfig()->isItemDetailedDate()) {
-            $this->creationDate = new DateTime();
-            $this->modificationDate = new DateTime();
-        }
-    }
-
-    /**
-     * @param ExtendedCacheItemPoolInterface $driver
-     * @return ExtendedCacheItemInterface
-     * @throws PhpfastcacheInvalidArgumentException
-     */
-    public function setDriver(ExtendedCacheItemPoolInterface $driver): ExtendedCacheItemInterface
-    {
-        $driverClass = $this->getDriverClass();
-        if ($driver instanceof $driverClass) {
-            $this->driver = $driver;
-
-            return $this;
-        }
-
-        throw new PhpfastcacheInvalidArgumentException(\sprintf('Invalid driver instance "%s" for cache item "%s"', $driver::class, static::class));
-    }
-
-    /**
-     * @inheritDoc
-     */
-    public function getEncodedKey(): string
-    {
-        if (!isset($this->encodedKey)) {
-            $this->encodedKey = $this->driver->getEncodedKey($this->getKey());
-        }
-
-        return $this->encodedKey;
-    }
-
-    /**
-     * @inheritDoc
-     * @SuppressWarnings(PHPMD.CamelCaseMethodName)
-     */
-    public function _getData(): mixed // @phpcs:ignore
-    {
-        return $this->data;
-    }
-
-    /**
-     * @inheritDoc
-     */
-    public function getExpirationDate(): DateTimeInterface
-    {
-        return $this->expirationDate;
-    }
-
-    /**
-     * @inheritDoc
-     * @throws PhpfastcacheInvalidArgumentException
-     */
-    public function setExpirationDate(DateTimeInterface $expiration): ExtendedCacheItemInterface
-    {
-        return $this->expiresAt($expiration);
-    }
-
-    /**
-     * @inheritDoc
-     * @throws PhpfastcacheLogicException
-     */
-    public function getCreationDate(): DateTimeInterface
-    {
-        if ($this->driver->getConfig()->isItemDetailedDate()) {
-            return $this->creationDate;
-        }
-
-        throw new PhpfastcacheLogicException('Cannot access to the creation date when the "itemDetailedDate" configuration is disabled.');
-    }
-
-    /**
-     * @inheritDoc
-     * @throws PhpfastcacheLogicException
-     */
-    public function setCreationDate(DateTimeInterface $date): ExtendedCacheItemInterface
-    {
-        if ($this->driver->getConfig()->isItemDetailedDate()) {
-            $this->creationDate = $this->demutateDatetime($date);
-            return $this;
-        }
-
-        throw new PhpfastcacheLogicException('Cannot access to the creation date when the "itemDetailedDate" configuration is disabled.');
-    }
-
-    /**
-     * @inheritDoc
-     * @throws PhpfastcacheLogicException
-     */
-    public function getModificationDate(): DateTimeInterface
-    {
-        if ($this->driver->getConfig()->isItemDetailedDate()) {
-            return $this->modificationDate;
-        }
-
-        throw new PhpfastcacheLogicException('Cannot access to the modification date when the "itemDetailedDate" configuration is disabled.');
-    }
-
-    /**
-     * @inheritDoc
-     * @throws PhpfastcacheLogicException
-     */
-    public function setModificationDate(DateTimeInterface $date): ExtendedCacheItemInterface
-    {
-        if ($this->driver->getConfig()->isItemDetailedDate()) {
-            $this->modificationDate = $this->demutateDatetime($date);
-            return $this;
-        }
-
-        throw new PhpfastcacheLogicException('Cannot access to the modification date when the "itemDetailedDate" configuration is disabled.');
-    }
-
-    public function getTtl(): int
-    {
-        return \max(0, $this->expirationDate->getTimestamp() - \time());
-    }
-
-    public function isExpired(): bool
-    {
-        return $this->getTtl() <= 0;
-    }
-
-    public function isNull(): bool
-    {
-        return $this->get() === null;
-    }
-
-    public function isEmpty(): bool
-    {
-        return empty($this->get());
-    }
-
-    /**
-     * Return the data length:
-     * Either the string length if it's a string (binary mode)
-     * # or the number of element (count) if it's an array
-     * # or the number returned by count() if it's an object implementing \Countable interface
-     * # -1 for anything else
-     * @return int
-     */
-    public function getLength(): int
-    {
-        switch (\gettype($this->data)) {
-            case 'array':
-            case 'object':
-                if (\is_countable($this->data)) {
-                    return \count($this->data);
-                }
-                break;
-
-            case 'string':
-                return \strlen($this->data);
-        }
-
-        return -1;
-    }
-
-    /**
-     * @throws PhpfastcacheInvalidTypeException
-     */
-    public function increment(int $step = 1): ExtendedCacheItemInterface
-    {
-        if ($this->data !== null && !\is_numeric($this->data)) {
-            throw new PhpfastcacheInvalidTypeException(\sprintf('Cannot increment on a "%s" type.', \gettype($this->data)));
-        }
-
-        $this->data += $step;
-
-        return $this;
-    }
-
-    /**
-     * @throws PhpfastcacheInvalidTypeException
-     */
-    public function decrement(int $step = 1): ExtendedCacheItemInterface
-    {
-        if ($this->data !== null && !\is_numeric($this->data)) {
-            throw new PhpfastcacheInvalidTypeException(\sprintf('Cannot decrement on a "%s" type.', \gettype($this->data)));
-        }
-
-        $this->data -= $step;
-
-        return $this;
-    }
-
-    /**
-     * @throws PhpfastcacheInvalidTypeException
-     */
-    public function append(array|string $data): ExtendedCacheItemInterface
-    {
-        if ($this->data !== null && !\is_string($this->data) && !\is_array($this->data)) {
-            throw new PhpfastcacheInvalidTypeException(\sprintf('Cannot append on a "%s" type.', \gettype($this->data)));
-        }
-
-        if (\is_array($this->data)) {
-            $this->data[] = $data;
-        } else {
-            $this->data .= $data;
-        }
-
-        return $this;
-    }
-
-    /**
-     * @throws PhpfastcacheInvalidTypeException
-     */
-    public function prepend(array|string $data): ExtendedCacheItemInterface
-    {
-        if ($this->data !== null && !\is_string($this->data) && !\is_array($this->data)) {
-            throw new PhpfastcacheInvalidTypeException(\sprintf('Cannot prepend on a "%s" type.', \gettype($this->data)));
-        }
-
-        if (\is_array($this->data)) {
-            \array_unshift($this->data, $data);
-        } else {
-            $this->data = $data . $this->data;
-        }
-
-        return $this;
-    }
-
-    /**
-     * Return the data as a well-formatted string.
-     * Any scalar value will be cast to an array
-     * @param int $options \json_encode() options
-     * @param int $depth \json_encode() depth
-     * @return string
-     */
-    public function getDataAsJsonString(int $options = JSON_THROW_ON_ERROR, int $depth = 512): string
-    {
-        $data = $this->get();
-
-        if (\is_object($data) || \is_array($data)) {
-            $data = \json_encode($data, $options, $depth);
-        } else {
-            $data = \json_encode([$data], $options, $depth);
-        }
-
-        return \json_encode($data, $options, $depth);
-    }
-
-    public function jsonSerialize(): mixed
-    {
-        return $this->get();
-    }
-
-    public function doesItemBelongToThatDriverBackend(ExtendedCacheItemPoolInterface $driverPool): bool
-    {
-        return $driverPool::getClassNamespace() === self::getClassNamespace();
-    }
-
-    abstract protected function getDriverClass(): string;
+	use CacheItemTrait;
+
+	protected ExtendedCacheItemPoolInterface $driver;
+
+	protected string $encodedKey;
+
+	/**
+	 * Item constructor.
+	 * @param ExtendedCacheItemPoolInterface $driver
+	 * @param string $key
+	 * @param EventManagerInterface $em
+	 * @throws PhpfastcacheInvalidArgumentException
+	 */
+	public function __construct(ExtendedCacheItemPoolInterface $driver, string $key, EventManagerInterface $em)
+	{
+		$this->data = null;
+		$this->key = $key;
+		$this->setEventManager($em);
+		$this->setDriver($driver);
+		if ($driver->getConfig()->isUseStaticItemCaching()) {
+			$this->driver->setItem($this);
+		}
+		$this->expirationDate = new DateTime();
+		if ($this->driver->getConfig()->isItemDetailedDate()) {
+			$this->creationDate = new DateTime();
+			$this->modificationDate = new DateTime();
+		}
+	}
+
+	/**
+	 * @param ExtendedCacheItemPoolInterface $driver
+	 * @return ExtendedCacheItemInterface
+	 * @throws PhpfastcacheInvalidArgumentException
+	 */
+	public function setDriver(ExtendedCacheItemPoolInterface $driver): ExtendedCacheItemInterface
+	{
+		$driverClass = $this->getDriverClass();
+		if ($driver instanceof $driverClass) {
+			$this->driver = $driver;
+
+			return $this;
+		}
+
+		throw new PhpfastcacheInvalidArgumentException(\sprintf('Invalid driver instance "%s" for cache item "%s"', $driver::class, static::class));
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function getEncodedKey(): string
+	{
+		if (!isset($this->encodedKey)) {
+			$this->encodedKey = $this->driver->getEncodedKey($this->getKey());
+		}
+
+		return $this->encodedKey;
+	}
+
+	/**
+	 * @inheritDoc
+	 * @SuppressWarnings(PHPMD.CamelCaseMethodName)
+	 */
+	public function _getData(): mixed // @phpcs:ignore
+	{
+		return $this->data;
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function getExpirationDate(): DateTimeInterface
+	{
+		return $this->expirationDate;
+	}
+
+	/**
+	 * @inheritDoc
+	 * @throws PhpfastcacheInvalidArgumentException
+	 */
+	public function setExpirationDate(DateTimeInterface $expiration): ExtendedCacheItemInterface
+	{
+		return $this->expiresAt($expiration);
+	}
+
+	/**
+	 * @inheritDoc
+	 * @throws PhpfastcacheLogicException
+	 */
+	public function getCreationDate(): DateTimeInterface
+	{
+		if ($this->driver->getConfig()->isItemDetailedDate()) {
+			return $this->creationDate;
+		}
+
+		throw new PhpfastcacheLogicException('Cannot access to the creation date when the "itemDetailedDate" configuration is disabled.');
+	}
+
+	/**
+	 * @inheritDoc
+	 * @throws PhpfastcacheLogicException
+	 */
+	public function setCreationDate(DateTimeInterface $date): ExtendedCacheItemInterface
+	{
+		if ($this->driver->getConfig()->isItemDetailedDate()) {
+			$this->creationDate = $this->demutateDatetime($date);
+			return $this;
+		}
+
+		throw new PhpfastcacheLogicException('Cannot access to the creation date when the "itemDetailedDate" configuration is disabled.');
+	}
+
+	/**
+	 * @inheritDoc
+	 * @throws PhpfastcacheLogicException
+	 */
+	public function getModificationDate(): DateTimeInterface
+	{
+		if ($this->driver->getConfig()->isItemDetailedDate()) {
+			return $this->modificationDate;
+		}
+
+		throw new PhpfastcacheLogicException('Cannot access to the modification date when the "itemDetailedDate" configuration is disabled.');
+	}
+
+	/**
+	 * @inheritDoc
+	 * @throws PhpfastcacheLogicException
+	 */
+	public function setModificationDate(DateTimeInterface $date): ExtendedCacheItemInterface
+	{
+		if ($this->driver->getConfig()->isItemDetailedDate()) {
+			$this->modificationDate = $this->demutateDatetime($date);
+			return $this;
+		}
+
+		throw new PhpfastcacheLogicException('Cannot access to the modification date when the "itemDetailedDate" configuration is disabled.');
+	}
+
+	public function getTtl(): int
+	{
+		return \max(0, $this->expirationDate->getTimestamp() - \time());
+	}
+
+	public function isExpired(): bool
+	{
+		return $this->getTtl() <= 0;
+	}
+
+	public function isNull(): bool
+	{
+		return $this->get() === null;
+	}
+
+	public function isEmpty(): bool
+	{
+		return empty($this->get());
+	}
+
+	/**
+	 * Return the data length:
+	 * Either the string length if it's a string (binary mode)
+	 * # or the number of element (count) if it's an array
+	 * # or the number returned by count() if it's an object implementing \Countable interface
+	 * # -1 for anything else
+	 * @return int
+	 */
+	public function getLength(): int
+	{
+		switch (\gettype($this->data)) {
+			case 'array':
+			case 'object':
+				if (\is_countable($this->data)) {
+					return \count($this->data);
+				}
+				break;
+
+			case 'string':
+				return \strlen($this->data);
+		}
+
+		return -1;
+	}
+
+	/**
+	 * @throws PhpfastcacheInvalidTypeException
+	 */
+	public function increment(int $step = 1): ExtendedCacheItemInterface
+	{
+		if ($this->data !== null && !\is_numeric($this->data)) {
+			throw new PhpfastcacheInvalidTypeException(\sprintf('Cannot increment on a "%s" type.', \gettype($this->data)));
+		}
+
+		$this->data += $step;
+
+		return $this;
+	}
+
+	/**
+	 * @throws PhpfastcacheInvalidTypeException
+	 */
+	public function decrement(int $step = 1): ExtendedCacheItemInterface
+	{
+		if ($this->data !== null && !\is_numeric($this->data)) {
+			throw new PhpfastcacheInvalidTypeException(\sprintf('Cannot decrement on a "%s" type.', \gettype($this->data)));
+		}
+
+		$this->data -= $step;
+
+		return $this;
+	}
+
+	/**
+	 * @throws PhpfastcacheInvalidTypeException
+	 */
+	public function append(array|string $data): ExtendedCacheItemInterface
+	{
+		if ($this->data !== null && !\is_string($this->data) && !\is_array($this->data)) {
+			throw new PhpfastcacheInvalidTypeException(\sprintf('Cannot append on a "%s" type.', \gettype($this->data)));
+		}
+
+		if (\is_array($this->data)) {
+			$this->data[] = $data;
+		} else {
+			$this->data .= $data;
+		}
+
+		return $this;
+	}
+
+	/**
+	 * @throws PhpfastcacheInvalidTypeException
+	 */
+	public function prepend(array|string $data): ExtendedCacheItemInterface
+	{
+		if ($this->data !== null && !\is_string($this->data) && !\is_array($this->data)) {
+			throw new PhpfastcacheInvalidTypeException(\sprintf('Cannot prepend on a "%s" type.', \gettype($this->data)));
+		}
+
+		if (\is_array($this->data)) {
+			\array_unshift($this->data, $data);
+		} else {
+			$this->data = $data . $this->data;
+		}
+
+		return $this;
+	}
+
+	/**
+	 * Return the data as a well-formatted string.
+	 * Any scalar value will be cast to an array
+	 * @param int $options \json_encode() options
+	 * @param int $depth \json_encode() depth
+	 * @return string
+	 */
+	public function getDataAsJsonString(int $options = JSON_THROW_ON_ERROR, int $depth = 512): string
+	{
+		$data = $this->get();
+
+		if (\is_object($data) || \is_array($data)) {
+			$data = \json_encode($data, $options, $depth);
+		} else {
+			$data = \json_encode([$data], $options, $depth);
+		}
+
+		return \json_encode($data, $options, $depth);
+	}
+
+	public function jsonSerialize(): mixed
+	{
+		return $this->get();
+	}
+
+	public function doesItemBelongToThatDriverBackend(ExtendedCacheItemPoolInterface $driverPool): bool
+	{
+		return $driverPool::getClassNamespace() === self::getClassNamespace();
+	}
+
+	abstract protected function getDriverClass(): string;
 }

plugins/files/php/vendor/phpfastcache/phpfastcache/lib/Phpfastcache/Core/Item/ExtendedCacheItemInterface.php

Indentation +176 added lines, -176 removed lines

@@ -27,181 +27,181 @@
 use Psr\Cache\CacheItemInterface;
 
 interface ExtendedCacheItemInterface extends
-    CacheItemInterface,
-    EventManagerDispatcherInterface,
-    ClassNamespaceResolverInterface,
-    JsonSerializable,
-    TaggableCacheItemInterface
+	CacheItemInterface,
+	EventManagerDispatcherInterface,
+	ClassNamespaceResolverInterface,
+	JsonSerializable,
+	TaggableCacheItemInterface
 {
-    /**
-     * Returns the encoded key for the current cache item.
-     * Is a MD5 (default),SHA1,SHA256 hash if "defaultKeyHashFunction" config option is configured
-     * Else return the plain cache item key "defaultKeyHashFunction" config option is emptied
-     *
-     * @return string
-     *   The encoded key string for this cache item.
-     */
-    public function getEncodedKey(): string;
-
-    /**
-     * Returns the cache item value, regardless of hit status.
-     * This method can be called if the cache item is NOT YET
-     * persisted, and you need to access to its set value.
-     *
-     * Although not part of the CacheItemInterface, this method is used by
-     * the pool for extracting information for saving.
-     *
-     * @return mixed
-     *
-     * @internal This method is used internally by phpfastcache, so you should not use it in your application.
-     * @SuppressWarnings(PHPMD.CamelCaseMethodName)
-     */
-    public function _getData(): mixed; // @phpcs:ignore
-
-    /**
-     * @return DateTimeInterface
-     */
-    public function getExpirationDate(): DateTimeInterface;
-
-    /**
-     * Alias of expireAt() with forced $expiration param
-     *
-     * @param DateTimeInterface $expiration
-     *   The point in time after which the item MUST be considered expired.
-     *   If null is passed explicitly, a default value MAY be used. If none is set,
-     *   the value should be stored permanently or for as long as the
-     *   implementation allows.
-     *
-     * @return ExtendedCacheItemInterface
-     *   The called object.
-     */
-    public function setExpirationDate(DateTimeInterface $expiration): ExtendedCacheItemInterface;
-
-    /**
-     * @return DateTimeInterface
-     * @throws PhpfastcacheLogicException
-     */
-    public function getCreationDate(): DateTimeInterface;
-
-    /**
-     * @return DateTimeInterface
-     * @throws PhpfastcacheLogicException
-     */
-    public function getModificationDate(): DateTimeInterface;
-
-    /**
-     * @param $date DateTimeInterface
-     *
-     * @return ExtendedCacheItemInterface
-     * @throws PhpfastcacheLogicException
-     */
-    public function setCreationDate(DateTimeInterface $date): ExtendedCacheItemInterface;
-
-    /**
-     * @param $date DateTimeInterface
-     *
-     * @return ExtendedCacheItemInterface
-     * @throws PhpfastcacheLogicException
-     */
-    public function setModificationDate(DateTimeInterface $date): ExtendedCacheItemInterface;
-
-    /**
-     * @return int
-     */
-    public function getTtl(): int;
-
-    /**
-     * @return bool
-     */
-    public function isExpired(): bool;
-
-    /**
-     * @return bool
-     */
-    public function isNull(): bool;
-
-    /**
-     * @return bool
-     */
-    public function isEmpty(): bool;
-
-    /**
-     * Return the data length:
-     * - Either the number of char if it's a string (binary mode)
-     * - or the number of element if it's an array
-     * - or the number returned by count() if it's an object implementing \Countable interface
-     * - or -1 for anything else
-     *
-     * @return int
-     */
-    public function getLength(): int;
-
-    /**
-     * @param ExtendedCacheItemPoolInterface $driver
-     *
-     * @return ExtendedCacheItemInterface
-     */
-    public function setDriver(ExtendedCacheItemPoolInterface $driver): ExtendedCacheItemInterface;
-
-    /**
-     * @param bool $isHit
-     *
-     * @return ExtendedCacheItemInterface
-     */
-    public function setHit(bool $isHit): ExtendedCacheItemInterface;
-
-    /**
-     * @param int $step
-     *
-     * @return ExtendedCacheItemInterface
-     * @throws PhpfastcacheInvalidTypeException
-     */
-    public function increment(int $step = 1): ExtendedCacheItemInterface;
-
-    /**
-     * @param int $step
-     *
-     * @return ExtendedCacheItemInterface
-     * @throws PhpfastcacheInvalidTypeException
-     */
-    public function decrement(int $step = 1): ExtendedCacheItemInterface;
-
-    /**
-     * @param mixed[]|string $data
-     *
-     * @return ExtendedCacheItemInterface
-     * @throws PhpfastcacheInvalidTypeException
-     */
-    public function append(array|string $data): ExtendedCacheItemInterface;
-
-    /**
-     * @param mixed[]|string $data
-     *
-     * @return ExtendedCacheItemInterface
-     * @throws PhpfastcacheInvalidTypeException
-     */
-    public function prepend(array|string $data): ExtendedCacheItemInterface;
-
-    /**
-     * Return the data as a well-formatted string.
-     * Any scalar value will be casted to an array
-     *
-     * @param int $options \json_encode() options
-     * @param int $depth \json_encode() depth
-     *
-     * @return string
-     */
-    public function getDataAsJsonString(int $options = JSON_THROW_ON_ERROR, int $depth = 512): string;
-
-    /**
-     * @param ExtendedCacheItemPoolInterface $driverPool
-     * @return bool
-     */
-    public function doesItemBelongToThatDriverBackend(ExtendedCacheItemPoolInterface $driverPool): bool;
-
-    /**
-     * @param ExtendedCacheItemInterface $itemTarget
-     * @param ExtendedCacheItemPoolInterface|null $itemPoolTarget
-     */
-    public function cloneInto(ExtendedCacheItemInterface $itemTarget, ?ExtendedCacheItemPoolInterface $itemPoolTarget = null): void;
+	/**
+	 * Returns the encoded key for the current cache item.
+	 * Is a MD5 (default),SHA1,SHA256 hash if "defaultKeyHashFunction" config option is configured
+	 * Else return the plain cache item key "defaultKeyHashFunction" config option is emptied
+	 *
+	 * @return string
+	 *   The encoded key string for this cache item.
+	 */
+	public function getEncodedKey(): string;
+
+	/**
+	 * Returns the cache item value, regardless of hit status.
+	 * This method can be called if the cache item is NOT YET
+	 * persisted, and you need to access to its set value.
+	 *
+	 * Although not part of the CacheItemInterface, this method is used by
+	 * the pool for extracting information for saving.
+	 *
+	 * @return mixed
+	 *
+	 * @internal This method is used internally by phpfastcache, so you should not use it in your application.
+	 * @SuppressWarnings(PHPMD.CamelCaseMethodName)
+	 */
+	public function _getData(): mixed; // @phpcs:ignore
+
+	/**
+	 * @return DateTimeInterface
+	 */
+	public function getExpirationDate(): DateTimeInterface;
+
+	/**
+	 * Alias of expireAt() with forced $expiration param
+	 *
+	 * @param DateTimeInterface $expiration
+	 *   The point in time after which the item MUST be considered expired.
+	 *   If null is passed explicitly, a default value MAY be used. If none is set,
+	 *   the value should be stored permanently or for as long as the
+	 *   implementation allows.
+	 *
+	 * @return ExtendedCacheItemInterface
+	 *   The called object.
+	 */
+	public function setExpirationDate(DateTimeInterface $expiration): ExtendedCacheItemInterface;
+
+	/**
+	 * @return DateTimeInterface
+	 * @throws PhpfastcacheLogicException
+	 */
+	public function getCreationDate(): DateTimeInterface;
+
+	/**
+	 * @return DateTimeInterface
+	 * @throws PhpfastcacheLogicException
+	 */
+	public function getModificationDate(): DateTimeInterface;
+
+	/**
+	 * @param $date DateTimeInterface
+	 *
+	 * @return ExtendedCacheItemInterface
+	 * @throws PhpfastcacheLogicException
+	 */
+	public function setCreationDate(DateTimeInterface $date): ExtendedCacheItemInterface;
+
+	/**
+	 * @param $date DateTimeInterface
+	 *
+	 * @return ExtendedCacheItemInterface
+	 * @throws PhpfastcacheLogicException
+	 */
+	public function setModificationDate(DateTimeInterface $date): ExtendedCacheItemInterface;
+
+	/**
+	 * @return int
+	 */
+	public function getTtl(): int;
+
+	/**
+	 * @return bool
+	 */
+	public function isExpired(): bool;
+
+	/**
+	 * @return bool
+	 */
+	public function isNull(): bool;
+
+	/**
+	 * @return bool
+	 */
+	public function isEmpty(): bool;
+
+	/**
+	 * Return the data length:
+	 * - Either the number of char if it's a string (binary mode)
+	 * - or the number of element if it's an array
+	 * - or the number returned by count() if it's an object implementing \Countable interface
+	 * - or -1 for anything else
+	 *
+	 * @return int
+	 */
+	public function getLength(): int;
+
+	/**
+	 * @param ExtendedCacheItemPoolInterface $driver
+	 *
+	 * @return ExtendedCacheItemInterface
+	 */
+	public function setDriver(ExtendedCacheItemPoolInterface $driver): ExtendedCacheItemInterface;
+
+	/**
+	 * @param bool $isHit
+	 *
+	 * @return ExtendedCacheItemInterface
+	 */
+	public function setHit(bool $isHit): ExtendedCacheItemInterface;
+
+	/**
+	 * @param int $step
+	 *
+	 * @return ExtendedCacheItemInterface
+	 * @throws PhpfastcacheInvalidTypeException
+	 */
+	public function increment(int $step = 1): ExtendedCacheItemInterface;
+
+	/**
+	 * @param int $step
+	 *
+	 * @return ExtendedCacheItemInterface
+	 * @throws PhpfastcacheInvalidTypeException
+	 */
+	public function decrement(int $step = 1): ExtendedCacheItemInterface;
+
+	/**
+	 * @param mixed[]|string $data
+	 *
+	 * @return ExtendedCacheItemInterface
+	 * @throws PhpfastcacheInvalidTypeException
+	 */
+	public function append(array|string $data): ExtendedCacheItemInterface;
+
+	/**
+	 * @param mixed[]|string $data
+	 *
+	 * @return ExtendedCacheItemInterface
+	 * @throws PhpfastcacheInvalidTypeException
+	 */
+	public function prepend(array|string $data): ExtendedCacheItemInterface;
+
+	/**
+	 * Return the data as a well-formatted string.
+	 * Any scalar value will be casted to an array
+	 *
+	 * @param int $options \json_encode() options
+	 * @param int $depth \json_encode() depth
+	 *
+	 * @return string
+	 */
+	public function getDataAsJsonString(int $options = JSON_THROW_ON_ERROR, int $depth = 512): string;
+
+	/**
+	 * @param ExtendedCacheItemPoolInterface $driverPool
+	 * @return bool
+	 */
+	public function doesItemBelongToThatDriverBackend(ExtendedCacheItemPoolInterface $driverPool): bool;
+
+	/**
+	 * @param ExtendedCacheItemInterface $itemTarget
+	 * @param ExtendedCacheItemPoolInterface|null $itemPoolTarget
+	 */
+	public function cloneInto(ExtendedCacheItemInterface $itemTarget, ?ExtendedCacheItemPoolInterface $itemPoolTarget = null): void;
 }

plugins/files/php/vendor/phpfastcache/phpfastcache/lib/Phpfastcache/Core/Item/CacheItemTrait.php

Indentation +119 added lines, -119 removed lines

@@ -27,123 +27,123 @@
 
 trait CacheItemTrait
 {
-    use EventManagerDispatcherTrait;
-    use ClassNamespaceResolverTrait;
-
-    protected string $key;
-
-    protected mixed $data;
-
-    protected DateTimeInterface $expirationDate;
-
-    protected DateTimeInterface $creationDate;
-
-    protected DateTimeInterface $modificationDate;
-
-    protected bool $isHit = false;
-
-    public function getKey(): string
-    {
-        return $this->key;
-    }
-
-    public function get(): mixed
-    {
-        if (!$this->isHit()) {
-            return null;
-        }
-
-        return $this->data;
-    }
-
-    /**
-     * @throws PhpfastcacheInvalidArgumentException
-     */
-    public function set(mixed $value): static
-    {
-        if ($value instanceof \Closure) {
-            throw new PhpfastcacheInvalidArgumentException('The value set cannot be an instance of \\Closure.');
-        }
-
-        if (\is_resource($value)) {
-            throw new PhpfastcacheInvalidArgumentException('The value set cannot be a resource');
-        }
-
-        $this->eventManager->dispatch(Event::CACHE_ITEM_SET, $this, new EventReferenceParameter($value, true));
-
-        $this->data = $value;
-
-        return $this;
-    }
-
-    /**
-     * @return bool
-     */
-    public function isHit(): bool
-    {
-        return $this->isHit;
-    }
-
-    /**
-     * @param bool $isHit
-     * @return ExtendedCacheItemInterface
-     */
-    public function setHit(bool $isHit): ExtendedCacheItemInterface
-    {
-        $this->isHit = $isHit;
-
-        return $this;
-    }
-
-    /**
-     * @throws PhpfastcacheInvalidArgumentException
-     */
-    public function expiresAt(?\DateTimeInterface $expiration): static
-    {
-        if ($expiration instanceof DateTimeInterface) {
-            $this->eventManager->dispatch(Event::CACHE_ITEM_EXPIRE_AT, $this, $expiration);
-            $this->expirationDate = $this->demutateDatetime($expiration);
-        } else {
-            throw new PhpfastcacheInvalidArgumentException('$expiration must be an object implementing the DateTimeInterface got: ' . \gettype($expiration));
-        }
-
-        return $this;
-    }
-
-    /**
-     * @return $this
-     * @throws PhpfastcacheInvalidArgumentException
-     * @throws \Exception
-     */
-    public function expiresAfter(int|\DateInterval|null $time): static
-    {
-        if (\is_numeric($time)) {
-            if ($time <= 0) {
-                /**
-                 * 5 months, however memcached or memory cached will be gone when u restart it
-                 * just recommended for sqlite. files
-                 */
-                $time = 30 * 24 * 3600 * 5;
-            }
-
-            $this->eventManager->dispatch(Event::CACHE_ITEM_EXPIRE_AFTER, $this, $time);
-
-            $this->expirationDate = (new DateTime())->add(new DateInterval(\sprintf('PT%dS', $time)));
-        } elseif ($time instanceof DateInterval) {
-            $this->eventManager->dispatch(Event::CACHE_ITEM_EXPIRE_AFTER, $this, $time);
-
-            $this->expirationDate = (new DateTime())->add($time);
-        } else {
-            throw new PhpfastcacheInvalidArgumentException(\sprintf('Invalid date format, got "%s"', \gettype($time)));
-        }
-
-        return $this;
-    }
-
-    protected function demutateDatetime(\DateTimeInterface $dateTime): \DateTimeInterface
-    {
-        return $dateTime instanceof \DateTimeImmutable
-            ? \DateTime::createFromImmutable($dateTime)
-            : $dateTime;
-    }
+	use EventManagerDispatcherTrait;
+	use ClassNamespaceResolverTrait;
+
+	protected string $key;
+
+	protected mixed $data;
+
+	protected DateTimeInterface $expirationDate;
+
+	protected DateTimeInterface $creationDate;
+
+	protected DateTimeInterface $modificationDate;
+
+	protected bool $isHit = false;
+
+	public function getKey(): string
+	{
+		return $this->key;
+	}
+
+	public function get(): mixed
+	{
+		if (!$this->isHit()) {
+			return null;
+		}
+
+		return $this->data;
+	}
+
+	/**
+	 * @throws PhpfastcacheInvalidArgumentException
+	 */
+	public function set(mixed $value): static
+	{
+		if ($value instanceof \Closure) {
+			throw new PhpfastcacheInvalidArgumentException('The value set cannot be an instance of \\Closure.');
+		}
+
+		if (\is_resource($value)) {
+			throw new PhpfastcacheInvalidArgumentException('The value set cannot be a resource');
+		}
+
+		$this->eventManager->dispatch(Event::CACHE_ITEM_SET, $this, new EventReferenceParameter($value, true));
+
+		$this->data = $value;
+
+		return $this;
+	}
+
+	/**
+	 * @return bool
+	 */
+	public function isHit(): bool
+	{
+		return $this->isHit;
+	}
+
+	/**
+	 * @param bool $isHit
+	 * @return ExtendedCacheItemInterface
+	 */
+	public function setHit(bool $isHit): ExtendedCacheItemInterface
+	{
+		$this->isHit = $isHit;
+
+		return $this;
+	}
+
+	/**
+	 * @throws PhpfastcacheInvalidArgumentException
+	 */
+	public function expiresAt(?\DateTimeInterface $expiration): static
+	{
+		if ($expiration instanceof DateTimeInterface) {
+			$this->eventManager->dispatch(Event::CACHE_ITEM_EXPIRE_AT, $this, $expiration);
+			$this->expirationDate = $this->demutateDatetime($expiration);
+		} else {
+			throw new PhpfastcacheInvalidArgumentException('$expiration must be an object implementing the DateTimeInterface got: ' . \gettype($expiration));
+		}
+
+		return $this;
+	}
+
+	/**
+	 * @return $this
+	 * @throws PhpfastcacheInvalidArgumentException
+	 * @throws \Exception
+	 */
+	public function expiresAfter(int|\DateInterval|null $time): static
+	{
+		if (\is_numeric($time)) {
+			if ($time <= 0) {
+				/**
+				 * 5 months, however memcached or memory cached will be gone when u restart it
+				 * just recommended for sqlite. files
+				 */
+				$time = 30 * 24 * 3600 * 5;
+			}
+
+			$this->eventManager->dispatch(Event::CACHE_ITEM_EXPIRE_AFTER, $this, $time);
+
+			$this->expirationDate = (new DateTime())->add(new DateInterval(\sprintf('PT%dS', $time)));
+		} elseif ($time instanceof DateInterval) {
+			$this->eventManager->dispatch(Event::CACHE_ITEM_EXPIRE_AFTER, $this, $time);
+
+			$this->expirationDate = (new DateTime())->add($time);
+		} else {
+			throw new PhpfastcacheInvalidArgumentException(\sprintf('Invalid date format, got "%s"', \gettype($time)));
+		}
+
+		return $this;
+	}
+
+	protected function demutateDatetime(\DateTimeInterface $dateTime): \DateTimeInterface
+	{
+		return $dateTime instanceof \DateTimeImmutable
+			? \DateTime::createFromImmutable($dateTime)
+			: $dateTime;
+	}
 }

plugins/files/php/vendor/phpfastcache/phpfastcache/lib/Phpfastcache/Core/Pool/ExtendedCacheItemPoolTrait.php

Indentation +105 added lines, -105 removed lines

@@ -27,109 +27,109 @@
 
 trait ExtendedCacheItemPoolTrait
 {
-    use CacheItemPoolTrait;
-    use AggregatablePoolTrait;
-
-    /**
-     * @inheritDoc
-     * @param string $pattern
-     * @return array<string, mixed>
-     */
-    public function getAllItems(string $pattern = ''): iterable
-    {
-        $driverReadAllKeysCallback = fn (string $pattern): iterable => $this->driverReadAllKeys($pattern);
-
-        /**
-         * This event allow you to customize the callback and wrap it to an invoker
-         * like SebastianBergmann\Invoke\Invoke, so you can set up custom timeouts.
-         */
-        $this->eventManager->dispatch(Event::CACHE_GET_ALL_ITEMS, $this, new EventReferenceParameter($driverReadAllKeysCallback));
-        $keys = $driverReadAllKeysCallback($pattern);
-
-        if (count($keys) > 0) {
-            return $this->getItems($keys instanceof \Traversable ? iterator_to_array($keys) : $keys);
-        }
-
-        return [];
-    }
-
-    /**
-     * @inheritDoc
-     * @throws PhpfastcacheCoreException
-     * @throws PhpfastcacheDriverException
-     * @throws PhpfastcacheInvalidArgumentException
-     * @throws PhpfastcacheLogicException
-     */
-    public function getItemsAsJsonString(array $keys = [], int $options = \JSON_THROW_ON_ERROR, int $depth = 512): string
-    {
-        return \json_encode(
-            \array_map(
-                static fn(CacheItemInterface $item) => $item->get(),
-                \array_values($this->getItems($keys))
-            ),
-            $options,
-            $depth
-        );
-    }
-
-    public function detachAllItems(): static
-    {
-        foreach ($this->itemInstances as $item) {
-            $this->detachItem($item);
-        }
-
-        return $this;
-    }
-
-    public function detachItem(CacheItemInterface $item): static
-    {
-        if (isset($this->itemInstances[$item->getKey()])) {
-            $this->deregisterItem($item->getKey());
-        }
-
-        return $this;
-    }
-
-    /**
-     * @param ExtendedCacheItemInterface ...$items
-     * @return bool
-     * @throws PhpfastcacheCoreException
-     * @throws PhpfastcacheDriverException
-     * @throws PhpfastcacheInvalidArgumentException
-     * @throws PhpfastcacheLogicException
-     */
-    public function saveMultiple(ExtendedCacheItemInterface ...$items): bool
-    {
-        $this->eventManager->dispatch(Event::CACHE_SAVE_MULTIPLE_ITEMS, $this, new EventReferenceParameter($items));
-
-        if (\count($items)) {
-            foreach ($items as $item) {
-                $this->save($item);
-            }
-            return true;
-        }
-        return false;
-    }
-
-    /**
-     * @return string
-     */
-    public function getHelp(): string
-    {
-        return '';
-    }
-
-    /**
-     * @throws PhpfastcacheInvalidArgumentException
-     */
-    public function throwUnsupportedDriverReadAllPattern(string $linkReference = ''): void
-    {
-        throw new PhpfastcacheInvalidArgumentException(
-            sprintf(
-                '%s does not support a pattern argument.%s',
-                $this->getDriverName(),
-                $linkReference ? " See $linkReference" : ''
-            )
-        );
-    }
+	use CacheItemPoolTrait;
+	use AggregatablePoolTrait;
+
+	/**
+	 * @inheritDoc
+	 * @param string $pattern
+	 * @return array<string, mixed>
+	 */
+	public function getAllItems(string $pattern = ''): iterable
+	{
+		$driverReadAllKeysCallback = fn (string $pattern): iterable => $this->driverReadAllKeys($pattern);
+
+		/**
+		 * This event allow you to customize the callback and wrap it to an invoker
+		 * like SebastianBergmann\Invoke\Invoke, so you can set up custom timeouts.
+		 */
+		$this->eventManager->dispatch(Event::CACHE_GET_ALL_ITEMS, $this, new EventReferenceParameter($driverReadAllKeysCallback));
+		$keys = $driverReadAllKeysCallback($pattern);
+
+		if (count($keys) > 0) {
+			return $this->getItems($keys instanceof \Traversable ? iterator_to_array($keys) : $keys);
+		}
+
+		return [];
+	}
+
+	/**
+	 * @inheritDoc
+	 * @throws PhpfastcacheCoreException
+	 * @throws PhpfastcacheDriverException
+	 * @throws PhpfastcacheInvalidArgumentException
+	 * @throws PhpfastcacheLogicException
+	 */
+	public function getItemsAsJsonString(array $keys = [], int $options = \JSON_THROW_ON_ERROR, int $depth = 512): string
+	{
+		return \json_encode(
+			\array_map(
+				static fn(CacheItemInterface $item) => $item->get(),
+				\array_values($this->getItems($keys))
+			),
+			$options,
+			$depth
+		);
+	}
+
+	public function detachAllItems(): static
+	{
+		foreach ($this->itemInstances as $item) {
+			$this->detachItem($item);
+		}
+
+		return $this;
+	}
+
+	public function detachItem(CacheItemInterface $item): static
+	{
+		if (isset($this->itemInstances[$item->getKey()])) {
+			$this->deregisterItem($item->getKey());
+		}
+
+		return $this;
+	}
+
+	/**
+	 * @param ExtendedCacheItemInterface ...$items
+	 * @return bool
+	 * @throws PhpfastcacheCoreException
+	 * @throws PhpfastcacheDriverException
+	 * @throws PhpfastcacheInvalidArgumentException
+	 * @throws PhpfastcacheLogicException
+	 */
+	public function saveMultiple(ExtendedCacheItemInterface ...$items): bool
+	{
+		$this->eventManager->dispatch(Event::CACHE_SAVE_MULTIPLE_ITEMS, $this, new EventReferenceParameter($items));
+
+		if (\count($items)) {
+			foreach ($items as $item) {
+				$this->save($item);
+			}
+			return true;
+		}
+		return false;
+	}
+
+	/**
+	 * @return string
+	 */
+	public function getHelp(): string
+	{
+		return '';
+	}
+
+	/**
+	 * @throws PhpfastcacheInvalidArgumentException
+	 */
+	public function throwUnsupportedDriverReadAllPattern(string $linkReference = ''): void
+	{
+		throw new PhpfastcacheInvalidArgumentException(
+			sprintf(
+				'%s does not support a pattern argument.%s',
+				$this->getDriverName(),
+				$linkReference ? " See $linkReference" : ''
+			)
+		);
+	}
 }

plugins/files/php/vendor/phpfastcache/phpfastcache/lib/Phpfastcache/Core/Pool/CacheItemPoolTrait.php

Indentation +584 added lines, -584 removed lines

@@ -41,590 +41,590 @@
  */
 trait CacheItemPoolTrait
 {
-    use DriverBaseTrait {
-        DriverBaseTrait::__construct as __driverBaseConstruct;
-    }
-
-    /**
-     * @var string
-     */
-    protected static string $unsupportedKeyChars = '{}()/\@:';
-
-    /**
-     * @var ExtendedCacheItemInterface[]|CacheItemInterface[]
-     */
-    protected array $deferredList = [];
-
-    /**
-     * @var ExtendedCacheItemInterface[]|CacheItemInterface[]
-     */
-    protected array $itemInstances = [];
-
-    protected DriverIO $IO;
-
-    public function __construct(#[\SensitiveParameter] ConfigurationOptionInterface $config, string $instanceId, EventManagerInterface $em)
-    {
-        $this->IO = new DriverIO();
-        $this->__driverBaseConstruct($config, $instanceId, $em);
-    }
-
-    /**
-     * @throws PhpfastcacheLogicException
-     * @throws PhpfastcacheInvalidArgumentException
-     */
-    public function setItem(CacheItemInterface $item): static
-    {
-        if (self::getItemClass() === $item::class) {
-            if (!$this->getConfig()->isUseStaticItemCaching()) {
-                throw new PhpfastcacheLogicException(
-                    'The static item caching option (useStaticItemCaching) is disabled so you cannot attach an item.'
-                );
-            }
-
-            $this->itemInstances[$item->getKey()] = $item;
-
-            return $this;
-        }
-        throw new PhpfastcacheInvalidArgumentException(
-            \sprintf(
-                'Invalid cache item class "%s" for driver "%s".',
-                get_class($item),
-                get_class($this)
-            )
-        );
-    }
-
-    /**
-     * @inheritDoc
-     * @throws PhpfastcacheCoreException
-     * @throws PhpfastcacheDriverException
-     * @throws PhpfastcacheInvalidArgumentException
-     * @throws PhpfastcacheLogicException
-     */
-    public function getItems(array $keys = []): iterable
-    {
-        $items = [];
-
-        /**
-         * Usually, drivers that are able to enable cache slams
-         * does not benefit of driverReadMultiple() call.
-         */
-        if (!$this->getConfig()->isPreventCacheSlams()) {
-            $this->validateCacheKeys(...$keys);
-
-            /**
-             * Check for local item instances first.
-             */
-            foreach ($keys as $index => $key) {
-                if (isset($this->itemInstances[$key]) && $this->getConfig()->isUseStaticItemCaching()) {
-                    $items[$key] = $this->itemInstances[$key];
-                    // Key already exists in local item instances, no need to fetch it again.
-                    unset($keys[$index]);
-                }
-            }
-            $keys = array_values($keys);
-
-            /**
-             * If there's still keys to fetch, let's choose the right method (if supported).
-             */
-            if (count($keys) > 1) {
-                $items = array_merge(
-                    array_combine($keys, array_map(fn($key) => new (self::getItemClass())($this, $key, $this->eventManager), $keys)),
-                    $items
-                );
-
-                try {
-                    $driverArrays = $this->driverReadMultiple(...$items);
-                } catch (PhpfastcacheUnsupportedMethodException) {
-                    /**
-                     * Fallback for drivers that does not yet implement driverReadMultiple() method.
-                     */
-                    $driverArrays = array_combine(
-                        array_map(fn($item) => $item->getKey(), $items),
-                        array_map(fn($item) => $this->driverRead($item), $items)
-                    );
-                } finally {
-                    foreach ($items as $item) {
-                        $driverArray = $driverArrays[$item->getKey()] ?? null;
-                        if ($driverArray !== null) {
-                            $item->set($this->driverUnwrapData($driverArray));
-                            $item->expiresAt($this->driverUnwrapEdate($driverArray));
-                            if ($this->getConfig()->isItemDetailedDate()) {
-                                /**
-                                 * If the itemDetailedDate has been
-                                 * set after caching, we MUST inject
-                                 * a new DateTime object on the fly
-                                 */
-                                $item->setCreationDate($this->driverUnwrapCdate($driverArray) ?: new DateTime());
-                                $item->setModificationDate($this->driverUnwrapMdate($driverArray) ?: new DateTime());
-                            }
-                            $item->setTags($this->driverUnwrapTags($driverArray));
-                            $this->handleExpiredCacheItem($item);
-                        } else {
-                            $item->expiresAfter((int) abs($this->getConfig()->getDefaultTtl()));
-                        }
-                        $item->isHit() ? $this->getIO()->incReadHit() : $this->getIO()->incReadMiss();
-                    }
-                }
-            } else {
-                $index = array_key_first($keys);
-                if ($index !== null) {
-                    $items[$keys[$index]] = $this->getItem($keys[$index]);
-                }
-            }
-        } else {
-            $collection = [];
-
-            foreach ($keys as $key) {
-                $collection[$key] = $this->getItem($key);
-            }
-
-            return $collection;
-        }
-
-        $this->eventManager->dispatch(Event::CACHE_GET_ITEMS, $this, $items);
-
-        return $items;
-    }
-
-    /**
-     * @param string $key
-     * @return ExtendedCacheItemInterface
-     * @throws PhpfastcacheCoreException
-     * @throws PhpfastcacheInvalidArgumentException
-     * @throws PhpfastcacheLogicException
-     * @throws PhpfastcacheDriverException
-     *
-     * @SuppressWarnings(PHPMD.NPathComplexity)
-     * @SuppressWarnings(PHPMD.GotoStatement)
-     */
-    public function getItem(string $key): ExtendedCacheItemInterface
-    {
-        /**
-         * Replace array_key_exists by isset
-         * due to performance issue on huge
-         * loop dispatching operations
-         */
-        if (!isset($this->itemInstances[$key]) || !$this->getConfig()->isUseStaticItemCaching()) {
-            $this->validateCacheKeys($key);
-
-            /** @var $item ExtendedCacheItemInterface */
-            $item = new (self::getItemClass())($this, $key, $this->eventManager);
-
-            $getItemDriverRead = function (float $cacheSlamsSpendSeconds = 0) use (&$getItemDriverRead, $item): void {
-                $config = $this->getConfig();
-
-                $driverArray = $this->driverRead($item);
-
-                if ($driverArray) {
-                    $driverData = $this->driverUnwrapData($driverArray);
-
-                    if ($config instanceof IOConfigurationOptionInterface && $config->isPreventCacheSlams()) {
-                        while ($driverData instanceof ItemBatch) {
-                            if ($driverData->getItemDate()->getTimestamp() + $config->getCacheSlamsTimeout() < \time()) {
-                                /**
-                                 * The timeout has been reached
-                                 * Consider that the batch has
-                                 * failed and serve an empty item
-                                 * to avoid get stuck with a
-                                 * batch item stored in driver
-                                 */
-                                $this->handleExpiredCacheItem($item);
-                                return;
-                            }
-
-                            $this->eventManager->dispatch(Event::CACHE_GET_ITEM_IN_SLAM_BATCH, $this, $driverData, $cacheSlamsSpendSeconds);
-
-                            /**
-                             * Wait for a second before
-                             * attempting to get exit
-                             * the current batch process
-                             */
-                            \usleep(100000);
-
-                            $getItemDriverRead($cacheSlamsSpendSeconds + 0.1);
-                        }
-                    }
-
-                    $item->set($driverData);
-                    $item->expiresAt($this->driverUnwrapEdate($driverArray));
-
-                    if ($this->getConfig()->isItemDetailedDate()) {
-                        /**
-                         * If the itemDetailedDate has been
-                         * set after caching, we MUST inject
-                         * a new DateTime object on the fly
-                         */
-                        $item->setCreationDate($this->driverUnwrapCdate($driverArray) ?: new DateTime());
-                        $item->setModificationDate($this->driverUnwrapMdate($driverArray) ?: new DateTime());
-                    }
-
-                    $item->setTags($this->driverUnwrapTags($driverArray));
-                    $this->handleExpiredCacheItem($item);
-                } else {
-                    $item->expiresAfter((int) abs($this->getConfig()->getDefaultTtl()));
-                }
-            };
-            $getItemDriverRead();
-        } else {
-            $item = $this->itemInstances[$key];
-        }
-
-        $this->eventManager->dispatch(Event::CACHE_GET_ITEM, $this, $item);
-
-        $item->isHit() ? $this->getIO()->incReadHit() : $this->getIO()->incReadMiss();
-
-        return $item;
-    }
-
-    /**
-     * @param string $key
-     * @return bool
-     * @throws PhpfastcacheCoreException
-     * @throws PhpfastcacheDriverException
-     * @throws PhpfastcacheInvalidArgumentException
-     * @throws PhpfastcacheLogicException
-     */
-    public function hasItem(string $key): bool
-    {
-        return $this->getItem($key)->isHit();
-    }
-
-    /**
-     * @return bool
-     * @throws PhpfastcacheCoreException
-     * @throws PhpfastcacheDriverException
-     * @throws PhpfastcacheLogicException
-     * @throws PhpfastcacheIOException
-     */
-    public function clear(): bool
-    {
-        $this->eventManager->dispatch(Event::CACHE_CLEAR_ITEM, $this, $this->itemInstances);
-
-        $this->getIO()->incWriteHit();
-        // Faster than detachAllItems()
-        $this->itemInstances = [];
-
-        return $this->driverClear();
-    }
-
-    /**
-     * @inheritDoc
-     * @throws PhpfastcacheCoreException
-     * @throws PhpfastcacheDriverException
-     * @throws PhpfastcacheInvalidArgumentException
-     * @throws PhpfastcacheLogicException
-     */
-    public function deleteItems(array $keys): bool
-    {
-        if (count($keys) > 1) {
-            $return = true;
-            try {
-                $items = $this->getItems($keys);
-                $return = $this->driverDeleteMultiple($keys);
-                foreach ($items as $item) {
-                    $item->setHit(false);
-
-                    if (!\str_starts_with($item->getKey(), TaggableCacheItemPoolInterface::DRIVER_TAGS_KEY_PREFIX)) {
-                        $this->cleanItemTags($item);
-                    }
-                }
-                $this->getIO()->incWriteHit();
-                $this->eventManager->dispatch(Event::CACHE_DELETE_ITEMS, $this, $items);
-                $this->deregisterItems($keys);
-            } catch (PhpfastcacheUnsupportedMethodException) {
-                foreach ($keys as $key) {
-                    $result = $this->deleteItem($key);
-                    if ($result !== true) {
-                        $return = false;
-                    }
-                }
-            }
-
-            return $return;
-        }
-
-        $index = array_key_first($keys);
-        if ($index !== null) {
-            return $this->deleteItem($keys[$index]);
-        }
-
-        return false;
-    }
-
-    /**
-     * @param string $key
-     * @return bool
-     * @throws PhpfastcacheCoreException
-     * @throws PhpfastcacheDriverException
-     * @throws PhpfastcacheInvalidArgumentException
-     * @throws PhpfastcacheLogicException
-     */
-    public function deleteItem(string $key): bool
-    {
-        $item = $this->getItem($key);
-        if ($item->isHit()) {
-            $result = $this->driverDelete($item->getKey(), $item->getEncodedKey());
-            $item->setHit(false);
-            $this->getIO()->incWriteHit();
-
-            $this->eventManager->dispatch(Event::CACHE_DELETE_ITEM, $this, $item);
-
-            /**
-             * De-register the item instance
-             * then collect gc cycles
-             */
-            $this->deregisterItem($key);
-
-            /**
-             * Perform a tag cleanup to avoid memory leaks
-             */
-            if (!\str_starts_with($key, TaggableCacheItemPoolInterface::DRIVER_TAGS_KEY_PREFIX)) {
-                $this->cleanItemTags($item);
-            }
-
-            return $result;
-        }
-
-        return false;
-    }
-
-    /**
-     * @param CacheItemInterface $item
-     * @return bool
-     */
-    public function saveDeferred(CacheItemInterface $item): bool
-    {
-        $this->assertCacheItemType($item, self::getItemClass());
-        if (!\array_key_exists($item->getKey(), $this->itemInstances)) {
-            $this->itemInstances[$item->getKey()] = $item;
-        } elseif (\spl_object_hash($item) !== \spl_object_hash($this->itemInstances[$item->getKey()])) {
-            throw new RuntimeException('Spl object hash mismatches ! You probably tried to save a detached item which has been already retrieved from cache.');
-        }
-
-        $this->eventManager->dispatch(Event::CACHE_SAVE_DEFERRED_ITEM, $this, $item);
-        $this->deferredList[$item->getKey()] = $item;
-
-        return true;
-    }
-
-    /**
-     * @return bool
-     * @throws PhpfastcacheCoreException
-     * @throws PhpfastcacheDriverException
-     * @throws PhpfastcacheInvalidArgumentException
-     * @throws PhpfastcacheLogicException
-     */
-    public function commit(): bool
-    {
-        $this->eventManager->dispatch(Event::CACHE_COMMIT_ITEM, $this, new EventReferenceParameter($this->deferredList));
-
-        if (\count($this->deferredList)) {
-            $return = true;
-            foreach ($this->deferredList as $key => $item) {
-                $result = $this->save($item);
-                unset($this->deferredList[$key]);
-                if ($result !== true) {
-                    $return = $result;
-                }
-            }
-
-            return $return;
-        }
-        return false;
-    }
-
-    /**
-     * @param CacheItemInterface $item
-     * @return bool
-     * @throws PhpfastcacheCoreException
-     * @throws PhpfastcacheDriverException
-     * @throws PhpfastcacheIOException
-     * @throws PhpfastcacheInvalidArgumentException
-     * @throws PhpfastcacheLogicException
-     */
-    public function save(CacheItemInterface $item): bool
-    {
-        $this->assertCacheItemType($item, self::getItemClass());
-        /**
-         * @var ExtendedCacheItemInterface $item
-         *
-         * Replace array_key_exists by isset
-         * due to performance issue on huge
-         * loop dispatching operations
-         */
-        if (!isset($this->itemInstances[$item->getKey()])) {
-            if ($this->getConfig()->isUseStaticItemCaching()) {
-                $this->itemInstances[$item->getKey()] = $item;
-            }
-        } elseif (\spl_object_hash($item) !== \spl_object_hash($this->itemInstances[$item->getKey()])) {
-            throw new RuntimeException('Spl object hash mismatches ! You probably tried to save a detached item which has been already retrieved from cache.');
-        }
-
-        $this->assertCacheItemType($item, self::getItemClass());
-        $this->eventManager->dispatch(Event::CACHE_SAVE_ITEM, $this, $item);
-
-        if ($this->getConfig() instanceof IOConfigurationOptionInterface && $this->getConfig()->isPreventCacheSlams()) {
-            /**
-             * @var $itemBatch ExtendedCacheItemInterface
-             */
-            $itemClassName = self::getItemClass();
-            $itemBatch = new $itemClassName($this, $item->getKey(), $this->eventManager);
-            $itemBatch->set(new ItemBatch($item->getKey(), new DateTime()))
-                ->expiresAfter($this->getConfig()->getCacheSlamsTimeout());
-
-            /**
-             * To avoid SPL mismatches
-             * we have to re-attach the
-             * original item to the pool
-             */
-            $this->driverWrite($itemBatch);
-            $this->detachItem($itemBatch);
-            $this->attachItem($item);
-        }
-
-
-        if ($this->driverWrite($item) && $this->driverWriteTags($item)) {
-            $item->setHit(true)
-                ->clearRemovedTags();
-
-            if ($this->getConfig()->isItemDetailedDate()) {
-                $item->setModificationDate(new \DateTime());
-            }
-
-            $this->getIO()->incWriteHit();
-
-            return true;
-        }
-
-        return false;
-    }
-
-    /**
-     * @return DriverIO
-     */
-    public function getIO(): DriverIO
-    {
-        return $this->IO;
-    }
-
-    /**
-     * @internal This method de-register an item from $this->itemInstances
-     */
-    protected function deregisterItem(string $itemKey): static
-    {
-        unset($this->itemInstances[$itemKey]);
-
-        if (\gc_enabled()) {
-            \gc_collect_cycles();
-        }
-
-        return $this;
-    }
-
-    /**
-     * @param string[] $itemKeys
-     * @internal This method de-register multiple items from $this->itemInstances
-     */
-    protected function deregisterItems(array $itemKeys): static
-    {
-        $this->itemInstances = array_diff_key($this->itemInstances, array_flip($itemKeys));
-
-        if (\gc_enabled()) {
-            \gc_collect_cycles();
-        }
-
-        return $this;
-    }
-
-    /**
-     * @throws PhpfastcacheLogicException
-     */
-    public function attachItem(CacheItemInterface $item): static
-    {
-        if (isset($this->itemInstances[$item->getKey()]) && \spl_object_hash($item) !== \spl_object_hash($this->itemInstances[$item->getKey()])) {
-            throw new PhpfastcacheLogicException(
-                'The item already exists and cannot be overwritten because the Spl object hash mismatches ! 
+	use DriverBaseTrait {
+		DriverBaseTrait::__construct as __driverBaseConstruct;
+	}
+
+	/**
+	 * @var string
+	 */
+	protected static string $unsupportedKeyChars = '{}()/\@:';
+
+	/**
+	 * @var ExtendedCacheItemInterface[]|CacheItemInterface[]
+	 */
+	protected array $deferredList = [];
+
+	/**
+	 * @var ExtendedCacheItemInterface[]|CacheItemInterface[]
+	 */
+	protected array $itemInstances = [];
+
+	protected DriverIO $IO;
+
+	public function __construct(#[\SensitiveParameter] ConfigurationOptionInterface $config, string $instanceId, EventManagerInterface $em)
+	{
+		$this->IO = new DriverIO();
+		$this->__driverBaseConstruct($config, $instanceId, $em);
+	}
+
+	/**
+	 * @throws PhpfastcacheLogicException
+	 * @throws PhpfastcacheInvalidArgumentException
+	 */
+	public function setItem(CacheItemInterface $item): static
+	{
+		if (self::getItemClass() === $item::class) {
+			if (!$this->getConfig()->isUseStaticItemCaching()) {
+				throw new PhpfastcacheLogicException(
+					'The static item caching option (useStaticItemCaching) is disabled so you cannot attach an item.'
+				);
+			}
+
+			$this->itemInstances[$item->getKey()] = $item;
+
+			return $this;
+		}
+		throw new PhpfastcacheInvalidArgumentException(
+			\sprintf(
+				'Invalid cache item class "%s" for driver "%s".',
+				get_class($item),
+				get_class($this)
+			)
+		);
+	}
+
+	/**
+	 * @inheritDoc
+	 * @throws PhpfastcacheCoreException
+	 * @throws PhpfastcacheDriverException
+	 * @throws PhpfastcacheInvalidArgumentException
+	 * @throws PhpfastcacheLogicException
+	 */
+	public function getItems(array $keys = []): iterable
+	{
+		$items = [];
+
+		/**
+		 * Usually, drivers that are able to enable cache slams
+		 * does not benefit of driverReadMultiple() call.
+		 */
+		if (!$this->getConfig()->isPreventCacheSlams()) {
+			$this->validateCacheKeys(...$keys);
+
+			/**
+			 * Check for local item instances first.
+			 */
+			foreach ($keys as $index => $key) {
+				if (isset($this->itemInstances[$key]) && $this->getConfig()->isUseStaticItemCaching()) {
+					$items[$key] = $this->itemInstances[$key];
+					// Key already exists in local item instances, no need to fetch it again.
+					unset($keys[$index]);
+				}
+			}
+			$keys = array_values($keys);
+
+			/**
+			 * If there's still keys to fetch, let's choose the right method (if supported).
+			 */
+			if (count($keys) > 1) {
+				$items = array_merge(
+					array_combine($keys, array_map(fn($key) => new (self::getItemClass())($this, $key, $this->eventManager), $keys)),
+					$items
+				);
+
+				try {
+					$driverArrays = $this->driverReadMultiple(...$items);
+				} catch (PhpfastcacheUnsupportedMethodException) {
+					/**
+					 * Fallback for drivers that does not yet implement driverReadMultiple() method.
+					 */
+					$driverArrays = array_combine(
+						array_map(fn($item) => $item->getKey(), $items),
+						array_map(fn($item) => $this->driverRead($item), $items)
+					);
+				} finally {
+					foreach ($items as $item) {
+						$driverArray = $driverArrays[$item->getKey()] ?? null;
+						if ($driverArray !== null) {
+							$item->set($this->driverUnwrapData($driverArray));
+							$item->expiresAt($this->driverUnwrapEdate($driverArray));
+							if ($this->getConfig()->isItemDetailedDate()) {
+								/**
+								 * If the itemDetailedDate has been
+								 * set after caching, we MUST inject
+								 * a new DateTime object on the fly
+								 */
+								$item->setCreationDate($this->driverUnwrapCdate($driverArray) ?: new DateTime());
+								$item->setModificationDate($this->driverUnwrapMdate($driverArray) ?: new DateTime());
+							}
+							$item->setTags($this->driverUnwrapTags($driverArray));
+							$this->handleExpiredCacheItem($item);
+						} else {
+							$item->expiresAfter((int) abs($this->getConfig()->getDefaultTtl()));
+						}
+						$item->isHit() ? $this->getIO()->incReadHit() : $this->getIO()->incReadMiss();
+					}
+				}
+			} else {
+				$index = array_key_first($keys);
+				if ($index !== null) {
+					$items[$keys[$index]] = $this->getItem($keys[$index]);
+				}
+			}
+		} else {
+			$collection = [];
+
+			foreach ($keys as $key) {
+				$collection[$key] = $this->getItem($key);
+			}
+
+			return $collection;
+		}
+
+		$this->eventManager->dispatch(Event::CACHE_GET_ITEMS, $this, $items);
+
+		return $items;
+	}
+
+	/**
+	 * @param string $key
+	 * @return ExtendedCacheItemInterface
+	 * @throws PhpfastcacheCoreException
+	 * @throws PhpfastcacheInvalidArgumentException
+	 * @throws PhpfastcacheLogicException
+	 * @throws PhpfastcacheDriverException
+	 *
+	 * @SuppressWarnings(PHPMD.NPathComplexity)
+	 * @SuppressWarnings(PHPMD.GotoStatement)
+	 */
+	public function getItem(string $key): ExtendedCacheItemInterface
+	{
+		/**
+		 * Replace array_key_exists by isset
+		 * due to performance issue on huge
+		 * loop dispatching operations
+		 */
+		if (!isset($this->itemInstances[$key]) || !$this->getConfig()->isUseStaticItemCaching()) {
+			$this->validateCacheKeys($key);
+
+			/** @var $item ExtendedCacheItemInterface */
+			$item = new (self::getItemClass())($this, $key, $this->eventManager);
+
+			$getItemDriverRead = function (float $cacheSlamsSpendSeconds = 0) use (&$getItemDriverRead, $item): void {
+				$config = $this->getConfig();
+
+				$driverArray = $this->driverRead($item);
+
+				if ($driverArray) {
+					$driverData = $this->driverUnwrapData($driverArray);
+
+					if ($config instanceof IOConfigurationOptionInterface && $config->isPreventCacheSlams()) {
+						while ($driverData instanceof ItemBatch) {
+							if ($driverData->getItemDate()->getTimestamp() + $config->getCacheSlamsTimeout() < \time()) {
+								/**
+								 * The timeout has been reached
+								 * Consider that the batch has
+								 * failed and serve an empty item
+								 * to avoid get stuck with a
+								 * batch item stored in driver
+								 */
+								$this->handleExpiredCacheItem($item);
+								return;
+							}
+
+							$this->eventManager->dispatch(Event::CACHE_GET_ITEM_IN_SLAM_BATCH, $this, $driverData, $cacheSlamsSpendSeconds);
+
+							/**
+							 * Wait for a second before
+							 * attempting to get exit
+							 * the current batch process
+							 */
+							\usleep(100000);
+
+							$getItemDriverRead($cacheSlamsSpendSeconds + 0.1);
+						}
+					}
+
+					$item->set($driverData);
+					$item->expiresAt($this->driverUnwrapEdate($driverArray));
+
+					if ($this->getConfig()->isItemDetailedDate()) {
+						/**
+						 * If the itemDetailedDate has been
+						 * set after caching, we MUST inject
+						 * a new DateTime object on the fly
+						 */
+						$item->setCreationDate($this->driverUnwrapCdate($driverArray) ?: new DateTime());
+						$item->setModificationDate($this->driverUnwrapMdate($driverArray) ?: new DateTime());
+					}
+
+					$item->setTags($this->driverUnwrapTags($driverArray));
+					$this->handleExpiredCacheItem($item);
+				} else {
+					$item->expiresAfter((int) abs($this->getConfig()->getDefaultTtl()));
+				}
+			};
+			$getItemDriverRead();
+		} else {
+			$item = $this->itemInstances[$key];
+		}
+
+		$this->eventManager->dispatch(Event::CACHE_GET_ITEM, $this, $item);
+
+		$item->isHit() ? $this->getIO()->incReadHit() : $this->getIO()->incReadMiss();
+
+		return $item;
+	}
+
+	/**
+	 * @param string $key
+	 * @return bool
+	 * @throws PhpfastcacheCoreException
+	 * @throws PhpfastcacheDriverException
+	 * @throws PhpfastcacheInvalidArgumentException
+	 * @throws PhpfastcacheLogicException
+	 */
+	public function hasItem(string $key): bool
+	{
+		return $this->getItem($key)->isHit();
+	}
+
+	/**
+	 * @return bool
+	 * @throws PhpfastcacheCoreException
+	 * @throws PhpfastcacheDriverException
+	 * @throws PhpfastcacheLogicException
+	 * @throws PhpfastcacheIOException
+	 */
+	public function clear(): bool
+	{
+		$this->eventManager->dispatch(Event::CACHE_CLEAR_ITEM, $this, $this->itemInstances);
+
+		$this->getIO()->incWriteHit();
+		// Faster than detachAllItems()
+		$this->itemInstances = [];
+
+		return $this->driverClear();
+	}
+
+	/**
+	 * @inheritDoc
+	 * @throws PhpfastcacheCoreException
+	 * @throws PhpfastcacheDriverException
+	 * @throws PhpfastcacheInvalidArgumentException
+	 * @throws PhpfastcacheLogicException
+	 */
+	public function deleteItems(array $keys): bool
+	{
+		if (count($keys) > 1) {
+			$return = true;
+			try {
+				$items = $this->getItems($keys);
+				$return = $this->driverDeleteMultiple($keys);
+				foreach ($items as $item) {
+					$item->setHit(false);
+
+					if (!\str_starts_with($item->getKey(), TaggableCacheItemPoolInterface::DRIVER_TAGS_KEY_PREFIX)) {
+						$this->cleanItemTags($item);
+					}
+				}
+				$this->getIO()->incWriteHit();
+				$this->eventManager->dispatch(Event::CACHE_DELETE_ITEMS, $this, $items);
+				$this->deregisterItems($keys);
+			} catch (PhpfastcacheUnsupportedMethodException) {
+				foreach ($keys as $key) {
+					$result = $this->deleteItem($key);
+					if ($result !== true) {
+						$return = false;
+					}
+				}
+			}
+
+			return $return;
+		}
+
+		$index = array_key_first($keys);
+		if ($index !== null) {
+			return $this->deleteItem($keys[$index]);
+		}
+
+		return false;
+	}
+
+	/**
+	 * @param string $key
+	 * @return bool
+	 * @throws PhpfastcacheCoreException
+	 * @throws PhpfastcacheDriverException
+	 * @throws PhpfastcacheInvalidArgumentException
+	 * @throws PhpfastcacheLogicException
+	 */
+	public function deleteItem(string $key): bool
+	{
+		$item = $this->getItem($key);
+		if ($item->isHit()) {
+			$result = $this->driverDelete($item->getKey(), $item->getEncodedKey());
+			$item->setHit(false);
+			$this->getIO()->incWriteHit();
+
+			$this->eventManager->dispatch(Event::CACHE_DELETE_ITEM, $this, $item);
+
+			/**
+			 * De-register the item instance
+			 * then collect gc cycles
+			 */
+			$this->deregisterItem($key);
+
+			/**
+			 * Perform a tag cleanup to avoid memory leaks
+			 */
+			if (!\str_starts_with($key, TaggableCacheItemPoolInterface::DRIVER_TAGS_KEY_PREFIX)) {
+				$this->cleanItemTags($item);
+			}
+
+			return $result;
+		}
+
+		return false;
+	}
+
+	/**
+	 * @param CacheItemInterface $item
+	 * @return bool
+	 */
+	public function saveDeferred(CacheItemInterface $item): bool
+	{
+		$this->assertCacheItemType($item, self::getItemClass());
+		if (!\array_key_exists($item->getKey(), $this->itemInstances)) {
+			$this->itemInstances[$item->getKey()] = $item;
+		} elseif (\spl_object_hash($item) !== \spl_object_hash($this->itemInstances[$item->getKey()])) {
+			throw new RuntimeException('Spl object hash mismatches ! You probably tried to save a detached item which has been already retrieved from cache.');
+		}
+
+		$this->eventManager->dispatch(Event::CACHE_SAVE_DEFERRED_ITEM, $this, $item);
+		$this->deferredList[$item->getKey()] = $item;
+
+		return true;
+	}
+
+	/**
+	 * @return bool
+	 * @throws PhpfastcacheCoreException
+	 * @throws PhpfastcacheDriverException
+	 * @throws PhpfastcacheInvalidArgumentException
+	 * @throws PhpfastcacheLogicException
+	 */
+	public function commit(): bool
+	{
+		$this->eventManager->dispatch(Event::CACHE_COMMIT_ITEM, $this, new EventReferenceParameter($this->deferredList));
+
+		if (\count($this->deferredList)) {
+			$return = true;
+			foreach ($this->deferredList as $key => $item) {
+				$result = $this->save($item);
+				unset($this->deferredList[$key]);
+				if ($result !== true) {
+					$return = $result;
+				}
+			}
+
+			return $return;
+		}
+		return false;
+	}
+
+	/**
+	 * @param CacheItemInterface $item
+	 * @return bool
+	 * @throws PhpfastcacheCoreException
+	 * @throws PhpfastcacheDriverException
+	 * @throws PhpfastcacheIOException
+	 * @throws PhpfastcacheInvalidArgumentException
+	 * @throws PhpfastcacheLogicException
+	 */
+	public function save(CacheItemInterface $item): bool
+	{
+		$this->assertCacheItemType($item, self::getItemClass());
+		/**
+		 * @var ExtendedCacheItemInterface $item
+		 *
+		 * Replace array_key_exists by isset
+		 * due to performance issue on huge
+		 * loop dispatching operations
+		 */
+		if (!isset($this->itemInstances[$item->getKey()])) {
+			if ($this->getConfig()->isUseStaticItemCaching()) {
+				$this->itemInstances[$item->getKey()] = $item;
+			}
+		} elseif (\spl_object_hash($item) !== \spl_object_hash($this->itemInstances[$item->getKey()])) {
+			throw new RuntimeException('Spl object hash mismatches ! You probably tried to save a detached item which has been already retrieved from cache.');
+		}
+
+		$this->assertCacheItemType($item, self::getItemClass());
+		$this->eventManager->dispatch(Event::CACHE_SAVE_ITEM, $this, $item);
+
+		if ($this->getConfig() instanceof IOConfigurationOptionInterface && $this->getConfig()->isPreventCacheSlams()) {
+			/**
+			 * @var $itemBatch ExtendedCacheItemInterface
+			 */
+			$itemClassName = self::getItemClass();
+			$itemBatch = new $itemClassName($this, $item->getKey(), $this->eventManager);
+			$itemBatch->set(new ItemBatch($item->getKey(), new DateTime()))
+				->expiresAfter($this->getConfig()->getCacheSlamsTimeout());
+
+			/**
+			 * To avoid SPL mismatches
+			 * we have to re-attach the
+			 * original item to the pool
+			 */
+			$this->driverWrite($itemBatch);
+			$this->detachItem($itemBatch);
+			$this->attachItem($item);
+		}
+
+
+		if ($this->driverWrite($item) && $this->driverWriteTags($item)) {
+			$item->setHit(true)
+				->clearRemovedTags();
+
+			if ($this->getConfig()->isItemDetailedDate()) {
+				$item->setModificationDate(new \DateTime());
+			}
+
+			$this->getIO()->incWriteHit();
+
+			return true;
+		}
+
+		return false;
+	}
+
+	/**
+	 * @return DriverIO
+	 */
+	public function getIO(): DriverIO
+	{
+		return $this->IO;
+	}
+
+	/**
+	 * @internal This method de-register an item from $this->itemInstances
+	 */
+	protected function deregisterItem(string $itemKey): static
+	{
+		unset($this->itemInstances[$itemKey]);
+
+		if (\gc_enabled()) {
+			\gc_collect_cycles();
+		}
+
+		return $this;
+	}
+
+	/**
+	 * @param string[] $itemKeys
+	 * @internal This method de-register multiple items from $this->itemInstances
+	 */
+	protected function deregisterItems(array $itemKeys): static
+	{
+		$this->itemInstances = array_diff_key($this->itemInstances, array_flip($itemKeys));
+
+		if (\gc_enabled()) {
+			\gc_collect_cycles();
+		}
+
+		return $this;
+	}
+
+	/**
+	 * @throws PhpfastcacheLogicException
+	 */
+	public function attachItem(CacheItemInterface $item): static
+	{
+		if (isset($this->itemInstances[$item->getKey()]) && \spl_object_hash($item) !== \spl_object_hash($this->itemInstances[$item->getKey()])) {
+			throw new PhpfastcacheLogicException(
+				'The item already exists and cannot be overwritten because the Spl object hash mismatches ! 
                 You probably tried to re-attach a detached item which has been already retrieved from cache.'
-            );
-        }
-
-        if (!$this->getConfig()->isUseStaticItemCaching()) {
-            throw new PhpfastcacheLogicException(
-                'The static item caching option (useStaticItemCaching) is disabled so you cannot attach an item.'
-            );
-        }
-
-        $this->itemInstances[$item->getKey()] = $item;
-
-        return $this;
-    }
-
-    public function isAttached(CacheItemInterface $item): bool
-    {
-        if (isset($this->itemInstances[$item->getKey()])) {
-            return \spl_object_hash($item) === \spl_object_hash($this->itemInstances[$item->getKey()]);
-        }
-        return false;
-    }
-
-    protected function validateCacheKeys(string ...$keys): void
-    {
-        foreach ($keys as $key) {
-            if (\preg_match('~([' . \preg_quote(self::$unsupportedKeyChars, '~') . ']+)~', $key, $matches)) {
-                throw new PhpfastcacheInvalidArgumentException(
-                    'Unsupported key character detected: "' . $matches[1] . '". 
+			);
+		}
+
+		if (!$this->getConfig()->isUseStaticItemCaching()) {
+			throw new PhpfastcacheLogicException(
+				'The static item caching option (useStaticItemCaching) is disabled so you cannot attach an item.'
+			);
+		}
+
+		$this->itemInstances[$item->getKey()] = $item;
+
+		return $this;
+	}
+
+	public function isAttached(CacheItemInterface $item): bool
+	{
+		if (isset($this->itemInstances[$item->getKey()])) {
+			return \spl_object_hash($item) === \spl_object_hash($this->itemInstances[$item->getKey()]);
+		}
+		return false;
+	}
+
+	protected function validateCacheKeys(string ...$keys): void
+	{
+		foreach ($keys as $key) {
+			if (\preg_match('~([' . \preg_quote(self::$unsupportedKeyChars, '~') . ']+)~', $key, $matches)) {
+				throw new PhpfastcacheInvalidArgumentException(
+					'Unsupported key character detected: "' . $matches[1] . '". 
                     Please check: https://github.com/PHPSocialNetwork/phpfastcache/wiki/%5BV6%5D-Unsupported-characters-in-key-identifiers'
-                );
-            }
-        }
-    }
-
-    protected function handleExpiredCacheItem(ExtendedCacheItemInterface $item): void
-    {
-        if ($item->isExpired()) {
-            /**
-             * Using driverDelete() instead of delete()
-             * to avoid infinite loop caused by
-             * getItem() call in delete() method
-             * As we MUST return an item in any
-             * way, we do not de-register here
-             */
-            $this->driverDelete($item->getKey(), $item->getEncodedKey());
-
-            /**
-             * Reset the Item
-             */
-            $item->set(null)
-                ->expiresAfter((int) abs($this->getConfig()->getDefaultTtl()))
-                ->setHit(false)
-                ->setTags([]);
-
-            if ($this->getConfig()->isItemDetailedDate()) {
-                /**
-                 * If the itemDetailedDate has been
-                 * set after caching, we MUST inject
-                 * a new DateTime object on the fly
-                 */
-                $item->setCreationDate(new DateTime());
-                $item->setModificationDate(new DateTime());
-            }
-        } else {
-            $item->setHit(true);
-        }
-    }
-
-    /**
-     * @param ExtendedCacheItemInterface[] $items
-     * @param bool $encoded
-     * @param string $keyPrefix
-     * @return string[]
-     */
-    protected function getKeys(array $items, bool $encoded = false, string $keyPrefix = ''): array
-    {
-        return array_map(
-            static fn(ExtendedCacheItemInterface $item) => $keyPrefix . ($encoded ? $item->getEncodedKey() : $item->getKey()),
-            $items
-        );
-    }
+				);
+			}
+		}
+	}
+
+	protected function handleExpiredCacheItem(ExtendedCacheItemInterface $item): void
+	{
+		if ($item->isExpired()) {
+			/**
+			 * Using driverDelete() instead of delete()
+			 * to avoid infinite loop caused by
+			 * getItem() call in delete() method
+			 * As we MUST return an item in any
+			 * way, we do not de-register here
+			 */
+			$this->driverDelete($item->getKey(), $item->getEncodedKey());
+
+			/**
+			 * Reset the Item
+			 */
+			$item->set(null)
+				->expiresAfter((int) abs($this->getConfig()->getDefaultTtl()))
+				->setHit(false)
+				->setTags([]);
+
+			if ($this->getConfig()->isItemDetailedDate()) {
+				/**
+				 * If the itemDetailedDate has been
+				 * set after caching, we MUST inject
+				 * a new DateTime object on the fly
+				 */
+				$item->setCreationDate(new DateTime());
+				$item->setModificationDate(new DateTime());
+			}
+		} else {
+			$item->setHit(true);
+		}
+	}
+
+	/**
+	 * @param ExtendedCacheItemInterface[] $items
+	 * @param bool $encoded
+	 * @param string $keyPrefix
+	 * @return string[]
+	 */
+	protected function getKeys(array $items, bool $encoded = false, string $keyPrefix = ''): array
+	{
+		return array_map(
+			static fn(ExtendedCacheItemInterface $item) => $keyPrefix . ($encoded ? $item->getEncodedKey() : $item->getKey()),
+			$items
+		);
+	}
 }

plugins/files/php/vendor/phpfastcache/phpfastcache/lib/Phpfastcache/Core/Pool/TaggableCacheItemPoolInterface.php

Indentation +247 added lines, -247 removed lines

@@ -21,268 +21,268 @@
 
 interface TaggableCacheItemPoolInterface
 {
-    public const DRIVER_TAGS_KEY_PREFIX = '_TAG_';
+	public const DRIVER_TAGS_KEY_PREFIX = '_TAG_';
 
-    public const DRIVER_TAGS_WRAPPER_INDEX = 'g';
+	public const DRIVER_TAGS_WRAPPER_INDEX = 'g';
 
-    /**
-     * Allows you to get cache item(s) by at least **ONE** of the specified matching tag(s).
-     * Default behavior
-     */
-    public const TAG_STRATEGY_ONE = 1;
+	/**
+	 * Allows you to get cache item(s) by at least **ONE** of the specified matching tag(s).
+	 * Default behavior
+	 */
+	public const TAG_STRATEGY_ONE = 1;
 
-    /**
-     * Allows you to get cache item(s) by **ALL** of the specified matching tag(s)
-     * The cache item *CAN* have additional tag(s)
-     */
-    public const TAG_STRATEGY_ALL = 2;
+	/**
+	 * Allows you to get cache item(s) by **ALL** of the specified matching tag(s)
+	 * The cache item *CAN* have additional tag(s)
+	 */
+	public const TAG_STRATEGY_ALL = 2;
 
-    /**
-     * Allows you to get cache item(s) by **ONLY** the specified matching tag(s)
-     * The cache item *CANNOT* have additional tag(s)
-     */
-    public const TAG_STRATEGY_ONLY = 4;
+	/**
+	 * Allows you to get cache item(s) by **ONLY** the specified matching tag(s)
+	 * The cache item *CANNOT* have additional tag(s)
+	 */
+	public const TAG_STRATEGY_ONLY = 4;
 
-    /**
-     * Returns a traversable set of cache items by a tag name.
-     *
-     * @param string $tagName
-     * An indexed array of keys of items to retrieve.
-     *
-     * @param int $strategy
-     *
-     * @return ExtendedCacheItemInterface[]
-     *   A traversable collection of Cache Items keyed by the cache keys of
-     *   each item. A Cache item will be returned for each key, even if that
-     *   key is not found. However, if no keys are specified then an empty
-     *   traversable MUST be returned instead.
-     * @throws InvalidArgumentException
-     *   If any of the keys in $keys are not a legal value a phpfastcacheInvalidArgumentException
-     *   MUST be thrown.
-     *
-     */
-    public function getItemsByTag(string $tagName, int $strategy = self::TAG_STRATEGY_ONE): array;
+	/**
+	 * Returns a traversable set of cache items by a tag name.
+	 *
+	 * @param string $tagName
+	 * An indexed array of keys of items to retrieve.
+	 *
+	 * @param int $strategy
+	 *
+	 * @return ExtendedCacheItemInterface[]
+	 *   A traversable collection of Cache Items keyed by the cache keys of
+	 *   each item. A Cache item will be returned for each key, even if that
+	 *   key is not found. However, if no keys are specified then an empty
+	 *   traversable MUST be returned instead.
+	 * @throws InvalidArgumentException
+	 *   If any of the keys in $keys are not a legal value a phpfastcacheInvalidArgumentException
+	 *   MUST be thrown.
+	 *
+	 */
+	public function getItemsByTag(string $tagName, int $strategy = self::TAG_STRATEGY_ONE): array;
 
-    /**
-     * Returns a traversable set of cache items by one of multiple tag names.
-     *
-     * @param string[] $tagNames
-     * An indexed array of keys of items to retrieve.
-     *
-     * @param int $strategy
-     *
-     * @return ExtendedCacheItemInterface[]
-     *   A traversable collection of Cache Items keyed by the cache keys of
-     *   each item. A Cache item will be returned for each key, even if that
-     *   key is not found. However, if no keys are specified then an empty
-     *   traversable MUST be returned instead.
-     * @throws InvalidArgumentException
-     *   If any of the keys in $keys are not a legal value a phpfastcacheInvalidArgumentException
-     *   MUST be thrown.
-     *
-     */
-    public function getItemsByTags(array $tagNames, int $strategy = self::TAG_STRATEGY_ONE): array;
+	/**
+	 * Returns a traversable set of cache items by one of multiple tag names.
+	 *
+	 * @param string[] $tagNames
+	 * An indexed array of keys of items to retrieve.
+	 *
+	 * @param int $strategy
+	 *
+	 * @return ExtendedCacheItemInterface[]
+	 *   A traversable collection of Cache Items keyed by the cache keys of
+	 *   each item. A Cache item will be returned for each key, even if that
+	 *   key is not found. However, if no keys are specified then an empty
+	 *   traversable MUST be returned instead.
+	 * @throws InvalidArgumentException
+	 *   If any of the keys in $keys are not a legal value a phpfastcacheInvalidArgumentException
+	 *   MUST be thrown.
+	 *
+	 */
+	public function getItemsByTags(array $tagNames, int $strategy = self::TAG_STRATEGY_ONE): array;
 
-    /**
-     * Returns A json string that represents an array of items by tags-based.
-     *
-     * @param string[] $tagNames
-     * An indexed array of keys of items to retrieve.
-     * @param int $option \json_encode() options
-     * @param int $depth \json_encode() depth
-     * @param int $strategy
-     *
-     * @return string
-     * @throws InvalidArgumentException
-     *   If any of the keys in $keys are not a legal value a phpfastcacheInvalidArgumentException
-     *   MUST be thrown.
-     *
-     */
-    public function getItemsByTagsAsJsonString(array $tagNames, int $option = \JSON_THROW_ON_ERROR, int $depth = 512, int $strategy = self::TAG_STRATEGY_ONE): string;
+	/**
+	 * Returns A json string that represents an array of items by tags-based.
+	 *
+	 * @param string[] $tagNames
+	 * An indexed array of keys of items to retrieve.
+	 * @param int $option \json_encode() options
+	 * @param int $depth \json_encode() depth
+	 * @param int $strategy
+	 *
+	 * @return string
+	 * @throws InvalidArgumentException
+	 *   If any of the keys in $keys are not a legal value a phpfastcacheInvalidArgumentException
+	 *   MUST be thrown.
+	 *
+	 */
+	public function getItemsByTagsAsJsonString(array $tagNames, int $option = \JSON_THROW_ON_ERROR, int $depth = 512, int $strategy = self::TAG_STRATEGY_ONE): string;
 
-    /**
-     * Removes the item from the pool by tag.
-     *
-     * @param string $tagName
-     *   The tag for which to delete
-     *
-     * @param int $strategy
-     *
-     * @return bool
-     *   True if the item was successfully removed. False if there was an error.
-     * @throws InvalidArgumentException
-     *   If the $key string is not a legal value a phpfastcacheInvalidArgumentException
-     *   MUST be thrown.
-     *
-     */
-    public function deleteItemsByTag(string $tagName, int $strategy = self::TAG_STRATEGY_ONE): bool;
+	/**
+	 * Removes the item from the pool by tag.
+	 *
+	 * @param string $tagName
+	 *   The tag for which to delete
+	 *
+	 * @param int $strategy
+	 *
+	 * @return bool
+	 *   True if the item was successfully removed. False if there was an error.
+	 * @throws InvalidArgumentException
+	 *   If the $key string is not a legal value a phpfastcacheInvalidArgumentException
+	 *   MUST be thrown.
+	 *
+	 */
+	public function deleteItemsByTag(string $tagName, int $strategy = self::TAG_STRATEGY_ONE): bool;
 
-    /**
-     * Removes the item from the pool by one of multiple tag names.
-     *
-     * @param string[] $tagNames
-     *   The tag for which to delete
-     *
-     * @param int $strategy
-     *
-     * @return bool
-     *   True if the items were successfully removed. False if there was an error.
-     * @throws InvalidArgumentException
-     *   If the $key string is not a legal value a phpfastcacheInvalidArgumentException
-     *   MUST be thrown.
-     *
-     */
-    public function deleteItemsByTags(array $tagNames, int $strategy = self::TAG_STRATEGY_ONE): bool;
+	/**
+	 * Removes the item from the pool by one of multiple tag names.
+	 *
+	 * @param string[] $tagNames
+	 *   The tag for which to delete
+	 *
+	 * @param int $strategy
+	 *
+	 * @return bool
+	 *   True if the items were successfully removed. False if there was an error.
+	 * @throws InvalidArgumentException
+	 *   If the $key string is not a legal value a phpfastcacheInvalidArgumentException
+	 *   MUST be thrown.
+	 *
+	 */
+	public function deleteItemsByTags(array $tagNames, int $strategy = self::TAG_STRATEGY_ONE): bool;
 
-    /**
-     * Increment the items from the pool by tag.
-     *
-     * @param string $tagName
-     *   The tag for which to increment
-     *
-     * @param int $step
-     *
-     * @param int $strategy
-     *
-     * @return bool
-     *   True if the item was successfully incremented. False if there was an error.
-     * @throws InvalidArgumentException
-     *   If the $key string is not a legal value a phpfastcacheInvalidArgumentException
-     *   MUST be thrown.
-     *
-     */
-    public function incrementItemsByTag(string $tagName, int $step = 1, int $strategy = self::TAG_STRATEGY_ONE): bool;
+	/**
+	 * Increment the items from the pool by tag.
+	 *
+	 * @param string $tagName
+	 *   The tag for which to increment
+	 *
+	 * @param int $step
+	 *
+	 * @param int $strategy
+	 *
+	 * @return bool
+	 *   True if the item was successfully incremented. False if there was an error.
+	 * @throws InvalidArgumentException
+	 *   If the $key string is not a legal value a phpfastcacheInvalidArgumentException
+	 *   MUST be thrown.
+	 *
+	 */
+	public function incrementItemsByTag(string $tagName, int $step = 1, int $strategy = self::TAG_STRATEGY_ONE): bool;
 
-    /**
-     * Increment the items from the pool by one of multiple tag names.
-     *
-     * @param string[] $tagNames
-     *   The tag for which to increment
-     *
-     * @param int $step
-     *
-     * @param int $strategy
-     *
-     * @return bool
-     *   True if the items were successfully incremented. False if there was an error.
-     * @throws InvalidArgumentException
-     *   If the $key string is not a legal value a phpfastcacheInvalidArgumentException
-     *   MUST be thrown.
-     *
-     */
-    public function incrementItemsByTags(array $tagNames, int $step = 1, int $strategy = self::TAG_STRATEGY_ONE): bool;
+	/**
+	 * Increment the items from the pool by one of multiple tag names.
+	 *
+	 * @param string[] $tagNames
+	 *   The tag for which to increment
+	 *
+	 * @param int $step
+	 *
+	 * @param int $strategy
+	 *
+	 * @return bool
+	 *   True if the items were successfully incremented. False if there was an error.
+	 * @throws InvalidArgumentException
+	 *   If the $key string is not a legal value a phpfastcacheInvalidArgumentException
+	 *   MUST be thrown.
+	 *
+	 */
+	public function incrementItemsByTags(array $tagNames, int $step = 1, int $strategy = self::TAG_STRATEGY_ONE): bool;
 
-    /**
-     * Decrement the items from the pool by tag.
-     *
-     * @param string $tagName
-     *   The tag for which to decrement
-     *
-     * @param int $step
-     *
-     * @param int $strategy
-     *
-     * @return bool
-     *   True if the item was successfully decremented. False if there was an error.
-     * @throws InvalidArgumentException
-     *   If the $key string is not a legal value a phpfastcacheInvalidArgumentException
-     *   MUST be thrown.
-     *
-     */
-    public function decrementItemsByTag(string $tagName, int $step = 1, int $strategy = self::TAG_STRATEGY_ONE): bool;
+	/**
+	 * Decrement the items from the pool by tag.
+	 *
+	 * @param string $tagName
+	 *   The tag for which to decrement
+	 *
+	 * @param int $step
+	 *
+	 * @param int $strategy
+	 *
+	 * @return bool
+	 *   True if the item was successfully decremented. False if there was an error.
+	 * @throws InvalidArgumentException
+	 *   If the $key string is not a legal value a phpfastcacheInvalidArgumentException
+	 *   MUST be thrown.
+	 *
+	 */
+	public function decrementItemsByTag(string $tagName, int $step = 1, int $strategy = self::TAG_STRATEGY_ONE): bool;
 
-    /**
-     * Decrement the items from the pool by one of multiple tag names.
-     *
-     * @param string[] $tagNames
-     *   The tag for which to decrement
-     *
-     * @param int $step
-     *
-     * @param int $strategy
-     *
-     * @return bool
-     *   True if the item was successfully decremented. False if there was an error.
-     * @throws InvalidArgumentException
-     *   If the $key string is not a legal value a phpfastcacheInvalidArgumentException
-     *   MUST be thrown.
-     *
-     */
-    public function decrementItemsByTags(array $tagNames, int $step = 1, int $strategy = self::TAG_STRATEGY_ONE): bool;
+	/**
+	 * Decrement the items from the pool by one of multiple tag names.
+	 *
+	 * @param string[] $tagNames
+	 *   The tag for which to decrement
+	 *
+	 * @param int $step
+	 *
+	 * @param int $strategy
+	 *
+	 * @return bool
+	 *   True if the item was successfully decremented. False if there was an error.
+	 * @throws InvalidArgumentException
+	 *   If the $key string is not a legal value a phpfastcacheInvalidArgumentException
+	 *   MUST be thrown.
+	 *
+	 */
+	public function decrementItemsByTags(array $tagNames, int $step = 1, int $strategy = self::TAG_STRATEGY_ONE): bool;
 
-    /**
-     * Decrement the items from the pool by tag.
-     *
-     * @param string $tagName
-     *   The tag for which to append
-     *
-     * @param array<mixed>|string $data
-     *
-     * @param int $strategy
-     *
-     * @return bool
-     *   True if the item was successfully appended. False if there was an error.
-     * @throws InvalidArgumentException
-     *   If the $key string is not a legal value a phpfastcacheInvalidArgumentException
-     *   MUST be thrown.
-     *
-     */
-    public function appendItemsByTag(string $tagName, array|string $data, int $strategy = self::TAG_STRATEGY_ONE): bool;
+	/**
+	 * Decrement the items from the pool by tag.
+	 *
+	 * @param string $tagName
+	 *   The tag for which to append
+	 *
+	 * @param array<mixed>|string $data
+	 *
+	 * @param int $strategy
+	 *
+	 * @return bool
+	 *   True if the item was successfully appended. False if there was an error.
+	 * @throws InvalidArgumentException
+	 *   If the $key string is not a legal value a phpfastcacheInvalidArgumentException
+	 *   MUST be thrown.
+	 *
+	 */
+	public function appendItemsByTag(string $tagName, array|string $data, int $strategy = self::TAG_STRATEGY_ONE): bool;
 
-    /**
-     * Append the items from the pool by one of multiple tag names.
-     *
-     * @param string[] $tagNames
-     *   The tag for which to append
-     *
-     * @param array<mixed>|string $data
-     *
-     * @param int $strategy
-     *
-     * @return bool
-     *   True if the items were successfully appended. False if there was an error.
-     * @throws InvalidArgumentException
-     *   If the $key string is not a legal value a phpfastcacheInvalidArgumentException
-     *   MUST be thrown.
-     *
-     */
-    public function appendItemsByTags(array $tagNames, array|string $data, int $strategy = self::TAG_STRATEGY_ONE): bool;
+	/**
+	 * Append the items from the pool by one of multiple tag names.
+	 *
+	 * @param string[] $tagNames
+	 *   The tag for which to append
+	 *
+	 * @param array<mixed>|string $data
+	 *
+	 * @param int $strategy
+	 *
+	 * @return bool
+	 *   True if the items were successfully appended. False if there was an error.
+	 * @throws InvalidArgumentException
+	 *   If the $key string is not a legal value a phpfastcacheInvalidArgumentException
+	 *   MUST be thrown.
+	 *
+	 */
+	public function appendItemsByTags(array $tagNames, array|string $data, int $strategy = self::TAG_STRATEGY_ONE): bool;
 
-    /**
-     * Prepend the items from the pool by tag.
-     *
-     * @param string $tagName
-     *   The tag for which to prepend
-     *
-     * @param array<mixed>|string $data
-     *
-     * @param int $strategy
-     *
-     * @return bool
-     *   True if the item was successfully prepended. False if there was an error.
-     * @throws InvalidArgumentException
-     *   If the $key string is not a legal value a phpfastcacheInvalidArgumentException
-     *   MUST be thrown.
-     *
-     */
-    public function prependItemsByTag(string $tagName, array|string $data, int $strategy = self::TAG_STRATEGY_ONE): bool;
+	/**
+	 * Prepend the items from the pool by tag.
+	 *
+	 * @param string $tagName
+	 *   The tag for which to prepend
+	 *
+	 * @param array<mixed>|string $data
+	 *
+	 * @param int $strategy
+	 *
+	 * @return bool
+	 *   True if the item was successfully prepended. False if there was an error.
+	 * @throws InvalidArgumentException
+	 *   If the $key string is not a legal value a phpfastcacheInvalidArgumentException
+	 *   MUST be thrown.
+	 *
+	 */
+	public function prependItemsByTag(string $tagName, array|string $data, int $strategy = self::TAG_STRATEGY_ONE): bool;
 
-    /**
-     * Prepend the items from the pool by one of multiple tag names.
-     *
-     * @param string[] $tagNames
-     *   The tag for which to prepend
-     *
-     * @param array<mixed>|string $data
-     *
-     * @param int $strategy
-     *
-     * @return bool
-     *   True if the item was successfully prepended. False if there was an error.
-     * @throws InvalidArgumentException
-     *   If the $key string is not a legal value a phpfastcacheInvalidArgumentException
-     *   MUST be thrown.
-     *
-     */
-    public function prependItemsByTags(array $tagNames, array|string $data, int $strategy = self::TAG_STRATEGY_ONE): bool;
+	/**
+	 * Prepend the items from the pool by one of multiple tag names.
+	 *
+	 * @param string[] $tagNames
+	 *   The tag for which to prepend
+	 *
+	 * @param array<mixed>|string $data
+	 *
+	 * @param int $strategy
+	 *
+	 * @return bool
+	 *   True if the item was successfully prepended. False if there was an error.
+	 * @throws InvalidArgumentException
+	 *   If the $key string is not a legal value a phpfastcacheInvalidArgumentException
+	 *   MUST be thrown.
+	 *
+	 */
+	public function prependItemsByTags(array $tagNames, array|string $data, int $strategy = self::TAG_STRATEGY_ONE): bool;
 }

plugins/files/php/vendor/phpfastcache/phpfastcache/lib/Phpfastcache/Core/Pool/DriverPoolAbstractTrait.php

Indentation +97 added lines, -97 removed lines

@@ -24,101 +24,101 @@
 
 trait DriverPoolAbstractTrait
 {
-    /**
-     * @return bool
-     */
-    abstract protected function driverCheck(): bool;
-
-    /**
-     * @return bool
-     */
-    abstract protected function driverConnect(): bool;
-
-    /**
-     * @param ExtendedCacheItemInterface $item
-     * @return ?array<string, mixed>
-     */
-    abstract protected function driverRead(ExtendedCacheItemInterface $item): ?array;
-
-    /**
-     * @param ExtendedCacheItemInterface ...$items
-     * @return array<array<string, mixed>>
-     * @throws PhpfastcacheUnsupportedMethodException
-     */
-    protected function driverReadMultiple(ExtendedCacheItemInterface ...$items): array
-    {
-        throw new PhpfastcacheUnsupportedMethodException();
-    }
-
-    /**
-     * @return \Traversable<int, string>
-     * @throws PhpfastcacheUnsupportedMethodException
-     */
-    protected function driverReadAllKeys(string $pattern = ''): iterable
-    {
-        throw new PhpfastcacheUnsupportedMethodException(
-            sprintf(
-                'The "readAll" operation is unsupported by the the "%s" driver. See the Wiki for more information at %s',
-                $this->getDriverName(),
-                Wiki::FETCH_ALL_KEY_URL,
-            )
-        );
-    }
-
-    /**
-     * @param ExtendedCacheItemInterface $item
-     * @return bool
-     */
-    abstract protected function driverWrite(ExtendedCacheItemInterface $item): bool;
-
-    /**
-     * @param ExtendedCacheItemInterface ...$item
-     * @return bool
-     * @throws PhpfastcacheUnsupportedMethodException
-     */
-    protected function driverWriteMultiple(ExtendedCacheItemInterface ...$item): bool
-    {
-        /**
-         * @todo Implement bulk writes to be for v10:
-         * For methods commit() and saveMultiple()
-         */
-        throw new PhpfastcacheUnsupportedMethodException();
-    }
-
-
-    /**
-     * @param string $key
-     * @param string $encodedKey
-     * @return bool
-     */
-    abstract protected function driverDelete(string $key, string $encodedKey): bool;
-
-    /**
-     * @param string[] $keys
-     * @return bool
-     * @throws PhpfastcacheUnsupportedMethodException
-     */
-    protected function driverDeleteMultiple(array $keys): bool
-    {
-        throw new PhpfastcacheUnsupportedMethodException();
-    }
-
-    /**
-     * @return bool
-     */
-    abstract protected function driverClear(): bool;
-
-    /**
-     * @param CacheItemInterface $item
-     * @param string $expectedClassType
-     * @throws PhpfastcacheInvalidArgumentException
-     */
-    protected function assertCacheItemType(CacheItemInterface $item, string $expectedClassType): void
-    {
-        if (!($item instanceof $expectedClassType)) {
-            throw new PhpfastcacheInvalidArgumentException(
-                \sprintf('Cross-driver type confusion detected: Expected "%s" object, got "%s"', $expectedClassType, $item::class)
-            );
-        }
-    }
+	/**
+	 * @return bool
+	 */
+	abstract protected function driverCheck(): bool;
+
+	/**
+	 * @return bool
+	 */
+	abstract protected function driverConnect(): bool;
+
+	/**
+	 * @param ExtendedCacheItemInterface $item
+	 * @return ?array<string, mixed>
+	 */
+	abstract protected function driverRead(ExtendedCacheItemInterface $item): ?array;
+
+	/**
+	 * @param ExtendedCacheItemInterface ...$items
+	 * @return array<array<string, mixed>>
+	 * @throws PhpfastcacheUnsupportedMethodException
+	 */
+	protected function driverReadMultiple(ExtendedCacheItemInterface ...$items): array
+	{
+		throw new PhpfastcacheUnsupportedMethodException();
+	}
+
+	/**
+	 * @return \Traversable<int, string>
+	 * @throws PhpfastcacheUnsupportedMethodException
+	 */
+	protected function driverReadAllKeys(string $pattern = ''): iterable
+	{
+		throw new PhpfastcacheUnsupportedMethodException(
+			sprintf(
+				'The "readAll" operation is unsupported by the the "%s" driver. See the Wiki for more information at %s',
+				$this->getDriverName(),
+				Wiki::FETCH_ALL_KEY_URL,
+			)
+		);
+	}
+
+	/**
+	 * @param ExtendedCacheItemInterface $item
+	 * @return bool
+	 */
+	abstract protected function driverWrite(ExtendedCacheItemInterface $item): bool;
+
+	/**
+	 * @param ExtendedCacheItemInterface ...$item
+	 * @return bool
+	 * @throws PhpfastcacheUnsupportedMethodException
+	 */
+	protected function driverWriteMultiple(ExtendedCacheItemInterface ...$item): bool
+	{
+		/**
+		 * @todo Implement bulk writes to be for v10:
+		 * For methods commit() and saveMultiple()
+		 */
+		throw new PhpfastcacheUnsupportedMethodException();
+	}
+
+
+	/**
+	 * @param string $key
+	 * @param string $encodedKey
+	 * @return bool
+	 */
+	abstract protected function driverDelete(string $key, string $encodedKey): bool;
+
+	/**
+	 * @param string[] $keys
+	 * @return bool
+	 * @throws PhpfastcacheUnsupportedMethodException
+	 */
+	protected function driverDeleteMultiple(array $keys): bool
+	{
+		throw new PhpfastcacheUnsupportedMethodException();
+	}
+
+	/**
+	 * @return bool
+	 */
+	abstract protected function driverClear(): bool;
+
+	/**
+	 * @param CacheItemInterface $item
+	 * @param string $expectedClassType
+	 * @throws PhpfastcacheInvalidArgumentException
+	 */
+	protected function assertCacheItemType(CacheItemInterface $item, string $expectedClassType): void
+	{
+		if (!($item instanceof $expectedClassType)) {
+			throw new PhpfastcacheInvalidArgumentException(
+				\sprintf('Cross-driver type confusion detected: Expected "%s" object, got "%s"', $expectedClassType, $item::class)
+			);
+		}
+	}
 }