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