1 | // -- Boost Lambda Library -- exceptions.hpp ---------------- |
2 | // |
3 | // Copyright (C) 2000 Gary Powell (gwpowell@hotmail.com) |
4 | // Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi) |
5 | // |
6 | // Distributed under the Boost Software License, Version 1.0. (See |
7 | // accompanying file LICENSE_1_0.txt or copy at |
8 | // http://www.boost.org/LICENSE_1_0.txt) |
9 | // |
10 | // For more information, see http://www.boost.org |
11 | |
12 | // ----------------------------------------------------- |
13 | |
14 | #if !defined(BOOST_LAMBDA_EXCEPTIONS_HPP) |
15 | #define BOOST_LAMBDA_EXCEPTIONS_HPP |
16 | |
17 | #include "boost/lambda/core.hpp" |
18 | #include "boost/lambda/detail/control_constructs_common.hpp" |
19 | |
20 | namespace boost { |
21 | namespace lambda { |
22 | |
23 | typedef lambda_functor<placeholder<EXCEPTION> > placeholderE_type; |
24 | |
25 | namespace { |
26 | boost::lambda::placeholderE_type freeE; |
27 | boost::lambda::placeholderE_type& _e = freeE; |
28 | } |
29 | |
30 | // -- exception related actions ------------------- |
31 | |
32 | // catch actions. |
33 | template <class Catch1, class Catch2 = null_type, class Catch3 = null_type, |
34 | class Catch4 = null_type, class Catch5 = null_type, |
35 | class Catch6 = null_type, class Catch7 = null_type, |
36 | class Catch8 = null_type, class Catch9 = null_type, |
37 | class Catch10 = null_type> |
38 | struct catch_action {}; |
39 | |
40 | struct catch_all_action {}; |
41 | |
42 | template<class CatchActions> |
43 | struct return_try_catch_action {}; |
44 | |
45 | template<class CatchActions> |
46 | struct try_catch_action {}; |
47 | |
48 | // rethrow actions |
49 | struct throw_new_action {}; |
50 | struct rethrow_action {}; |
51 | |
52 | template<class ThrowType> struct throw_action; |
53 | |
54 | template<> |
55 | struct throw_action<rethrow_action> { |
56 | template<class RET> |
57 | static RET apply() { |
58 | throw; |
59 | } |
60 | }; |
61 | |
62 | template<> struct throw_action<throw_new_action> { |
63 | template<class RET, class T> |
64 | static RET apply(T& t) { |
65 | throw t; |
66 | } |
67 | }; |
68 | |
69 | // return types for throw_actions -------------------------------------------- |
70 | |
71 | template<class T, class Any> |
72 | struct |
73 | return_type_N<throw_action<T>, Any> { |
74 | typedef void type; |
75 | }; |
76 | |
77 | |
78 | // return types deductions ------------------------------------------------- |
79 | |
80 | // the return type of try_catch is the return type of the try lambda_functor |
81 | // (the return types of try and catch parts must match unless try returns void |
82 | // or the catch part throws for sure) |
83 | |
84 | // NOTE, the exception placeholder deduction rule is defined |
85 | // in return_type_traits.hpp |
86 | |
87 | |
88 | |
89 | // defined in control_constructs |
90 | class ifthenelse_action; |
91 | |
92 | namespace detail { |
93 | |
94 | // Templates for deducing, wether a lambda_functor throws inevitably of not - |
95 | // This mechanism is needed to make the compiler happy about |
96 | // return types of try and catch parts. |
97 | |
98 | // a lambda_functor throws for sure if: |
99 | // - it is a throw expression |
100 | // - it is a comma expression, and one of its arguments throws for sure |
101 | // - it is an if_then_else expression and either the if statement or both |
102 | // the then and else throw. |
103 | // (there are other cases as well, but we do not cover them) |
104 | // e.g. _1 + (rethrow(), 3) does throw for sure but this is not checked |
105 | // This implies, that in such a case, the return types of try and catch parts |
106 | // must match if the try part returns other than void. |
107 | // (Such checks could be done though) |
108 | |
109 | template <class Arg> |
110 | struct throws_for_sure_phase2 { |
111 | static const bool value = false; |
112 | }; |
113 | |
114 | template <int N, class ThrowType, class Args> |
115 | struct throws_for_sure_phase2< |
116 | lambda_functor< |
117 | lambda_functor_base<action<N, throw_action<ThrowType> >, Args> |
118 | > |
119 | > |
120 | { |
121 | static const bool value = true; |
122 | }; |
123 | |
124 | // Both then and else or the if throw of an if_then_else. |
125 | template <class Args> |
126 | struct throws_for_sure_phase2< |
127 | lambda_functor< |
128 | lambda_functor_base< |
129 | ifthenelse_action, Args |
130 | > |
131 | > |
132 | > |
133 | { |
134 | static const bool value = |
135 | throws_for_sure_phase2< |
136 | typename boost::tuples::element<0, Args>::type>::value |
137 | || |
138 | ( |
139 | throws_for_sure_phase2< |
140 | typename boost::tuples::element<1, Args>::type |
141 | >::value |
142 | && |
143 | throws_for_sure_phase2< |
144 | typename boost::tuples::element<2, Args>::type |
145 | >::value |
146 | ); |
147 | }; |
148 | |
149 | template <class Args> |
150 | struct throws_for_sure_phase2< |
151 | lambda_functor< |
152 | lambda_functor_base< other_action<comma_action>, Args> |
153 | > |
154 | > |
155 | { |
156 | static const bool value = |
157 | throws_for_sure_phase2< |
158 | typename boost::tuples::element<0, Args>::type |
159 | >::value |
160 | || |
161 | throws_for_sure_phase2< |
162 | typename boost::tuples::element<1, Args>::type |
163 | >::value; |
164 | }; |
165 | |
166 | // get rid of any qualifiers and references |
167 | // lambda_functors should be stored like that, so this is to be extra sure |
168 | template <class Arg> |
169 | struct throws_for_sure { |
170 | static const bool value |
171 | = throws_for_sure_phase2< |
172 | typename detail::remove_reference_and_cv<Arg>::type |
173 | >::value; |
174 | }; |
175 | |
176 | |
177 | // -- return_or_throw templates ----------------------------- |
178 | |
179 | // false case, catch and try return types are incompatible |
180 | // Now the catch part must throw for sure, otherwise a compile time error |
181 | // occurs. |
182 | template<bool is_conversion> |
183 | struct return_or_throw_phase2 { |
184 | template<class RET, class Arg, CALL_TEMPLATE_ARGS> |
185 | static RET call(Arg& arg, CALL_FORMAL_ARGS) { |
186 | BOOST_STATIC_ASSERT(throws_for_sure<Arg>::value); |
187 | detail::select(arg, CALL_ACTUAL_ARGS); // this line throws |
188 | throw 1; // this line is never performed, hence 1 is just a dummy |
189 | // The line is needed to make compiler happy and not require |
190 | // a matching return type |
191 | } |
192 | }; |
193 | |
194 | // the try and catch return types are compatible |
195 | template<> |
196 | struct return_or_throw_phase2<true> { |
197 | template<class RET, class Arg, CALL_TEMPLATE_ARGS> |
198 | static RET call(Arg& arg, CALL_FORMAL_ARGS) { |
199 | return detail::select(arg, CALL_ACTUAL_ARGS); |
200 | } |
201 | }; |
202 | |
203 | |
204 | // the non-void case. Try part returns a value, so catch parts must |
205 | // return a value of the same type or throw |
206 | template<class RET, class ARG> |
207 | struct return_or_throw { |
208 | // Arg should be equal to ARG except that ARG may be a reference |
209 | // to be sure, that there are no suprises for peculiarly defined return types |
210 | // ARG is passed explicitely |
211 | template<class Arg, CALL_TEMPLATE_ARGS> |
212 | static RET call(Arg& arg, CALL_FORMAL_ARGS) |
213 | { |
214 | // typedef typename Arg::return_type<ARG, open_args<A&, B&, C&> >::type RT; |
215 | typedef typename as_lambda_functor<ARG>::type lf_type; |
216 | typedef typename lf_type::inherited::template |
217 | sig<tuple<CALL_REFERENCE_TYPES> >::type RT; |
218 | |
219 | return |
220 | return_or_throw_phase2< |
221 | ::boost::is_convertible<RT, RET>::value |
222 | >::template call<RET>(arg, CALL_ACTUAL_ARGS); |
223 | } |
224 | }; |
225 | |
226 | // if try part returns void, we do not return the catch parts either |
227 | template<class ARG> |
228 | struct return_or_throw<void, ARG> { |
229 | template<class Arg, CALL_TEMPLATE_ARGS> |
230 | static void call(Arg& arg, CALL_FORMAL_ARGS) { detail::select(arg, CALL_ACTUAL_ARGS); } |
231 | }; |
232 | |
233 | } // end detail |
234 | |
235 | // Throwing exceptions --------------------------------------------- |
236 | |
237 | namespace detail { |
238 | |
239 | template <class T> struct catch_block {}; |
240 | struct catch_all_block {}; |
241 | |
242 | template <class T> struct exception_catch_tag {}; |
243 | |
244 | // normal catch block is represented as |
245 | // tagged_lambda_functor<exception_catch_tag<catch_type<T> > >, LambdaFunctor> |
246 | |
247 | // the default catch all block as: |
248 | // tagged_lambda_functor<exception_catch_tag<catch_all_block> >, LambdaFunctor> |
249 | |
250 | |
251 | } // end detail |
252 | |
253 | // the code is RETHROW, this ensures that a compile time error results, |
254 | // if this lambda_functor is used outside a delayed catch_expression |
255 | inline const |
256 | lambda_functor< |
257 | lambda_functor_base< |
258 | action<0, throw_action<rethrow_action> >, |
259 | null_type |
260 | > |
261 | > |
262 | rethrow() { |
263 | return |
264 | lambda_functor_base< |
265 | action<0, throw_action<rethrow_action> >, |
266 | null_type |
267 | > |
268 | ( null_type() ); |
269 | } |
270 | |
271 | template <class Arg1> |
272 | inline const |
273 | lambda_functor< |
274 | lambda_functor_base< |
275 | action<1, throw_action<throw_new_action> >, |
276 | tuple<typename const_copy_argument<const Arg1>::type> |
277 | > |
278 | > |
279 | throw_exception(const Arg1& a1) { |
280 | return |
281 | lambda_functor_base< |
282 | action<1, throw_action<throw_new_action> >, |
283 | tuple<typename const_copy_argument<const Arg1>::type> |
284 | > |
285 | ( tuple<typename const_copy_argument<const Arg1>::type>(a1)); |
286 | } |
287 | |
288 | // create catch blocks |
289 | template <class CatchType, class Arg> |
290 | inline const |
291 | tagged_lambda_functor< |
292 | detail::exception_catch_tag<detail::catch_block<CatchType> >, |
293 | lambda_functor<Arg> |
294 | > |
295 | catch_exception(const lambda_functor<Arg>& a) { |
296 | // the third placeholder cannot be used in catch_exception |
297 | // BOOST_STATIC_ASSERT((!has_placeholder<Arg, THIRD>::value)); |
298 | return |
299 | tagged_lambda_functor< |
300 | detail::exception_catch_tag<detail::catch_block<CatchType> >, |
301 | lambda_functor<Arg> |
302 | > (a); |
303 | } |
304 | |
305 | // catch and do nothing case. |
306 | template <class CatchType> |
307 | inline const |
308 | tagged_lambda_functor< |
309 | detail::exception_catch_tag<detail::catch_block<CatchType> >, |
310 | lambda_functor< |
311 | lambda_functor_base< |
312 | do_nothing_action, |
313 | null_type |
314 | > |
315 | > |
316 | > |
317 | catch_exception() { |
318 | return |
319 | tagged_lambda_functor< |
320 | detail::exception_catch_tag<detail::catch_block<CatchType> >, |
321 | lambda_functor< |
322 | lambda_functor_base< |
323 | do_nothing_action, |
324 | null_type |
325 | > |
326 | > |
327 | > (); |
328 | } |
329 | |
330 | // create catch(...) blocks |
331 | template <class Arg> |
332 | inline const |
333 | tagged_lambda_functor< |
334 | detail::exception_catch_tag<detail::catch_all_block>, |
335 | lambda_functor<Arg> |
336 | > |
337 | catch_all(const lambda_functor<Arg>& a) { |
338 | // the third placeholder cannot be used in catch_exception |
339 | BOOST_STATIC_ASSERT((!has_placeholder<Arg, THIRD>::value)); |
340 | return |
341 | tagged_lambda_functor< |
342 | detail::exception_catch_tag<detail::catch_all_block>, |
343 | lambda_functor<Arg> |
344 | > (a); |
345 | } |
346 | |
347 | // catch(...) and do nothing case. |
348 | inline const |
349 | tagged_lambda_functor< |
350 | detail::exception_catch_tag<detail::catch_all_block>, |
351 | lambda_functor< |
352 | lambda_functor_base< |
353 | do_nothing_action, |
354 | null_type |
355 | > |
356 | > |
357 | > |
358 | catch_all() { |
359 | return |
360 | tagged_lambda_functor< |
361 | detail::exception_catch_tag<detail::catch_all_block>, |
362 | lambda_functor< |
363 | lambda_functor_base< |
364 | do_nothing_action, |
365 | null_type |
366 | > |
367 | > |
368 | > (); |
369 | } |
370 | |
371 | // try_catch functions -------------------------------- |
372 | // The second -> N argument(s) are must be catch lambda_functors |
373 | template <class TryArg, class Catch1, class LF1> |
374 | inline const |
375 | lambda_functor< |
376 | lambda_functor_base< |
377 | action<2, try_catch_action<catch_action<Catch1> > >, |
378 | tuple<lambda_functor<TryArg>, LF1> |
379 | > |
380 | > |
381 | try_catch( |
382 | const lambda_functor<TryArg>& a1, |
383 | const tagged_lambda_functor<detail::exception_catch_tag<Catch1>, LF1>& a2) |
384 | { |
385 | return |
386 | lambda_functor_base< |
387 | action<2, try_catch_action<catch_action<Catch1> > >, |
388 | tuple<lambda_functor<TryArg>, LF1> |
389 | > |
390 | ( tuple< lambda_functor<TryArg>, LF1>(a1, a2)); |
391 | } |
392 | |
393 | template <class TryArg, class Catch1, class LF1, |
394 | class Catch2, class LF2> |
395 | inline const |
396 | lambda_functor< |
397 | lambda_functor_base< |
398 | action<3, try_catch_action<catch_action<detail::catch_block<Catch1>, Catch2> > >, |
399 | tuple<lambda_functor<TryArg>, LF1, LF2> |
400 | > |
401 | > |
402 | try_catch( |
403 | const lambda_functor<TryArg>& a1, |
404 | const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch1> >, LF1>& a2, |
405 | const tagged_lambda_functor<detail::exception_catch_tag<Catch2>, LF2>& a3) |
406 | { |
407 | return |
408 | lambda_functor_base< |
409 | action<3, try_catch_action<catch_action<detail::catch_block<Catch1>, Catch2> > >, |
410 | tuple<lambda_functor<TryArg>, LF1, LF2> |
411 | > |
412 | ( tuple<lambda_functor<TryArg>, LF1, LF2>(a1, a2, a3)); |
413 | } |
414 | |
415 | template <class TryArg, class Catch1, class LF1, |
416 | class Catch2, class LF2, |
417 | class Catch3, class LF3> |
418 | inline const lambda_functor< |
419 | lambda_functor_base< |
420 | action<4, try_catch_action<catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>, Catch3> > >, |
421 | tuple<lambda_functor<TryArg>, LF1, LF2, LF3> |
422 | > |
423 | > |
424 | try_catch( |
425 | const lambda_functor<TryArg>& a1, |
426 | const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch1> >, LF1>& a2, |
427 | const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch2> >, LF2>& a3, |
428 | const tagged_lambda_functor<detail::exception_catch_tag<Catch3>, LF3>& a4) |
429 | { |
430 | return |
431 | lambda_functor_base< |
432 | action<4, try_catch_action<catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>, Catch3> > >, |
433 | tuple<lambda_functor<TryArg>, LF1, LF2, LF3> |
434 | > |
435 | ( tuple<lambda_functor<TryArg>, LF1, LF2, LF3>(a1, a2, a3, a4)); |
436 | } |
437 | |
438 | template <class TryArg, class Catch1, class LF1, |
439 | class Catch2, class LF2, |
440 | class Catch3, class LF3, |
441 | class Catch4, class LF4> |
442 | inline const |
443 | lambda_functor< |
444 | lambda_functor_base< |
445 | action< |
446 | 5, |
447 | try_catch_action< |
448 | catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3>, Catch4> |
449 | > |
450 | >, |
451 | tuple<lambda_functor<TryArg>, LF1, LF2, LF3, LF4> |
452 | > |
453 | > |
454 | try_catch( |
455 | const lambda_functor<TryArg>& a1, |
456 | const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch1> >, LF1>& a2, |
457 | const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch2> >, LF2>& a3, |
458 | const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch3> >, LF3>& a4, |
459 | const tagged_lambda_functor<detail::exception_catch_tag<Catch4>, LF4>& a5) |
460 | { |
461 | return |
462 | lambda_functor_base< |
463 | action< |
464 | 5, |
465 | try_catch_action<catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3>, Catch4> > |
466 | >, |
467 | tuple<lambda_functor<TryArg>, LF1, LF2, LF3, LF4> |
468 | > |
469 | ( tuple<lambda_functor<TryArg>, LF1, LF2, LF3, LF4>(a1, a2, a3, a4, a5)); |
470 | } |
471 | |
472 | template <class TryArg, class Catch1, class LF1, |
473 | class Catch2, class LF2, |
474 | class Catch3, class LF3, |
475 | class Catch4, class LF4, |
476 | class Catch5, class LF5> |
477 | inline const |
478 | lambda_functor< |
479 | lambda_functor_base< |
480 | action< |
481 | 6, |
482 | try_catch_action<catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3>, detail::catch_block<Catch4>, Catch5> > |
483 | >, |
484 | tuple<lambda_functor<TryArg>, LF1, LF2, LF3, LF4, LF5> |
485 | > |
486 | > |
487 | try_catch( |
488 | const lambda_functor<TryArg>& a1, |
489 | const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch1> >, LF1>& a2, |
490 | const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch2> >, LF2>& a3, |
491 | const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch3> >, LF3>& a4, |
492 | const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch4> >, LF4>& a5, |
493 | const tagged_lambda_functor<detail::exception_catch_tag<Catch5>, LF5>& a6) |
494 | { |
495 | return |
496 | lambda_functor_base< |
497 | action< |
498 | 6, |
499 | try_catch_action< |
500 | catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3>, detail::catch_block<Catch4>, Catch5> |
501 | > |
502 | >, |
503 | tuple<lambda_functor<TryArg>, LF1, LF2, LF3, LF4, LF5> |
504 | > |
505 | ( tuple<lambda_functor<TryArg>, LF1, LF2, LF3, LF4, LF5> |
506 | (a1, a2, a3, a4, a5, a6) |
507 | ); |
508 | } |
509 | |
510 | template <class TryArg, class Catch1, class LF1, |
511 | class Catch2, class LF2, |
512 | class Catch3, class LF3, |
513 | class Catch4, class LF4, |
514 | class Catch5, class LF5, |
515 | class Catch6, class LF6> |
516 | inline const |
517 | lambda_functor< |
518 | lambda_functor_base< |
519 | action< |
520 | 7, |
521 | try_catch_action< |
522 | catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3>, detail::catch_block<Catch4>, detail::catch_block<Catch5>, Catch6> |
523 | > |
524 | >, |
525 | tuple<lambda_functor<TryArg>, LF1, LF2, LF3, LF4, LF5, LF6> |
526 | > |
527 | > |
528 | try_catch( |
529 | const lambda_functor<TryArg>& a1, |
530 | const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch1> >, LF1>& a2, |
531 | const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch2> >, LF2>& a3, |
532 | const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch3> >, LF3>& a4, |
533 | const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch4> >, LF4>& a5, |
534 | const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch5> >, LF5>& a6, |
535 | const tagged_lambda_functor<detail::exception_catch_tag<Catch6>, LF6>& a7) |
536 | { |
537 | return |
538 | lambda_functor_base< |
539 | action< |
540 | 7, |
541 | try_catch_action< |
542 | catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3>, detail::catch_block<Catch4>, detail::catch_block<Catch5>,Catch6> |
543 | > |
544 | >, |
545 | tuple<lambda_functor<TryArg>, LF1, LF2, LF3, LF4, LF5, LF6> |
546 | > |
547 | ( tuple<lambda_functor<TryArg>, LF1, LF2, LF3, LF4, LF5, LF6> |
548 | (a1, a2, a3, a4, a5, a6, a7)); |
549 | } |
550 | |
551 | template <class TryArg, class Catch1, class LF1, |
552 | class Catch2, class LF2, |
553 | class Catch3, class LF3, |
554 | class Catch4, class LF4, |
555 | class Catch5, class LF5, |
556 | class Catch6, class LF6, |
557 | class Catch7, class LF7> |
558 | inline const |
559 | lambda_functor< |
560 | lambda_functor_base< |
561 | action< |
562 | 8, |
563 | try_catch_action< |
564 | catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3>, detail::catch_block<Catch4>, detail::catch_block<Catch5>, detail::catch_block<Catch6>, Catch7> |
565 | > |
566 | >, |
567 | tuple<lambda_functor<TryArg>, LF1, LF2, LF3, LF4, LF5, LF6, LF7> |
568 | > |
569 | > |
570 | try_catch( |
571 | const lambda_functor<TryArg>& a1, |
572 | const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch1> >, LF1>& a2, |
573 | const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch2> >, LF2>& a3, |
574 | const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch3> >, LF3>& a4, |
575 | const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch4> >, LF4>& a5, |
576 | const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch5> >, LF5>& a6, |
577 | const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch6> >, LF6>& a7, |
578 | const tagged_lambda_functor<detail::exception_catch_tag<Catch7>, LF7>& a8) |
579 | { |
580 | return |
581 | lambda_functor_base< |
582 | action< |
583 | 8, |
584 | try_catch_action< |
585 | catch_action< |
586 | detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3>, detail::catch_block<Catch4>, detail::catch_block<Catch5>, detail::catch_block<Catch6>, Catch7 |
587 | > |
588 | > |
589 | >, |
590 | tuple<lambda_functor<TryArg>, LF1, LF2, LF3, LF4, LF5, LF6, LF7> |
591 | > |
592 | ( tuple<lambda_functor<TryArg>, LF1, LF2, LF3, LF4, LF5, LF6, LF7> |
593 | (a1, a2, a3, a4, a5, a6, a7, a8)); |
594 | } |
595 | |
596 | template <class TryArg, class Catch1, class LF1, |
597 | class Catch2, class LF2, |
598 | class Catch3, class LF3, |
599 | class Catch4, class LF4, |
600 | class Catch5, class LF5, |
601 | class Catch6, class LF6, |
602 | class Catch7, class LF7, |
603 | class Catch8, class LF8> |
604 | inline const |
605 | lambda_functor< |
606 | lambda_functor_base< |
607 | action< |
608 | 9, |
609 | try_catch_action< |
610 | catch_action< |
611 | detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3>, detail::catch_block<Catch4>, detail::catch_block<Catch5>, detail::catch_block<Catch6>, detail::catch_block<Catch7>, Catch8 |
612 | > |
613 | > |
614 | >, |
615 | tuple<lambda_functor<TryArg>, LF1, LF2, LF3, LF4, LF5, LF6, LF7, LF8> |
616 | > |
617 | > |
618 | try_catch( |
619 | const lambda_functor<TryArg>& a1, |
620 | const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch1> >, LF1>& a2, |
621 | const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch2> >, LF2>& a3, |
622 | const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch3> >, LF3>& a4, |
623 | const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch4> >, LF4>& a5, |
624 | const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch5> >, LF5>& a6, |
625 | const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch6> >, LF6>& a7, |
626 | const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch7> >, LF7>& a8, |
627 | const tagged_lambda_functor<detail::exception_catch_tag<Catch8>, LF8>& a9) |
628 | { |
629 | return |
630 | lambda_functor_base< |
631 | action< |
632 | 9, |
633 | try_catch_action< |
634 | catch_action< |
635 | detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3>, detail::catch_block<Catch4>, detail::catch_block<Catch5>, detail::catch_block<Catch6>, detail::catch_block<Catch7>, Catch8 |
636 | > |
637 | > |
638 | >, |
639 | tuple<lambda_functor<TryArg>, LF1, LF2, LF3, LF4, LF5, LF6, LF7, LF8> |
640 | > |
641 | ( tuple<lambda_functor<TryArg>, LF1, LF2, LF3, LF4, LF5, LF6, LF7, LF8> |
642 | (a1, a2, a3, a4, a5, a6, a7, a8, a9)); |
643 | } |
644 | |
645 | template <class TryArg, class Catch1, class LF1, |
646 | class Catch2, class LF2, |
647 | class Catch3, class LF3, |
648 | class Catch4, class LF4, |
649 | class Catch5, class LF5, |
650 | class Catch6, class LF6, |
651 | class Catch7, class LF7, |
652 | class Catch8, class LF8, |
653 | class Catch9, class LF9> |
654 | inline const |
655 | lambda_functor< |
656 | lambda_functor_base< |
657 | action< |
658 | 10, |
659 | try_catch_action< |
660 | catch_action< |
661 | detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3>, detail::catch_block<Catch4>, detail::catch_block<Catch5>, detail::catch_block<Catch6>, detail::catch_block<Catch7>, detail::catch_block<Catch8>, |
662 | Catch9 |
663 | > |
664 | > |
665 | >, |
666 | tuple< |
667 | lambda_functor<TryArg>, LF1, LF2, LF3, LF4, LF5, LF6, LF7, LF8, LF9 |
668 | > |
669 | > |
670 | > |
671 | try_catch( |
672 | const lambda_functor<TryArg>& a1, |
673 | const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch1> >, LF1>& a2, |
674 | const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch2> >, LF2>& a3, |
675 | const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch3> >, LF3>& a4, |
676 | const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch4> >, LF4>& a5, |
677 | const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch5> >, LF5>& a6, |
678 | const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch6> >, LF6>& a7, |
679 | const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch7> >, LF7>& a8, |
680 | const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch8> >, LF8>& a9, |
681 | const tagged_lambda_functor<detail::exception_catch_tag<Catch9>, LF9>& a10) |
682 | { |
683 | return |
684 | lambda_functor_base< |
685 | action< |
686 | 10, |
687 | try_catch_action< |
688 | catch_action< |
689 | detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3>, detail::catch_block<Catch4>, detail::catch_block<Catch5>, detail::catch_block<Catch6>, detail::catch_block<Catch7>, detail::catch_block<Catch8>, |
690 | Catch9 |
691 | > |
692 | > |
693 | >, |
694 | tuple< |
695 | lambda_functor<TryArg>, LF1, LF2, LF3, LF4, LF5, LF6, LF7, LF8, LF9 |
696 | > |
697 | > |
698 | ( tuple< |
699 | lambda_functor<TryArg>, LF1, LF2, LF3, LF4, LF5, LF6, LF7, LF8, LF9 |
700 | >(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)); |
701 | } |
702 | |
703 | |
704 | // --------------------------------------------------------------------------- |
705 | // Specializations for lambda_functor_base of try_catch ---------------------- |
706 | |
707 | // 1 catch type case |
708 | |
709 | template<class Args, class Catch1> |
710 | class lambda_functor_base< |
711 | action<2, try_catch_action<catch_action<detail::catch_block<Catch1> > > >, |
712 | Args |
713 | > |
714 | { |
715 | public: |
716 | Args args; |
717 | public: |
718 | explicit lambda_functor_base(const Args& a) : args(a) {} |
719 | |
720 | // the return type of try_catch is the return type of the try lambda_functor |
721 | // (the return types of try and catch parts must match unless try returns void |
722 | // or the catch part throws for sure) |
723 | |
724 | template <class SigArgs> struct sig { |
725 | typedef typename |
726 | as_lambda_functor< |
727 | typename boost::tuples::element<0, Args>::type |
728 | >::type lf_type; |
729 | |
730 | typedef typename lf_type::inherited::template sig<SigArgs>::type type; |
731 | }; |
732 | |
733 | template<class RET, CALL_TEMPLATE_ARGS> |
734 | RET call(CALL_FORMAL_ARGS) const { |
735 | try |
736 | { |
737 | return detail::select(::boost::tuples::get<0>(args), CALL_ACTUAL_ARGS); |
738 | } |
739 | catch (Catch1& e) |
740 | { |
741 | return |
742 | detail::return_or_throw<RET, typename ::boost::tuples::element<1, Args>::type> |
743 | ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
744 | } |
745 | } |
746 | }; |
747 | |
748 | |
749 | |
750 | template<class Args> |
751 | class lambda_functor_base<action<2, try_catch_action<catch_action<detail::catch_all_block> > >, Args> { |
752 | public: |
753 | Args args; |
754 | public: |
755 | explicit lambda_functor_base(const Args& a) : args(a) {} |
756 | |
757 | template <class SigArgs> struct sig { |
758 | typedef typename |
759 | as_lambda_functor< |
760 | typename boost::tuples::element<0, Args>::type |
761 | >::type lf_type; |
762 | |
763 | typedef typename lf_type::inherited::template sig<SigArgs>::type type; |
764 | }; |
765 | |
766 | template<class RET, CALL_TEMPLATE_ARGS> |
767 | RET call(CALL_FORMAL_ARGS) const { |
768 | try |
769 | { |
770 | return detail::select(::boost::tuples::get<0>(args), CALL_ACTUAL_ARGS); |
771 | } |
772 | catch (...) |
773 | { |
774 | return |
775 | detail::return_or_throw<RET, typename ::boost::tuples::element<1, Args>::type> |
776 | ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS); |
777 | } |
778 | } |
779 | }; |
780 | |
781 | |
782 | // 2 catch types case |
783 | template<class Args, class Catch1, class Catch2> |
784 | class lambda_functor_base<action<3, try_catch_action<catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2> > > >, Args> { |
785 | public: |
786 | Args args; |
787 | public: |
788 | explicit lambda_functor_base(const Args& a) : args(a) {} |
789 | |
790 | template <class SigArgs> struct sig { |
791 | typedef typename |
792 | as_lambda_functor< |
793 | typename boost::tuples::element<0, Args>::type |
794 | >::type lf_type; |
795 | |
796 | typedef typename lf_type::inherited::template sig<SigArgs>::type type; |
797 | }; |
798 | |
799 | template<class RET, CALL_TEMPLATE_ARGS> |
800 | RET call(CALL_FORMAL_ARGS) const { |
801 | try |
802 | { |
803 | return detail::select(::boost::tuples::get<0>(args), CALL_ACTUAL_ARGS); |
804 | } |
805 | catch (Catch1& e) |
806 | { |
807 | return |
808 | detail::return_or_throw<RET, typename ::boost::tuples::element<1, Args>::type> |
809 | ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
810 | } |
811 | catch (Catch2& e) |
812 | { |
813 | return |
814 | detail::return_or_throw<RET, typename ::boost::tuples::element<2, Args>::type> |
815 | ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
816 | } |
817 | } |
818 | }; |
819 | |
820 | template<class Args, class Catch1> |
821 | class lambda_functor_base<action<3, try_catch_action<catch_action<detail::catch_block<Catch1>,detail::catch_all_block> > >, Args> { |
822 | public: |
823 | Args args; |
824 | public: |
825 | explicit lambda_functor_base(const Args& a) : args(a) {} |
826 | |
827 | template <class SigArgs> struct sig { |
828 | typedef typename |
829 | as_lambda_functor< |
830 | typename boost::tuples::element<0, Args>::type |
831 | >::type lf_type; |
832 | |
833 | typedef typename lf_type::inherited::template sig<SigArgs>::type type; |
834 | }; |
835 | |
836 | template<class RET, CALL_TEMPLATE_ARGS> |
837 | RET call(CALL_FORMAL_ARGS) const { |
838 | try |
839 | { |
840 | return detail::select(::boost::tuples::get<0>(args), CALL_ACTUAL_ARGS); |
841 | } |
842 | catch (Catch1& e) |
843 | { |
844 | return |
845 | detail::return_or_throw<RET, typename ::boost::tuples::element<1, Args>::type> |
846 | ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
847 | } |
848 | catch (...) |
849 | { |
850 | return |
851 | detail::return_or_throw<RET, typename ::boost::tuples::element<2, Args>::type> |
852 | ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS); |
853 | } |
854 | } |
855 | }; |
856 | |
857 | // 3 catch types case |
858 | template<class Args, class Catch1, class Catch2, class Catch3> |
859 | class lambda_functor_base<action<4, try_catch_action<catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3> > > >, Args> { |
860 | public: |
861 | Args args; |
862 | public: |
863 | explicit lambda_functor_base(const Args& a) : args(a) {} |
864 | |
865 | template <class SigArgs> struct sig { |
866 | typedef typename |
867 | as_lambda_functor< |
868 | typename boost::tuples::element<0, Args>::type |
869 | >::type lf_type; |
870 | |
871 | typedef typename lf_type::inherited::template sig<SigArgs>::type type; |
872 | }; |
873 | |
874 | template<class RET, CALL_TEMPLATE_ARGS> |
875 | RET call(CALL_FORMAL_ARGS) const { |
876 | try |
877 | { |
878 | return detail::select(::boost::tuples::get<0>(args), CALL_ACTUAL_ARGS); |
879 | } |
880 | catch (Catch1& e) |
881 | { |
882 | return |
883 | detail::return_or_throw<RET, typename ::boost::tuples::element<1, Args>::type> |
884 | ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
885 | |
886 | } |
887 | catch (Catch2& e) |
888 | { |
889 | return |
890 | detail::return_or_throw<RET, typename ::boost::tuples::element<2, Args>::type> |
891 | ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
892 | |
893 | } |
894 | catch (Catch3& e) |
895 | { |
896 | return |
897 | detail::return_or_throw<RET, typename ::boost::tuples::element<3, Args>::type> |
898 | ::call(::boost::tuples::get<3>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
899 | } |
900 | } |
901 | }; |
902 | |
903 | template<class Args, class Catch1, class Catch2> |
904 | class lambda_functor_base<action<4, try_catch_action<catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>,detail::catch_all_block> > >, Args> { |
905 | public: |
906 | Args args; |
907 | public: |
908 | explicit lambda_functor_base(const Args& a) : args(a) {} |
909 | |
910 | template <class SigArgs> struct sig { |
911 | typedef typename |
912 | as_lambda_functor< |
913 | typename boost::tuples::element<0, Args>::type |
914 | >::type lf_type; |
915 | |
916 | typedef typename lf_type::inherited::template sig<SigArgs>::type type; |
917 | }; |
918 | |
919 | template<class RET, CALL_TEMPLATE_ARGS> |
920 | RET call(CALL_FORMAL_ARGS) const { |
921 | try |
922 | { |
923 | return detail::select(::boost::tuples::get<0>(args), CALL_ACTUAL_ARGS); |
924 | } |
925 | catch (Catch1& e) |
926 | { |
927 | return |
928 | detail::return_or_throw<RET, typename ::boost::tuples::element<1, Args>::type> |
929 | ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
930 | } |
931 | catch (Catch2& e) |
932 | { |
933 | return |
934 | detail::return_or_throw<RET, typename ::boost::tuples::element<2, Args>::type> |
935 | ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
936 | } |
937 | catch (...) |
938 | { |
939 | return |
940 | detail::return_or_throw<RET, typename ::boost::tuples::element<3, Args>::type> |
941 | ::call(::boost::tuples::get<3>(args), CALL_ACTUAL_ARGS); |
942 | } |
943 | } |
944 | }; |
945 | |
946 | // 4 catch types case |
947 | template<class Args, class Catch1, class Catch2, class Catch3, class Catch4> |
948 | class lambda_functor_base<action<5, try_catch_action<catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3>, detail::catch_block<Catch4> > > >, Args> { |
949 | public: |
950 | Args args; |
951 | public: |
952 | explicit lambda_functor_base(const Args& a) : args(a) {} |
953 | |
954 | template <class SigArgs> struct sig { |
955 | typedef typename |
956 | as_lambda_functor< |
957 | typename boost::tuples::element<0, Args>::type |
958 | >::type lf_type; |
959 | |
960 | typedef typename lf_type::inherited::template sig<SigArgs>::type type; |
961 | }; |
962 | |
963 | template<class RET, CALL_TEMPLATE_ARGS> |
964 | RET call(CALL_FORMAL_ARGS) const { |
965 | try |
966 | { |
967 | return detail::select(::boost::tuples::get<0>(args), CALL_ACTUAL_ARGS); |
968 | } |
969 | catch (Catch1& e) |
970 | { |
971 | return |
972 | detail::return_or_throw<RET, typename ::boost::tuples::element<1, Args>::type> |
973 | ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
974 | } |
975 | catch (Catch2& e) |
976 | { |
977 | return |
978 | detail::return_or_throw<RET, typename ::boost::tuples::element<2, Args>::type> |
979 | ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
980 | } |
981 | catch (Catch3& e) |
982 | { |
983 | return |
984 | detail::return_or_throw<RET, typename ::boost::tuples::element<3, Args>::type> |
985 | ::call(::boost::tuples::get<3>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
986 | } |
987 | catch (Catch4& e) |
988 | { |
989 | return |
990 | detail::return_or_throw<RET, typename ::boost::tuples::element<4, Args>::type> |
991 | ::call(::boost::tuples::get<4>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
992 | } |
993 | } |
994 | }; |
995 | |
996 | template<class Args, class Catch1, class Catch2, class Catch3> |
997 | class lambda_functor_base<action<5, try_catch_action<catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3>,detail::catch_all_block> > >, Args> { |
998 | public: |
999 | Args args; |
1000 | public: |
1001 | explicit lambda_functor_base(const Args& a) : args(a) {} |
1002 | |
1003 | template <class SigArgs> struct sig { |
1004 | typedef typename |
1005 | as_lambda_functor< |
1006 | typename boost::tuples::element<0, Args>::type |
1007 | >::type lf_type; |
1008 | |
1009 | typedef typename lf_type::inherited::template sig<SigArgs>::type type; |
1010 | }; |
1011 | |
1012 | template<class RET, CALL_TEMPLATE_ARGS> |
1013 | RET call(CALL_FORMAL_ARGS) const { |
1014 | try |
1015 | { |
1016 | return detail::select(::boost::tuples::get<0>(args), CALL_ACTUAL_ARGS); |
1017 | } |
1018 | catch (Catch1& e) |
1019 | { |
1020 | return |
1021 | detail::return_or_throw<RET, typename ::boost::tuples::element<1, Args>::type> |
1022 | ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1023 | } |
1024 | catch (Catch2& e) |
1025 | { |
1026 | return |
1027 | detail::return_or_throw<RET, typename ::boost::tuples::element<2, Args>::type> |
1028 | ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1029 | } |
1030 | catch (Catch3& e) |
1031 | { |
1032 | return |
1033 | detail::return_or_throw<RET, typename ::boost::tuples::element<3, Args>::type> |
1034 | ::call(::boost::tuples::get<3>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1035 | } |
1036 | catch (...) |
1037 | { |
1038 | return |
1039 | detail::return_or_throw<RET, typename ::boost::tuples::element<4, Args>::type> |
1040 | ::call(::boost::tuples::get<4>(args), CALL_ACTUAL_ARGS); |
1041 | } |
1042 | } |
1043 | }; |
1044 | |
1045 | // 5 catch types case |
1046 | template<class Args, class Catch1, class Catch2, class Catch3, class Catch4, class Catch5> |
1047 | class lambda_functor_base<action<6, try_catch_action<catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3>, detail::catch_block<Catch4>, detail::catch_block<Catch5> > > >, Args> { |
1048 | public: |
1049 | Args args; |
1050 | public: |
1051 | explicit lambda_functor_base(const Args& a) : args(a) {} |
1052 | |
1053 | template <class SigArgs> struct sig { |
1054 | typedef typename |
1055 | as_lambda_functor< |
1056 | typename boost::tuples::element<0, Args>::type |
1057 | >::type lf_type; |
1058 | |
1059 | typedef typename lf_type::inherited::template sig<SigArgs>::type type; |
1060 | }; |
1061 | |
1062 | template<class RET, CALL_TEMPLATE_ARGS> |
1063 | RET call(CALL_FORMAL_ARGS) const { |
1064 | try |
1065 | { |
1066 | return detail::select(::boost::tuples::get<0>(args), CALL_ACTUAL_ARGS); |
1067 | } |
1068 | catch (Catch1& e) |
1069 | { |
1070 | return |
1071 | detail::return_or_throw<RET, typename ::boost::tuples::element<1, Args>::type> |
1072 | ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1073 | } |
1074 | catch (Catch2& e) |
1075 | { |
1076 | return |
1077 | detail::return_or_throw<RET, typename ::boost::tuples::element<2, Args>::type> |
1078 | ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1079 | } |
1080 | catch (Catch3& e) |
1081 | { |
1082 | return |
1083 | detail::return_or_throw<RET, typename ::boost::tuples::element<3, Args>::type> |
1084 | ::call(::boost::tuples::get<3>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1085 | } |
1086 | catch (Catch4& e) |
1087 | { |
1088 | return |
1089 | detail::return_or_throw<RET, typename ::boost::tuples::element<4, Args>::type> |
1090 | ::call(::boost::tuples::get<4>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1091 | } |
1092 | catch (Catch5& e) |
1093 | { |
1094 | return |
1095 | detail::return_or_throw<RET, typename ::boost::tuples::element<4, Args>::type> |
1096 | ::call(::boost::tuples::get<5>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1097 | } |
1098 | } |
1099 | }; |
1100 | |
1101 | template<class Args, class Catch1, class Catch2, class Catch3, class Catch4> |
1102 | class lambda_functor_base<action<6, try_catch_action<catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3>, detail::catch_block<Catch4>,detail::catch_all_block> > >, Args> { |
1103 | public: |
1104 | Args args; |
1105 | public: |
1106 | explicit lambda_functor_base(const Args& a) : args(a) {} |
1107 | |
1108 | template <class SigArgs> struct sig { |
1109 | typedef typename |
1110 | as_lambda_functor< |
1111 | typename boost::tuples::element<0, Args>::type |
1112 | >::type lf_type; |
1113 | |
1114 | typedef typename lf_type::inherited::template sig<SigArgs>::type type; |
1115 | }; |
1116 | |
1117 | template<class RET, CALL_TEMPLATE_ARGS> |
1118 | RET call(CALL_FORMAL_ARGS) const { |
1119 | try |
1120 | { |
1121 | return detail::select(::boost::tuples::get<0>(args), CALL_ACTUAL_ARGS); |
1122 | } |
1123 | catch (Catch1& e) |
1124 | { |
1125 | return |
1126 | detail::return_or_throw<RET, typename ::boost::tuples::element<1, Args>::type> |
1127 | ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1128 | } |
1129 | catch (Catch2& e) |
1130 | { |
1131 | return |
1132 | detail::return_or_throw<RET, typename ::boost::tuples::element<2, Args>::type> |
1133 | ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1134 | } |
1135 | catch (Catch3& e) |
1136 | { |
1137 | return |
1138 | detail::return_or_throw<RET, typename ::boost::tuples::element<3, Args>::type> |
1139 | ::call(::boost::tuples::get<3>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1140 | } |
1141 | catch (Catch4& e) |
1142 | { |
1143 | return |
1144 | detail::return_or_throw<RET, typename ::boost::tuples::element<4, Args>::type> |
1145 | ::call(::boost::tuples::get<4>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1146 | } |
1147 | catch (...) |
1148 | { |
1149 | return |
1150 | detail::return_or_throw<RET, typename ::boost::tuples::element<5, Args>::type> |
1151 | ::call(::boost::tuples::get<5>(args), CALL_ACTUAL_ARGS); |
1152 | } |
1153 | } |
1154 | }; |
1155 | |
1156 | // 6 catch types case |
1157 | template<class Args, class Catch1, class Catch2, class Catch3, class Catch4, class Catch5, class Catch6> |
1158 | class lambda_functor_base<action<7, try_catch_action<catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3>, detail::catch_block<Catch4>, detail::catch_block<Catch5>, detail::catch_block<Catch6> > > >, Args> { |
1159 | public: |
1160 | Args args; |
1161 | public: |
1162 | explicit lambda_functor_base(const Args& a) : args(a) {} |
1163 | |
1164 | template <class SigArgs> struct sig { |
1165 | typedef typename |
1166 | as_lambda_functor< |
1167 | typename boost::tuples::element<0, Args>::type |
1168 | >::type lf_type; |
1169 | |
1170 | typedef typename lf_type::inherited::template sig<SigArgs>::type type; |
1171 | }; |
1172 | |
1173 | template<class RET, CALL_TEMPLATE_ARGS> |
1174 | RET call(CALL_FORMAL_ARGS) const { |
1175 | try |
1176 | { |
1177 | return detail::select(::boost::tuples::get<0>(args), CALL_ACTUAL_ARGS); |
1178 | } |
1179 | catch (Catch1& e) |
1180 | { |
1181 | return |
1182 | detail::return_or_throw<RET, typename ::boost::tuples::element<1, Args>::type> |
1183 | ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1184 | } |
1185 | catch (Catch2& e) |
1186 | { |
1187 | return |
1188 | detail::return_or_throw<RET, typename ::boost::tuples::element<2, Args>::type> |
1189 | ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1190 | } |
1191 | catch (Catch3& e) |
1192 | { |
1193 | return |
1194 | detail::return_or_throw<RET, typename ::boost::tuples::element<3, Args>::type> |
1195 | ::call(::boost::tuples::get<3>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1196 | } |
1197 | catch (Catch4& e) |
1198 | { |
1199 | return |
1200 | detail::return_or_throw<RET, typename ::boost::tuples::element<4, Args>::type> |
1201 | ::call(::boost::tuples::get<4>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1202 | } |
1203 | catch (Catch5& e) |
1204 | { |
1205 | return |
1206 | detail::return_or_throw<RET, typename ::boost::tuples::element<5, Args>::type> |
1207 | ::call(::boost::tuples::get<5>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1208 | } |
1209 | catch (Catch6& e) |
1210 | { |
1211 | return |
1212 | detail::return_or_throw<RET, typename ::boost::tuples::element<6, Args>::type> |
1213 | ::call(::boost::tuples::get<6>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1214 | } |
1215 | } |
1216 | }; |
1217 | |
1218 | template<class Args, class Catch1, class Catch2, class Catch3, class Catch4, class Catch5> |
1219 | class lambda_functor_base<action<7, try_catch_action<catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3>, detail::catch_block<Catch4>, detail::catch_block<Catch5>,detail::catch_all_block> > >, Args> { |
1220 | public: |
1221 | Args args; |
1222 | public: |
1223 | explicit lambda_functor_base(const Args& a) : args(a) {} |
1224 | |
1225 | template <class SigArgs> struct sig { |
1226 | typedef typename |
1227 | as_lambda_functor< |
1228 | typename boost::tuples::element<0, Args>::type |
1229 | >::type lf_type; |
1230 | |
1231 | typedef typename lf_type::inherited::template sig<SigArgs>::type type; |
1232 | }; |
1233 | |
1234 | template<class RET, CALL_TEMPLATE_ARGS> |
1235 | RET call(CALL_FORMAL_ARGS) const { |
1236 | try |
1237 | { |
1238 | return detail::select(::boost::tuples::get<0>(args), CALL_ACTUAL_ARGS); |
1239 | } |
1240 | catch (Catch1& e) |
1241 | { |
1242 | return |
1243 | detail::return_or_throw<RET, typename ::boost::tuples::element<1, Args>::type> |
1244 | ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1245 | } |
1246 | catch (Catch2& e) |
1247 | { |
1248 | return |
1249 | detail::return_or_throw<RET, typename ::boost::tuples::element<2, Args>::type> |
1250 | ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1251 | } |
1252 | catch (Catch3& e) |
1253 | { |
1254 | return |
1255 | detail::return_or_throw<RET, typename ::boost::tuples::element<3, Args>::type> |
1256 | ::call(::boost::tuples::get<3>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1257 | } |
1258 | catch (Catch4& e) |
1259 | { |
1260 | return |
1261 | detail::return_or_throw<RET, typename ::boost::tuples::element<4, Args>::type> |
1262 | ::call(::boost::tuples::get<4>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1263 | } |
1264 | catch (Catch5& e) |
1265 | { |
1266 | return |
1267 | detail::return_or_throw<RET, typename ::boost::tuples::element<5, Args>::type> |
1268 | ::call(::boost::tuples::get<5>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1269 | } |
1270 | catch (...) |
1271 | { |
1272 | return |
1273 | detail::return_or_throw<RET, typename ::boost::tuples::element<6, Args>::type> |
1274 | ::call(::boost::tuples::get<6>(args), CALL_ACTUAL_ARGS); |
1275 | } |
1276 | } |
1277 | }; |
1278 | |
1279 | // 7 catch types case |
1280 | template<class Args, class Catch1, class Catch2, class Catch3, class Catch4, class Catch5, class Catch6, |
1281 | class Catch7> |
1282 | class lambda_functor_base<action<8, try_catch_action<catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3>, detail::catch_block<Catch4>, detail::catch_block<Catch5>, detail::catch_block<Catch6>, detail::catch_block<Catch7> > > >, Args> { |
1283 | public: |
1284 | Args args; |
1285 | public: |
1286 | explicit lambda_functor_base(const Args& a) : args(a) {} |
1287 | |
1288 | template <class SigArgs> struct sig { |
1289 | typedef typename |
1290 | as_lambda_functor< |
1291 | typename boost::tuples::element<0, Args>::type |
1292 | >::type lf_type; |
1293 | |
1294 | typedef typename lf_type::inherited::template sig<SigArgs>::type type; |
1295 | }; |
1296 | |
1297 | template<class RET, CALL_TEMPLATE_ARGS> |
1298 | RET call(CALL_FORMAL_ARGS) const { |
1299 | try |
1300 | { |
1301 | return detail::select(::boost::tuples::get<0>(args), CALL_ACTUAL_ARGS); |
1302 | } |
1303 | catch (Catch1& e) |
1304 | { |
1305 | return |
1306 | detail::return_or_throw<RET, typename ::boost::tuples::element<1, Args>::type> |
1307 | ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1308 | } |
1309 | catch (Catch2& e) |
1310 | { |
1311 | return |
1312 | detail::return_or_throw<RET, typename ::boost::tuples::element<2, Args>::type> |
1313 | ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1314 | } |
1315 | catch (Catch3& e) |
1316 | { |
1317 | return |
1318 | detail::return_or_throw<RET, typename ::boost::tuples::element<3, Args>::type> |
1319 | ::call(::boost::tuples::get<3>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1320 | } |
1321 | catch (Catch4& e) |
1322 | { |
1323 | return |
1324 | detail::return_or_throw<RET, typename ::boost::tuples::element<4, Args>::type> |
1325 | ::call(::boost::tuples::get<4>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1326 | } |
1327 | catch (Catch5& e) |
1328 | { |
1329 | return |
1330 | detail::return_or_throw<RET, typename ::boost::tuples::element<5, Args>::type> |
1331 | ::call(::boost::tuples::get<5>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1332 | } |
1333 | catch (Catch6& e) |
1334 | { |
1335 | return |
1336 | detail::return_or_throw<RET, typename ::boost::tuples::element<6, Args>::type> |
1337 | ::call(::boost::tuples::get<6>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1338 | } |
1339 | catch (Catch7& e) |
1340 | { |
1341 | return |
1342 | detail::return_or_throw<RET, typename ::boost::tuples::element<7, Args>::type> |
1343 | ::call(::boost::tuples::get<7>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1344 | } |
1345 | } |
1346 | }; |
1347 | |
1348 | template<class Args, class Catch1, class Catch2, class Catch3, class Catch4, class Catch5, class Catch6> |
1349 | class lambda_functor_base<action<8, try_catch_action<catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3>, detail::catch_block<Catch4>, detail::catch_block<Catch5>, detail::catch_block<Catch6>, |
1350 | detail::catch_all_block> > >, Args> { |
1351 | public: |
1352 | Args args; |
1353 | public: |
1354 | explicit lambda_functor_base(const Args& a) : args(a) {} |
1355 | |
1356 | template <class SigArgs> struct sig { |
1357 | typedef typename |
1358 | as_lambda_functor< |
1359 | typename boost::tuples::element<0, Args>::type |
1360 | >::type lf_type; |
1361 | |
1362 | typedef typename lf_type::inherited::template sig<SigArgs>::type type; |
1363 | }; |
1364 | |
1365 | template<class RET, CALL_TEMPLATE_ARGS> |
1366 | RET call(CALL_FORMAL_ARGS) const { |
1367 | try |
1368 | { |
1369 | return detail::select(::boost::tuples::get<0>(args), CALL_ACTUAL_ARGS); |
1370 | } |
1371 | catch (Catch1& e) |
1372 | { |
1373 | return |
1374 | detail::return_or_throw<RET, typename ::boost::tuples::element<1, Args>::type> |
1375 | ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1376 | } |
1377 | catch (Catch2& e) |
1378 | { |
1379 | return |
1380 | detail::return_or_throw<RET, typename ::boost::tuples::element<2, Args>::type> |
1381 | ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1382 | } |
1383 | catch (Catch3& e) |
1384 | { |
1385 | return |
1386 | detail::return_or_throw<RET, typename ::boost::tuples::element<3, Args>::type> |
1387 | ::call(::boost::tuples::get<3>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1388 | } |
1389 | catch (Catch4& e) |
1390 | { |
1391 | return |
1392 | detail::return_or_throw<RET, typename ::boost::tuples::element<4, Args>::type> |
1393 | ::call(::boost::tuples::get<4>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1394 | } |
1395 | catch (Catch5& e) |
1396 | { |
1397 | return |
1398 | detail::return_or_throw<RET, typename ::boost::tuples::element<5, Args>::type> |
1399 | ::call(::boost::tuples::get<5>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1400 | } |
1401 | catch (Catch6& e) |
1402 | { |
1403 | return |
1404 | detail::return_or_throw<RET, typename ::boost::tuples::element<6, Args>::type> |
1405 | ::call(::boost::tuples::get<6>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1406 | } |
1407 | catch (...) |
1408 | { |
1409 | return |
1410 | detail::return_or_throw<RET, typename ::boost::tuples::element<7, Args>::type> |
1411 | ::call(::boost::tuples::get<7>(args), CALL_ACTUAL_ARGS); |
1412 | } |
1413 | } |
1414 | }; |
1415 | |
1416 | // 8 catch types case |
1417 | template<class Args, class Catch1, class Catch2, class Catch3, class Catch4, class Catch5, class Catch6, |
1418 | class Catch7, class Catch8> |
1419 | class lambda_functor_base<action<9, try_catch_action<catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3>, detail::catch_block<Catch4>, detail::catch_block<Catch5>, detail::catch_block<Catch6>, |
1420 | detail::catch_block<Catch7>, detail::catch_block<Catch8> > > >, Args> { |
1421 | public: |
1422 | Args args; |
1423 | public: |
1424 | explicit lambda_functor_base(const Args& a) : args(a) {} |
1425 | |
1426 | template <class SigArgs> struct sig { |
1427 | typedef typename |
1428 | as_lambda_functor< |
1429 | typename boost::tuples::element<0, Args>::type |
1430 | >::type lf_type; |
1431 | |
1432 | typedef typename lf_type::inherited::template sig<SigArgs>::type type; |
1433 | }; |
1434 | |
1435 | template<class RET, CALL_TEMPLATE_ARGS> |
1436 | RET call(CALL_FORMAL_ARGS) const { |
1437 | try |
1438 | { |
1439 | return detail::select(::boost::tuples::get<0>(args), CALL_ACTUAL_ARGS); |
1440 | } |
1441 | catch (Catch1& e) |
1442 | { |
1443 | return |
1444 | detail::return_or_throw<RET, typename ::boost::tuples::element<1, Args>::type> |
1445 | ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1446 | } |
1447 | catch (Catch2& e) |
1448 | { |
1449 | return |
1450 | detail::return_or_throw<RET, typename ::boost::tuples::element<2, Args>::type> |
1451 | ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1452 | } |
1453 | catch (Catch3& e) |
1454 | { |
1455 | return |
1456 | detail::return_or_throw<RET, typename ::boost::tuples::element<3, Args>::type> |
1457 | ::call(::boost::tuples::get<3>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1458 | } |
1459 | catch (Catch4& e) |
1460 | { |
1461 | return |
1462 | detail::return_or_throw<RET, typename ::boost::tuples::element<4, Args>::type> |
1463 | ::call(::boost::tuples::get<4>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1464 | } |
1465 | catch (Catch5& e) |
1466 | { |
1467 | return |
1468 | detail::return_or_throw<RET, typename ::boost::tuples::element<5, Args>::type> |
1469 | ::call(::boost::tuples::get<5>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1470 | } |
1471 | catch (Catch6& e) |
1472 | { |
1473 | return |
1474 | detail::return_or_throw<RET, typename ::boost::tuples::element<6, Args>::type> |
1475 | ::call(::boost::tuples::get<6>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1476 | } |
1477 | catch (Catch7& e) |
1478 | { |
1479 | return |
1480 | detail::return_or_throw<RET, typename ::boost::tuples::element<7, Args>::type> |
1481 | ::call(::boost::tuples::get<7>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1482 | } |
1483 | catch (Catch8& e) |
1484 | { |
1485 | return |
1486 | detail::return_or_throw<RET, typename ::boost::tuples::element<8, Args>::type> |
1487 | ::call(::boost::tuples::get<8>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1488 | } |
1489 | } |
1490 | }; |
1491 | |
1492 | template<class Args, class Catch1, class Catch2, class Catch3, class Catch4, class Catch5, class Catch6, |
1493 | class Catch7> |
1494 | class lambda_functor_base<action<9, try_catch_action<catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3>, detail::catch_block<Catch4>, detail::catch_block<Catch5>, detail::catch_block<Catch6>, |
1495 | detail::catch_block<Catch7>,detail::catch_all_block> > >, Args> { |
1496 | public: |
1497 | Args args; |
1498 | public: |
1499 | explicit lambda_functor_base(const Args& a) : args(a) {} |
1500 | |
1501 | template <class SigArgs> struct sig { |
1502 | typedef typename |
1503 | as_lambda_functor< |
1504 | typename boost::tuples::element<0, Args>::type |
1505 | >::type lf_type; |
1506 | |
1507 | typedef typename lf_type::inherited::template sig<SigArgs>::type type; |
1508 | }; |
1509 | |
1510 | template<class RET, CALL_TEMPLATE_ARGS> |
1511 | RET call(CALL_FORMAL_ARGS) const { |
1512 | try |
1513 | { |
1514 | return detail::select(::boost::tuples::get<0>(args), CALL_ACTUAL_ARGS); |
1515 | } |
1516 | catch (Catch1& e) |
1517 | { |
1518 | return |
1519 | detail::return_or_throw<RET, typename ::boost::tuples::element<1, Args>::type> |
1520 | ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1521 | } |
1522 | catch (Catch2& e) |
1523 | { |
1524 | return |
1525 | detail::return_or_throw<RET, typename ::boost::tuples::element<2, Args>::type> |
1526 | ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1527 | } |
1528 | catch (Catch3& e) |
1529 | { |
1530 | return |
1531 | detail::return_or_throw<RET, typename ::boost::tuples::element<3, Args>::type> |
1532 | ::call(::boost::tuples::get<3>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1533 | } |
1534 | catch (Catch4& e) |
1535 | { |
1536 | return |
1537 | detail::return_or_throw<RET, typename ::boost::tuples::element<4, Args>::type> |
1538 | ::call(::boost::tuples::get<4>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1539 | } |
1540 | catch (Catch5& e) |
1541 | { |
1542 | return |
1543 | detail::return_or_throw<RET, typename ::boost::tuples::element<5, Args>::type> |
1544 | ::call(::boost::tuples::get<5>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1545 | } |
1546 | catch (Catch6& e) |
1547 | { |
1548 | return |
1549 | detail::return_or_throw<RET, typename ::boost::tuples::element<6, Args>::type> |
1550 | ::call(::boost::tuples::get<6>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1551 | } |
1552 | catch (Catch7& e) |
1553 | { |
1554 | return |
1555 | detail::return_or_throw<RET, typename ::boost::tuples::element<7, Args>::type> |
1556 | ::call(::boost::tuples::get<7>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1557 | } |
1558 | catch (...) |
1559 | { |
1560 | return |
1561 | detail::return_or_throw<RET, typename ::boost::tuples::element<8, Args>::type> |
1562 | ::call(::boost::tuples::get<8>(args), CALL_ACTUAL_ARGS); |
1563 | } |
1564 | } |
1565 | }; |
1566 | |
1567 | // 9 catch types case |
1568 | template<class Args, class Catch1, class Catch2, class Catch3, class Catch4, class Catch5, class Catch6, |
1569 | class Catch7, class Catch8, class Catch9> |
1570 | class lambda_functor_base<action<10, try_catch_action<catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3>, detail::catch_block<Catch4>, detail::catch_block<Catch5>, detail::catch_block<Catch6>, |
1571 | detail::catch_block<Catch7>, detail::catch_block<Catch8>, detail::catch_block<Catch9> > > >, Args> { |
1572 | public: |
1573 | Args args; |
1574 | public: |
1575 | explicit lambda_functor_base(const Args& a) : args(a) {} |
1576 | |
1577 | template <class SigArgs> struct sig { |
1578 | typedef typename |
1579 | as_lambda_functor< |
1580 | typename boost::tuples::element<0, Args>::type |
1581 | >::type lf_type; |
1582 | |
1583 | typedef typename lf_type::inherited::template sig<SigArgs>::type type; |
1584 | }; |
1585 | |
1586 | template<class RET, CALL_TEMPLATE_ARGS> |
1587 | RET call(CALL_FORMAL_ARGS) const { |
1588 | try |
1589 | { |
1590 | return detail::select(::boost::tuples::get<0>(args), CALL_ACTUAL_ARGS); |
1591 | } |
1592 | catch (Catch1& e) |
1593 | { |
1594 | return |
1595 | detail::return_or_throw<RET, typename ::boost::tuples::element<1, Args>::type> |
1596 | ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1597 | } |
1598 | catch (Catch2& e) |
1599 | { |
1600 | return |
1601 | detail::return_or_throw<RET, typename ::boost::tuples::element<2, Args>::type> |
1602 | ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1603 | } |
1604 | catch (Catch3& e) |
1605 | { |
1606 | return |
1607 | detail::return_or_throw<RET, typename ::boost::tuples::element<3, Args>::type> |
1608 | ::call(::boost::tuples::get<3>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1609 | } |
1610 | catch (Catch4& e) |
1611 | { |
1612 | return |
1613 | detail::return_or_throw<RET, typename ::boost::tuples::element<4, Args>::type> |
1614 | ::call(::boost::tuples::get<4>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1615 | } |
1616 | catch (Catch5& e) |
1617 | { |
1618 | return |
1619 | detail::return_or_throw<RET, typename ::boost::tuples::element<5, Args>::type> |
1620 | ::call(::boost::tuples::get<5>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1621 | } |
1622 | catch (Catch6& e) |
1623 | { |
1624 | return |
1625 | detail::return_or_throw<RET, typename ::boost::tuples::element<6, Args>::type> |
1626 | ::call(::boost::tuples::get<6>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1627 | } |
1628 | catch (Catch7& e) |
1629 | { |
1630 | return |
1631 | detail::return_or_throw<RET, typename ::boost::tuples::element<7, Args>::type> |
1632 | ::call(::boost::tuples::get<7>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1633 | } |
1634 | catch (Catch8& e) |
1635 | { |
1636 | return |
1637 | detail::return_or_throw<RET, typename ::boost::tuples::element<8, Args>::type> |
1638 | ::call(::boost::tuples::get<8>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1639 | } |
1640 | catch (Catch9& e) |
1641 | { |
1642 | return |
1643 | detail::return_or_throw<RET, typename ::boost::tuples::element<9, Args>::type> |
1644 | ::call(::boost::tuples::get<9>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1645 | } |
1646 | } |
1647 | }; |
1648 | |
1649 | template<class Args, class Catch1, class Catch2, class Catch3, class Catch4, class Catch5, class Catch6, |
1650 | class Catch7, class Catch8> |
1651 | class lambda_functor_base<action<10, try_catch_action<catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3>, detail::catch_block<Catch4>, detail::catch_block<Catch5>, detail::catch_block<Catch6>, |
1652 | detail::catch_block<Catch7>, detail::catch_block<Catch8>,detail::catch_all_block> > >, Args> { |
1653 | public: |
1654 | Args args; |
1655 | public: |
1656 | explicit lambda_functor_base(const Args& a) : args(a) {} |
1657 | |
1658 | template <class SigArgs> struct sig { |
1659 | typedef typename |
1660 | as_lambda_functor< |
1661 | typename boost::tuples::element<0, Args>::type |
1662 | >::type lf_type; |
1663 | |
1664 | typedef typename lf_type::inherited::template sig<SigArgs>::type type; |
1665 | }; |
1666 | |
1667 | template<class RET, CALL_TEMPLATE_ARGS> |
1668 | RET call(CALL_FORMAL_ARGS) const { |
1669 | try |
1670 | { |
1671 | return detail::select(::boost::tuples::get<0>(args), CALL_ACTUAL_ARGS); |
1672 | } |
1673 | catch (Catch1& e) |
1674 | { |
1675 | return |
1676 | detail::return_or_throw<RET, typename ::boost::tuples::element<1, Args>::type> |
1677 | ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1678 | } |
1679 | catch (Catch2& e) |
1680 | { |
1681 | return |
1682 | detail::return_or_throw<RET, typename ::boost::tuples::element<2, Args>::type> |
1683 | ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1684 | } |
1685 | catch (Catch3& e) |
1686 | { |
1687 | return |
1688 | detail::return_or_throw<RET, typename ::boost::tuples::element<3, Args>::type> |
1689 | ::call(::boost::tuples::get<3>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1690 | } |
1691 | catch (Catch4& e) |
1692 | { |
1693 | return |
1694 | detail::return_or_throw<RET, typename ::boost::tuples::element<4, Args>::type> |
1695 | ::call(::boost::tuples::get<4>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1696 | } |
1697 | catch (Catch5& e) |
1698 | { |
1699 | return |
1700 | detail::return_or_throw<RET, typename ::boost::tuples::element<5, Args>::type> |
1701 | ::call(::boost::tuples::get<5>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1702 | } |
1703 | catch (Catch6& e) |
1704 | { |
1705 | return |
1706 | detail::return_or_throw<RET, typename ::boost::tuples::element<6, Args>::type> |
1707 | ::call(::boost::tuples::get<6>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1708 | } |
1709 | catch (Catch7& e) |
1710 | { |
1711 | return |
1712 | detail::return_or_throw<RET, typename ::boost::tuples::element<7, Args>::type> |
1713 | ::call(::boost::tuples::get<7>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1714 | } |
1715 | catch (Catch8& e) |
1716 | { |
1717 | return |
1718 | detail::return_or_throw<RET, typename ::boost::tuples::element<8, Args>::type> |
1719 | ::call(::boost::tuples::get<8>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
1720 | } |
1721 | catch (...) |
1722 | { |
1723 | return |
1724 | detail::return_or_throw<RET, typename ::boost::tuples::element<9, Args>::type> |
1725 | ::call(::boost::tuples::get<9>(args), CALL_ACTUAL_ARGS); |
1726 | } |
1727 | } |
1728 | }; |
1729 | |
1730 | |
1731 | } // namespace lambda |
1732 | } // namespace boost |
1733 | |
1734 | |
1735 | #endif |
1736 | |
1737 | |
1738 | |
1739 | |
1740 | |
1741 | |
1742 | |