boost/signals/signal_template.hpp
// Boost.Signals library // 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 intentionally does not have include guards, because it is meant // to be included multiple times (one for each signalN class). The // BOOST_SIGNALS_SIGNAL_TEMPLATE_HEADER_INCLUDED macro merely serves to // suppress reinclusion of the files that this header depends on. #ifndef BOOST_SIGNALS_SIGNAL_TEMPLATE_HEADER_INCLUDED #define BOOST_SIGNALS_SIGNAL_TEMPLATE_HEADER_INCLUDED # include <boost/config.hpp> # include <boost/signals/connection.hpp> # include <boost/utility.hpp> # include <boost/ref.hpp> # include <boost/signals/slot.hpp> # include <boost/last_value.hpp> # include <boost/signals/detail/signal_base.hpp> # include <boost/signals/detail/slot_call_iterator.hpp> # include <boost/mpl/bool.hpp> # include <boost/type_traits/is_convertible.hpp> # include <cassert> # include <functional> # include <memory> #endif // !BOOST_SIGNALS_SIGNAL_TEMPLATE_HEADER_INCLUDED #ifdef BOOST_HAS_ABI_HEADERS # include BOOST_ABI_PREFIX #endif // Include the appropriate functionN header #define BOOST_SIGNAL_FUNCTION_N_HEADER BOOST_JOIN(<boost/function/function,BOOST_SIGNALS_NUM_ARGS.hpp>) #include BOOST_SIGNAL_FUNCTION_N_HEADER // Determine if a comma should follow a listing of the arguments/parameters #if BOOST_SIGNALS_NUM_ARGS == 0 # define BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS #else # define BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS , #endif // BOOST_SIGNALS_NUM_ARGS > 0 // Define class names used #define BOOST_SIGNALS_SIGNAL BOOST_JOIN(signal,BOOST_SIGNALS_NUM_ARGS) #define BOOST_SIGNALS_FUNCTION BOOST_JOIN(function,BOOST_SIGNALS_NUM_ARGS) #define BOOST_SIGNALS_ARGS_STRUCT BOOST_JOIN(args,BOOST_SIGNALS_NUM_ARGS) #define BOOST_SIGNALS_CALL_BOUND BOOST_JOIN(call_bound,BOOST_SIGNALS_NUM_ARGS) // Define commonly-used instantiations #define BOOST_SIGNALS_ARGS_STRUCT_INST \ BOOST_SIGNALS_NAMESPACE::detail::BOOST_SIGNALS_ARGS_STRUCT<BOOST_SIGNALS_TEMPLATE_ARGS> namespace boost { namespace BOOST_SIGNALS_NAMESPACE { namespace detail { // Holds the arguments for a bound slot call in a single place template<BOOST_SIGNALS_TEMPLATE_PARMS BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS typename Dummy = int> struct BOOST_SIGNALS_ARGS_STRUCT { BOOST_SIGNALS_ARGS_STRUCT(BOOST_SIGNALS_COPY_PARMS) BOOST_SIGNALS_INIT_ARGS { } BOOST_SIGNALS_ARGS_AS_MEMBERS }; // Function object that calls the function object given to it, passing // the bound arguments along to that underlying function object template<typename R> struct BOOST_SIGNALS_CALL_BOUND { template<BOOST_SIGNALS_TEMPLATE_PARMS BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS typename F> struct caller { typedef BOOST_SIGNALS_ARGS_STRUCT<BOOST_SIGNALS_TEMPLATE_ARGS>* args_type; args_type args; typedef R result_type; caller() {} caller(args_type a) : args(a) {} template<typename Pair> R operator()(const Pair& slot) const { F* target = const_cast<F*>(unsafe_any_cast<F>(&slot.second)); return (*target)(BOOST_SIGNALS_BOUND_ARGS); } }; }; template<> struct BOOST_SIGNALS_CALL_BOUND<void> { template<BOOST_SIGNALS_TEMPLATE_PARMS BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS typename F> struct caller { typedef BOOST_SIGNALS_ARGS_STRUCT<BOOST_SIGNALS_TEMPLATE_ARGS>* args_type; args_type args; typedef unusable result_type; caller(args_type a) : args(a) {} template<typename Pair> unusable operator()(const Pair& slot) const { F* target = const_cast<F*>(unsafe_any_cast<F>(&slot.second)); (*target)(BOOST_SIGNALS_BOUND_ARGS); return unusable(); } }; }; } // namespace detail } // namespace BOOST_SIGNALS_NAMESPACE // The actual signalN class template< typename R, BOOST_SIGNALS_TEMPLATE_PARMS BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS typename Combiner = last_value<R>, typename Group = int, typename GroupCompare = std::less<Group>, typename SlotFunction = BOOST_SIGNALS_FUNCTION< R BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS BOOST_SIGNALS_TEMPLATE_ARGS> > class BOOST_SIGNALS_SIGNAL : public BOOST_SIGNALS_NAMESPACE::detail::signal_base, // management of slot list public BOOST_SIGNALS_NAMESPACE::trackable // signals are trackable { public: // The slot function type typedef SlotFunction slot_function_type; // Result type of a slot typedef typename BOOST_SIGNALS_NAMESPACE::detail::slot_result_type<R>::type slot_result_type; // Argument types BOOST_SIGNALS_ARG_TYPES #if BOOST_SIGNALS_NUM_ARGS == 1 typedef T1 argument_type; #elif BOOST_SIGNALS_NUM_ARGS == 2 typedef T1 first_argument_type; typedef T2 second_argument_type; #endif private: // The real slot name comparison object type typedef BOOST_SIGNALS_NAMESPACE::detail::group_bridge_compare<GroupCompare, Group> real_group_compare_type; // The function object passed to the slot call iterator that will call // the underlying slot function with its arguments bound typedef BOOST_SIGNALS_NAMESPACE::detail::BOOST_SIGNALS_CALL_BOUND<R> outer_bound_slot_caller; typedef typename outer_bound_slot_caller::template caller<BOOST_SIGNALS_TEMPLATE_ARGS BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS slot_function_type> call_bound_slot; public: // Combiner's result type typedef typename Combiner::result_type result_type; // Combiner type typedef Combiner combiner_type; // Slot type typedef slot<slot_function_type> slot_type; // Slot name type and comparison typedef Group group_type; typedef GroupCompare group_compare_type; typedef BOOST_SIGNALS_NAMESPACE::detail::slot_call_iterator< call_bound_slot, iterator> slot_call_iterator; explicit BOOST_SIGNALS_SIGNAL(const Combiner& c = Combiner(), const GroupCompare& comp = GroupCompare()) : BOOST_SIGNALS_NAMESPACE::detail::signal_base(real_group_compare_type(comp), c) { } // Connect a slot to this signal BOOST_SIGNALS_NAMESPACE::connection connect(const slot_type&, BOOST_SIGNALS_NAMESPACE::connect_position at = BOOST_SIGNALS_NAMESPACE::at_back); BOOST_SIGNALS_NAMESPACE::connection connect(const group_type&, const slot_type&, BOOST_SIGNALS_NAMESPACE::connect_position at = BOOST_SIGNALS_NAMESPACE::at_back); #if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) // MSVC 6.0 and 7.0 don't handle the is_convertible test well void disconnect(const group_type& group) { impl->disconnect(group); } #else template<typename T> void disconnect(const T& t) { typedef mpl::bool_<(is_convertible<T, group_type>::value)> is_group; this->do_disconnect(t, is_group()); } private: // Disconnect a named slot void do_disconnect(const group_type& group, mpl::bool_<true>) { impl->disconnect(group); } template<typename Function> void do_disconnect(const Function& f, mpl::bool_<false>) { // Notify the slot handling code that we are iterating through the slots BOOST_SIGNALS_NAMESPACE::detail::call_notification notification(this->impl); for (iterator i = impl->slots_.begin(); i != impl->slots_.end(); ++i) { slot_function_type& s = *unsafe_any_cast<slot_function_type>(&i->second); if (s == f) i->first.disconnect(); } } #endif public: // Emit the signal result_type operator()(BOOST_SIGNALS_PARMS); result_type operator()(BOOST_SIGNALS_PARMS) const; Combiner& combiner() { return *unsafe_any_cast<Combiner>(&impl->combiner_); } const Combiner& combiner() const { return *unsafe_any_cast<const Combiner>(&impl->combiner_); } }; template< typename R, BOOST_SIGNALS_TEMPLATE_PARMS BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS typename Combiner, typename Group, typename GroupCompare, typename SlotFunction > BOOST_SIGNALS_NAMESPACE::connection BOOST_SIGNALS_SIGNAL< R, BOOST_SIGNALS_TEMPLATE_ARGS BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS Combiner, Group, GroupCompare, SlotFunction >::connect(const slot_type& in_slot, BOOST_SIGNALS_NAMESPACE::connect_position at) { using boost::BOOST_SIGNALS_NAMESPACE::detail::stored_group; // If the slot has been disconnected, just return a disconnected // connection if (!in_slot.is_active()) { return BOOST_SIGNALS_NAMESPACE::connection(); } return impl->connect_slot(in_slot.get_slot_function(), stored_group(), in_slot.get_data(), at); } template< typename R, BOOST_SIGNALS_TEMPLATE_PARMS BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS typename Combiner, typename Group, typename GroupCompare, typename SlotFunction > BOOST_SIGNALS_NAMESPACE::connection BOOST_SIGNALS_SIGNAL< R, BOOST_SIGNALS_TEMPLATE_ARGS BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS Combiner, Group, GroupCompare, SlotFunction >::connect(const group_type& group, const slot_type& in_slot, BOOST_SIGNALS_NAMESPACE::connect_position at) { // If the slot has been disconnected, just return a disconnected // connection if (!in_slot.is_active()) { return BOOST_SIGNALS_NAMESPACE::connection(); } return impl->connect_slot(in_slot.get_slot_function(), group, in_slot.get_data(), at); } template< typename R, BOOST_SIGNALS_TEMPLATE_PARMS BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS typename Combiner, typename Group, typename GroupCompare, typename SlotFunction > typename BOOST_SIGNALS_SIGNAL< R, BOOST_SIGNALS_TEMPLATE_ARGS BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS Combiner, Group, GroupCompare, SlotFunction>::result_type BOOST_SIGNALS_SIGNAL< R, BOOST_SIGNALS_TEMPLATE_ARGS BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS Combiner, Group, GroupCompare, SlotFunction >::operator()(BOOST_SIGNALS_PARMS) { // Notify the slot handling code that we are making a call BOOST_SIGNALS_NAMESPACE::detail::call_notification notification(this->impl); // Construct a function object that will call the underlying slots // with the given arguments. #if BOOST_SIGNALS_NUM_ARGS == 0 BOOST_SIGNALS_ARGS_STRUCT_INST args; #else BOOST_SIGNALS_ARGS_STRUCT_INST args(BOOST_SIGNALS_ARGS); #endif // BOOST_SIGNALS_NUM_ARGS > 0 call_bound_slot f(&args); typedef typename call_bound_slot::result_type result_type; optional<result_type> cache; // Let the combiner call the slots via a pair of input iterators return combiner()(slot_call_iterator(notification.impl->slots_.begin(), impl->slots_.end(), f, cache), slot_call_iterator(notification.impl->slots_.end(), impl->slots_.end(), f, cache)); } template< typename R, BOOST_SIGNALS_TEMPLATE_PARMS BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS typename Combiner, typename Group, typename GroupCompare, typename SlotFunction > typename BOOST_SIGNALS_SIGNAL< R, BOOST_SIGNALS_TEMPLATE_ARGS BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS Combiner, Group, GroupCompare, SlotFunction>::result_type BOOST_SIGNALS_SIGNAL< R, BOOST_SIGNALS_TEMPLATE_ARGS BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS Combiner, Group, GroupCompare, SlotFunction >::operator()(BOOST_SIGNALS_PARMS) const { // Notify the slot handling code that we are making a call BOOST_SIGNALS_NAMESPACE::detail::call_notification notification(this->impl); // Construct a function object that will call the underlying slots // with the given arguments. #if BOOST_SIGNALS_NUM_ARGS == 0 BOOST_SIGNALS_ARGS_STRUCT_INST args; #else BOOST_SIGNALS_ARGS_STRUCT_INST args(BOOST_SIGNALS_ARGS); #endif // BOOST_SIGNALS_NUM_ARGS > 0 call_bound_slot f(&args); typedef typename call_bound_slot::result_type result_type; optional<result_type> cache; // Let the combiner call the slots via a pair of input iterators return combiner()(slot_call_iterator(notification.impl->slots_.begin(), impl->slots_.end(), f, cache), slot_call_iterator(notification.impl->slots_.end(), impl->slots_.end(), f, cache)); } } // namespace boost #undef BOOST_SIGNAL_FUNCTION_N_HEADER #undef BOOST_SIGNALS_ARGS_STRUCT_INST #undef BOOST_SIGNALS_CALL_BOUND #undef BOOST_SIGNALS_ARGS_STRUCT #undef BOOST_SIGNALS_FUNCTION #undef BOOST_SIGNALS_SIGNAL #undef BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS #ifdef BOOST_HAS_ABI_HEADERS # include BOOST_ABI_SUFFIX #endif