grommunio / grommunio-web

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

Indentation +122 added lines, -122 removed lines

@@ -23,126 +23,126 @@
 
 class Directory
 {
-    /**
-     * Get the directory size
-     * @param string $directory
-     * @param bool $includeDirAllocSize
-     * @return int
-     */
-    public static function dirSize(string $directory, bool $includeDirAllocSize = false): int
-    {
-        $size = 0;
-        foreach (new RecursiveIteratorIterator(new RecursiveDirectoryIterator($directory)) as $file) {
-            /**
-             * @var SplFileInfo $file
-             */
-            if ($file->isFile()) {
-                $size += filesize($file->getRealPath());
-            } elseif ($includeDirAllocSize) {
-                $size += $file->getSize();
-            }
-        }
-
-        return $size;
-    }
-
-    /**
-     * @param string $path
-     * @return int
-     */
-    public static function getFileCount(string $path): int
-    {
-        $count = 0;
-        $objects = new RecursiveIteratorIterator(new RecursiveDirectoryIterator($path), RecursiveIteratorIterator::SELF_FIRST);
-        foreach ($objects as $object) {
-            /**
-             * @var SplFileInfo $object
-             */
-            if ($object->isFile()) {
-                $count++;
-            }
-        }
-
-        return $count;
-    }
-
-    /**
-     * Recursively delete a directory and all of its contents - e.g.the equivalent of `rm -r` on the command-line.
-     * Consistent with `rmdir()` and `unlink()`, an E_WARNING level error will be generated on failure.
-     *
-     * @param string $source absolute path to directory or file to delete.
-     * @param bool $removeOnlyChildren set to true will only remove content inside directory.
-     *
-     * @return bool true on success; false on failure
-     */
-    public static function rrmdir(string $source, bool $removeOnlyChildren = false): bool
-    {
-        if (empty($source) || file_exists($source) === false) {
-            return false;
-        }
-
-        if (is_file($source) || is_link($source)) {
-            clearstatcache(true, $source);
-            return unlink($source);
-        }
-
-        $files = new RecursiveIteratorIterator(
-            new RecursiveDirectoryIterator($source, FilesystemIterator::SKIP_DOTS),
-            RecursiveIteratorIterator::CHILD_FIRST
-        );
-
-        foreach ($files as $fileInfo) {
-            /**
-             * @var SplFileInfo $fileInfo
-             */
-            $realpath = $fileInfo->getRealPath();
-            if ($realpath) {
-                if ($fileInfo->isDir()) {
-                    if (self::rrmdir($fileInfo->getRealPath()) === false) {
-                        return false;
-                    }
-                } elseif (unlink($realpath) === false) {
-                    return false;
-                }
-            } else {
-                return false;
-            }
-        }
-
-        if ($removeOnlyChildren === false) {
-            return rmdir($source);
-        }
-
-        return true;
-    }
-
-    /**
-     * Alias of realpath() but work
-     * on non-existing files
-     *
-     * @param string $path
-     * @return string
-     */
-    public static function getAbsolutePath(string $path): string
-    {
-        $parts = preg_split('~[/\\\\]+~', $path, 0, PREG_SPLIT_NO_EMPTY);
-        $absolutes = [];
-        foreach ($parts as $part) {
-            if ('.' === $part) {
-                continue;
-            }
-            if ('..' === $part) {
-                array_pop($absolutes);
-            } else {
-                $absolutes[] = $part;
-            }
-        }
-
-        /**
-         * Allows dereferencing char
-         */
-        $file = preg_replace('~^(([a-z0-9\-]+)://)~', '', __FILE__);// remove file protocols such as "phar://" etc.
-        $prefix = $file[0] === DIRECTORY_SEPARATOR ? DIRECTORY_SEPARATOR : '';
-        return $prefix . implode(DIRECTORY_SEPARATOR, $absolutes);
-    }
+	/**
+	 * Get the directory size
+	 * @param string $directory
+	 * @param bool $includeDirAllocSize
+	 * @return int
+	 */
+	public static function dirSize(string $directory, bool $includeDirAllocSize = false): int
+	{
+		$size = 0;
+		foreach (new RecursiveIteratorIterator(new RecursiveDirectoryIterator($directory)) as $file) {
+			/**
+			 * @var SplFileInfo $file
+			 */
+			if ($file->isFile()) {
+				$size += filesize($file->getRealPath());
+			} elseif ($includeDirAllocSize) {
+				$size += $file->getSize();
+			}
+		}
+
+		return $size;
+	}
+
+	/**
+	 * @param string $path
+	 * @return int
+	 */
+	public static function getFileCount(string $path): int
+	{
+		$count = 0;
+		$objects = new RecursiveIteratorIterator(new RecursiveDirectoryIterator($path), RecursiveIteratorIterator::SELF_FIRST);
+		foreach ($objects as $object) {
+			/**
+			 * @var SplFileInfo $object
+			 */
+			if ($object->isFile()) {
+				$count++;
+			}
+		}
+
+		return $count;
+	}
+
+	/**
+	 * Recursively delete a directory and all of its contents - e.g.the equivalent of `rm -r` on the command-line.
+	 * Consistent with `rmdir()` and `unlink()`, an E_WARNING level error will be generated on failure.
+	 *
+	 * @param string $source absolute path to directory or file to delete.
+	 * @param bool $removeOnlyChildren set to true will only remove content inside directory.
+	 *
+	 * @return bool true on success; false on failure
+	 */
+	public static function rrmdir(string $source, bool $removeOnlyChildren = false): bool
+	{
+		if (empty($source) || file_exists($source) === false) {
+			return false;
+		}
+
+		if (is_file($source) || is_link($source)) {
+			clearstatcache(true, $source);
+			return unlink($source);
+		}
+
+		$files = new RecursiveIteratorIterator(
+			new RecursiveDirectoryIterator($source, FilesystemIterator::SKIP_DOTS),
+			RecursiveIteratorIterator::CHILD_FIRST
+		);
+
+		foreach ($files as $fileInfo) {
+			/**
+			 * @var SplFileInfo $fileInfo
+			 */
+			$realpath = $fileInfo->getRealPath();
+			if ($realpath) {
+				if ($fileInfo->isDir()) {
+					if (self::rrmdir($fileInfo->getRealPath()) === false) {
+						return false;
+					}
+				} elseif (unlink($realpath) === false) {
+					return false;
+				}
+			} else {
+				return false;
+			}
+		}
+
+		if ($removeOnlyChildren === false) {
+			return rmdir($source);
+		}
+
+		return true;
+	}
+
+	/**
+	 * Alias of realpath() but work
+	 * on non-existing files
+	 *
+	 * @param string $path
+	 * @return string
+	 */
+	public static function getAbsolutePath(string $path): string
+	{
+		$parts = preg_split('~[/\\\\]+~', $path, 0, PREG_SPLIT_NO_EMPTY);
+		$absolutes = [];
+		foreach ($parts as $part) {
+			if ('.' === $part) {
+				continue;
+			}
+			if ('..' === $part) {
+				array_pop($absolutes);
+			} else {
+				$absolutes[] = $part;
+			}
+		}
+
+		/**
+		 * Allows dereferencing char
+		 */
+		$file = preg_replace('~^(([a-z0-9\-]+)://)~', '', __FILE__);// remove file protocols such as "phar://" etc.
+		$prefix = $file[0] === DIRECTORY_SEPARATOR ? DIRECTORY_SEPARATOR : '';
+		return $prefix . implode(DIRECTORY_SEPARATOR, $absolutes);
+	}
 }

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

