//Purpose:
//  Prototype method for creating container<all_of_aligned,Index0,Components...>
//  which has contructor taking "named component arguments".
//  IOW, a ctor taking a sequence of:
//
//    fusion::pair<Index,Ti>
//
//  where Index is mpl::advance<Index0,int_<i> >::type
//  for some 0<=i<sizeof...(Components) and Ti is the i-th elment in Components...
//  
#include <boost/fusion/support/pair.hpp>
#include <boost/mpl/pair.hpp>
#include <boost/mpl/fold_assoc_pack.hpp>
#include <iostream>

template<int I>
struct ti
{
    int v;
    ti(int a=-1)
    : v(a)
    {}
};

  template
  < int I
  >
  std::ostream&
operator<<
( std::ostream& sout
, ti<I>const& x
)
{
    sout<<"ti<"<<I<<">("<<x.v<<")";
    return sout;
}    

struct end_args
{
        typedef
      end_args
    type
    ;
        static 
      void 
    arg(void)
    {}
};

  template
  < typename KeyValue
  , typename TailArgs
  >
struct ctor_default_args
: TailArgs
{
        typedef
      ctor_default_args
    type
    ;
        using
      TailArgs::
    arg
    ;
      typename KeyValue::second
    arg(typename KeyValue::first)
    {
        typedef typename KeyValue::second value;
        return value();
    }
};

  template
  < typename KeyValue
  , typename TailArgs
  >
struct ctor_named_args
: TailArgs
{
        typedef
      ctor_named_args
    type
    ;
        using
      TailArgs::
    arg
    ;
      typename KeyValue::second_type
    my_arg
    ;
      typename KeyValue::second_type&
    arg(typename KeyValue::first_type)
    {
        return my_arg;
    }
      template
      < typename... Args
      >
    ctor_named_args
    ( KeyValue& key_value
    , Args... args
    )
    : TailArgs(args...)
    , my_arg(key_value.second)
    {}
};

using namespace boost;

  template
  < typename... Pairs
  >
struct pairs_default
: mpl::fold_assoc_pack
  < mpl::assoc_right
  , ctor_default_args
  , end_args
  , Pairs...
  >::type
{
};

  template
  < typename Defaults
  , typename... Pairs
  >
struct pairs_named
: mpl::fold_assoc_pack
  < mpl::assoc_right
  , ctor_named_args
  , Defaults
  , Pairs...
  >::type
{
        typedef typename
      mpl::fold_assoc_pack
      < mpl::assoc_right
      , ctor_named_args
      , Defaults
      , Pairs...
      >::type
    super_type
    ;
      template
      < typename... Args
      >
    pairs_named
    ( Args... args
    )
    : super_type(args...)
    {}
};

int main(void)
{
        typedef
      pairs_default
      < mpl::pair<mpl::int_<1>,ti<1> >
      , mpl::pair<mpl::int_<2>,ti<2> >
      , mpl::pair<mpl::int_<3>,ti<3> >
      >
    pairs_def_ti1_3_t;
      pairs_def_ti1_3_t
    pairs_def_ti1_3_v;
    std::cout<<"-------------------------\n";
    std::cout<<"default values for tuple:\n";
    std::cout<<"-------------------------\n";
    std::cout<<"at1="<<pairs_def_ti1_3_v.arg(mpl::int_<1>())<<"\n";
    std::cout<<"at2="<<pairs_def_ti1_3_v.arg(mpl::int_<2>())<<"\n";
    std::cout<<"at3="<<pairs_def_ti1_3_v.arg(mpl::int_<3>())<<"\n";
        typedef
      pairs_named
      < pairs_def_ti1_3_t
      , fusion::pair<mpl::int_<1>,ti<1> >
      , fusion::pair<mpl::int_<2>,ti<2> >
      >
    pairs_nam_ti1_3_t;
      pairs_nam_ti1_3_t
    pairs_nam_ti1_3_v
    ( fusion::pair<mpl::int_<1>,ti<1> >(1)
    , fusion::pair<mpl::int_<2>,ti<2> >(2)
    )
    ;
    std::cout<<"-------------------------------\n";
    std::cout<<"named/default values for tuple:\n";
    std::cout<<"-------------------------------\n";
    std::cout<<"at1="<<pairs_nam_ti1_3_v.arg(mpl::int_<1>())<<"\n";
    std::cout<<"at2="<<pairs_nam_ti1_3_v.arg(mpl::int_<2>())<<"\n";
    std::cout<<"at3="<<pairs_nam_ti1_3_v.arg(mpl::int_<3>())<<"\n";
    return 0;
}