Is changing an objects state/contents appropriate Iterator usage (php)

Consider an object used to store a collection of items, but that collection may vary depending on predefined contexts.

Class Container implements IteratorAggregate (
  protected $contexts; // list of associated contexts, example: array(0=>1,1=>3)
  protected $contents; /开发者_运维百科/ array
  public loadContents( $contextId ) { /* populates $this->contents*/ }
  public getContexts() { /* populates $this->contexts */ }
  ...
  public function getIterator() { return new ArrayIterator($this->contents); }
  public getContextIterator() { return new contextIterator($this); }
}

The iterator looks like:

Class contextIterator {
  protected $container;
  protected $contexts;
  protected $currentContext;

  public function __construct($container) {
    $this->container = $container;
    $this->contexts = $container->getContexts();
    $this->currentContext = 0;
  }

  public current() {
    $this->container->loadContents( $this->key() );
    return $this->contexts[ $this->key() ];
  }

  public function key() { return $this->currentContext; }
  public function next() { $this->currentContext++; }
  public function rewind() { $this->currentContext = 0; }
  public function valid() { return isset( $this->contexts[ $this->key() ] ); }
}

For the few cases where each context needs to be examined iteratively, I do the following:

$myContainer = new Container();
foreach( $myContainer->getContextIterator() as $key => $value ) {
  $myContainer->someMethod();
}

The above is nice and compact, but it feels dirty to me since I'm never actually using $key or $value. Is using the iterator overkill? Further, should an iterator ever change the state/contents of the object it is iterating?

The above is nice and compact, but it feels dirty to me since I'm never actually using $key or $value.

You have not shown the inners of getContextIterator() so it's hard to make concrete suggestions. Generally it's possible to create iterate-able objects in PHP by implementing the OuterIterator interace or by just implementing the Iterator interface. Both interfaces are predefined and you then can use your object with next(), foreach etc.

I assume you've implemented something like OuterIterator. If you implement OuterIterator instead, you will get some speed benefit AFAIK.

Is using the iterator overkill?

No, won't say so. Iterators are very good for collections as you said you have one. I just would change it into a SPL iterator though.

Further, should an iterator ever change the state/contents of the object it is iterating?

Well actually each iterator does, at least for the internal pointer of the iteration. But I think that was not your concern, but might already lighten up.

So even for "more" changes inside the object you're iterating over, it's perfectly okay that it changes as long as it's clear what it does. Counter-Example: if you iterate over an array and it would shuffle elements each time the iteration goes one step ahead would not be useful.

But there are other cases where this is totally valid and useful. So decide on what's done, not with a general rule.