Indentation +11 added lines, -11 removed lines

@@ -18,16 +18,16 @@
 
 class SapiDetector
 {
-    /**
-     * @SuppressWarnings(PHPMD.Superglobals)
-     */
-    public static function isWebScript(): bool
-    {
-        return \PHP_SAPI === 'apache2handler' || str_contains(\PHP_SAPI, 'handler') || isset($_SERVER['REQUEST_METHOD']);
-    }
+	/**
+	 * @SuppressWarnings(PHPMD.Superglobals)
+	 */
+	public static function isWebScript(): bool
+	{
+		return \PHP_SAPI === 'apache2handler' || str_contains(\PHP_SAPI, 'handler') || isset($_SERVER['REQUEST_METHOD']);
+	}
 
-    public static function isCliScript(): bool
-    {
-        return (\PHP_SAPI === 'cli') || \defined('STDIN');
-    }
+	public static function isCliScript(): bool
+	{
+		return (\PHP_SAPI === 'cli') || \defined('STDIN');
+	}
 }

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

Indentation +20 added lines, -20 removed lines

@@ -18,31 +18,31 @@
 
 trait MemcacheDriverCollisionDetectorTrait
 {
-    protected static string $driverUsed;
+	protected static string $driverUsed;
 
-    public static function checkCollision(string $driverName): bool
-    {
-        $constantName = __NAMESPACE__ . '\MEMCACHE_DRIVER_USED';
+	public static function checkCollision(string $driverName): bool
+	{
+		$constantName = __NAMESPACE__ . '\MEMCACHE_DRIVER_USED';
 
-        if ($driverName) {
-            if (!defined($constantName)) {
-                define($constantName, $driverName);
+		if ($driverName) {
+			if (!defined($constantName)) {
+				define($constantName, $driverName);
 
-                return true;
-            }
+				return true;
+			}
 
-            if (constant($constantName) !== $driverName) {
-                trigger_error(
-                    'Memcache collision detected, you used both Memcache and Memcached driver in your script, this may leads to unexpected behaviours',
-                    E_USER_WARNING
-                );
+			if (constant($constantName) !== $driverName) {
+				trigger_error(
+					'Memcache collision detected, you used both Memcache and Memcached driver in your script, this may leads to unexpected behaviours',
+					E_USER_WARNING
+				);
 
-                return false;
-            }
+				return false;
+			}
 
-            return true;
-        }
+			return true;
+		}
 
-        return false;
-    }
+		return false;
+	}
 }

