]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | // |
2 | // detail/handler_tracking.hpp | |
3 | // ~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
4 | // | |
92f5a8d4 | 5 | // Copyright (c) 2003-2019 Christopher M. Kohlhoff (chris at kohlhoff dot com) |
7c673cae FG |
6 | // |
7 | // Distributed under the Boost Software License, Version 1.0. (See accompanying | |
8 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) | |
9 | // | |
10 | ||
11 | #ifndef BOOST_ASIO_DETAIL_HANDLER_TRACKING_HPP | |
12 | #define BOOST_ASIO_DETAIL_HANDLER_TRACKING_HPP | |
13 | ||
14 | #if defined(_MSC_VER) && (_MSC_VER >= 1200) | |
15 | # pragma once | |
16 | #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) | |
17 | ||
18 | #include <boost/asio/detail/config.hpp> | |
19 | ||
b32b8144 FG |
20 | namespace boost { |
21 | namespace asio { | |
22 | ||
23 | class execution_context; | |
24 | ||
25 | } // namespace asio | |
26 | } // namespace boost | |
27 | ||
28 | #if defined(BOOST_ASIO_CUSTOM_HANDLER_TRACKING) | |
29 | # include BOOST_ASIO_CUSTOM_HANDLER_TRACKING | |
30 | #elif defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING) | |
7c673cae FG |
31 | # include <boost/system/error_code.hpp> |
32 | # include <boost/asio/detail/cstdint.hpp> | |
33 | # include <boost/asio/detail/static_mutex.hpp> | |
34 | # include <boost/asio/detail/tss_ptr.hpp> | |
35 | #endif // defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING) | |
36 | ||
37 | #include <boost/asio/detail/push_options.hpp> | |
38 | ||
39 | namespace boost { | |
40 | namespace asio { | |
41 | namespace detail { | |
42 | ||
b32b8144 FG |
43 | #if defined(BOOST_ASIO_CUSTOM_HANDLER_TRACKING) |
44 | ||
45 | // The user-specified header must define the following macros: | |
46 | // - BOOST_ASIO_INHERIT_TRACKED_HANDLER | |
47 | // - BOOST_ASIO_ALSO_INHERIT_TRACKED_HANDLER | |
48 | // - BOOST_ASIO_HANDLER_TRACKING_INIT | |
49 | // - BOOST_ASIO_HANDLER_CREATION(args) | |
50 | // - BOOST_ASIO_HANDLER_COMPLETION(args) | |
51 | // - BOOST_ASIO_HANDLER_INVOCATION_BEGIN(args) | |
52 | // - BOOST_ASIO_HANDLER_INVOCATION_END | |
53 | // - BOOST_ASIO_HANDLER_OPERATION(args) | |
54 | // - BOOST_ASIO_HANDLER_REACTOR_REGISTRATION(args) | |
55 | // - BOOST_ASIO_HANDLER_REACTOR_DEREGISTRATION(args) | |
56 | // - BOOST_ASIO_HANDLER_REACTOR_READ_EVENT | |
57 | // - BOOST_ASIO_HANDLER_REACTOR_WRITE_EVENT | |
58 | // - BOOST_ASIO_HANDLER_REACTOR_ERROR_EVENT | |
59 | // - BOOST_ASIO_HANDLER_REACTOR_EVENTS(args) | |
60 | // - BOOST_ASIO_HANDLER_REACTOR_OPERATION(args) | |
61 | ||
62 | # if !defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING) | |
63 | # define BOOST_ASIO_ENABLE_HANDLER_TRACKING 1 | |
64 | # endif /// !defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING) | |
65 | ||
66 | #elif defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING) | |
7c673cae FG |
67 | |
68 | class handler_tracking | |
69 | { | |
70 | public: | |
71 | class completion; | |
72 | ||
73 | // Base class for objects containing tracked handlers. | |
74 | class tracked_handler | |
75 | { | |
76 | private: | |
77 | // Only the handler_tracking class will have access to the id. | |
78 | friend class handler_tracking; | |
79 | friend class completion; | |
80 | uint64_t id_; | |
81 | ||
82 | protected: | |
83 | // Constructor initialises with no id. | |
84 | tracked_handler() : id_(0) {} | |
85 | ||
86 | // Prevent deletion through this type. | |
87 | ~tracked_handler() {} | |
88 | }; | |
89 | ||
90 | // Initialise the tracking system. | |
91 | BOOST_ASIO_DECL static void init(); | |
92 | ||
93 | // Record the creation of a tracked handler. | |
b32b8144 FG |
94 | BOOST_ASIO_DECL static void creation( |
95 | execution_context& context, tracked_handler& h, | |
96 | const char* object_type, void* object, | |
97 | uintmax_t native_handle, const char* op_name); | |
7c673cae FG |
98 | |
99 | class completion | |
100 | { | |
101 | public: | |
102 | // Constructor records that handler is to be invoked with no arguments. | |
b32b8144 | 103 | BOOST_ASIO_DECL explicit completion(const tracked_handler& h); |
7c673cae FG |
104 | |
105 | // Destructor records only when an exception is thrown from the handler, or | |
106 | // if the memory is being freed without the handler having been invoked. | |
107 | BOOST_ASIO_DECL ~completion(); | |
108 | ||
109 | // Records that handler is to be invoked with no arguments. | |
110 | BOOST_ASIO_DECL void invocation_begin(); | |
111 | ||
112 | // Records that handler is to be invoked with one arguments. | |
113 | BOOST_ASIO_DECL void invocation_begin(const boost::system::error_code& ec); | |
114 | ||
115 | // Constructor records that handler is to be invoked with two arguments. | |
116 | BOOST_ASIO_DECL void invocation_begin( | |
117 | const boost::system::error_code& ec, std::size_t bytes_transferred); | |
118 | ||
119 | // Constructor records that handler is to be invoked with two arguments. | |
120 | BOOST_ASIO_DECL void invocation_begin( | |
121 | const boost::system::error_code& ec, int signal_number); | |
122 | ||
123 | // Constructor records that handler is to be invoked with two arguments. | |
124 | BOOST_ASIO_DECL void invocation_begin( | |
125 | const boost::system::error_code& ec, const char* arg); | |
126 | ||
127 | // Record that handler invocation has ended. | |
128 | BOOST_ASIO_DECL void invocation_end(); | |
129 | ||
130 | private: | |
131 | friend class handler_tracking; | |
132 | uint64_t id_; | |
133 | bool invoked_; | |
134 | completion* next_; | |
135 | }; | |
136 | ||
b32b8144 FG |
137 | // Record an operation that is not directly associated with a handler. |
138 | BOOST_ASIO_DECL static void operation(execution_context& context, | |
139 | const char* object_type, void* object, | |
140 | uintmax_t native_handle, const char* op_name); | |
141 | ||
142 | // Record that a descriptor has been registered with the reactor. | |
143 | BOOST_ASIO_DECL static void reactor_registration(execution_context& context, | |
144 | uintmax_t native_handle, uintmax_t registration); | |
145 | ||
146 | // Record that a descriptor has been deregistered from the reactor. | |
147 | BOOST_ASIO_DECL static void reactor_deregistration(execution_context& context, | |
148 | uintmax_t native_handle, uintmax_t registration); | |
149 | ||
150 | // Record a reactor-based operation that is associated with a handler. | |
151 | BOOST_ASIO_DECL static void reactor_events(execution_context& context, | |
152 | uintmax_t registration, unsigned events); | |
153 | ||
154 | // Record a reactor-based operation that is associated with a handler. | |
155 | BOOST_ASIO_DECL static void reactor_operation( | |
156 | const tracked_handler& h, const char* op_name, | |
157 | const boost::system::error_code& ec); | |
158 | ||
159 | // Record a reactor-based operation that is associated with a handler. | |
160 | BOOST_ASIO_DECL static void reactor_operation( | |
161 | const tracked_handler& h, const char* op_name, | |
162 | const boost::system::error_code& ec, std::size_t bytes_transferred); | |
7c673cae FG |
163 | |
164 | // Write a line of output. | |
165 | BOOST_ASIO_DECL static void write_line(const char* format, ...); | |
166 | ||
167 | private: | |
168 | struct tracking_state; | |
169 | BOOST_ASIO_DECL static tracking_state* get_state(); | |
170 | }; | |
171 | ||
172 | # define BOOST_ASIO_INHERIT_TRACKED_HANDLER \ | |
173 | : public boost::asio::detail::handler_tracking::tracked_handler | |
174 | ||
175 | # define BOOST_ASIO_ALSO_INHERIT_TRACKED_HANDLER \ | |
176 | , public boost::asio::detail::handler_tracking::tracked_handler | |
177 | ||
178 | # define BOOST_ASIO_HANDLER_TRACKING_INIT \ | |
179 | boost::asio::detail::handler_tracking::init() | |
180 | ||
181 | # define BOOST_ASIO_HANDLER_CREATION(args) \ | |
182 | boost::asio::detail::handler_tracking::creation args | |
183 | ||
184 | # define BOOST_ASIO_HANDLER_COMPLETION(args) \ | |
185 | boost::asio::detail::handler_tracking::completion tracked_completion args | |
186 | ||
187 | # define BOOST_ASIO_HANDLER_INVOCATION_BEGIN(args) \ | |
188 | tracked_completion.invocation_begin args | |
189 | ||
190 | # define BOOST_ASIO_HANDLER_INVOCATION_END \ | |
191 | tracked_completion.invocation_end() | |
192 | ||
193 | # define BOOST_ASIO_HANDLER_OPERATION(args) \ | |
194 | boost::asio::detail::handler_tracking::operation args | |
195 | ||
b32b8144 FG |
196 | # define BOOST_ASIO_HANDLER_REACTOR_REGISTRATION(args) \ |
197 | boost::asio::detail::handler_tracking::reactor_registration args | |
198 | ||
199 | # define BOOST_ASIO_HANDLER_REACTOR_DEREGISTRATION(args) \ | |
200 | boost::asio::detail::handler_tracking::reactor_deregistration args | |
201 | ||
202 | # define BOOST_ASIO_HANDLER_REACTOR_READ_EVENT 1 | |
203 | # define BOOST_ASIO_HANDLER_REACTOR_WRITE_EVENT 2 | |
204 | # define BOOST_ASIO_HANDLER_REACTOR_ERROR_EVENT 4 | |
205 | ||
206 | # define BOOST_ASIO_HANDLER_REACTOR_EVENTS(args) \ | |
207 | boost::asio::detail::handler_tracking::reactor_events args | |
208 | ||
209 | # define BOOST_ASIO_HANDLER_REACTOR_OPERATION(args) \ | |
210 | boost::asio::detail::handler_tracking::reactor_operation args | |
211 | ||
7c673cae FG |
212 | #else // defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING) |
213 | ||
214 | # define BOOST_ASIO_INHERIT_TRACKED_HANDLER | |
215 | # define BOOST_ASIO_ALSO_INHERIT_TRACKED_HANDLER | |
216 | # define BOOST_ASIO_HANDLER_TRACKING_INIT (void)0 | |
217 | # define BOOST_ASIO_HANDLER_CREATION(args) (void)0 | |
218 | # define BOOST_ASIO_HANDLER_COMPLETION(args) (void)0 | |
219 | # define BOOST_ASIO_HANDLER_INVOCATION_BEGIN(args) (void)0 | |
220 | # define BOOST_ASIO_HANDLER_INVOCATION_END (void)0 | |
221 | # define BOOST_ASIO_HANDLER_OPERATION(args) (void)0 | |
b32b8144 FG |
222 | # define BOOST_ASIO_HANDLER_REACTOR_REGISTRATION(args) (void)0 |
223 | # define BOOST_ASIO_HANDLER_REACTOR_DEREGISTRATION(args) (void)0 | |
224 | # define BOOST_ASIO_HANDLER_REACTOR_READ_EVENT 0 | |
225 | # define BOOST_ASIO_HANDLER_REACTOR_WRITE_EVENT 0 | |
226 | # define BOOST_ASIO_HANDLER_REACTOR_ERROR_EVENT 0 | |
227 | # define BOOST_ASIO_HANDLER_REACTOR_EVENTS(args) (void)0 | |
228 | # define BOOST_ASIO_HANDLER_REACTOR_OPERATION(args) (void)0 | |
7c673cae FG |
229 | |
230 | #endif // defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING) | |
231 | ||
232 | } // namespace detail | |
233 | } // namespace asio | |
234 | } // namespace boost | |
235 | ||
236 | #include <boost/asio/detail/pop_options.hpp> | |
237 | ||
238 | #if defined(BOOST_ASIO_HEADER_ONLY) | |
239 | # include <boost/asio/detail/impl/handler_tracking.ipp> | |
240 | #endif // defined(BOOST_ASIO_HEADER_ONLY) | |
241 | ||
242 | #endif // BOOST_ASIO_DETAIL_HANDLER_TRACKING_HPP |