// 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