Added boost header

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