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