grommunio / grommunio-web

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

Indentation +190 added lines, -190 removed lines

@@ -36,196 +36,196 @@
  */
 interface ExtendedCacheItemPoolInterface extends CacheItemPoolInterface, EventManagerDispatcherInterface, ClassNamespaceResolverInterface, TaggableCacheItemPoolInterface
 {
-    public const DRIVER_CHECK_FAILURE = '%s is not installed or is misconfigured, cannot continue. 
+	public const DRIVER_CHECK_FAILURE = '%s is not installed or is misconfigured, cannot continue. 
     Also, please verify the suggested dependencies in composer because as of the V6, 3rd party libraries are no longer required.%s';
 
-    public const DRIVER_CONNECT_FAILURE = '%s failed to connect with the following error message: "%s" line %d in %s.';
-
-    public const DRIVER_KEY_WRAPPER_INDEX = 'k';
-
-    public const DRIVER_DATA_WRAPPER_INDEX = 'd';
-
-    /**
-     * Expiration date Index
-     */
-    public const DRIVER_EDATE_WRAPPER_INDEX = 'e';
-
-    /**
-     * Creation date Index
-     */
-    public const DRIVER_CDATE_WRAPPER_INDEX = 'c';
-
-    /**
-     * Modification date Index
-     */
-    public const DRIVER_MDATE_WRAPPER_INDEX = 'm';
-
-    /**
-     * Hard-limit count  of items returns by getAllItems()
-     */
-    public const MAX_ALL_KEYS_COUNT = 9999;
-
-    /**
-     * Return the config class name
-     * @return string
-     */
-    public static function getConfigClass(): string;
-
-    /**
-     * Return the item class name
-     * @return string
-     */
-    public static function getItemClass(): string;
-
-    /**
-     * @param string $key
-     * @return string
-     */
-    public function getEncodedKey(string $key): string;
-
-    /**
-     * @return ConfigurationOptionInterface
-     */
-    public function getConfig(): ConfigurationOptionInterface;
-
-    /**
-     * @return ConfigurationOptionInterface
-     */
-    public function getDefaultConfig(): ConfigurationOptionInterface;
-
-    /**
-     * @return string
-     */
-    public function getDriverName(): string;
-
-    /**
-     * @return mixed
-     */
-    public function getInstanceId(): string;
-
-    /**
-     * [Phpfastcache phpDoc Override]
-     * Returns a Cache Item representing the specified key.
-     *
-     * This method must always return a CacheItemInterface object, even in case of
-     * a cache miss. It MUST NOT return null.
-     *
-     * @param string $key
-     *   The key for which to return the corresponding Cache Item.
-     *
-     * @return ExtendedCacheItemInterface
-     *   The corresponding Cache Item.
-     * @throws PhpfastcacheInvalidArgumentException
-     *   If the $key string is not a legal value a phpfastcacheInvalidArgumentException
-     *   MUST be thrown.
-     *
-     */
-    public function getItem(string $key): ExtendedCacheItemInterface;
-
-    /**
-     * [Phpfastcache phpDoc Override]
-     * Returns a traversable set of cache items.
-     *
-     * @param string[] $keys
-     * An indexed array of keys of items to retrieve.
-     *
-     * @return iterable<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 getItems(array $keys = []): iterable;
-
-    /**
-     * Returns the WHOLE cache as a traversable set of cache items.
-     * A hard-limit of 9999 items is defined internally to prevent
-     * serious performances issues of your application.
-     * @see ExtendedCacheItemPoolInterface::MAX_ALL_KEYS_COUNT
-     *
-     * @param string $pattern
-     * An optional pattern supported by a limited range of drivers.
-     * If this parameter is unsupported by the driver, a PhpfastcacheInvalidArgumentException will be thrown.
-     *
-     * @return iterable<ExtendedCacheItemInterface>
-     *   A traversable collection of Cache Items keyed by the cache keys of
-     *   each item. However, if no keys are returned by the backend then an empty
-     *   traversable WILL be returned instead.
-     *
-     * @throws PhpfastcacheInvalidArgumentException If the driver does not support the $pattern argument
-     * @throws PhpfastcacheUnsupportedMethodException If the driver does not permit to list all the keys through this implementation.
-     */
-    public function getAllItems(string $pattern = ''): iterable;
-
-    /**
-     * Returns A json string that represents an array of items.
-     *
-     * @param array<string> $keys An indexed array of keys of items to retrieve.
-     * @param int $options \json_encode() options
-     * @param int $depth \json_encode() depth
-     *
-     * @return string
-     * @throws InvalidArgumentException
-     *   If any of the keys in $keys are not a legal value a phpfastcacheInvalidArgumentException
-     *   MUST be thrown.
-     *
-     */
-    public function getItemsAsJsonString(array $keys = [], int $options = \JSON_THROW_ON_ERROR, int $depth = 512): string;
-
-    public function setItem(CacheItemInterface $item): static;
-
-    public function getStats(): DriverStatistic;
-
-    /**
-     * Get a quick help guide
-     * about the current driver
-     */
-    public function getHelp(): string;
-
-    public function detachItem(CacheItemInterface $item): static;
-
-    public function detachAllItems(): static;
-
-    public function attachItem(CacheItemInterface $item): static;
-
-    /**
-     * Returns true if the item exists, is attached and the Spl Hash matches
-     * Returns false if the item exists, is attached and the Spl Hash mismatches
-     * Returns null if the item does not exist
-     *
-     * @param CacheItemInterface $item
-     * @return bool
-     * @throws PhpfastcacheLogicException
-     */
-    public function isAttached(CacheItemInterface $item): bool;
-
-    /**
-     * Persists a cache item immediately.
-     *
-     * @param ExtendedCacheItemInterface|CacheItemInterface $item
-     *   The cache item to save.
-     *
-     * @return bool
-     *   True if the item was successfully persisted. False if there was an error.
-     */
-    public function save(ExtendedCacheItemInterface|CacheItemInterface $item): bool;
-
-    /**
-     * Save multiple items, possible uses:
-     *  saveMultiple([$item1, $item2, $item3]);
-     *  saveMultiple($item1, $item2, $item3);
-     *
-     * @param ExtendedCacheItemInterface[] $items
-     * @return bool
-     */
-    public function saveMultiple(ExtendedCacheItemInterface ...$items): bool;
-
-    /**
-     * @return DriverIO
-     */
-    public function getIO(): DriverIO;
+	public const DRIVER_CONNECT_FAILURE = '%s failed to connect with the following error message: "%s" line %d in %s.';
+
+	public const DRIVER_KEY_WRAPPER_INDEX = 'k';
+
+	public const DRIVER_DATA_WRAPPER_INDEX = 'd';
+
+	/**
+	 * Expiration date Index
+	 */
+	public const DRIVER_EDATE_WRAPPER_INDEX = 'e';
+
+	/**
+	 * Creation date Index
+	 */
+	public const DRIVER_CDATE_WRAPPER_INDEX = 'c';
+
+	/**
+	 * Modification date Index
+	 */
+	public const DRIVER_MDATE_WRAPPER_INDEX = 'm';
+
+	/**
+	 * Hard-limit count  of items returns by getAllItems()
+	 */
+	public const MAX_ALL_KEYS_COUNT = 9999;
+
+	/**
+	 * Return the config class name
+	 * @return string
+	 */
+	public static function getConfigClass(): string;
+
+	/**
+	 * Return the item class name
+	 * @return string
+	 */
+	public static function getItemClass(): string;
+
+	/**
+	 * @param string $key
+	 * @return string
+	 */
+	public function getEncodedKey(string $key): string;
+
+	/**
+	 * @return ConfigurationOptionInterface
+	 */
+	public function getConfig(): ConfigurationOptionInterface;
+
+	/**
+	 * @return ConfigurationOptionInterface
+	 */
+	public function getDefaultConfig(): ConfigurationOptionInterface;
+
+	/**
+	 * @return string
+	 */
+	public function getDriverName(): string;
+
+	/**
+	 * @return mixed
+	 */
+	public function getInstanceId(): string;
+
+	/**
+	 * [Phpfastcache phpDoc Override]
+	 * Returns a Cache Item representing the specified key.
+	 *
+	 * This method must always return a CacheItemInterface object, even in case of
+	 * a cache miss. It MUST NOT return null.
+	 *
+	 * @param string $key
+	 *   The key for which to return the corresponding Cache Item.
+	 *
+	 * @return ExtendedCacheItemInterface
+	 *   The corresponding Cache Item.
+	 * @throws PhpfastcacheInvalidArgumentException
+	 *   If the $key string is not a legal value a phpfastcacheInvalidArgumentException
+	 *   MUST be thrown.
+	 *
+	 */
+	public function getItem(string $key): ExtendedCacheItemInterface;
+
+	/**
+	 * [Phpfastcache phpDoc Override]
+	 * Returns a traversable set of cache items.
+	 *
+	 * @param string[] $keys
+	 * An indexed array of keys of items to retrieve.
+	 *
+	 * @return iterable<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 getItems(array $keys = []): iterable;
+
+	/**
+	 * Returns the WHOLE cache as a traversable set of cache items.
+	 * A hard-limit of 9999 items is defined internally to prevent
+	 * serious performances issues of your application.
+	 * @see ExtendedCacheItemPoolInterface::MAX_ALL_KEYS_COUNT
+	 *
+	 * @param string $pattern
+	 * An optional pattern supported by a limited range of drivers.
+	 * If this parameter is unsupported by the driver, a PhpfastcacheInvalidArgumentException will be thrown.
+	 *
+	 * @return iterable<ExtendedCacheItemInterface>
+	 *   A traversable collection of Cache Items keyed by the cache keys of
+	 *   each item. However, if no keys are returned by the backend then an empty
+	 *   traversable WILL be returned instead.
+	 *
+	 * @throws PhpfastcacheInvalidArgumentException If the driver does not support the $pattern argument
+	 * @throws PhpfastcacheUnsupportedMethodException If the driver does not permit to list all the keys through this implementation.
+	 */
+	public function getAllItems(string $pattern = ''): iterable;
+
+	/**
+	 * Returns A json string that represents an array of items.
+	 *
+	 * @param array<string> $keys An indexed array of keys of items to retrieve.
+	 * @param int $options \json_encode() options
+	 * @param int $depth \json_encode() depth
+	 *
+	 * @return string
+	 * @throws InvalidArgumentException
+	 *   If any of the keys in $keys are not a legal value a phpfastcacheInvalidArgumentException
+	 *   MUST be thrown.
+	 *
+	 */
+	public function getItemsAsJsonString(array $keys = [], int $options = \JSON_THROW_ON_ERROR, int $depth = 512): string;
+
+	public function setItem(CacheItemInterface $item): static;
+
+	public function getStats(): DriverStatistic;
+
+	/**
+	 * Get a quick help guide
+	 * about the current driver
+	 */
+	public function getHelp(): string;
+
+	public function detachItem(CacheItemInterface $item): static;
+
+	public function detachAllItems(): static;
+
+	public function attachItem(CacheItemInterface $item): static;
+
+	/**
+	 * Returns true if the item exists, is attached and the Spl Hash matches
+	 * Returns false if the item exists, is attached and the Spl Hash mismatches
+	 * Returns null if the item does not exist
+	 *
+	 * @param CacheItemInterface $item
+	 * @return bool
+	 * @throws PhpfastcacheLogicException
+	 */
+	public function isAttached(CacheItemInterface $item): bool;
+
+	/**
+	 * Persists a cache item immediately.
+	 *
+	 * @param ExtendedCacheItemInterface|CacheItemInterface $item
+	 *   The cache item to save.
+	 *
+	 * @return bool
+	 *   True if the item was successfully persisted. False if there was an error.
+	 */
+	public function save(ExtendedCacheItemInterface|CacheItemInterface $item): bool;
+
+	/**
+	 * Save multiple items, possible uses:
+	 *  saveMultiple([$item1, $item2, $item3]);
+	 *  saveMultiple($item1, $item2, $item3);
+	 *
+	 * @param ExtendedCacheItemInterface[] $items
+	 * @return bool
+	 */
+	public function saveMultiple(ExtendedCacheItemInterface ...$items): bool;
+
+	/**
+	 * @return DriverIO
+	 */
+	public function getIO(): DriverIO;
 }

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

