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