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 

    19 namespace boost { 

    20 namespace lambda {

    21 

    22 typedef lambda_functor<placeholder<EXCEPTION> > placeholderE_type;

    23 

    24 namespace {

    25   boost::lambda::placeholderE_type freeE;

    26   boost::lambda::placeholderE_type& _e = freeE;        

    27 }

    28 

    29 // -- exception related actions -------------------

    30 

    31 // catch actions.

    32 template <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>

    37 struct catch_action {};

    38 

    39 struct catch_all_action {};

    40 

    41 template<class CatchActions>

    42 struct return_try_catch_action {};

    43 

    44 template<class CatchActions>

    45 struct try_catch_action {};

    46 

    47 // rethrow actions

    48 struct throw_new_action {};

    49 struct rethrow_action {};

    50 

    51 template<class ThrowType> struct throw_action;

    52 

    53 template<>

    54 struct throw_action<rethrow_action> {

    55   template<class RET>

    56   static RET apply() {

    57     throw;

    58   }

    59 };

    60 

    61 template<> 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 

    70 template<class T, class Any>

    71 struct 

    72 return_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

    89 class ifthenelse_action;

    90 

    91 namespace 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 

   108 template <class Arg> 

   109 struct throws_for_sure_phase2 {

   110   static const bool value = false;

   111 };

   112 

   113 template <int N, class ThrowType, class Args> 

   114 struct 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.

   124 template <class Args> 

   125 struct 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 

   148 template <class Args> 

   149 struct 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 

   167 template <class Arg> 

   168 struct 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.

   181 template<bool is_conversion>

   182 struct 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

   194 template<>

   195 struct 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

   205 template<class RET, class ARG>

   206 struct 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

   226 template<class ARG>

   227 struct 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 

   236 namespace detail {

   237 

   238 template <class T> struct catch_block {}; 

   239 struct catch_all_block {};

   240 

   241 template <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

   254 inline const 

   255 lambda_functor< 

   256   lambda_functor_base< 

   257     action<0, throw_action<rethrow_action> >, 

   258     null_type

   259   > 

   260 >

   261 rethrow() { 

   262   return 

   263       lambda_functor_base< 

   264         action<0, throw_action<rethrow_action> >,

   265         null_type

   266       > 

   267     ( null_type() );

   268 }

   269 

   270 template <class Arg1>

   271 inline const 

   272 lambda_functor<

   273   lambda_functor_base< 

   274     action<1, throw_action<throw_new_action> >, 

   275     tuple<typename const_copy_argument<const Arg1>::type>

   276   > 

   277 >

   278 throw_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

   288 template <class CatchType, class Arg>

   289 inline const 

   290 tagged_lambda_functor<

   291   detail::exception_catch_tag<detail::catch_block<CatchType> >, 

   292   lambda_functor<Arg> 

   293 > 

   294 catch_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.

   305 template <class CatchType>

   306 inline const 

   307 tagged_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 >

   316 catch_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

   330 template <class Arg>

   331 inline const 

   332 tagged_lambda_functor<

   333   detail::exception_catch_tag<detail::catch_all_block>, 

   334   lambda_functor<Arg> 

   335 > 

   336 catch_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.

   347 inline const 

   348 tagged_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 >

   357 catch_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 

   372 template <class TryArg, class Catch1, class LF1>

   373 inline const 

   374 lambda_functor< 

   375   lambda_functor_base< 

   376     action<2, try_catch_action<catch_action<Catch1> > >, 

   377     tuple<lambda_functor<TryArg>, LF1>

   378   > 

   379 >

   380 try_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 

   392 template <class TryArg, class Catch1, class LF1, 

   393                         class Catch2, class LF2>

   394 inline 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 >

   401 try_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 

   414 template <class TryArg, class Catch1, class LF1, 

   415                         class Catch2, class LF2, 

   416                         class Catch3, class LF3>

   417 inline 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 >

   423 try_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 

   437 template <class TryArg, class Catch1, class LF1, 

   438                         class Catch2, class LF2, 

   439                         class Catch3, class LF3, 

   440                         class Catch4, class LF4>

   441 inline const 

   442 lambda_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 >

   453 try_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 

   471 template <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>

   476 inline const 

   477 lambda_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 >

   486 try_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 

   509 template <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>

   515 inline const 

   516 lambda_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 >

   527 try_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 

   550 template <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>

   557 inline const 

   558 lambda_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 >

   569 try_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 

   595 template <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>

   603 inline const 

   604 lambda_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 >

   617 try_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 

   644 template <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>

   653 inline 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   >

   670 try_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 

   708 template<class Args, class Catch1>

   709 class lambda_functor_base<

   710   action<2, try_catch_action<catch_action<detail::catch_block<Catch1> > > >, 

   711   Args

   712 > 

   713 {

   714 public:

   715   Args args;

   716 public:

   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 

   749 template<class Args>

   750 class lambda_functor_base<action<2, try_catch_action<catch_action<detail::catch_all_block> > >, Args> {

   751 public:

   752   Args args;

   753 public:

   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

   782 template<class Args, class Catch1, class Catch2>

   783 class lambda_functor_base<action<3, try_catch_action<catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2> > > >, Args> {

   784 public:

   785   Args args;

   786 public:

   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 

   819 template<class Args, class Catch1>

   820 class lambda_functor_base<action<3, try_catch_action<catch_action<detail::catch_block<Catch1>,detail::catch_all_block> > >, Args> {

   821 public:

   822   Args args;

   823 public:

   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

   857 template<class Args, class Catch1, class Catch2, class Catch3>

   858 class lambda_functor_base<action<4, try_catch_action<catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3> > > >, Args> {

   859 public:

   860   Args args;

   861 public:

   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 

   902 template<class Args, class Catch1, class Catch2>

   903 class lambda_functor_base<action<4, try_catch_action<catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>,detail::catch_all_block> > >, Args> {

   904 public:

   905   Args args;

   906 public:

   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

   946 template<class Args, class Catch1, class Catch2, class Catch3, class Catch4>

   947 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> {

   948 public:

   949   Args args;

   950 public:

   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 

   995 template<class Args, class Catch1, class Catch2, class Catch3>

   996 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> {

   997 public:

   998   Args args;

   999 public:

  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

  1045 template<class Args, class Catch1, class Catch2, class Catch3, class Catch4, class Catch5>

  1046 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> {

  1047 public:

  1048   Args args;

  1049 public:

  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 

  1100 template<class Args, class Catch1, class Catch2, class Catch3, class Catch4>

  1101 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> {

  1102 public:

  1103   Args args;

  1104 public:

  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     {