libs/function_types/example/interface.hpp
// (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