Indentation +438 added lines, -438 removed lines

@@ -30,442 +30,442 @@
  */
 trait TaggableCacheItemPoolTrait
 {
-    use ExtendedCacheItemPoolTrait;
-
-    /**
-     * @inheritDoc
-     * @throws PhpfastcacheCoreException
-     * @throws PhpfastcacheDriverException
-     * @throws PhpfastcacheInvalidArgumentException
-     * @throws PhpfastcacheLogicException
-     */
-    public function getItemsByTagsAsJsonString(
-        array $tagNames,
-        int $option = \JSON_THROW_ON_ERROR,
-        int $depth = 512,
-        int $strategy = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONE
-    ): string {
-        return \json_encode(
-            \array_map(
-                static fn(CacheItemInterface $item) => $item->get(),
-                \array_values($this->getItemsByTags($tagNames, $strategy))
-            ),
-            $option,
-            $depth,
-        );
-    }
-
-    /**
-     * @inheritDoc
-     * @throws PhpfastcacheCoreException
-     * @throws PhpfastcacheDriverException
-     * @throws PhpfastcacheInvalidArgumentException
-     * @throws PhpfastcacheLogicException
-     */
-    public function getItemsByTags(array $tagNames, int $strategy = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONE): array
-    {
-        $items = [];
-        foreach (\array_unique($tagNames) as $tagName) {
-            $items[] = $this->fetchItemsByTagFromBackend($tagName);
-        }
-
-        $items = \array_merge([], ...$items);
-
-        switch ($strategy) {
-            case TaggableCacheItemPoolInterface::TAG_STRATEGY_ALL:
-                foreach ($items as $key => $item) {
-                    if (\array_diff($tagNames, $item->getTags())) {
-                        unset($items[$key]);
-                    }
-                }
-                break;
-
-            case TaggableCacheItemPoolInterface::TAG_STRATEGY_ONLY:
-                foreach ($items as $key => $item) {
-                    if (\array_diff($tagNames, $item->getTags()) || \array_diff($item->getTags(), $tagNames)) {
-                        unset($items[$key]);
-                    }
-                }
-                break;
-        }
-        return $items;
-    }
-
-    /**
-     * @param string $tagName
-     * @return ExtendedCacheItemInterface[]
-     * @throws PhpfastcacheCoreException
-     * @throws PhpfastcacheDriverException
-     * @throws PhpfastcacheInvalidArgumentException
-     * @throws PhpfastcacheLogicException
-     */
-    protected function fetchItemsByTagFromBackend(string $tagName): array
-    {
-        $driverResponse = $this->getItem($this->getTagKey($tagName));
-
-        if ($driverResponse->isHit()) {
-            $tagsItems = (array)$driverResponse->get();
-            /**
-             * getItems() may provide expired item(s)
-             * themselves provided by a cache of item
-             * keys based stored the tag item.
-             * Therefore, we pass a filter callback
-             * to remove the expired Item(s) provided by
-             * the item keys passed through getItems()
-             *
-             * #headache
-             */
-            return \array_filter(
-                $this->getItems(\array_unique(\array_keys($tagsItems))),
-                static fn (ExtendedCacheItemInterface $item) => $item->isHit(),
-            );
-        }
-        return [];
-    }
-
-    /**
-     * @param string $key
-     * @return string
-     */
-    protected function getTagKey(string $key): string
-    {
-        return TaggableCacheItemPoolInterface::DRIVER_TAGS_KEY_PREFIX . $key;
-    }
-
-    /**
-     * @inheritDoc
-     * @throws PhpfastcacheCoreException
-     * @throws PhpfastcacheInvalidArgumentException
-     * @throws PhpfastcacheLogicException
-     * @throws PhpfastcacheDriverException
-     */
-    public function deleteItemsByTags(array $tagNames, int $strategy = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONE): bool
-    {
-        $return = true;
-
-        foreach ($this->getItemsByTags($tagNames, $strategy) as $item) {
-            $result = $this->deleteItem($item->getKey());
-            if ($result !== true) {
-                $return = $result;
-            }
-        }
-
-        return $return;
-    }
-
-    /**
-     * @inheritDoc
-     * @throws PhpfastcacheCoreException
-     * @throws PhpfastcacheInvalidArgumentException
-     * @throws PhpfastcacheLogicException
-     * @throws PhpfastcacheDriverException
-     */
-    public function deleteItemsByTag(string $tagName, int $strategy = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONE): bool
-    {
-        $return = true;
-        foreach ($this->getItemsByTag($tagName, $strategy) as $item) {
-            $result = $this->deleteItem($item->getKey());
-            if ($result !== true) {
-                $return = $result;
-            }
-        }
-
-        return $return;
-    }
-
-    /**
-     * @inheritDoc
-     * @throws PhpfastcacheCoreException
-     * @throws PhpfastcacheDriverException
-     * @throws PhpfastcacheInvalidArgumentException
-     * @throws PhpfastcacheLogicException
-     */
-    public function getItemsByTag(string $tagName, int $strategy = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONE): array
-    {
-        $items = $this->fetchItemsByTagFromBackend($tagName);
-
-        if ($strategy === TaggableCacheItemPoolInterface::TAG_STRATEGY_ONLY) {
-            foreach ($items as $key => $item) {
-                if (\array_diff($item->getTags(), [$tagName])) {
-                    unset($items[$key]);
-                }
-            }
-        }
-        return $items;
-    }
-
-    /**
-     * @inheritDoc
-     * @throws PhpfastcacheCoreException
-     * @throws PhpfastcacheDriverException
-     * @throws PhpfastcacheInvalidArgumentException
-     * @throws PhpfastcacheLogicException
-     * @throws \ReflectionException
-     */
-    public function incrementItemsByTags(array $tagNames, int $step = 1, int $strategy = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONE): bool
-    {
-        $return = true;
-        foreach ($tagNames as $tagName) {
-            $result = $this->incrementItemsByTag($tagName, $step, $strategy);
-            if ($result !== true) {
-                $return = $result;
-            }
-        }
-
-        return $return;
-    }
-
-    /**
-     * @inheritDoc
-     * @throws PhpfastcacheCoreException
-     * @throws PhpfastcacheDriverException
-     * @throws PhpfastcacheInvalidArgumentException
-     * @throws PhpfastcacheLogicException
-     * @throws \ReflectionException
-     */
-    public function incrementItemsByTag(string $tagName, int $step = 1, int $strategy = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONE): bool
-    {
-        foreach ($this->getItemsByTag($tagName, $strategy) as $item) {
-            $item->increment($step);
-            $this->saveDeferred($item);
-        }
-
-        return $this->commit();
-    }
-
-    /**
-     * @inheritDoc
-     * @throws PhpfastcacheCoreException
-     * @throws PhpfastcacheDriverException
-     * @throws PhpfastcacheInvalidArgumentException
-     * @throws PhpfastcacheLogicException
-     * @throws \ReflectionException
-     */
-    public function decrementItemsByTags(array $tagNames, int $step = 1, int $strategy = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONE): bool
-    {
-        $return = true;
-        foreach ($tagNames as $tagName) {
-            $result = $this->decrementItemsByTag($tagName, $step, $strategy);
-            if ($result !== true) {
-                $return = $result;
-            }
-        }
-
-        return $return;
-    }
-
-    /**
-     * @inheritDoc
-     * @throws PhpfastcacheCoreException
-     * @throws PhpfastcacheDriverException
-     * @throws PhpfastcacheInvalidArgumentException
-     * @throws PhpfastcacheLogicException
-     * @throws \ReflectionException
-     */
-    public function decrementItemsByTag(string $tagName, int $step = 1, int $strategy = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONE): bool
-    {
-        foreach ($this->getItemsByTag($tagName, $strategy) as $item) {
-            $item->decrement($step);
-            $this->saveDeferred($item);
-        }
-
-        return $this->commit();
-    }
-
-    /**
-     * @inheritDoc
-     * @throws PhpfastcacheCoreException
-     * @throws PhpfastcacheDriverException
-     * @throws PhpfastcacheInvalidArgumentException
-     * @throws PhpfastcacheLogicException
-     * @throws \ReflectionException
-     */
-    public function appendItemsByTags(array $tagNames, array|string $data, int $strategy = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONE): bool
-    {
-        $return = true;
-        foreach ($tagNames as $tagName) {
-            $result = $this->appendItemsByTag($tagName, $data, $strategy);
-            if ($result !== true) {
-                $return = $result;
-            }
-        }
-
-        return $return;
-    }
-
-    /**
-     * @inheritDoc
-     * @throws PhpfastcacheCoreException
-     * @throws PhpfastcacheDriverException
-     * @throws PhpfastcacheInvalidArgumentException
-     * @throws PhpfastcacheLogicException
-     * @throws \ReflectionException
-     */
-    public function appendItemsByTag(string $tagName, array|string $data, int $strategy = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONE): bool
-    {
-        foreach ($this->getItemsByTag($tagName, $strategy) as $item) {
-            $item->append($data);
-            $this->saveDeferred($item);
-        }
-
-        return $this->commit();
-    }
-
-    /**
-     * @inheritDoc
-     * @throws PhpfastcacheCoreException
-     * @throws PhpfastcacheDriverException
-     * @throws PhpfastcacheInvalidArgumentException
-     * @throws PhpfastcacheLogicException
-     * @throws \ReflectionException
-     */
-    public function prependItemsByTags(array $tagNames, array|string $data, int $strategy = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONE): bool
-    {
-        $return = true;
-        foreach ($tagNames as $tagName) {
-            $result = $this->prependItemsByTag($tagName, $data, $strategy);
-            if ($result !== true) {
-                $return = $result;
-            }
-        }
-
-        return $return;
-    }
-
-    /**
-     * @inheritDoc
-     * @throws PhpfastcacheCoreException
-     * @throws PhpfastcacheDriverException
-     * @throws PhpfastcacheInvalidArgumentException
-     * @throws PhpfastcacheLogicException
-     * @throws \ReflectionException
-     */
-    public function prependItemsByTag(string $tagName, array|string $data, int $strategy = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONE): bool
-    {
-        foreach ($this->getItemsByTag($tagName, $strategy) as $item) {
-            $item->prepend($data);
-            $this->saveDeferred($item);
-        }
-
-        return $this->commit();
-    }
-
-    /**
-     * @param array<mixed> $wrapper
-     * @return string[]
-     */
-    protected function driverUnwrapTags(array $wrapper): array
-    {
-        return $wrapper[TaggableCacheItemPoolInterface::DRIVER_TAGS_WRAPPER_INDEX];
-    }
-
-    /**
-     * @param ExtendedCacheItemInterface $item
-     * @throws PhpfastcacheCoreException
-     * @throws PhpfastcacheDriverException
-     * @throws PhpfastcacheInvalidArgumentException
-     * @throws PhpfastcacheLogicException
-     */
-    protected function cleanItemTags(ExtendedCacheItemInterface $item): void
-    {
-        if (!empty($item->getTags()) || !empty($item->getRemovedTags())) {
-            $this->driverWriteTags($item->removeTags($item->getTags()));
-        }
-    }
-
-    /**
-     * @param ExtendedCacheItemInterface $item
-     * @return bool
-     * @throws PhpfastcacheCoreException
-     * @throws PhpfastcacheInvalidArgumentException
-     * @throws PhpfastcacheLogicException
-     * @throws PhpfastcacheDriverException
-     */
-    protected function driverWriteTags(ExtendedCacheItemInterface $item): bool
-    {
-        /**
-         * Do not attempt to write tags
-         * on tags item, it can lead
-         * to an infinite recursive calls
-         */
-        if (str_starts_with($item->getKey(), TaggableCacheItemPoolInterface::DRIVER_TAGS_KEY_PREFIX)) {
-            throw new PhpfastcacheLogicException('Trying to set tag(s) to an Tag item index: ' . $item->getKey());
-        }
-
-        if (!$item->getTags() && !$item->getRemovedTags()) {
-            return true;
-        }
-
-        /**
-         * @var $tagsItems ExtendedCacheItemInterface[]
-         */
-        $tagsItems = $this->getItems($this->getTagKeys($item->getTags()));
-
-        foreach ($tagsItems as $tagsItem) {
-            $data = $tagsItem->get();
-            $expTimestamp = $item->getExpirationDate()->getTimestamp();
-
-            /**
-             * Using the key will
-             * avoid to use array_unique
-             * that has slow performances
-             */
-            $data = \array_merge((array)$data, [$item->getKey() => $expTimestamp]);
-            $tagsItem->set($data);
-
-            /**
-             * Recalculate the expiration date
-             *
-             * If the $tagsItem does not have
-             * any cache item references left
-             * then remove it from tagsItems index
-             */
-            $tagsItem->expiresAt((new DateTime())->setTimestamp(max($data)));
-
-            $this->driverWrite($tagsItem);
-            $tagsItem->setHit(true);
-        }
-
-        /**
-         * Also update removed tags to
-         * keep the index up to date
-         */
-        $tagsItems = $this->getItems($this->getTagKeys($item->getRemovedTags()));
-
-        foreach ($tagsItems as $tagsItem) {
-            $data = (array)$tagsItem->get();
-
-            unset($data[$item->getKey()]);
-            $tagsItem->set($data);
-
-            /**
-             * Recalculate the expiration date
-             *
-             * If the $tagsItem does not have
-             * any cache item references left
-             * then remove it from tagsItems index
-             */
-            if (\count($data)) {
-                $tagsItem->expiresAt((new DateTime())->setTimestamp(max($data)));
-                $this->driverWrite($tagsItem);
-                $tagsItem->setHit(true);
-            } else {
-                $this->deleteItem($tagsItem->getKey());
-            }
-        }
-
-        return true;
-    }
-
-    /**
-     * @param array<string> $keys
-     * @return array<string>
-     */
-    protected function getTagKeys(array $keys): array
-    {
-        return \array_map(
-            fn (string $key) => $this->getTagKey($key),
-            $keys
-        );
-    }
+	use ExtendedCacheItemPoolTrait;
+
+	/**
+	 * @inheritDoc
+	 * @throws PhpfastcacheCoreException
+	 * @throws PhpfastcacheDriverException
+	 * @throws PhpfastcacheInvalidArgumentException
+	 * @throws PhpfastcacheLogicException
+	 */
+	public function getItemsByTagsAsJsonString(
+		array $tagNames,
+		int $option = \JSON_THROW_ON_ERROR,
+		int $depth = 512,
+		int $strategy = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONE
+	): string {
+		return \json_encode(
+			\array_map(
+				static fn(CacheItemInterface $item) => $item->get(),
+				\array_values($this->getItemsByTags($tagNames, $strategy))
+			),
+			$option,
+			$depth,
+		);
+	}
+
+	/**
+	 * @inheritDoc
+	 * @throws PhpfastcacheCoreException
+	 * @throws PhpfastcacheDriverException
+	 * @throws PhpfastcacheInvalidArgumentException
+	 * @throws PhpfastcacheLogicException
+	 */
+	public function getItemsByTags(array $tagNames, int $strategy = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONE): array
+	{
+		$items = [];
+		foreach (\array_unique($tagNames) as $tagName) {
+			$items[] = $this->fetchItemsByTagFromBackend($tagName);
+		}
+
+		$items = \array_merge([], ...$items);
+
+		switch ($strategy) {
+			case TaggableCacheItemPoolInterface::TAG_STRATEGY_ALL:
+				foreach ($items as $key => $item) {
+					if (\array_diff($tagNames, $item->getTags())) {
+						unset($items[$key]);
+					}
+				}
+				break;
+
+			case TaggableCacheItemPoolInterface::TAG_STRATEGY_ONLY:
+				foreach ($items as $key => $item) {
+					if (\array_diff($tagNames, $item->getTags()) || \array_diff($item->getTags(), $tagNames)) {
+						unset($items[$key]);
+					}
+				}
+				break;
+		}
+		return $items;
+	}
+
+	/**
+	 * @param string $tagName
+	 * @return ExtendedCacheItemInterface[]
+	 * @throws PhpfastcacheCoreException
+	 * @throws PhpfastcacheDriverException
+	 * @throws PhpfastcacheInvalidArgumentException
+	 * @throws PhpfastcacheLogicException
+	 */
+	protected function fetchItemsByTagFromBackend(string $tagName): array
+	{
+		$driverResponse = $this->getItem($this->getTagKey($tagName));
+
+		if ($driverResponse->isHit()) {
+			$tagsItems = (array)$driverResponse->get();
+			/**
+			 * getItems() may provide expired item(s)
+			 * themselves provided by a cache of item
+			 * keys based stored the tag item.
+			 * Therefore, we pass a filter callback
+			 * to remove the expired Item(s) provided by
+			 * the item keys passed through getItems()
+			 *
+			 * #headache
+			 */
+			return \array_filter(
+				$this->getItems(\array_unique(\array_keys($tagsItems))),
+				static fn (ExtendedCacheItemInterface $item) => $item->isHit(),
+			);
+		}
+		return [];
+	}
+
+	/**
+	 * @param string $key
+	 * @return string
+	 */
+	protected function getTagKey(string $key): string
+	{
+		return TaggableCacheItemPoolInterface::DRIVER_TAGS_KEY_PREFIX . $key;
+	}
+
+	/**
+	 * @inheritDoc
+	 * @throws PhpfastcacheCoreException
+	 * @throws PhpfastcacheInvalidArgumentException
+	 * @throws PhpfastcacheLogicException
+	 * @throws PhpfastcacheDriverException
+	 */
+	public function deleteItemsByTags(array $tagNames, int $strategy = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONE): bool
+	{
+		$return = true;
+
+		foreach ($this->getItemsByTags($tagNames, $strategy) as $item) {
+			$result = $this->deleteItem($item->getKey());
+			if ($result !== true) {
+				$return = $result;
+			}
+		}
+
+		return $return;
+	}
+
+	/**
+	 * @inheritDoc
+	 * @throws PhpfastcacheCoreException
+	 * @throws PhpfastcacheInvalidArgumentException
+	 * @throws PhpfastcacheLogicException
+	 * @throws PhpfastcacheDriverException
+	 */
+	public function deleteItemsByTag(string $tagName, int $strategy = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONE): bool
+	{
+		$return = true;
+		foreach ($this->getItemsByTag($tagName, $strategy) as $item) {
+			$result = $this->deleteItem($item->getKey());
+			if ($result !== true) {
+				$return = $result;
+			}
+		}
+
+		return $return;
+	}
+
+	/**
+	 * @inheritDoc
+	 * @throws PhpfastcacheCoreException
+	 * @throws PhpfastcacheDriverException
+	 * @throws PhpfastcacheInvalidArgumentException
+	 * @throws PhpfastcacheLogicException
+	 */
+	public function getItemsByTag(string $tagName, int $strategy = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONE): array
+	{
+		$items = $this->fetchItemsByTagFromBackend($tagName);
+
+		if ($strategy === TaggableCacheItemPoolInterface::TAG_STRATEGY_ONLY) {
+			foreach ($items as $key => $item) {
+				if (\array_diff($item->getTags(), [$tagName])) {
+					unset($items[$key]);
+				}
+			}
+		}
+		return $items;
+	}
+
+	/**
+	 * @inheritDoc
+	 * @throws PhpfastcacheCoreException
+	 * @throws PhpfastcacheDriverException
+	 * @throws PhpfastcacheInvalidArgumentException
+	 * @throws PhpfastcacheLogicException
+	 * @throws \ReflectionException
+	 */
+	public function incrementItemsByTags(array $tagNames, int $step = 1, int $strategy = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONE): bool
+	{
+		$return = true;
+		foreach ($tagNames as $tagName) {
+			$result = $this->incrementItemsByTag($tagName, $step, $strategy);
+			if ($result !== true) {
+				$return = $result;
+			}
+		}
+
+		return $return;
+	}
+
+	/**
+	 * @inheritDoc
+	 * @throws PhpfastcacheCoreException
+	 * @throws PhpfastcacheDriverException
+	 * @throws PhpfastcacheInvalidArgumentException
+	 * @throws PhpfastcacheLogicException
+	 * @throws \ReflectionException
+	 */
+	public function incrementItemsByTag(string $tagName, int $step = 1, int $strategy = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONE): bool
+	{
+		foreach ($this->getItemsByTag($tagName, $strategy) as $item) {
+			$item->increment($step);
+			$this->saveDeferred($item);
+		}
+
+		return $this->commit();
+	}
+
+	/**
+	 * @inheritDoc
+	 * @throws PhpfastcacheCoreException
+	 * @throws PhpfastcacheDriverException
+	 * @throws PhpfastcacheInvalidArgumentException
+	 * @throws PhpfastcacheLogicException
+	 * @throws \ReflectionException
+	 */
+	public function decrementItemsByTags(array $tagNames, int $step = 1, int $strategy = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONE): bool
+	{
+		$return = true;
+		foreach ($tagNames as $tagName) {
+			$result = $this->decrementItemsByTag($tagName, $step, $strategy);
+			if ($result !== true) {
+				$return = $result;
+			}
+		}
+
+		return $return;
+	}
+
+	/**
+	 * @inheritDoc
+	 * @throws PhpfastcacheCoreException
+	 * @throws PhpfastcacheDriverException
+	 * @throws PhpfastcacheInvalidArgumentException
+	 * @throws PhpfastcacheLogicException
+	 * @throws \ReflectionException
+	 */
+	public function decrementItemsByTag(string $tagName, int $step = 1, int $strategy = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONE): bool
+	{
+		foreach ($this->getItemsByTag($tagName, $strategy) as $item) {
+			$item->decrement($step);
+			$this->saveDeferred($item);
+		}
+
+		return $this->commit();
+	}
+
+	/**
+	 * @inheritDoc
+	 * @throws PhpfastcacheCoreException
+	 * @throws PhpfastcacheDriverException
+	 * @throws PhpfastcacheInvalidArgumentException
+	 * @throws PhpfastcacheLogicException
+	 * @throws \ReflectionException
+	 */
+	public function appendItemsByTags(array $tagNames, array|string $data, int $strategy = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONE): bool
+	{
+		$return = true;
+		foreach ($tagNames as $tagName) {
+			$result = $this->appendItemsByTag($tagName, $data, $strategy);
+			if ($result !== true) {
+				$return = $result;
+			}
+		}
+
+		return $return;
+	}
+
+	/**
+	 * @inheritDoc
+	 * @throws PhpfastcacheCoreException
+	 * @throws PhpfastcacheDriverException
+	 * @throws PhpfastcacheInvalidArgumentException
+	 * @throws PhpfastcacheLogicException
+	 * @throws \ReflectionException
+	 */
+	public function appendItemsByTag(string $tagName, array|string $data, int $strategy = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONE): bool
+	{
+		foreach ($this->getItemsByTag($tagName, $strategy) as $item) {
+			$item->append($data);
+			$this->saveDeferred($item);
+		}
+
+		return $this->commit();
+	}
+
+	/**
+	 * @inheritDoc
+	 * @throws PhpfastcacheCoreException
+	 * @throws PhpfastcacheDriverException
+	 * @throws PhpfastcacheInvalidArgumentException
+	 * @throws PhpfastcacheLogicException
+	 * @throws \ReflectionException
+	 */
+	public function prependItemsByTags(array $tagNames, array|string $data, int $strategy = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONE): bool
+	{
+		$return = true;
+		foreach ($tagNames as $tagName) {
+			$result = $this->prependItemsByTag($tagName, $data, $strategy);
+			if ($result !== true) {
+				$return = $result;
+			}
+		}
+
+		return $return;
+	}
+
+	/**
+	 * @inheritDoc
+	 * @throws PhpfastcacheCoreException
+	 * @throws PhpfastcacheDriverException
+	 * @throws PhpfastcacheInvalidArgumentException
+	 * @throws PhpfastcacheLogicException
+	 * @throws \ReflectionException
+	 */
+	public function prependItemsByTag(string $tagName, array|string $data, int $strategy = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONE): bool
+	{
+		foreach ($this->getItemsByTag($tagName, $strategy) as $item) {
+			$item->prepend($data);
+			$this->saveDeferred($item);
+		}
+
+		return $this->commit();
+	}
+
+	/**
+	 * @param array<mixed> $wrapper
+	 * @return string[]
+	 */
+	protected function driverUnwrapTags(array $wrapper): array
+	{
+		return $wrapper[TaggableCacheItemPoolInterface::DRIVER_TAGS_WRAPPER_INDEX];
+	}
+
+	/**
+	 * @param ExtendedCacheItemInterface $item
+	 * @throws PhpfastcacheCoreException
+	 * @throws PhpfastcacheDriverException
+	 * @throws PhpfastcacheInvalidArgumentException
+	 * @throws PhpfastcacheLogicException
+	 */
+	protected function cleanItemTags(ExtendedCacheItemInterface $item): void
+	{
+		if (!empty($item->getTags()) || !empty($item->getRemovedTags())) {
+			$this->driverWriteTags($item->removeTags($item->getTags()));
+		}
+	}
+
+	/**
+	 * @param ExtendedCacheItemInterface $item
+	 * @return bool
+	 * @throws PhpfastcacheCoreException
+	 * @throws PhpfastcacheInvalidArgumentException
+	 * @throws PhpfastcacheLogicException
+	 * @throws PhpfastcacheDriverException
+	 */
+	protected function driverWriteTags(ExtendedCacheItemInterface $item): bool
+	{
+		/**
+		 * Do not attempt to write tags
+		 * on tags item, it can lead
+		 * to an infinite recursive calls
+		 */
+		if (str_starts_with($item->getKey(), TaggableCacheItemPoolInterface::DRIVER_TAGS_KEY_PREFIX)) {
+			throw new PhpfastcacheLogicException('Trying to set tag(s) to an Tag item index: ' . $item->getKey());
+		}
+
+		if (!$item->getTags() && !$item->getRemovedTags()) {
+			return true;
+		}
+
+		/**
+		 * @var $tagsItems ExtendedCacheItemInterface[]
+		 */
+		$tagsItems = $this->getItems($this->getTagKeys($item->getTags()));
+
+		foreach ($tagsItems as $tagsItem) {
+			$data = $tagsItem->get();
+			$expTimestamp = $item->getExpirationDate()->getTimestamp();
+
+			/**
+			 * Using the key will
+			 * avoid to use array_unique
+			 * that has slow performances
+			 */
+			$data = \array_merge((array)$data, [$item->getKey() => $expTimestamp]);
+			$tagsItem->set($data);
+
+			/**
+			 * Recalculate the expiration date
+			 *
+			 * If the $tagsItem does not have
+			 * any cache item references left
+			 * then remove it from tagsItems index
+			 */
+			$tagsItem->expiresAt((new DateTime())->setTimestamp(max($data)));
+
+			$this->driverWrite($tagsItem);
+			$tagsItem->setHit(true);
+		}
+
+		/**
+		 * Also update removed tags to
+		 * keep the index up to date
+		 */
+		$tagsItems = $this->getItems($this->getTagKeys($item->getRemovedTags()));
+
+		foreach ($tagsItems as $tagsItem) {
+			$data = (array)$tagsItem->get();
+
+			unset($data[$item->getKey()]);
+			$tagsItem->set($data);
+
+			/**
+			 * Recalculate the expiration date
+			 *
+			 * If the $tagsItem does not have
+			 * any cache item references left
+			 * then remove it from tagsItems index
+			 */
+			if (\count($data)) {
+				$tagsItem->expiresAt((new DateTime())->setTimestamp(max($data)));
+				$this->driverWrite($tagsItem);
+				$tagsItem->setHit(true);
+			} else {
+				$this->deleteItem($tagsItem->getKey());
+			}
+		}
+
+		return true;
+	}
+
+	/**
+	 * @param array<string> $keys
+	 * @return array<string>
+	 */
+	protected function getTagKeys(array $keys): array
+	{
+		return \array_map(
+			fn (string $key) => $this->getTagKey($key),
+			$keys
+		);
+	}
 }

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

