vendor/doctrine/mongodb-odm/lib/Doctrine/ODM/MongoDB/Iterator/CachingIterator.php line 31

  1. <?php
  3. declare(strict_types=1);
  5. namespace Doctrine\ODM\MongoDB\Iterator;
  7. use Countable;
  8. use Generator;
  9. use ReturnTypeWillChange;
  10. use RuntimeException;
  11. use Traversable;
  13. use function count;
  14. use function current;
  15. use function key;
  16. use function next;
  17. use function reset;
  19. /**
  20.  * Iterator for wrapping a Traversable and caching its results.
  21.  *
  22.  * By caching results, this iterators allows a Traversable to be counted and
  23.  * rewound multiple times, even if the wrapped object does not natively support
  24.  * those operations (e.g. MongoDB\Driver\Cursor).
  25.  *
  26.  * @internal
  27.  *
  28.  * @template TValue
  29.  * @template-implements Iterator<TValue>
  30.  */
  31. final class CachingIterator implements Countable, Iterator
  32. {
  33.     /** @var array<mixed, TValue> */
  34.     private array $items = [];
  36.     /** @var Generator<mixed, TValue>|null */
  37.     private ?Generator $iterator;
  39.     private bool $iteratorAdvanced = false;
  41.     private bool $iteratorExhausted = false;
  43.     /**
  44.      * Initialize the iterator and stores the first item in the cache. This
  45.      * effectively rewinds the Traversable and the wrapping Generator, which
  46.      * will execute up to its first yield statement. Additionally, this mimics
  47.      * behavior of the SPL iterators and allows users to omit an explicit call
  48.      * to rewind() before using the other methods.
  49.      *
  50.      * @param Traversable<mixed, TValue> $iterator
  51.      */
  52.     public function __construct(Traversable $iterator)
  53.     {
  54.         $this->iterator = $this->wrapTraversable($iterator);
  55.         $this->storeCurrentItem();
  56.     }
  58.     /** @see https://php.net/countable.count */
  59.     public function count(): int
  60.     {
  61.         $this->exhaustIterator();
  63.         return count($this->items);
  64.     }
  66.     public function __destruct()
  67.     {
  68.         $this->iterator = null;
  69.     }
  71.     public function toArray(): array
  72.     {
  73.         $this->exhaustIterator();
  75.         return $this->items;
  76.     }
  78.     /** @return TValue|false */
  79.     #[ReturnTypeWillChange]
  80.     public function current()
  81.     {
  82.         return current($this->items);
  83.     }
  85.     /** @return mixed */
  86.     #[ReturnTypeWillChange]
  87.     public function key()
  88.     {
  89.         return key($this->items);
  90.     }
  92.     /** @see http://php.net/iterator.next */
  93.     public function next(): void
  94.     {
  95.         if (! $this->iteratorExhausted) {
  96.             $this->getIterator()->next();
  97.             $this->storeCurrentItem();
  98.         }
  100.         next($this->items);
  101.     }
  103.     /** @see http://php.net/iterator.rewind */
  104.     public function rewind(): void
  105.     {
  106.         /* If the iterator has advanced, exhaust it now so that future iteration
  107.          * can rely on the cache.
  108.          */
  109.         if ($this->iteratorAdvanced) {
  110.             $this->exhaustIterator();
  111.         }
  113.         reset($this->items);
  114.     }
  116.     /** @see http://php.net/iterator.valid */
  117.     public function valid(): bool
  118.     {
  119.         return $this->key() !== null;
  120.     }
  122.     /**
  123.      * Ensures that the inner iterator is fully consumed and cached.
  124.      */
  125.     private function exhaustIterator(): void
  126.     {
  127.         while (! $this->iteratorExhausted) {
  128.             $this->next();
  129.         }
  131.         $this->iterator = null;
  132.     }
  134.     /** @return Generator<mixed, TValue> */
  135.     private function getIterator(): Generator
  136.     {
  137.         if ($this->iterator === null) {
  138.             throw new RuntimeException('Iterator has already been destroyed');
  139.         }
  141.         return $this->iterator;
  142.     }
  144.     /**
  145.      * Stores the current item in the cache.
  146.      */
  147.     private function storeCurrentItem(): void
  148.     {
  149.         $key = $this->getIterator()->key();
  151.         if ($key === null) {
  152.             return;
  153.         }
  155.         $this->items[$key] = $this->getIterator()->current();
  156.     }
  158.     /**
  159.      * @param Traversable<mixed, TValue> $traversable
  160.      *
  161.      * @return Generator<mixed, TValue>
  162.      */
  163.     private function wrapTraversable(Traversable $traversable): Generator
  164.     {
  165.         foreach ($traversable as $key => $value) {
  166.             yield $key => $value;
  168.             $this->iteratorAdvanced = true;
  169.         }
  171.         $this->iteratorExhausted = true;
  172.     }
  173. }