See if the pimpl proposal currently sitting in the review queue http://www.boost.org/community/review_schedule.html meets your needs. If not, let's extend it. Best, V. ----- Original Message ----- From: "Krzysztof Czainski" <1czajnik@gmail.com> Newsgroups: gmane.comp.lib.boost.devel To: <boost@lists.boost.org> Sent: Monday, December 06, 2010 5:25 AM Subject: Re: pimpl library proposal
2010/12/4 Michael Bailey <jinxidoru@gmail.com>
---- boost/pimpl.hpp ----
#include <boost/typeof/typeof.hpp> #include <boost/type_traits/function_traits.hpp> #include <boost/preprocessor/repetition/enum_trailing_params.hpp> #include <boost/preprocessor/repetition/enum_shifted_params.hpp> #include <boost/preprocessor/repetition/enum_params.hpp> #include <boost/preprocessor/repetition/enum_shifted.hpp> #include <boost/preprocessor/arithmetic/inc.hpp>
namespace boost {
template <typename T> class pimpl { public:
typedef T* ptr_type;
pimpl( ptr_type p = new T() ) : m_impl( p ) {}
~pimpl() { delete m_impl; }
protected:
T& impl() { return *m_impl; } const T& impl() const { return *m_impl; }
private: ptr_type m_impl; };
template <typename T> struct method_traits;
#ifndef BOOST_METHOD_TRAITS_LIMIT # define BOOST_METHOD_TRAITS_LIMIT 10 #endif
#define BOOST_METHOD_TRAITS(z,n,data) \ template <typename C, typename R \ BOOST_PP_ENUM_TRAILING_PARAMS_Z(z,n,class T) > \ struct method_traits< R(C::*)( BOOST_PP_ENUM_PARAMS_Z(z,n,T) ) data > \ : public function_traits< R( BOOST_PP_ENUM_PARAMS_Z(z,n,T) ) > { \ typedef data C class_type; \ };
BOOST_PP_REPEAT(BOOST_METHOD_TRAITS_LIMIT,BOOST_METHOD_TRAITS,) BOOST_PP_REPEAT(BOOST_METHOD_TRAITS_LIMIT,BOOST_METHOD_TRAITS,const) BOOST_PP_REPEAT(BOOST_METHOD_TRAITS_LIMIT,BOOST_METHOD_TRAITS,volatile) BOOST_PP_REPEAT(BOOST_METHOD_TRAITS_LIMIT,BOOST_METHOD_TRAITS,const volatile)
}
#define BOOST_PIMPL_CTOR( cls ) \ cls::cls() {}
#define BOOST_PIMPL_DEFINE_METHOD_M( z, n, data ) \ BOOST_JOIN(BOOST_JOIN(data::arg,n),_type) BOOST_JOIN(a,n)
#define BOOST_PIMPL_METHOD( args, cls, meth, ... ) \ ::boost::method_traits< BOOST_TYPEOF(&cls::meth) >::result_type \ cls::meth( \ BOOST_PP_ENUM_SHIFTED( BOOST_PP_INC(args), \ BOOST_PIMPL_DEFINE_METHOD_M, \ ::boost::method_traits<typeof(&cls::meth)> \ ) \ ) __VA_ARGS__ { \ return impl().meth( \ BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_INC(args),a) \ ); \ }
Hello,
I would like to see some pimpl idiom library in boost. I have tackled the problem of simplifying pimpl implementation a while ego. I begun by designing a base class (similar to Your approach, Michael). In the end, however, I came up with a value_ptr class, which is a bit more general, then just for pimpl idiom. I thought to propose it to boost, but I haven't (yet). By now I have used It many times, and I am happy with it.
/** * Smart pointer adaptor, that preserves constness of @c element_type, and upon construction * allocates the object using @c new, and forwards constructor arguments. * * It is perfect for the PIMPL idiom. * * @tparam SmartPtr Underlying smart pointer, owning the object. */ template < class SmartPtr, class Element = typename pointee<SmartPtr>::type, class ValuePtrAllocator = value_ptr_heap_allocator<SmartPtr> > class value_ptr;
MyClass.h:
class MyClass { public: MyClass(); // needed, but trivial ~MyClass(); // sometimes needed, but trivial // methods... private: struct Impl; value_ptr< scoped_ptr<Impl> > impl_; };
MyClass.cpp:
struct MyClass::Impl {/*...*/};
MyClass::MyClass() {} // value_ptr automatically allocates an Impl instance
MyClass::~MyClass() {} // value_ptr automatically deallocates Impl
// methods...
So, we gain: - easy allocation (without explicit call to new, which avoids possible problems with exception safety if we need to call some throwing operations in the ctor), - value_ptr has a set of templated ctors, which forward args to Impl's ctor, - allocation is customizable by value_ptr's third template parameter, - automatic deallocation, which is done by the underlying SmartPtr (scoped_ptr, shared_ptr, or some other ptr like clone_ptr can be used), - const-correct versions of operator* and -> with respect to the fact, that MyClass logically owns it's Impl.
Right now I can't spend more time on trying to understand how the method macros proposed by Michael work (I'm not familiar with advanced macros), but I like the Idea, and I am looking forward to adding those to value_ptr in the future ;-)
The source code for value_ptr together with a few other related tools can be found here: https://libcz.svn.sourceforge.net/svnroot/libcz/trunk/boost
Regards, Kris _______________________________________________ Unsubscribe & other changes: http://lists.boost.org/mailman/listinfo.cgi/boost