[Boost-users] Boost.MultiIndex iterator types

From: Jonathan Wang (jtwang_at_[hidden])
Date: 2007-02-02 19:16:35

I have two multi_index_containers that are identical except for the
ordering of the iterators. For example:

struct Foo { long x, y; };
typedef boost::multi_index_container<Foo,
   indexed_by<ordered_non_unique<composite_key<Foo, member<Foo, long, &Foo::x>,
                                                    member<Foo, long,
&Foo::y> > > > >
FooAscending;

typedef boost::multi_index_container<Foo,
   indexed_by<ordered_non_unique<composite_key<Foo, member<Foo, long, &Foo::x>,
                                                    member<Foo, long,
&Foo::y> >,

composite_key_compare<std::greater<long>, std::greater<long> > > > >
 FooDescending;

The containers are indexed on composite keys of x and y - one in
ascending order of y, the other in descending order.

I have code that operates on iterators over these containers.
Conveniently, the operation is identical, save for the ordering, so I
can reuse the interesting code that works on these iterators. However,
I am finding that the iterator types for the two containers are
identical.

Yet if I just define my overload for one of the iterators, everything
works as expected.

So my question is, is there a way to specify a generic iterator over a
multi_index_container such that code on iterators can be reused in
this way? It seems from the symbols gcc spits out that the iterator
type depends only on the type held and the number of indices in the
container (i.e. a container with a unique key on just Foo::x would
also have its iterator type collide with FooAscending::iterator and
FooDescending::iterator).

Thanks,
Jonathan