boost/boost/signals/connection.hpp

   1 // Boost.Signals library
   2
   3 // Copyright Douglas Gregor 2001-2004. Use, modification and
   4 // distribution is subject to the Boost Software License, Version
   5 // 1.0. (See accompanying file LICENSE_1_0.txt or copy at
   6 // http://www.boost.org/LICENSE_1_0.txt)
   7
   8 // For more information, see http://www.boost.org
   9
  10 #ifndef BOOST_SIGNALS_CONNECTION_HPP
  11 #define BOOST_SIGNALS_CONNECTION_HPP
  12
  13 #include <boost/signals/detail/signals_common.hpp>
  14 #include <boost/smart_ptr.hpp>
  15 #include <boost/operators.hpp>
  16 #include <boost/any.hpp>
  17 #include <list>
  18 #include <cassert>
  19 #include <utility>
  20
  21 #ifdef BOOST_HAS_ABI_HEADERS
  22 #  include BOOST_ABI_PREFIX
  23 #endif
  24
  25 namespace boost {
  26   namespace BOOST_SIGNALS_NAMESPACE {
  27     class trackable;
  28
  29     namespace detail {
  30       // Represents an object that has been bound as part of a slot, and how
  31       // to notify that object of a disconnect
  32       struct bound_object {
  33         void* obj;
  34         void* data;
  35         void (*disconnect)(void*, void*);
  36
  37         bool operator==(const bound_object& other) const
  38           { return obj == other.obj && data == other.data; }
  39         bool operator<(const bound_object& other) const
  40           { return obj < other.obj; }
  41
  42         // To support intel 80 compiler, 2004/03/18 (Mark Rodgers)
  43         bool operator!=(const bound_object& other) const
  44         { return !(*this==other); }
  45         bool operator>(const bound_object& other) const
  46         { return !(*this < other); }
  47       };
  48
  49       // Describes the connection between a signal and the objects that are
  50       // bound for a specific slot. Enables notification of the signal and the
  51       // slots when a disconnect is requested.
  52       struct basic_connection {
  53         void* signal;
  54         void* signal_data;
  55         void (*signal_disconnect)(void*, void*);
  56         bool blocked_;
  57
  58         std::list<bound_object> bound_objects;
  59       };
  60     } // end namespace detail
  61
  62     // The user may freely pass around the "connection" object and terminate
  63     // the connection at any time using disconnect().
  64     class BOOST_SIGNALS_DECL connection :
  65       private less_than_comparable1<connection>,
  66       private equality_comparable1<connection>
  67     {
  68     public:
  69       connection() : con(), controlling_connection(false) {}
  70       connection(const connection&);
  71       ~connection();
  72
  73       // Block he connection: if the connection is still active, there
  74       // will be no notification
  75       void block(bool should_block = true) { con->blocked_ = should_block; }
  76       void unblock() { con->blocked_ = false; }
  77       bool blocked() const { return !connected() || con->blocked_; }
  78
  79       // Disconnect the signal and slot, if they are connected
  80       void disconnect() const;
  81
  82       // Returns true if the signal and slot are connected
  83       bool connected() const { return con.get() && con->signal_disconnect; }
  84
  85       // Comparison of connections
  86       bool operator==(const connection& other) const;
  87       bool operator<(const connection& other) const;
  88
  89       // Connection assignment
  90       connection& operator=(const connection& other) ;
  91
  92       // Swap connections
  93       void swap(connection& other);
  94
  95     public: // TBD: CHANGE THIS
  96       // Set whether this connection object is controlling or not
  97       void set_controlling(bool control = true)
  98       { controlling_connection = control; }
  99
 100       shared_ptr<BOOST_SIGNALS_NAMESPACE::detail::basic_connection>
 101       get_connection() const
 102       { return con; }
 103
 104     private:
 105       friend class detail::signal_base_impl;
 106       friend class detail::slot_base;
 107       friend class trackable;
 108
 109       // Reset this connection to refer to a different actual connection
 110       void reset(BOOST_SIGNALS_NAMESPACE::detail::basic_connection*);
 111
 112       // Add a bound object to this connection (not for users)
 113       void add_bound_object(const BOOST_SIGNALS_NAMESPACE::detail::bound_object& b);
 114
 115       friend class BOOST_SIGNALS_NAMESPACE::detail::bound_objects_visitor;
 116
 117       // Pointer to the actual contents of the connection
 118       shared_ptr<BOOST_SIGNALS_NAMESPACE::detail::basic_connection> con;
 119
 120       // True if the destruction of this connection object should disconnect
 121       bool controlling_connection;
 122     };
 123
 124     // Similar to connection, but will disconnect the connection when it is
 125     // destroyed unless release() has been called.
 126     class BOOST_SIGNALS_DECL scoped_connection : public connection {
 127     public:
 128       scoped_connection() : connection(), released(false) {}
 129       scoped_connection(const connection&);
 130       scoped_connection(const scoped_connection&);
 131       ~scoped_connection();
 132
 133       connection release();
 134
 135       void swap(scoped_connection&);
 136
 137       scoped_connection& operator=(const connection&);
 138       scoped_connection& operator=(const scoped_connection&);
 139
 140     private:
 141       bool released;
 142     };
 143
 144     namespace detail {
 145       struct connection_slot_pair {
 146         connection first;
 147         any second;
 148
 149         connection_slot_pair() {}
 150
 151         connection_slot_pair(const connection& c, const any& a)
 152           : first(c), second(a)
 153         {
 154         }
 155
 156         // Dummys to allow explicit instantiation to work
 157         bool operator==(const connection_slot_pair&) const { return false; }
 158         bool operator<(const connection_slot_pair&) const { return false;}
 159       };
 160
 161       // Determines if the underlying connection is disconnected
 162       struct is_disconnected {
 163         typedef connection_slot_pair argument_type;
 164         typedef bool result_type;
 165
 166         inline bool operator()(const argument_type& c) const
 167         {
 168           return !c.first.connected();
 169         }
 170       };
 171
 172       // Determines if the underlying connection is callable, ie if
 173       // it is connected and not blocked
 174       struct is_callable {
 175         typedef connection_slot_pair argument_type;
 176         typedef bool result_type;
 177
 178         inline bool operator()(const argument_type& c) const
 179         {
 180           return c.first.connected() && !c.first.blocked() ;
 181         }
 182       };
 183
 184       // Autodisconnects the bound object when it is destroyed unless the
 185       // release method is invoked.
 186       class auto_disconnect_bound_object {
 187       public:
 188         auto_disconnect_bound_object(const bound_object& b) :
 189           binding(b), auto_disconnect(true)
 190         {
 191         }
 192
 193         ~auto_disconnect_bound_object()
 194         {
 195           if (auto_disconnect)
 196             binding.disconnect(binding.obj, binding.data);
 197         }
 198
 199         void release() { auto_disconnect = false; }
 200
 201       private:
 202         bound_object binding;
 203         bool auto_disconnect;
 204       };
 205     } // end namespace detail
 206   } // end namespace BOOST_SIGNALS_NAMESPACE
 207 } // end namespace boost
 208
 209 #ifdef BOOST_HAS_ABI_HEADERS
 210 #  include BOOST_ABI_SUFFIX
 211 #endif
 212
 213 #endif // BOOST_SIGNALS_CONNECTION_HPP