//Purpose:
//  Test binding_of
//
#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;

unsigned value_instances=0;
template<typename PH>
struct ph_value
{
    typedef ph_value type;
    virtual ~ph_value(){}
    unsigned my_instance;
    ph_value():my_instance(value_instances++){}
    ph_value(const ph_value&):my_instance(value_instances++){}
};

  template<typename PH>
  std::ostream&
operator<<
  ( std::ostream&sout
  , ph_value<PH>const&x
  )
  {
      sout<<"ph_value<"<<typeid(x).name()<<">.my_instance="<<x.my_instance;
      return sout;
  }      

int main()
{
        typedef
      ph_value<_a>
    a_type;
        typedef 
      mpl::vector
      < destructible<_a>
    #define HARDCODE_CTOR_ARG
    #ifdef  HARDCODE_CTOR_ARG
      , constructible<_a(const a_type&)>
    #else
      , constructible<_a(const     _a&)>
    #endif
      , typeid_<_a>
      > 
    ConceptA;
        typedef 
      mpl::map
      < mpl::pair<_a, a_type>
      > 
    bindings_map_t;
    static_binding<bindings_map_t> bindings_map_v=make_binding<bindings_map_t>();
        typedef 
      any
      < ConceptA
      , _a
      > 
    AnyA;
      a_type
    a_valu;
    std::cout<<"a_valu="
      <<a_valu
      <<"\n";
    std::cout<<"creating a_fst\n";
      AnyA 
    a_fst
      ( a_valu
      , bindings_map_v
      );

    a_type&fst_cast=any_cast<a_type&>(a_fst);
    std::cout<<"fst_cast="
      <<fst_cast
      <<"\n";
      
  #define MAKE_A_DUP
  #ifdef  MAKE_A_DUP      
        typedef 
      binding<ConceptA> 
    bindings_con_t;
      bindings_con_t const& 
    bindings_fst_v=binding_of(a_fst);

    std::cout<<"creating a_dup\n";
      AnyA 
    a_dup
      ( bindings_fst_v
    #define A_DUP_VALUE
    #ifdef  A_DUP_VALUE
      , a_valu
    #else
      , a_fst
    #endif
      )
      ;
    std::cout<<"a_dup="
      <<any_cast<a_type&>(a_dup)
      <<"\n";

  #endif
    return 0;
}