Update strategies

denisyukphp · May 25, 2022 · 21dad6e · 21dad6e
1 parent a5de389
commit 21dad6e
Show file tree

Hide file tree

Showing 27 changed files with 209 additions and 163 deletions.
diff --git a/README.md b/README.md
@@ -33,7 +33,7 @@ use Orangesoft\Throttler\Throttler;
 
 $throttler = new Throttler(
     new WeightedRoundRobinStrategy(
-        new InMemoryCounter(start: 0)
+        new InMemoryCounter(start: 0),
     )
 );
 

diff --git a/docs/index.md b/docs/index.md
@@ -23,7 +23,7 @@ use Orangesoft\Throttler\Throttler;
 
 $throttler = new Throttler(
     new WeightedRoundRobinStrategy(
-        new InMemoryCounter(start: 0)
+        new InMemoryCounter(start: 0),
     )
 );
 ```
@@ -135,7 +135,7 @@ FrequencyRandomStrategy has 2 not required options: frequency and depth. Frequen
 
 ```php
 $throttler = new Throttler(
-    new FrequencyRandomStrategy(frequency: 0.8, depth: 0.2)
+    new FrequencyRandomStrategy(frequency: 0.8, depth: 0.2),
 );
 
 /** @var Node $node */
@@ -178,7 +178,7 @@ use Orangesoft\Throttler\Strategy\WeightedRoundRobinStrategy;
 use Predis\Client;
 
 $strategy = new RoundRobinStrategy(
-    new InMemoryCounter(start: 0)
+    new InMemoryCounter(start: 0),
 );
 ```
 
@@ -209,7 +209,7 @@ In the example above, we wrote the counter with Redis.
 /** @var Predis\Client $client */
 
 $strategy = new WeightedRoundRobinStrategy(
-    new RedisCounter($client)
+    new RedisCounter($client),
 );
 ```
 

diff --git a/src/Collection/Collection.php b/src/Collection/Collection.php
@@ -6,13 +6,12 @@
 
 final class Collection implements CollectionInterface
 {
-    private \SplObjectStorage $storage;
-
+    private \SplObjectStorage $nodes;
     private bool $isWeighted = true;
 
     public function __construct(iterable $nodes = [])
     {
-        $this->storage = new \SplObjectStorage();
+        $this->nodes = new \SplObjectStorage();
 
         foreach ($nodes as $node) {
             $this->addNode($node);
@@ -25,44 +24,44 @@ public function addNode(Node $node): self
             $this->isWeighted = false;
         }
 
-        $this->storage->attach($node);
+        $this->nodes->attach($node);
 
         return $this;
     }
 
     public function getNode(int $index): Node
     {
-        if ($index > $this->storage->count()) {
+        if ($index > $this->nodes->count()) {
             throw new \InvalidArgumentException(
-                sprintf('Cannot find node at index %d', $index)
+                sprintf('Cannot find node at index "%d".', $index)
             );
         }
 
-        $this->storage->rewind();
+        $this->nodes->rewind();
 
         while ($index--) {
-            $this->storage->next();
+            $this->nodes->next();
         }
 
         /** @var Node $node */
-        $node = $this->storage->current();
+        $node = $this->nodes->current();
 
         return $node;
     }
 
     public function hasNode(Node $node): bool
     {
-        return $this->storage->contains($node);
+        return $this->nodes->contains($node);
     }
 
     public function removeNode(Node $node): void
     {
-        $this->storage->detach($node);
+        $this->nodes->detach($node);
     }
 
     public function purge(): void
     {
-        $this->storage->removeAll($this->storage);
+        $this->nodes->removeAll($this->nodes);
     }
 
     public function isWeighted(): bool
@@ -72,24 +71,24 @@ public function isWeighted(): bool
 
     public function isEmpty(): bool
     {
-        return 0 === $this->storage->count();
+        return 0 === $this->nodes->count();
     }
 
     public function count(): int
     {
-        return $this->storage->count();
+        return $this->nodes->count();
     }
 
     /**
      * @return Node[]
      */
     public function toArray(): array
     {
-        return iterator_to_array($this->storage, false);
+        return iterator_to_array($this->nodes, false);
     }
 
     public function getIterator(): \Traversable
     {
-        return $this->storage;
+        return $this->nodes;
     }
 }
diff --git a/src/Collection/Exception/EmptyCollectionException.php b/src/Collection/Exception/EmptyCollectionException.php
@@ -6,4 +6,8 @@
 
 class EmptyCollectionException extends \LogicException
 {
+    public function __construct(string $message = 'Collection of nodes must not be empty.', int $code = 0, ?\Throwable $previous = null)
+    {
+        parent::__construct($message, $code, $previous);
+    }
 }
diff --git a/src/Collection/Exception/UnweightedCollectionException.php b/src/Collection/Exception/UnweightedCollectionException.php
@@ -6,4 +6,8 @@
 
 class UnweightedCollectionException extends \LogicException
 {
+    public function __construct(string $message = 'All nodes in the collection must be weighted.', int $code = 0, ?\Throwable $previous = null)
+    {
+        parent::__construct($message, $code, $previous);
+    }
 }
diff --git a/src/Strategy/ClusterDetermineStrategy.php b/src/Strategy/ClusterDetermineStrategy.php
@@ -5,6 +5,7 @@
 namespace Orangesoft\Throttler\Strategy;
 
 use Orangesoft\Throttler\Collection\CollectionInterface;
+use Orangesoft\Throttler\Collection\Node;
 
 final class ClusterDetermineStrategy implements StrategyInterface
 {
@@ -34,21 +35,21 @@ public function __construct(ClusterSet ...$clusterSets)
         }
     }
 
