//Purpose:
//  Demonstrate what compute_bases does.
//
//#define TRACE_INDENTED_CONCEPT_INTERFACE
#include <boost/utility/demangled_type_name.hpp>
#include <boost/utility/trace_scope.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/type_erasure/any.hpp>

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

template<class C=_self>
struct simple
{
        static 
     void
    apply
      ( C const& cont
      ) 
      { 
          ::boost::trace_scope ts
            ( ::utility::demangled_type_name<simple<C> >()+"::"+__FUNCTION__+"(C const&)"
            );
          std::cout
            <<":type_name<C>="<<::utility::demangled_type_name<C>()
            <<":cont="<<cont
            <<"\n"
            ;
      }
};

  template
  < class T=_self
  >
struct requirements
{  
        typedef
      mpl::vector
      < destructible<T>
      , simple<T>
      >
    type
    ;
};

namespace boost {
namespace type_erasure {

  template
  < class C
  , class Base
  >
struct concept_interface
  < ::simple<C>
  , Base
  , C
  > 
: Base
{
    typedef ::simple<C> concept_t;
    concept_interface()
    {
        ::boost::trace_scope ts("compute_bases.cpp:concept_interface<simple<C>,Base,C>::CTOR()");
        std::cout<<":concept_t="<<::utility::demangled_type_name<concept_t>()<<"\n";
        std::cout<<":Base="<<::utility::demangled_type_name<Base>()<<"\n";
    }
    void simple()
    {
        ::boost::trace_scope ts("compute_bases.cpp:concept_interface<simple<C>,Base,C>::simple()");
        std::cout<<"***right simple interface***\n";
        ::simple<C> a_simple; 
        call(a_simple, *this); 
    }
};

//#define OVERLOAD_SIMPLE
#ifdef OVERLOAD_SIMPLE
  template
  < class C
  , class Base
  >
struct concept_interface
  < typename requirements<C>::type
  , Base
  , C
  > 
: Base
{
    typedef typename requirements<C>::type concept_t;
    concept_interface()
    {
        ::boost::trace_scope ts("compute_bases.cpp:concept_interface<requirements<C>::type,Base,C>::concept_CTOR()");
        std::cout<<":concept_t="<<::utility::demangled_type_name<concept_t>()<<"\n";
        std::cout<<":Base="<<::utility::demangled_type_name<Base>()<<"\n";
    }
    void simple()
    {
        ::boost::trace_scope ts("compute_bases.cpp:concept_interface<requirments<C>::type,Base,C>::simple()");
        std::cout<<"***wrong simple interface***\n";
    }
};
#endif
}
}

    typedef
  requirements<_self>::type
requirements_t
;  
    typedef 
  detail::compute_bases
  < any<requirements_t, _self>
  , requirements_t
  , _self
  >::type
computed_bases_t
;

int main()
{
    ::boost::iostreams::indent_scoped_ostreambuf<> indent_cout(std::cout);
  #ifdef TRACE_INDENTED_CONCEPT_INTERFACE
    std::cout<<":concept_interfaces<computed_bases_t>=\n";
    trace_indented_concept_interface<computed_bases_t>::_();
  #else
    std::cout<<":computed_bases_t=\n  "
      <<::utility::demangled_type_name<computed_bases_t>()<<"\n";
  #endif
    any<requirements_t> a_any(int(999));
    a_any.simple();
    return 0;
}