
// (C) Copyright Tobias Schwinger
//
// Use modification and distribution are subject to the boost Software License,
// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).

//------------------------------------------------------------------------------
//
// This example implements interfaces. 
// 
// Detailed description
// ====================
//
// An interface is a collection of member function prototypes that may be
// implemented by classes. Objects of classes that implement the interface can 
// then be assigned to an interface variable through which the interface's 
// functions can be called.
//
// Interfaces are a feature of the Java programming language [Gosling] and the
// most obvious way to model interfaces in C++ is (multiple) inheritance.
// Using inheritance for this purpose, however, is neither the most efficient 
// nor the most flexible solution, because:
//
//   - all functions must be virtual,
//
//     => a function that calls another function of the interface must do so
//        via virtual dispatch (as opposed to inlining)
//     => a class can not implement an interface's (overloaded) function via
//        a function template
//
//   - inhertitance is intrusive
//
//     => object size increases 
//     => client's are always polymorphic
//     => dependencies cause tighter coupling
//
// Fortunately it is possible to eliminate all the drawbacks mentioned above
// based on an alternative implementation proposed by David Abrahams. 
// We'll add some detail to the original scheme (see [Abrahams]) such as 
// support for overloaded and const qualified functions.
// The implementation in this example uses Boost.FunctionTypes to shift 
// metaprogramming code from the preprocessor into templates, to reduce 
// preprocessing time and increase maintainability.
//
// 
// Limitations
// ===========
//
// There is no lifetime management as implemented by the Boost candidate
// Interfaces library (see [Turkanis]).
//
// This example does not compile with Visual C++. Template argument deduction
// from the result of the address-of operator does not work properly with this
// compiler. It is possible to partially work around the problem, but it isn't
// done here for the sake of readability.
//
//
// Bibliography
// ============
//
// [Gosling]  Gosling, J., Joy, B., Steele, G. The Java Language Specification
//   http://java.sun.com/docs/books/jls/third_edition/html/interfaces.html
//
// [Abrahams] Abrahams, D. Proposal: interfaces, Post to newsgroup comp.std.c++
//   http://groups.google.com/group/comp.std.c++/msg/85af30a61bf677e4
//
// [Turkanis] Turkanis, J., Diggins, C. Boost candidate Interfaces library
//   http://www.kangaroologic.com/interfaces/libs/interfaces/doc/index.html

#include <cstddef>

#include <boost/function_types/function_pointer.hpp>
#include <boost/function_types/member_function_pointer.hpp>

#include <boost/config.hpp>
#include <boost/detail/workaround.hpp>

#include <boost/utility/addressof.hpp>

#include <boost/mpl/at.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/mpl/joint_view.hpp>
#include <boost/mpl/single_view.hpp>
#include <boost/mpl/transform_view.hpp>

#include <boost/preprocessor/seq/seq.hpp>
#include <boost/preprocessor/seq/enum.hpp>
#include <boost/preprocessor/seq/elem.hpp>
#include <boost/preprocessor/seq/size.hpp>
#include <boost/preprocessor/tuple/elem.hpp>
#include <boost/preprocessor/arithmetic/dec.hpp>
#include <boost/preprocessor/arithmetic/inc.hpp>
#include <boost/preprocessor/facilities/empty.hpp>
#include <boost/preprocessor/facilities/identity.hpp>
#include <boost/preprocessor/punctuation/comma_if.hpp>
#include <boost/preprocessor/iteration/local.hpp>
#include <boost/preprocessor/repetition/enum.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
#include <boost/preprocessor/repetition/enum_trailing_params.hpp>

#include "detail/param_type.hpp"

namespace example 
{
  namespace ft = boost::function_types;
  namespace mpl = boost::mpl;
  using namespace mpl::placeholders;

  // join a single type and an MPL-sequence
  // in some ways similar to mpl::push_front (but mpl::push_front requires
  // an MPL Extensible Sequence and this template does not)
  template<typename T, typename Seq>
  struct concat_view
    : mpl::joint_view<mpl::single_view<T>, Seq>
  { };

  // metafunction returning a function pointer type for a vtable entry
  template<typename Inf>
  struct vtable_entry
    : ft::function_pointer
      < concat_view< typename Inf::result, mpl::transform_view< 
            typename Inf::params, param_type<_> > > >
  { };

  // the expression '& member<MetaInfo,Tag>::wrap<& Class::Function> ' in an
  // assignment context binds the member function Function of Class with the
  // properties described by MetaInfo and Tag to the corresponding vtable 
  // entry
  template<typename Inf, typename Tag>
  struct member
  {
    typedef typename ft::member_function_pointer 
      < concat_view<typename Inf::result,typename Inf::params>,Tag
      >::type
    mem_func_ptr;

    typedef typename mpl::at_c<typename Inf::params,0>::type context;

