//Purpose:
//  Test rebind_any
//
#include <iostream>
#include <boost/type_erasure/any.hpp>
#include <boost/type_erasure/any_cast.hpp>
#include <boost/type_erasure/binding_of.hpp>
#include <boost/type_erasure/typeid_of.hpp>
#include <boost/type_erasure/builtin.hpp>
#include <boost/type_erasure/operators.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/any.hpp>
#define USE_DEMANGLED
#ifdef USE_DEMANGLED
#include <boost/utility/demangled_type_name.hpp>
#define DEMANGLE_TYPE(TYPE) utility::demangled_type_name<TYPE>()
#define DEMANGLE_EXPR(EXPR) utility::demangled_type_name(EXPR)
#else
#include <typeinfo>
#define DEMANGLE_TYPE(TYPE) typeid(TYPE).name()
#define DEMANGLE_EXPR(EXPR) DEMANGLE_TYPE(EXPR)
#endif

namespace mpl = boost::mpl;
using namespace boost::type_erasure;

  template
  < typename PH//a te placeholder
  >
struct ph_value
{
        typedef
      ph_value<PH>
    type;
};

int main()
{
        typedef 
      mpl::vector
      < copy_constructible<_a>
      , copy_constructible<_b>
    //#define USE_B_BINDING
    #ifdef USE_B_BINDING
      , constructible<_a(ph_value<_a>::type)>
    #endif
      > 
    ConceptAB;
      std::cout<<"ConceptAB="
        <<DEMANGLE_TYPE(ConceptAB)
        <<"\n";
    
      std::cout<<"ph_value<_a>::type="
        <<DEMANGLE_TYPE(ph_value<_a>::type)
        <<"\n";
    
      std::cout<<"ph_value<_b>::type="
        <<DEMANGLE_TYPE(ph_value<_b>::type)
        <<"\n";
    
    typedef mpl::map<
        mpl::pair<_a, ph_value<_a>::type >,
        mpl::pair<_b, ph_value<_b>::type >
    > bindings_map_t;
    static_binding<bindings_map_t> bindings_made=make_binding<bindings_map_t>();

    typedef any< ConceptAB, _b
    > AnyB;
    
    std::cout<<"creating b_any\n";
    ph_value<_b>::type b_valu;
    std::cout<<"typeof(b_valu)="
      <<DEMANGLE_EXPR(b_valu)
      <<"\n";
    AnyB b_any(b_valu,bindings_made);

    typedef binding<ConceptAB> ab_binding_t;
    ab_binding_t const& b_binding=binding_of(b_any);
    std::cout<<"b_binding="
      <<DEMANGLE_EXPR(b_binding)
      <<"\n";

    typedef any< ConceptAB, _a
    > AnyA;
    std::cout<<"creating a_any\n";
    ph_value<_a>::type a_valu;
    std::cout<<"typeof(a_valu)="
      <<DEMANGLE_EXPR(a_valu)
      <<"\n";
      AnyA 
    a_any
      ( b_binding
      , a_valu
      )
      ;
    ab_binding_t const&a_binding=binding_of(a_any);
    std::cout<<"a_binding="
      <<DEMANGLE_EXPR(a_binding)
      <<"\n";

    return 0;
}