plugins/files/php/vendor/phpfastcache/phpfastcache/lib/Phpfastcache/Cluster/AggregatorInterface.php

Indentation +69 added lines, -69 removed lines

@@ -20,81 +20,81 @@
 
 interface AggregatorInterface
 {
-    /**
-     * Full replication mechanism
-     *
-     * Read on first working (and synchronize if needed, no failure allowed),
-     * Write on all (no failure allowed),
-     * Delete on all (no failure allowed)
-     *
-     * Conflict on multiple reads: Keep first found item (but sync the others)
-     * Cluster size: 2 minimum, unlimited
-     */
-    public const STRATEGY_FULL_REPLICATION = 1;
+	/**
+	 * Full replication mechanism
+	 *
+	 * Read on first working (and synchronize if needed, no failure allowed),
+	 * Write on all (no failure allowed),
+	 * Delete on all (no failure allowed)
+	 *
+	 * Conflict on multiple reads: Keep first found item (but sync the others)
+	 * Cluster size: 2 minimum, unlimited
+	 */
+	public const STRATEGY_FULL_REPLICATION = 1;
 
-    /**
-     * Semi replication mechanism
-     *
-     * Read first working (but do not synchronize, with partial failure allowed),
-     * Write on all (with partial failure allowed)
-     * Delete on all (with partial failure allowed)
-     *
-     * Conflict on multiple reads: Keep first found item
-     * Cluster size: 2 minimum, unlimited
-     */
-    public const STRATEGY_SEMI_REPLICATION = 2;
+	/**
+	 * Semi replication mechanism
+	 *
+	 * Read first working (but do not synchronize, with partial failure allowed),
+	 * Write on all (with partial failure allowed)
+	 * Delete on all (with partial failure allowed)
+	 *
+	 * Conflict on multiple reads: Keep first found item
+	 * Cluster size: 2 minimum, unlimited
+	 */
+	public const STRATEGY_SEMI_REPLICATION = 2;
 
-    /**
-     * First pool is master, second is slave
-     *
-     * Read from master (but do not synchronize, with master failure only allowed)
-     * Write on all (with master failure only allowed)
-     * Delete on all (with master failure only allowed)
-     *
-     * Conflict on multiple reads: No, master is exclusive source except if it fails
-     * Cluster size: 2 exactly: Master & Slave (Exception if more or less)
-     */
-    public const STRATEGY_MASTER_SLAVE = 4;
+	/**
+	 * First pool is master, second is slave
+	 *
+	 * Read from master (but do not synchronize, with master failure only allowed)
+	 * Write on all (with master failure only allowed)
+	 * Delete on all (with master failure only allowed)
+	 *
+	 * Conflict on multiple reads: No, master is exclusive source except if it fails
+	 * Cluster size: 2 exactly: Master & Slave (Exception if more or less)
+	 */
+	public const STRATEGY_MASTER_SLAVE = 4;
 
-    /**
-     * Mostly used for development testing
-     *
-     * CRUD operations are made on a random-chosen backend from a given cluster.
-     * This means you have 1 chance out of (n count of pools) to find an existing cache item
-     * but also to write/delete a non-existing item.
-     */
-    public const STRATEGY_RANDOM_REPLICATION = 8;
+	/**
+	 * Mostly used for development testing
+	 *
+	 * CRUD operations are made on a random-chosen backend from a given cluster.
+	 * This means you have 1 chance out of (n count of pools) to find an existing cache item
+	 * but also to write/delete a non-existing item.
+	 */
+	public const STRATEGY_RANDOM_REPLICATION = 8;
 
-    /**
-     * AggregatorInterface constructor.
-     *
-     * @param string $clusterAggregatorName
-     * @param AggregatablePoolInterface ...$driverPools
-     */
-    public function __construct(string $clusterAggregatorName, AggregatablePoolInterface ...$driverPools);
+	/**
+	 * AggregatorInterface constructor.
+	 *
+	 * @param string $clusterAggregatorName
+	 * @param AggregatablePoolInterface ...$driverPools
+	 */
+	public function __construct(string $clusterAggregatorName, AggregatablePoolInterface ...$driverPools);
 
-    /**
-     * @param int $strategy
-     *
-     * @return ClusterPoolInterface
-     */
-    public function getCluster(int $strategy): ClusterPoolInterface;
+	/**
+	 * @param int $strategy
+	 *
+	 * @return ClusterPoolInterface
+	 */
+	public function getCluster(int $strategy): ClusterPoolInterface;
 
-    /**
-     * @param string $driverName
-     * @param ConfigurationOption|NULL $driverConfig
-     *
-     * @return void
-     */
-    public function aggregateDriverByName(string $driverName, ConfigurationOption $driverConfig = null): void;
+	/**
+	 * @param string $driverName
+	 * @param ConfigurationOption|NULL $driverConfig
+	 *
+	 * @return void
+	 */
+	public function aggregateDriverByName(string $driverName, ConfigurationOption $driverConfig = null): void;
 
-    /**
-     * @param AggregatablePoolInterface $driverPool
-     */
-    public function aggregateDriver(AggregatablePoolInterface $driverPool): void;
+	/**
+	 * @param AggregatablePoolInterface $driverPool
+	 */
+	public function aggregateDriver(AggregatablePoolInterface $driverPool): void;
 
-    /**
-     * @param AggregatablePoolInterface $driverPool
-     */
-    public function disaggregateDriver(AggregatablePoolInterface $driverPool): void;
+	/**
+	 * @param AggregatablePoolInterface $driverPool
+	 */
+	public function disaggregateDriver(AggregatablePoolInterface $driverPool): void;
 }