    template<mem_func_ptr MemFuncPtr>
    static typename Inf::result wrap(void* c)
    {
      return (reinterpret_cast<context*>(c)->*MemFuncPtr)();
    }
    template<mem_func_ptr MemFuncPtr, typename T0>
    static typename Inf::result wrap(void* c, T0 a0)
    {
      return (reinterpret_cast<context*>(c)->*MemFuncPtr)(a0);
    }
    template<mem_func_ptr MemFuncPtr, typename T0, typename T1>
    static typename Inf::result wrap(void* c, T0 a0, T1 a1)
    {
      return (reinterpret_cast<context*>(c)->*MemFuncPtr)(a0,a1);
    }
    // continue with the preprocessor (the scheme should be clear, by now)
    #define  BOOST_PP_LOCAL_MACRO(n)                                           \
    template<mem_func_ptr MemFuncPtr, BOOST_PP_ENUM_PARAMS(n,typename T)>      \
    static typename Inf::result wrap(void* c,                                  \
        BOOST_PP_ENUM_BINARY_PARAMS(n,T,a))                                    \
    {                                                                          \
      return (reinterpret_cast<context*>(c)->*MemFuncPtr)(                     \
        BOOST_PP_ENUM_PARAMS(n,a) );                                           \
    }
    #define  BOOST_PP_LOCAL_LIMITS (3,BOOST_FT_MAX_ARITY-1)
    #include BOOST_PP_LOCAL_ITERATE()
  };

  // extract a parameter by index
  template<typename Inf, std::size_t Index>
  struct param
    : param_type< typename mpl::at_c< typename Inf::params,Index>::type >
  { };
}

// the interface definition on the client's side
#define BOOST_EXAMPLE_INTERFACE(name,def)                                      \
    class name                                                                 \
    {                                                                          \
      struct vtable                                                            \
      {                                                                        \
        BOOST_EXAMPLE_INTERFACE__MEMBERS(def,VTABLE)                           \
      };                                                                       \
                                                                               \
      vtable const * ptr_vtable;                                               \
      void * ptr_that;                                                         \
                                                                               \
      template<class T> struct vtable_holder                                   \
      {                                                                        \
        static vtable const val_vtable;                                        \
      };                                                                       \
                                                                               \
    public:                                                                    \
                                                                               \
      template<class T>                                                        \
      inline name (T & that)                                                   \
        : ptr_vtable(& vtable_holder<T>::val_vtable)                           \
        , ptr_that(boost::addressof(that))                                     \
      { }                                                                      \
                                                                               \
      BOOST_EXAMPLE_INTERFACE__MEMBERS(def,FUNCTION)                           \
    };                                                                         \
                                                                               \
    template<typename T>                                                       \
    name ::vtable const name ::vtable_holder<T>::val_vtable                    \
        = { BOOST_EXAMPLE_INTERFACE__MEMBERS(def,INIT_VTABLE) }


#ifdef BOOST_PP_NIL // never defined -- a comment with syntax highlighting

BOOST_EXAMPLE_INTERFACE( interface_x,
  (( a_func, (void)(int), const_qualified ))
  (( another_func, (int), non_const   )) 
);

// expands to:
class interface_x 
{ 
  struct vtable 
  {
    // meta information for first function 
    template<typename T = void*> struct inf0 
    {
      typedef void result; 
      typedef ::boost::mpl::vector< T, int > params; 
    };
    // function pointer with void* context pointer and parameters optimized
    // for forwarding 
    ::example::vtable_entry<inf0<> >::type func0; 

    // second function
    template<typename T = void*> struct inf1 
    {
      typedef int result; 
      typedef ::boost::mpl::vector< T > params; 
    }; 
    ::example::vtable_entry<inf1<> >::type func1; 
  }; 

  // data members
  vtable const * ptr_vtable; 
  void * ptr_that; 

  // this template is instantiated for every class T this interface is created
  // from, causing the compiler to emit an initialized vtable for this type 
  // (see aggregate assignment, below)
  template<class T> struct vtable_holder 
  {
    static vtable const val_vtable; 
  }; 

public: 

  // converting ctor, creates an interface from an arbitrary class
  template<class T> 
  inline interface_x (T & that) 
    : ptr_vtable(& vtable_holder<T>::val_vtable)
    , ptr_that(boost::addressof(that)) 
  { } 

  // the member functions from the interface definition, parameters are 
  // optimized for forwarding

  inline vtable::inf0<> ::result a_func (
      ::example::param<vtable::inf0<>,1>::type p0) const 
  { 
    return ptr_vtable-> func0(ptr_that , p0); 
  } 

  inline vtable::inf1<> ::result another_func () 
  {
    return ptr_vtable-> func1(ptr_that ); 
  } 
}; 

template<typename T> 
interface_x ::vtable const interface_x ::vtable_holder<T>::val_vtable = 
{
  // instantiate function templates that wrap member function pointers (which
  // are known at compile time) by taking their addresses in assignment to
  // function pointer context
  & ::example::member< vtable::inf0<T>, ::example::ft:: const_qualified >
        ::template wrap < &T:: a_func > 
, & ::example::member< vtable::inf1<T>, ::example::ft:: non_const >
        ::template wrap < &T:: another_func > 
};
#endif

