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