grommunio / grommunio-web

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);
+			}
+		}
+	}
 }

Braces +4 added lines, -2 removed lines

@@ -49,12 +49,14 @@
                     if ($item->get() != $poolItemData) {
                         $poolsToResync[] = $driverPool;
                     }
-                } else {
+                }
+                else {
                     if ($item->get() !== $poolItemData) {
                         $poolsToResync[] = $driverPool;
                     }
                 }
-            } else {
+            }
+            else {
                 $poolsToResync[] = $driverPool;
             }
         }

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());
+	}
 }

Braces +1 added lines, -2 removed lines

@@ -58,8 +58,7 @@
      * @param callable $operation
      * @return mixed
      */
-    protected function makeOperation(callable $operation)
-    {
+    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;
+	}
 }

Braces +12 added lines, -6 removed lines

@@ -43,7 +43,8 @@ 
                     $item = $poolItem;
                     break;
                 }
-            } catch (PhpfastcacheExceptionInterface) {
+            }
+            catch (PhpfastcacheExceptionInterface) {
                 $eCount++;
             }
         }
@@ -73,7 +74,8 @@ 
                 if ($poolItem->isHit()) {
                     return true;
                 }
-            } catch (PhpfastcacheExceptionInterface) {
+            }
+            catch (PhpfastcacheExceptionInterface) {
                 $eCount++;
             }
         }
@@ -99,7 +101,8 @@ 
                 if ($result = $driverPool->clear()) {
                     $hasClearedOnce = $result;
                 }
-            } catch (PhpfastcacheExceptionInterface) {
+            }
+            catch (PhpfastcacheExceptionInterface) {
                 $eCount++;
             }
         }
@@ -127,7 +130,8 @@ 
                 if ($result = $driverPool->deleteItem($key)) {
                     $hasDeletedOnce = $result;
                 }
-            } catch (PhpfastcacheExceptionInterface) {
+            }
+            catch (PhpfastcacheExceptionInterface) {
                 $eCount++;
             }
         }
@@ -157,7 +161,8 @@ 
                 if ($result = $driverPool->save($poolItem)) {
                     $hasSavedOnce = $result;
                 }
-            } catch (PhpfastcacheExceptionInterface) {
+            }
+            catch (PhpfastcacheExceptionInterface) {
                 $eCount++;
             }
         }
@@ -183,7 +188,8 @@ 
                 if ($result = $driverPool->commit()) {
                     $hasCommitOnce = $result;
                 }
-            } catch (PhpfastcacheExceptionInterface) {
+            }
+            catch (PhpfastcacheExceptionInterface) {
                 $eCount++;
             }
         }

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

Indentation +127 added lines, -127 removed lines