Indentation +282 added lines, -282 removed lines

@@ -39,286 +39,286 @@
 
 trait DriverBaseTrait
 {
-    use DriverPoolAbstractTrait;
-    use ClassNamespaceResolverTrait;
-    use EventManagerDispatcherTrait;
-
-    /**
-     * @var string[]
-     */
-    protected static array $cacheItemClasses = [];
-
-    protected ConfigurationOptionInterface $config;
-
-    /**
-     * @var object|null
-     */
-    protected ?object $instance;
-
-    protected string $driverName;
-
-    protected string $instanceId;
-
-    /**
-     * Driver constructor.
-     * @param ConfigurationOptionInterface $config
-     * @param string $instanceId
-     * @param EventManagerInterface $em
-     * @throws PhpfastcacheCoreException
-     * @throws PhpfastcacheDriverCheckException
-     * @throws PhpfastcacheDriverConnectException
-     * @throws PhpfastcacheIOException
-     * @throws PhpfastcacheInvalidArgumentException
-     */
-    public function __construct(#[\SensitiveParameter] ConfigurationOptionInterface $config, string $instanceId, EventManagerInterface $em)
-    {
-        $this->setEventManager($em->getScopedEventManager($this));
-        $this->setConfig($config);
-        $this->instanceId = $instanceId;
-
-        if (!$this->driverCheck()) {
-            throw new PhpfastcacheDriverCheckException(
-                \sprintf(
-                    ExtendedCacheItemPoolInterface::DRIVER_CHECK_FAILURE,
-                    $this->getDriverName(),
-                    $this->getHelp() ? " Additionally, {$this->getHelp()}" : ''
-                )
-            );
-        }
-        $this->eventManager->dispatch(Event::CACHE_DRIVER_CHECKED, $this);
-
-        try {
-            $this->driverConnect();
-            $config->lock($this); // Lock the config only after a successful driver connection.
-            $this->eventManager->dispatch(Event::CACHE_DRIVER_CONNECTED, $this, $this->instance ?? null);
-        } catch (Throwable $e) {
-            throw new PhpfastcacheDriverConnectException(
-                sprintf(
-                    ExtendedCacheItemPoolInterface::DRIVER_CONNECT_FAILURE,
-                    $this->getDriverName(),
-                    $e->getMessage(),
-                    $e->getLine() ?: 'unknown line',
-                    $e->getFile() ?: 'unknown file',
-                ),
-                0,
-                $e
-            );
-        }
-    }
-
-    /**
-     * @return string
-     */
-    public function getDriverName(): string
-    {
-        if (!isset($this->driverName)) {
-            $this->driverName = \ucfirst(\substr(\strrchr((new ReflectionObject($this))->getNamespaceName(), '\\'), 1));
-        }
-        return $this->driverName;
-    }
-
-    /**
-     * @return ConfigurationOptionInterface
-     */
-    public function getDefaultConfig(): ConfigurationOptionInterface
-    {
-        $className = $this::getConfigClass();
-
-        return new $className();
-    }
-
-    /**
-     * @return string
-     */
-    public static function getConfigClass(): string
-    {
-        $localConfigClass = \substr(static::class, 0, \strrpos(static::class, '\\')) . '\Config';
-        if (\class_exists($localConfigClass) && \is_a($localConfigClass, ConfigurationOption::class, true)) {
-            return $localConfigClass;
-        }
-        return ConfigurationOption::class;
-    }
-
-    public static function getItemClass(): string
-    {
-        if (!isset(self::$cacheItemClasses[static::class])) {
-            self::$cacheItemClasses[static::class] = self::getClassNamespace() . '\\' . 'Item';
-        }
-
-        return self::$cacheItemClasses[static::class];
-    }
-
-    /**
-     * @inheritDoc
-     */
-    public function getEncodedKey(string $key): string
-    {
-        $keyHashFunction = $this->getConfig()->getDefaultKeyHashFunction();
-
-        if ($keyHashFunction) {
-            if (\is_callable($keyHashFunction)) {
-                return $keyHashFunction($key);
-            }
-            throw new PhpfastcacheLogicException('Unable to build the encoded key (defaultKeyHashFunction is not callable)');
-        }
-
-        return $key;
-    }
-
-
-
-    /**
-     * @param ExtendedCacheItemInterface $item
-     * @param bool $stringifyDate
-     * @return array<string, mixed>
-     * @throws PhpfastcacheLogicException
-     */
-    public function driverPreWrap(ExtendedCacheItemInterface $item, bool $stringifyDate = false): array
-    {
-        $wrap = [
-            ExtendedCacheItemPoolInterface::DRIVER_KEY_WRAPPER_INDEX => $item->getKey(), // Stored but not really used, allow you to quickly identify the cache key
-            ExtendedCacheItemPoolInterface::DRIVER_DATA_WRAPPER_INDEX => $item->_getData(),
-            ExtendedCacheItemPoolInterface::DRIVER_EDATE_WRAPPER_INDEX => $item->getExpirationDate(),
-            TaggableCacheItemPoolInterface::DRIVER_TAGS_WRAPPER_INDEX => $item->getTags(),
-        ];
-
-        if ($this->getConfig()->isItemDetailedDate()) {
-            $wrap[ExtendedCacheItemPoolInterface::DRIVER_MDATE_WRAPPER_INDEX] = new DateTime();// Always on the latest date
-            /**
-             * If the creation date exists
-             * reuse it else set a new Date
-             */
-            $wrap[ExtendedCacheItemPoolInterface::DRIVER_CDATE_WRAPPER_INDEX] = $item->getCreationDate();
-        } else {
-            $wrap[ExtendedCacheItemPoolInterface::DRIVER_MDATE_WRAPPER_INDEX] = null;
-            $wrap[ExtendedCacheItemPoolInterface::DRIVER_CDATE_WRAPPER_INDEX] = null;
-        }
-
-        if ($stringifyDate) {
-            \array_walk($wrap, static function (mixed &$value, string $key): void {
-                if ($value instanceof DateTimeInterface && $key !== ExtendedCacheItemPoolInterface::DRIVER_DATA_WRAPPER_INDEX) {
-                    $value = $value->format(DateTimeInterface::W3C);
-                }
-            });
-        }
-
-        return $wrap;
-    }
-
-    /**
-     * @return ConfigurationOptionInterface
-     */
-    public function getConfig(): ConfigurationOptionInterface
-    {
-        return $this->config;
-    }
-
-    /**
-     * @param ConfigurationOptionInterface $config
-     * @return static
-     */
-    public function setConfig(ConfigurationOptionInterface $config): static
-    {
-        $this->config = $config;
-
-        return $this;
-    }
-
-    /**
-     * @param array<string, mixed> $wrapper
-     * @return mixed
-     * @throws \Exception
-     */
-    public function driverUnwrapData(array $wrapper): mixed
-    {
-        return $wrapper[ExtendedCacheItemPoolInterface::DRIVER_DATA_WRAPPER_INDEX];
-    }
-
-    /**
-     * @param array<string, mixed> $wrapper
-     * @return DateTimeInterface
-     */
-    public function driverUnwrapEdate(array $wrapper): \DateTimeInterface
-    {
-        if ($wrapper[ExtendedCacheItemPoolInterface::DRIVER_EDATE_WRAPPER_INDEX] instanceof \DateTimeInterface) {
-            return $wrapper[ExtendedCacheItemPoolInterface::DRIVER_EDATE_WRAPPER_INDEX];
-        }
-
-        return DateTime::createFromFormat(\DateTimeInterface::W3C, $wrapper[ExtendedCacheItemPoolInterface::DRIVER_EDATE_WRAPPER_INDEX]);
-    }
-
-    /**
-     * @param array<string, mixed> $wrapper
-     * @return DateTimeInterface|null
-     */
-    public function driverUnwrapCdate(array $wrapper): ?\DateTimeInterface
-    {
-        if ($wrapper[ExtendedCacheItemPoolInterface::DRIVER_CDATE_WRAPPER_INDEX] instanceof \DateTimeInterface) {
-            return $wrapper[ExtendedCacheItemPoolInterface::DRIVER_CDATE_WRAPPER_INDEX];
-        }
-
-        return DateTime::createFromFormat(\DateTimeInterface::W3C, $wrapper[ExtendedCacheItemPoolInterface::DRIVER_CDATE_WRAPPER_INDEX]);
-    }
-
-    /**
-     * @param array<string, mixed> $wrapper
-     * @return DateTimeInterface|null
-     */
-    public function driverUnwrapMdate(array $wrapper): ?\DateTimeInterface
-    {
-        if ($wrapper[ExtendedCacheItemPoolInterface::DRIVER_MDATE_WRAPPER_INDEX] instanceof \DateTimeInterface) {
-            return $wrapper[ExtendedCacheItemPoolInterface::DRIVER_MDATE_WRAPPER_INDEX];
-        }
-
-        return DateTime::createFromFormat(\DateTimeInterface::W3C, $wrapper[ExtendedCacheItemPoolInterface::DRIVER_MDATE_WRAPPER_INDEX]);
-    }
-
-    /**
-     * @return string
-     */
-    public function getInstanceId(): string
-    {
-        return $this->instanceId;
-    }
-
-    /**
-     * Encode data types such as object/array
-     * for driver that does not support
-     * non-scalar value
-     * @param mixed $data
-     * @return string
-     */
-    protected function encode(mixed $data): string
-    {
-        return \serialize($data);
-    }
-
-    /**
-     * Decode data stored in the cache
-     * for driver that does not support
-     * non-scalar value storage.
-     * @param string|null $value
-     * @return array<string, mixed>|null
-     * @throws PhpfastcacheDriverException
-     */
-    protected function decode(?string $value): ?array
-    {
-        $decoded = $this->unserialize($value);
-
-        if ($decoded === null || is_array($decoded)) {
-            return $decoded;
-        }
-        throw new PhpfastcacheCorruptedDataException(
-            sprintf(
-                'Failed to unserialize data from the cache, expected array or null but got "%s". Stored data may be corrupted.',
-                gettype($decoded)
-            ),
-            $value
-        );
-    }
-
-    protected function unserialize(?string $value): mixed
-    {
-        return $value ? \unserialize($value, ['allowed_classes' => true]) : null;
-    }
+	use DriverPoolAbstractTrait;
+	use ClassNamespaceResolverTrait;
+	use EventManagerDispatcherTrait;
+
+	/**
+	 * @var string[]
+	 */
+	protected static array $cacheItemClasses = [];
+
+	protected ConfigurationOptionInterface $config;
+
+	/**
+	 * @var object|null
+	 */
+	protected ?object $instance;
+
+	protected string $driverName;
+
+	protected string $instanceId;
+
+	/**
+	 * Driver constructor.
+	 * @param ConfigurationOptionInterface $config
+	 * @param string $instanceId
+	 * @param EventManagerInterface $em
+	 * @throws PhpfastcacheCoreException
+	 * @throws PhpfastcacheDriverCheckException
+	 * @throws PhpfastcacheDriverConnectException
+	 * @throws PhpfastcacheIOException
+	 * @throws PhpfastcacheInvalidArgumentException
+	 */
+	public function __construct(#[\SensitiveParameter] ConfigurationOptionInterface $config, string $instanceId, EventManagerInterface $em)
+	{
+		$this->setEventManager($em->getScopedEventManager($this));
+		$this->setConfig($config);
+		$this->instanceId = $instanceId;
+
+		if (!$this->driverCheck()) {
+			throw new PhpfastcacheDriverCheckException(
+				\sprintf(
+					ExtendedCacheItemPoolInterface::DRIVER_CHECK_FAILURE,
+					$this->getDriverName(),
+					$this->getHelp() ? " Additionally, {$this->getHelp()}" : ''
+				)
+			);
+		}
+		$this->eventManager->dispatch(Event::CACHE_DRIVER_CHECKED, $this);
+
+		try {
+			$this->driverConnect();
+			$config->lock($this); // Lock the config only after a successful driver connection.
+			$this->eventManager->dispatch(Event::CACHE_DRIVER_CONNECTED, $this, $this->instance ?? null);
+		} catch (Throwable $e) {
+			throw new PhpfastcacheDriverConnectException(
+				sprintf(
+					ExtendedCacheItemPoolInterface::DRIVER_CONNECT_FAILURE,
+					$this->getDriverName(),
+					$e->getMessage(),
+					$e->getLine() ?: 'unknown line',
+					$e->getFile() ?: 'unknown file',
+				),
+				0,
+				$e
+			);
+		}
+	}
+
+	/**
+	 * @return string
+	 */
+	public function getDriverName(): string
+	{
+		if (!isset($this->driverName)) {
+			$this->driverName = \ucfirst(\substr(\strrchr((new ReflectionObject($this))->getNamespaceName(), '\\'), 1));
+		}
+		return $this->driverName;
+	}
+
+	/**
+	 * @return ConfigurationOptionInterface
+	 */
+	public function getDefaultConfig(): ConfigurationOptionInterface
+	{
+		$className = $this::getConfigClass();
+
+		return new $className();
+	}
+
+	/**
+	 * @return string
+	 */
+	public static function getConfigClass(): string
+	{
+		$localConfigClass = \substr(static::class, 0, \strrpos(static::class, '\\')) . '\Config';
+		if (\class_exists($localConfigClass) && \is_a($localConfigClass, ConfigurationOption::class, true)) {
+			return $localConfigClass;
+		}
+		return ConfigurationOption::class;
+	}
+
+	public static function getItemClass(): string
+	{
+		if (!isset(self::$cacheItemClasses[static::class])) {
+			self::$cacheItemClasses[static::class] = self::getClassNamespace() . '\\' . 'Item';
+		}
+
+		return self::$cacheItemClasses[static::class];
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function getEncodedKey(string $key): string
+	{
+		$keyHashFunction = $this->getConfig()->getDefaultKeyHashFunction();
+
+		if ($keyHashFunction) {
+			if (\is_callable($keyHashFunction)) {
+				return $keyHashFunction($key);
+			}
+			throw new PhpfastcacheLogicException('Unable to build the encoded key (defaultKeyHashFunction is not callable)');
+		}
+
+		return $key;
+	}
+
+
+
+	/**
+	 * @param ExtendedCacheItemInterface $item
+	 * @param bool $stringifyDate
+	 * @return array<string, mixed>
+	 * @throws PhpfastcacheLogicException
+	 */
+	public function driverPreWrap(ExtendedCacheItemInterface $item, bool $stringifyDate = false): array
+	{
+		$wrap = [
+			ExtendedCacheItemPoolInterface::DRIVER_KEY_WRAPPER_INDEX => $item->getKey(), // Stored but not really used, allow you to quickly identify the cache key
+			ExtendedCacheItemPoolInterface::DRIVER_DATA_WRAPPER_INDEX => $item->_getData(),
+			ExtendedCacheItemPoolInterface::DRIVER_EDATE_WRAPPER_INDEX => $item->getExpirationDate(),
+			TaggableCacheItemPoolInterface::DRIVER_TAGS_WRAPPER_INDEX => $item->getTags(),
+		];
+
+		if ($this->getConfig()->isItemDetailedDate()) {
+			$wrap[ExtendedCacheItemPoolInterface::DRIVER_MDATE_WRAPPER_INDEX] = new DateTime();// Always on the latest date
+			/**
+			 * If the creation date exists
+			 * reuse it else set a new Date
+			 */
+			$wrap[ExtendedCacheItemPoolInterface::DRIVER_CDATE_WRAPPER_INDEX] = $item->getCreationDate();
+		} else {
+			$wrap[ExtendedCacheItemPoolInterface::DRIVER_MDATE_WRAPPER_INDEX] = null;
+			$wrap[ExtendedCacheItemPoolInterface::DRIVER_CDATE_WRAPPER_INDEX] = null;
+		}
+
+		if ($stringifyDate) {
+			\array_walk($wrap, static function (mixed &$value, string $key): void {
+				if ($value instanceof DateTimeInterface && $key !== ExtendedCacheItemPoolInterface::DRIVER_DATA_WRAPPER_INDEX) {
+					$value = $value->format(DateTimeInterface::W3C);
+				}
+			});
+		}
+
+		return $wrap;
+	}
+
+	/**
+	 * @return ConfigurationOptionInterface
+	 */
+	public function getConfig(): ConfigurationOptionInterface
+	{
+		return $this->config;
+	}
+
+	/**
+	 * @param ConfigurationOptionInterface $config
+	 * @return static
+	 */
+	public function setConfig(ConfigurationOptionInterface $config): static
+	{
+		$this->config = $config;
+
+		return $this;
+	}
+
+	/**
+	 * @param array<string, mixed> $wrapper
+	 * @return mixed
+	 * @throws \Exception
+	 */
+	public function driverUnwrapData(array $wrapper): mixed
+	{
+		return $wrapper[ExtendedCacheItemPoolInterface::DRIVER_DATA_WRAPPER_INDEX];
+	}
+
+	/**
+	 * @param array<string, mixed> $wrapper
+	 * @return DateTimeInterface
+	 */
+	public function driverUnwrapEdate(array $wrapper): \DateTimeInterface
+	{
+		if ($wrapper[ExtendedCacheItemPoolInterface::DRIVER_EDATE_WRAPPER_INDEX] instanceof \DateTimeInterface) {
+			return $wrapper[ExtendedCacheItemPoolInterface::DRIVER_EDATE_WRAPPER_INDEX];
+		}
+
+		return DateTime::createFromFormat(\DateTimeInterface::W3C, $wrapper[ExtendedCacheItemPoolInterface::DRIVER_EDATE_WRAPPER_INDEX]);
+	}
+
+	/**
+	 * @param array<string, mixed> $wrapper
+	 * @return DateTimeInterface|null
+	 */
+	public function driverUnwrapCdate(array $wrapper): ?\DateTimeInterface
+	{
+		if ($wrapper[ExtendedCacheItemPoolInterface::DRIVER_CDATE_WRAPPER_INDEX] instanceof \DateTimeInterface) {
+			return $wrapper[ExtendedCacheItemPoolInterface::DRIVER_CDATE_WRAPPER_INDEX];
+		}
+
+		return DateTime::createFromFormat(\DateTimeInterface::W3C, $wrapper[ExtendedCacheItemPoolInterface::DRIVER_CDATE_WRAPPER_INDEX]);
+	}
+
+	/**
+	 * @param array<string, mixed> $wrapper
+	 * @return DateTimeInterface|null
+	 */
+	public function driverUnwrapMdate(array $wrapper): ?\DateTimeInterface
+	{
+		if ($wrapper[ExtendedCacheItemPoolInterface::DRIVER_MDATE_WRAPPER_INDEX] instanceof \DateTimeInterface) {
+			return $wrapper[ExtendedCacheItemPoolInterface::DRIVER_MDATE_WRAPPER_INDEX];
+		}
+
+		return DateTime::createFromFormat(\DateTimeInterface::W3C, $wrapper[ExtendedCacheItemPoolInterface::DRIVER_MDATE_WRAPPER_INDEX]);
+	}
+
+	/**
+	 * @return string
+	 */
+	public function getInstanceId(): string
+	{
+		return $this->instanceId;
+	}
+
+	/**
+	 * Encode data types such as object/array
+	 * for driver that does not support
+	 * non-scalar value
+	 * @param mixed $data
+	 * @return string
+	 */
+	protected function encode(mixed $data): string
+	{
+		return \serialize($data);
+	}
+
+	/**
+	 * Decode data stored in the cache
+	 * for driver that does not support
+	 * non-scalar value storage.
+	 * @param string|null $value
+	 * @return array<string, mixed>|null
+	 * @throws PhpfastcacheDriverException
+	 */
+	protected function decode(?string $value): ?array
+	{
+		$decoded = $this->unserialize($value);
+
+		if ($decoded === null || is_array($decoded)) {
+			return $decoded;
+		}
+		throw new PhpfastcacheCorruptedDataException(
+			sprintf(
+				'Failed to unserialize data from the cache, expected array or null but got "%s". Stored data may be corrupted.',
+				gettype($decoded)
+			),
+			$value
+		);
+	}
+
+	protected function unserialize(?string $value): mixed
+	{
+		return $value ? \unserialize($value, ['allowed_classes' => true]) : null;
+	}
 }

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

Indentation +10 added lines, -10 removed lines

@@ -18,17 +18,17 @@
 
 trait AggregatablePoolTrait
 {
-    protected ?ClusterPoolInterface $clusterPool = null;
+	protected ?ClusterPoolInterface $clusterPool = null;
 
-    public function isAggregatedBy(): ?ClusterPoolInterface
-    {
-        return $this->clusterPool;
-    }
+	public function isAggregatedBy(): ?ClusterPoolInterface
+	{
+		return $this->clusterPool;
+	}
 
-    public function setAggregatedBy(ClusterPoolInterface $clusterPool): static
-    {
-        $this->clusterPool = $clusterPool;
+	public function setAggregatedBy(ClusterPoolInterface $clusterPool): static
+	{
+		$this->clusterPool = $clusterPool;
 
-        return $this;
-    }
+		return $this;
+	}
 }

plugins/files/php/vendor/phpfastcache/phpfastcache/lib/Phpfastcache/ExtensionManager.php

Indentation +47 added lines, -47 removed lines

@@ -26,56 +26,56 @@
  */
 final class ExtensionManager
 {
-    use UninstanciableObjectTrait;
+	use UninstanciableObjectTrait;
 
-    public const KNOWN_EXTENSION_NAMES = [
-        'Arangodb',
-        'Couchbasev4',
-        'Couchdb',
-        'Dynamodb',
-        'Firestore',
-        'Mongodb',
-        'Ravendb',
-        'Solr'
-    ];
+	public const KNOWN_EXTENSION_NAMES = [
+		'Arangodb',
+		'Couchbasev4',
+		'Couchdb',
+		'Dynamodb',
+		'Firestore',
+		'Mongodb',
+		'Ravendb',
+		'Solr'
+	];
 
-    /**
-     * @var array<string, string>
-     */
-    protected static array $registeredExtensions = [];
+	/**
+	 * @var array<string, string>
+	 */
+	protected static array $registeredExtensions = [];
 
-    public static function registerExtension(string $extensionName, string $driverClassName): void
-    {
-        if (!str_starts_with($driverClassName, ltrim('Phpfastcache\\Extensions\\', '\\'))) {
-            throw new PhpfastcacheInvalidArgumentException(
-                'Only extensions from "\\Phpfastcache\\Extensions\\" namespace are allowed. Use CacheManager::addCustomDriver() to create your own extensions.'
-            );
-        }
-        self::$registeredExtensions[$extensionName] = $driverClassName;
-    }
+	public static function registerExtension(string $extensionName, string $driverClassName): void
+	{
+		if (!str_starts_with($driverClassName, ltrim('Phpfastcache\\Extensions\\', '\\'))) {
+			throw new PhpfastcacheInvalidArgumentException(
+				'Only extensions from "\\Phpfastcache\\Extensions\\" namespace are allowed. Use CacheManager::addCustomDriver() to create your own extensions.'
+			);
+		}
+		self::$registeredExtensions[$extensionName] = $driverClassName;
+	}
 
-    public static function extensionExists(string $extensionName): bool
-    {
-        return isset(self::$registeredExtensions[$extensionName]);
-    }
+	public static function extensionExists(string $extensionName): bool
+	{
+		return isset(self::$registeredExtensions[$extensionName]);
+	}
 
-    /**
-     * @param string $name
-     * @return string
-     * @throws PhpfastcacheExtensionNotFoundException
-     */
-    public static function getExtension(string $name): string
-    {
-        if (isset(self::$registeredExtensions[$name])) {
-            return self::$registeredExtensions[$name];
-        } else {
-            throw new PhpfastcacheExtensionNotFoundException(
-                sprintf(
-                    'Unable too find the %s extension. Make sure that you you added through composer: `composer require phpfastcache/%s-extension`',
-                    $name,
-                    strtolower($name)
-                )
-            );
-        }
-    }
+	/**
+	 * @param string $name
+	 * @return string
+	 * @throws PhpfastcacheExtensionNotFoundException
+	 */
+	public static function getExtension(string $name): string
+	{
+		if (isset(self::$registeredExtensions[$name])) {
+			return self::$registeredExtensions[$name];
+		} else {
+			throw new PhpfastcacheExtensionNotFoundException(
+				sprintf(
+					'Unable too find the %s extension. Make sure that you you added through composer: `composer require phpfastcache/%s-extension`',
+					$name,
+					strtolower($name)
+				)
+			);
+		}
+	}
 }

plugins/files/php/vendor/phpfastcache/phpfastcache/lib/Phpfastcache/Entities/DriverStatistic.php

Indentation +106 added lines, -106 removed lines

@@ -21,110 +21,110 @@
  */
 class DriverStatistic
 {
-    protected string $info = '';
-
-    protected ?int $size = 0;
-
-    protected ?int $count = 0;
-
-    protected string $data = '';
-
-    protected mixed $rawData;
-
-    /**
-     * Return quick information about the driver instance
-     * @return string
-     */
-    public function getInfo(): string
-    {
-        return $this->info;
-    }
-
-    public function setInfo(string $info): static
-    {
-        $this->info = $info;
-
-        return $this;
-    }
-
-    /**
-     * Return the approximate size taken by the driver instance (in bytes) (null if unsupported by the driver)
-     * @return int|null
-     */
-    public function getSize(): ?int
-    {
-        return $this->size;
-    }
-
-    public function setSize(?int $size): static
-    {
-        $this->size = $size;
-
-        return $this;
-    }
-
-    /**
-     * Return the approximate count of elements stored in a driver database (or collection if applicable). Added in v9.2.3
-     * @since 9.2.3
-     * @return int|null
-     */
-    public function getCount(): ?int
-    {
-        return $this->count;
-    }
-
-    public function setCount(?int $count): static
-    {
-        $this->count = $count;
-        return $this;
-    }
-
-    /**
-     * Return an array of item keys used by this driver instance (deprecated as of v9.2.3, will be removed as of v10)
-     * @deprecated as of phpfastcache 9.2.3, will be removed as of v10
-     */
-    public function getData(): string
-    {
-        return $this->data;
-    }
-
-    /**
-     * @deprecated as of phpfastcache 9.2.3, will be removed as of v10
-     */
-    public function setData(string $data): static
-    {
-        $this->data = ($data ?: '');
-
-        return $this;
-    }
-
-    /**
-     * Return a bunch of random data provided by the driver. Any type can be provided, usually an array
-     * @return mixed
-     */
-    public function getRawData(): mixed
-    {
-        return $this->rawData;
-    }
-
-    public function setRawData(mixed $raw): static
-    {
-        $this->rawData = $raw;
-
-        return $this;
-    }
-
-    /**
-     * @return array<string, string>
-     */
-    public function getPublicDesc(): array
-    {
-        return [
-            'Info' => 'Cache Information',
-            'Size' => 'Cache Size',
-            'Count' => 'Cache database/collection count',
-            'Data' => 'Cache items keys (Deprecated)',
-            'RawData' => 'Cache raw data',
-        ];
-    }
+	protected string $info = '';
+
+	protected ?int $size = 0;
+
+	protected ?int $count = 0;
+
+	protected string $data = '';
+
+	protected mixed $rawData;
+
+	/**
+	 * Return quick information about the driver instance
+	 * @return string
+	 */
+	public function getInfo(): string
+	{
+		return $this->info;
+	}
+
+	public function setInfo(string $info): static
+	{
+		$this->info = $info;
+
+		return $this;
+	}
+
+	/**
+	 * Return the approximate size taken by the driver instance (in bytes) (null if unsupported by the driver)
+	 * @return int|null
+	 */
+	public function getSize(): ?int
+	{
+		return $this->size;
+	}
+
+	public function setSize(?int $size): static
+	{
+		$this->size = $size;
+
+		return $this;
+	}
+
+	/**
+	 * Return the approximate count of elements stored in a driver database (or collection if applicable). Added in v9.2.3
+	 * @since 9.2.3
+	 * @return int|null
+	 */
+	public function getCount(): ?int
+	{
+		return $this->count;
+	}
+
+	public function setCount(?int $count): static
+	{
+		$this->count = $count;
+		return $this;
+	}
+
+	/**
+	 * Return an array of item keys used by this driver instance (deprecated as of v9.2.3, will be removed as of v10)
+	 * @deprecated as of phpfastcache 9.2.3, will be removed as of v10
+	 */
+	public function getData(): string
+	{
+		return $this->data;
+	}
+
+	/**
+	 * @deprecated as of phpfastcache 9.2.3, will be removed as of v10
+	 */
+	public function setData(string $data): static
+	{
+		$this->data = ($data ?: '');
+
+		return $this;
+	}
+
+	/**
+	 * Return a bunch of random data provided by the driver. Any type can be provided, usually an array
+	 * @return mixed
+	 */
+	public function getRawData(): mixed
+	{
+		return $this->rawData;
+	}
+
+	public function setRawData(mixed $raw): static
+	{
+		$this->rawData = $raw;
+
+		return $this;
+	}
+
+	/**
+	 * @return array<string, string>
+	 */
+	public function getPublicDesc(): array
+	{
+		return [
+			'Info' => 'Cache Information',
+			'Size' => 'Cache Size',
+			'Count' => 'Cache database/collection count',
+			'Data' => 'Cache items keys (Deprecated)',
+			'RawData' => 'Cache raw data',
+		];
+	}
 }

plugins/files/php/vendor/phpfastcache/phpfastcache/lib/Phpfastcache/Entities/ItemBatch.php

Indentation +24 added lines, -24 removed lines

@@ -20,30 +20,30 @@
 
 class ItemBatch
 {
-    /**
-     * ItemBatch constructor.
-     * @param string $itemKey
-     * @param DateTimeInterface $itemDate
-     */
-    public function __construct(
-        protected string $itemKey,
-        protected DateTimeInterface $itemDate
-    ) {
-    }
+	/**
+	 * ItemBatch constructor.
+	 * @param string $itemKey
+	 * @param DateTimeInterface $itemDate
+	 */
+	public function __construct(
+		protected string $itemKey,
+		protected DateTimeInterface $itemDate
+	) {
+	}
 
-    /**
-     * @return string
-     */
-    public function getItemKey(): string
-    {
-        return $this->itemKey;
-    }
+	/**
+	 * @return string
+	 */
+	public function getItemKey(): string
+	{
+		return $this->itemKey;
+	}
 
-    /**
-     * @return DateTimeInterface
-     */
-    public function getItemDate(): DateTimeInterface
-    {
-        return $this->itemDate;
-    }
+	/**
+	 * @return DateTimeInterface
+	 */
+	public function getItemDate(): DateTimeInterface
+	{
+		return $this->itemDate;
+	}
 }

plugins/files/php/vendor/phpfastcache/phpfastcache/lib/Phpfastcache/Entities/DriverIO.php

Indentation +61 added lines, -61 removed lines

@@ -18,65 +18,65 @@
 
 class DriverIO
 {
-    protected int $writeHit = 0;
-
-    protected int $readHit = 0;
-
-    protected int $readMiss = 0;
-
-
-    public function getWriteHit(): int
-    {
-        return $this->writeHit;
-    }
-
-    /**
-     * @param int $writeHit
-     * @return DriverIO
-     */
-    public function setWriteHit(int $writeHit): DriverIO
-    {
-        $this->writeHit = $writeHit;
-        return $this;
-    }
-
-    public function incWriteHit(): DriverIO
-    {
-        $this->writeHit++;
-        return $this;
-    }
-
-    public function getReadHit(): int
-    {
-        return $this->readHit;
-    }
-
-    public function setReadHit(int $readHit): DriverIO
-    {
-        $this->readHit = $readHit;
-        return $this;
-    }
-
-    public function incReadHit(): DriverIO
-    {
-        $this->readHit++;
-        return $this;
-    }
-
-    public function getReadMiss(): int
-    {
-        return $this->readMiss;
-    }
-
-    public function setReadMiss(int $readMiss): DriverIO
-    {
-        $this->readMiss = $readMiss;
-        return $this;
-    }
-
-    public function incReadMiss(): DriverIO
-    {
-        $this->readMiss++;
-        return $this;
-    }
+	protected int $writeHit = 0;
+
+	protected int $readHit = 0;
+
+	protected int $readMiss = 0;
+
+
+	public function getWriteHit(): int
+	{
+		return $this->writeHit;
+	}
+
+	/**
+	 * @param int $writeHit
+	 * @return DriverIO
+	 */
+	public function setWriteHit(int $writeHit): DriverIO
+	{
+		$this->writeHit = $writeHit;
+		return $this;
+	}
+
+	public function incWriteHit(): DriverIO
+	{
+		$this->writeHit++;
+		return $this;
+	}
+
+	public function getReadHit(): int
+	{
+		return $this->readHit;
+	}
+
+	public function setReadHit(int $readHit): DriverIO
+	{
+		$this->readHit = $readHit;
+		return $this;
+	}
+
+	public function incReadHit(): DriverIO
+	{
+		$this->readHit++;
+		return $this;
+	}
+
+	public function getReadMiss(): int
+	{
+		return $this->readMiss;
+	}
+
+	public function setReadMiss(int $readMiss): DriverIO
+	{
+		$this->readMiss = $readMiss;
+		return $this;
+	}
+
+	public function incReadMiss(): DriverIO
+	{
+		$this->readMiss++;
+		return $this;
+	}
 }

plugins/files/php/vendor/phpfastcache/phpfastcache/lib/Phpfastcache/Util/ClassNamespaceResolverTrait.php

Indentation +169 added lines, -169 removed lines

@@ -21,173 +21,173 @@
 
 trait ClassNamespaceResolverTrait
 {
-    /**
-     * @var array<string, string>
-     */
-    protected static array $namespaces = [];
-
-    /**
-     * Iterate over all files in the given directory searching for classes.
-     *
-     * NOTICE: This method has been borrowed from Symfony ClassLoader 3.4 since they
-     * deprecated the whole component as of SF4. Our thanks to them.
-     *
-     * @param string $dir The directory to search in or an iterator
-     *
-     * @return array<string, string> A class map array
-     */
-    protected static function createClassMap(string $dir): array
-    {
-        $dirIterator = new RecursiveIteratorIterator(new RecursiveDirectoryIterator($dir));
-
-        $map = [];
-
-        foreach ($dirIterator as $file) {
-            if (!$file->isFile()) {
-                continue;
-            }
-            $path = $file->getRealPath() ?: $file->getPathname();
-            if ('php' !== pathinfo($path, PATHINFO_EXTENSION)) {
-                continue;
-            }
-            $classes = self::findClasses($path);
-            gc_mem_caches();
-            foreach ($classes as $class) {
-                $map[$class] = $path;
-            }
-        }
-
-        return $map;
-    }
-
-    /**
-     * Extract the classes in the given file.
-     *
-     * NOTICE: This method has been borrowed from Symfony ClassLoader 3.4 since they
-     * deprecated the whole component as of SF4. Our thanks to them.
-     *
-     * @param string $path The file to check
-     *
-     * @return string[] The found classes
-     *
-     * @SuppressWarnings(PHPMD.CyclomaticComplexity)
-     */
-    protected static function findClasses(string $path): array
-    {
-        $contents = file_get_contents($path);
-        $tokens = token_get_all($contents);
-        $classes = [];
-        $namespace = '';
-        for ($i = 0; isset($tokens[$i]); ++$i) {
-            $token = $tokens[$i];
-            if (!isset($token[1])) {
-                continue;
-            }
-            $class = '';
-            switch ($token[0]) {
-                case T_NAMESPACE:
-                    $namespace = self::buildTokenNamespace($i, $tokens);
-                    break;
-                case T_CLASS:
-                case T_INTERFACE:
-                case T_TRAIT:
-                    $classes = self::buildTokenClasses($namespace, $class, $classes, $i, $tokens);
-                    break;
-                default:
-                    break;
-            }
-        }
-
-        return $classes;
-    }
-
-    /**
-     * @param string $namespace
-     * @param string $class
-     * @param string[] $classes
-     * @param int $index
-     * @param array<array<mixed>|string> $tokens
-     * @return string[]
-     */
-    protected static function buildTokenClasses(string $namespace, string $class, array $classes, int $index, array $tokens): array
-    {
-        // Skip usage of ::class constant
-        $isClassConstant = false;
-        for ($j = $index - 1; $j > 0; --$j) {
-            if (!isset($tokens[$j][1])) {
-                break;
-            }
-            if (T_DOUBLE_COLON === $tokens[$j][0]) {
-                $isClassConstant = true;
-                break;
-            }
-
-            if (!\in_array($tokens[$j][0], [T_WHITESPACE, T_DOC_COMMENT, T_COMMENT], false)) {
-                break;
-            }
-        }
-        if ($isClassConstant) {
-            return $classes;
-        }
-
-        // Find the classname
-        while (isset($tokens[++$index][1])) {
-            $t = $tokens[$index];
-            if (T_STRING === $t[0]) {
-                $class .= $t[1];
-            } elseif ('' !== $class && T_WHITESPACE === $t[0]) {
-                break;
-            }
-        }
-
-        return \array_merge($classes, [\ltrim($namespace . $class, '\\')]);
-    }
-
-    /**
-     * @param int $index
-     * @param array<array<mixed>|string> $tokens
-     * @return string
-     */
-    protected static function buildTokenNamespace(int $index, array $tokens): string
-    {
-        $namespace = '';
-
-        // If there is a namespace, extract it (PHP 8 test)
-        if (\defined('T_NAME_QUALIFIED')) {
-            while (isset($tokens[++$index][1])) {
-                if ($tokens[$index][0] === T_NAME_QUALIFIED) {
-                    $namespace = $tokens[$index][1];
-                    break;
-                }
-            }
-        } else {
-            while (isset($tokens[++$index][1])) {
-                if (\in_array($tokens[$index][0], [T_STRING, T_NS_SEPARATOR], true)) {
-                    $namespace .= $tokens[$index][1];
-                }
-            }
-        }
-
-        return $namespace . '\\';
-    }
-
-    /**
-     * @return string
-     */
-    public static function getClassNamespace(): string
-    {
-        if (!isset(self::$namespaces[static::class])) {
-            self::$namespaces[static::class] = substr(static::class, 0, strrpos(static::class, '\\'));
-        }
-
-        return self::$namespaces[static::class];
-    }
-
-    /**
-     * @return string
-     */
-    public function getClassName(): string
-    {
-        return static::class;
-    }
+	/**
+	 * @var array<string, string>
+	 */
+	protected static array $namespaces = [];
+
+	/**
+	 * Iterate over all files in the given directory searching for classes.
+	 *
+	 * NOTICE: This method has been borrowed from Symfony ClassLoader 3.4 since they
+	 * deprecated the whole component as of SF4. Our thanks to them.
+	 *
+	 * @param string $dir The directory to search in or an iterator
+	 *
+	 * @return array<string, string> A class map array
+	 */
+	protected static function createClassMap(string $dir): array
+	{
+		$dirIterator = new RecursiveIteratorIterator(new RecursiveDirectoryIterator($dir));
+
+		$map = [];
+
+		foreach ($dirIterator as $file) {
+			if (!$file->isFile()) {
+				continue;
+			}
+			$path = $file->getRealPath() ?: $file->getPathname();
+			if ('php' !== pathinfo($path, PATHINFO_EXTENSION)) {
+				continue;
+			}
+			$classes = self::findClasses($path);
+			gc_mem_caches();
+			foreach ($classes as $class) {
+				$map[$class] = $path;
+			}
+		}
+
+		return $map;
+	}
+
+	/**
+	 * Extract the classes in the given file.
+	 *
+	 * NOTICE: This method has been borrowed from Symfony ClassLoader 3.4 since they
+	 * deprecated the whole component as of SF4. Our thanks to them.
+	 *
+	 * @param string $path The file to check
+	 *
+	 * @return string[] The found classes
+	 *
+	 * @SuppressWarnings(PHPMD.CyclomaticComplexity)
+	 */
+	protected static function findClasses(string $path): array
+	{
+		$contents = file_get_contents($path);
+		$tokens = token_get_all($contents);
+		$classes = [];
+		$namespace = '';
+		for ($i = 0; isset($tokens[$i]); ++$i) {
+			$token = $tokens[$i];
+			if (!isset($token[1])) {
+				continue;
+			}
+			$class = '';
+			switch ($token[0]) {
+				case T_NAMESPACE:
+					$namespace = self::buildTokenNamespace($i, $tokens);
+					break;
+				case T_CLASS:
+				case T_INTERFACE:
+				case T_TRAIT:
+					$classes = self::buildTokenClasses($namespace, $class, $classes, $i, $tokens);
+					break;
+				default:
+					break;
+			}
+		}
+
+		return $classes;
+	}
+
+	/**
+	 * @param string $namespace
+	 * @param string $class
+	 * @param string[] $classes
+	 * @param int $index
+	 * @param array<array<mixed>|string> $tokens
+	 * @return string[]
+	 */
+	protected static function buildTokenClasses(string $namespace, string $class, array $classes, int $index, array $tokens): array
+	{
+		// Skip usage of ::class constant
+		$isClassConstant = false;
+		for ($j = $index - 1; $j > 0; --$j) {
+			if (!isset($tokens[$j][1])) {
+				break;
+			}
+			if (T_DOUBLE_COLON === $tokens[$j][0]) {
+				$isClassConstant = true;
+				break;
+			}
+
+			if (!\in_array($tokens[$j][0], [T_WHITESPACE, T_DOC_COMMENT, T_COMMENT], false)) {
+				break;
+			}
+		}
+		if ($isClassConstant) {
+			return $classes;
+		}
+
+		// Find the classname
+		while (isset($tokens[++$index][1])) {
+			$t = $tokens[$index];
+			if (T_STRING === $t[0]) {
+				$class .= $t[1];
+			} elseif ('' !== $class && T_WHITESPACE === $t[0]) {
+				break;
+			}
+		}
+
+		return \array_merge($classes, [\ltrim($namespace . $class, '\\')]);
+	}
+
+	/**
+	 * @param int $index
+	 * @param array<array<mixed>|string> $tokens
+	 * @return string
+	 */
+	protected static function buildTokenNamespace(int $index, array $tokens): string
+	{
+		$namespace = '';
+
+		// If there is a namespace, extract it (PHP 8 test)
+		if (\defined('T_NAME_QUALIFIED')) {
+			while (isset($tokens[++$index][1])) {
+				if ($tokens[$index][0] === T_NAME_QUALIFIED) {
+					$namespace = $tokens[$index][1];
+					break;
+				}
+			}
+		} else {
+			while (isset($tokens[++$index][1])) {
+				if (\in_array($tokens[$index][0], [T_STRING, T_NS_SEPARATOR], true)) {
+					$namespace .= $tokens[$index][1];
+				}
+			}
+		}
+
+		return $namespace . '\\';
+	}
+
+	/**
+	 * @return string
+	 */
+	public static function getClassNamespace(): string
+	{
+		if (!isset(self::$namespaces[static::class])) {
+			self::$namespaces[static::class] = substr(static::class, 0, strrpos(static::class, '\\'));
+		}
+
+		return self::$namespaces[static::class];
+	}
+
+	/**
+	 * @return string
+	 */
+	public function getClassName(): string
+	{
+		return static::class;
+	}
 }