#include <boost/multi_index/composite_key.hpp>
#include <boost/mpl/reverse_fold.hpp>
#include <boost/preprocessor/arithmetic/dec.hpp> 
#include <boost/preprocessor/repetition/for.hpp>
#include <boost/preprocessor/tuple/elem.hpp> 
#include <boost/tuple/tuple.hpp>

struct mpl_sequence_flatter_tail
{
  typedef mpl_sequence_flatter_tail super;
  typedef boost::tuples::null_type  type;
};

template<typename Super,typename Type>
struct mpl_sequence_flatter:Super
{
  typedef Super super;
  typedef Type  type;
};

struct mpl_sequence_flatter_applier
{
  template<typename Super,typename Type>
  struct apply
  {
    typedef mpl_sequence_flatter<Super,Type> type;
  };
};

#define AUX_pred(r,state) BOOST_PP_TUPLE_ELEM(2,0,state)
#define AUX_op(r,state)                                                       \
(                                                                             \
  BOOST_PP_DEC(BOOST_PP_TUPLE_ELEM(2, 0, state)),                             \
  BOOST_PP_TUPLE_ELEM(2, 1, state)::super                                     \
)
#define AUX_macro(r,state) ,typename BOOST_PP_TUPLE_ELEM(2, 1, state)::type

template<typename Value,typename Sequence>
struct composite_key_from_sequence
{
  typedef typename boost::mpl::reverse_fold<
    Sequence,
    mpl_sequence_flatter_tail,
    mpl_sequence_flatter_applier
  >::type aux;
  
  typedef boost::multi_index::composite_key<
    Value
    BOOST_PP_FOR(
      (BOOST_MULTI_INDEX_LIMIT_COMPOSITE_KEY_SIZE,aux),
      AUX_pred,AUX_op,AUX_macro
    )   
  > type;
};

#undef AUX_pred
#undef AUX_op
#undef AUX_macro


/**************** testing ****************/

#include <boost/multi_index/member.hpp>
#include <boost/mpl/assert.hpp>
#include <boost/mpl/list.hpp>
#include <boost/mpl/push_back.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/type_traits/is_same.hpp>
#include <string>

using namespace boost;
using namespace boost::multi_index;
using namespace std;

struct employee
{
  string name;
  int    age;
  int    salary;
  int    ssn;
};

typedef member<employee,string,&employee::name> member0_type;
typedef member<employee,int,&employee::age>     member1_type;
typedef member<employee,int,&employee::salary>  member2_type;
typedef member<employee,int,&employee::ssn>     member3_type;

typedef mpl::vector<member0_type>  vector0_type;
typedef mpl::push_back<
  vector0_type,member1_type>::type vector1_type;
typedef mpl::push_back<
  vector1_type,member2_type>::type vector2_type;
typedef mpl::push_back<
  vector2_type,member3_type>::type vector3_type;
typedef mpl::list<
  member3_type,member2_type,
  member1_type,member0_type>       list0_type;

BOOST_MPL_ASSERT((
  is_same<
    composite_key_from_sequence<employee,vector0_type>::type,
    composite_key<employee,member0_type>
  >
));

BOOST_MPL_ASSERT((
  is_same<
    composite_key_from_sequence<employee,vector1_type>::type,
    composite_key<employee,member0_type,member1_type>
  >
));

BOOST_MPL_ASSERT((
  is_same<
    composite_key_from_sequence<employee,vector2_type>::type,
    composite_key<employee,member0_type,member1_type,member2_type>
  >
));

BOOST_MPL_ASSERT((
  is_same<
    composite_key_from_sequence<employee,vector3_type>::type,
    composite_key<employee,member0_type,member1_type,member2_type,member3_type>
  >
));

BOOST_MPL_ASSERT((
  is_same<
    composite_key_from_sequence<employee,list0_type>::type,
    composite_key<employee,member3_type,member2_type,member1_type,member0_type>
  >
));

int main(){}