@@ -34,131 +34,131 @@
 
 class Driver extends ClusterPoolAbstract
 {
-    /**
-     * MasterSlaveReplicationCluster constructor.
-     * @param string $clusterName
-     * @param EventManagerInterface $em
-     * @param AggregatablePoolInterface ...$driverPools
-     * @throws PhpfastcacheDriverCheckException
-     * @throws PhpfastcacheDriverConnectException
-     * @throws PhpfastcacheInvalidArgumentException
-     * @throws PhpfastcacheCoreException
-     * @throws PhpfastcacheDriverException
-     * @throws PhpfastcacheIOException
-     */
-    public function __construct(string $clusterName, EventManagerInterface $em, AggregatablePoolInterface ...$driverPools)
-    {
-        if (\count($driverPools) !== 2) {
-            throw new PhpfastcacheInvalidArgumentException('A "master/slave" cluster requires exactly two pools to be working.');
-        }
-
-        parent::__construct($clusterName, $em, ...$driverPools);
-    }
-
-    /**
-     * @inheritDoc
-     */
-    public function getItem(string $key): ExtendedCacheItemInterface
-    {
-        return $this->getStandardizedItem(
-            $this->makeOperation(static function (ExtendedCacheItemPoolInterface $pool) use ($key) {
-                return $pool->getItem($key);
-            }) ?? (new Item($this, $key, $this->getEventManager()))->expiresAfter((int) abs($this->getConfig()->getDefaultTtl())),
-            $this
-        );
-    }
-
-    /**
-     * @param callable $operation
-     * @return mixed
-     * @throws PhpfastcacheReplicationException
-     */
-    protected function makeOperation(callable $operation)
-    {
-        try {
-            return $operation($this->getMasterPool());
-        } catch (PhpfastcacheExceptionInterface $e) {
-            try {
-                $this->eventManager->dispatch(
-                    Event::CACHE_REPLICATION_SLAVE_FALLBACK,
-                    $this,
-                    \debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 2)[1]['function']
-                );
-                return $operation($this->getSlavePool());
-            } catch (PhpfastcacheExceptionInterface $e) {
-                throw new PhpfastcacheReplicationException('Master and Slave thrown an exception !');
-            }
-        }
-    }
-
-    /**
-     * @return AggregatablePoolInterface
-     */
-    protected function getMasterPool(): AggregatablePoolInterface
-    {
-        return $this->clusterPools[0];
-    }
-
-    /**
-     * @return AggregatablePoolInterface
-     */
-    protected function getSlavePool(): AggregatablePoolInterface
-    {
-        return $this->clusterPools[1];
-    }
-
-    /**
-     * @inheritDoc
-     */
-    public function hasItem(string $key): bool
-    {
-        return $this->makeOperation(
-            static fn (ExtendedCacheItemPoolInterface $pool) => $pool->hasItem($key)
-        );
-    }
-
-    /**
-     * @inheritDoc
-     */
-    public function clear(): bool
-    {
-        return $this->makeOperation(
-            static fn (ExtendedCacheItemPoolInterface $pool) => $pool->clear()
-        );
-    }
-
-    /**
-     * @inheritDoc
-     */
-    public function deleteItem(string $key): bool
-    {
-        return $this->makeOperation(
-            static fn (ExtendedCacheItemPoolInterface $pool) => $pool->deleteItem($key)
-        );
-    }
-
-    /**
-     * @inheritDoc
-     */
-    public function save(CacheItemInterface $item): bool
-    {
-        return $this->makeOperation(
-            function (ExtendedCacheItemPoolInterface $pool) use ($item) {
-                /** @var ExtendedCacheItemInterface $item */
-                $item->setHit(true);
-                return $pool->save($this->getStandardizedItem($item, $pool));
-            }
-        );
-    }
-
-
-    /**
-     * @inheritDoc
-     */
-    public function commit(): bool
-    {
-        return $this->makeOperation(
-            static fn (ExtendedCacheItemPoolInterface $pool) => $pool->commit()
-        );
-    }
+	/**
+	 * MasterSlaveReplicationCluster constructor.
+	 * @param string $clusterName
+	 * @param EventManagerInterface $em
+	 * @param AggregatablePoolInterface ...$driverPools
+	 * @throws PhpfastcacheDriverCheckException
+	 * @throws PhpfastcacheDriverConnectException
+	 * @throws PhpfastcacheInvalidArgumentException
+	 * @throws PhpfastcacheCoreException
+	 * @throws PhpfastcacheDriverException
+	 * @throws PhpfastcacheIOException
+	 */
+	public function __construct(string $clusterName, EventManagerInterface $em, AggregatablePoolInterface ...$driverPools)
+	{
+		if (\count($driverPools) !== 2) {
+			throw new PhpfastcacheInvalidArgumentException('A "master/slave" cluster requires exactly two pools to be working.');
+		}
+
+		parent::__construct($clusterName, $em, ...$driverPools);
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function getItem(string $key): ExtendedCacheItemInterface
+	{
+		return $this->getStandardizedItem(
+			$this->makeOperation(static function (ExtendedCacheItemPoolInterface $pool) use ($key) {
+				return $pool->getItem($key);
+			}) ?? (new Item($this, $key, $this->getEventManager()))->expiresAfter((int) abs($this->getConfig()->getDefaultTtl())),
+			$this
+		);
+	}
+
+	/**
+	 * @param callable $operation
+	 * @return mixed
+	 * @throws PhpfastcacheReplicationException
+	 */
+	protected function makeOperation(callable $operation)
+	{
+		try {
+			return $operation($this->getMasterPool());
+		} catch (PhpfastcacheExceptionInterface $e) {
+			try {
+				$this->eventManager->dispatch(
+					Event::CACHE_REPLICATION_SLAVE_FALLBACK,
+					$this,
+					\debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 2)[1]['function']
+				);
+				return $operation($this->getSlavePool());
+			} catch (PhpfastcacheExceptionInterface $e) {
+				throw new PhpfastcacheReplicationException('Master and Slave thrown an exception !');
+			}
+		}
+	}
+
+	/**
+	 * @return AggregatablePoolInterface
+	 */
+	protected function getMasterPool(): AggregatablePoolInterface
+	{
+		return $this->clusterPools[0];
+	}
+
+	/**
+	 * @return AggregatablePoolInterface
+	 */
+	protected function getSlavePool(): AggregatablePoolInterface
+	{
+		return $this->clusterPools[1];
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function hasItem(string $key): bool
+	{
+		return $this->makeOperation(
+			static fn (ExtendedCacheItemPoolInterface $pool) => $pool->hasItem($key)
+		);
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function clear(): bool
+	{
+		return $this->makeOperation(
+			static fn (ExtendedCacheItemPoolInterface $pool) => $pool->clear()
+		);
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function deleteItem(string $key): bool
+	{
+		return $this->makeOperation(
+			static fn (ExtendedCacheItemPoolInterface $pool) => $pool->deleteItem($key)
+		);
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function save(CacheItemInterface $item): bool
+	{
+		return $this->makeOperation(
+			function (ExtendedCacheItemPoolInterface $pool) use ($item) {
+				/** @var ExtendedCacheItemInterface $item */
+				$item->setHit(true);
+				return $pool->save($this->getStandardizedItem($item, $pool));
+			}
+		);
+	}
+
+
+	/**
+	 * @inheritDoc
+	 */
+	public function commit(): bool
+	{
+		return $this->makeOperation(
+			static fn (ExtendedCacheItemPoolInterface $pool) => $pool->commit()
+		);
+	}
 }

Spacing +2 added lines, -2 removed lines

@@ -61,7 +61,7 @@ 
     public function getItem(string $key): ExtendedCacheItemInterface
     {
         return $this->getStandardizedItem(
-            $this->makeOperation(static function (ExtendedCacheItemPoolInterface $pool) use ($key) {
+            $this->makeOperation(static function(ExtendedCacheItemPoolInterface $pool) use ($key) {
                 return $pool->getItem($key);
             }) ?? (new Item($this, $key, $this->getEventManager()))->expiresAfter((int) abs($this->getConfig()->getDefaultTtl())),
             $this
@@ -143,7 +143,7 @@ 
     public function save(CacheItemInterface $item): bool
     {
         return $this->makeOperation(
-            function (ExtendedCacheItemPoolInterface $pool) use ($item) {
+            function(ExtendedCacheItemPoolInterface $pool) use ($item) {
                 /** @var ExtendedCacheItemInterface $item */
                 $item->setHit(true);
                 return $pool->save($this->getStandardizedItem($item, $pool));

Braces +6 added lines, -6 removed lines

@@ -46,8 +46,7 @@ 
      * @throws PhpfastcacheDriverException
      * @throws PhpfastcacheIOException
      */
-    public function __construct(string $clusterName, EventManagerInterface $em, AggregatablePoolInterface ...$driverPools)
-    {
+    public function __construct(string $clusterName, EventManagerInterface $em, AggregatablePoolInterface ...$driverPools) {
         if (\count($driverPools) !== 2) {
             throw new PhpfastcacheInvalidArgumentException('A "master/slave" cluster requires exactly two pools to be working.');
         }
@@ -73,11 +72,11 @@ 
      * @return mixed
      * @throws PhpfastcacheReplicationException
      */
-    protected function makeOperation(callable $operation)
-    {
+    protected function makeOperation(callable $operation) {
         try {
             return $operation($this->getMasterPool());
-        } catch (PhpfastcacheExceptionInterface $e) {
+        }
+        catch (PhpfastcacheExceptionInterface $e) {
             try {
                 $this->eventManager->dispatch(
                     Event::CACHE_REPLICATION_SLAVE_FALLBACK,
@@ -85,7 +84,8 @@ 
                     \debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 2)[1]['function']
                 );
                 return $operation($this->getSlavePool());
-            } catch (PhpfastcacheExceptionInterface $e) {
+            }
+            catch (PhpfastcacheExceptionInterface $e) {
                 throw new PhpfastcacheReplicationException('Master and Slave thrown an exception !');
             }
         }

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

Indentation +207 added lines, -207 removed lines

@@ -40,211 +40,211 @@
 
 abstract class ClusterPoolAbstract implements ClusterPoolInterface
 {
-    use TaggableCacheItemPoolTrait;
-    use ClusterPoolTrait {
-        TaggableCacheItemPoolTrait::__construct as private __parentConstruct;
-    }
-
-    public const STRATEGY = [
-        AggregatorInterface::STRATEGY_FULL_REPLICATION => FullReplicationCluster::class,
-        AggregatorInterface::STRATEGY_SEMI_REPLICATION => SemiReplicationCluster::class,
-        AggregatorInterface::STRATEGY_MASTER_SLAVE => MasterSlaveReplicationCluster::class,
-        AggregatorInterface::STRATEGY_RANDOM_REPLICATION => RandomReplicationCluster::class,
-    ];
-
-    /**
-     * @var AggregatablePoolInterface[]
-     */
-    protected array $clusterPools;
-
-    /**
-     * ClusterPoolAbstract constructor.
-     * @param string $clusterName
-     * @param EventManagerInterface $em
-     * @param ExtendedCacheItemPoolInterface ...$driverPools
-     * @throws PhpfastcacheDriverCheckException
-     * @throws PhpfastcacheDriverConnectException
-     * @throws PhpfastcacheInvalidArgumentException
-     * @throws PhpfastcacheCoreException
-     * @throws PhpfastcacheDriverException
-     * @throws PhpfastcacheIOException
-     */
-    public function __construct(string $clusterName, EventManagerInterface $em, AggregatablePoolInterface ...$driverPools)
-    {
-        if (count($driverPools) < 2) {
-            throw new PhpfastcacheInvalidArgumentException('A cluster requires at least two pools to be working.');
-        }
-        $this->clusterPools = $driverPools;
-        $this->__parentConstruct(new ConfigurationOption(), $clusterName, $em);
-        $this->setEventManager(EventManager::getInstance());
-        $this->setClusterPoolsAggregator();
-    }
-
-    protected function setClusterPoolsAggregator(): void
-    {
-        foreach ($this->clusterPools as $clusterPool) {
-            $clusterPool->setAggregatedBy($this);
-        }
-    }
-
-    /**
-     * @inheritDoc
-     */
-    public function getIO(): DriverIO
-    {
-        $io = new DriverIO();
-        foreach ($this->clusterPools as $clusterPool) {
-            $io->setReadHit($io->getReadHit() + $clusterPool->getIO()->getReadHit())
-                ->setReadMiss($io->getReadMiss() + $clusterPool->getIO()->getReadMiss())
-                ->setWriteHit($io->getWriteHit() + $clusterPool->getIO()->getWriteHit());
-        }
-        return $io;
-    }
-
-    /**
-     * @inheritDoc
-     */
-    public function getClusterPools(): array
-    {
-        return $this->clusterPools;
-    }
-
-    /**
-     * @inheritDoc
-     */
-    public function getConfigs(): array
-    {
-        $configs = [];
-
-        foreach ($this->getClusterPools() as $clusterPool) {
-            $configs[$clusterPool->getDriverName()] = $clusterPool->getConfig();
-        }
-
-        return $configs;
-    }
-
-    /**
-     * @inheritDoc
-     */
-    public function getItems(array $keys = []): iterable
-    {
-        $items = [];
-
-        foreach ($keys as $key) {
-            $items[$key] = $this->getItem($key);
-        }
-
-        return $items;
-    }
-    /**
-     * Shared method used by All Clusters
-     */
-
-    /**
-     * @inheritDoc
-     */
-    public function deleteItems(array $keys): bool
-    {
-        $hasDeletedOnce = false;
-        foreach ($this->clusterPools as $driverPool) {
-            if ($result = $driverPool->deleteItems($keys)) {
-                $hasDeletedOnce = $result;
-            }
-        }
-        // Return true only if at least one backend confirmed the "clear" operation
-        return $hasDeletedOnce;
-    }
-
-    /**
-     * @param CacheItemInterface $item
-     * @return bool
-     * @throws InvalidArgumentException
-     * @throws PhpfastcacheLogicException
-     */
-    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;
-    }
-
-    /**
-     * @param ExtendedCacheItemInterface $item
-     * @param ExtendedCacheItemPoolInterface $driverPool
-     * @return ExtendedCacheItemInterface
-     * @throws InvalidArgumentException
-     * @throws PhpfastcacheLogicException
-     */
-    protected function getStandardizedItem(ExtendedCacheItemInterface $item, ExtendedCacheItemPoolInterface $driverPool): ExtendedCacheItemInterface
-    {
-        if (!$item->doesItemBelongToThatDriverBackend($driverPool)) {
-            /**
-             * Avoid infinite loop
-             */
-            if ($driverPool === $this) {
-                /** @var ExtendedCacheItemInterface $itemPool */
-                $itemClass = $driverPool::getItemClass();
-                $itemPool = new $itemClass($this, $item->getKey(), $this->getEventManager());
-                $item->cloneInto($itemPool, $driverPool);
-
-                return $itemPool;
-            }
-
-            $itemPool = $driverPool->getItem($item->getKey());
-            $item->cloneInto($itemPool, $driverPool);
-
-            return $itemPool;
-        }
-
-        return $item->setEventManager($this->getEventManager());
-    }
-
-    /**
-     * @return DriverStatistic
-     */
-    public function getStats(): DriverStatistic
-    {
-        $stats = new DriverStatistic();
-        $stats->setInfo(
-            sprintf(
-                'Using %d pool(s): %s',
-                \count($this->clusterPools),
-                \implode(
-                    ', ',
-                    \array_map(
-                        static fn (ExtendedCacheItemPoolInterface $pool) => \get_class($pool),
-                        $this->clusterPools
-                    )
-                )
-            )
-        );
-
-        $stats->setSize(
-            (int)\array_sum(
-                \array_map(
-                    static fn (ExtendedCacheItemPoolInterface $pool) => $pool->getStats()->getSize(),
-                    $this->clusterPools
-                )
-            )
-        );
-
-        $stats->setData(
-            \implode(
-                ', ',
-                \array_map(
-                    static fn (ExtendedCacheItemPoolInterface $pool) => $pool->getStats()->getData(),
-                    $this->clusterPools
-                )
-            )
-        );
-
-        return $stats;
-    }
+	use TaggableCacheItemPoolTrait;
+	use ClusterPoolTrait {
+		TaggableCacheItemPoolTrait::__construct as private __parentConstruct;
+	}
+
+	public const STRATEGY = [
+		AggregatorInterface::STRATEGY_FULL_REPLICATION => FullReplicationCluster::class,
+		AggregatorInterface::STRATEGY_SEMI_REPLICATION => SemiReplicationCluster::class,
+		AggregatorInterface::STRATEGY_MASTER_SLAVE => MasterSlaveReplicationCluster::class,
+		AggregatorInterface::STRATEGY_RANDOM_REPLICATION => RandomReplicationCluster::class,
+	];
+
+	/**
+	 * @var AggregatablePoolInterface[]
+	 */
+	protected array $clusterPools;
+
+	/**
+	 * ClusterPoolAbstract constructor.
+	 * @param string $clusterName
+	 * @param EventManagerInterface $em
+	 * @param ExtendedCacheItemPoolInterface ...$driverPools
+	 * @throws PhpfastcacheDriverCheckException
+	 * @throws PhpfastcacheDriverConnectException
+	 * @throws PhpfastcacheInvalidArgumentException
+	 * @throws PhpfastcacheCoreException
+	 * @throws PhpfastcacheDriverException
+	 * @throws PhpfastcacheIOException
+	 */
+	public function __construct(string $clusterName, EventManagerInterface $em, AggregatablePoolInterface ...$driverPools)
+	{
+		if (count($driverPools) < 2) {
+			throw new PhpfastcacheInvalidArgumentException('A cluster requires at least two pools to be working.');
+		}
+		$this->clusterPools = $driverPools;
+		$this->__parentConstruct(new ConfigurationOption(), $clusterName, $em);
+		$this->setEventManager(EventManager::getInstance());
+		$this->setClusterPoolsAggregator();
+	}
+
+	protected function setClusterPoolsAggregator(): void
+	{
+		foreach ($this->clusterPools as $clusterPool) {
+			$clusterPool->setAggregatedBy($this);
+		}
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function getIO(): DriverIO
+	{
+		$io = new DriverIO();
+		foreach ($this->clusterPools as $clusterPool) {
+			$io->setReadHit($io->getReadHit() + $clusterPool->getIO()->getReadHit())
+				->setReadMiss($io->getReadMiss() + $clusterPool->getIO()->getReadMiss())
+				->setWriteHit($io->getWriteHit() + $clusterPool->getIO()->getWriteHit());
+		}
+		return $io;
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function getClusterPools(): array
+	{
+		return $this->clusterPools;
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function getConfigs(): array
+	{
+		$configs = [];
+
+		foreach ($this->getClusterPools() as $clusterPool) {
+			$configs[$clusterPool->getDriverName()] = $clusterPool->getConfig();
+		}
+
+		return $configs;
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public function getItems(array $keys = []): iterable
+	{
+		$items = [];
+
+		foreach ($keys as $key) {
+			$items[$key] = $this->getItem($key);
+		}
+
+		return $items;
+	}
+	/**
+	 * Shared method used by All Clusters
+	 */
+
+	/**
+	 * @inheritDoc
+	 */
+	public function deleteItems(array $keys): bool
+	{
+		$hasDeletedOnce = false;
+		foreach ($this->clusterPools as $driverPool) {
+			if ($result = $driverPool->deleteItems($keys)) {
+				$hasDeletedOnce = $result;
+			}
+		}
+		// Return true only if at least one backend confirmed the "clear" operation
+		return $hasDeletedOnce;
+	}
+
+	/**
+	 * @param CacheItemInterface $item
+	 * @return bool
+	 * @throws InvalidArgumentException
+	 * @throws PhpfastcacheLogicException
+	 */
+	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;
+	}
+
+	/**
+	 * @param ExtendedCacheItemInterface $item
+	 * @param ExtendedCacheItemPoolInterface $driverPool
+	 * @return ExtendedCacheItemInterface
+	 * @throws InvalidArgumentException
+	 * @throws PhpfastcacheLogicException
+	 */
+	protected function getStandardizedItem(ExtendedCacheItemInterface $item, ExtendedCacheItemPoolInterface $driverPool): ExtendedCacheItemInterface
+	{
+		if (!$item->doesItemBelongToThatDriverBackend($driverPool)) {
+			/**
+			 * Avoid infinite loop
+			 */
+			if ($driverPool === $this) {
+				/** @var ExtendedCacheItemInterface $itemPool */
+				$itemClass = $driverPool::getItemClass();
+				$itemPool = new $itemClass($this, $item->getKey(), $this->getEventManager());
+				$item->cloneInto($itemPool, $driverPool);
+
+				return $itemPool;
+			}
+
+			$itemPool = $driverPool->getItem($item->getKey());
+			$item->cloneInto($itemPool, $driverPool);
+
+			return $itemPool;
+		}
+
+		return $item->setEventManager($this->getEventManager());
+	}
+
+	/**
+	 * @return DriverStatistic
+	 */
+	public function getStats(): DriverStatistic
+	{
+		$stats = new DriverStatistic();
+		$stats->setInfo(
+			sprintf(
+				'Using %d pool(s): %s',
+				\count($this->clusterPools),
+				\implode(
+					', ',
+					\array_map(
+						static fn (ExtendedCacheItemPoolInterface $pool) => \get_class($pool),
+						$this->clusterPools
+					)
+				)
+			)
+		);
+
+		$stats->setSize(
+			(int)\array_sum(
+				\array_map(
+					static fn (ExtendedCacheItemPoolInterface $pool) => $pool->getStats()->getSize(),
+					$this->clusterPools
+				)
+			)
+		);
+
+		$stats->setData(
+			\implode(
+				', ',
+				\array_map(
+					static fn (ExtendedCacheItemPoolInterface $pool) => $pool->getStats()->getData(),
+					$this->clusterPools
+				)
+			)
+		);
+
+		return $stats;
+	}
 }

Spacing +1 added lines, -1 removed lines

@@ -227,7 +227,7 @@
         );
 
         $stats->setSize(
-            (int)\array_sum(
+            (int) \array_sum(
                 \array_map(
                     static fn (ExtendedCacheItemPoolInterface $pool) => $pool->getStats()->getSize(),
                     $this->clusterPools

Braces +1 added lines, -2 removed lines

@@ -69,8 +69,7 @@
      * @throws PhpfastcacheDriverException
      * @throws PhpfastcacheIOException
      */
-    public function __construct(string $clusterName, EventManagerInterface $em, AggregatablePoolInterface ...$driverPools)
-    {
+    public function __construct(string $clusterName, EventManagerInterface $em, AggregatablePoolInterface ...$driverPools) {
         if (count($driverPools) < 2) {
             throw new PhpfastcacheInvalidArgumentException('A cluster requires at least two pools to be working.');
         }

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

Indentation +137 added lines, -137 removed lines

@@ -30,141 +30,141 @@
 
 class ClusterAggregator implements AggregatorInterface
 {
-    /**
-     * @var array<string, AggregatablePoolInterface>
-     */
-    protected array $driverPools;
-
-    protected ClusterPoolInterface $cluster;
-
-    protected string $clusterAggregatorName;
-
-    /**
-     * ClusterAggregator constructor.
-     * @param string $clusterAggregatorName
-     * @param array<AggregatablePoolInterface> $driverPools
-     * @throws PhpfastcacheLogicException
-     */
-    public function __construct(string $clusterAggregatorName = '', AggregatablePoolInterface ...$driverPools)
-    {
-        $clusterAggregatorName = trim($clusterAggregatorName);
-        if (empty($clusterAggregatorName)) {
-            try {
-                $clusterAggregatorName = 'cluster_' . \bin2hex(\random_bytes(15));
-            } catch (Exception) {
-                $clusterAggregatorName = 'cluster_' . \str_shuffle(\spl_object_hash(new stdClass()));
-            }
-        }
-
-        $this->clusterAggregatorName = $clusterAggregatorName;
-
-        foreach ($driverPools as $driverPool) {
-            $this->aggregateDriver($driverPool);
-        }
-    }
-
-    /**
-     * @param AggregatablePoolInterface $driverPool
-     *
-     * @throws PhpfastcacheLogicException
-     */
-    public function aggregateDriver(AggregatablePoolInterface $driverPool): void
-    {
-        if (isset($this->cluster)) {
-            throw new PhpfastcacheLogicException('The cluster has been already build, cannot aggregate more pools.');
-        }
-
-        $splHash = \spl_object_hash($driverPool);
-        if (!isset($this->driverPools[$splHash])) {
-            if ($driverPool instanceof ClusterPoolInterface) {
-                throw new PhpfastcacheLogicException('Recursive cluster aggregation is not allowed !');
-            }
-
-            $this->driverPools[$splHash] = $driverPool;
-        } else {
-            throw new PhpfastcacheLogicException('This pool has been already aggregated !');
-        }
-    }
-
-    /**
-     * @param string $driverName
-     * @param ConfigurationOption|null $driverConfig
-     * @throws PhpfastcacheDriverCheckException
-     * @throws PhpfastcacheDriverException
-     * @throws PhpfastcacheDriverNotFoundException
-     * @throws PhpfastcacheLogicException
-     */
-    public function aggregateDriverByName(string $driverName, ConfigurationOption $driverConfig = null): void
-    {
-        if (isset($this->cluster)) {
-            throw new PhpfastcacheLogicException('The cluster has been already build, cannot aggregate more pools.');
-        }
-
-        $driverInstance = CacheManager::getInstance($driverName, $driverConfig);
-
-        if ($driverInstance instanceof AggregatablePoolInterface) {
-            $this->aggregateDriver($driverInstance);
-        }
-
-        throw new PhpfastcacheDriverException(
-            \sprintf(
-                'Driver "%s" does not implements "%s"',
-                $driverInstance::class,
-                AggregatablePoolInterface::class
-            )
-        );
-    }
-
-    /**
-     * @param AggregatablePoolInterface $driverPool
-     *
-     * @throws PhpfastcacheLogicException
-     */
-    public function disaggregateDriver(AggregatablePoolInterface $driverPool): void
-    {
-        if (isset($this->cluster)) {
-            throw new PhpfastcacheLogicException('The cluster has been already build, cannot disaggregate pools.');
-        }
-
-        $splHash = \spl_object_hash($driverPool);
-        if (isset($this->driverPools[$splHash])) {
-            unset($this->driverPools[$splHash]);
-        } else {
-            throw new PhpfastcacheLogicException('This pool was not aggregated !');
-        }
-    }
-
-    /**
-     * @param int $strategy
-     *
-     * @return ClusterPoolInterface
-     * @throws PhpfastcacheInvalidArgumentException
-     */
-    public function getCluster(int $strategy = AggregatorInterface::STRATEGY_FULL_REPLICATION): ClusterPoolInterface
-    {
-        if (isset(ClusterPoolAbstract::STRATEGY[$strategy])) {
-            if (!isset($this->cluster)) {
-                $clusterClass = ClusterPoolAbstract::STRATEGY[$strategy];
-                $this->cluster = new $clusterClass(
-                    $this->getClusterAggregatorName(),
-                    EventManager::getInstance(),
-                    ...\array_values($this->driverPools)
-                );
-
-                $this->cluster->getEventManager()->dispatch(Event::CACHE_CLUSTER_BUILT, $this, $this->cluster);
-            }
-        } else {
-            throw new PhpfastcacheInvalidArgumentException('Unknown cluster strategy');
-        }
-
-        return $this->cluster;
-    }
-
-    /**
-     * @return string
-     */
-    public function getClusterAggregatorName(): string
-    {
-        return $this->clusterAggregatorName;
-    }
+	/**
+	 * @var array<string, AggregatablePoolInterface>
+	 */
+	protected array $driverPools;
+
+	protected ClusterPoolInterface $cluster;
+
+	protected string $clusterAggregatorName;
+
+	/**
+	 * ClusterAggregator constructor.
+	 * @param string $clusterAggregatorName
+	 * @param array<AggregatablePoolInterface> $driverPools
+	 * @throws PhpfastcacheLogicException
+	 */
+	public function __construct(string $clusterAggregatorName = '', AggregatablePoolInterface ...$driverPools)
+	{
+		$clusterAggregatorName = trim($clusterAggregatorName);
+		if (empty($clusterAggregatorName)) {
+			try {
+				$clusterAggregatorName = 'cluster_' . \bin2hex(\random_bytes(15));
+			} catch (Exception) {
+				$clusterAggregatorName = 'cluster_' . \str_shuffle(\spl_object_hash(new stdClass()));
+			}
+		}
+
+		$this->clusterAggregatorName = $clusterAggregatorName;
+
+		foreach ($driverPools as $driverPool) {
+			$this->aggregateDriver($driverPool);
+		}
+	}
+
+	/**
+	 * @param AggregatablePoolInterface $driverPool
+	 *
+	 * @throws PhpfastcacheLogicException
+	 */
+	public function aggregateDriver(AggregatablePoolInterface $driverPool): void
+	{
+		if (isset($this->cluster)) {
+			throw new PhpfastcacheLogicException('The cluster has been already build, cannot aggregate more pools.');
+		}
+
+		$splHash = \spl_object_hash($driverPool);
+		if (!isset($this->driverPools[$splHash])) {
+			if ($driverPool instanceof ClusterPoolInterface) {
+				throw new PhpfastcacheLogicException('Recursive cluster aggregation is not allowed !');
+			}
+
+			$this->driverPools[$splHash] = $driverPool;
+		} else {
+			throw new PhpfastcacheLogicException('This pool has been already aggregated !');
+		}
+	}
+
+	/**
+	 * @param string $driverName
+	 * @param ConfigurationOption|null $driverConfig
+	 * @throws PhpfastcacheDriverCheckException
+	 * @throws PhpfastcacheDriverException
+	 * @throws PhpfastcacheDriverNotFoundException
+	 * @throws PhpfastcacheLogicException
+	 */
+	public function aggregateDriverByName(string $driverName, ConfigurationOption $driverConfig = null): void
+	{
+		if (isset($this->cluster)) {
+			throw new PhpfastcacheLogicException('The cluster has been already build, cannot aggregate more pools.');
+		}
+
+		$driverInstance = CacheManager::getInstance($driverName, $driverConfig);
+
+		if ($driverInstance instanceof AggregatablePoolInterface) {
+			$this->aggregateDriver($driverInstance);
+		}
+
+		throw new PhpfastcacheDriverException(
+			\sprintf(
+				'Driver "%s" does not implements "%s"',
+				$driverInstance::class,
+				AggregatablePoolInterface::class
+			)
+		);
+	}
+
+	/**
+	 * @param AggregatablePoolInterface $driverPool
+	 *
+	 * @throws PhpfastcacheLogicException
+	 */
+	public function disaggregateDriver(AggregatablePoolInterface $driverPool): void
+	{
+		if (isset($this->cluster)) {
+			throw new PhpfastcacheLogicException('The cluster has been already build, cannot disaggregate pools.');
+		}
+
+		$splHash = \spl_object_hash($driverPool);
+		if (isset($this->driverPools[$splHash])) {
+			unset($this->driverPools[$splHash]);
+		} else {
+			throw new PhpfastcacheLogicException('This pool was not aggregated !');
+		}
+	}
+
+	/**
+	 * @param int $strategy
+	 *
+	 * @return ClusterPoolInterface
+	 * @throws PhpfastcacheInvalidArgumentException
+	 */
+	public function getCluster(int $strategy = AggregatorInterface::STRATEGY_FULL_REPLICATION): ClusterPoolInterface
+	{
+		if (isset(ClusterPoolAbstract::STRATEGY[$strategy])) {
+			if (!isset($this->cluster)) {
+				$clusterClass = ClusterPoolAbstract::STRATEGY[$strategy];
+				$this->cluster = new $clusterClass(
+					$this->getClusterAggregatorName(),
+					EventManager::getInstance(),
+					...\array_values($this->driverPools)
+				);
+
+				$this->cluster->getEventManager()->dispatch(Event::CACHE_CLUSTER_BUILT, $this, $this->cluster);
+			}
+		} else {
+			throw new PhpfastcacheInvalidArgumentException('Unknown cluster strategy');
+		}
+
+		return $this->cluster;
+	}
+
+	/**
+	 * @return string
+	 */
+	public function getClusterAggregatorName(): string
+	{
+		return $this->clusterAggregatorName;
+	}
 }

Braces +9 added lines, -6 removed lines

@@ -45,13 +45,13 @@ 
      * @param array<AggregatablePoolInterface> $driverPools
      * @throws PhpfastcacheLogicException
      */
-    public function __construct(string $clusterAggregatorName = '', AggregatablePoolInterface ...$driverPools)
-    {
+    public function __construct(string $clusterAggregatorName = '', AggregatablePoolInterface ...$driverPools) {
         $clusterAggregatorName = trim($clusterAggregatorName);
         if (empty($clusterAggregatorName)) {
             try {
                 $clusterAggregatorName = 'cluster_' . \bin2hex(\random_bytes(15));
-            } catch (Exception) {
+            }
+            catch (Exception) {
                 $clusterAggregatorName = 'cluster_' . \str_shuffle(\spl_object_hash(new stdClass()));
             }
         }
@@ -81,7 +81,8 @@ 
             }
 
             $this->driverPools[$splHash] = $driverPool;
-        } else {
+        }
+        else {
             throw new PhpfastcacheLogicException('This pool has been already aggregated !');
         }
     }
@@ -129,7 +130,8 @@ 
         $splHash = \spl_object_hash($driverPool);
         if (isset($this->driverPools[$splHash])) {
             unset($this->driverPools[$splHash]);
-        } else {
+        }
+        else {
             throw new PhpfastcacheLogicException('This pool was not aggregated !');
         }
     }
@@ -153,7 +155,8 @@ 
 
                 $this->cluster->getEventManager()->dispatch(Event::CACHE_CLUSTER_BUILT, $this, $this->cluster);
             }
-        } else {
+        }
+        else {
             throw new PhpfastcacheInvalidArgumentException('Unknown cluster strategy');
         }
 

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

Indentation +8 added lines, -8 removed lines

@@ -21,13 +21,13 @@
 
 interface ClusterPoolInterface extends ExtendedCacheItemPoolInterface
 {
-    /**
-     * @return AggregatablePoolInterface[]
-     */
-    public function getClusterPools(): array;
+	/**
+	 * @return AggregatablePoolInterface[]
+	 */
+	public function getClusterPools(): array;
 
-    /**
-     * @return ConfigurationOptionInterface[]
-     */
-    public function getConfigs(): array;
+	/**
+	 * @return ConfigurationOptionInterface[]
+	 */
+	public function getConfigs(): array;
 }