// 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 | |
#ifndef BOOST_SIGNALS_SLOT_HEADER | |
#define BOOST_SIGNALS_SLOT_HEADER | |
#include <boost/signals/detail/signals_common.hpp> | |
#include <boost/signals/connection.hpp> | |
#include <boost/signals/trackable.hpp> | |
#include <boost/visit_each.hpp> | |
#include <boost/shared_ptr.hpp> | |
#include <cassert> | |
#ifdef BOOST_HAS_ABI_HEADERS | |
# include BOOST_ABI_PREFIX | |
#endif | |
namespace boost { | |
namespace BOOST_SIGNALS_NAMESPACE { | |
namespace detail { | |
class BOOST_SIGNALS_DECL slot_base { | |
// We would have to enumerate all of the signalN classes here as | |
// friends to make this private (as it otherwise should be). We can't | |
// name all of them because we don't know how many there are. | |
public: | |
struct data_t { | |
std::vector<const trackable*> bound_objects; | |
connection watch_bound_objects; | |
}; | |
shared_ptr<data_t> get_data() const { return data; } | |
// Get the set of bound objects | |
std::vector<const trackable*>& get_bound_objects() const | |
{ return data->bound_objects; } | |
// Determine if this slot is still "active", i.e., all of the bound | |
// objects still exist | |
bool is_active() const | |
{ return data->watch_bound_objects.connected(); } | |
protected: | |
// Create a connection for this slot | |
void create_connection(); | |
shared_ptr<data_t> data; | |
private: | |
static void bound_object_destructed(void*, void*) {} | |
}; | |
} // end namespace detail | |
// Get the slot so that it can be copied | |
template<typename F> | |
reference_wrapper<const F> | |
get_invocable_slot(const F& f, BOOST_SIGNALS_NAMESPACE::detail::signal_tag) | |
{ return reference_wrapper<const F>(f); } | |
template<typename F> | |
const F& | |
get_invocable_slot(const F& f, BOOST_SIGNALS_NAMESPACE::detail::reference_tag) | |
{ return f; } | |
template<typename F> | |
const F& | |
get_invocable_slot(const F& f, BOOST_SIGNALS_NAMESPACE::detail::value_tag) | |
{ return f; } | |
// Get the slot so that it can be inspected for trackable objects | |
template<typename F> | |
const F& | |
get_inspectable_slot(const F& f, BOOST_SIGNALS_NAMESPACE::detail::signal_tag) | |
{ return f; } | |
template<typename F> | |
const F& | |
get_inspectable_slot(const reference_wrapper<F>& f, BOOST_SIGNALS_NAMESPACE::detail::reference_tag) | |
{ return f.get(); } | |
template<typename F> | |
const F& | |
get_inspectable_slot(const F& f, BOOST_SIGNALS_NAMESPACE::detail::value_tag) | |
{ return f; } | |
// Determines the type of the slot - is it a signal, a reference to a | |
// slot or just a normal slot. | |
template<typename F> | |
typename BOOST_SIGNALS_NAMESPACE::detail::get_slot_tag<F>::type | |
tag_type(const F&) | |
{ | |
typedef typename BOOST_SIGNALS_NAMESPACE::detail::get_slot_tag<F>::type | |
the_tag_type; | |
the_tag_type tag = the_tag_type(); | |
return tag; | |
} | |
} // end namespace BOOST_SIGNALS_NAMESPACE | |
template<typename SlotFunction> | |
class slot : public BOOST_SIGNALS_NAMESPACE::detail::slot_base { | |
typedef BOOST_SIGNALS_NAMESPACE::detail::slot_base inherited; | |
typedef typename inherited::data_t data_t; | |
public: | |
template<typename F> | |
slot(const F& f) : slot_function(BOOST_SIGNALS_NAMESPACE::get_invocable_slot(f, BOOST_SIGNALS_NAMESPACE::tag_type(f))) | |
{ | |
this->data.reset(new data_t); | |
// Visit each of the bound objects and store them for later use | |
// An exception thrown here will allow the basic_connection to be | |
// destroyed when this goes out of scope, and no other connections | |
// have been made. | |
BOOST_SIGNALS_NAMESPACE::detail::bound_objects_visitor | |
do_bind(this->data->bound_objects); | |
visit_each(do_bind, | |
BOOST_SIGNALS_NAMESPACE::get_inspectable_slot | |
(f, BOOST_SIGNALS_NAMESPACE::tag_type(f))); | |
create_connection(); | |
} | |
#ifdef __BORLANDC__ | |
template<typename F> | |
slot(F* f) : slot_function(f) | |
{ | |
this->data.reset(new data_t); | |
create_connection(); | |
} | |
#endif // __BORLANDC__ | |
// We would have to enumerate all of the signalN classes here as friends | |
// to make this private (as it otherwise should be). We can't name all of | |
// them because we don't know how many there are. | |
public: | |
// Get the slot function to call the actual slot | |
const SlotFunction& get_slot_function() const { return slot_function; } | |
void release() const { data->watch_bound_objects.set_controlling(false); } | |
private: | |
slot(); // no default constructor | |
slot& operator=(const slot&); // no assignment operator | |
SlotFunction slot_function; | |
}; | |
} // end namespace boost | |
#ifdef BOOST_HAS_ABI_HEADERS | |
# include BOOST_ABI_SUFFIX | |
#endif | |
#endif // BOOST_SIGNALS_SLOT_HEADER |