//Purpose:
//  Demo the conversion using binding<Concept>
//
#include <iostream>
#include <boost/type_erasure/any.hpp>
#include <boost/type_erasure/builtin.hpp>
#include <boost/type_erasure/binding_of.hpp>
#include <boost/type_erasure/any_cast.hpp>
#include <boost/type_erasure/typeid_of.hpp>
#include <boost/mpl/vector.hpp>

#include <boost/assert.hpp>
#define BOOST_CHECK_EQUAL(X,Y) BOOST_ASSERT(X==Y)

using namespace boost::type_erasure;

template<class T = _self>
struct common 
: ::boost::mpl::vector
  < copy_constructible<T>
  , typeid_<T>
  > 
{};

  template
  < unsigned Tag
  >
struct type_uns
{
    unsigned const my_tag;
    type_uns(): my_tag(Tag)
    {
        std::cout<<"type_uns<"<<Tag<<">()\n";
    }
    type_uns( type_uns const&other): my_tag(Tag)
    {
        std::cout<<"type_uns<"<<Tag<<">( type_uns const&other.my_tag="<<other.my_tag<<")\n";
    }
    void operator=( type_uns const&other)
    {
        std::cout<<"type_uns<"<<Tag<<">::operator=( type_uns const&other.my_tag="<<other.my_tag<<")\n";
    }
    void operator++(){}
};
  template
  < unsigned Tag
  >
  bool
operator==
  ( type_uns<Tag> const&
  , type_uns<Tag> const&
  )
  {
      return true;
  }
  
  template
  < typename Concept1
  , typename Tag1
  , typename Concept2
  >
  bool
same_concrete
  ( any<Concept1,Tag1> const& a_any1
  , binding<Concept2> const& a_bind2
  )
  /**@brief
   *   is actual type of Tag1 in a_any1 == actual type of Tag1 in a_bind2 ?
   */
  {   
      std::type_info const& info1=typeid_of(a_any1);
      std::type_info const& info2=typeid_of<Tag1>(a_bind2);
      return info1 == info2;
  }           

int main()
{
    typedef type_uns<0> src_concrete_t;
    typedef type_uns<1> dst_concrete_t;
    typedef ::boost::mpl::vector<common<_a> > the_concept;
    typedef ::boost::mpl::map<boost::mpl::pair<_a, src_concrete_t> > src_mmap;
    typedef ::boost::mpl::map<boost::mpl::pair<_a, dst_concrete_t> > dst_mmap;

    static_binding<src_mmap> src_smap=make_binding<src_mmap>();
    static_binding<dst_mmap> dst_smap=make_binding<dst_mmap>();
    binding<the_concept> dst_binding(dst_smap);
    src_concrete_t src_concrete_v;
    any<the_concept, _a> src_a( src_concrete_v, src_smap);
    BOOST_CHECK_EQUAL(any_cast<src_concrete_t>(src_a), src_concrete_v);
  #define CHECK_CONCRETE
  #ifdef CHECK_CONCRETE
    BOOST_ASSERT(same_concrete(src_a, dst_binding));
  #endif
    any<the_concept, _a> dst_a( src_a, dst_binding);
    dst_concrete_t dst_concrete_v;
    BOOST_CHECK_EQUAL(any_cast<dst_concrete_t>(dst_a), dst_concrete_v);
    return 0;
}