//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
    ;
      void 
    at_key(void)
    {}
};

  template
  < typename KeyValue
  , typename TailArgs
  >
struct ctor_default_args
: TailArgs
{
        typedef
      ctor_default_args
    type
    ;
        using
      TailArgs::
    at_key
    ;
      typename KeyValue::second
    my_value
    ;
      typename KeyValue::second const&
    at_key(typename KeyValue::first)const
    {
        return my_value;
    }
      typename KeyValue::second&
    at_key(typename KeyValue::first)
    {
        return my_value;
    }
};

using namespace boost;

  template
  < typename... TypePairs
  >
struct map_default
: mpl::fold_assoc_pack
  < mpl::assoc_right
  , ctor_default_args
  , end_args
  , TypePairs...
  >::type
{
     
      void
    put
    ( void
    )
    {
    }
      template
      < typename HeadValue
      , typename... TailValues
      >
      void
    put
    ( HeadValue const& head_arg
    , TailValues const&... tail_args
    )
    {
        typedef typename HeadValue::first_type key_type;
        typedef typename HeadValue::second_type value_type;
        value_type& v=this->at_key(key_type());
        v=head_arg.second;
        put(tail_args...);
    }    
      template
      < typename... ValuePairs
      >
    map_default
    ( ValuePairs const&... value_pairs
    )
    {
        put(value_pairs...);
    }
        
};

int main(void)
{
        typedef
      map_default
      < mpl::pair<mpl::int_<1>,ti<1> >
      , mpl::pair<mpl::int_<2>,ti<2> >
      , mpl::pair<mpl::int_<3>,ti<3> >
      >
    map_def_ti1_3_t;
      map_def_ti1_3_t
    map_def_ti1_3_def;
    std::cout<<"-----------------------\n";
    std::cout<<"default values for map:\n";
    std::cout<<"-----------------------\n";
    std::cout<<"at_key1="<<map_def_ti1_3_def.at_key(mpl::int_<1>())<<"\n";
    std::cout<<"at_key2="<<map_def_ti1_3_def.at_key(mpl::int_<2>())<<"\n";
    std::cout<<"at_key3="<<map_def_ti1_3_def.at_key(mpl::int_<3>())<<"\n";
      map_def_ti1_3_t
    map_def_ti1_3_val2_1
    ( fusion::pair<mpl::int_<2>,ti<2> >(2)
    , fusion::pair<mpl::int_<1>,ti<1> >(1)
    )
    ;
    std::cout<<"-----------------------------\n";
    std::cout<<"named/default values for map:\n";
    std::cout<<"-----------------------------\n";
    std::cout<<"at_key1="<<map_def_ti1_3_val2_1.at_key(mpl::int_<1>())<<"\n";
    std::cout<<"at_key2="<<map_def_ti1_3_val2_1.at_key(mpl::int_<2>())<<"\n";
    std::cout<<"at_key3="<<map_def_ti1_3_val2_1.at_key(mpl::int_<3>())<<"\n";
    return 0;
}