-    public function getIndex(CollectionInterface $collection, array $context = []): int
+    public function getNode(CollectionInterface $collection, array $context = []): Node
     {
         if (!isset($context['cluster_name'])) {
-            throw new \RuntimeException('Required parameter "cluster_name" is missing.');
+            throw new \LogicException('Required parameter "cluster_name" is missing.');
         }
 
         if (!isset($this->clusterNames[$context['cluster_name']])) {
-            throw new \RuntimeException(
+            throw new \LogicException(
                 sprintf('Cluster name "%s" is undefined.', $context['cluster_name'])
             );
         }
 
         /** @var StrategyInterface $strategy */
         $strategy = $this->strategies[$this->clusterNames[$context['cluster_name']]];
 
-        return $strategy->getIndex($collection, $context);
+        return $strategy->getNode($collection, $context);
     }
 }
diff --git a/src/Strategy/FrequencyRandomStrategy.php b/src/Strategy/FrequencyRandomStrategy.php
@@ -6,6 +6,7 @@
 
 use Orangesoft\Throttler\Collection\CollectionInterface;
 use Orangesoft\Throttler\Collection\Exception\EmptyCollectionException;
+use Orangesoft\Throttler\Collection\Node;
 
 final class FrequencyRandomStrategy implements StrategyInterface
 {
@@ -15,10 +16,10 @@ public function __construct(
     ) {
     }
 
-    public function getIndex(CollectionInterface $collection, array $context = []): int
+    public function getNode(CollectionInterface $collection, array $context = []): Node
     {
         if ($collection->isEmpty()) {
-            throw new EmptyCollectionException('Collection of nodes must not be empty.');
+            throw new EmptyCollectionException();
         }
 
         $total = count($collection);
@@ -27,7 +28,7 @@ public function getIndex(CollectionInterface $collection, array $context = []):
 
         $index = $this->isChance($this->frequency) ? mt_rand(1, $low) : mt_rand($high, $total);
 
-        return $index - 1;
+        return $collection->getNode($index - 1);
     }
 
     private function isChance(float $frequency): bool

diff --git a/src/Strategy/MultipleDynamicStrategy.php b/src/Strategy/MultipleDynamicStrategy.php
@@ -5,13 +5,14 @@
 namespace Orangesoft\Throttler\Strategy;
 
 use Orangesoft\Throttler\Collection\CollectionInterface;
+use Orangesoft\Throttler\Collection\Node;
 
 final class MultipleDynamicStrategy implements StrategyInterface
 {
     /**
      * @var array<string, StrategyInterface>
      */
-    private array $pool;
+    private array $pool = [];
 
     public function __construct(StrategyInterface ...$strategies)
     {
@@ -20,14 +21,14 @@ public function __construct(StrategyInterface ...$strategies)
         }
     }
 
-    public function getIndex(CollectionInterface $collection, array $context = []): int
+    public function getNode(CollectionInterface $collection, array $context = []): Node
     {
         if (!isset($context['strategy_name'])) {
-            throw new \RuntimeException('Required parameter "strategy_name" is missing.');
+            throw new \LogicException('Required parameter "strategy_name" is missing.');
         }
 
         if (!class_exists($context['strategy_name']) || !is_a($context['strategy_name'], StrategyInterface::class, true)) {
-            throw new \RuntimeException(
+            throw new \LogicException(
                 vsprintf('Strategy must be a class that exists and implements "%s" interface, "%s" given.', [
                     StrategyInterface::class,
                     $context['strategy_name'],
@@ -36,14 +37,14 @@ public function getIndex(CollectionInterface $collection, array $context = []):
         }
 
         if (!isset($this->pool[$context['strategy_name']])) {
-            throw new \RuntimeException(
+            throw new \LogicException(
                 sprintf('Strategy "%s" is undefined.', $context['strategy_name'])
             );
         }
 
         /** @var StrategyInterface $strategy */
         $strategy = $this->pool[$context['strategy_name']];
 
-        return $strategy->getIndex($collection, $context);
+        return $strategy->getNode($collection, $context);
     }
 }
diff --git a/src/Strategy/RandomStrategy.php b/src/Strategy/RandomStrategy.php
@@ -6,15 +6,18 @@
 
 use Orangesoft\Throttler\Collection\CollectionInterface;
 use Orangesoft\Throttler\Collection\Exception\EmptyCollectionException;
+use Orangesoft\Throttler\Collection\Node;
 
 final class RandomStrategy implements StrategyInterface
 {
-    public function getIndex(CollectionInterface $collection, array $context = []): int
+    public function getNode(CollectionInterface $collection, array $context = []): Node
     {
         if ($collection->isEmpty()) {
-            throw new EmptyCollectionException('Collection of nodes must not be empty.');
+            throw new EmptyCollectionException();
         }
 
-        return mt_rand(0, count($collection) - 1);
+        $index = mt_rand(0, count($collection) - 1);
+
+        return $collection->getNode($index);
     }
 }
diff --git a/src/Strategy/RoundRobinStrategy.php b/src/Strategy/RoundRobinStrategy.php
@@ -6,6 +6,7 @@
 
 use Orangesoft\Throttler\Collection\CollectionInterface;
 use Orangesoft\Throttler\Collection\Exception\EmptyCollectionException;
+use Orangesoft\Throttler\Collection\Node;
 
 final class RoundRobinStrategy implements StrategyInterface
 {
@@ -14,12 +15,14 @@ public function __construct(
     ) {
     }
 
-    public function getIndex(CollectionInterface $collection, array $context = []): int
+    public function getNode(CollectionInterface $collection, array $context = []): Node
     {
         if ($collection->isEmpty()) {
-            throw new EmptyCollectionException('Collection of nodes must not be empty.');
+            throw new EmptyCollectionException();
         }
 
-        return $this->counter->next($context['counter_name'] ?? self::class) % count($collection);
+        $index = $this->counter->next($context['counter_name'] ?? self::class) % count($collection);
+
+        return $collection->getNode($index);
     }
 }
diff --git a/src/Strategy/SmoothWeightedRoundRobinStrategy.php b/src/Strategy/SmoothWeightedRoundRobinStrategy.php
@@ -20,14 +20,14 @@ final class SmoothWeightedRoundRobinStrategy implements StrategyInterface
      */
     private array $currentWeights = [];
 
-    public function getIndex(CollectionInterface $collection, array $context = []): int
+    public function getNode(CollectionInterface $collection, array $context = []): Node
     {
         if ($collection->isEmpty()) {
-            throw new EmptyCollectionException('Collection of nodes must not be empty.');
+            throw new EmptyCollectionException();
         }
 
         if (!$collection->isWeighted()) {
-            throw new UnweightedCollectionException('All nodes in the collection must be weighted.');
+            throw new UnweightedCollectionException();
         }
 
         if (0 === count($this->weights) || 0 === count($this->currentWeights)) {
@@ -41,7 +41,7 @@ public function getIndex(CollectionInterface $collection, array $context = []):
 
         $this->recalculateCurrentWeights($maxCurrentWeightIndex);
 
-        return $maxCurrentWeightIndex;
+        return $collection->getNode($maxCurrentWeightIndex);
     }
 
     private function getMaxCurrentWeightIndex(): int

diff --git a/src/Strategy/StrategyInterface.php b/src/Strategy/StrategyInterface.php
@@ -5,8 +5,9 @@
 namespace Orangesoft\Throttler\Strategy;
 
 use Orangesoft\Throttler\Collection\CollectionInterface;
+use Orangesoft\Throttler\Collection\Node;
 
 interface StrategyInterface
 {
-    public function getIndex(CollectionInterface $collection, array $context = []): int;
+    public function getNode(CollectionInterface $collection, array $context = []): Node;
 }
diff --git a/src/Strategy/WeightedRandomStrategy.php b/src/Strategy/WeightedRandomStrategy.php
@@ -13,14 +13,14 @@ final class WeightedRandomStrategy implements StrategyInterface
 {
     private int $sumWeight = 0;
 
-    public function getIndex(CollectionInterface $collection, array $context = []): int
+    public function getNode(CollectionInterface $collection, array $context = []): Node
     {
         if ($collection->isEmpty()) {
-            throw new EmptyCollectionException('Collection of nodes must not be empty.');
+            throw new EmptyCollectionException();
         }
 
         if (!$collection->isWeighted()) {
-            throw new UnweightedCollectionException('All nodes in the collection must be weighted.');
+            throw new UnweightedCollectionException();
         }
 
         $currentWeight = 0;
@@ -31,12 +31,12 @@ public function getIndex(CollectionInterface $collection, array $context = []):
 
         $randomWeight = mt_rand(1, $this->sumWeight);
 
-        /** @var array<int, Node> $collection*/
+        /** @var array<int, Node> $collection */
         foreach ($collection as $index => $node) {
             $currentWeight += $node->weight;
 
             if ($randomWeight <= $currentWeight) {
-                return $index;
+                return $collection->getNode($index);
             }
         }