Menu
▾
▴
[Boost-sandbox-cvs] boost-sandbox/boost/thread_safe_signals/detail signals_common_macros.hpp, NONE, 1.1 slot_template.hpp, NONE, 1.1 signal_base.hpp, 1.1, 1.2 signal_template.hpp, 1.34, 1.35 slot_call_iterator.hpp, 1.19, 1.20
Update of /cvsroot/boost-sandbox/boost-sandbox/boost/thread_safe_signals/detail In directory sc8-pr-cvs3.sourceforge.net:/tmp/cvs-serv22644/boost/thread_safe_signals/detail Modified Files: signal_base.hpp signal_template.hpp slot_call_iterator.hpp Added Files: signals_common_macros.hpp slot_template.hpp Log Message: Added Signature template parameter to slot class, so that an operator() could be added. Bind can be used to bind together slots with different signatures now. Added some syntactic sugar to slot constructors, so a bind() call is inserted automatically for the constructors that take more than one argument. All tracking for automatic connection management is now done through slot::track(). Added track_test.cpp test program, which tests some of the new functionality. Index: slot_call_iterator.hpp =================================================================== RCS file: /cvsroot/boost-sandbox/boost-sandbox/boost/thread_safe_signals/detail/slot_call_iterator.hpp,v retrieving revision 1.19 retrieving revision 1.20 diff -u -d -r1.19 -r1.20 --- slot_call_iterator.hpp 20 Feb 2007 13:32:23 -0000 1.19 +++ slot_call_iterator.hpp 27 Feb 2007 21:19:25 -0000 1.20 @@ -18,6 +18,7 @@ #include <boost/optional.hpp> #include <boost/scoped_ptr.hpp> #include <boost/thread_safe_signals/connection.hpp> +#include <boost/thread_safe_signals/slot_base.hpp> #include <boost/type_traits.hpp> #ifdef BOOST_HAS_ABI_HEADERS @@ -43,11 +44,11 @@ boost::single_pass_traversal_tag, typename Function::result_type const&> inherited; - + typedef typename Function::result_type result_type; - + friend class boost::iterator_core_access; - + public: slot_call_iterator_t(Iterator iter_in, Iterator end_in, Function f, boost::optional<result_type> &c): @@ -56,7 +57,7 @@ { lockNextCallable(); } - + typename inherited::reference dereference() const { @@ -65,22 +66,22 @@ } return cache->get(); } - + void increment() { ++iter; lockNextCallable(); cache->reset(); } - + bool equal(const slot_call_iterator_t& other) const { return iter == other.iter; } - + private: typedef typename ConnectionBody::mutex_type::scoped_lock lock_type; - + void lockNextCallable() const { if(iter == callable_iter) @@ -102,13 +103,13 @@ callable_iter = end; } } - + mutable Iterator iter; Iterator end; Function f; optional<result_type>* cache; mutable Iterator callable_iter; - mutable typename ConnectionBody::shared_ptrs_type tracked_ptrs; + mutable typename slot_base::locked_container_type tracked_ptrs; }; } // end namespace detail } // end namespace BOOST_SIGNALS_NAMESPACE --- NEW FILE: signals_common_macros.hpp --- /* Template for Signa1, Signal2, ... classes that support signals with 1, 2, ... parameters Author: Frank Hess <fra...@ni...> Begin: 2007-01-23 */ /* This software was developed at the National Institute of Standards and * Technology by employees of the Federal Government in the course of * their official duties. Pursuant to title 17 Section 105 of the United * States Code this software is not subject to copyright protection and is * in the public domain. This is an experimental system. NIST assumes no * responsibility whatsoever for its use by other parties, and makes no * guarantees, expressed or implied, about its quality, reliability, or * any other characteristic. We would appreciate acknowledgement if the * software is used. */ // Use, modification and // distribution is subject to the Boost Software License, Version // 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_SIGNALS_COMMON_MACROS_HEADER #define BOOST_SIGNALS_COMMON_MACROS_HEADER // argn #define BOOST_SIGNAL_SIGNATURE_ARG_NAME(z, n, data) BOOST_PP_CAT(arg, BOOST_PP_INC(n)) // Tn argn #define BOOST_SIGNAL_SIGNATURE_FULL_ARG(z, n, data) \ BOOST_PP_CAT(T, BOOST_PP_INC(n)) BOOST_SIGNAL_SIGNATURE_ARG_NAME(~, n, ~) // T1 arg1, T2 arg2, ..., Tn argn #define BOOST_SIGNAL_SIGNATURE_FULL_ARGS(arity) \ BOOST_PP_ENUM(arity, BOOST_SIGNAL_SIGNATURE_FULL_ARG, ~) // arg1, arg2, ..., argn #define BOOST_SIGNAL_SIGNATURE_ARG_NAMES(arity) BOOST_PP_ENUM(arity, BOOST_SIGNAL_SIGNATURE_ARG_NAME, ~) // typename R, typename T1, typename T2, ..., typename TN #define BOOST_SIGNAL_SIGNATURE_TEMPLATE_DECL(arity) \ typename R BOOST_PP_COMMA_IF(arity) BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_INC(arity), typename T) // R, T1, T2, ..., TN #define BOOST_SIGNAL_SIGNATURE_TEMPLATE_INSTANTIATION(arity) \ R BOOST_PP_COMMA_IF(arity) BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_INC(arity), T) // functionN<R, T1, T2, ..., TN> #define BOOST_FUNCTION_N_DECL(arity) BOOST_PP_CAT(function, arity)<\ BOOST_SIGNAL_SIGNATURE_TEMPLATE_INSTANTIATION(arity) > // slotN #define BOOST_SLOT_CLASS_NAME(arity) BOOST_PP_CAT(slot, arity) // typename function_traits<Signature>::argn_type #define BOOST_SIGNAL_SIGNATURE_TO_ARGN_TYPE(z, n, Signature) \ BOOST_PP_CAT(BOOST_PP_CAT(typename function_traits<Signature>::arg, BOOST_PP_INC(n)), _type) // typename function_traits<Signature>::result_type, // typename function_traits<Signature>::arg1_type, // typename function_traits<Signature>::arg2_type, // ..., // typename function_traits<Signature>::argn_type #define BOOST_SIGNAL_PORTABLE_SIGNATURE(arity, Signature) \ typename function_traits<Signature>::result_type \ BOOST_PP_COMMA_IF(arity) BOOST_PP_ENUM(arity, BOOST_SIGNAL_SIGNATURE_TO_ARGN_TYPE, Signature) #endif // BOOST_SIGNALS_COMMON_MACROS_HEADER --- NEW FILE: slot_template.hpp --- // Boost.Signals library // Copyright Frank Mori Hess 2007. // Copyright Timmo Stange 2007. // Copyright Douglas Gregor 2001-2004. Use, modification and // distribution is subject to the Boost Software License, Version // 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // For more information, see http://www.boost.org // This file is included iteratively, and should not be protected from multiple inclusion #define BOOST_SIGNALS_NUM_ARGS BOOST_PP_ITERATION() #define BOOST_SLOT_IMPL_CLASS_NAME BOOST_PP_CAT(BOOST_SLOT_CLASS_NAME, _impl) #define BOOST_SLOT_IMPL_BASE_CLASS_NAME BOOST_PP_CAT(BOOST_SLOT_CLASS_NAME, _impl_base) namespace boost { // slot class template. template<BOOST_SIGNAL_SIGNATURE_TEMPLATE_DECL(BOOST_SIGNALS_NUM_ARGS), typename SlotFunction = BOOST_FUNCTION_N_DECL(BOOST_SIGNALS_NUM_ARGS)> class BOOST_SLOT_CLASS_NAME(BOOST_SIGNALS_NUM_ARGS): public signalslib::detail::slot_base { public: typedef R result_type; template<typename F> BOOST_SLOT_CLASS_NAME(BOOST_SIGNALS_NUM_ARGS)(const F& f): _slot_function(signalslib::detail::get_invocable_slot(f, signalslib::detail::tag_type(f))) { } // bind syntactic sugar // const ArgTypeN argN #define BOOST_SLOT_BINDING_ARG_DECL(z, n, data) \ BOOST_PP_CAT(ArgType, n) BOOST_PP_CAT(arg, n) // template<typename Func, typename ArgType0, typename ArgType1, ..., typename ArgTypen-1> slotN(... #define BOOST_SLOT_BINDING_CONSTRUCTOR(z, n, data) \ template<typename Func BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, typename ArgType)> \ BOOST_SLOT_CLASS_NAME(BOOST_SIGNALS_NUM_ARGS)(Func func BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM(n, BOOST_SLOT_BINDING_ARG_DECL, ~)): \ _slot_function(bind(func BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, arg))) \ {} #define BOOST_SLOT_MAX_BINDING_ARGS 10 BOOST_PP_REPEAT_FROM_TO(1, BOOST_SLOT_MAX_BINDING_ARGS, BOOST_SLOT_BINDING_CONSTRUCTOR, ~) #undef BOOST_SLOT_MAX_BINDING_ARGS #undef BOOST_SLOT_BINDING_ARG_DECL #undef BOOST_SLOT_BINDING_CONSTRUCTOR R operator()(BOOST_SIGNAL_SIGNATURE_FULL_ARGS(BOOST_SIGNALS_NUM_ARGS)) { return _slot_function(BOOST_SIGNAL_SIGNATURE_ARG_NAMES(BOOST_SIGNALS_NUM_ARGS)); } BOOST_SLOT_CLASS_NAME(BOOST_SIGNALS_NUM_ARGS)& track(const weak_ptr<void> &tracked) { _trackedObjects.push_back(tracked); return *this; } BOOST_SLOT_CLASS_NAME(BOOST_SIGNALS_NUM_ARGS)& track(const slot_base &slot) { tracked_container_type::const_iterator it; for(it = slot.tracked_objects().begin(); it != slot.tracked_objects().end(); ++it) { track(*it); } return *this; } BOOST_SLOT_CLASS_NAME(BOOST_SIGNALS_NUM_ARGS)& track(const signalslib::detail::signal_base &signal) { track(signal.lock_pimpl()); return *this; } private: SlotFunction _slot_function; }; namespace signalslib { namespace detail { template<unsigned arity, typename Signature, typename SlotFunction> class slotN; // partial template specialization template<typename Signature, typename SlotFunction> class slotN<BOOST_SIGNALS_NUM_ARGS, Signature, SlotFunction> { public: typedef BOOST_SLOT_CLASS_NAME(BOOST_SIGNALS_NUM_ARGS)< BOOST_SIGNAL_PORTABLE_SIGNATURE(BOOST_SIGNALS_NUM_ARGS, Signature), SlotFunction> type; }; } } } // end namespace boost #undef BOOST_SIGNALS_NUM_ARGS #undef BOOST_SLOT_IMPL_CLASS_NAME #undef BOOST_SLOT_IMPL_BASE_CLASS_NAME Index: signal_template.hpp =================================================================== RCS file: /cvsroot/boost-sandbox/boost-sandbox/boost/thread_safe_signals/detail/signal_template.hpp,v retrieving revision 1.34 retrieving revision 1.35 diff -u -d -r1.34 -r1.35 --- signal_template.hpp 18 Feb 2007 00:13:37 -0000 1.34 +++ signal_template.hpp 27 Feb 2007 21:19:25 -0000 1.35 @@ -22,43 +22,31 @@ // This file is included iteratively, and should not be protected from multiple inclusion -#define EPG_SIGNALS_NUM_ARGS BOOST_PP_ITERATION() +#define BOOST_SIGNALS_NUM_ARGS BOOST_PP_ITERATION() -#define EPG_SIGNAL_CLASS_NAME BOOST_PP_CAT(signal, EPG_SIGNALS_NUM_ARGS) -#define EPG_WEAK_SIGNAL_CLASS_NAME BOOST_PP_CAT(weak_, EPG_SIGNAL_CLASS_NAME) -#define EPG_SIGNAL_IMPL_CLASS_NAME BOOST_PP_CAT(EPG_SIGNAL_CLASS_NAME, _impl) +#define BOOST_SIGNAL_CLASS_NAME BOOST_PP_CAT(signal, BOOST_SIGNALS_NUM_ARGS) +#define BOOST_WEAK_SIGNAL_CLASS_NAME BOOST_PP_CAT(weak_, BOOST_SIGNAL_CLASS_NAME) +#define BOOST_SIGNAL_IMPL_CLASS_NAME BOOST_PP_CAT(BOOST_SIGNAL_CLASS_NAME, _impl) -// argn -#define EPG_SIGNAL_SIGNATURE_ARG_NAME(z, n, data) BOOST_PP_CAT(arg, BOOST_PP_INC(n)) -// Tn argn -#define EPG_SIGNAL_SIGNATURE_FULL_ARG(z, n, data) \ - BOOST_PP_CAT(T, BOOST_PP_INC(n)) EPG_SIGNAL_SIGNATURE_ARG_NAME(~, n, ~) -// T1 arg1, T2 arg2, ... -// Tn argn -#define EPG_SIGNAL_SIGNATURE_FULL_ARGS(arity, data) \ - BOOST_PP_ENUM(arity, EPG_SIGNAL_SIGNATURE_FULL_ARG, data) -// arg1, arg2, ..., argn -#define EPG_SIGNAL_SIGNATURE_ARG_NAMES(arity) BOOST_PP_ENUM(arity, EPG_SIGNAL_SIGNATURE_ARG_NAME, ~) // typename R, typename T1, typename T2, ..., typename TN, typename Combiner = boost::last_value<R>, ... -#define EPG_SIGNAL_TEMPLATE_DEFAULTED_DECL \ - typename R, BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_INC(EPG_SIGNALS_NUM_ARGS), typename T) BOOST_PP_COMMA_IF(EPG_SIGNALS_NUM_ARGS) \ +#define BOOST_SIGNAL_TEMPLATE_DEFAULTED_DECL \ + BOOST_SIGNAL_SIGNATURE_TEMPLATE_DECL(BOOST_SIGNALS_NUM_ARGS), \ typename Combiner = boost::last_value<R>, \ typename Group = int, \ typename GroupCompare = std::less<Group>, \ - typename SlotFunction = BOOST_PP_CAT(boost::function, EPG_SIGNALS_NUM_ARGS)<R BOOST_PP_COMMA_IF(EPG_SIGNALS_NUM_ARGS) \ - BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_INC(EPG_SIGNALS_NUM_ARGS), T) >, \ + typename SlotFunction = BOOST_FUNCTION_N_DECL(BOOST_SIGNALS_NUM_ARGS), \ typename ThreadingModel = signalslib::single_threaded // typename R, typename T1, typename T2, ..., typename TN, typename Combiner, ... -#define EPG_SIGNAL_TEMPLATE_DECL \ - typename R, BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_INC(EPG_SIGNALS_NUM_ARGS), typename T) BOOST_PP_COMMA_IF(EPG_SIGNALS_NUM_ARGS) \ +#define BOOST_SIGNAL_TEMPLATE_DECL \ + BOOST_SIGNAL_SIGNATURE_TEMPLATE_DECL(BOOST_SIGNALS_NUM_ARGS), \ typename Combiner, \ typename Group, \ typename GroupCompare, \ typename SlotFunction, \ typename ThreadingModel // R, T1, T2, ..., TN, Combiner, Group, GroupCompare, SlotFunction, ThreadingModel -#define EPG_SIGNAL_TEMPLATE_INSTANTIATION \ - R, BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_INC(EPG_SIGNALS_NUM_ARGS), T) BOOST_PP_COMMA_IF(EPG_SIGNALS_NUM_ARGS) \ +#define BOOST_SIGNAL_TEMPLATE_INSTANTIATION \ + BOOST_SIGNAL_SIGNATURE_TEMPLATE_INSTANTIATION(BOOST_SIGNALS_NUM_ARGS), \ Combiner, Group, GroupCompare, SlotFunction, ThreadingModel namespace boost @@ -67,17 +55,20 @@ { namespace detail { - template<EPG_SIGNAL_TEMPLATE_DECL> - class EPG_SIGNAL_IMPL_CLASS_NAME + template<BOOST_SIGNAL_TEMPLATE_DECL> + class BOOST_SIGNAL_IMPL_CLASS_NAME { + public: + typedef BOOST_SLOT_CLASS_NAME(BOOST_SIGNALS_NUM_ARGS)<BOOST_SIGNAL_SIGNATURE_TEMPLATE_INSTANTIATION(BOOST_SIGNALS_NUM_ARGS), + SlotFunction> slot_type; private: class slot_invoker; typedef typename signalslib::detail::group_key<Group>::type group_key_type; - typedef shared_ptr<ConnectionBody<group_key_type, SlotFunction, ThreadingModel> > connection_body_type; + typedef shared_ptr<ConnectionBody<group_key_type, slot_type, ThreadingModel> > connection_body_type; typedef grouped_list<Group, GroupCompare, connection_body_type> connection_list_type; public: typedef SlotFunction slot_function_type; - typedef slot<slot_function_type> slot_type; + // typedef slotN<Signature, SlotFunction> slot_type; typedef typename slot_function_type::result_type slot_result_type; typedef Combiner combiner_type; typedef typename combiner_type::result_type result_type; @@ -86,7 +77,7 @@ typedef typename signalslib::detail::slot_call_iterator_t<slot_invoker, typename connection_list_type::iterator, ConnectionBody<group_key_type, SlotFunction, ThreadingModel> > slot_call_iterator; - EPG_SIGNAL_IMPL_CLASS_NAME(const combiner_type &combiner, + BOOST_SIGNAL_IMPL_CLASS_NAME(const combiner_type &combiner, const group_compare_type &group_compare): _shared_state(new invocation_state(connection_list_type(group_compare), combiner)), _garbage_collector_it(_shared_state->connection_bodies.end()) @@ -161,7 +152,7 @@ do_disconnect(slot, is_group()); } // emit signal - result_type operator ()(EPG_SIGNAL_SIGNATURE_FULL_ARGS(EPG_SIGNALS_NUM_ARGS, ~)) + result_type operator ()(BOOST_SIGNAL_SIGNATURE_FULL_ARGS(BOOST_SIGNALS_NUM_ARGS)) { shared_ptr<invocation_state> local_state; typename connection_list_type::iterator it; @@ -175,14 +166,14 @@ during invocation. */ local_state = _shared_state; } - slot_invoker invoker BOOST_PP_IF(EPG_SIGNALS_NUM_ARGS, \ - (EPG_SIGNAL_SIGNATURE_ARG_NAMES(EPG_SIGNALS_NUM_ARGS)), ); + slot_invoker invoker BOOST_PP_IF(BOOST_SIGNALS_NUM_ARGS, \ + (BOOST_SIGNAL_SIGNATURE_ARG_NAMES(BOOST_SIGNALS_NUM_ARGS)), ); optional<typename signalslib::detail::slot_result_type_wrapper<slot_result_type>::type > cache; return local_state->combiner( slot_call_iterator(local_state->connection_bodies.begin(), local_state->connection_bodies.end(), invoker, cache), slot_call_iterator(local_state->connection_bodies.end(), local_state->connection_bodies.end(), invoker, cache)); } - result_type operator ()(EPG_SIGNAL_SIGNATURE_FULL_ARGS(EPG_SIGNALS_NUM_ARGS, ~)) const + result_type operator ()(BOOST_SIGNAL_SIGNATURE_FULL_ARGS(BOOST_SIGNALS_NUM_ARGS)) const { shared_ptr<invocation_state> local_state; typename connection_list_type::iterator it; @@ -196,8 +187,8 @@ during invocation. */ local_state = _shared_state; } - slot_invoker invoker BOOST_PP_IF(EPG_SIGNALS_NUM_ARGS, \ - (EPG_SIGNAL_SIGNATURE_ARG_NAMES(EPG_SIGNALS_NUM_ARGS)), ); + slot_invoker invoker BOOST_PP_IF(BOOST_SIGNALS_NUM_ARGS, \ + (BOOST_SIGNAL_SIGNATURE_ARG_NAMES(BOOST_SIGNALS_NUM_ARGS)), ); optional<typename signalslib::detail::slot_result_type_wrapper<slot_result_type>::type > cache; return const_cast<const combiner_type&>(local_state->combiner)( slot_call_iterator(local_state->connection_bodies.begin(), local_state->connection_bodies.end(), invoker, cache), @@ -243,20 +234,20 @@ } private: typedef typename ThreadingModel::mutex_type mutex_type; - + // slot_invoker is passed to slot_call_iterator_t to run slots class slot_invoker { public: typedef typename signalslib::detail::slot_result_type_wrapper<slot_result_type>::type result_type; - slot_invoker(EPG_SIGNAL_SIGNATURE_FULL_ARGS(EPG_SIGNALS_NUM_ARGS, ~)) BOOST_PP_IF(EPG_SIGNALS_NUM_ARGS, :, ) + slot_invoker(BOOST_SIGNAL_SIGNATURE_FULL_ARGS(BOOST_SIGNALS_NUM_ARGS)) BOOST_PP_IF(BOOST_SIGNALS_NUM_ARGS, :, ) // argn ( argn ) , -#define EPG_SIGNAL_MISC_STATEMENT(z, n, data) \ +#define BOOST_SIGNAL_MISC_STATEMENT(z, n, data) \ BOOST_PP_CAT(arg, n) ( BOOST_PP_CAT(arg, n) ) // arg1(arg1), arg2(arg2), ..., argn(argn) - BOOST_PP_ENUM_SHIFTED(BOOST_PP_INC(EPG_SIGNALS_NUM_ARGS), EPG_SIGNAL_MISC_STATEMENT, ~) -#undef EPG_SIGNAL_MISC_STATEMENT + BOOST_PP_ENUM_SHIFTED(BOOST_PP_INC(BOOST_SIGNALS_NUM_ARGS), BOOST_SIGNAL_MISC_STATEMENT, ~) +#undef BOOST_SIGNAL_MISC_STATEMENT {} result_type operator ()(const connection_body_type &connectionBody) const { @@ -265,20 +256,20 @@ resolver); } // Tn argn; -#define EPG_SIGNAL_MISC_STATEMENT(z, n, Signature) \ - BOOST_PP_CAT(T, BOOST_PP_INC(n)) EPG_SIGNAL_SIGNATURE_ARG_NAME(~, n, ~); - BOOST_PP_REPEAT(EPG_SIGNALS_NUM_ARGS, EPG_SIGNAL_MISC_STATEMENT, ~) -#undef EPG_SIGNAL_MISC_STATEMENT +#define BOOST_SIGNAL_MISC_STATEMENT(z, n, Signature) \ + BOOST_PP_CAT(T, BOOST_PP_INC(n)) BOOST_SIGNAL_SIGNATURE_ARG_NAME(~, n, ~); + BOOST_PP_REPEAT(BOOST_SIGNALS_NUM_ARGS, BOOST_SIGNAL_MISC_STATEMENT, ~) +#undef BOOST_SIGNAL_MISC_STATEMENT private: result_type m_invoke(const connection_body_type &connectionBody, const signalslib::detail::unusable *resolver) const { - connectionBody->slot(EPG_SIGNAL_SIGNATURE_ARG_NAMES(EPG_SIGNALS_NUM_ARGS)); + connectionBody->slot(BOOST_SIGNAL_SIGNATURE_ARG_NAMES(BOOST_SIGNALS_NUM_ARGS)); return signalslib::detail::unusable(); } result_type m_invoke(const connection_body_type &connectionBody, ...) const { - return connectionBody->slot(EPG_SIGNAL_SIGNATURE_ARG_NAMES(EPG_SIGNALS_NUM_ARGS)); + return connectionBody->slot(BOOST_SIGNAL_SIGNATURE_ARG_NAMES(BOOST_SIGNALS_NUM_ARGS)); } }; // a struct used to optimize (minimize) the number of shared_ptrs that need to be created @@ -296,7 +287,7 @@ connection_list_type connection_bodies; combiner_type combiner; }; - + // clean up disconnected connections void nolock_cleanup_connections(bool grab_tracked, const connection_list_type::iterator &begin, const connection_list_type::iterator &end) const @@ -315,7 +306,7 @@ }else { if(grab_tracked) - (*it)->nolock_grab_tracked_objects(); + (*it)->nolock_slot_expired(); connected = (*it)->nolock_nograb_connected(); } }// scoped lock destructs here, safe to erase now @@ -367,7 +358,7 @@ connection_body_type create_new_connection(const slot_type &slot) { nolock_force_unique_connection_list(); - return connection_body_type(new ConnectionBody<group_key_type, slot_function_type, ThreadingModel>(slot)); + return connection_body_type(new ConnectionBody<group_key_type, slot_type, ThreadingModel>(slot)); } void do_disconnect(const group_type &group, mpl::bool_<true> is_group) { @@ -397,46 +388,47 @@ mutable mutex_type _mutex; }; - template<EPG_SIGNAL_TEMPLATE_DECL> - class EPG_WEAK_SIGNAL_CLASS_NAME; + template<BOOST_SIGNAL_TEMPLATE_DECL> + class BOOST_WEAK_SIGNAL_CLASS_NAME; } } - template<EPG_SIGNAL_TEMPLATE_DEFAULTED_DECL> - class EPG_SIGNAL_CLASS_NAME: public signalslib::detail::signal_base + template<BOOST_SIGNAL_TEMPLATE_DEFAULTED_DECL> + class BOOST_SIGNAL_CLASS_NAME: public signalslib::detail::signal_base { public: - typedef signalslib::detail::EPG_WEAK_SIGNAL_CLASS_NAME<EPG_SIGNAL_TEMPLATE_INSTANTIATION> weak_signal_type; + typedef signalslib::detail::BOOST_WEAK_SIGNAL_CLASS_NAME<BOOST_SIGNAL_TEMPLATE_INSTANTIATION> weak_signal_type; friend class weak_signal_type; - friend class signalslib::detail::tracked_objects_visitor; typedef SlotFunction slot_function_type; - typedef slot<slot_function_type> slot_type; + // typedef slotN<Signature, SlotFunction> slot_type; + typedef BOOST_SLOT_CLASS_NAME(BOOST_SIGNALS_NUM_ARGS)<BOOST_SIGNAL_SIGNATURE_TEMPLATE_INSTANTIATION(BOOST_SIGNALS_NUM_ARGS), + slot_function_type> slot_type; typedef typename slot_function_type::result_type slot_result_type; typedef Combiner combiner_type; typedef typename combiner_type::result_type result_type; typedef Group group_type; typedef GroupCompare group_compare_type; - typedef signalslib::detail::EPG_SIGNAL_IMPL_CLASS_NAME<EPG_SIGNAL_TEMPLATE_INSTANTIATION>::slot_call_iterator + typedef signalslib::detail::BOOST_SIGNAL_IMPL_CLASS_NAME<BOOST_SIGNAL_TEMPLATE_INSTANTIATION>::slot_call_iterator slot_call_iterator; // typedef Tn argn_type; -#define EPG_SIGNAL_MISC_STATEMENT(z, n, data) \ +#define BOOST_SIGNAL_MISC_STATEMENT(z, n, data) \ typedef BOOST_PP_CAT(T, BOOST_PP_INC(n)) BOOST_PP_CAT(BOOST_PP_CAT(arg, BOOST_PP_INC(n)), _type); - BOOST_PP_REPEAT(EPG_SIGNALS_NUM_ARGS, EPG_SIGNAL_MISC_STATEMENT, ~) -#undef EPG_SIGNAL_MISC_STATEMENT -#if EPG_SIGNALS_NUM_ARGS == 1 + BOOST_PP_REPEAT(BOOST_SIGNALS_NUM_ARGS, BOOST_SIGNAL_MISC_STATEMENT, ~) +#undef BOOST_SIGNAL_MISC_STATEMENT +#if BOOST_SIGNALS_NUM_ARGS == 1 typedef arg1_type argument_type; -#elif EPG_SIGNALS_NUM_ARGS == 2 +#elif BOOST_SIGNALS_NUM_ARGS == 2 typedef arg1_type first_argument_type; typedef arg2_type second_argument_type; #endif - static const int arity = EPG_SIGNALS_NUM_ARGS; + static const int arity = BOOST_SIGNALS_NUM_ARGS; - EPG_SIGNAL_CLASS_NAME(const combiner_type &combiner = combiner_type(), + BOOST_SIGNAL_CLASS_NAME(const combiner_type &combiner = combiner_type(), const group_compare_type &group_compare = group_compare_type()): - _pimpl(new signalslib::detail::EPG_SIGNAL_IMPL_CLASS_NAME<EPG_SIGNAL_TEMPLATE_INSTANTIATION>(combiner, group_compare)) + _pimpl(new signalslib::detail::BOOST_SIGNAL_IMPL_CLASS_NAME<BOOST_SIGNAL_TEMPLATE_INSTANTIATION>(combiner, group_compare)) {}; - ~EPG_SIGNAL_CLASS_NAME() + virtual ~BOOST_SIGNAL_CLASS_NAME() { disconnect_all_slots(); } @@ -462,13 +454,13 @@ { (*_pimpl).disconnect(slot); } - result_type operator ()(EPG_SIGNAL_SIGNATURE_FULL_ARGS(EPG_SIGNALS_NUM_ARGS, ~)) + result_type operator ()(BOOST_SIGNAL_SIGNATURE_FULL_ARGS(BOOST_SIGNALS_NUM_ARGS)) { - return (*_pimpl)(EPG_SIGNAL_SIGNATURE_ARG_NAMES(EPG_SIGNALS_NUM_ARGS)); + return (*_pimpl)(BOOST_SIGNAL_SIGNATURE_ARG_NAMES(BOOST_SIGNALS_NUM_ARGS)); } - result_type operator ()(EPG_SIGNAL_SIGNATURE_FULL_ARGS(EPG_SIGNALS_NUM_ARGS, ~)) const + result_type operator ()(BOOST_SIGNAL_SIGNATURE_FULL_ARGS(BOOST_SIGNALS_NUM_ARGS)) const { - return (*_pimpl)(EPG_SIGNAL_SIGNATURE_ARG_NAMES(EPG_SIGNALS_NUM_ARGS)); + return (*_pimpl)(BOOST_SIGNAL_SIGNATURE_ARG_NAMES(BOOST_SIGNALS_NUM_ARGS)); } std::size_t num_slots() const { @@ -486,13 +478,13 @@ { return (*_pimpl).set_combiner(combiner); } - private: - shared_ptr<void> lock_pimpl() const + protected: + virtual shared_ptr<void> lock_pimpl() const { return _pimpl; } - - shared_ptr<signalslib::detail::EPG_SIGNAL_IMPL_CLASS_NAME<EPG_SIGNAL_TEMPLATE_INSTANTIATION> > + private: + shared_ptr<signalslib::detail::BOOST_SIGNAL_IMPL_CLASS_NAME<BOOST_SIGNAL_TEMPLATE_INSTANTIATION> > _pimpl; }; @@ -501,33 +493,33 @@ namespace detail { // wrapper class for storing other signals as slots with automatic lifetime tracking - template<EPG_SIGNAL_TEMPLATE_DECL> - class EPG_WEAK_SIGNAL_CLASS_NAME + template<BOOST_SIGNAL_TEMPLATE_DECL> + class BOOST_WEAK_SIGNAL_CLASS_NAME { public: typedef SlotFunction slot_function_type; typedef typename slot_function_type::result_type slot_result_type; - typedef EPG_SIGNAL_CLASS_NAME<EPG_SIGNAL_TEMPLATE_INSTANTIATION>::result_type + typedef BOOST_SIGNAL_CLASS_NAME<BOOST_SIGNAL_TEMPLATE_INSTANTIATION>::result_type result_type; - EPG_WEAK_SIGNAL_CLASS_NAME(const EPG_SIGNAL_CLASS_NAME<EPG_SIGNAL_TEMPLATE_INSTANTIATION> + BOOST_WEAK_SIGNAL_CLASS_NAME(const BOOST_SIGNAL_CLASS_NAME<BOOST_SIGNAL_TEMPLATE_INSTANTIATION> &signal): _weak_pimpl(signal._pimpl) {} - result_type operator ()(EPG_SIGNAL_SIGNATURE_FULL_ARGS(EPG_SIGNALS_NUM_ARGS, ~)) + result_type operator ()(BOOST_SIGNAL_SIGNATURE_FULL_ARGS(BOOST_SIGNALS_NUM_ARGS)) { - shared_ptr<signalslib::detail::EPG_SIGNAL_IMPL_CLASS_NAME<EPG_SIGNAL_TEMPLATE_INSTANTIATION> > + shared_ptr<signalslib::detail::BOOST_SIGNAL_IMPL_CLASS_NAME<BOOST_SIGNAL_TEMPLATE_INSTANTIATION> > shared_pimpl(_weak_pimpl); - return (*shared_pimpl)(EPG_SIGNAL_SIGNATURE_ARG_NAMES(EPG_SIGNALS_NUM_ARGS)); + return (*shared_pimpl)(BOOST_SIGNAL_SIGNATURE_ARG_NAMES(BOOST_SIGNALS_NUM_ARGS)); } - result_type operator ()(EPG_SIGNAL_SIGNATURE_FULL_ARGS(EPG_SIGNALS_NUM_ARGS, ~)) const + result_type operator ()(BOOST_SIGNAL_SIGNATURE_FULL_ARGS(BOOST_SIGNALS_NUM_ARGS)) const { - shared_ptr<signalslib::detail::EPG_SIGNAL_IMPL_CLASS_NAME<EPG_SIGNAL_TEMPLATE_INSTANTIATION> > + shared_ptr<signalslib::detail::BOOST_SIGNAL_IMPL_CLASS_NAME<BOOST_SIGNAL_TEMPLATE_INSTANTIATION> > shared_pimpl(_weak_pimpl); - return (*shared_pimpl)(EPG_SIGNAL_SIGNATURE_ARG_NAMES(EPG_SIGNALS_NUM_ARGS)); + return (*shared_pimpl)(BOOST_SIGNAL_SIGNATURE_ARG_NAMES(BOOST_SIGNALS_NUM_ARGS)); } private: - boost::weak_ptr<signalslib::detail::EPG_SIGNAL_IMPL_CLASS_NAME<EPG_SIGNAL_TEMPLATE_INSTANTIATION> > + boost::weak_ptr<signalslib::detail::BOOST_SIGNAL_IMPL_CLASS_NAME<BOOST_SIGNAL_TEMPLATE_INSTANTIATION> > _weak_pimpl; }; @@ -537,30 +529,23 @@ // partial template specialization template<typename Signature, typename Combiner, typename Group, typename GroupCompare, typename SlotFunction, typename ThreadingModel> - class signalN<EPG_SIGNALS_NUM_ARGS, Signature, Combiner, Group, + class signalN<BOOST_SIGNALS_NUM_ARGS, Signature, Combiner, Group, GroupCompare, SlotFunction, ThreadingModel> { public: - typedef EPG_SIGNAL_CLASS_NAME<typename boost::function_traits<Signature>::result_type, -// typename boost::function_traits<Signature>::argn_type , -#define EPG_SIGNAL_MISC_STATEMENT(z, n, Signature) \ - BOOST_PP_CAT(BOOST_PP_CAT(typename boost::function_traits<Signature>::arg, BOOST_PP_INC(n)), _type) , - BOOST_PP_REPEAT(EPG_SIGNALS_NUM_ARGS, EPG_SIGNAL_MISC_STATEMENT, Signature) -#undef EPG_SIGNAL_MISC_STATEMENT - Combiner, Group, - GroupCompare, SlotFunction, ThreadingModel> type; + typedef BOOST_SIGNAL_CLASS_NAME< + BOOST_SIGNAL_PORTABLE_SIGNATURE(BOOST_SIGNALS_NUM_ARGS, Signature), + Combiner, Group, + GroupCompare, SlotFunction, ThreadingModel> type; }; } } } -#undef EPG_SIGNALS_NUM_ARGS -#undef EPG_SIGNAL_CLASS_NAME -#undef EPG_SIGNAL_IMPL_CLASS_NAME -#undef EPG_SIGNAL_SIGNATURE_ARG_NAME -#undef EPG_SIGNAL_SIGNATURE_FULL_ARG -#undef EPG_SIGNAL_SIGNATURE_FULL_ARGS -#undef EPG_SIGNAL_SIGNATURE_ARG_NAMES -#undef EPG_SIGNAL_TEMPLATE_DEFAULTED_DECL -#undef EPG_SIGNAL_TEMPLATE_DECL -#undef EPG_SIGNAL_TEMPLATE_INSTANTIATION +#undef BOOST_SIGNALS_NUM_ARGS +#undef BOOST_SIGNAL_CLASS_NAME +#undef BOOST_WEAK_SIGNAL_CLASS_NAME +#undef BOOST_SIGNAL_IMPL_CLASS_NAME +#undef BOOST_SIGNAL_TEMPLATE_DEFAULTED_DECL +#undef BOOST_SIGNAL_TEMPLATE_DECL +#undef BOOST_SIGNAL_TEMPLATE_INSTANTIATION Index: signal_base.hpp =================================================================== RCS file: /cvsroot/boost-sandbox/boost-sandbox/boost/thread_safe_signals/detail/signal_base.hpp,v retrieving revision 1.1 retrieving revision 1.2 diff -u -d -r1.1 -r1.2 --- signal_base.hpp 13 Feb 2007 16:17:28 -0000 1.1 +++ signal_base.hpp 27 Feb 2007 21:19:25 -0000 1.2 @@ -17,14 +17,21 @@ #endif namespace boost { - namespace signalslib { - namespace detail { - class signal_base : public noncopyable - { - public: - }; - } // end namespace detail - } // end namespace BOOST_SIGNALS_NAMESPACE + namespace signalslib { + namespace detail { + class slot_base; + + class signal_base : public noncopyable + { + public: + friend class slot_base; + + virtual ~signal_base() {} + protected: + virtual shared_ptr<void> lock_pimpl() const = 0; + }; + } // end namespace detail + } // end namespace BOOST_SIGNALS_NAMESPACE } // end namespace boost #ifdef BOOST_HAS_ABI_HEADERS |