plugins/files/php/vendor/phpfastcache/phpfastcache/lib/Phpfastcache/Cluster/AggregatablePoolInterface.php

Indentation +2 added lines, -2 removed lines

@@ -20,7 +20,7 @@
 
 interface AggregatablePoolInterface extends ExtendedCacheItemPoolInterface
 {
-    public function isAggregatedBy(): ?ClusterPoolInterface;
+	public function isAggregatedBy(): ?ClusterPoolInterface;
 
-    public function setAggregatedBy(ClusterPoolInterface $clusterPool): static;
+	public function setAggregatedBy(ClusterPoolInterface $clusterPool): static;
 }

plugins/files/php/vendor/phpfastcache/phpfastcache/lib/Phpfastcache/Cluster/Drivers/FullReplication/Item.php

Indentation +4 added lines, -4 removed lines

@@ -20,8 +20,8 @@
 
 class Item extends ItemAbstract
 {
-    protected function getDriverClass(): string
-    {
-        return Driver::class;
-    }
+	protected function getDriverClass(): string
+	{
+		return Driver::class;
+	}
 }

plugins/files/php/vendor/phpfastcache/phpfastcache/lib/Phpfastcache/Cluster/Drivers/FullReplication/Driver.php

Indentation +161 added lines, -161 removed lines

