// 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_CONNECTION_HPP | |
#define BOOST_SIGNALS_CONNECTION_HPP | |
#include <boost/signals/detail/signals_common.hpp> | |
#include <boost/smart_ptr.hpp> | |
#include <boost/operators.hpp> | |
#include <boost/any.hpp> | |
#include <list> | |
#include <cassert> | |
#include <utility> | |
#ifdef BOOST_HAS_ABI_HEADERS | |
# include BOOST_ABI_PREFIX | |
#endif | |
namespace boost { | |
namespace BOOST_SIGNALS_NAMESPACE { | |
class trackable; | |
namespace detail { | |
// Represents an object that has been bound as part of a slot, and how | |
// to notify that object of a disconnect | |
struct bound_object { | |
void* obj; | |
void* data; | |
void (*disconnect)(void*, void*); | |
bool operator==(const bound_object& other) const | |
{ return obj == other.obj && data == other.data; } | |
bool operator<(const bound_object& other) const | |
{ return obj < other.obj; } | |
// To support intel 80 compiler, 2004/03/18 (Mark Rodgers) | |
bool operator!=(const bound_object& other) const | |
{ return !(*this==other); } | |
bool operator>(const bound_object& other) const | |
{ return !(*this < other); } | |
}; | |
// Describes the connection between a signal and the objects that are | |
// bound for a specific slot. Enables notification of the signal and the | |
// slots when a disconnect is requested. | |
struct basic_connection { | |
void* signal; | |
void* signal_data; | |
void (*signal_disconnect)(void*, void*); | |
bool blocked_; | |
std::list<bound_object> bound_objects; | |
}; | |
} // end namespace detail | |
// The user may freely pass around the "connection" object and terminate | |
// the connection at any time using disconnect(). | |
class BOOST_SIGNALS_DECL connection : | |
private less_than_comparable1<connection>, | |
private equality_comparable1<connection> | |
{ | |
public: | |
connection() : con(), controlling_connection(false) {} | |
connection(const connection&); | |
~connection(); | |
// Block he connection: if the connection is still active, there | |
// will be no notification | |
void block(bool should_block = true) { con->blocked_ = should_block; } | |
void unblock() { con->blocked_ = false; } | |
bool blocked() const { return !connected() || con->blocked_; } | |
// Disconnect the signal and slot, if they are connected | |
void disconnect() const; | |
// Returns true if the signal and slot are connected | |
bool connected() const { return con.get() && con->signal_disconnect; } | |
// Comparison of connections | |
bool operator==(const connection& other) const; | |
bool operator<(const connection& other) const; | |
// Connection assignment | |
connection& operator=(const connection& other) ; | |
// Swap connections | |
void swap(connection& other); | |
public: // TBD: CHANGE THIS | |
// Set whether this connection object is controlling or not | |
void set_controlling(bool control = true) | |
{ controlling_connection = control; } | |
shared_ptr<BOOST_SIGNALS_NAMESPACE::detail::basic_connection> | |
get_connection() const | |
{ return con; } | |
private: | |
friend class detail::signal_base_impl; | |
friend class detail::slot_base; | |
friend class trackable; | |
// Reset this connection to refer to a different actual connection | |
void reset(BOOST_SIGNALS_NAMESPACE::detail::basic_connection*); | |
// Add a bound object to this connection (not for users) | |
void add_bound_object(const BOOST_SIGNALS_NAMESPACE::detail::bound_object& b); | |
friend class BOOST_SIGNALS_NAMESPACE::detail::bound_objects_visitor; | |
// Pointer to the actual contents of the connection | |
shared_ptr<BOOST_SIGNALS_NAMESPACE::detail::basic_connection> con; | |
// True if the destruction of this connection object should disconnect | |
bool controlling_connection; | |
}; | |
// Similar to connection, but will disconnect the connection when it is | |
// destroyed unless release() has been called. | |
class BOOST_SIGNALS_DECL scoped_connection : public connection { | |
public: | |
scoped_connection() : connection(), released(false) {} | |
scoped_connection(const connection&); | |
scoped_connection(const scoped_connection&); | |
~scoped_connection(); | |
connection release(); | |
inline void swap(scoped_connection&); | |
scoped_connection& operator=(const connection&); | |
scoped_connection& operator=(const scoped_connection&); | |
private: | |
bool released; | |
}; | |
namespace detail { | |
struct connection_slot_pair { | |
connection first; | |
any second; | |
connection_slot_pair() {} | |
connection_slot_pair(const connection& c, const any& a) | |
: first(c), second(a) | |
{ | |
} | |
// Dummys to allow explicit instantiation to work | |
bool operator==(const connection_slot_pair&) const { return false; } | |
bool operator<(const connection_slot_pair&) const { return false;} | |
}; | |
// Determines if the underlying connection is disconnected | |
struct is_disconnected { | |
typedef connection_slot_pair argument_type; | |
typedef bool result_type; | |
inline bool operator()(const argument_type& c) const | |
{ | |
return !c.first.connected(); | |
} | |
}; | |
// Determines if the underlying connection is callable, ie if | |
// it is connected and not blocked | |
struct is_callable { | |
typedef connection_slot_pair argument_type; | |
typedef bool result_type; | |
inline bool operator()(const argument_type& c) const | |
{ | |
return c.first.connected() && !c.first.blocked() ; | |
} | |
}; | |
// Autodisconnects the bound object when it is destroyed unless the | |
// release method is invoked. | |
class auto_disconnect_bound_object { | |
public: | |
auto_disconnect_bound_object(const bound_object& b) : | |
binding(b), auto_disconnect(true) | |
{ | |
} | |
~auto_disconnect_bound_object() | |
{ | |
if (auto_disconnect) | |
binding.disconnect(binding.obj, binding.data); | |
} | |
void release() { auto_disconnect = false; } | |
private: | |
bound_object binding; | |
bool auto_disconnect; | |
}; | |
} // end namespace detail | |
} // end namespace BOOST_SIGNALS_NAMESPACE | |
} // end namespace boost | |
#ifdef BOOST_HAS_ABI_HEADERS | |
# include BOOST_ABI_SUFFIX | |
#endif | |
#endif // BOOST_SIGNALS_CONNECTION_HPP |