1 | |
2 | // Copyright (C) 2006-2009, 2012 Alexander Nasonov |
3 | // Copyright (C) 2012 Lorenzo Caminiti |
4 | // Distributed under the Boost Software License, Version 1.0 |
5 | // (see accompanying file LICENSE_1_0.txt or a copy at |
6 | // http://www.boost.org/LICENSE_1_0.txt) |
7 | // Home at http://www.boost.org/libs/scope_exit |
8 | |
9 | #ifndef FILE_boost_scope_exit_hpp_INCLUDED |
10 | #define FILE_boost_scope_exit_hpp_INCLUDED |
11 | |
12 | #ifndef DOXYGEN |
13 | |
14 | #include <boost/detail/workaround.hpp> |
15 | #include <boost/mpl/assert.hpp> |
16 | #include <boost/mpl/int.hpp> |
17 | #include <boost/utility/enable_if.hpp> |
18 | #include <boost/function.hpp> |
19 | #include <boost/typeof/typeof.hpp> |
20 | #include <boost/config.hpp> |
21 | #include <boost/preprocessor/cat.hpp> |
22 | #include <boost/preprocessor/control/iif.hpp> |
23 | #include <boost/preprocessor/control/expr_iif.hpp> |
24 | #include <boost/preprocessor/comparison/equal.hpp> |
25 | #include <boost/preprocessor/logical/bitor.hpp> |
26 | #include <boost/preprocessor/logical/bitand.hpp> |
27 | #include <boost/preprocessor/facilities/empty.hpp> |
28 | #include <boost/preprocessor/facilities/is_empty.hpp> |
29 | #include <boost/preprocessor/facilities/identity.hpp> |
30 | #include <boost/preprocessor/punctuation/comma_if.hpp> |
31 | #include <boost/preprocessor/punctuation/paren_if.hpp> |
32 | #include <boost/preprocessor/seq/cat.hpp> |
33 | #include <boost/preprocessor/seq/size.hpp> |
34 | #include <boost/preprocessor/seq/to_tuple.hpp> |
35 | #include <boost/preprocessor/tuple/elem.hpp> |
36 | #include <boost/preprocessor/tuple/eat.hpp> |
37 | #include <boost/preprocessor/tuple/to_list.hpp> |
38 | #include <boost/preprocessor/list/append.hpp> |
39 | #include <boost/preprocessor/list/fold_left.hpp> |
40 | #include <boost/preprocessor/list/enum.hpp> |
41 | #include <boost/preprocessor/list/adt.hpp> |
42 | #include <boost/preprocessor/list/for_each_i.hpp> |
43 | #include <boost/preprocessor/detail/is_unary.hpp> |
44 | |
45 | // PRIVATE/PROTECTED // |
46 | |
47 | // NOTE: AUX prefix and aux namespace mark "private" symbols that shall be used |
48 | // only within this library; DETAIL prefix and detail namespace mark "protected" |
49 | // symbols that can be used by other Boost libraries but not outside Boost. |
50 | |
51 | // WARNING: BOOST_SCOPE_EXIT_AUX_GCC also used by some regression test. |
52 | #if defined(__GNUC__) && !defined(BOOST_INTEL) |
53 | # define BOOST_SCOPE_EXIT_AUX_GCC (__GNUC__ * 100 + __GNUC_MINOR__) |
54 | #else |
55 | # define BOOST_SCOPE_EXIT_AUX_GCC 0 |
56 | #endif |
57 | |
58 | #if BOOST_WORKAROUND(BOOST_SCOPE_EXIT_AUX_GCC, BOOST_TESTED_AT(413)) |
59 | # define BOOST_SCOPE_EXIT_AUX_TPL_GCC_WORKAROUND_01 1 |
60 | #else |
61 | # define BOOST_SCOPE_EXIT_AUX_TPL_GCC_WORKAROUND_01 0 |
62 | #endif |
63 | |
64 | #if BOOST_MSVC |
65 | # define BOOST_SCOPE_EXIT_AUX_TYPEOF_THIS_MSVC_WORKAROUND_01 1 |
66 | #else |
67 | # define BOOST_SCOPE_EXIT_AUX_TYPEOF_THIS_MSVC_WORKAROUND_01 0 |
68 | #endif |
69 | |
70 | // MSVC has problems expanding __LINE__ so use (the non standard) __COUNTER__. |
71 | #ifdef BOOST_MSVC |
72 | # define BOOST_SCOPE_EXIT_AUX_PP_LINE_COUNTER __COUNTER__ |
73 | #else |
74 | # define BOOST_SCOPE_EXIT_AUX_PP_LINE_COUNTER __LINE__ |
75 | #endif |
76 | |
77 | // Preprocessor "keyword" detection. |
78 | |
79 | // These are not a local macros, do not #undefine them (these are used by the |
80 | // ..._BACK macros below). |
81 | #define this_BOOST_SCOPE_EXIT_AUX_PP_KEYWORD_THISUNDERSCORE_IS (1) /* unary */ |
82 | #define void_BOOST_SCOPE_EXIT_AUX_PP_KEYWORD_VOID_IS (1) /* unary */ |
83 | |
84 | #define BOOST_SCOPE_EXIT_AUX_PP_KEYWORD_IS_BACK_(token, checking_postfix) \ |
85 | BOOST_PP_IS_UNARY(BOOST_PP_CAT(token, checking_postfix)) |
86 | |
87 | #define BOOST_SCOPE_EXIT_AUX_PP_KEYWORD_IS_THISUNDERSCORE_BACK(token) \ |
88 | BOOST_SCOPE_EXIT_AUX_PP_KEYWORD_IS_BACK_(token, \ |
89 | BOOST_SCOPE_EXIT_AUX_PP_KEYWORD_THISUNDERSCORE_IS) |
90 | |
91 | #define BOOST_SCOPE_EXIT_AUX_PP_KEYWORD_IS_VOID_BACK(token) \ |
92 | BOOST_SCOPE_EXIT_AUX_PP_KEYWORD_IS_BACK_(token, \ |
93 | _BOOST_SCOPE_EXIT_AUX_PP_KEYWORD_VOID_IS) |
94 | |
95 | // Preprocessor "void-list". |
96 | |
97 | // NOTE: Empty list must always be represented as void (which is also a way to |
98 | // specify no function parameter) and it can never be empty because (1) |
99 | // IS_EMPTY(&var) fails (because of the leading non alphanumeric symbol) and |
100 | // (2) some compilers (MSVC) fail to correctly pass empty macro parameters |
101 | // even if they support variadic macros. Therefore, always using void to |
102 | // represent is more portable. |
103 | |
104 | // Argument: (token1)... |
105 | #define BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_FROM_SEQ_(unused, seq) \ |
106 | BOOST_PP_TUPLE_TO_LIST(BOOST_PP_SEQ_SIZE(seq), BOOST_PP_SEQ_TO_TUPLE(seq)) |
107 | |
108 | // Token: void | token1 |
109 | #define BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_HANDLE_VOID_( \ |
110 | is_void_macro, token) \ |
111 | BOOST_PP_IIF(is_void_macro(token), \ |
112 | BOOST_PP_NIL \ |
113 | , \ |
114 | (token, BOOST_PP_NIL) \ |
115 | ) |
116 | |
117 | // Token: (a)(b)... | empty | void | token |
118 | #define BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_HANDLE_SEQ_( \ |
119 | is_void_macro, token) \ |
120 | BOOST_PP_IIF(BOOST_PP_IS_UNARY(token), /* unary paren (a)... */ \ |
121 | BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_FROM_SEQ_ \ |
122 | , \ |
123 | BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_HANDLE_VOID_ \ |
124 | )(is_void_macro, token) |
125 | |
126 | #define BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_NEVER_(tokens) \ |
127 | 0 /* void check always returns false */ |
128 | |
129 | #ifdef BOOST_NO_CXX11_VARIADIC_MACROS |
130 | |
131 | #define BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_(is_void_macro, seq) \ |
132 | BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_HANDLE_SEQ_(is_void_macro, seq) |
133 | |
134 | // Expand `void | (a)(b)...` to pp-list `NIL | (a, (b, NIL))`. |
135 | #define BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST(sign) \ |
136 | BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_( \ |
137 | BOOST_SCOPE_EXIT_AUX_PP_KEYWORD_IS_VOID_BACK, sign) |
138 | |
139 | // Expand `(a)(b)...` to pp-list `(a, (b, NIL))`. |
140 | #define BOOST_SCOPE_EXIT_AUX_PP_NON_VOID_LIST(seq) \ |
141 | BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_( \ |
142 | BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_NEVER_, seq) |
143 | |
144 | #else // VARIADICS |
145 | |
146 | // FUTURE: Replace this with BOOST_PP_VARIADIC_SIZE when and if |
147 | // BOOST_PP_VARIAIDCS detection will match !BOOST_NO_CXX11_VARIADIC_MACROS (for |
148 | // now Boost.Preprocessor and Boost.Config disagree on detecting compiler |
149 | // variadic support while this VARIADIC_SIZE works on compilers not detected by |
150 | // PP). |
151 | #if BOOST_MSVC |
152 | # define BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_VARIADIC_SIZE_(...) \ |
153 | BOOST_PP_CAT(BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_VARIADIC_SIZE_I_(__VA_ARGS__, 64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1,),) |
154 | #else // MSVC |
155 | # define BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_VARIADIC_SIZE_(...) \ |
156 | BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_VARIADIC_SIZE_I_(__VA_ARGS__, 64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1,) |
157 | #endif // MSVC |
158 | #define BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_VARIADIC_SIZE_I_(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63, size, ...) size |
159 | |
160 | // Argument: token1, ... |
161 | #define BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_FROM_VARIADIC_(unused, ...) \ |
162 | BOOST_PP_TUPLE_TO_LIST( \ |
163 | BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_VARIADIC_SIZE_( \ |
164 | __VA_ARGS__), (__VA_ARGS__)) |
165 | |
166 | #define BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_(is_void_macro, ...) \ |
167 | BOOST_PP_IIF(BOOST_PP_EQUAL( \ |
168 | BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_VARIADIC_SIZE_( \ |
169 | __VA_ARGS__), 1), \ |
170 | BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_HANDLE_SEQ_ \ |
171 | , \ |
172 | BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_FROM_VARIADIC_ \ |
173 | )(is_void_macro, __VA_ARGS__) |
174 | |
175 | // Expand `void | (a)(b)... | a, b, ...` to pp-list `NIL | (a, (b, NIL))`. |
176 | #define BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST(...) \ |
177 | BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_( \ |
178 | BOOST_SCOPE_EXIT_AUX_PP_KEYWORD_IS_VOID_BACK, __VA_ARGS__) |
179 | |
180 | // Expand `(a)(b)... | a, b, ...` to pp-list `(a, (b, NIL))`. |
181 | #define BOOST_SCOPE_EXIT_AUX_PP_NON_VOID_LIST(...) \ |
182 | BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_( \ |
183 | BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_NEVER_, __VA_ARGS__) |
184 | |
185 | #endif // VARIADICS |
186 | |
187 | // Steven Watanabe's trick with a modification suggested by Kim Barrett |
188 | namespace boost { namespace scope_exit { namespace detail { |
189 | |
190 | // Type of a local BOOST_SCOPE_EXIT_AUX_ARGS variable. |
191 | // First use in a local scope will declare the BOOST_SCOPE_EXIT_AUX_ARGS |
192 | // variable, subsequent uses will be resolved as two comparisons |
193 | // (cmp1 with 0 and cmp2 with BOOST_SCOPE_EXIT_AUX_ARGS). |
194 | template<int Dummy = 0> |
195 | struct declared |
196 | { |
197 | void* value; |
198 | static int const cmp2 = 0; |
199 | friend void operator>(int, declared const&) {} |
200 | }; |
201 | |
202 | struct undeclared { declared<> dummy[2]; }; |
203 | |
204 | template<int> struct resolve; |
205 | |
206 | template<> |
207 | struct resolve<sizeof(declared<>)> |
208 | { |
209 | static const int cmp1 = 0; |
210 | }; |
211 | |
212 | template<> |
213 | struct resolve<sizeof(undeclared)> |
214 | { |
215 | template<int> |
216 | struct cmp1 |
217 | { |
218 | static int const cmp2 = 0; |
219 | }; |
220 | }; |
221 | |
222 | typedef void (*ref_tag)(int&); |
223 | typedef void (*val_tag)(int ); |
224 | |
225 | template<class T, class Tag> struct member; |
226 | |
227 | template<class T> |
228 | struct member<T,ref_tag> |
229 | { |
230 | T& value; |
231 | #if !BOOST_SCOPE_EXIT_AUX_TPL_GCC_WORKAROUND_01 |
232 | member(T& ref) : value(ref) {} |
233 | #endif |
234 | }; |
235 | |
236 | template<class T> |
237 | struct member<T,val_tag> |
238 | { |
239 | T value; |
240 | #if !BOOST_SCOPE_EXIT_AUX_TPL_GCC_WORKAROUND_01 |
241 | member(T& val) : value(val) {} |
242 | #endif |
243 | }; |
244 | |
245 | template<class T> inline T& deref(T* p, ref_tag) { return *p; } |
246 | template<class T> inline T& deref(T& r, val_tag) { return r; } |
247 | |
248 | template<class T> |
249 | struct wrapper |
250 | { |
251 | typedef T type; |
252 | }; |
253 | |
254 | template<class T> wrapper<T> wrap(T&); |
255 | |
256 | } } } // namespace |
257 | |
258 | #include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP() |
259 | BOOST_TYPEOF_REGISTER_TEMPLATE(boost::scope_exit::detail::wrapper, 1) |
260 | |
261 | #define BOOST_SCOPE_EXIT_AUX_ARGS boost_scope_exit_aux_args |
262 | extern boost::scope_exit::detail::undeclared BOOST_SCOPE_EXIT_AUX_ARGS; |
263 | |
264 | #define BOOST_SCOPE_EXIT_AUX_GUARD(id) \ |
265 | BOOST_PP_CAT(boost_se_guard_, id) |
266 | |
267 | #define BOOST_SCOPE_EXIT_AUX_GUARD_T(id) \ |
268 | BOOST_PP_CAT(boost_se_guard_t_, id) |
269 | |
270 | #define BOOST_SCOPE_EXIT_AUX_PARAMS(id) \ |
271 | BOOST_PP_CAT(boost_se_params_, id) |
272 | |
273 | #define BOOST_SCOPE_EXIT_AUX_THIS_T(id) \ |
274 | BOOST_PP_CAT(boost_se_this_t_, id) |
275 | |
276 | #define BOOST_SCOPE_EXIT_AUX_THIS_CAPTURE_T(id) \ |
277 | BOOST_PP_CAT(boost_se_this_capture_t_, id) |
278 | |
279 | #define BOOST_SCOPE_EXIT_DETAIL_PARAMS_T(id) \ |
280 | BOOST_PP_CAT(boost_se_params_t_, id) |
281 | |
282 | #define BOOST_SCOPE_EXIT_DETAIL_TAG(id, i) \ |
283 | BOOST_PP_SEQ_CAT( (boost_se_tag_)(i)(_)(id) ) |
284 | |
285 | #define BOOST_SCOPE_EXIT_DETAIL_PARAM_THIS(id) \ |
286 | BOOST_PP_SEQ_CAT( (boost_se_param_this_)(id) ) |
287 | |
288 | #define BOOST_SCOPE_EXIT_DETAIL_PARAM(id, i, var) \ |
289 | BOOST_PP_SEQ_CAT( (boost_se_param_)(i)(_)(id) ) |
290 | |
291 | #define BOOST_SCOPE_EXIT_DETAIL_PARAM_T(id, i, var) \ |
292 | BOOST_PP_SEQ_CAT( (boost_se_param_t_)(i)(_)(id) ) |
293 | |
294 | #define BOOST_SCOPE_EXIT_DETAIL_CAPTURE_T(id, i, var) \ |
295 | BOOST_PP_SEQ_CAT( (boost_se_capture_t_)(i)(_)(id) ) |
296 | |
297 | #define BOOST_SCOPE_EXIT_AUX_WRAPPED(id, i) \ |
298 | BOOST_PP_SEQ_CAT( (boost_se_wrapped_t_)(i)(_)(id) ) |
299 | |
300 | #define BOOST_SCOPE_EXIT_AUX_DEREF(id, i, var) \ |
301 | ::boost::scope_exit::detail::deref(var, \ |
302 | static_cast<BOOST_SCOPE_EXIT_DETAIL_TAG(id, i)>(0)) |
303 | |
304 | #define BOOST_SCOPE_EXIT_AUX_MEMBER(r, id, i, var) \ |
305 | ::boost::scope_exit::detail::member< \ |
306 | BOOST_SCOPE_EXIT_DETAIL_PARAM_T(id, i, var), \ |
307 | BOOST_SCOPE_EXIT_DETAIL_TAG(id, i) \ |
308 | > BOOST_SCOPE_EXIT_DETAIL_PARAM(id, i, var); |
309 | |
310 | #define BOOST_SCOPE_EXIT_AUX_ARG_DECL(r, id_ty, i, var) \ |
311 | BOOST_PP_COMMA_IF(i) \ |
312 | BOOST_PP_TUPLE_ELEM(2, 1, id_ty) \ |
313 | BOOST_SCOPE_EXIT_DETAIL_PARAMS_T(BOOST_PP_TUPLE_ELEM(2, 0, id_ty)):: \ |
314 | BOOST_SCOPE_EXIT_DETAIL_PARAM_T(BOOST_PP_TUPLE_ELEM(2, 0, id_ty), \ |
315 | i, var) \ |
316 | var |
317 | |
318 | #define BOOST_SCOPE_EXIT_AUX_ARG(r, id, i, var) \ |
319 | BOOST_PP_COMMA_IF(i) \ |
320 | boost_se_params_->BOOST_SCOPE_EXIT_DETAIL_PARAM(id, i, var).value |
321 | |
322 | #define BOOST_SCOPE_EXIT_DETAIL_TAG_DECL(r, id, i, var) \ |
323 | typedef void (*BOOST_SCOPE_EXIT_DETAIL_TAG(id, i))(int var); |
324 | |
325 | // Adam Butcher's workaround to deduce `this` type on MSVC revision < 10. |
326 | // Boost.Typeof for VC71's typeid-based workaround does not work to determine |
327 | // `this` type due to error C2355 being incorrectly reported. The typical |
328 | // avoidance strategy implemented below is to make an indirect compile-time |
329 | // constant by assigning an enum and use that as type-index-- this only works |
330 | // with the sizeof() approach and not with the typeid() approach. Lorenzo |
331 | // Caminiti extended this approach to work in type-of emulation mode. This code |
332 | // is very similar (and somewhat of a duplication) of the code in |
333 | // boost/typeof/msvc/typeof_impl.hpp). However, this code cannot be integrated |
334 | // into Boost.Typeof because its final API has to be a `typedef ...` and it |
335 | // cannot be a `typeof(...)`. |
336 | #if BOOST_SCOPE_EXIT_AUX_TYPEOF_THIS_MSVC_WORKAROUND_01 |
337 | |
338 | #include <boost/config.hpp> |
339 | #include <boost/detail/workaround.hpp> |
340 | #include <boost/mpl/int.hpp> |
341 | #include <boost/type_traits/is_function.hpp> |
342 | #include <boost/utility/enable_if.hpp> |
343 | |
344 | #if defined(BOOST_MSVC) |
345 | # include <typeinfo> |
346 | #endif |
347 | |
348 | namespace boost { namespace scope_exit { namespace aux { |
349 | namespace msvc_typeof_this { |
350 | |
351 | // compile-time constant code |
352 | #if defined(BOOST_MSVC) && defined(_MSC_EXTENSIONS) |
353 | |
354 | template<int N> struct the_counter; |
355 | |
356 | template<typename T,int N = 5 /* for similarity */> |
357 | struct encode_counter { |
358 | __if_exists(the_counter<N + 256>) { |
359 | BOOST_STATIC_CONSTANT(unsigned, |
360 | count=(encode_counter<T,N + 257>::count)); |
361 | } |
362 | __if_not_exists(the_counter<N + 256>) { |
363 | __if_exists(the_counter<N + 64>) { |
364 | BOOST_STATIC_CONSTANT(unsigned, |
365 | count=(encode_counter<T,N + 65>::count)); |
366 | } |
367 | __if_not_exists(the_counter<N + 64>) { |
368 | __if_exists(the_counter<N + 16>) { |
369 | BOOST_STATIC_CONSTANT(unsigned, |
370 | count=(encode_counter<T,N + 17>::count)); |
371 | } |
372 | __if_not_exists(the_counter<N + 16>) { |
373 | __if_exists(the_counter<N + 4>) { |
374 | BOOST_STATIC_CONSTANT(unsigned, |
375 | count=(encode_counter<T,N + 5>::count)); |
376 | } |
377 | __if_not_exists(the_counter<N + 4>) { |
378 | __if_exists(the_counter<N>) { |
379 | BOOST_STATIC_CONSTANT(unsigned, |
380 | count=(encode_counter<T,N + 1>::count)); |
381 | } |
382 | __if_not_exists(the_counter<N>) { |
383 | BOOST_STATIC_CONSTANT(unsigned,count=N); |
384 | typedef the_counter<N> type; |
385 | } |
386 | } |
387 | } |
388 | } |
389 | } |
390 | }; |
391 | |
392 | #else // compile-time constant code |
393 | |
394 | template<int N> struct encode_counter : encode_counter<N - 1> {}; |
395 | |
396 | template<> struct encode_counter<0> {}; |
397 | |
398 | #endif // compile-time constant code |
399 | |
400 | #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) // type-of code |
401 | |
402 | struct msvc_extract_type_default_param {}; |
403 | |
404 | template<typename ID, typename T = msvc_extract_type_default_param> |
405 | struct msvc_extract_type; |
406 | |
407 | template<typename ID> |
408 | struct msvc_extract_type<ID, msvc_extract_type_default_param> { |
409 | template<bool> |
410 | struct id2type_impl; |
411 | |
412 | typedef id2type_impl<true> id2type; |
413 | }; |
414 | |
415 | template<typename ID, typename T> |
416 | struct msvc_extract_type |
417 | : msvc_extract_type<ID, msvc_extract_type_default_param> { |
418 | template<> |
419 | struct id2type_impl<true> { // VC8.0 specific bug-feature. |
420 | typedef T type; |
421 | }; |
422 | |
423 | template<bool> |
424 | struct id2type_impl; |
425 | |
426 | typedef id2type_impl<true> id2type; |
427 | }; |
428 | |
429 | template<typename T, typename ID> |
430 | struct msvc_register_type : msvc_extract_type<ID, T> {}; |
431 | |
432 | #else // type-of code |
433 | |
434 | template<typename ID> |
435 | struct msvc_extract_type { |
436 | struct id2type; |
437 | }; |
438 | |
439 | template<typename T, typename ID> |
440 | struct msvc_register_type : msvc_extract_type<ID> { |
441 | typedef msvc_extract_type<ID> base_type; |
442 | struct base_type::id2type { // This uses nice VC6.5 and VC7.1 bug-features. |
443 | typedef T type; |
444 | }; |
445 | }; |
446 | |
447 | #endif // typeof code |
448 | |
449 | template<int Id> |
450 | struct msvc_typeid_wrapper { |
451 | typedef typename msvc_extract_type<boost::mpl::int_<Id> |
452 | >::id2type id2type; |
453 | typedef typename id2type::type type; |
454 | }; |
455 | |
456 | template<> |
457 | struct msvc_typeid_wrapper<4> { |
458 | typedef msvc_typeid_wrapper<4> type; |
459 | }; |
460 | |
461 | template<typename T> |
462 | struct encode_type { |
463 | BOOST_STATIC_CONSTANT(unsigned, value = encode_counter<T>::count); |
464 | typedef typename msvc_register_type<T, |
465 | boost::mpl::int_<value> >::id2type type; |
466 | BOOST_STATIC_CONSTANT(unsigned, next = value + 1); |
467 | }; |
468 | |
469 | template<class T> |
470 | struct sizer { |
471 | typedef char(*type)[encode_type<T>::value]; |
472 | }; |
473 | |
474 | template<typename T> |
475 | typename boost::disable_if< |
476 | typename boost::is_function<T>::type |
477 | , typename sizer<T>::type |
478 | >::type encode_start(T const&); |
479 | |
480 | template<typename T> |
481 | typename boost::enable_if< |
482 | typename boost::is_function<T>::type |
483 | , typename sizer<T>::type |
484 | >::type encode_start(T&); |
485 | |
486 | template<typename Organizer, typename T> |
487 | msvc_register_type<T, Organizer> typeof_register_type(const T&, |
488 | Organizer* = 0); |
489 | |
490 | } } } } // namespace |
491 | |
492 | #define BOOST_SCOPE_EXIT_AUX_TYPEDEF_TYPEOF_THIS_INDEX_(id) \ |
493 | BOOST_PP_CAT(boost_se_thistype_index_, id) |
494 | |
495 | #define BOOST_SCOPE_EXIT_DETAIL_TYPEDEF_TYPEOF_THIS(id, ty, new_type) \ |
496 | /* unfortunately, we need to go via this enum which causes this to be */ \ |
497 | /* a typedef construct and not a typeof (so this code cannot be */ \ |
498 | /* integrated into Boost.Typeof) */ \ |
499 | enum { \ |
500 | BOOST_SCOPE_EXIT_AUX_TYPEDEF_TYPEOF_THIS_INDEX_(id) = sizeof( \ |
501 | *::boost::scope_exit::aux::msvc_typeof_this::encode_start(this)) \ |
502 | }; \ |
503 | typedef \ |
504 | ty ::boost::scope_exit::aux::msvc_typeof_this::msvc_typeid_wrapper< \ |
505 | BOOST_SCOPE_EXIT_AUX_TYPEDEF_TYPEOF_THIS_INDEX_(id) \ |
506 | >::type \ |
507 | new_type \ |
508 | ; |
509 | |
510 | #else // TYPEOF_THIS_MSVC_WORKAROUND |
511 | |
512 | #define BOOST_SCOPE_EXIT_DETAIL_TYPEDEF_TYPEOF_THIS(id, ty, new_type) \ |
513 | typedef /* trailing `EMPTY()` handles empty `ty` */ \ |
514 | BOOST_PP_IIF(BOOST_PP_IS_EMPTY(ty BOOST_PP_EMPTY()), \ |
515 | BOOST_TYPEOF \ |
516 | , \ |
517 | BOOST_TYPEOF_TPL \ |
518 | )(this) \ |
519 | new_type \ |
520 | ; |
521 | |
522 | #endif // TYPEOF_THIS_MSVC_WORKAROUND |
523 | |
524 | #if BOOST_SCOPE_EXIT_AUX_TPL_GCC_WORKAROUND_01 |
525 | |
526 | #define BOOST_SCOPE_EXIT_AUX_PARAMS_T_CTOR(id, ty, captures, has_this) \ |
527 | /* expand to nothing */ |
528 | |
529 | #define BOOST_SCOPE_EXIT_DETAIL_PARAM_INIT(r, id, i, var) \ |
530 | BOOST_PP_COMMA_IF(i) { BOOST_SCOPE_EXIT_AUX_DEREF(id, i, var) } |
531 | |
532 | #define BOOST_SCOPE_EXIT_AUX_PARAMS_INIT(id, captures, has_this) \ |
533 | BOOST_PP_EXPR_IIF(BOOST_PP_BITOR(has_this, \ |
534 | BOOST_PP_LIST_IS_CONS(captures)), \ |
535 | = { \ |
536 | ) \ |
537 | BOOST_PP_LIST_FOR_EACH_I(BOOST_SCOPE_EXIT_DETAIL_PARAM_INIT, id, captures) \ |
538 | BOOST_PP_COMMA_IF(BOOST_PP_BITAND(BOOST_PP_LIST_IS_CONS(captures), \ |
539 | has_this)) \ |
540 | BOOST_PP_EXPR_IIF(has_this, this) /* no extra {...} needed here */ \ |
541 | BOOST_PP_EXPR_IIF(BOOST_PP_BITOR(has_this, \ |
542 | BOOST_PP_LIST_IS_CONS(captures)), \ |
543 | } /* trailing `;` will be added by the caller */ \ |
544 | ) |
545 | |
546 | #else // TPL_GCC_WORKAROUND |
547 | |
548 | #define BOOST_SCOPE_EXIT_AUX_CTOR_ARG(r, id, i, var) \ |
549 | BOOST_PP_COMMA_IF(i) \ |
550 | BOOST_SCOPE_EXIT_DETAIL_PARAM_T(id, i, var) & BOOST_PP_CAT(a, i) |
551 | |
552 | #define BOOST_SCOPE_EXIT_AUX_MEMBER_INIT(r, id, i, var) \ |
553 | BOOST_PP_COMMA_IF(i) \ |
554 | BOOST_SCOPE_EXIT_DETAIL_PARAM(id, i, var) ( BOOST_PP_CAT(a, i) ) |
555 | |
556 | #define BOOST_SCOPE_EXIT_AUX_CTOR_ARG_THIS_NAME(id) \ |
557 | BOOST_PP_CAT(boost_se_this_arg_, id) |
558 | |
559 | #define BOOST_SCOPE_EXIT_AUX_CTOR_ARG_THIS(id, ty, comma01) \ |
560 | BOOST_PP_COMMA_IF(comma01) \ |
561 | ty BOOST_SCOPE_EXIT_DETAIL_PARAMS_T(id)::BOOST_SCOPE_EXIT_AUX_THIS_T(id) \ |
562 | BOOST_SCOPE_EXIT_AUX_CTOR_ARG_THIS_NAME(id) /* ptr so no & */ |
563 | |
564 | #define BOOST_SCOPE_EXIT_AUX_MEMBER_THIS_INIT(id, comma01) \ |
565 | BOOST_PP_COMMA_IF(comma01) \ |
566 | BOOST_SCOPE_EXIT_DETAIL_PARAM_THIS(id)( \ |
567 | BOOST_SCOPE_EXIT_AUX_CTOR_ARG_THIS_NAME(id)) |
568 | |
569 | #define BOOST_SCOPE_EXIT_AUX_PARAMS_T_CTOR(id, ty, captures, has_this) \ |
570 | BOOST_SCOPE_EXIT_DETAIL_PARAMS_T(id)( \ |
571 | BOOST_PP_LIST_FOR_EACH_I(BOOST_SCOPE_EXIT_AUX_CTOR_ARG, id, captures) \ |
572 | BOOST_PP_IIF(has_this, \ |
573 | BOOST_SCOPE_EXIT_AUX_CTOR_ARG_THIS \ |
574 | , \ |
575 | BOOST_PP_TUPLE_EAT(3) \ |
576 | )(id, ty, BOOST_PP_LIST_IS_CONS(captures)) \ |
577 | ) \ |
578 | BOOST_PP_EXPR_IIF(BOOST_PP_BITOR(BOOST_PP_LIST_IS_CONS(captures), \ |
579 | has_this), \ |
580 | : \ |
581 | ) \ |
582 | BOOST_PP_LIST_FOR_EACH_I(BOOST_SCOPE_EXIT_AUX_MEMBER_INIT, id, \ |
583 | captures) \ |
584 | BOOST_PP_IIF(has_this, \ |
585 | BOOST_SCOPE_EXIT_AUX_MEMBER_THIS_INIT \ |
586 | , \ |
587 | BOOST_PP_TUPLE_EAT(2) \ |
588 | )(id, BOOST_PP_LIST_IS_CONS(captures)) \ |
589 | {} |
590 | |
591 | #define BOOST_SCOPE_EXIT_DETAIL_PARAM_INIT(r, id, i, var) \ |
592 | BOOST_PP_COMMA_IF(i) BOOST_SCOPE_EXIT_AUX_DEREF(id,i,var) |
593 | |
594 | #define BOOST_SCOPE_EXIT_AUX_PARAMS_INIT(id, captures, has_this) \ |
595 | BOOST_PP_LPAREN_IF(BOOST_PP_BITOR(has_this, \ |
596 | BOOST_PP_LIST_IS_CONS(captures))) \ |
597 | BOOST_PP_LIST_FOR_EACH_I(BOOST_SCOPE_EXIT_DETAIL_PARAM_INIT, id, captures) \ |
598 | BOOST_PP_COMMA_IF(BOOST_PP_BITAND(BOOST_PP_LIST_IS_CONS(captures), \ |
599 | has_this)) \ |
600 | BOOST_PP_EXPR_IIF(has_this, this) \ |
601 | BOOST_PP_RPAREN_IF(BOOST_PP_BITOR(has_this, \ |
602 | BOOST_PP_LIST_IS_CONS(captures))) |
603 | |
604 | #endif // TPL_GCC_WORKAROUND |
605 | |
606 | #if defined(BOOST_TYPEOF_EMULATION) |
607 | |
608 | #define BOOST_SCOPE_EXIT_DETAIL_CAPTURE_DECL(r, id_ty, i, var) \ |
609 | struct BOOST_SCOPE_EXIT_AUX_WRAPPED(BOOST_PP_TUPLE_ELEM(2, 0, id_ty), i) \ |
610 | /* no need to use TYPEOF_TPL here because it's within inheritance */ \ |
611 | : BOOST_TYPEOF(::boost::scope_exit::detail::wrap( \ |
612 | BOOST_SCOPE_EXIT_AUX_DEREF(BOOST_PP_TUPLE_ELEM(2, 0, id_ty), \ |
613 | i, var))) \ |
614 | {}; \ |
615 | typedef BOOST_PP_TUPLE_ELEM(2, 1, id_ty) \ |
616 | BOOST_SCOPE_EXIT_AUX_WRAPPED(BOOST_PP_TUPLE_ELEM(2, 0, id_ty), i)::type\ |
617 | BOOST_SCOPE_EXIT_DETAIL_CAPTURE_T(BOOST_PP_TUPLE_ELEM(2, 0, id_ty), \ |
618 | i, var) \ |
619 | ; |
620 | |
621 | #elif defined(BOOST_INTEL) |
622 | |
623 | #define BOOST_SCOPE_EXIT_DETAIL_CAPTURE_DECL(r, id_ty, i, var) \ |
624 | typedef \ |
625 | /* no TYPEOF_TPL here because uses TYPEOF_KEYWORD directly */ \ |
626 | BOOST_TYPEOF_KEYWORD(BOOST_SCOPE_EXIT_AUX_DEREF( \ |
627 | BOOST_PP_TUPLE_ELEM(2, 0, id_ty), i, var)) \ |
628 | BOOST_SCOPE_EXIT_DETAIL_CAPTURE_T(BOOST_PP_TUPLE_ELEM(2, 0, id_ty), \ |
629 | i, var) \ |
630 | ; |
631 | |
632 | #else |
633 | |
634 | #define BOOST_SCOPE_EXIT_DETAIL_CAPTURE_DECL(r, id_ty, i, var) \ |
635 | typedef \ |
636 | /* no need to use TYPEOF_TPL here because it's a typedef */ \ |
637 | BOOST_TYPEOF(::boost::scope_exit::detail::wrap( \ |
638 | BOOST_SCOPE_EXIT_AUX_DEREF(BOOST_PP_TUPLE_ELEM(2, 0, id_ty), \ |
639 | i, var))) \ |
640 | BOOST_SCOPE_EXIT_AUX_WRAPPED(BOOST_PP_TUPLE_ELEM(2, 0, id_ty), i) \ |
641 | ; \ |
642 | typedef BOOST_PP_TUPLE_ELEM(2, 1, id_ty) \ |
643 | BOOST_SCOPE_EXIT_AUX_WRAPPED(BOOST_PP_TUPLE_ELEM(2, 0, id_ty), i)::type\ |
644 | BOOST_SCOPE_EXIT_DETAIL_CAPTURE_T(BOOST_PP_TUPLE_ELEM(2, 0, id_ty), \ |
645 | i, var) \ |
646 | ; |
647 | |
648 | #endif |
649 | |
650 | #define BOOST_SCOPE_EXIT_DETAIL_PARAM_DECL(r, id_ty, i, var) \ |
651 | typedef \ |
652 | BOOST_SCOPE_EXIT_DETAIL_CAPTURE_T(BOOST_PP_TUPLE_ELEM(2, 0, id_ty), \ |
653 | i, var) \ |
654 | BOOST_SCOPE_EXIT_DETAIL_PARAM_T(BOOST_PP_TUPLE_ELEM(2, 0, id_ty), \ |
655 | i, var) \ |
656 | ; |
657 | |
658 | // Traits. |
659 | |
660 | #define BOOST_SCOPE_EXIT_AUX_TRAITS_OP_CAPTURE(d, captures, this01, capture) \ |
661 | (BOOST_PP_LIST_APPEND(captures, (capture, BOOST_PP_NIL)), this01) |
662 | |
663 | #define BOOST_SCOPE_EXIT_AUX_TRAITS_OP_THIS(d, captures, this01, this_) \ |
664 | (captures, 1 /* has this (note, no error if multiple this_) */) |
665 | |
666 | #define BOOST_SCOPE_EXIT_AUX_TRAITS_OP(d, captures_this, capture) \ |
667 | BOOST_PP_IIF(BOOST_SCOPE_EXIT_AUX_PP_KEYWORD_IS_THISUNDERSCORE_BACK(\ |
668 | capture), \ |
669 | BOOST_SCOPE_EXIT_AUX_TRAITS_OP_THIS \ |
670 | , \ |
671 | BOOST_SCOPE_EXIT_AUX_TRAITS_OP_CAPTURE \ |
672 | )(d, BOOST_PP_TUPLE_ELEM(2, 0, captures_this), \ |
673 | BOOST_PP_TUPLE_ELEM(2, 1, captures_this), capture) |
674 | |
675 | // ref_val: & | = |
676 | #define BOOST_SCOPE_EXIT_AUX_TRAITS_ALL_OP(ref_val, traits) \ |
677 | ( \ |
678 | BOOST_PP_LIST_APPEND((ref_val, BOOST_PP_NIL), \ |
679 | BOOST_SCOPE_EXIT_AUX_TRAITS_CAPTURES(traits)) \ |
680 | , \ |
681 | BOOST_SCOPE_EXIT_AUX_TRAITS_HAS_THIS(traits) \ |
682 | ) |
683 | |
684 | #define BOOST_SCOPE_EXIT_AUX_TRAITS(captures) \ |
685 | BOOST_PP_LIST_FOLD_LEFT(BOOST_SCOPE_EXIT_AUX_TRAITS_OP, \ |
686 | (BOOST_PP_NIL, 0), captures) |
687 | |
688 | #define BOOST_SCOPE_EXIT_AUX_TRAITS_ALL(captures) \ |
689 | BOOST_SCOPE_EXIT_AUX_TRAITS_ALL_OP(BOOST_PP_LIST_FIRST(captures), \ |
690 | BOOST_SCOPE_EXIT_AUX_TRAITS(BOOST_PP_LIST_REST(captures))) |
691 | |
692 | #define BOOST_SCOPE_EXIT_AUX_TRAITS_CAPTURES(traits) \ |
693 | BOOST_PP_TUPLE_ELEM(2, 0, traits) |
694 | |
695 | #define BOOST_SCOPE_EXIT_AUX_TRAITS_HAS_THIS(traits) \ |
696 | BOOST_PP_TUPLE_ELEM(2, 1, traits) |
697 | |
698 | #ifndef BOOST_NO_CXX11_LAMBDAS |
699 | |
700 | namespace boost { namespace scope_exit { namespace aux { |
701 | |
702 | template<typename This = void> |
703 | struct guard { // With object `this_` (for backward compatibility). |
704 | explicit guard(This _this) : this_(_this) {} |
705 | ~guard() { if(f_) f_(this_); } |
706 | template<typename Lambda> |
707 | void operator=(Lambda f) { f_ = f; } |
708 | private: |
709 | This this_; |
710 | boost::function<void (This)> f_; |
711 | }; |
712 | |
713 | template<> |
714 | struct guard<void> { // Without object `this_` (could capture `this` directly). |
715 | ~guard() { if(f_) f_(); } |
716 | template<typename Lambda> |
717 | void operator=(Lambda f) { f_ = f; } |
718 | private: |
719 | boost::function<void (void)> f_; |
720 | }; |
721 | |
722 | } } } // namespace |
723 | |
724 | #define BOOST_SCOPE_EXIT_AUX_LAMBDA_PARAMS(id) \ |
725 | BOOST_PP_CAT(boost_se_lambda_params_, id) |
726 | |
727 | #define BOOST_SCOPE_EXIT_AUX_LAMBDA_THIS_CAPTURE_TYPE(id) \ |
728 | BOOST_PP_CAT(boost_se_lambda_this_t_, id) |
729 | |
730 | #define BOOST_SCOPE_EXIT_AUX_LAMBDA_THIS_PARAM_TYPE(id) \ |
731 | BOOST_PP_CAT(boost_se_lambda_this_capture_t_, id) |
732 | |
733 | #define BOOST_SCOPE_EXIT_AUX_LAMBDA_THIS_TYPE(id, ty) \ |
734 | ty BOOST_SCOPE_EXIT_AUX_LAMBDA_PARAMS(id):: \ |
735 | BOOST_SCOPE_EXIT_AUX_LAMBDA_THIS_PARAM_TYPE(id) |
736 | |
737 | // Precondition: HAS_THIS(traits). |
738 | #define BOOST_SCOPE_EXIT_AUX_LAMBDA_THIS_TYPEDEFS(id, ty, traits) \ |
739 | BOOST_SCOPE_EXIT_DETAIL_TYPEDEF_TYPEOF_THIS(id, ty, \ |
740 | BOOST_SCOPE_EXIT_AUX_LAMBDA_THIS_CAPTURE_TYPE(id)) \ |
741 | /* capture type for workaround GCC internal error (even on later C++11) */ \ |
742 | struct BOOST_SCOPE_EXIT_AUX_LAMBDA_PARAMS(id) { \ |
743 | typedef BOOST_SCOPE_EXIT_AUX_LAMBDA_THIS_CAPTURE_TYPE(id) \ |
744 | BOOST_SCOPE_EXIT_AUX_LAMBDA_THIS_PARAM_TYPE(id); \ |
745 | }; |
746 | |
747 | #define BOOST_SCOPE_EXIT_AUX_IMPL_LAMBDA(id, ty, traits) \ |
748 | BOOST_PP_IIF(BOOST_SCOPE_EXIT_AUX_TRAITS_HAS_THIS(traits), \ |
749 | /* no need for TYPEDEF THIS MSVC workaround on C++11 */ \ |
750 | BOOST_SCOPE_EXIT_AUX_LAMBDA_THIS_TYPEDEFS \ |
751 | , \ |
752 | BOOST_PP_TUPLE_EAT(3) \ |
753 | )(id, ty, traits) \ |
754 | ::boost::scope_exit::aux::guard< \ |
755 | BOOST_PP_IIF(BOOST_SCOPE_EXIT_AUX_TRAITS_HAS_THIS(traits), \ |
756 | BOOST_SCOPE_EXIT_AUX_LAMBDA_THIS_TYPE \ |
757 | , \ |
758 | BOOST_PP_TUPLE_EAT(2) \ |
759 | )(id, ty) \ |
760 | > BOOST_SCOPE_EXIT_AUX_GUARD(id) \ |
761 | BOOST_PP_EXPR_IIF(BOOST_SCOPE_EXIT_AUX_TRAITS_HAS_THIS(traits), \ |
762 | (this) \ |
763 | ) \ |
764 | ; \ |
765 | BOOST_SCOPE_EXIT_AUX_GUARD(id) = [ \ |
766 | BOOST_PP_LIST_ENUM(BOOST_SCOPE_EXIT_AUX_TRAITS_CAPTURES(traits)) \ |
767 | ]( \ |
768 | BOOST_PP_IIF(BOOST_SCOPE_EXIT_AUX_TRAITS_HAS_THIS(traits), \ |
769 | BOOST_SCOPE_EXIT_AUX_LAMBDA_THIS_TYPE \ |
770 | , \ |
771 | BOOST_PP_TUPLE_EAT(2) \ |
772 | )(id, ty) \ |
773 | BOOST_PP_EXPR_IIF(BOOST_SCOPE_EXIT_AUX_TRAITS_HAS_THIS(traits), this_) \ |
774 | ) mutable /* can change value captures (as with SCOPE_EXIT) */ -> void |
775 | |
776 | #endif // Lambdas. |
777 | |
778 | #if defined(BOOST_SCOPE_EXIT_CONFIG_USE_LAMBDAS) && \ |
779 | !defined(BOOST_NO_CXX11_LAMBDAS) // Use lambda for SCOPE_EXIT (not just _ALL). |
780 | |
781 | #define BOOST_SCOPE_EXIT_AUX_IMPL(id, ty, traits) \ |
782 | BOOST_SCOPE_EXIT_AUX_IMPL_LAMBDA(id, ty, traits) |
783 | |
784 | #else // Not using lambdas. |
785 | |
786 | // ty: EMPTY() | typename |
787 | #define BOOST_SCOPE_EXIT_AUX_IMPL(id, ty, traits) \ |
788 | BOOST_PP_LIST_FOR_EACH_I(BOOST_SCOPE_EXIT_DETAIL_TAG_DECL, id, \ |
789 | BOOST_SCOPE_EXIT_AUX_TRAITS_CAPTURES(traits)) \ |
790 | BOOST_PP_LIST_FOR_EACH_I(BOOST_SCOPE_EXIT_DETAIL_CAPTURE_DECL, (id, ty), \ |
791 | BOOST_SCOPE_EXIT_AUX_TRAITS_CAPTURES(traits)) \ |
792 | BOOST_PP_IIF(BOOST_SCOPE_EXIT_AUX_TRAITS_HAS_THIS(traits), \ |
793 | BOOST_SCOPE_EXIT_DETAIL_TYPEDEF_TYPEOF_THIS \ |
794 | , \ |
795 | BOOST_PP_TUPLE_EAT(3) \ |
796 | )(id, ty, BOOST_SCOPE_EXIT_AUX_THIS_CAPTURE_T(id)) \ |
797 | struct BOOST_SCOPE_EXIT_DETAIL_PARAMS_T(id) { \ |
798 | /* interim capture types to workaround internal errors on old GCC */ \ |
799 | BOOST_PP_LIST_FOR_EACH_I(BOOST_SCOPE_EXIT_DETAIL_PARAM_DECL, (id, ty), \ |
800 | BOOST_SCOPE_EXIT_AUX_TRAITS_CAPTURES(traits)) \ |
801 | BOOST_PP_EXPR_IIF(BOOST_SCOPE_EXIT_AUX_TRAITS_HAS_THIS(traits), \ |
802 | typedef BOOST_SCOPE_EXIT_AUX_THIS_CAPTURE_T(id) \ |
803 | BOOST_SCOPE_EXIT_AUX_THIS_T(id) ; \ |
804 | ) \ |
805 | BOOST_PP_LIST_FOR_EACH_I(BOOST_SCOPE_EXIT_AUX_MEMBER, id, \ |
806 | BOOST_SCOPE_EXIT_AUX_TRAITS_CAPTURES(traits)) \ |
807 | BOOST_PP_EXPR_IIF(BOOST_SCOPE_EXIT_AUX_TRAITS_HAS_THIS(traits), \ |
808 | BOOST_SCOPE_EXIT_AUX_THIS_T(id) \ |
809 | BOOST_SCOPE_EXIT_DETAIL_PARAM_THIS(id) ; \ |
810 | ) \ |
811 | BOOST_SCOPE_EXIT_AUX_PARAMS_T_CTOR(id, ty, \ |
812 | BOOST_SCOPE_EXIT_AUX_TRAITS_CAPTURES(traits), \ |
813 | BOOST_SCOPE_EXIT_AUX_TRAITS_HAS_THIS(traits)) \ |
814 | } BOOST_SCOPE_EXIT_AUX_PARAMS(id) \ |
815 | BOOST_SCOPE_EXIT_AUX_PARAMS_INIT(id, \ |
816 | BOOST_SCOPE_EXIT_AUX_TRAITS_CAPTURES(traits), \ |
817 | BOOST_SCOPE_EXIT_AUX_TRAITS_HAS_THIS(traits)) \ |
818 | ; \ |
819 | ::boost::scope_exit::detail::declared< \ |
820 | ::boost::scope_exit::detail::resolve< \ |
821 | sizeof(BOOST_SCOPE_EXIT_AUX_ARGS) \ |
822 | >::cmp1<0>::cmp2 \ |
823 | > BOOST_SCOPE_EXIT_AUX_ARGS; \ |
824 | BOOST_SCOPE_EXIT_AUX_ARGS.value = &BOOST_SCOPE_EXIT_AUX_PARAMS(id); \ |
825 | struct BOOST_SCOPE_EXIT_AUX_GUARD_T(id) { \ |
826 | BOOST_SCOPE_EXIT_DETAIL_PARAMS_T(id)* boost_se_params_; \ |
827 | BOOST_SCOPE_EXIT_AUX_GUARD_T(id) (void* boost_se_params) \ |
828 | : boost_se_params_( \ |
829 | (BOOST_SCOPE_EXIT_DETAIL_PARAMS_T(id)*)boost_se_params) \ |
830 | {} \ |
831 | ~BOOST_SCOPE_EXIT_AUX_GUARD_T(id)() { \ |
832 | boost_se_body( \ |
833 | BOOST_PP_LIST_FOR_EACH_I(BOOST_SCOPE_EXIT_AUX_ARG, id, \ |
834 | BOOST_SCOPE_EXIT_AUX_TRAITS_CAPTURES(traits)) \ |
835 | BOOST_PP_COMMA_IF(BOOST_PP_BITAND(BOOST_PP_LIST_IS_CONS( \ |
836 | BOOST_SCOPE_EXIT_AUX_TRAITS_CAPTURES(traits)), \ |
837 | BOOST_SCOPE_EXIT_AUX_TRAITS_HAS_THIS(traits))) \ |
838 | BOOST_PP_EXPR_IIF(BOOST_SCOPE_EXIT_AUX_TRAITS_HAS_THIS( \ |
839 | traits), \ |
840 | boost_se_params_->BOOST_SCOPE_EXIT_DETAIL_PARAM_THIS(id) \ |
841 | ) \ |
842 | ); \ |
843 | } \ |
844 | static void boost_se_body( \ |
845 | BOOST_PP_LIST_FOR_EACH_I(BOOST_SCOPE_EXIT_AUX_ARG_DECL, (id, ty), \ |
846 | BOOST_SCOPE_EXIT_AUX_TRAITS_CAPTURES(traits)) \ |
847 | BOOST_PP_COMMA_IF(BOOST_PP_BITAND(BOOST_PP_LIST_IS_CONS( \ |
848 | BOOST_SCOPE_EXIT_AUX_TRAITS_CAPTURES(traits)), \ |
849 | BOOST_SCOPE_EXIT_AUX_TRAITS_HAS_THIS(traits))) \ |
850 | BOOST_PP_EXPR_IIF(BOOST_SCOPE_EXIT_AUX_TRAITS_HAS_THIS(traits), \ |
851 | ty BOOST_SCOPE_EXIT_DETAIL_PARAMS_T(id):: \ |
852 | BOOST_SCOPE_EXIT_AUX_THIS_T(id) this_ \ |
853 | ) \ |
854 | ) |
855 | |
856 | #endif // Using lambdas. |
857 | |
858 | // PUBLIC // |
859 | |
860 | #if defined(BOOST_NO_CXX11_VARIADIC_MACROS) // No variadic macros (sequences only). |
861 | # define BOOST_SCOPE_EXIT_ID(id, void_or_seq) \ |
862 | BOOST_SCOPE_EXIT_AUX_IMPL(id, BOOST_PP_EMPTY(), \ |
863 | BOOST_SCOPE_EXIT_AUX_TRAITS( \ |
864 | BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST(void_or_seq))) |
865 | # define BOOST_SCOPE_EXIT_ID_TPL(id, void_or_seq) \ |
866 | BOOST_SCOPE_EXIT_AUX_IMPL(id, typename, \ |
867 | BOOST_SCOPE_EXIT_AUX_TRAITS( \ |
868 | BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST(void_or_seq))) |
869 | # define BOOST_SCOPE_EXIT(void_or_seq) \ |
870 | BOOST_SCOPE_EXIT_ID(BOOST_SCOPE_EXIT_AUX_PP_LINE_COUNTER, \ |
871 | void_or_seq) |
872 | # define BOOST_SCOPE_EXIT_TPL(void_or_seq) \ |
873 | BOOST_SCOPE_EXIT_ID_TPL(BOOST_SCOPE_EXIT_AUX_PP_LINE_COUNTER, \ |
874 | void_or_seq) |
875 | # if !defined(BOOST_NO_CXX11_LAMBDAS) |
876 | # define BOOST_SCOPE_EXIT_ALL_ID(id, seq) \ |
877 | BOOST_SCOPE_EXIT_AUX_IMPL_LAMBDA(id, \ |
878 | /* C++11 allows to use typename outside templates so */ \ |
879 | /* always typename here and no need for ..._ALL_TPL */ \ |
880 | /* (if a C++11 compiler does not implement this use of */ \ |
881 | /* typename, always use `this` instead of `this_`) */ \ |
882 | typename, \ |
883 | BOOST_SCOPE_EXIT_AUX_TRAITS_ALL( \ |
884 | BOOST_SCOPE_EXIT_AUX_PP_NON_VOID_LIST(seq))) |
885 | # define BOOST_SCOPE_EXIT_ALL(seq) \ |
886 | BOOST_SCOPE_EXIT_ALL_ID( \ |
887 | BOOST_SCOPE_EXIT_AUX_PP_LINE_COUNTER, seq) |
888 | # endif |
889 | #else // Variadic macros (both sequences and variadic tuples). |
890 | # define BOOST_SCOPE_EXIT_ID(id, ...) \ |
891 | BOOST_SCOPE_EXIT_AUX_IMPL(id, BOOST_PP_EMPTY(), \ |
892 | BOOST_SCOPE_EXIT_AUX_TRAITS( \ |
893 | BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST(__VA_ARGS__))) |
894 | # define BOOST_SCOPE_EXIT_ID_TPL(id, ...) \ |
895 | BOOST_SCOPE_EXIT_AUX_IMPL(id, typename, \ |
896 | BOOST_SCOPE_EXIT_AUX_TRAITS( \ |
897 | BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST(__VA_ARGS__))) |
898 | # define BOOST_SCOPE_EXIT(...) \ |
899 | BOOST_SCOPE_EXIT_ID(BOOST_SCOPE_EXIT_AUX_PP_LINE_COUNTER, \ |
900 | __VA_ARGS__) |
901 | # define BOOST_SCOPE_EXIT_TPL(...) \ |
902 | BOOST_SCOPE_EXIT_ID_TPL(BOOST_SCOPE_EXIT_AUX_PP_LINE_COUNTER, \ |
903 | __VA_ARGS__) |
904 | # if !defined(BOOST_NO_CXX11_LAMBDAS) |
905 | # define BOOST_SCOPE_EXIT_ALL_ID(id, ...) \ |
906 | BOOST_SCOPE_EXIT_AUX_IMPL_LAMBDA(id, \ |
907 | /* C++11 allows to use typename outside templates so */ \ |
908 | /* always typename here and no need for ..._ALL_TPL */ \ |
909 | /* (if a C++11 compiler does not implement this use of */ \ |
910 | /* typename, always use `this` instead of `this_`) */ \ |
911 | typename, \ |
912 | BOOST_SCOPE_EXIT_AUX_TRAITS_ALL( \ |
913 | BOOST_SCOPE_EXIT_AUX_PP_NON_VOID_LIST( \ |
914 | __VA_ARGS__))) |
915 | # define BOOST_SCOPE_EXIT_ALL(...) \ |
916 | BOOST_SCOPE_EXIT_ALL_ID( \ |
917 | BOOST_SCOPE_EXIT_AUX_PP_LINE_COUNTER, __VA_ARGS__) |
918 | # endif |
919 | #endif // Variadics. |
920 | |
921 | #if defined(BOOST_SCOPE_EXIT_CONFIG_USE_LAMBDAS) && \ |
922 | !defined(BOOST_NO_CXX11_LAMBDAS) // Use lambdas for SCOPE_EXIT (not just ALL). |
923 | # define BOOST_SCOPE_EXIT_END_ID(id) \ |
924 | ; /* lambdas ended with just `;` */ |
925 | #else // Not using lambdas. |
926 | # define BOOST_SCOPE_EXIT_END_ID(id) \ |
927 | } BOOST_SCOPE_EXIT_AUX_GUARD(id)(BOOST_SCOPE_EXIT_AUX_ARGS.value); |
928 | #endif // Using lambdas. |
929 | #define BOOST_SCOPE_EXIT_END \ |
930 | BOOST_SCOPE_EXIT_END_ID(BOOST_SCOPE_EXIT_AUX_PP_LINE_COUNTER) |
931 | |
932 | // DOCUMENTATION // |
933 | |
934 | #else // DOXYGEN |
935 | |
936 | /** @file |
937 | @brief Scope exits allow to execute arbitrary code when the enclosing scope |
938 | exits. |
939 | */ |
940 | |
941 | /** |
942 | @brief This macro declares a scope exit. |
943 | |
944 | The scope exit declaration schedules the execution of the scope exit body at |
945 | the exit of the enclosing scope: |
946 | |
947 | @code |
948 | { // Some local scope. |
949 | ... |
950 | BOOST_SCOPE_EXIT(capture_list) { |
951 | ... // Body code. |
952 | } BOOST_SCOPE_EXIT_END |
953 | ... |
954 | } |
955 | @endcode |
956 | |
957 | The enclosing scope must be local. |
958 | If multiple scope exits are declared within the same enclosing scope, the scope |
959 | exit bodies are executed in the reversed order of their declarations. |
960 | Note how the end of the scope exit body must be marked by |
961 | @RefMacro{BOOST_SCOPE_EXIT_END}. |
962 | |
963 | @Params |
964 | @Param{capture_list, |
965 | On compilers that support variadic macros (see also Boost.Config |
966 | <c>BOOST_NO_CXX11_VARIADIC_MACROS</c>)\, the capture list syntax is defined by the |
967 | following grammar: |
968 | @code |
969 | capture_list: |
970 | void | capture_tuple | capture_sequence |
971 | capture_tuple: |
972 | capture\, capture\, ... |
973 | capture_sequence: |
974 | (capture) (capture) ... |
975 | capture: |
976 | [&]variable | this_ |
977 | @endcode |
978 | On compilers that do not support variadic macros\, <c>capture_tuple</c> cannot |
979 | be used: |
980 | @code |
981 | capture_list: |
982 | void | capture_sequence |
983 | @endcode |
984 | Furthermore\, if @RefMacro{BOOST_SCOPE_EXIT_CONFIG_USE_LAMBDAS} is defined on |
985 | C++11 compilers that support lambda functions (i.e.\, Boost.Config's <c>BOOST_NO_CXX11_LAMBDAS</c> is not defined) then a semicolon <c>;</c> can be used instead of |
986 | @RefMacro{BOOST_SCOPE_EXIT_END} and <c>this</c> can be used instead of |
987 | <c>this_</c>: |
988 | @code |
989 | capture: |
990 | [&]variable | this_ | this |
991 | @endcode |
992 | |
993 | (Lexical conventions: <c>token1 | token2</c> means either <c>token1</c> or |
994 | <c>token2</c>; <c>[token]</c> means either <c>token</c> or nothing; |
995 | <c>{expression}</c> means the tokens resulting from the expression.) |
996 | } |
997 | @EndParams |
998 | |
999 | Note that on compilers that support variadic macros (most of moder compliers |
1000 | and all C++11 compilers), the capture list can be specified as a |
1001 | comma-separated list of tokens (this is the preferred syntax). |
1002 | However, on all compilers the same macro @RefMacro{BOOST_SCOPE_EXIT} also |
1003 | allows to specify the capture list as a Boost.Preprocessor sequence of tokens |
1004 | (for supporting compilers without variadic macros and for backward compatibility with older versions of this library). |
1005 | |
1006 | The name <c>variable</c> of each captured variable must be a valid name in the |
1007 | enclosing scope and it must appear exactly once in the capture list. |
1008 | If a capture starts with the ampersand sign <c>&</c>, the corresponding |
1009 | variable will be available by reference within the scope exit body; otherwise, |
1010 | a copy of the variable will be made at the point of the scope exit declaration |
1011 | and that copy will be available inside the scope exit body (in this case, the |
1012 | variable's type must be <c>CopyConstructible</c>). |
1013 | |
1014 | From within a member function, the object <c>this</c> can be captured using the |
1015 | special name <c>this_</c> in both the capture list and the scope exit body |
1016 | (using <c>this</c> instead of <c>this_</c> in the scope exit body leads to |
1017 | undefined behaviour). |
1018 | |
1019 | It is possible to capture no variable by specifying the capture list as |
1020 | <c>void</c> (regardless of variadic macro support). |
1021 | |
1022 | Only variables listed in the capture list, static variables, <c>extern</c> |
1023 | variables, global variables, functions, and enumerations from the enclosing |
1024 | scope can be used inside the scope exit body. |
1025 | |
1026 | On various GCC versions the special macro @RefMacro{BOOST_SCOPE_EXIT_TPL} must |
1027 | be used instead of @RefMacro{BOOST_SCOPE_EXIT} within templates (to maximize |
1028 | portability, it is recommended to always use @RefMacro{BOOST_SCOPE_EXIT_TPL} |
1029 | within templates). |
1030 | |
1031 | On C++11, it is possible capture all variables in scope without listing their |
1032 | names one-by-one using the macro @RefMacro{BOOST_SCOPE_EXIT_ALL}. |
1033 | |
1034 | In general, the special macro @RefMacro{BOOST_SCOPE_EXIT_ID} must be used |
1035 | instead of @RefMacro{BOOST_SCOPE_EXIT} when it is necessary to expand multiple |
1036 | scope exit declarations on the same line. |
1037 | |
1038 | @Warning The implementation executes the scope exit body within a destructor |
1039 | thus the scope exit body must never throw in order to comply with STL exception |
1040 | safety requirements. |
1041 | |
1042 | @Note The implementation uses Boost.Typeof to automatically deduce the types of |
1043 | the captured variables. |
1044 | In order to compile code in type-of emulation mode, all types must be properly |
1045 | registered with Boost.Typeof (see the |
1046 | @RefSect{getting_started, Getting Started} section). |
1047 | |
1048 | @See @RefSect{tutorial, Tutorial} section, |
1049 | @RefSect{getting_started, Getting Started} section, |
1050 | @RefSect{no_variadic_macros, No Variadic Macros} section, |
1051 | @RefMacro{BOOST_SCOPE_EXIT_TPL}, @RefMacro{BOOST_SCOPE_EXIT_ALL}, |
1052 | @RefMacro{BOOST_SCOPE_EXIT_END}, @RefMacro{BOOST_SCOPE_EXIT_ID}. |
1053 | */ |
1054 | #define BOOST_SCOPE_EXIT(capture_list) |
1055 | |
1056 | /** |
1057 | @brief This macro is a workaround for various versions of GCC to declare scope |
1058 | exits within templates. |
1059 | |
1060 | Various versions of the GCC compiler do not compile @RefMacro{BOOST_SCOPE_EXIT} |
1061 | inside function templates. |
1062 | As a workaround, @RefMacro{BOOST_SCOPE_EXIT_TPL} should be used instead of |
1063 | @RefMacro{BOOST_SCOPE_EXIT} in these cases: |
1064 | |
1065 | @code |
1066 | { // Some local scope. |
1067 | ... |
1068 | BOOST_SCOPE_EXIT_TPL(capture_list) { |
1069 | ... // Body code. |
1070 | } BOOST_SCOPE_EXIT_END |
1071 | ... |
1072 | } |
1073 | @endcode |
1074 | |
1075 | The syntax of @RefMacro{BOOST_SCOPE_EXIT_TPL} is the exact same as the one of |
1076 | @RefMacro{BOOST_SCOPE_EXIT} (see @RefMacro{BOOST_SCOPE_EXIT} for more |
1077 | information). |
1078 | |
1079 | On C++11 compilers, @RefMacro{BOOST_SCOPE_EXIT_TPL} is not needed because |
1080 | @RefMacro{BOOST_SCOPE_EXIT} always compiles on GCC versions that support C++11. |
1081 | However, @RefMacro{BOOST_SCOPE_EXIT_TPL} is still provided on C++11 so to write code that is portable between C++03 and C++11 compilers. |
1082 | It is recommended to always use @RefMacro{BOOST_SCOPE_EXIT_TPL} within |
1083 | templates so to maximize portability. |
1084 | |
1085 | In general, the special macro @RefMacro{BOOST_SCOPE_EXIT_ID_TPL} must be used |
1086 | instead of @RefMacro{BOOST_SCOPE_EXIT_TPL} when it is necessary to expand |
1087 | multiple scope exit declarations on the same line within templates. |
1088 | |
1089 | @Note The issue in compiling scope exit declarations that some GCC versions |
1090 | have is illustrated by the following code (see also |
1091 | <a href="http://gcc.gnu.org/bugzilla/show_bug.cgi?id=37920">GCC bug 37920</a>): |
1092 | @code |
1093 | template<class T> |
1094 | void f(T const& x) { |
1095 | int i = 0; |
1096 | struct local { |
1097 | typedef __typeof__(i) typeof_i; |
1098 | typedef __typeof__(x) typeof_x; |
1099 | }; |
1100 | typedef local::typeof_i i_type; |
1101 | typedef local::typeof_x x_type; |
1102 | } |
1103 | |
1104 | int main(void) { f(0); } |
1105 | @endcode |
1106 | This can be fixed by adding <c>typename</c> in front of <c>local::typeof_i</c> |
1107 | and <c>local::typeof_x</c> (which is the approach followed by the |
1108 | implementation of the @RefMacro{BOOST_SCOPE_EXIT_TPL} macro). |
1109 | |
1110 | @Note Although @RefMacro{BOOST_SCOPE_EXIT_TPL} has the same suffix as |
1111 | <c>BOOST_TYPEOF_TPL</c>, it does not follow the Boost.Typeof convention. |
1112 | |
1113 | @See @RefSect{tutorial, Tutorial} section, @RefMacro{BOOST_SCOPE_EXIT}, |
1114 | @RefMacro{BOOST_SCOPE_EXIT_END}, @RefMacro{BOOST_SCOPE_EXIT_ID_TPL}. |
1115 | */ |
1116 | #define BOOST_SCOPE_EXIT_TPL(capture_list) |
1117 | |
1118 | /** |
1119 | @brief This macro allows to expand multiple scope exit declarations on the same |
1120 | line. |
1121 | |
1122 | This macro is equivalent to @RefMacro{BOOST_SCOPE_EXIT} but it can be expanded |
1123 | multiple times on the same line if different identifiers <c>id</c> are provided |
1124 | for each expansion (see @RefMacro{BOOST_SCOPE_EXIT} for more information). |
1125 | |
1126 | @Params |
1127 | @Param{id, |
1128 | A unique identifier token which can be concatenated by the preprocessor |
1129 | (<c>__LINE__</c>\, <c>scope_exit_number_1_on_line_123</c>\, a combination of |
1130 | alphanumeric tokens\, etc). |
1131 | } |
1132 | @Param{capture_list, |
1133 | Same as the <c>capture_list</c> parameter of the @RefMacro{BOOST_SCOPE_EXIT} |
1134 | macro. |
1135 | } |
1136 | @EndParams |
1137 | |
1138 | @Note This macro can be useful when the scope exit macros are expanded |
1139 | within user-defined macros (because nested macros expand on the same line). |
1140 | On some compilers (e.g., MSVC which supports the non standard |
1141 | <c>__COUNTER__</c> macro) it might not be necessary to use this macro but |
1142 | the use of this macro is always necessary to ensure portability when expanding |
1143 | multiple scope exit declarations on the same line. |
1144 | |
1145 | @See @RefSect{tutorial, Tutorial} section, @RefMacro{BOOST_SCOPE_EXIT}, |
1146 | @RefMacro{BOOST_SCOPE_EXIT_END_ID}, @RefMacro{BOOST_SCOPE_EXIT_ALL_ID}, |
1147 | @RefMacro{BOOST_SCOPE_EXIT_ID_TPL}. |
1148 | */ |
1149 | #define BOOST_SCOPE_EXIT_ID(id, capture_list) |
1150 | |
1151 | /** |
1152 | @brief This macro is required to expand multiple scope exit declarations on the |
1153 | same line within templates on various versions of GCC. |
1154 | |
1155 | This macro is equivalent to @RefMacro{BOOST_SCOPE_EXIT_TPL} but it can be |
1156 | expanded multiple times on the same line if different identifiers <c>id</c> are |
1157 | provided for each expansion (see @RefMacro{BOOST_SCOPE_EXIT_TPL} for more |
1158 | information). |
1159 | As with @RefMacro{BOOST_SCOPE_EXIT_TPL}, it is recommended to always use this |
1160 | macro when expanding scope exits multiple times on the same line within |
1161 | templates. |
1162 | |
1163 | @Params |
1164 | @Param{id, |
1165 | A unique identifier token which can be concatenated by the preprocessor |
1166 | (<c>__LINE__</c>\, <c>scope_exit_number_1_on_line_123</c>\, a combination of |
1167 | alphanumeric tokens\, etc). |
1168 | } |
1169 | @Param{capture_list, |
1170 | Same as the <c>capture_list</c> parameter of the |
1171 | @RefMacro{BOOST_SCOPE_EXIT_TPL} macro. |
1172 | } |
1173 | @EndParams |
1174 | |
1175 | @Note This macro can be useful when the scope exit macros are expanded |
1176 | within user-defined macros (because nested macros expand on the same line). |
1177 | On some compilers (e.g., MSVC which supports the non standard |
1178 | <c>__COUNTER__</c> macro) it might not be necessary to use this macro but |
1179 | the use of this macro is always necessary to ensure portability when expanding |
1180 | multiple scope exit declarations on the same line. |
1181 | |
1182 | @See @RefSect{tutorial, Tutorial} section, @RefMacro{BOOST_SCOPE_EXIT_TPL}, |
1183 | @RefMacro{BOOST_SCOPE_EXIT_END_ID}, @RefMacro{BOOST_SCOPE_EXIT_ID}, |
1184 | @RefMacro{BOOST_SCOPE_EXIT_ALL_ID}. |
1185 | */ |
1186 | #define BOOST_SCOPE_EXIT_ID_TPL(id, capture_list) |
1187 | |
1188 | /** |
1189 | @brief This macro declares a scope exit that captures all variables in scope |
1190 | (C++11 only). |
1191 | |
1192 | This macro accepts a capture list starting with either <c>&</c> or <c>=</c> to capture all variables in scope by reference or value respectively (following the same syntax of C++11 lambdas). |
1193 | A part from that, this macro works like @RefMacro{BOOST_SCOPE_EXIT} (see @RefMacro{BOOST_SCOPE_EXIT} for more information): |
1194 | |
1195 | @code |
1196 | { // Some local scope. |
1197 | ... |
1198 | BOOST_SCOPE_EXIT_ALL(capture_list) { // C++11 only. |
1199 | ... // Body code. |
1200 | }; // Use `;` instead of `BOOST_SCOPE_EXIT_END` (C++11 only). |
1201 | ... |
1202 | } |
1203 | @endcode |
1204 | |
1205 | Note how the end of the scope exit body declared by this macro must be marked |
1206 | by a semi-column <c>;</c> (and not by @RefMacro{BOOST_SCOPE_EXIT_END}). |
1207 | |
1208 | @Warning This macro is only available on C++11 compilers (specifically, on |
1209 | C++11 compilers that do not define the Boost.Config <c>BOOST_NO_CXX11_LAMBDAS</c> |
1210 | macro). |
1211 | It is not defined on non-C++11 compilers so its use on non-C++11 compilers will generate a compiler error. |
1212 | |
1213 | @Params |
1214 | @Param{capture_list, |
1215 | On compilers that support variadic macros (see also Boost.Config |
1216 | <c>BOOST_NO_CXX11_VARIADIC_MACROS</c>)\, the capture list syntax is defined by the |
1217 | following grammar: |
1218 | @code |
1219 | capture_list: |
1220 | capture_tuple | capture_sequence |
1221 | capture_tuple: |
1222 | {& | =} [\, capture\, capture\, ...] |
1223 | capture_sequence: |
1224 | {(&) | (=)} [(capture) (capture) ...] |
1225 | capture: |
1226 | [&]variable | this_ |
1227 | @endcode |
1228 | On compilers that do not support variadic macros\, <c>capture_tuple</c> cannot |
1229 | be used: |
1230 | @code |
1231 | capture_list: |
1232 | void | capture_sequence |
1233 | @endcode |
1234 | Furthermore\, on C++11 compilers that support the use of <c>typename</c> |
1235 | outside templates\, also <c>this</c> can be used to capture the object at member |
1236 | function scope: |
1237 | @code |
1238 | capture: |
1239 | [&]variable | this_ | this |
1240 | @endcode |
1241 | |
1242 | (Lexical conventions: <c>token1 | token2</c> means either <c>token1</c> or |
1243 | <c>token2</c>; <c>[token]</c> means either <c>token</c> or nothing; |
1244 | <c>{expression}</c> means the token resulting from the expression.) |
1245 | } |
1246 | @EndParams |
1247 | |
1248 | Note that on compilers with variadic macro support (which should be all C++11 |
1249 | compilers), the capture list can be specified as a comma-separated list. |
1250 | On all compilers, the same macro @RefMacro{BOOST_SCOPE_EXIT_ALL} also allows to |
1251 | specify the capture list as a Boost.Preprocessor sequence. |
1252 | |
1253 | The capture list must always contain at least the leading <c>&</c> or <c>=</c> |
1254 | so it can never be <c>void</c> (<c>BOOST_SCOPE_EXIT(void)</c> should be used |
1255 | to program scope exits with an empty capture list). |
1256 | |
1257 | In general, the special macro @RefMacro{BOOST_SCOPE_EXIT_ALL_ID} must be used |
1258 | instead of @RefMacro{BOOST_SCOPE_EXIT_ALL} when it is necessary to expand |
1259 | multiple scope exit declarations on the same line. |
1260 | |
1261 | @Warning This macro capture list follows the exact same syntax of C++11 lambda |
1262 | captures which is unfortunately different from the syntax of |
1263 | @RefMacro{BOOST_SCOPE_EXIT} captures (unless programmers define the |
1264 | @RefMacro{BOOST_SCOPE_EXIT_CONFIG_USE_LAMBDAS} macro). |
1265 | For example, like C++11 lambda functions, @RefMacro{BOOST_SCOPE_EXIT_ALL} |
1266 | requires to capture data members by capturing the object <c>this</c> while |
1267 | @RefMacro{BOOST_SCOPE_EXIT} allows to capture data members directly and without |
1268 | capturing the object. |
1269 | |
1270 | @Warning The implementation executes the scope exit body within a destructor |
1271 | thus the scope exit body must never throw in order to comply with STL exception |
1272 | safety requirements. |
1273 | |
1274 | @Note This macro can always be used also within templates (so there is no need |
1275 | for a <c>BOOST_SCOPE_EXIT_ALL_TPL</c> macro). |
1276 | |
1277 | @See @RefSect{tutorial, Tutorial} section, |
1278 | @RefSect{no_variadic_macros, No Variadic Macros} section, |
1279 | @RefMacro{BOOST_SCOPE_EXIT}, @RefMacro{BOOST_SCOPE_EXIT_ALL_ID}. |
1280 | */ |
1281 | #define BOOST_SCOPE_EXIT_ALL(capture_list) |
1282 | |
1283 | /** |
1284 | @brief This macro allows to expand on the same line multiple scope exits that |
1285 | capture all variables in scope (C++11 only). |
1286 | |
1287 | This macro is equivalent to @RefMacro{BOOST_SCOPE_EXIT_ALL} but it can be |
1288 | expanded multiple times on the same line if different identifiers <c>id</c> are |
1289 | provided for each expansion (see @RefMacro{BOOST_SCOPE_EXIT_ALL} for more |
1290 | information). |
1291 | As with @RefMacro{BOOST_SCOPE_EXIT_ALL}, this macro is only available on C++11 |
1292 | compilers (specifically, on C++11 compilers that do not define the |
1293 | Boost.Config <c>BOOST_NO_CXX11_LAMBDAS</c> macro). |
1294 | |
1295 | @Params |
1296 | @Param{id, |
1297 | A unique identifier token which can be concatenated by the preprocessor |
1298 | (<c>__LINE__</c>\, <c>scope_exit_number_1_on_line_123</c>\, a combination of |
1299 | alphanumeric tokens\, etc). |
1300 | } |
1301 | @Param{capture_list, |
1302 | Same as the <c>capture_list</c> parameter of the |
1303 | @RefMacro{BOOST_SCOPE_EXIT_ALL} macro. |
1304 | } |
1305 | @EndParams |
1306 | |
1307 | @Note This macro can be useful when the scope exit macros are expanded |
1308 | within user-defined macros (because nested macros expand on the same line). |
1309 | On some compilers (e.g., MSVC which supports the non standard |
1310 | <c>__COUNTER__</c> macro) it might not be necessary to use this macro but |
1311 | the use of this macro is always necessary to ensure portability when expanding |
1312 | multiple scope exit declarations on the same line. |
1313 | |
1314 | @See @RefSect{tutorial, Tutorial} section, @RefMacro{BOOST_SCOPE_EXIT_ALL}, |
1315 | @RefMacro{BOOST_SCOPE_EXIT_ID}. |
1316 | */ |
1317 | #define BOOST_SCOPE_EXIT_ALL_ID(id, capture_list) |
1318 | |
1319 | /** |
1320 | @brief This macro marks the end of a scope exit body. |
1321 | |
1322 | This macro must follow the closing curly bracket <c>}</c> that ends the body of |
1323 | either @RefMacro{BOOST_SCOPE_EXIT} or @RefMacro{BOOST_SCOPE_EXIT_TPL}: |
1324 | |
1325 | @code |
1326 | { // Some local scope. |
1327 | ... |
1328 | BOOST_SCOPE_EXIT(capture_list) { |
1329 | ... // Body code. |
1330 | } BOOST_SCOPE_EXIT_END |
1331 | ... |
1332 | } |
1333 | @endcode |
1334 | |
1335 | In general, the special macro @RefMacro{BOOST_SCOPE_EXIT_END_ID} must be used |
1336 | instead of @RefMacro{BOOST_SCOPE_EXIT_END} when it is necessary to expand |
1337 | multiple scope exit bodies on the same line. |
1338 | |
1339 | @Note If programmers define the @RefMacro{BOOST_SCOPE_EXIT_CONFIG_USE_LAMBDAS} |
1340 | macro on C++11 compilers, a semicolon <c>;</c> can be used instead of this |
1341 | macro. |
1342 | However, to maximize portability, it is recommended to always use |
1343 | @RefMacro{BOOST_SCOPE_EXIT_END}. |
1344 | |
1345 | @See @RefSect{tutorial, Tutorial} section, @RefMacro{BOOST_SCOPE_EXIT}, |
1346 | @RefMacro{BOOST_SCOPE_EXIT_TPL}, @RefMacro{BOOST_SCOPE_EXIT_END_ID}. |
1347 | */ |
1348 | #define BOOST_SCOPE_EXIT_END |
1349 | |
1350 | /** |
1351 | @brief This macro allows to terminate multiple scope exit bodies on the same |
1352 | line. |
1353 | |
1354 | This macro is equivalent to @RefMacro{BOOST_SCOPE_EXIT_END} but it can be |
1355 | expanded multiple times on the same line if different identifiers <c>id</c> are |
1356 | provided for each expansion (see @RefMacro{BOOST_SCOPE_EXIT_END} for more |
1357 | information). |
1358 | |
1359 | @Params |
1360 | @Param{id, |
1361 | A unique identifier token which can be concatenated by the preprocessor |
1362 | (<c>__LINE__</c>\, <c>scope_exit_number_1_on_line_123</c>\, a combination of |
1363 | alphanumeric tokens\, etc). |
1364 | } |
1365 | @EndParams |
1366 | |
1367 | @Note This macro can be useful when the scope exit macros are expanded |
1368 | within user-defined macros (because macros all expand on the same line). |
1369 | On some compilers (e.g., MSVC which supports the non standard |
1370 | <c>__COUNTER__</c> macro) it might not be necessary to use this macro but |
1371 | the use of this macro is always necessary to ensure portability when expanding |
1372 | multiple scope exit macros on the same line (because this library can only |
1373 | portably use <c>__LINE__</c> to internally generate unique identifiers). |
1374 | |
1375 | @See @RefMacro{BOOST_SCOPE_EXIT_ID}, @RefMacro{BOOST_SCOPE_EXIT_ID_TPL}, |
1376 | @RefMacro{BOOST_SCOPE_EXIT_END}. |
1377 | */ |
1378 | #define BOOST_SCOPE_EXIT_END_ID(id) |
1379 | |
1380 | /** |
1381 | @brief Force to use C++11 lambda functions to implement scope exits. |
1382 | |
1383 | If programmers define this configuration macro on a C++11 compiler for which |
1384 | the Boost.Config macro <c>BOOST_NO_CXX11_LAMBDAS</c> is not defined, the |
1385 | @RefMacro{BOOST_SCOPE_EXIT} and @RefMacro{BOOST_SCOPE_EXIT_TPL} macros will use |
1386 | C++11 lambda functions to declare scope exits. |
1387 | By default this macro is not defined. |
1388 | |
1389 | @Warning When scope exits are implemented using lambda functions, the syntax of |
1390 | the capture list follows the exact same syntax of C++11 lambda captures |
1391 | which is in general different from the legacy capture syntax of this library. |
1392 | For example, C++11 lambdas require to capture data members by capturing the |
1393 | object <c>this</c> while this library always allowed to capture data members |
1394 | directly. |
1395 | Therefore, when this configuration macro is defined, |
1396 | @RefMacro{BOOST_SCOPE_EXIT} and @RefMacro{BOOST_SCOPE_EXIT_TPL} are no longer |
1397 | backward compatible (and this is why this macro is not defined by default). |
1398 | |
1399 | A semicolon <c>;</c> can be used instead of @RefMacro{BOOST_SCOPE_EXIT_END} |
1400 | when this configuration macro is defined (but it is recommended to always use |
1401 | @RefMacro{BOOST_SCOPE_EXIT_END} so to maximize portability). |
1402 | |
1403 | @Note This configuration macro does not control the definition of |
1404 | @RefMacro{BOOST_SCOPE_EXIT_ALL} which is always and automatically defined on |
1405 | compilers that support C++11 lambda functions. |
1406 | |
1407 | @See @RefMacro{BOOST_SCOPE_EXIT}, @RefMacro{BOOST_SCOPE_EXIT_TPL}, |
1408 | @RefMacro{BOOST_SCOPE_EXIT_END}. |
1409 | */ |
1410 | #define BOOST_SCOPE_EXIT_CONFIG_USE_LAMBDAS |
1411 | |
1412 | #endif // DOXYGEN |
1413 | |
1414 | #endif // #ifndef FILE_boost_scope_exit_hpp_INCLUDED |
1415 | |
1416 | |