[Dune-devel] Random-Access Iterators

[Carsten Gräser]

Hi Jö,
first of all thank you for working this out.

Am 30.09.2014 um 23:17 schrieb Jö Fahlke:
> The random-access entity iterators are now ready for general review.
> https://cgit.dune-project.org/repositories/dune-grid/log/?h=feature/random-access-entity-iterators
> 
> @Carsten: are you willing to include this in 2.4, provided noone finds any
>           serious issues?
We should really vote on this for several reasons:

* Random access is a major conceptual addition.
* While it's only small interface change (in fact only an addition)
  it will be hard to revert once people start using it.
* We discussed various approaches for random access
  several times without any clear result.

In order to get this possibly into 2.4 it might be appropriate
to shorten the voting period.

My personal view is, that this approach is a good solution for
random access. However I don't understand why we should omit
operator[] in 2.4. We decided to implement copyable entities
for 2.4. If the latter are not ready yet, we should fix this first.

Best,
Carsten


> A grid declares that certain entity iterators are random-access by doing
> 
>   typedef std::random_access_iterator_tag iterator_category;
> 
> in the iterator implementation class.  The facade class Dune::EntityIterator
> notices this and defines the additional methods needed for random access
> iterators in terms of the member functions advance(n) and distanceTo(otherIt)
> of the iterator implementation class.  If your grids entity iterators do
> 
>   typedef std::forward_iterator_tag iterator_category;
> 
> or omit the member type completely, the EntityIterator will be a forward
> interator, as before.
> 
> To do this, Dune::EntityIterator no longer implements the iterator methods
> itself, but derives from Dune::EntityIteratorBase, which has a template
> parameter category to select which type of iterator to implement.  Previously
> the ancestry looked like
> 
>   EntityPointer
>   EntityIterator
> 
> now it looks like (for forward iterators)
> 
>   EntityPointer
>   EntityIteratorBase<..., std::forward_iterator_tag>
>   EntityIterator
> 
> or (for random access iterators)
> 
>   EntityPointer
>   EntityIteratorBase<..., std::forward_iterator_tag>
>   EntityIteratorBase<..., std::random_access_iterator_tag>
>   EntityIterator
> 
> The template argument list of EntityIterator is completely the same as before.
> 
> There is one function that has been omitted from random access iterators for
> the time being, namely operator[].  There are three possibilities for the
> return type of operator[]: Either return the entity by value -- but that needs
> copyable entities, which are not ready yet.  Or return a reference to the
> entity -- not possible, since we have nothing that stores that entity.  Or
> return a proxy object -- but I'm too lazy to implement that, since we will
> have copyable entities soon.  Note that instead of the (currently) invalid
> expression "it[n]" you can write "*(it+n)": The + creates a temporary
> iterator that holds the entity.
> 
> I also omitted implementing bidirectional iterators, since I could not come up
> with a use case for iterating backwards through the grid.  If a grid declares
> an iterator implementation as bidirectional, the resulting EntityIterator will
> nevertheless just be a forward iterator.  It should be easy to add
> bidirectional iterators, should the need arise.
> 
> Regards,
> Jö.


-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 473 bytes
Desc: OpenPGP digital signature
URL: <https://lists.dune-project.org/pipermail/dune-devel/attachments/20141001/f3be8304/attachment.sig>