#include <boost/mpl/apply.hpp>
#include <boost/mpl/empty_base.hpp>
#include <boost/mpl/fold.hpp>
#include <boost/mpl/identity.hpp>
#include <boost/mpl/inherit.hpp>
#include <boost/mpl/joint_view.hpp>
#include <boost/mpl/lambda.hpp>
#include <boost/mpl/pair.hpp>
#include <boost/mpl/transform.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/control/expr_if.hpp>
#include <boost/preprocessor/repetition/enum.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp> 
#include <utility>

template<typename T,typename Op>
class variable_list_member
{
public:
  typedef typename boost::mpl::apply1<Op,T>::type member_type;

        member_type& get()     {return t;}
  const member_type& get()const{return t;}

private:
  member_type t;
};

template<typename Sequence,typename Op=boost::mpl::identity<boost::mpl::_> >
class variable_list_seq:
  private boost::mpl::fold<
    Sequence,
    boost::mpl::empty_base,
    boost::mpl::inherit<
      boost::mpl::_1,
      variable_list_member<
        boost::mpl::_2,
        typename boost::mpl::lambda<Op>::type
      >
    >
  >::type
{
  typedef typename boost::mpl::lambda<Op>::type op_type;
public:
  template<typename T>
  typename variable_list_member<T,op_type>::member_type & get()
  {
    return static_cast<variable_list_member<T,op_type>&>(*this).get();
  }

  template<typename T>
  const typename variable_list_member<T,op_type>::member_type & get()const
  {
    return static_cast<const variable_list_member<T,op_type>&>(*this).get();
  }
};

/* front end to variable_list_seq hiding the use of MPL sequences */

#define VARIABLE_LIST_TEMPLATE_PARM(z,n,var) \
  typename BOOST_PP_CAT(var,n) BOOST_PP_EXPR_IF(n,=boost::mpl::na)

template<BOOST_PP_ENUM(10,VARIABLE_LIST_TEMPLATE_PARM,T)>
class variable_list:
  public variable_list_seq<boost::mpl::vector<BOOST_PP_ENUM_PARAMS(10,T)> >
{
};

#undef VARIABLE_LIST_TEMPLATE_PARM

/* cartesian variable list */

template<typename P,typename Op>
class product_variable_list_member
{
public:
  typedef typename boost::mpl::apply2<
    Op,
    typename P::first,
    typename P::second
  >::type member_type;

        member_type& get()     {return t;}
  const member_type& get()const{return t;}

private:
  member_type t;
};

template<typename T> struct pair_with:boost::mpl::pair<T,boost::mpl::_>{};

template<typename Sequence1,typename Sequence2>
struct sequence_product:
  boost::mpl::fold<
    Sequence1,
    boost::mpl::vector0<>,
    boost::mpl::joint_view<
      boost::mpl::_1,
      boost::mpl::transform<
        Sequence2,
        pair_with<boost::mpl::_2>
      >
    >
  >
{};

template<
  typename Sequence1,typename Sequence2,
  typename Op=std::pair<boost::mpl::_1,boost::mpl::_2>
>
class product_variable_list_seq:
  private boost::mpl::fold<
    typename sequence_product<Sequence1,Sequence2>::type,
    boost::mpl::empty_base,
    boost::mpl::inherit<
      boost::mpl::_1,
      product_variable_list_member<
        boost::mpl::_2,
        typename boost::mpl::lambda<Op>::type
      >
    >
  >::type
{
  typedef typename boost::mpl::lambda<Op>::type op_type;
public:
  template<typename T,typename Q>
  typename product_variable_list_member<
    boost::mpl::pair<T,Q>,op_type
  >::member_type & get()
  {
    return static_cast<
      product_variable_list_member<
        boost::mpl::pair<T,Q>,op_type>&>(*this).get();
  }

  template<typename T,typename Q>
  const typename product_variable_list_member<
    boost::mpl::pair<T,Q>,op_type
  >::member_type & get()const
  {
    return static_cast<
      const product_variable_list_member<
        boost::mpl::pair<T,Q>,op_type>&>(*this).get();
  }
};

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

#include <iostream>

template<typename T> struct my_type{typedef T* type;};

int main()
{
  typedef variable_list<int,char,double> vl_type;

  vl_type        v;
  const vl_type& vc=v;

  v.get<int>()=5;
  v.get<char>()='a';
  v.get<double>()=1.0;

  std::cout<<"v.get<int>()=="<<vc.get<int>()<<std::endl;
  std::cout<<"v.get<char>()=="<<vc.get<char>()<<std::endl;
  std::cout<<"v.get<double>()=="<<vc.get<double>()<<std::endl;

  typedef variable_list_seq<
    boost::mpl::vector<int,char>,
    my_type<boost::mpl::_>
  > vl_type2;

  vl_type2        v2;
  const vl_type2& vc2=v2;
  int             x=5;

  v2.get<int>()=&x;
  v2.get<char>()="hello";

  std::cout<<"*(v2.get<int>())=="<<*(vc2.get<int>())<<std::endl;
  std::cout<<"v2.get<char>()=="<<vc2.get<char>()<<std::endl;

  typedef product_variable_list_seq<
    boost::mpl::vector<int,char>,
    boost::mpl::vector<double,const char*>
  > pvl_type;

  pvl_type        pv;
  const pvl_type& pvc=pv;

  pv.get<int,double>()=std::make_pair(0,1.0);
  pv.get<int,const char*>()=std::make_pair(1,"boost");
  pv.get<char,double>()=std::make_pair('a',2.0);
  pv.get<char,const char*>()=std::make_pair('b',"bye");

  std::cout<<"pv.get<int,double>()==("<<
    pvc.get<int,double>().first<<","<<
    pvc.get<int,double>().second<<")"<<std::endl;
  std::cout<<"pv.get<int,const char*>()==("<<
    pvc.get<int,const char*>().first<<","<<
    pvc.get<int,const char*>().second<<")"<<std::endl;
  std::cout<<"pv.get<char,double>()==("<<
    pvc.get<char,double>().first<<","<<
    pvc.get<char,double>().second<<")"<<std::endl;
  std::cout<<"pv.get<char,const char*>()==("<<
    pvc.get<char,const char*>().first<<","<<
    pvc.get<char,const char*>().second<<")"<<std::endl;
}