//Purpose:
//  use list_comprehension.cpp method 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:
//  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>
//    )
//
//  then form the cross_product of these pairs, then eliminate
//  any void elements in the cross_product elements.
//
//Requirements:
//  The variadic template mpl library:
//    https://svn.boost.org/trac/boost/browser/sandbox/variadic_templates
//
#include <boost/mpl/package.hpp>
#include <boost/mpl/push_back.hpp>
#include <boost/mpl/apply.hpp>
#include <boost/mpl/arg.hpp>
#include <boost/mpl/fold.hpp>
#include <boost/mpl/unpack_args.hpp>

namespace boost
{
namespace mpl
{

  template
  < typename Left
  , typename Right
  >
struct cat_pkg
;  
  template
  < typename... Left
  , typename... Right
  >
struct cat_pkg
  < package<Left...>
  , package<Right...>
  >
{
        typedef 
      package
      < Left...
      , Right...
      >
    type
    ;
};  
  template
  < typename One
  , typename Many
  >
struct cross_one_many
;
  template
  < typename... Many
  >
struct cross_one_many
  < package<>
  , package<Many...>
  >
{
        typedef
      package
      < Many...
      >
    type
    ;
};
  template
  < typename One
  , typename... Many
  >
struct cross_one_many
  < One
  , package<Many...>
  >
{
        typedef
      package
      < typename push_back<One,Many>::type...
      >
    type
    ;
};
  template
  < typename Package
  , typename Op
  >
struct transform_pkg
;
  template
  < typename... Args
  , typename Op
  >
struct transform_pkg
  < package<Args...>
  , Op
  >
{
        typedef
      package
      < typename apply<Op,Args>::type...
      >
    type
    ;
};
  template
  < typename Left
  , typename Right
  >
struct cross_product
{
        typedef
      typename transform_pkg
      < Left
      , cross_one_many
        < arg<1>
        , Right
        >
      >::type
    packages
    ;
        typedef
      typename fold
      < packages
      , package<>
      , cat_pkg<arg<1>,arg<2> >
      >::type
    type
    ;
};

struct cross_prod_nil
{};
  template
  < typename... Right
  >
struct cross_product
  < cross_prod_nil
  , package<Right...>
  >
{
        typedef
      package
      < package<Right>...
      >
    type
    ;
};
  template
  < typename Domains
  >
struct cross_product_fold
: fold
  < Domains
  , cross_prod_nil
  , cross_product<arg<1>, arg<2> >
  >
{
};
}//exit mpl namespace
}//exit boost namespace

#include <boost/mpl/package.hpp>
#include <boost/mpl/for_each.hpp>
#include <boost/mpl/size.hpp>
#include <boost/mpl/remove_if.hpp>
#include <boost/mpl/transform.hpp>
#include <boost/mpl/back_inserter.hpp>
#include <boost/fusion/support/pair.hpp>
#include <iostream>
#include <iomanip>
//#define DEBUG_MPL
#ifdef DEBUG_MPL
#include <boost/mpl/at.hpp>
#include <boost/mpl/assert.hpp>
#include <boost/type_traits/is_same.hpp>
#endif

namespace fusion = boost::fusion;

namespace boost
{
namespace mpl
{
  template
  < int FieldId
  >
struct field_name
{};  
  template
  < int FieldId
  >
struct field_type
{};  

    typedef
  package
  < fusion::pair<field_name<1>, field_type<1> >
  , fusion::pair<field_name<2>, field_type<2> >
  , fusion::pair<field_name<3>, field_type<1> >
  >
fields_t
;
 
struct absent_tag
{}; 
    typedef
  package<absent_tag>
absent_t
;
    typedef
  cross_product_fold
  < package<absent_t,fields_t>
  >::type
absent_fields_seq
;
struct print_absent_fields
{
      template
      < int FieldName
      , int FieldType
      >
    void operator()
      ( package
        < absent_tag
        , fusion::pair<field_name<FieldName>, field_type<FieldType> >
        >
      )
    {
        std::cout
          <<"( name="<<FieldName
          <<", type="<<FieldType
          <<")\n";
    }
};

struct print_field
{
    static int const width_absent=20;
    static int const width_field=2;
    void operator()
      ( absent_tag
      )
    {
        if(first_field)
        {
            first_field = false;
        }
        else
        {
            std::cout<<", ";
        }
        std::cout<<std::setw(width_absent)<<"absent ";
    }
      template
      < int FieldName
      , int FieldType
      >
    void operator()
      ( fusion::pair<field_name<FieldName>, field_type<FieldType> >
      )
    {
        if(first_field)
        {
            first_field = false;
        }
        else
        {
            std::cout<<", ";
        }
        std::cout<<"( name="; 
        std::cout<<std::setw(width_field)<<FieldName;
        std::cout<<", type=";
        std::cout<<std::setw(width_field)<<FieldType;
        std::cout<<") "; 
    }
    print_field(void)
    : first_field(true)
    {}
      bool
    first_field
    ;
};

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

  template
  < typename AbsentOrField
  >
struct is_absent
: false_
{};
  template
  <
  >
struct is_absent
  < absent_tag
  >
: true_
{};

  template
  < typename AbsentOrFieldRow
  >
struct rm_absent_row
: remove_if
  < AbsentOrFieldRow
  , is_absent<arg<1> >
  , back_inserter<package<> >
  >
{
};

  template
  < typename AbsentOrFieldTable
  >
struct rm_absent_table
: transform
  < AbsentOrFieldTable
  , rm_absent_row<arg<1> >
  , back_inserter<package<> >
  >
{
};

void test(void)
{
    print_absent_fields absent_fields_printer;
    std::cout<<"absent_fields_seq=\n";
    for_each<absent_fields_seq>(absent_fields_printer);
    
    print_select_fields select_fields_printer;
    std::cout<<"size<select_fields_seq>::value="<<size<select_fields_seq>::value<<"\n";
    std::cout<<"select_fields_seq=\n";
    for_each<select_fields_seq>(select_fields_printer);
    typedef rm_absent_table<select_fields_seq>::type rm_absent_seq;
    std::cout<<"rm_absent_seq=\n";
    for_each<rm_absent_seq>(select_fields_printer);
}
  
}//exit mpl namespace
}//exit boost namespace

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