//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 LambdaExpr
  , typename Args
  >
struct apply_each_pkg
;
  template
  < typename LambdaExpr
  , typename... Args
  >
struct apply_each_pkg
  < LambdaExpr
  , package<Args...>
  >
{
        typedef
      package
      < typename apply
        < LambdaExpr
        , Args
        >::type
        ...
      >
    type
    ;
};  

  template
  < typename LambdaExpr 
  , typename Domains
  >
struct list_comprehension
/**@brief
 *  The equivalent of haskell list comprehension expression
 *  (see http://www.haskell.org/haskellwiki/List_comprehension ):
 *
 *    [ LambdaExpr
 *    | arg<1> <- at_c<Domains,0>::type
 *    , arg<2> <- at_c<Domains,1>::type
 *    ...
 *    , arg<N> <- at_c<Domains,N-1>::type
 *    ]
 *
 *  where N=size<Domains>::type::value
 *
 **@input_conditions:
 *  LambdaExpr:
 *    an mpl Lambda Expression with arity=N.
 *    (http://www.boost.org/doc/libs/1_40_0/libs/mpl/doc/refmanual/lambda-expression.html)
 *  Domains:
 *    an mpl sequence of sequences, one for each argument to LambdaExpr.
 **@output_conditions:
 *  Let:
 *    Result = the list_comprehension<LambdaExpr,Domains>:;type;
 *    for all L in 0...N-1:
 *      S_L = size<at_c<Domains,L> >::type::value;
 *  Then:
 *    M = size<Result>::type::value = S_0*S_1*...*S_(N-1)
 *    for each K in 0...M-1:
 *      at_c<Result,K>::type = apply<LambdaExpr, Args_K>::type
 *      where:
 *        size<Args_K>::type::value = N;
 *        for all L in 0...N-1:
 *          at_c<Args_K,L>::type = some element in L-th domain of Domains.
 *      Furthermore, each Args_K is "unique", i.e. it's complosed
 *        different elements from at least one domain.
 */
{
        typedef
      typename fold
      < Domains
      , cross_prod_nil
      , cross_product<arg<1>, arg<2> >
      >::type
    arg_lists
    ;
        typedef
      unpack_args
      < LambdaExpr
      >
    unary_expr
    ;
        typedef
      typename apply_each_pkg
      < unary_expr
      , arg_lists
      >::type
    type
    ;
};

}//exit mpl namespace
}//exit boost namespace

#include <boost/mpl/package_c.hpp>
#include <boost/mpl/for_each.hpp>
#include <boost/mpl/size.hpp>
#include <iostream>
//#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 boost
{
namespace mpl
{

    typedef
  package_c<int,9001,9002,9003>::pkg_type
fields_t
;
  
    typedef
  package_c<int,9000>::pkg_type
absent_t
;
  template
  < typename Arg1
  , typename Arg2
  >
struct pkg_pair
{
    typedef package<Arg1,Arg2> type;
};  
    typedef
  list_comprehension
  < pkg_pair<arg<1>,arg<2> >
  , package<absent_t,fields_t>
  >::type
absent_fields_seq
;
struct print_absent_fields
{
      template
      < int Absent
      , int Field
      >
    void operator()
      ( package
        < integral_c<int,Absent>
        , integral_c<int,Field>
        >
      )
    {
        std::cout<<"( Absent="<<Absent<<", Field="<<Field<<")\n";
    }
};

struct print_field
{
      template
      < int Field
      >
    void operator()
      ( integral_c<int,Field>
      )
    {
        if(first_field)
        {
            std::cout<<"{ ";
            first_field = false;
        }
        else
        {
            std::cout<<", ";
        }
        std::cout<<Field;
    }
    print_field(void)
    : first_field(true)
    {}
      bool
    first_field
    ;
};

  template
  < typename Field1
  , typename Field2
  , typename Field3
  >
struct selected_fields
{
    typedef selected_fields type;
};

    typedef
  list_comprehension
  < selected_fields<arg<1>,arg<2>,arg<3> >
  , absent_fields_seq
  >::type
select_fields_seq
;
struct print_select_fields
{
  //#define SIMPLE_PRINT
  #ifdef SIMPLE_PRINT
      template
      < typename F1
      >
    void print
      ( F1
      )
    {
        std::cout<<"print_select_fields::print<F1>(F1)\n";
    }
  #else
      template
      < typename F1
      , typename F2
      , typename F3
      >
    void operator()
      ( selected_fields<F1,F2,F3>
      )
    {
        print_field field_printer;
        typedef package<F1,F2,F3> fields;
        for_each<fields>(field_printer);
        std::cout<<"}\n";
    }
  #endif
};

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);
}
  
}//exit mpl namespace
}//exit boost namespace

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