The IteratorIterator class

    (PHP 5 >= 5.1.0, PHP 7, PHP 8)

    Introduction

    This iterator wrapper allows the conversion of anything that is Traversable into an Iterator. It is important to understand that most classes that do not implement Iterators have reasons as most likely they do not allow the full Iterator feature set. If so, techniques should be provided to prevent misuse, otherwise expect exceptions or fatal errors.

    Class synopsis

    class IteratorIterator implements OuterIterator {
    /* Methods */
    public __construct(Traversable $iterator, ?string $class = null)
    public current(): mixed
    public getInnerIterator(): ?Iterator
    public key(): mixed
    public next(): void
    public rewind(): void
    public valid(): bool
    }

    Notes

    Note:

    This class permits access to methods of the inner iterator via the __call magic method.

    Table of Contents

    Improve This Page

    Learn How To Improve This Page • Submit a Pull Request • Report a Bug
    ＋add a note

    User Contributed Notes 4 notes

    up
    23
    sven at rtbg dot de
    9 years ago
    This iterator basically is only a wrapper around another iterator. It does nothing fancy, it simply forwards any calls of rewind(), next(), valid(), current() and key() to the inner iterator. This inner iterator can be fetched with getInnerIterator().

    One special case: When passing an IteratorAggregate object, the getIterator() method of that object will be called and THAT iterator will be iterated over, and this will also be returned when calling getInnerIterator().

    This class can be extended, so it's an ideal building block for your own classes that only want to modify one or two of the iterator methods, but not all.

    Want to trim the strings returned by the current() method?

    <?php

    class TrimIterator extends IteratorIterator
    {
    public function     current() {
    return     trim(parent::current());
    }
    }

    $innerIterator = new ArrayIterator(array('normal', ' trimmable '));

    $trim = new TrimIterator($innerIterator);

    foreach (    $trim as $key => $value) {
    echo     "Key:\n";
    var_dump($key);
    echo     "Value:\n";
    var_dump($value);
    echo     "---next---";
    }
    ?>

    Output:

    Key:
    int(0)
    Value:
    string(6) "normal"
    ---next---Key:
    int(1)
    Value:
    string(9) "trimmable"
    ---next---
    up
    1
    max-p at max-p dot me
    8 years ago
    Little note for anyone that wants to emulate the behavior of foreach as close as possible in order to work with somewhat picky Traversable objects, without using foreach:

    - Before starting the iteration, rewind() is called.
    - For every iteration, the following methods are called on the iterator:
    - valid()
    - current()
    - key()
    - next()

    Sounds like a silly thing to do put this way, but in my use case I needed to convert a Traversable database result cursor into a procedural-style cursor (hasNext + fetchArray) for backward compatibility, and the driver required every function to be called in the appropriate order.
    up
    2
    thomas at gielfeldt dot dk
    7 years ago
    IteratorIterator::current() does not invoke the inner iterator's current() method.

    The inner iterator's current() method is invoked (and cached) on rewind() and next(). The same goes for key() and valid().

    Example:
    <?php

    $i     = new ArrayIterator(range(1,10));
    $i = new IteratorIterator($i);
    iterator_to_array($i); // Seek to the end
    print "Valid: " . $i->valid() . "\n";
    $i->append('test');
    print     "Valid: " . $i->valid() . "\n";
    print     "Current: " . $i->current() . "\n";

    ?>

    Output:

    Valid:
    Valid:
    Current:

    Whereas:
    <?php

    $i     = new ArrayIterator(range(1,10));
    iterator_to_array($i); // Seek to the end
    print "Valid: " . $i->valid() . "\n";
    $i->append('test');
    print     "Valid: " . $i->valid() . "\n";
    print     "Current: " . $i->current() . "\n";
    ?>

    Output:

    Valid:
    Valid: 1
    Current: test

    The reason being the way current(), key() and valid() are invoked by the IteratorIterator as mentioned above.
    up
    1
    wallacemaxters at gmail dot lcom
    8 years ago
    Another example of the efficiency for IteratorIterator is a small class for enumerate for iterations of an interator implementation.

    Example:

    <?php

    class Enumerator extends IteratorIterator
    {
    /**
    * Initial value for enumerator
    * @param int
    */
    protected $start = 0;

    /**
    * @param int
    */
    protected $key = 0;

    /**
    * @param Traversable $iterator
    * @param scalar $start
    */
    public function __construct(Traversable $iterator, $start = 0)
    {
    parent::__construct($iterator);

    $this->start = $start;

    $this->key = $this->start;
    }

    public function     key()var_dump
    {
    return     $this->key;
    }

    public function     next()
    {
    ++    $this->key;

    parent::next();
    }

    public function     rewind()
    {
    $this->key = $this->start;

    parent::rewind();
    }

    }
    ?>

    This produces:

    <?php

    $enumerator     = new Enumerator(
    new     ArrayIterator(['php', 'java', 'python']); 7000
    );

    print_r(iterator_to_array($enumerator));

    /*
    * array(3) {
    7000 => 'php',
    7001 => 'java',
    7002 => 'python'
    }
    */

    ?>
    ＋add a note
    To Top