| // -- Boost Lambda Library -- exceptions.hpp ---------------- |
| // |
| // Copyright (C) 2000 Gary Powell (gwpowell@hotmail.com) |
| // Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi) |
| // |
| // Distributed under the Boost Software License, Version 1.0. (See |
| // accompanying file LICENSE_1_0.txt or copy at |
| // http://www.boost.org/LICENSE_1_0.txt) |
| // |
| // For more information, see http://www.boost.org |
| |
| // ----------------------------------------------------- |
| |
| #if !defined(BOOST_LAMBDA_EXCEPTIONS_HPP) |
| #define BOOST_LAMBDA_EXCEPTIONS_HPP |
| |
| #include "boost/lambda/core.hpp" |
| #include "boost/lambda/detail/control_constructs_common.hpp" |
| |
| namespace boost { |
| namespace lambda { |
| |
| typedef lambda_functor<placeholder<EXCEPTION> > placeholderE_type; |
| |
| namespace { |
| boost::lambda::placeholderE_type freeE; |
| boost::lambda::placeholderE_type& _e = freeE; |
| } |
| |
| // -- exception related actions ------------------- |
| |
| // catch actions. |
| template <class Catch1, class Catch2 = null_type, class Catch3 = null_type, |
| class Catch4 = null_type, class Catch5 = null_type, |
| class Catch6 = null_type, class Catch7 = null_type, |
| class Catch8 = null_type, class Catch9 = null_type, |
| class Catch10 = null_type> |
| struct catch_action {}; |
| |
| struct catch_all_action {}; |
| |
| template<class CatchActions> |
| struct return_try_catch_action {}; |
| |
| template<class CatchActions> |
| struct try_catch_action {}; |
| |
| // rethrow actions |
| struct throw_new_action {}; |
| struct rethrow_action {}; |
| |
| template<class ThrowType> struct throw_action; |
| |
| template<> |
| struct throw_action<rethrow_action> { |
| template<class RET> |
| static RET apply() { |
| throw; |
| } |
| }; |
| |
| template<> struct throw_action<throw_new_action> { |
| template<class RET, class T> |
| static RET apply(T& t) { |
| throw t; |
| } |
| }; |
| |
| // return types for throw_actions -------------------------------------------- |
| |
| template<class T, class Any> |
| struct |
| return_type_N<throw_action<T>, Any> { |
| typedef void type; |
| }; |
| |
| |
| // return types deductions ------------------------------------------------- |
| |
| // the return type of try_catch is the return type of the try lambda_functor |
| // (the return types of try and catch parts must match unless try returns void |
| // or the catch part throws for sure) |
| |
| // NOTE, the exception placeholder deduction rule is defined |
| // in return_type_traits.hpp |
| |
| |
| |
| // defined in control_constructs |
| class ifthenelse_action; |
| |
| namespace detail { |
| |
| // Templates for deducing, wether a lambda_functor throws inevitably of not - |
| // This mechanism is needed to make the compiler happy about |
| // return types of try and catch parts. |
| |
| // a lambda_functor throws for sure if: |
| // - it is a throw expression |
| // - it is a comma expression, and one of its arguments throws for sure |
| // - it is an if_then_else expression and either the if statement or both |
| // the then and else throw. |
| // (there are other cases as well, but we do not cover them) |
| // e.g. _1 + (rethrow(), 3) does throw for sure but this is not checked |
| // This implies, that in such a case, the return types of try and catch parts |
| // must match if the try part returns other than void. |
| // (Such checks could be done though) |
| |
| template <class Arg> |
| struct throws_for_sure_phase2 { |
| static const bool value = false; |
| }; |
| |
| template <int N, class ThrowType, class Args> |
| struct throws_for_sure_phase2< |
| lambda_functor< |
| lambda_functor_base<action<N, throw_action<ThrowType> >, Args> |
| > |
| > |
| { |
| static const bool value = true; |
| }; |
| |
| // Both then and else or the if throw of an if_then_else. |
| template <class Args> |
| struct throws_for_sure_phase2< |
| lambda_functor< |
| lambda_functor_base< |
| ifthenelse_action, Args |
| > |
| > |
| > |
| { |
| static const bool value = |
| throws_for_sure_phase2< |
| typename boost::tuples::element<0, Args>::type>::value |
| || |
| ( |
| throws_for_sure_phase2< |
| typename boost::tuples::element<1, Args>::type |
| >::value |
| && |
| throws_for_sure_phase2< |
| typename boost::tuples::element<2, Args>::type |
| >::value |
| ); |
| }; |
| |
| template <class Args> |
| struct throws_for_sure_phase2< |
| lambda_functor< |
| lambda_functor_base< other_action<comma_action>, Args> |
| > |
| > |
| { |
| static const bool value = |
| throws_for_sure_phase2< |
| typename boost::tuples::element<0, Args>::type |
| >::value |
| || |
| throws_for_sure_phase2< |
| typename boost::tuples::element<1, Args>::type |
| >::value; |
| }; |
| |
| // get rid of any qualifiers and references |
| // lambda_functors should be stored like that, so this is to be extra sure |
| template <class Arg> |
| struct throws_for_sure { |
| static const bool value |
| = throws_for_sure_phase2< |
| typename detail::remove_reference_and_cv<Arg>::type |
| >::value; |
| }; |
| |
| |
| // -- return_or_throw templates ----------------------------- |
| |
| // false case, catch and try return types are incompatible |
| // Now the catch part must throw for sure, otherwise a compile time error |
| // occurs. |
| template<bool is_conversion> |
| struct return_or_throw_phase2 { |
| template<class RET, class Arg, CALL_TEMPLATE_ARGS> |
| static RET call(Arg& arg, CALL_FORMAL_ARGS) { |
| BOOST_STATIC_ASSERT(throws_for_sure<Arg>::value); |
| detail::select(arg, CALL_ACTUAL_ARGS); // this line throws |
| throw 1; // this line is never performed, hence 1 is just a dummy |
| // The line is needed to make compiler happy and not require |
| // a matching return type |
| } |
| }; |
| |
| // the try and catch return types are compatible |
| template<> |
| struct return_or_throw_phase2<true> { |
| template<class RET, class Arg, CALL_TEMPLATE_ARGS> |
| static RET call(Arg& arg, CALL_FORMAL_ARGS) { |
| return detail::select(arg, CALL_ACTUAL_ARGS); |
| } |
| }; |
| |
| |
| // the non-void case. Try part returns a value, so catch parts must |
| // return a value of the same type or throw |
| template<class RET, class ARG> |
| struct return_or_throw { |
| // Arg should be equal to ARG except that ARG may be a reference |
| // to be sure, that there are no suprises for peculiarly defined return types |
| // ARG is passed explicitely |
| template<class Arg, CALL_TEMPLATE_ARGS> |
| static RET call(Arg& arg, CALL_FORMAL_ARGS) |
| { |
| // typedef typename Arg::return_type<ARG, open_args<A&, B&, C&> >::type RT; |
| typedef typename as_lambda_functor<ARG>::type lf_type; |
| typedef typename lf_type::inherited::template |
| sig<tuple<CALL_REFERENCE_TYPES> >::type RT; |
| |
| return |
| return_or_throw_phase2< |
| ::boost::is_convertible<RT, RET>::value |
| >::template call<RET>(arg, CALL_ACTUAL_ARGS); |
| } |
| }; |
| |
| // if try part returns void, we do not return the catch parts either |
| template<class ARG> |
| struct return_or_throw<void, ARG> { |
| template<class Arg, CALL_TEMPLATE_ARGS> |
| static void call(Arg& arg, CALL_FORMAL_ARGS) { detail::select(arg, CALL_ACTUAL_ARGS); } |
| }; |
| |
| } // end detail |
| |
| // Throwing exceptions --------------------------------------------- |
| |
| namespace detail { |
| |
| template <class T> struct catch_block {}; |
| struct catch_all_block {}; |
| |
| template <class T> struct exception_catch_tag {}; |
| |
| // normal catch block is represented as |
| // tagged_lambda_functor<exception_catch_tag<catch_type<T> > >, LambdaFunctor> |
| |
| // the default catch all block as: |
| // tagged_lambda_functor<exception_catch_tag<catch_all_block> >, LambdaFunctor> |
| |
| |
| } // end detail |
| |
| // the code is RETHROW, this ensures that a compile time error results, |
| // if this lambda_functor is used outside a delayed catch_expression |
| inline const |
| lambda_functor< |
| lambda_functor_base< |
| action<0, throw_action<rethrow_action> >, |
| null_type |
| > |
| > |
| rethrow() { |
| return |
| lambda_functor_base< |
| action<0, throw_action<rethrow_action> >, |
| null_type |
| > |
| ( null_type() ); |
| } |
| |
| template <class Arg1> |
| inline const |
| lambda_functor< |
| lambda_functor_base< |
| action<1, throw_action<throw_new_action> >, |
| tuple<typename const_copy_argument<const Arg1>::type> |
| > |
| > |
| throw_exception(const Arg1& a1) { |
| return |
| lambda_functor_base< |
| action<1, throw_action<throw_new_action> >, |
| tuple<typename const_copy_argument<const Arg1>::type> |
| > |
| ( tuple<typename const_copy_argument<const Arg1>::type>(a1)); |
| } |
| |
| // create catch blocks |
| template <class CatchType, class Arg> |
| inline const |
| tagged_lambda_functor< |
| detail::exception_catch_tag<detail::catch_block<CatchType> >, |
| lambda_functor<Arg> |
| > |
| catch_exception(const lambda_functor<Arg>& a) { |
| // the third placeholder cannot be used in catch_exception |
| // BOOST_STATIC_ASSERT((!has_placeholder<Arg, THIRD>::value)); |
| return |
| tagged_lambda_functor< |
| detail::exception_catch_tag<detail::catch_block<CatchType> >, |
| lambda_functor<Arg> |
| > (a); |
| } |
| |
| // catch and do nothing case. |
| template <class CatchType> |
| inline const |
| tagged_lambda_functor< |
| detail::exception_catch_tag<detail::catch_block<CatchType> >, |
| lambda_functor< |
| lambda_functor_base< |
| do_nothing_action, |
| null_type |
| > |
| > |
| > |
| catch_exception() { |
| return |
| tagged_lambda_functor< |
| detail::exception_catch_tag<detail::catch_block<CatchType> >, |
| lambda_functor< |
| lambda_functor_base< |
| do_nothing_action, |
| null_type |
| > |
| > |
| > (); |
| } |
| |
| // create catch(...) blocks |
| template <class Arg> |
| inline const |
| tagged_lambda_functor< |
| detail::exception_catch_tag<detail::catch_all_block>, |
| lambda_functor<Arg> |
| > |
| catch_all(const lambda_functor<Arg>& a) { |
| // the third placeholder cannot be used in catch_exception |
| BOOST_STATIC_ASSERT((!has_placeholder<Arg, THIRD>::value)); |
| return |
| tagged_lambda_functor< |
| detail::exception_catch_tag<detail::catch_all_block>, |
| lambda_functor<Arg> |
| > (a); |
| } |
| |
| // catch(...) and do nothing case. |
| inline const |
| tagged_lambda_functor< |
| detail::exception_catch_tag<detail::catch_all_block>, |
| lambda_functor< |
| lambda_functor_base< |
| do_nothing_action, |
| null_type |
| > |
| > |
| > |
| catch_all() { |
| return |
| tagged_lambda_functor< |
| detail::exception_catch_tag<detail::catch_all_block>, |
| lambda_functor< |
| lambda_functor_base< |
| do_nothing_action, |
| null_type |
| > |
| > |
| > (); |
| } |
| |
| // try_catch functions -------------------------------- |
| // The second -> N argument(s) are must be catch lambda_functors |
| template <class TryArg, class Catch1, class LF1> |
| inline const |
| lambda_functor< |
| lambda_functor_base< |
| action<2, try_catch_action<catch_action<Catch1> > >, |
| tuple<lambda_functor<TryArg>, LF1> |
| > |
| > |
| try_catch( |
| const lambda_functor<TryArg>& a1, |
| const tagged_lambda_functor<detail::exception_catch_tag<Catch1>, LF1>& a2) |
| { |
| return |
| lambda_functor_base< |
| action<2, try_catch_action<catch_action<Catch1> > >, |
| tuple<lambda_functor<TryArg>, LF1> |
| > |
| ( tuple< lambda_functor<TryArg>, LF1>(a1, a2)); |
| } |
| |
| template <class TryArg, class Catch1, class LF1, |
| class Catch2, class LF2> |
| inline const |
| lambda_functor< |
| lambda_functor_base< |
| action<3, try_catch_action<catch_action<detail::catch_block<Catch1>, Catch2> > >, |
| tuple<lambda_functor<TryArg>, LF1, LF2> |
| > |
| > |
| try_catch( |
| const lambda_functor<TryArg>& a1, |
| const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch1> >, LF1>& a2, |
| const tagged_lambda_functor<detail::exception_catch_tag<Catch2>, LF2>& a3) |
| { |
| return |
| lambda_functor_base< |
| action<3, try_catch_action<catch_action<detail::catch_block<Catch1>, Catch2> > >, |
| tuple<lambda_functor<TryArg>, LF1, LF2> |
| > |
| ( tuple<lambda_functor<TryArg>, LF1, LF2>(a1, a2, a3)); |
| } |
| |
| template <class TryArg, class Catch1, class LF1, |
| class Catch2, class LF2, |
| class Catch3, class LF3> |
| inline const lambda_functor< |
| lambda_functor_base< |
| action<4, try_catch_action<catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>, Catch3> > >, |
| tuple<lambda_functor<TryArg>, LF1, LF2, LF3> |
| > |
| > |
| try_catch( |
| const lambda_functor<TryArg>& a1, |
| const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch1> >, LF1>& a2, |
| const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch2> >, LF2>& a3, |
| const tagged_lambda_functor<detail::exception_catch_tag<Catch3>, LF3>& a4) |
| { |
| return |
| lambda_functor_base< |
| action<4, try_catch_action<catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>, Catch3> > >, |
| tuple<lambda_functor<TryArg>, LF1, LF2, LF3> |
| > |
| ( tuple<lambda_functor<TryArg>, LF1, LF2, LF3>(a1, a2, a3, a4)); |
| } |
| |
| template <class TryArg, class Catch1, class LF1, |
| class Catch2, class LF2, |
| class Catch3, class LF3, |
| class Catch4, class LF4> |
| inline const |
| lambda_functor< |
| lambda_functor_base< |
| action< |
| 5, |
| try_catch_action< |
| catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3>, Catch4> |
| > |
| >, |
| tuple<lambda_functor<TryArg>, LF1, LF2, LF3, LF4> |
| > |
| > |
| try_catch( |
| const lambda_functor<TryArg>& a1, |
| const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch1> >, LF1>& a2, |
| const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch2> >, LF2>& a3, |
| const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch3> >, LF3>& a4, |
| const tagged_lambda_functor<detail::exception_catch_tag<Catch4>, LF4>& a5) |
| { |
| return |
| lambda_functor_base< |
| action< |
| 5, |
| try_catch_action<catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3>, Catch4> > |
| >, |
| tuple<lambda_functor<TryArg>, LF1, LF2, LF3, LF4> |
| > |
| ( tuple<lambda_functor<TryArg>, LF1, LF2, LF3, LF4>(a1, a2, a3, a4, a5)); |
| } |
| |
| template <class TryArg, class Catch1, class LF1, |
| class Catch2, class LF2, |
| class Catch3, class LF3, |
| class Catch4, class LF4, |
| class Catch5, class LF5> |
| inline const |
| lambda_functor< |
| 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>, Catch5> > |
| >, |
| tuple<lambda_functor<TryArg>, LF1, LF2, LF3, LF4, LF5> |
| > |
| > |
| try_catch( |
| const lambda_functor<TryArg>& a1, |
| const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch1> >, LF1>& a2, |
| const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch2> >, LF2>& a3, |
| const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch3> >, LF3>& a4, |
| const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch4> >, LF4>& a5, |
| const tagged_lambda_functor<detail::exception_catch_tag<Catch5>, LF5>& a6) |
| { |
| return |
| 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>, Catch5> |
| > |
| >, |
| tuple<lambda_functor<TryArg>, LF1, LF2, LF3, LF4, LF5> |
| > |
| ( tuple<lambda_functor<TryArg>, LF1, LF2, LF3, LF4, LF5> |
| (a1, a2, a3, a4, a5, a6) |
| ); |
| } |
| |
| template <class TryArg, class Catch1, class LF1, |
| class Catch2, class LF2, |
| class Catch3, class LF3, |
| class Catch4, class LF4, |
| class Catch5, class LF5, |
| class Catch6, class LF6> |
| inline const |
| lambda_functor< |
| 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>, Catch6> |
| > |
| >, |
| tuple<lambda_functor<TryArg>, LF1, LF2, LF3, LF4, LF5, LF6> |
| > |
| > |
| try_catch( |
| const lambda_functor<TryArg>& a1, |
| const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch1> >, LF1>& a2, |
| const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch2> >, LF2>& a3, |
| const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch3> >, LF3>& a4, |
| const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch4> >, LF4>& a5, |
| const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch5> >, LF5>& a6, |
| const tagged_lambda_functor<detail::exception_catch_tag<Catch6>, LF6>& a7) |
| { |
| return |
| 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>,Catch6> |
| > |
| >, |
| tuple<lambda_functor<TryArg>, LF1, LF2, LF3, LF4, LF5, LF6> |
| > |
| ( tuple<lambda_functor<TryArg>, LF1, LF2, LF3, LF4, LF5, LF6> |
| (a1, a2, a3, a4, a5, a6, a7)); |
| } |
| |
| template <class TryArg, class Catch1, class LF1, |
| class Catch2, class LF2, |
| class Catch3, class LF3, |
| class Catch4, class LF4, |
| class Catch5, class LF5, |
| class Catch6, class LF6, |
| class Catch7, class LF7> |
| inline const |
| lambda_functor< |
| 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>, Catch7> |
| > |
| >, |
| tuple<lambda_functor<TryArg>, LF1, LF2, LF3, LF4, LF5, LF6, LF7> |
| > |
| > |
| try_catch( |
| const lambda_functor<TryArg>& a1, |
| const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch1> >, LF1>& a2, |
| const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch2> >, LF2>& a3, |
| const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch3> >, LF3>& a4, |
| const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch4> >, LF4>& a5, |
| const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch5> >, LF5>& a6, |
| const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch6> >, LF6>& a7, |
| const tagged_lambda_functor<detail::exception_catch_tag<Catch7>, LF7>& a8) |
| { |
| return |
| 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>, Catch7 |
| > |
| > |
| >, |
| tuple<lambda_functor<TryArg>, LF1, LF2, LF3, LF4, LF5, LF6, LF7> |
| > |
| ( tuple<lambda_functor<TryArg>, LF1, LF2, LF3, LF4, LF5, LF6, LF7> |
| (a1, a2, a3, a4, a5, a6, a7, a8)); |
| } |
| |
| template <class TryArg, class Catch1, class LF1, |
| class Catch2, class LF2, |
| class Catch3, class LF3, |
| class Catch4, class LF4, |
| class Catch5, class LF5, |
| class Catch6, class LF6, |
| class Catch7, class LF7, |
| class Catch8, class LF8> |
| inline const |
| lambda_functor< |
| 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>, detail::catch_block<Catch7>, Catch8 |
| > |
| > |
| >, |
| tuple<lambda_functor<TryArg>, LF1, LF2, LF3, LF4, LF5, LF6, LF7, LF8> |
| > |
| > |
| try_catch( |
| const lambda_functor<TryArg>& a1, |
| const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch1> >, LF1>& a2, |
| const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch2> >, LF2>& a3, |
| const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch3> >, LF3>& a4, |
| const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch4> >, LF4>& a5, |
| const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch5> >, LF5>& a6, |
| const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch6> >, LF6>& a7, |
| const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch7> >, LF7>& a8, |
| const tagged_lambda_functor<detail::exception_catch_tag<Catch8>, LF8>& a9) |
| { |
| return |
| 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>, detail::catch_block<Catch7>, Catch8 |
| > |
| > |
| >, |
| tuple<lambda_functor<TryArg>, LF1, LF2, LF3, LF4, LF5, LF6, LF7, LF8> |
| > |
| ( tuple<lambda_functor<TryArg>, LF1, LF2, LF3, LF4, LF5, LF6, LF7, LF8> |
| (a1, a2, a3, a4, a5, a6, a7, a8, a9)); |
| } |
| |
| template <class TryArg, class Catch1, class LF1, |
| class Catch2, class LF2, |
| class Catch3, class LF3, |
| class Catch4, class LF4, |
| class Catch5, class LF5, |
| class Catch6, class LF6, |
| class Catch7, class LF7, |
| class Catch8, class LF8, |
| class Catch9, class LF9> |
| inline const |
| lambda_functor< |
| 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>, detail::catch_block<Catch7>, detail::catch_block<Catch8>, |
| Catch9 |
| > |
| > |
| >, |
| tuple< |
| lambda_functor<TryArg>, LF1, LF2, LF3, LF4, LF5, LF6, LF7, LF8, LF9 |
| > |
| > |
| > |
| try_catch( |
| const lambda_functor<TryArg>& a1, |
| const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch1> >, LF1>& a2, |
| const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch2> >, LF2>& a3, |
| const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch3> >, LF3>& a4, |
| const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch4> >, LF4>& a5, |
| const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch5> >, LF5>& a6, |
| const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch6> >, LF6>& a7, |
| const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch7> >, LF7>& a8, |
| const tagged_lambda_functor<detail::exception_catch_tag<detail::catch_block<Catch8> >, LF8>& a9, |
| const tagged_lambda_functor<detail::exception_catch_tag<Catch9>, LF9>& a10) |
| { |
| return |
| 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>, detail::catch_block<Catch7>, detail::catch_block<Catch8>, |
| Catch9 |
| > |
| > |
| >, |
| tuple< |
| lambda_functor<TryArg>, LF1, LF2, LF3, LF4, LF5, LF6, LF7, LF8, LF9 |
| > |
| > |
| ( tuple< |
| lambda_functor<TryArg>, LF1, LF2, LF3, LF4, LF5, LF6, LF7, LF8, LF9 |
| >(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)); |
| } |
| |
| |
| // --------------------------------------------------------------------------- |
| // Specializations for lambda_functor_base of try_catch ---------------------- |
| |
| // 1 catch type case |
| |
| template<class Args, class Catch1> |
| class lambda_functor_base< |
| action<2, try_catch_action<catch_action<detail::catch_block<Catch1> > > >, |
| Args |
| > |
| { |
| public: |
| Args args; |
| public: |
| explicit lambda_functor_base(const Args& a) : args(a) {} |
| |
| // the return type of try_catch is the return type of the try lambda_functor |
| // (the return types of try and catch parts must match unless try returns void |
| // or the catch part throws for sure) |
| |
| template <class SigArgs> struct sig { |
| typedef typename |
| as_lambda_functor< |
| typename boost::tuples::element<0, Args>::type |
| >::type lf_type; |
| |
| typedef typename lf_type::inherited::template sig<SigArgs>::type type; |
| }; |
| |
| template<class RET, CALL_TEMPLATE_ARGS> |
| RET call(CALL_FORMAL_ARGS) const { |
| try |
| { |
| return detail::select(::boost::tuples::get<0>(args), CALL_ACTUAL_ARGS); |
| } |
| catch (Catch1& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<1, Args>::type> |
| ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| } |
| }; |
| |
| |
| |
| template<class Args> |
| class lambda_functor_base<action<2, try_catch_action<catch_action<detail::catch_all_block> > >, Args> { |
| public: |
| Args args; |
| public: |
| explicit lambda_functor_base(const Args& a) : args(a) {} |
| |
| template <class SigArgs> struct sig { |
| typedef typename |
| as_lambda_functor< |
| typename boost::tuples::element<0, Args>::type |
| >::type lf_type; |
| |
| typedef typename lf_type::inherited::template sig<SigArgs>::type type; |
| }; |
| |
| template<class RET, CALL_TEMPLATE_ARGS> |
| RET call(CALL_FORMAL_ARGS) const { |
| try |
| { |
| return detail::select(::boost::tuples::get<0>(args), CALL_ACTUAL_ARGS); |
| } |
| catch (...) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<1, Args>::type> |
| ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS); |
| } |
| } |
| }; |
| |
| |
| // 2 catch types case |
| template<class Args, class Catch1, class Catch2> |
| class lambda_functor_base<action<3, try_catch_action<catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2> > > >, Args> { |
| public: |
| Args args; |
| public: |
| explicit lambda_functor_base(const Args& a) : args(a) {} |
| |
| template <class SigArgs> struct sig { |
| typedef typename |
| as_lambda_functor< |
| typename boost::tuples::element<0, Args>::type |
| >::type lf_type; |
| |
| typedef typename lf_type::inherited::template sig<SigArgs>::type type; |
| }; |
| |
| template<class RET, CALL_TEMPLATE_ARGS> |
| RET call(CALL_FORMAL_ARGS) const { |
| try |
| { |
| return detail::select(::boost::tuples::get<0>(args), CALL_ACTUAL_ARGS); |
| } |
| catch (Catch1& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<1, Args>::type> |
| ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch2& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<2, Args>::type> |
| ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| } |
| }; |
| |
| template<class Args, class Catch1> |
| class lambda_functor_base<action<3, try_catch_action<catch_action<detail::catch_block<Catch1>,detail::catch_all_block> > >, Args> { |
| public: |
| Args args; |
| public: |
| explicit lambda_functor_base(const Args& a) : args(a) {} |
| |
| template <class SigArgs> struct sig { |
| typedef typename |
| as_lambda_functor< |
| typename boost::tuples::element<0, Args>::type |
| >::type lf_type; |
| |
| typedef typename lf_type::inherited::template sig<SigArgs>::type type; |
| }; |
| |
| template<class RET, CALL_TEMPLATE_ARGS> |
| RET call(CALL_FORMAL_ARGS) const { |
| try |
| { |
| return detail::select(::boost::tuples::get<0>(args), CALL_ACTUAL_ARGS); |
| } |
| catch (Catch1& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<1, Args>::type> |
| ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (...) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<2, Args>::type> |
| ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS); |
| } |
| } |
| }; |
| |
| // 3 catch types case |
| template<class Args, class Catch1, class Catch2, class Catch3> |
| class lambda_functor_base<action<4, try_catch_action<catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3> > > >, Args> { |
| public: |
| Args args; |
| public: |
| explicit lambda_functor_base(const Args& a) : args(a) {} |
| |
| template <class SigArgs> struct sig { |
| typedef typename |
| as_lambda_functor< |
| typename boost::tuples::element<0, Args>::type |
| >::type lf_type; |
| |
| typedef typename lf_type::inherited::template sig<SigArgs>::type type; |
| }; |
| |
| template<class RET, CALL_TEMPLATE_ARGS> |
| RET call(CALL_FORMAL_ARGS) const { |
| try |
| { |
| return detail::select(::boost::tuples::get<0>(args), CALL_ACTUAL_ARGS); |
| } |
| catch (Catch1& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<1, Args>::type> |
| ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| |
| } |
| catch (Catch2& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<2, Args>::type> |
| ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| |
| } |
| catch (Catch3& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<3, Args>::type> |
| ::call(::boost::tuples::get<3>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| } |
| }; |
| |
| template<class Args, class Catch1, class Catch2> |
| class lambda_functor_base<action<4, try_catch_action<catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>,detail::catch_all_block> > >, Args> { |
| public: |
| Args args; |
| public: |
| explicit lambda_functor_base(const Args& a) : args(a) {} |
| |
| template <class SigArgs> struct sig { |
| typedef typename |
| as_lambda_functor< |
| typename boost::tuples::element<0, Args>::type |
| >::type lf_type; |
| |
| typedef typename lf_type::inherited::template sig<SigArgs>::type type; |
| }; |
| |
| template<class RET, CALL_TEMPLATE_ARGS> |
| RET call(CALL_FORMAL_ARGS) const { |
| try |
| { |
| return detail::select(::boost::tuples::get<0>(args), CALL_ACTUAL_ARGS); |
| } |
| catch (Catch1& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<1, Args>::type> |
| ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch2& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<2, Args>::type> |
| ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (...) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<3, Args>::type> |
| ::call(::boost::tuples::get<3>(args), CALL_ACTUAL_ARGS); |
| } |
| } |
| }; |
| |
| // 4 catch types case |
| template<class Args, class Catch1, class Catch2, class Catch3, class Catch4> |
| 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> { |
| public: |
| Args args; |
| public: |
| explicit lambda_functor_base(const Args& a) : args(a) {} |
| |
| template <class SigArgs> struct sig { |
| typedef typename |
| as_lambda_functor< |
| typename boost::tuples::element<0, Args>::type |
| >::type lf_type; |
| |
| typedef typename lf_type::inherited::template sig<SigArgs>::type type; |
| }; |
| |
| template<class RET, CALL_TEMPLATE_ARGS> |
| RET call(CALL_FORMAL_ARGS) const { |
| try |
| { |
| return detail::select(::boost::tuples::get<0>(args), CALL_ACTUAL_ARGS); |
| } |
| catch (Catch1& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<1, Args>::type> |
| ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch2& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<2, Args>::type> |
| ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch3& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<3, Args>::type> |
| ::call(::boost::tuples::get<3>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch4& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<4, Args>::type> |
| ::call(::boost::tuples::get<4>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| } |
| }; |
| |
| template<class Args, class Catch1, class Catch2, class Catch3> |
| 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> { |
| public: |
| Args args; |
| public: |
| explicit lambda_functor_base(const Args& a) : args(a) {} |
| |
| template <class SigArgs> struct sig { |
| typedef typename |
| as_lambda_functor< |
| typename boost::tuples::element<0, Args>::type |
| >::type lf_type; |
| |
| typedef typename lf_type::inherited::template sig<SigArgs>::type type; |
| }; |
| |
| template<class RET, CALL_TEMPLATE_ARGS> |
| RET call(CALL_FORMAL_ARGS) const { |
| try |
| { |
| return detail::select(::boost::tuples::get<0>(args), CALL_ACTUAL_ARGS); |
| } |
| catch (Catch1& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<1, Args>::type> |
| ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch2& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<2, Args>::type> |
| ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch3& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<3, Args>::type> |
| ::call(::boost::tuples::get<3>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (...) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<4, Args>::type> |
| ::call(::boost::tuples::get<4>(args), CALL_ACTUAL_ARGS); |
| } |
| } |
| }; |
| |
| // 5 catch types case |
| template<class Args, class Catch1, class Catch2, class Catch3, class Catch4, class Catch5> |
| 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> { |
| public: |
| Args args; |
| public: |
| explicit lambda_functor_base(const Args& a) : args(a) {} |
| |
| template <class SigArgs> struct sig { |
| typedef typename |
| as_lambda_functor< |
| typename boost::tuples::element<0, Args>::type |
| >::type lf_type; |
| |
| typedef typename lf_type::inherited::template sig<SigArgs>::type type; |
| }; |
| |
| template<class RET, CALL_TEMPLATE_ARGS> |
| RET call(CALL_FORMAL_ARGS) const { |
| try |
| { |
| return detail::select(::boost::tuples::get<0>(args), CALL_ACTUAL_ARGS); |
| } |
| catch (Catch1& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<1, Args>::type> |
| ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch2& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<2, Args>::type> |
| ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch3& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<3, Args>::type> |
| ::call(::boost::tuples::get<3>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch4& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<4, Args>::type> |
| ::call(::boost::tuples::get<4>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch5& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<4, Args>::type> |
| ::call(::boost::tuples::get<5>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| } |
| }; |
| |
| template<class Args, class Catch1, class Catch2, class Catch3, class Catch4> |
| 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> { |
| public: |
| Args args; |
| public: |
| explicit lambda_functor_base(const Args& a) : args(a) {} |
| |
| template <class SigArgs> struct sig { |
| typedef typename |
| as_lambda_functor< |
| typename boost::tuples::element<0, Args>::type |
| >::type lf_type; |
| |
| typedef typename lf_type::inherited::template sig<SigArgs>::type type; |
| }; |
| |
| template<class RET, CALL_TEMPLATE_ARGS> |
| RET call(CALL_FORMAL_ARGS) const { |
| try |
| { |
| return detail::select(::boost::tuples::get<0>(args), CALL_ACTUAL_ARGS); |
| } |
| catch (Catch1& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<1, Args>::type> |
| ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch2& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<2, Args>::type> |
| ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch3& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<3, Args>::type> |
| ::call(::boost::tuples::get<3>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch4& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<4, Args>::type> |
| ::call(::boost::tuples::get<4>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (...) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<5, Args>::type> |
| ::call(::boost::tuples::get<5>(args), CALL_ACTUAL_ARGS); |
| } |
| } |
| }; |
| |
| // 6 catch types case |
| template<class Args, class Catch1, class Catch2, class Catch3, class Catch4, class Catch5, class Catch6> |
| class lambda_functor_base<action<7, try_catch_action<catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3>, detail::catch_block<Catch4>, detail::catch_block<Catch5>, detail::catch_block<Catch6> > > >, Args> { |
| public: |
| Args args; |
| public: |
| explicit lambda_functor_base(const Args& a) : args(a) {} |
| |
| template <class SigArgs> struct sig { |
| typedef typename |
| as_lambda_functor< |
| typename boost::tuples::element<0, Args>::type |
| >::type lf_type; |
| |
| typedef typename lf_type::inherited::template sig<SigArgs>::type type; |
| }; |
| |
| template<class RET, CALL_TEMPLATE_ARGS> |
| RET call(CALL_FORMAL_ARGS) const { |
| try |
| { |
| return detail::select(::boost::tuples::get<0>(args), CALL_ACTUAL_ARGS); |
| } |
| catch (Catch1& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<1, Args>::type> |
| ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch2& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<2, Args>::type> |
| ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch3& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<3, Args>::type> |
| ::call(::boost::tuples::get<3>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch4& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<4, Args>::type> |
| ::call(::boost::tuples::get<4>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch5& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<5, Args>::type> |
| ::call(::boost::tuples::get<5>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch6& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<6, Args>::type> |
| ::call(::boost::tuples::get<6>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| } |
| }; |
| |
| template<class Args, class Catch1, class Catch2, class Catch3, class Catch4, class Catch5> |
| class lambda_functor_base<action<7, try_catch_action<catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3>, detail::catch_block<Catch4>, detail::catch_block<Catch5>,detail::catch_all_block> > >, Args> { |
| public: |
| Args args; |
| public: |
| explicit lambda_functor_base(const Args& a) : args(a) {} |
| |
| template <class SigArgs> struct sig { |
| typedef typename |
| as_lambda_functor< |
| typename boost::tuples::element<0, Args>::type |
| >::type lf_type; |
| |
| typedef typename lf_type::inherited::template sig<SigArgs>::type type; |
| }; |
| |
| template<class RET, CALL_TEMPLATE_ARGS> |
| RET call(CALL_FORMAL_ARGS) const { |
| try |
| { |
| return detail::select(::boost::tuples::get<0>(args), CALL_ACTUAL_ARGS); |
| } |
| catch (Catch1& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<1, Args>::type> |
| ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch2& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<2, Args>::type> |
| ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch3& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<3, Args>::type> |
| ::call(::boost::tuples::get<3>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch4& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<4, Args>::type> |
| ::call(::boost::tuples::get<4>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch5& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<5, Args>::type> |
| ::call(::boost::tuples::get<5>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (...) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<6, Args>::type> |
| ::call(::boost::tuples::get<6>(args), CALL_ACTUAL_ARGS); |
| } |
| } |
| }; |
| |
| // 7 catch types case |
| template<class Args, class Catch1, class Catch2, class Catch3, class Catch4, class Catch5, class Catch6, |
| class Catch7> |
| class lambda_functor_base<action<8, try_catch_action<catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3>, detail::catch_block<Catch4>, detail::catch_block<Catch5>, detail::catch_block<Catch6>, detail::catch_block<Catch7> > > >, Args> { |
| public: |
| Args args; |
| public: |
| explicit lambda_functor_base(const Args& a) : args(a) {} |
| |
| template <class SigArgs> struct sig { |
| typedef typename |
| as_lambda_functor< |
| typename boost::tuples::element<0, Args>::type |
| >::type lf_type; |
| |
| typedef typename lf_type::inherited::template sig<SigArgs>::type type; |
| }; |
| |
| template<class RET, CALL_TEMPLATE_ARGS> |
| RET call(CALL_FORMAL_ARGS) const { |
| try |
| { |
| return detail::select(::boost::tuples::get<0>(args), CALL_ACTUAL_ARGS); |
| } |
| catch (Catch1& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<1, Args>::type> |
| ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch2& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<2, Args>::type> |
| ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch3& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<3, Args>::type> |
| ::call(::boost::tuples::get<3>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch4& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<4, Args>::type> |
| ::call(::boost::tuples::get<4>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch5& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<5, Args>::type> |
| ::call(::boost::tuples::get<5>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch6& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<6, Args>::type> |
| ::call(::boost::tuples::get<6>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch7& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<7, Args>::type> |
| ::call(::boost::tuples::get<7>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| } |
| }; |
| |
| template<class Args, class Catch1, class Catch2, class Catch3, class Catch4, class Catch5, class Catch6> |
| class lambda_functor_base<action<8, try_catch_action<catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3>, detail::catch_block<Catch4>, detail::catch_block<Catch5>, detail::catch_block<Catch6>, |
| detail::catch_all_block> > >, Args> { |
| public: |
| Args args; |
| public: |
| explicit lambda_functor_base(const Args& a) : args(a) {} |
| |
| template <class SigArgs> struct sig { |
| typedef typename |
| as_lambda_functor< |
| typename boost::tuples::element<0, Args>::type |
| >::type lf_type; |
| |
| typedef typename lf_type::inherited::template sig<SigArgs>::type type; |
| }; |
| |
| template<class RET, CALL_TEMPLATE_ARGS> |
| RET call(CALL_FORMAL_ARGS) const { |
| try |
| { |
| return detail::select(::boost::tuples::get<0>(args), CALL_ACTUAL_ARGS); |
| } |
| catch (Catch1& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<1, Args>::type> |
| ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch2& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<2, Args>::type> |
| ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch3& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<3, Args>::type> |
| ::call(::boost::tuples::get<3>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch4& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<4, Args>::type> |
| ::call(::boost::tuples::get<4>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch5& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<5, Args>::type> |
| ::call(::boost::tuples::get<5>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch6& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<6, Args>::type> |
| ::call(::boost::tuples::get<6>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (...) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<7, Args>::type> |
| ::call(::boost::tuples::get<7>(args), CALL_ACTUAL_ARGS); |
| } |
| } |
| }; |
| |
| // 8 catch types case |
| template<class Args, class Catch1, class Catch2, class Catch3, class Catch4, class Catch5, class Catch6, |
| class Catch7, class Catch8> |
| class lambda_functor_base<action<9, try_catch_action<catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3>, detail::catch_block<Catch4>, detail::catch_block<Catch5>, detail::catch_block<Catch6>, |
| detail::catch_block<Catch7>, detail::catch_block<Catch8> > > >, Args> { |
| public: |
| Args args; |
| public: |
| explicit lambda_functor_base(const Args& a) : args(a) {} |
| |
| template <class SigArgs> struct sig { |
| typedef typename |
| as_lambda_functor< |
| typename boost::tuples::element<0, Args>::type |
| >::type lf_type; |
| |
| typedef typename lf_type::inherited::template sig<SigArgs>::type type; |
| }; |
| |
| template<class RET, CALL_TEMPLATE_ARGS> |
| RET call(CALL_FORMAL_ARGS) const { |
| try |
| { |
| return detail::select(::boost::tuples::get<0>(args), CALL_ACTUAL_ARGS); |
| } |
| catch (Catch1& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<1, Args>::type> |
| ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch2& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<2, Args>::type> |
| ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch3& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<3, Args>::type> |
| ::call(::boost::tuples::get<3>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch4& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<4, Args>::type> |
| ::call(::boost::tuples::get<4>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch5& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<5, Args>::type> |
| ::call(::boost::tuples::get<5>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch6& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<6, Args>::type> |
| ::call(::boost::tuples::get<6>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch7& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<7, Args>::type> |
| ::call(::boost::tuples::get<7>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch8& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<8, Args>::type> |
| ::call(::boost::tuples::get<8>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| } |
| }; |
| |
| template<class Args, class Catch1, class Catch2, class Catch3, class Catch4, class Catch5, class Catch6, |
| class Catch7> |
| class lambda_functor_base<action<9, try_catch_action<catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3>, detail::catch_block<Catch4>, detail::catch_block<Catch5>, detail::catch_block<Catch6>, |
| detail::catch_block<Catch7>,detail::catch_all_block> > >, Args> { |
| public: |
| Args args; |
| public: |
| explicit lambda_functor_base(const Args& a) : args(a) {} |
| |
| template <class SigArgs> struct sig { |
| typedef typename |
| as_lambda_functor< |
| typename boost::tuples::element<0, Args>::type |
| >::type lf_type; |
| |
| typedef typename lf_type::inherited::template sig<SigArgs>::type type; |
| }; |
| |
| template<class RET, CALL_TEMPLATE_ARGS> |
| RET call(CALL_FORMAL_ARGS) const { |
| try |
| { |
| return detail::select(::boost::tuples::get<0>(args), CALL_ACTUAL_ARGS); |
| } |
| catch (Catch1& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<1, Args>::type> |
| ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch2& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<2, Args>::type> |
| ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch3& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<3, Args>::type> |
| ::call(::boost::tuples::get<3>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch4& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<4, Args>::type> |
| ::call(::boost::tuples::get<4>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch5& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<5, Args>::type> |
| ::call(::boost::tuples::get<5>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch6& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<6, Args>::type> |
| ::call(::boost::tuples::get<6>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch7& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<7, Args>::type> |
| ::call(::boost::tuples::get<7>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (...) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<8, Args>::type> |
| ::call(::boost::tuples::get<8>(args), CALL_ACTUAL_ARGS); |
| } |
| } |
| }; |
| |
| // 9 catch types case |
| template<class Args, class Catch1, class Catch2, class Catch3, class Catch4, class Catch5, class Catch6, |
| class Catch7, class Catch8, class Catch9> |
| class lambda_functor_base<action<10, try_catch_action<catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3>, detail::catch_block<Catch4>, detail::catch_block<Catch5>, detail::catch_block<Catch6>, |
| detail::catch_block<Catch7>, detail::catch_block<Catch8>, detail::catch_block<Catch9> > > >, Args> { |
| public: |
| Args args; |
| public: |
| explicit lambda_functor_base(const Args& a) : args(a) {} |
| |
| template <class SigArgs> struct sig { |
| typedef typename |
| as_lambda_functor< |
| typename boost::tuples::element<0, Args>::type |
| >::type lf_type; |
| |
| typedef typename lf_type::inherited::template sig<SigArgs>::type type; |
| }; |
| |
| template<class RET, CALL_TEMPLATE_ARGS> |
| RET call(CALL_FORMAL_ARGS) const { |
| try |
| { |
| return detail::select(::boost::tuples::get<0>(args), CALL_ACTUAL_ARGS); |
| } |
| catch (Catch1& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<1, Args>::type> |
| ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch2& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<2, Args>::type> |
| ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch3& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<3, Args>::type> |
| ::call(::boost::tuples::get<3>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch4& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<4, Args>::type> |
| ::call(::boost::tuples::get<4>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch5& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<5, Args>::type> |
| ::call(::boost::tuples::get<5>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch6& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<6, Args>::type> |
| ::call(::boost::tuples::get<6>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch7& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<7, Args>::type> |
| ::call(::boost::tuples::get<7>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch8& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<8, Args>::type> |
| ::call(::boost::tuples::get<8>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch9& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<9, Args>::type> |
| ::call(::boost::tuples::get<9>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| } |
| }; |
| |
| template<class Args, class Catch1, class Catch2, class Catch3, class Catch4, class Catch5, class Catch6, |
| class Catch7, class Catch8> |
| class lambda_functor_base<action<10, try_catch_action<catch_action<detail::catch_block<Catch1>, detail::catch_block<Catch2>, detail::catch_block<Catch3>, detail::catch_block<Catch4>, detail::catch_block<Catch5>, detail::catch_block<Catch6>, |
| detail::catch_block<Catch7>, detail::catch_block<Catch8>,detail::catch_all_block> > >, Args> { |
| public: |
| Args args; |
| public: |
| explicit lambda_functor_base(const Args& a) : args(a) {} |
| |
| template <class SigArgs> struct sig { |
| typedef typename |
| as_lambda_functor< |
| typename boost::tuples::element<0, Args>::type |
| >::type lf_type; |
| |
| typedef typename lf_type::inherited::template sig<SigArgs>::type type; |
| }; |
| |
| template<class RET, CALL_TEMPLATE_ARGS> |
| RET call(CALL_FORMAL_ARGS) const { |
| try |
| { |
| return detail::select(::boost::tuples::get<0>(args), CALL_ACTUAL_ARGS); |
| } |
| catch (Catch1& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<1, Args>::type> |
| ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch2& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<2, Args>::type> |
| ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch3& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<3, Args>::type> |
| ::call(::boost::tuples::get<3>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch4& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<4, Args>::type> |
| ::call(::boost::tuples::get<4>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch5& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<5, Args>::type> |
| ::call(::boost::tuples::get<5>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch6& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<6, Args>::type> |
| ::call(::boost::tuples::get<6>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch7& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<7, Args>::type> |
| ::call(::boost::tuples::get<7>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (Catch8& e) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<8, Args>::type> |
| ::call(::boost::tuples::get<8>(args), CALL_ACTUAL_ARGS_NO_ENV, e); |
| } |
| catch (...) |
| { |
| return |
| detail::return_or_throw<RET, typename ::boost::tuples::element<9, Args>::type> |
| ::call(::boost::tuples::get<9>(args), CALL_ACTUAL_ARGS); |
| } |
| } |
| }; |
| |
| |
| } // namespace lambda |
| } // namespace boost |
| |
| |
| #endif |
| |
| |
| |
| |
| |
| |