//Purpose:
//  Demo the conversion using binding<Concept>
//
#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/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
{
    void operator++(){}
};
  template
  < unsigned Tag
  >
  bool
operator==
  ( type_uns<Tag> const&
  , type_uns<Tag> const&
  )
  {
      return true;
  }
  
  template
  < typename Bind1
  , typename Bind2
  >
  bool
same_concrete
  ( Bind1 const& bind1
  , Bind2 const& bind2
  )
  {
      //tests whether bind1 and bind2 have same placeholders
      //*and* the actual types are same.
      //
      return false
        //obviously not actual implementation.
        //Actual implementation could possibly use
        //some type of visitor pattern to find and compare
        //the actual types associated with the placeholders.
        ;
  }           

void test()
{
    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);
    any<the_concept, _a> dst_a( src_a, dst_binding);
    BOOST_ASSERT(same_concrete(binding_of(src_a), dst_binding));
    dst_concrete_t dst_concrete_v;
    BOOST_CHECK_EQUAL(any_cast<dst_concrete_t>(dst_a), dst_concrete_v);
}

int main()
{
    test();
    return 0;
}