@@ -24,165 +24,165 @@
 
 class Driver extends ClusterPoolAbstract
 {
-    /**
-     * @inheritDoc
-     */
-    public function getItem(string $key): ExtendedCacheItemInterface
-    {
-        /** @var ExtendedCacheItemPoolInterface[] $poolsToResync */
-        $poolsToResync = [];
-        /** @var ?ExtendedCacheItemInterface $item */
-        $item = null;
-
-        foreach ($this->clusterPools as $driverPool) {
-            $poolItem = $driverPool->getItem($key);
-            if ($poolItem->isHit()) {
-                if (!$item) {
-                    $item = $poolItem;
-                    continue;
-                }
-
-                $itemData = $item->get();
-                $poolItemData = $poolItem->get();
-
-                if (\is_object($itemData)) {
-                    if ($item->get() != $poolItemData) {
-                        $poolsToResync[] = $driverPool;
-                    }
-                } else {
-                    if ($item->get() !== $poolItemData) {
-                        $poolsToResync[] = $driverPool;
-                    }
-                }
-            } else {
-                $poolsToResync[] = $driverPool;
-            }
-        }
-
-        $this->resynchronizePool($poolsToResync, $key, $item);
-
-        if ($item === null) {
-            $item = new Item($this, $key, $this->getEventManager());
-            $item->expiresAfter((int) abs($this->getConfig()->getDefaultTtl()));
-        }
-
-        return $this->getStandardizedItem($item, $this);
-    }
-
-    /**
-     * @inheritDoc
-     */
-    public function hasItem(string $key): bool
-    {
-        foreach ($this->clusterPools as $driverPool) {
-            $poolItem = $driverPool->getItem($key);
-            if ($poolItem->isHit()) {
-                return true;
-            }
-        }
-
-        return false;
-    }
-
-    /**
-     * @inheritDoc
-     */
-    public function clear(): bool
-    {
-        $hasClearedOnce = false;
-        foreach ($this->clusterPools as $driverPool) {
-            if ($result = $driverPool->clear()) {
-                $hasClearedOnce = $result;
-            }
-        }
-        // Return true only if at least one backend confirmed the "clear" operation
-        return $hasClearedOnce;
-    }
-
-    /**
-     * @inheritDoc
-     */
-    public function deleteItem(string $key): bool
-    {
-        $hasDeletedOnce = false;
-        foreach ($this->clusterPools as $driverPool) {
-            if ($result = $driverPool->deleteItem($key)) {
-                $hasDeletedOnce = $result;
-            }
-        }
-        // Return true only if at least one backend confirmed the "clear" operation
-        return $hasDeletedOnce;
-    }
-
-    /**
-     * @inheritDoc
-     */
-    public function save(CacheItemInterface $item): bool
-    {
-        /** @var ExtendedCacheItemInterface $item */
-        $hasSavedOnce = false;
-        foreach ($this->clusterPools as $driverPool) {
-            $poolItem = $this->getStandardizedItem($item, $driverPool);
-            if ($result = $driverPool->save($poolItem)) {
-                $hasSavedOnce = $result;
-            }
-        }
-        // Return true only if at least one backend confirmed the "commit" operation
-        return $hasSavedOnce;
-    }
-
-    /**
-     * @inheritDoc
-     */
-    public function saveDeferred(CacheItemInterface $item): bool
-    {
-        /** @var ExtendedCacheItemInterface $item */
-        $hasSavedOnce = false;
-        foreach ($this->clusterPools as $driverPool) {
-            $poolItem = $this->getStandardizedItem($item, $driverPool);
-            if ($result = $driverPool->saveDeferred($poolItem)) {
-                $hasSavedOnce = $result;
-            }
-        }
-        // Return true only if at least one backend confirmed the "commit" operation
-        return $hasSavedOnce;
-    }
-
-    /**
-     * @inheritDoc
-     */
-    public function commit(): bool
-    {
-        $hasCommitOnce = false;
-        foreach ($this->clusterPools as $driverPool) {
-            if ($result = $driverPool->commit()) {
-                $hasCommitOnce = $result;
-            }
-        }
-        // Return true only if at least one backend confirmed the "commit" operation
-        return $hasCommitOnce;
-    }
-
-    /**
-     * @param ExtendedCacheItemPoolInterface[] $poolsToResynchronize
-     * @param string $key
-     * @param ?ExtendedCacheItemInterface $item
-     * @return void
-     * @throws \Phpfastcache\Exceptions\PhpfastcacheInvalidArgumentException
-     */
-    protected function resynchronizePool(array $poolsToResynchronize, string $key, ?ExtendedCacheItemInterface $item): void
-    {
-        if ($item && $item->isHit() && \count($poolsToResynchronize) < \count($this->clusterPools)) {
-            foreach ($poolsToResynchronize as $poolToResynchronize) {
-                $poolItem = $poolToResynchronize->getItem($key);
-                $poolItem->setEventManager($this->getEventManager())
-                    ->set($item->get())
-                    ->setHit($item->isHit())
-                    ->setTags($item->getTags())
-                    ->expiresAt($item->getExpirationDate())
-                    ->setDriver($poolToResynchronize);
-                $poolToResynchronize->save($poolItem);
-            }
-        }
-    }
+	/**
+	 * @inheritDoc
+	 */
+	public function getItem(string $key): ExtendedCacheItemInterface
+	{
+		/** @var ExtendedCacheItemPoolInterface[] $poolsToResync */
+		$poolsToResync = [];
+		/** @var ?ExtendedCacheItemInterface $item */
+		$item = null;
+
+		foreach ($this->clusterPools as $driverPool) {
+			$poolItem = $driverPool->getItem($key);
+			if ($poolItem->isHit()) {
+				if (!$item) {
+					$item = $poolItem;
+					continue;
+				}
+
+				$itemData = $item->get();
+				$poolItemData = $poolItem->get();
+
+				if (\is_object($itemData)) {
+					if ($item->get() != $poolItemData) {
+						$poolsToResync[] = $driverPool;
+					}
+				} else {
+					if ($item->get() !== $poolItemData) {
+						$poolsToResync[] = $driverPool;
+					}
+				}
+			} else {
+				$poolsToResync[] = $driverPool;
+			}
+		}
+
+		$this->resynchronizePool($poolsToResync, $key, $item);
+
+		if ($item === null) {
+			$item = new Item($this, $key, $this->getEventManager());
+			$item->expiresAfter((int) abs($this->getConfig()->getDefaultTtl()));
+		}
+
+		return $this->getStandardizedItem($item, $this);
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function hasItem(string $key): bool
+	{
+		foreach ($this->clusterPools as $driverPool) {
+			$poolItem = $driverPool->getItem($key);
+			if ($poolItem->isHit()) {
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function clear(): bool
+	{
+		$hasClearedOnce = false;
+		foreach ($this->clusterPools as $driverPool) {
+			if ($result = $driverPool->clear()) {
+				$hasClearedOnce = $result;
+			}
+		}
+		// Return true only if at least one backend confirmed the "clear" operation
+		return $hasClearedOnce;
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function deleteItem(string $key): bool
+	{
+		$hasDeletedOnce = false;
+		foreach ($this->clusterPools as $driverPool) {
+			if ($result = $driverPool->deleteItem($key)) {
+				$hasDeletedOnce = $result;
+			}
+		}
+		// Return true only if at least one backend confirmed the "clear" operation
+		return $hasDeletedOnce;
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function save(CacheItemInterface $item): bool
+	{
+		/** @var ExtendedCacheItemInterface $item */
+		$hasSavedOnce = false;
+		foreach ($this->clusterPools as $driverPool) {
+			$poolItem = $this->getStandardizedItem($item, $driverPool);
+			if ($result = $driverPool->save($poolItem)) {
+				$hasSavedOnce = $result;
+			}
+		}
+		// Return true only if at least one backend confirmed the "commit" operation
+		return $hasSavedOnce;
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function saveDeferred(CacheItemInterface $item): bool
+	{
+		/** @var ExtendedCacheItemInterface $item */
+		$hasSavedOnce = false;
+		foreach ($this->clusterPools as $driverPool) {
+			$poolItem = $this->getStandardizedItem($item, $driverPool);
+			if ($result = $driverPool->saveDeferred($poolItem)) {
+				$hasSavedOnce = $result;
+			}
+		}
+		// Return true only if at least one backend confirmed the "commit" operation
+		return $hasSavedOnce;
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function commit(): bool
+	{
+		$hasCommitOnce = false;
+		foreach ($this->clusterPools as $driverPool) {
+			if ($result = $driverPool->commit()) {
+				$hasCommitOnce = $result;
+			}
+		}
+		// Return true only if at least one backend confirmed the "commit" operation
+		return $hasCommitOnce;
+	}
+
+	/**
+	 * @param ExtendedCacheItemPoolInterface[] $poolsToResynchronize
+	 * @param string $key
+	 * @param ?ExtendedCacheItemInterface $item
+	 * @return void
+	 * @throws \Phpfastcache\Exceptions\PhpfastcacheInvalidArgumentException
+	 */
+	protected function resynchronizePool(array $poolsToResynchronize, string $key, ?ExtendedCacheItemInterface $item): void
+	{
+		if ($item && $item->isHit() && \count($poolsToResynchronize) < \count($this->clusterPools)) {
+			foreach ($poolsToResynchronize as $poolToResynchronize) {
+				$poolItem = $poolToResynchronize->getItem($key);
+				$poolItem->setEventManager($this->getEventManager())
+					->set($item->get())
+					->setHit($item->isHit())
+					->setTags($item->getTags())
+					->expiresAt($item->getExpirationDate())
+					->setDriver($poolToResynchronize);
+				$poolToResynchronize->save($poolItem);
+			}
+		}
+	}
 }

plugins/files/php/vendor/phpfastcache/phpfastcache/lib/Phpfastcache/Cluster/Drivers/RandomReplication/Driver.php

Indentation +33 added lines, -33 removed lines

@@ -25,41 +25,41 @@
 
 class Driver extends MasterSlaveReplicationDriver
 {
-    /**
-     * RandomReplicationCluster constructor.
-     * @param string $clusterName
-     * @param EventManagerInterface $em
-     * @param AggregatablePoolInterface ...$driverPools
-     * @throws ReflectionException
-     */
-    public function __construct(
-        string $clusterName,
-        EventManagerInterface $em,
-        AggregatablePoolInterface ...$driverPools
-    ) {
-        /** Straight call to ClusterPoolAbstract constructor  */
-        (new ReflectionMethod(
-            \get_parent_class(\get_parent_class($this)),
-            __FUNCTION__
-        ))->invoke($this, $clusterName, $em, ...$driverPools);
+	/**
+	 * RandomReplicationCluster constructor.
+	 * @param string $clusterName
+	 * @param EventManagerInterface $em
+	 * @param AggregatablePoolInterface ...$driverPools
+	 * @throws ReflectionException
+	 */
+	public function __construct(
+		string $clusterName,
+		EventManagerInterface $em,
+		AggregatablePoolInterface ...$driverPools
+	) {
+		/** Straight call to ClusterPoolAbstract constructor  */
+		(new ReflectionMethod(
+			\get_parent_class(\get_parent_class($this)),
+			__FUNCTION__
+		))->invoke($this, $clusterName, $em, ...$driverPools);
 
-        $randomPool = $driverPools[\random_int(0, \count($driverPools) - 1)];
+		$randomPool = $driverPools[\random_int(0, \count($driverPools) - 1)];
 
-        $this->eventManager->dispatch(
-            Event::CACHE_REPLICATION_RANDOM_POOL_CHOSEN,
-            $this,
-            $randomPool
-        );
+		$this->eventManager->dispatch(
+			Event::CACHE_REPLICATION_RANDOM_POOL_CHOSEN,
+			$this,
+			$randomPool
+		);
 
-        $this->clusterPools = [$randomPool];
-    }
+		$this->clusterPools = [$randomPool];
+	}
 
-    /**
-     * @param callable $operation
-     * @return mixed
-     */
-    protected function makeOperation(callable $operation)
-    {
-        return $operation($this->getMasterPool());
-    }
+	/**
+	 * @param callable $operation
+	 * @return mixed
+	 */
+	protected function makeOperation(callable $operation)
+	{
+		return $operation($this->getMasterPool());
+	}
 }

plugins/files/php/vendor/phpfastcache/phpfastcache/lib/Phpfastcache/Cluster/Drivers/SemiReplication/Driver.php

Indentation +169 added lines, -169 removed lines

@@ -25,173 +25,173 @@
 
 class Driver extends ClusterPoolAbstract
 {
-    /**
-     * @inheritDoc
-     * @throws InvalidArgumentException
-     * @throws PhpfastcacheReplicationException
-     */
-    public function getItem(string $key): ExtendedCacheItemInterface
-    {
-        /** @var ?ExtendedCacheItemInterface $item */
-        $item = null;
-        $eCount = 0;
-
-        foreach ($this->clusterPools as $driverPool) {
-            try {
-                $poolItem = $driverPool->getItem($key);
-                if (!$item && $poolItem->isHit()) {
-                    $item = $poolItem;
-                    break;
-                }
-            } catch (PhpfastcacheExceptionInterface) {
-                $eCount++;
-            }
-        }
-
-        if (\count($this->clusterPools) <= $eCount) {
-            throw new PhpfastcacheReplicationException('Every pools thrown an exception');
-        }
-
-        if ($item === null) {
-            $item = new Item($this, $key, $this->getEventManager());
-            $item->expiresAfter((int) abs($this->getConfig()->getDefaultTtl()));
-        }
-
-        return $this->getStandardizedItem($item, $this);
-    }
-
-    /**
-     * @inheritDoc
-     * @throws PhpfastcacheReplicationException
-     */
-    public function hasItem(string $key): bool
-    {
-        $eCount = 0;
-        foreach ($this->clusterPools as $driverPool) {
-            try {
-                $poolItem = $driverPool->getItem($key);
-                if ($poolItem->isHit()) {
-                    return true;
-                }
-            } catch (PhpfastcacheExceptionInterface) {
-                $eCount++;
-            }
-        }
-
-        if (\count($this->clusterPools) <= $eCount) {
-            throw new PhpfastcacheReplicationException('Every pools thrown an exception');
-        }
-
-        return false;
-    }
-
-    /**
-     * @inheritDoc
-     * @throws PhpfastcacheReplicationException
-     */
-    public function clear(): bool
-    {
-        $hasClearedOnce = false;
-        $eCount = 0;
-
-        foreach ($this->clusterPools as $driverPool) {
-            try {
-                if ($result = $driverPool->clear()) {
-                    $hasClearedOnce = $result;
-                }
-            } catch (PhpfastcacheExceptionInterface) {
-                $eCount++;
-            }
-        }
-
-        if (\count($this->clusterPools) <= $eCount) {
-            throw new PhpfastcacheReplicationException('Every pools thrown an exception');
-        }
-
-        // Return true only if at least one backend confirmed the "clear" operation
-        return $hasClearedOnce;
-    }
-
-    /**
-     * @inheritDoc
-     * @throws PhpfastcacheReplicationException
-     * @throws InvalidArgumentException
-     */
-    public function deleteItem(string $key): bool
-    {
-        $hasDeletedOnce = false;
-        $eCount = 0;
-
-        foreach ($this->clusterPools as $driverPool) {
-            try {
-                if ($result = $driverPool->deleteItem($key)) {
-                    $hasDeletedOnce = $result;
-                }
-            } catch (PhpfastcacheExceptionInterface) {
-                $eCount++;
-            }
-        }
-
-        if (\count($this->clusterPools) <= $eCount) {
-            throw new PhpfastcacheReplicationException('Every pools thrown an exception');
-        }
-        // Return true only if at least one backend confirmed the "clear" operation
-        return $hasDeletedOnce;
-    }
-
-    /**
-     * @param CacheItemInterface $item
-     * @return bool
-     * @throws InvalidArgumentException
-     * @throws PhpfastcacheReplicationException
-     */
-    public function save(CacheItemInterface $item): bool
-    {
-        /** @var ExtendedCacheItemInterface $item */
-        $hasSavedOnce = false;
-        $eCount = 0;
-
-        foreach ($this->clusterPools as $driverPool) {
-            try {
-                $poolItem = $this->getStandardizedItem($item, $driverPool);
-                if ($result = $driverPool->save($poolItem)) {
-                    $hasSavedOnce = $result;
-                }
-            } catch (PhpfastcacheExceptionInterface) {
-                $eCount++;
-            }
-        }
-
-        if (\count($this->clusterPools) <= $eCount) {
-            throw new PhpfastcacheReplicationException('Every pools thrown an exception');
-        }
-        // Return true only if at least one backend confirmed the "commit" operation
-        return $hasSavedOnce;
-    }
-
-    /**
-     * @inheritDoc
-     * @throws PhpfastcacheReplicationException
-     */
-    public function commit(): bool
-    {
-        $hasCommitOnce = false;
-        $eCount = 0;
-
-        foreach ($this->clusterPools as $driverPool) {
-            try {
-                if ($result = $driverPool->commit()) {
-                    $hasCommitOnce = $result;
-                }
-            } catch (PhpfastcacheExceptionInterface) {
-                $eCount++;
-            }
-        }
-
-        if (\count($this->clusterPools) <= $eCount) {
-            throw new PhpfastcacheReplicationException('Every pools thrown an exception');
-        }
-        // Return true only if at least one backend confirmed the "commit" operation
-        return $hasCommitOnce;
-    }
+	/**
+	 * @inheritDoc
+	 * @throws InvalidArgumentException
+	 * @throws PhpfastcacheReplicationException
+	 */
+	public function getItem(string $key): ExtendedCacheItemInterface
+	{
+		/** @var ?ExtendedCacheItemInterface $item */
+		$item = null;
+		$eCount = 0;
+
+		foreach ($this->clusterPools as $driverPool) {
+			try {
+				$poolItem = $driverPool->getItem($key);
+				if (!$item && $poolItem->isHit()) {
+					$item = $poolItem;
+					break;
+				}
+			} catch (PhpfastcacheExceptionInterface) {
+				$eCount++;
+			}
+		}
+
+		if (\count($this->clusterPools) <= $eCount) {
+			throw new PhpfastcacheReplicationException('Every pools thrown an exception');
+		}
+
+		if ($item === null) {
+			$item = new Item($this, $key, $this->getEventManager());
+			$item->expiresAfter((int) abs($this->getConfig()->getDefaultTtl()));
+		}
+
+		return $this->getStandardizedItem($item, $this);
+	}
+
+	/**
+	 * @inheritDoc
+	 * @throws PhpfastcacheReplicationException
+	 */
+	public function hasItem(string $key): bool
+	{
+		$eCount = 0;
+		foreach ($this->clusterPools as $driverPool) {
+			try {
+				$poolItem = $driverPool->getItem($key);
+				if ($poolItem->isHit()) {
+					return true;
+				}
+			} catch (PhpfastcacheExceptionInterface) {
+				$eCount++;
+			}
+		}
+
+		if (\count($this->clusterPools) <= $eCount) {
+			throw new PhpfastcacheReplicationException('Every pools thrown an exception');
+		}
+
+		return false;
+	}
+
+	/**
+	 * @inheritDoc
+	 * @throws PhpfastcacheReplicationException
+	 */
+	public function clear(): bool
+	{
+		$hasClearedOnce = false;
+		$eCount = 0;
+
+		foreach ($this->clusterPools as $driverPool) {
+			try {
+				if ($result = $driverPool->clear()) {
+					$hasClearedOnce = $result;
+				}
+			} catch (PhpfastcacheExceptionInterface) {
+				$eCount++;
+			}
+		}
+
+		if (\count($this->clusterPools) <= $eCount) {
+			throw new PhpfastcacheReplicationException('Every pools thrown an exception');
+		}
+
+		// Return true only if at least one backend confirmed the "clear" operation
+		return $hasClearedOnce;
+	}
+
+	/**
+	 * @inheritDoc
+	 * @throws PhpfastcacheReplicationException
+	 * @throws InvalidArgumentException
+	 */
+	public function deleteItem(string $key): bool
+	{
+		$hasDeletedOnce = false;
+		$eCount = 0;
+
+		foreach ($this->clusterPools as $driverPool) {
+			try {
+				if ($result = $driverPool->deleteItem($key)) {
+					$hasDeletedOnce = $result;
+				}
+			} catch (PhpfastcacheExceptionInterface) {
+				$eCount++;
+			}
+		}
+
+		if (\count($this->clusterPools) <= $eCount) {
+			throw new PhpfastcacheReplicationException('Every pools thrown an exception');
+		}
+		// Return true only if at least one backend confirmed the "clear" operation
+		return $hasDeletedOnce;
+	}
+
+	/**
+	 * @param CacheItemInterface $item
+	 * @return bool
+	 * @throws InvalidArgumentException
+	 * @throws PhpfastcacheReplicationException
+	 */
+	public function save(CacheItemInterface $item): bool
+	{
+		/** @var ExtendedCacheItemInterface $item */
+		$hasSavedOnce = false;
+		$eCount = 0;
+
+		foreach ($this->clusterPools as $driverPool) {
+			try {
+				$poolItem = $this->getStandardizedItem($item, $driverPool);
+				if ($result = $driverPool->save($poolItem)) {
+					$hasSavedOnce = $result;
+				}
+			} catch (PhpfastcacheExceptionInterface) {
+				$eCount++;
+			}
+		}
+
+		if (\count($this->clusterPools) <= $eCount) {
+			throw new PhpfastcacheReplicationException('Every pools thrown an exception');
+		}
+		// Return true only if at least one backend confirmed the "commit" operation
+		return $hasSavedOnce;
+	}
+
+	/**
+	 * @inheritDoc
+	 * @throws PhpfastcacheReplicationException
+	 */
+	public function commit(): bool
+	{
+		$hasCommitOnce = false;
+		$eCount = 0;
+
+		foreach ($this->clusterPools as $driverPool) {
+			try {
+				if ($result = $driverPool->commit()) {
+					$hasCommitOnce = $result;
+				}
+			} catch (PhpfastcacheExceptionInterface) {
+				$eCount++;
+			}
+		}
+
+		if (\count($this->clusterPools) <= $eCount) {
+			throw new PhpfastcacheReplicationException('Every pools thrown an exception');
+		}
+		// Return true only if at least one backend confirmed the "commit" operation
+		return $hasCommitOnce;
+	}
 }