Directions:
1. Depth first or - we have that
2. Breadth first - that would insult full caching o fthe results which contradicts the ide of Iterators. If you want this do it in userland. For example you can use the function iterator_to_array() that is available in 5.1.

combined with one of:
1. Left to right
2. Right to left

Both require that the thing works on a tree structure - well we don't have a tree structure or object. And even if we had we would provide some tree walker methods and of course won't use the iterator stuff.

If you now you think you need tree's and everythink feel free to check out extension adt and get it fixed.

sorry nothing we can do atm.

I don't see how breadth first would break something that depth first doesnt't. The algorithm for breadth first is of  no higher complexity in time or memory requirements, and it certainly doesn't contradicts the idea of iterators. You say breadth first insults full caching of the results, I'm not sure what you mean and why would it do so? 

I didn't mean that PHP have a tree structure (or need one), but one wouldn't use a RecursiveIteratorIterator on something that doesn't look like a tree, let it be a directory tree or whatever tree structured data that one have.

Well, I already have these things implemented in PHP (if there is an interest, I can publish it somewhere).

The left to right or right to left functionality is best implemented at the RecursiveIterator level so that is what I have done, while depth first or breadth first is implemented at the RecursiveIteratorIterator level.

As a bonus, a depth limit option is available too, that simply prevents the iterator to go deeper than a chosen level.

My skill level in C will not allow me to do any fixes, but I'm working on that part. ;)

So, if anyone is interested in the PHP classes I wrote for iterating tree like structures in any direction, let me know.

Best Regards,

   Peter Albertsson

Sure i'd like to see what you've done.

Coming back to breadth first. The one way of doing this is to first iterate all elements and then again check for childs and iterate them. This 'again' involes one of two solutions. First you could store all elements that have children in an array and second you could rewind the iterator and try again. While the first solution caches all elements with children the second requires a working rewind() which doesn't hold for all iterators. Thus this is nothing we'd want to support in c i guess.

The other thing you mentioned the max depth is already implemented in 5.1-dev.