//Purpose:
//  use cross_product to solve problem posted with headers:
//
/*
From: "Hicham Mouline" <hicham@mouline.org>
Newsgroups: gmane.comp.lib.boost.user
Subject: generate structs with all combinations of members
	from a given struct
Date: Sat, 30 Jan 2010 13:37:52 +0700
 */
//Method:
//  1) For each field, F_i, form a pair<void,F_i>, then form
//  a sequence of these pairs:
//
//    ( pair<void,F_1>
//    , pair<void,F_2>
//    ...
//    , pair<void,F_n>
//    )
//
//  2) Then form the cross_product of these pairs:
//
//       ( ( void, void, void, ... , void)
//       , ( F_1 , void, void, ... , void)
//       , ( void, F_2 , void, ... , void)
//       , ( F_1 , F_2 , void, ... , void)
//
//       .
//       .
//       .
//
//       , ( F_1 , F_2 , F_3 , ... , F_n )
//       )
//
//  3) Then use each element in the cross product as the ComponentSeq
//     argument to composite_tagged<all_of_aligned,_,ComponentSeq>.
//
//ExternalSourceRequirements:
//  The variadic template mpl library:
//    https://svn.boost.org/trac/boost/browser/sandbox/variadic_templates
//  The variadic template fusion library:
//    https://svn.boost.org/trac/boost/browser/sandbox/SOC/2009/fusion
//  The composite_tagged_seq.zip from:
//    http://www.boostpro.com/vault/index.php?&directory=Data%20Structures
//
#include <boost/mpl/cross_product_pack.hpp>
#include <boost/composite_tagged_seq.hpp>

#include <boost/mpl/for_each.hpp>
#include <boost/mpl/aux_/type_wrapper.hpp>
#include <boost/mpl/at.hpp>
#include <boost/mpl/size.hpp>

#include <iostream>
#include <iomanip>

namespace boost
{
namespace client
{

enum field_enum
{ F_1=1
, F_2
, F_3
, F_4
, F_5
};  
  template
  < field_enum FieldType
  >
struct field_type
{
    typedef field_type type;
};

  template<field_enum FieldType>
  std::ostream&
operator<<
  ( std::ostream& sout
  , field_type<FieldType> const&
  )
{
    sout<<"field_type="<<FieldType;
    return sout;
}      
    typedef
  mpl::package
  < field_type<F_1>::type
  , field_type<F_2>::type
  , field_type<F_3>::type
  , field_type<F_4>::type
  , field_type<F_5>::type
  >
fields_t
;
 
    typedef
  void
absent_tag
;
    typedef
  mpl::package<absent_tag>
absent_t
;
    typedef
  mpl::cross_product_pack
  < mpl::package<absent_t,fields_t>
  >::type
absent_fields_seq
;
struct print_absent_fields
{
      template
      < field_enum FieldType
      >
    void operator()
      ( mpl::package
        < absent_tag
        , field_type<FieldType>
        >
      )
    {
        std::cout
          <<"package"
          <<"< absent_tag"
          <<", type="<<FieldType
          <<">\n";
    }
};

struct print_field
{
    static int const width_absent=11;
    static int const width_field=2;
    
    void operator()
      ( mpl::aux::type_wrapper<absent_tag>
      )
    {
        if(first_field)
        {
            first_field = false;
        }
        else
        {
            std::cout<<", ";
        }
        std::cout<<std::setw(width_absent)<<"absent ";
    }
      template
      < field_enum FieldType
      >
    void operator()
      ( mpl::aux::type_wrapper< field_type<FieldType>  >
      )
    {
        if(first_field)
        {
            first_field = false;
        }
        else
        {
            std::cout<<", ";
        }
        std::cout<<"( type=";
        std::cout<<std::setw(width_field)<<FieldType;
        std::cout<<") "; 
    }
    print_field(void)
    : first_field(true)
    {}
      bool
    first_field
    ;
};

    typedef
  mpl::cross_product_pack
  < absent_fields_seq
  >::type
select_fields_seq
;
struct print_select_fields
{
      template
      < typename... Fields
      >
    void operator()
      ( mpl::package<Fields...>
      )
    {
        print_field field_printer;
            typedef 
          mpl::package
          < mpl::aux::type_wrapper<Fields>...
          > 
        fields;
        std::cout<<"{ ";
        mpl::for_each<fields>(field_printer);
        std::cout<<"}\n";
    }
};

  template
  < typename ComponentSeq
  >
struct fields_subset  
: composite_tagged_seq
  < composite_tags::all_of_aligned
  , mpl::integral_c<field_enum,F_1>
  , ComponentSeq
  >
{
};
  template
  < typename SelectFieldsSeq
  >
struct fields_subsets
;  
  template
  < typename... ComponentSeq
  >
struct fields_subsets
  < mpl::package<ComponentSeq...>
  >
{
        typedef
      mpl::package
      < fields_subset<ComponentSeq>...
      >
    type
    ;
};  

void test(void)
{
    print_absent_fields absent_fields_printer;
    std::cout<<"absent_fields_seq=\n";
    mpl::for_each<absent_fields_seq>(absent_fields_printer);
    print_select_fields select_fields_printer;
    std::cout<<"size<select_fields_seq>::value="<<mpl::size<select_fields_seq>::value<<"\n";
    std::cout<<"select_fields_seq=\n";
    mpl::for_each<select_fields_seq>(select_fields_printer);
    typedef fields_subsets<select_fields_seq>::type fields_subsets_t;
    unsigned const size_subsets=mpl::size<fields_subsets_t>::value;
    unsigned const last_first_half=size_subsets/2-1;
    typedef mpl::at_c<fields_subsets_t,last_first_half>::type no_f1_t;
    no_f1_t no_f1_v;
  #if 0
    //
    //The followings should get compile-time error about
    //not match for fields_subset<package<...>::project().
    //
    std::cout<<"no_f1_v.F_1="<<no_f1_v.project<F_1>()<<"\n";
  #endif
    std::cout<<"no_f1_v.F_2="<<no_f1_v.project<F_2>()<<"\n";
    std::cout<<"no_f1_v.F_3="<<no_f1_v.project<F_3>()<<"\n";
}
 
}//exit client namespace 
}//exit boost namespace

int main(void)
{
    boost::client::test();
    return 0;
}