158 lines
5.1 KiB
C++
158 lines
5.1 KiB
C++
// 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
|