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

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. namespace Doctrine\ODM\MongoDB\Iterator;
  7. use Generator;
  8. use ReturnTypeWillChange;
  9. use RuntimeException;
  10. use Traversable;
  12. use function current;
  13. use function key;
  14. use function next;
  15. use function reset;
  17. /**
  18.  * Iterator for wrapping a Traversable and caching its results.
  19.  *
  20.  * By caching results, this iterators allows a Traversable to be counted and
  21.  * rewound multiple times, even if the wrapped object does not natively support
  22.  * those operations (e.g. MongoDB\Driver\Cursor).
  23.  *
  24.  * @internal
  25.  *
  26.  * @template TValue
  27.  * @template-implements Iterator<TValue>
  28.  */
  29. final class CachingIterator implements Iterator
  30. {
  31.     /** @var array<mixed, TValue> */
  32.     private $items = [];
  34.     /** @var Generator<mixed, TValue>|null */
  35.     private $iterator;
  37.     /** @var bool */
  38.     private $iteratorAdvanced = false;
  40.     /** @var bool */
  41.     private $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.     public function __destruct()
  59.     {
  60.         $this->iterator = null;
  61.     }
  63.     public function toArray(): array
  64.     {
  65.         $this->exhaustIterator();
  67.         return $this->items;
  68.     }
  70.     /**
  71.      * @return TValue|false
  72.      */
  73.     #[ReturnTypeWillChange]
  74.     public function current()
  75.     {
  76.         return current($this->items);
  77.     }
  79.     /**
  80.      * @return mixed
  81.      */
  82.     #[ReturnTypeWillChange]
  83.     public function key()
  84.     {
  85.         return key($this->items);
  86.     }
  88.     /**
  89.      * @see http://php.net/iterator.next
  90.      */
  91.     public function next(): void
  92.     {
  93.         if (! $this->iteratorExhausted) {
  94.             $this->getIterator()->next();
  95.             $this->storeCurrentItem();
  96.         }
  98.         next($this->items);
  99.     }
  101.     /**
  102.      * @see http://php.net/iterator.rewind
  103.      */
  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.     /**
  117.      * @see http://php.net/iterator.valid
  118.      */
  119.     public function valid(): bool
  120.     {
  121.         return $this->key() !== null;
  122.     }
  124.     /**
  125.      * Ensures that the inner iterator is fully consumed and cached.
  126.      */
  127.     private function exhaustIterator(): void
  128.     {
  129.         while (! $this->iteratorExhausted) {
  130.             $this->next();
  131.         }
  133.         $this->iterator = null;
  134.     }
  136.     /**
  137.      * @return Generator<mixed, TValue>
  138.      */
  139.     private function getIterator(): Generator
  140.     {
  141.         if ($this->iterator === null) {
  142.             throw new RuntimeException('Iterator has already been destroyed');
  143.         }
  145.         return $this->iterator;
  146.     }
  148.     /**
  149.      * Stores the current item in the cache.
  150.      */
  151.     private function storeCurrentItem(): void
  152.     {
  153.         $key = $this->getIterator()->key();
  155.         if ($key === null) {
  156.             return;
  157.         }
  159.         $this->items[$key] = $this->getIterator()->current();
  160.     }
  162.     /**
  163.      * @param Traversable<mixed, TValue> $traversable
  164.      *
  165.      * @return Generator<mixed, TValue>
  166.      */
  167.     private function wrapTraversable(Traversable $traversable): Generator
  168.     {
  169.         foreach ($traversable as $key => $value) {
  170.             yield $key => $value;
  172.             $this->iteratorAdvanced = true;
  173.         }
  175.         $this->iteratorExhausted = true;
  176.     }
  177. }