//Purpose:
//  Demo the conversion using binding<Concept>
//
#include <boost/type_erasure/any.hpp>
#include <boost/type_erasure/builtin.hpp>
#include <boost/type_erasure/operators.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;
  }    

void test()
{
    typedef type_uns<0> src_concrete_t;
    typedef type_uns<1> dst_concrete_t;
    typedef ::boost::mpl::vector<common<_a>, incrementable<_a> > src_concept;
    typedef ::boost::mpl::vector<common<_a>                    > dst_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<dst_concept> dst_binding(dst_smap);
    src_concrete_t src_concrete_v;
    any<src_concept, _a> src_a( src_concrete_v, src_smap);
    BOOST_CHECK_EQUAL(any_cast<src_concrete_t>(src_a), src_concrete_v);
    any<dst_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);
}

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