]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
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 |