Swift
summaryrefslogtreecommitdiffstats
path: root/3rdParty/Boost/boost/signals/connection.hpp
diff options
context:
space:
mode:
authorRemko Tronçon <git@el-tramo.be>2009-06-01 08:48:42 (GMT)
committerRemko Tronçon <git@el-tramo.be>2009-06-01 09:24:28 (GMT)
commit2812bddd81f8a1b804c7460f4e14cd0aa393d129 (patch)
treed46294f35150c4f0f43deaf2d31fceaf945ae715 /3rdParty/Boost/boost/signals/connection.hpp
downloadswift-2812bddd81f8a1b804c7460f4e14cd0aa393d129.zip
swift-2812bddd81f8a1b804c7460f4e14cd0aa393d129.tar.bz2
Import.
Diffstat (limited to '3rdParty/Boost/boost/signals/connection.hpp')
-rw-r--r--3rdParty/Boost/boost/signals/connection.hpp213
1 files changed, 213 insertions, 0 deletions
diff --git a/3rdParty/Boost/boost/signals/connection.hpp b/3rdParty/Boost/boost/signals/connection.hpp
new file mode 100644
index 0000000..48493aa
--- /dev/null
+++ b/3rdParty/Boost/boost/signals/connection.hpp
@@ -0,0 +1,213 @@
+// 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