//Purpose:
//  Test any CTOR with static_binding arg.
//
#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)
#define DEMANGLE_INFO(INFO) utility::demangled_type_info(INFO)
#else
#include <typeinfo>
#define DEMANGLE_TYPE(TYPE) typeid(TYPE).name()
#define DEMANGLE_EXPR(EXPR) DEMANGLE_TYPE(EXPR)
#define DEMANGLE_INFO(INFO) INFO.name()
#endif
#include <type_traits>

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

unsigned value_instances=0;
struct value_base
{
    unsigned my_instance;
    value_base()
      : my_instance(value_instances++)
    {}
    value_base(value_base const&)
      : my_instance(value_instances++)
    {}
    value_base&operator=(value_base const&)
    {
        return *this;
    }
    virtual ~value_base()
    {}
};
template<typename PH>
struct ph_ctor_arg
: value_base
{
    typedef ph_ctor_arg type;
    virtual ~ph_ctor_arg(){}
    ph_ctor_arg()
      {
          std::cout<<__LINE__
          <<":ph_ctor_arg<"
          <<DEMANGLE_TYPE(PH)
          <<">::CTOR.default"
          <<":my_instance="
          <<my_instance
          <<"\n";
      }
    ph_ctor_arg(const ph_ctor_arg&)
    #if 1
      {
          std::cout<<__LINE__
          <<":ph_ctor_arg<"
          <<DEMANGLE_TYPE(PH)
          <<">::CTOR.copy"
          <<":my_instance="
          <<my_instance
          <<":(void*)this="
          <<(void*)this
          <<"\n";
      }
    #else
      = delete
      ;
    #endif
};

template<typename PH>
struct ph_erasee
: value_base
{
    typedef ph_erasee type;
    virtual ~ph_erasee(){}
    unsigned my_instance;
    ph_erasee()
      {
          std::cout<<__LINE__
          <<":ph_erasee<"
          <<DEMANGLE_TYPE(PH)
          <<">::CTOR.default"
          <<":my_instance="
          <<my_instance
          <<"\n";
      }
    ph_erasee(const ph_ctor_arg<PH>&)
      {
          std::cout<<__LINE__
          <<":ph_erasee<"
          <<DEMANGLE_TYPE(PH)
          <<">::CTOR.(const ph_ctor_arg<"<<DEMANGLE_TYPE(PH)<<">&)"
          <<":my_instance="
          <<my_instance
          <<":(void*)this="
          <<(void*)this
          <<"\n";
      }
    ph_erasee(const ph_erasee&) 
      = delete
      ;
    ph_erasee& operator=(ph_erasee const&)
      {
          return *this;
      }
};

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

int main()
{
        typedef
      ph_erasee<_a>
    ph_erasee_type;
        typedef
      ph_ctor_arg<_a>
    ph_ctor_arg_type;
        typedef 
      mpl::vector
      < destructible<_a>
      , typeid_<_a>
      , destructible<_b>
      , typeid_<_b>
      > 
    ConceptA;
        typedef 
      mpl::map
      < mpl::pair<_a, ph_erasee_type>
      , mpl::pair<_b, ph_ctor_arg_type>
      > 
    bindings_map_t;
    static_binding<bindings_map_t> bindings_map_v=make_binding<bindings_map_t>();
        typedef 
      any
      < ConceptA
      , _a
      > 
    AnyA;
    std::cout
      <<"std::is_copy_constructible<ph_erasee_type>="
      <<std::is_copy_constructible<ph_erasee_type>::value
      <<"\n";
      ph_ctor_arg_type
    a_ctor_arg;
    std::cout<<"creating a_fst from a_ctor_arg\n";
      AnyA 
    a_fst
      ( a_ctor_arg
      , bindings_map_v
      );

    ph_erasee_type const*fst_cast=any_cast<ph_erasee_type const*>(&a_fst);
    std::cout<<":*fst_cast="
      <<*fst_cast
      <<":(void*)fst_cast="
      <<(void const*)fst_cast
      <<"\n";
    std::cout<<"typeid(*fst_cast).name()="<<DEMANGLE_INFO(typeid(*fst_cast))<<"\n";
    return 0;
}