toast/typed_factory.hpp

Go to the documentation of this file.

#ifndef toast_typed_factory_hpp_INCLUDED
#define toast_typed_factory_hpp_INCLUDED

#include <boost/shared_ptr.hpp>
#include <boost/bind.hpp>
#include <boost/function.hpp>

#include <boost/utility/typed_in_place_factory.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/punctuation/paren.hpp>
#include <boost/preprocessor/iteration/iterate.hpp>
#include <boost/preprocessor/repetition/repeat.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>

#ifndef TOAST_MAX_TYPED_FACTORY_ARITY

#define TOAST_MAX_TYPED_FACTORY_ARITY 10

#endif

#define TOAST_TYPED_FACTORY_INIT(z,n,_) BOOST_PP_CAT(m_a,n) BOOST_PP_LPAREN() BOOST_PP_CAT(a,n) BOOST_PP_RPAREN()
#define TOAST_TYPED_FACTORY_DECL(z,n,_) BOOST_PP_CAT(A,n) BOOST_PP_CAT(m_a,n);

namespace toast {
        namespace detail {
#define BOOST_PP_ITERATION_LIMITS (0, TOAST_MAX_TYPED_FACTORY_ARITY)
#define BOOST_PP_FILENAME_1 <toast/detail/typed_factoryN.hpp>
#include BOOST_PP_ITERATE()
        }


template <typename T>
class typed_factory : public boost::typed_in_place_factory_base
{
        boost::shared_ptr< boost::function<void (void *)> > apply_;
public:
        typedef T value_type;

        T * create() const
        {
                void *p = operator new(sizeof(T));
                (*apply_)(p);
                return static_cast<T *>(p);
        }

        void apply( void *addr ) const { (*apply_)(addr); }

        // constructor iteration
#define BOOST_PP_ITERATION_LIMITS (0, TOAST_MAX_TYPED_FACTORY_ARITY)
#define BOOST_PP_FILENAME_1 <toast/typed_factory.hpp>
#include BOOST_PP_ITERATE()

};

} // namespace toast


#undef TOAST_TYPED_FACTORY_INIT
#undef TOAST_TYPED_FACTORY_DECL

#elif BOOST_PP_IS_ITERATING

#define N BOOST_PP_ITERATION()

#if N > 0
        template <BOOST_PP_ENUM_PARAMS(N, typename A) >
#endif
        typed_factory( BOOST_PP_ENUM_BINARY_PARAMS(N, A, a) )
        : apply_( new boost::function<void (void *)>(
                        boost::bind(
                                & BOOST_PP_CAT(detail::typed_factory, N)<T BOOST_PP_ENUM_TRAILING_PARAMS(N, A)>::apply,
                                BOOST_PP_CAT(detail::typed_factory,N) <T BOOST_PP_ENUM_TRAILING_PARAMS(N, A)>( BOOST_PP_ENUM_PARAMS(N,a) ),
                                _1
                                ) 
                        ) 
                ) {}

// this conditional can be removed when boost::typed_in_place_factory
// is updated for nullary factories (1.35 or later)
#if N > 0
        template <BOOST_PP_ENUM_PARAMS(N, typename A) >
        typed_factory( BOOST_PP_CAT(boost::typed_in_place_factory, N) <T BOOST_PP_ENUM_TRAILING_PARAMS(N,A)> const &f )
        : apply_( new boost::function<void (void *)>(
                        boost::bind(
                                & BOOST_PP_CAT(boost::typed_in_place_factory,N) <T BOOST_PP_ENUM_TRAILING_PARAMS(N,A)>::apply,
                                f, _1 ) ) ) {}
#endif

#undef N

#endif

---