Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: downloads/boost_1_34_1/boost/lambda/exceptions.hpp @ 33

Last change on this file since 33 was 29, checked in by landauf, 16 years ago

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