<?php
/*

<  * Copyright 2017 MongoDB, Inc.



>  * Copyright 2017-present MongoDB, Inc.


 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *

<  *   http://www.apache.org/licenses/LICENSE-2.0



>  *   https://www.apache.org/licenses/LICENSE-2.0


 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

namespace MongoDB\Model;

use Countable;

< use Generator;


use Iterator;

> use IteratorIterator;
use Traversable;
> use ReturnTypeWillChange;


use function count;

> 


use function current;

< use function key;


use function next;
use function reset;

/**
 * Iterator for wrapping a Traversable and caching its results.
 *
 * By caching results, this iterators allows a Traversable to be counted and
 * rewound multiple times, even if the wrapped object does not natively support
 * those operations (e.g. MongoDB\Driver\Cursor).
 *
 * @internal
 */
class CachingIterator implements Countable, Iterator
{

>     private const FIELD_KEY = 0;
    /** @var array */
>     private const FIELD_VALUE = 1;
    private $items = [];
> 




<     /** @var Generator */



>     /** @var Iterator */


    private $iterator;

    /** @var boolean */
    private $iteratorAdvanced = false;

    /** @var boolean */
    private $iteratorExhausted = false;

    /**
     * Initialize the iterator and stores the first item in the cache. This

<      * effectively rewinds the Traversable and the wrapping Generator, which
<      * will execute up to its first yield statement. Additionally, this mimics
<      * behavior of the SPL iterators and allows users to omit an explicit call
<      * to rewind() before using the other methods.



>      * effectively rewinds the Traversable and the wrapping IteratorIterator.
>      * Additionally, this mimics behavior of the SPL iterators and allows users
>      * to omit an explicit call to rewind() before using the other methods.


     *
     * @param Traversable $traversable
     */
    public function __construct(Traversable $traversable)
    {

<         $this->iterator = $this->wrapTraversable($traversable);



>         $this->iterator = $traversable instanceof Iterator ? $traversable : new IteratorIterator($traversable);
> 
>         $this->iterator->rewind();


        $this->storeCurrentItem();
    }

    /**

<      * @see http://php.net/countable.count
<      * @return integer



>      * @see https://php.net/countable.count


     */

<     public function count()



>     public function count(): int


    {
        $this->exhaustIterator();

        return count($this->items);
    }

    /**

<      * @see http://php.net/iterator.current



>      * @see https://php.net/iterator.current


     * @return mixed
     */

>     #[ReturnTypeWillChange]


    public function current()
    {

<         return current($this->items);



>         $currentItem = current($this->items);
> 
>         return $currentItem !== false ? $currentItem[self::FIELD_VALUE] : false;


    }

    /**

<      * @see http://php.net/iterator.key



>      * @see https://php.net/iterator.key


     * @return mixed
     */

>     #[ReturnTypeWillChange]


    public function key()
    {

<         return key($this->items);



>         $currentItem = current($this->items);
> 
>         return $currentItem !== false ? $currentItem[self::FIELD_KEY] : null;


    }

    /**

<      * @see http://php.net/iterator.next
<      * @return void



>      * @see https://php.net/iterator.next


     */

<     public function next()



>     public function next(): void


    {
        if (! $this->iteratorExhausted) {

>             $this->iteratorAdvanced = true;


            $this->iterator->next();

> 


            $this->storeCurrentItem();

> 
        }
>             $this->iteratorExhausted = ! $this->iterator->valid();



        next($this->items);
    }

    /**

<      * @see http://php.net/iterator.rewind
<      * @return void



>      * @see https://php.net/iterator.rewind


     */

<     public function rewind()



>     public function rewind(): void


    {
        /* If the iterator has advanced, exhaust it now so that future iteration
         * can rely on the cache.
         */
        if ($this->iteratorAdvanced) {
            $this->exhaustIterator();
        }

        reset($this->items);
    }

    /**

<      * @see http://php.net/iterator.valid
<      * @return boolean



>      * @see https://php.net/iterator.valid


     */

<     public function valid()



>     public function valid(): bool


    {
        return $this->key() !== null;
    }

    /**
     * Ensures that the inner iterator is fully consumed and cached.
     */

<     private function exhaustIterator()



>     private function exhaustIterator(): void


    {
        while (! $this->iteratorExhausted) {
            $this->next();
        }
    }

    /**
     * Stores the current item in the cache.
     */

<     private function storeCurrentItem()



>     private function storeCurrentItem(): void


    {

<         $key = $this->iterator->key();
< 
<         if ($key === null) {



>         if (! $this->iterator->valid()) {


            return;
        }


<         $this->items[$key] = $this->iterator->current();
<     }
< 
<     /**
<      * Wraps the Traversable with a Generator.
<      *
<      * @param Traversable $traversable
<      * @return Generator
<      */
<     private function wrapTraversable(Traversable $traversable)
<     {
<         foreach ($traversable as $key => $value) {
<             yield $key => $value;
<             $this->iteratorAdvanced = true;
<         }
< 
<         $this->iteratorExhausted = true;



>         // Storing a new item in the internal cache
>         $this->items[] = [
>             self::FIELD_KEY => $this->iterator->key(),
>             self::FIELD_VALUE => $this->iterator->current(),
>         ];


    }
}