// preprocessing code details

// iterate all of the interface's members and invoke a macro (prefixed with
// BOOST_EXAMPLE_INTERFACE_)
#define BOOST_EXAMPLE_INTERFACE__MEMBERS(seq,macro)                            \
    BOOST_PP_REPEAT(BOOST_PP_SEQ_SIZE(seq),                                    \
        BOOST_EXAMPLE_INTERFACE__ ## macro,seq)

// extract signature sequence from entry 
#define BOOST_EXAMPLE_INTERFACE__VTABLE(z,i,seq)                               \
    BOOST_EXAMPLE_INTERFACE__VTABLE_I(z,i,                                     \
        BOOST_PP_TUPLE_ELEM(3,1,BOOST_PP_SEQ_ELEM(i,seq)))

// split the signature sequence result/params and insert T at the beginning of
// the params part
#define BOOST_EXAMPLE_INTERFACE__VTABLE_I(z,i,seq)                             \
    BOOST_EXAMPLE_INTERFACE__VTABLE_II(z,i,                                    \
        BOOST_PP_SEQ_HEAD(seq),(T)BOOST_PP_SEQ_TAIL(seq))

// emit the meta information structure and function pointer declaration
#define BOOST_EXAMPLE_INTERFACE__VTABLE_II(z,i,result_type,param_types)        \
    template<typename T = void*>                                               \
    struct BOOST_PP_CAT(inf,i)                                                 \
    {                                                                          \
      typedef result_type result;                                              \
      typedef ::boost::mpl::vector< BOOST_PP_SEQ_ENUM(param_types) > params;   \
    };                                                                         \
    ::example::vtable_entry<BOOST_PP_CAT(inf,i)<> >::type BOOST_PP_CAT(func,i);

// extract tuple entry from sequence and precalculate the name of the function
// pointer variable
#define BOOST_EXAMPLE_INTERFACE__INIT_VTABLE(z,i,seq)                          \
    BOOST_EXAMPLE_INTERFACE__INIT_VTABLE_I(i,seq,BOOST_PP_CAT(func,i),         \
        BOOST_PP_SEQ_ELEM(i,seq))

// emit a function pointer expression that encapsulates the corresponding
// member function of T
#define BOOST_EXAMPLE_INTERFACE__INIT_VTABLE_I(i,seq,func,desc)                \
    BOOST_PP_COMMA_IF(i) & ::example::member< BOOST_PP_CAT(vtable::inf,i)<T>,  \
        ::example::ft:: BOOST_PP_TUPLE_ELEM(3,2,desc) >::template wrap         \
                                          < &T:: BOOST_PP_TUPLE_ELEM(3,0,desc) >
        
// extract tuple entry from sequence
#define BOOST_EXAMPLE_INTERFACE__FUNCTION(z,i,seq)                             \
    BOOST_EXAMPLE_INTERFACE__FUNCTION_I(z,i,BOOST_PP_SEQ_ELEM(i,seq))

// precalculate function name, arity, name of meta info structure and cv-
// qualifiers
#define BOOST_EXAMPLE_INTERFACE__FUNCTION_I(z,i,desc)                          \
    BOOST_EXAMPLE_INTERFACE__FUNCTION_II(z,i,                                  \
        BOOST_PP_TUPLE_ELEM(3,0,desc),                                         \
        BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(BOOST_PP_TUPLE_ELEM(3,1,desc))),        \
        BOOST_PP_CAT(vtable::inf,i)<>,                                         \
        BOOST_PP_CAT(BOOST_EXAMPLE_INTERFACE___,BOOST_PP_TUPLE_ELEM(3,2,desc)) \
    )

// emit the definition for a member function of the interface
#define BOOST_EXAMPLE_INTERFACE__FUNCTION_II(z,i,name,arity,types,cv)          \
    inline types ::result name                                                 \
      (BOOST_PP_ENUM_ ## z (arity,BOOST_EXAMPLE_INTERFACE__PARAM,types)) cv()  \
    {                                                                          \
      return ptr_vtable-> BOOST_PP_CAT(func,i)(ptr_that                        \
          BOOST_PP_ENUM_TRAILING_PARAMS_Z(z,arity,p));                         \
    }

// emit a parameter of the function definition
#define BOOST_EXAMPLE_INTERFACE__PARAM(z,j,types)                              \
    ::example::param<types,BOOST_PP_INC(j)>::type BOOST_PP_CAT(p,j)

// helper macros to map 'const_qualified' to 'const' an 'non_const' to ''
#define BOOST_EXAMPLE_INTERFACE___const_qualified BOOST_PP_IDENTITY(const)
#define BOOST_EXAMPLE_INTERFACE___non_const BOOST_PP_EMPTY