I had a similar problem - I needed to iterate over elements of a map and
find each element's index. It works by using template recursion, iterating
from the start of the sequence, with the exit specialization being when the
type of the current element being iterated over is the same as the type of
the element in the sequence you are working with.
A natural side effect of this is that the types in the sequence need to be
unique, otherwise later duplicate types will get their index to be the
index of the first element in the sequence with the same type.
Here is my code, it may help (I posted this on stackoverflow here:
http://stackoverflow.com/questions/11698413/find-the-index-of-an-element-in-...
)
#include <iostream>
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
namespace fusion = boost::fusion;
namespace mpl = boost::mpl;
// given a field, returns a fusion pair of
template<class field>
struct make_pair
{
typedef typename fusion::result_of::make_pair::type type;
};
// given a sequence of fields, returns a fusion map which maps field
-> field::type
template
struct make_map
{
typedef typename fusion::result_of::as_map,
make_pairmpl::_1>::type>::type type;
};
//-------------------------------------------------------------------------------------------
// iterate through a fusion map to find the index of a given key
template
struct key_index
{
typedef typename fusion::result_of::next<iter>::type next_iter;
typedef typename fusion::result_of::key_of::type next_key;
enum { value = 1 + key_index::value };
};
template
struct key_index
{
enum { value = 0 };
};
//-------------------------------------------------------------------------------------------
// copy an element from a vector to a map, if the index in the vector exists
template
struct do_copy
{
template<typename T>
void operator()(const vector& v, const T& dest)
{
const_cast(dest) = fusion::at_c<index>(v);
}
};
template
struct do_copy
{
template<typename T>
void operator()(const vector&, const T&)
{ }
};
//-------------------------------------------------------------------------------------------
// initialise a map with the corresponding elements in a vector,
vector may be smaller than the map
template
struct init
{
init(const vector& v) : _v(v) {}
template <typename pair> void operator()(const pair& data) const
{
typedef typename fusion::result_of::begin<map>::type
begin_iter;
typedef typename fusion::result_of::key_of::type key_type;
enum { index = key_index::value };
enum { in_vec = fusion::result_of::size<vector>::type::value > index };
do_copy()(_v, data.second);
}
private:
const vector& _v;
};
//-------------------------------------------------------------------------------------------
struct field1 { typedef std::string type; };
struct field2 { typedef int type; };
struct field3 { typedef double type; };
struct field4 { typedef std::string type; };
struct field5 { typedef int type; };
struct field6 { typedef double type; };
struct my_map
{
template
my_map(args... a)
{
typedef typename fusion::vector vector;
fusion::for_each(_map, init(vector(a...)));
}
typedef typename make_map::type map;
map _map;
};
struct print
{
template <typename pair>
void operator()(pair const& data) const
{
std::cout << data.second << " ";
}
};
//-------------------------------------------------------------------------------------------
int main()
{
my_map m("hello world", 5, 2.4);
fusion::for_each(m._map, print());
std::cout << std::endl;
return 0;
}
