// -- 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 > placeholderE_type; namespace { boost::lambda::placeholderE_type freeE; boost::lambda::placeholderE_type& _e = freeE; } // -- exception related actions ------------------- // catch actions. template struct catch_action {}; struct catch_all_action {}; template struct return_try_catch_action {}; template struct try_catch_action {}; // rethrow actions struct throw_new_action {}; struct rethrow_action {}; template struct throw_action; template<> struct throw_action { template static RET apply() { throw; } }; template<> struct throw_action { template static RET apply(T& t) { throw t; } }; // return types for throw_actions -------------------------------------------- template struct return_type_N, 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 struct throws_for_sure_phase2 { static const bool value = false; }; template struct throws_for_sure_phase2< lambda_functor< lambda_functor_base >, Args> > > { static const bool value = true; }; // Both then and else or the if throw of an if_then_else. template 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 struct throws_for_sure_phase2< lambda_functor< lambda_functor_base< other_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 struct throws_for_sure { static const bool value = throws_for_sure_phase2< typename detail::remove_reference_and_cv::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 struct return_or_throw_phase2 { template static RET call(Arg& arg, CALL_FORMAL_ARGS) { BOOST_STATIC_ASSERT(throws_for_sure::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 { template 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 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 static RET call(Arg& arg, CALL_FORMAL_ARGS) { // typedef typename Arg::return_type >::type RT; typedef typename as_lambda_functor::type lf_type; typedef typename lf_type::inherited::template sig >::type RT; return return_or_throw_phase2< ::boost::is_convertible::value >::template call(arg, CALL_ACTUAL_ARGS); } }; // if try part returns void, we do not return the catch parts either template struct return_or_throw { template static void call(Arg& arg, CALL_FORMAL_ARGS) { detail::select(arg, CALL_ACTUAL_ARGS); } }; } // end detail // Throwing exceptions --------------------------------------------- namespace detail { template struct catch_block {}; struct catch_all_block {}; template struct exception_catch_tag {}; // normal catch block is represented as // tagged_lambda_functor > >, LambdaFunctor> // the default catch all block as: // tagged_lambda_functor >, 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 >, null_type > > rethrow() { return lambda_functor_base< action<0, throw_action >, null_type > ( null_type() ); } template inline const lambda_functor< lambda_functor_base< action<1, throw_action >, tuple::type> > > throw_exception(const Arg1& a1) { return lambda_functor_base< action<1, throw_action >, tuple::type> > ( tuple::type>(a1)); } // create catch blocks template inline const tagged_lambda_functor< detail::exception_catch_tag >, lambda_functor > catch_exception(const lambda_functor& a) { // the third placeholder cannot be used in catch_exception // BOOST_STATIC_ASSERT((!has_placeholder::value)); return tagged_lambda_functor< detail::exception_catch_tag >, lambda_functor > (a); } // catch and do nothing case. template inline const tagged_lambda_functor< detail::exception_catch_tag >, lambda_functor< lambda_functor_base< do_nothing_action, null_type > > > catch_exception() { return tagged_lambda_functor< detail::exception_catch_tag >, lambda_functor< lambda_functor_base< do_nothing_action, null_type > > > (); } // create catch(...) blocks template inline const tagged_lambda_functor< detail::exception_catch_tag, lambda_functor > catch_all(const lambda_functor& a) { // the third placeholder cannot be used in catch_exception BOOST_STATIC_ASSERT((!has_placeholder::value)); return tagged_lambda_functor< detail::exception_catch_tag, lambda_functor > (a); } // catch(...) and do nothing case. inline const tagged_lambda_functor< detail::exception_catch_tag, lambda_functor< lambda_functor_base< do_nothing_action, null_type > > > catch_all() { return tagged_lambda_functor< detail::exception_catch_tag, 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 inline const lambda_functor< lambda_functor_base< action<2, try_catch_action > >, tuple, LF1> > > try_catch( const lambda_functor& a1, const tagged_lambda_functor, LF1>& a2) { return lambda_functor_base< action<2, try_catch_action > >, tuple, LF1> > ( tuple< lambda_functor, LF1>(a1, a2)); } template inline const lambda_functor< lambda_functor_base< action<3, try_catch_action, Catch2> > >, tuple, LF1, LF2> > > try_catch( const lambda_functor& a1, const tagged_lambda_functor >, LF1>& a2, const tagged_lambda_functor, LF2>& a3) { return lambda_functor_base< action<3, try_catch_action, Catch2> > >, tuple, LF1, LF2> > ( tuple, LF1, LF2>(a1, a2, a3)); } template inline const lambda_functor< lambda_functor_base< action<4, try_catch_action, detail::catch_block, Catch3> > >, tuple, LF1, LF2, LF3> > > try_catch( const lambda_functor& a1, const tagged_lambda_functor >, LF1>& a2, const tagged_lambda_functor >, LF2>& a3, const tagged_lambda_functor, LF3>& a4) { return lambda_functor_base< action<4, try_catch_action, detail::catch_block, Catch3> > >, tuple, LF1, LF2, LF3> > ( tuple, LF1, LF2, LF3>(a1, a2, a3, a4)); } template inline const lambda_functor< lambda_functor_base< action< 5, try_catch_action< catch_action, detail::catch_block, detail::catch_block, Catch4> > >, tuple, LF1, LF2, LF3, LF4> > > try_catch( const lambda_functor& a1, const tagged_lambda_functor >, LF1>& a2, const tagged_lambda_functor >, LF2>& a3, const tagged_lambda_functor >, LF3>& a4, const tagged_lambda_functor, LF4>& a5) { return lambda_functor_base< action< 5, try_catch_action, detail::catch_block, detail::catch_block, Catch4> > >, tuple, LF1, LF2, LF3, LF4> > ( tuple, LF1, LF2, LF3, LF4>(a1, a2, a3, a4, a5)); } template inline const lambda_functor< lambda_functor_base< action< 6, try_catch_action, detail::catch_block, detail::catch_block, detail::catch_block, Catch5> > >, tuple, LF1, LF2, LF3, LF4, LF5> > > try_catch( const lambda_functor& a1, const tagged_lambda_functor >, LF1>& a2, const tagged_lambda_functor >, LF2>& a3, const tagged_lambda_functor >, LF3>& a4, const tagged_lambda_functor >, LF4>& a5, const tagged_lambda_functor, LF5>& a6) { return lambda_functor_base< action< 6, try_catch_action< catch_action, detail::catch_block, detail::catch_block, detail::catch_block, Catch5> > >, tuple, LF1, LF2, LF3, LF4, LF5> > ( tuple, LF1, LF2, LF3, LF4, LF5> (a1, a2, a3, a4, a5, a6) ); } template inline const lambda_functor< lambda_functor_base< action< 7, try_catch_action< catch_action, detail::catch_block, detail::catch_block, detail::catch_block, detail::catch_block, Catch6> > >, tuple, LF1, LF2, LF3, LF4, LF5, LF6> > > try_catch( const lambda_functor& a1, const tagged_lambda_functor >, LF1>& a2, const tagged_lambda_functor >, LF2>& a3, const tagged_lambda_functor >, LF3>& a4, const tagged_lambda_functor >, LF4>& a5, const tagged_lambda_functor >, LF5>& a6, const tagged_lambda_functor, LF6>& a7) { return lambda_functor_base< action< 7, try_catch_action< catch_action, detail::catch_block, detail::catch_block, detail::catch_block, detail::catch_block,Catch6> > >, tuple, LF1, LF2, LF3, LF4, LF5, LF6> > ( tuple, LF1, LF2, LF3, LF4, LF5, LF6> (a1, a2, a3, a4, a5, a6, a7)); } template inline const lambda_functor< lambda_functor_base< action< 8, try_catch_action< catch_action, detail::catch_block, detail::catch_block, detail::catch_block, detail::catch_block, detail::catch_block, Catch7> > >, tuple, LF1, LF2, LF3, LF4, LF5, LF6, LF7> > > try_catch( const lambda_functor& a1, const tagged_lambda_functor >, LF1>& a2, const tagged_lambda_functor >, LF2>& a3, const tagged_lambda_functor >, LF3>& a4, const tagged_lambda_functor >, LF4>& a5, const tagged_lambda_functor >, LF5>& a6, const tagged_lambda_functor >, LF6>& a7, const tagged_lambda_functor, LF7>& a8) { return lambda_functor_base< action< 8, try_catch_action< catch_action< detail::catch_block, detail::catch_block, detail::catch_block, detail::catch_block, detail::catch_block, detail::catch_block, Catch7 > > >, tuple, LF1, LF2, LF3, LF4, LF5, LF6, LF7> > ( tuple, LF1, LF2, LF3, LF4, LF5, LF6, LF7> (a1, a2, a3, a4, a5, a6, a7, a8)); } template inline const lambda_functor< lambda_functor_base< action< 9, try_catch_action< catch_action< detail::catch_block, detail::catch_block, detail::catch_block, detail::catch_block, detail::catch_block, detail::catch_block, detail::catch_block, Catch8 > > >, tuple, LF1, LF2, LF3, LF4, LF5, LF6, LF7, LF8> > > try_catch( const lambda_functor& a1, const tagged_lambda_functor >, LF1>& a2, const tagged_lambda_functor >, LF2>& a3, const tagged_lambda_functor >, LF3>& a4, const tagged_lambda_functor >, LF4>& a5, const tagged_lambda_functor >, LF5>& a6, const tagged_lambda_functor >, LF6>& a7, const tagged_lambda_functor >, LF7>& a8, const tagged_lambda_functor, LF8>& a9) { return lambda_functor_base< action< 9, try_catch_action< catch_action< detail::catch_block, detail::catch_block, detail::catch_block, detail::catch_block, detail::catch_block, detail::catch_block, detail::catch_block, Catch8 > > >, tuple, LF1, LF2, LF3, LF4, LF5, LF6, LF7, LF8> > ( tuple, LF1, LF2, LF3, LF4, LF5, LF6, LF7, LF8> (a1, a2, a3, a4, a5, a6, a7, a8, a9)); } template inline const lambda_functor< lambda_functor_base< action< 10, try_catch_action< catch_action< detail::catch_block, detail::catch_block, detail::catch_block, detail::catch_block, detail::catch_block, detail::catch_block, detail::catch_block, detail::catch_block, Catch9 > > >, tuple< lambda_functor, LF1, LF2, LF3, LF4, LF5, LF6, LF7, LF8, LF9 > > > try_catch( const lambda_functor& a1, const tagged_lambda_functor >, LF1>& a2, const tagged_lambda_functor >, LF2>& a3, const tagged_lambda_functor >, LF3>& a4, const tagged_lambda_functor >, LF4>& a5, const tagged_lambda_functor >, LF5>& a6, const tagged_lambda_functor >, LF6>& a7, const tagged_lambda_functor >, LF7>& a8, const tagged_lambda_functor >, LF8>& a9, const tagged_lambda_functor, LF9>& a10) { return lambda_functor_base< action< 10, try_catch_action< catch_action< detail::catch_block, detail::catch_block, detail::catch_block, detail::catch_block, detail::catch_block, detail::catch_block, detail::catch_block, detail::catch_block, Catch9 > > >, tuple< lambda_functor, LF1, LF2, LF3, LF4, LF5, LF6, LF7, LF8, LF9 > > ( tuple< lambda_functor, 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 lambda_functor_base< action<2, try_catch_action > > >, 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 struct sig { typedef typename as_lambda_functor< typename boost::tuples::element<0, Args>::type >::type lf_type; typedef typename lf_type::inherited::template sig::type type; }; template 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::type> ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e); } } }; template class lambda_functor_base > >, Args> { public: Args args; public: explicit lambda_functor_base(const Args& a) : args(a) {} template struct sig { typedef typename as_lambda_functor< typename boost::tuples::element<0, Args>::type >::type lf_type; typedef typename lf_type::inherited::template sig::type type; }; template RET call(CALL_FORMAL_ARGS) const { try { return detail::select(::boost::tuples::get<0>(args), CALL_ACTUAL_ARGS); } catch (...) { return detail::return_or_throw::type> ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS); } } }; // 2 catch types case template class lambda_functor_base, detail::catch_block > > >, Args> { public: Args args; public: explicit lambda_functor_base(const Args& a) : args(a) {} template struct sig { typedef typename as_lambda_functor< typename boost::tuples::element<0, Args>::type >::type lf_type; typedef typename lf_type::inherited::template sig::type type; }; template 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::type> ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e); } catch (Catch2& e) { return detail::return_or_throw::type> ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS_NO_ENV, e); } } }; template class lambda_functor_base,detail::catch_all_block> > >, Args> { public: Args args; public: explicit lambda_functor_base(const Args& a) : args(a) {} template struct sig { typedef typename as_lambda_functor< typename boost::tuples::element<0, Args>::type >::type lf_type; typedef typename lf_type::inherited::template sig::type type; }; template 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::type> ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e); } catch (...) { return detail::return_or_throw::type> ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS); } } }; // 3 catch types case template class lambda_functor_base, detail::catch_block, detail::catch_block > > >, Args> { public: Args args; public: explicit lambda_functor_base(const Args& a) : args(a) {} template struct sig { typedef typename as_lambda_functor< typename boost::tuples::element<0, Args>::type >::type lf_type; typedef typename lf_type::inherited::template sig::type type; }; template 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::type> ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e); } catch (Catch2& e) { return detail::return_or_throw::type> ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS_NO_ENV, e); } catch (Catch3& e) { return detail::return_or_throw::type> ::call(::boost::tuples::get<3>(args), CALL_ACTUAL_ARGS_NO_ENV, e); } } }; template class lambda_functor_base, detail::catch_block,detail::catch_all_block> > >, Args> { public: Args args; public: explicit lambda_functor_base(const Args& a) : args(a) {} template struct sig { typedef typename as_lambda_functor< typename boost::tuples::element<0, Args>::type >::type lf_type; typedef typename lf_type::inherited::template sig::type type; }; template 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::type> ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e); } catch (Catch2& e) { return detail::return_or_throw::type> ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS_NO_ENV, e); } catch (...) { return detail::return_or_throw::type> ::call(::boost::tuples::get<3>(args), CALL_ACTUAL_ARGS); } } }; // 4 catch types case template class lambda_functor_base, detail::catch_block, detail::catch_block, detail::catch_block > > >, Args> { public: Args args; public: explicit lambda_functor_base(const Args& a) : args(a) {} template struct sig { typedef typename as_lambda_functor< typename boost::tuples::element<0, Args>::type >::type lf_type; typedef typename lf_type::inherited::template sig::type type; }; template 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::type> ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e); } catch (Catch2& e) { return detail::return_or_throw::type> ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS_NO_ENV, e); } catch (Catch3& e) { return detail::return_or_throw::type> ::call(::boost::tuples::get<3>(args), CALL_ACTUAL_ARGS_NO_ENV, e); } catch (Catch4& e) { return detail::return_or_throw::type> ::call(::boost::tuples::get<4>(args), CALL_ACTUAL_ARGS_NO_ENV, e); } } }; template class lambda_functor_base, detail::catch_block, detail::catch_block,detail::catch_all_block> > >, Args> { public: Args args; public: explicit lambda_functor_base(const Args& a) : args(a) {} template struct sig { typedef typename as_lambda_functor< typename boost::tuples::element<0, Args>::type >::type lf_type; typedef typename lf_type::inherited::template sig::type type; }; template 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::type> ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e); } catch (Catch2& e) { return detail::return_or_throw::type> ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS_NO_ENV, e); } catch (Catch3& e) { return detail::return_or_throw::type> ::call(::boost::tuples::get<3>(args), CALL_ACTUAL_ARGS_NO_ENV, e); } catch (...) { return detail::return_or_throw::type> ::call(::boost::tuples::get<4>(args), CALL_ACTUAL_ARGS); } } }; // 5 catch types case template class lambda_functor_base, detail::catch_block, detail::catch_block, detail::catch_block, detail::catch_block > > >, Args> { public: Args args; public: explicit lambda_functor_base(const Args& a) : args(a) {} template struct sig { typedef typename as_lambda_functor< typename boost::tuples::element<0, Args>::type >::type lf_type; typedef typename lf_type::inherited::template sig::type type; }; template 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::type> ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e); } catch (Catch2& e) { return detail::return_or_throw::type> ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS_NO_ENV, e); } catch (Catch3& e) { return detail::return_or_throw::type> ::call(::boost::tuples::get<3>(args), CALL_ACTUAL_ARGS_NO_ENV, e); } catch (Catch4& e) { return detail::return_or_throw::type> ::call(::boost::tuples::get<4>(args), CALL_ACTUAL_ARGS_NO_ENV, e); } catch (Catch5& e) { return detail::return_or_throw::type> ::call(::boost::tuples::get<5>(args), CALL_ACTUAL_ARGS_NO_ENV, e); } } }; template class lambda_functor_base, detail::catch_block, detail::catch_block, detail::catch_block,detail::catch_all_block> > >, Args> { public: Args args; public: explicit lambda_functor_base(const Args& a) : args(a) {} template struct sig { typedef typename as_lambda_functor< typename boost::tuples::element<0, Args>::type >::type lf_type; typedef typename lf_type::inherited::template sig::type type; }; template 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::type> ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e); } catch (Catch2& e) { return detail::return_or_throw::type> ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS_NO_ENV, e); } catch (Catch3& e) { return detail::return_or_throw::type> ::call(::boost::tuples::get<3>(args), CALL_ACTUAL_ARGS_NO_ENV, e); } catch (Catch4& e) { return detail::return_or_throw::type> ::call(::boost::tuples::get<4>(args), CALL_ACTUAL_ARGS_NO_ENV, e); } catch (...) { return detail::return_or_throw::type> ::call(::boost::tuples::get<5>(args), CALL_ACTUAL_ARGS); } } }; // 6 catch types case template class lambda_functor_base, detail::catch_block, detail::catch_block, detail::catch_block, detail::catch_block, detail::catch_block > > >, Args> { public: Args args; public: explicit lambda_functor_base(const Args& a) : args(a) {} template struct sig { typedef typename as_lambda_functor< typename boost::tuples::element<0, Args>::type >::type lf_type; typedef typename lf_type::inherited::template sig::type type; }; template 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::type> ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e); } catch (Catch2& e) { return detail::return_or_throw::type> ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS_NO_ENV, e); } catch (Catch3& e) { return detail::return_or_throw::type> ::call(::boost::tuples::get<3>(args), CALL_ACTUAL_ARGS_NO_ENV, e); } catch (Catch4& e) { return detail::return_or_throw::type> ::call(::boost::tuples::get<4>(args), CALL_ACTUAL_ARGS_NO_ENV, e); } catch (Catch5& e) { return detail::return_or_throw::type> ::call(::boost::tuples::get<5>(args), CALL_ACTUAL_ARGS_NO_ENV, e); } catch (Catch6& e) { return detail::return_or_throw::type> ::call(::boost::tuples::get<6>(args), CALL_ACTUAL_ARGS_NO_ENV, e); } } }; template class lambda_functor_base, detail::catch_block, detail::catch_block, detail::catch_block, detail::catch_block,detail::catch_all_block> > >, Args> { public: Args args; public: explicit lambda_functor_base(const Args& a) : args(a) {} template struct sig { typedef typename as_lambda_functor< typename boost::tuples::element<0, Args>::type >::type lf_type; typedef typename lf_type::inherited::template sig::type type; }; template 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::type> ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e); } catch (Catch2& e) { return detail::return_or_throw::type> ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS_NO_ENV, e); } catch (Catch3& e) { return detail::return_or_throw::type> ::call(::boost::tuples::get<3>(args), CALL_ACTUAL_ARGS_NO_ENV, e); } catch (Catch4& e) { return detail::return_or_throw::type> ::call(::boost::tuples::get<4>(args), CALL_ACTUAL_ARGS_NO_ENV, e); } catch (Catch5& e) { return detail::return_or_throw::type> ::call(::boost::tuples::get<5>(args), CALL_ACTUAL_ARGS_NO_ENV, e); } catch (...) { return detail::return_or_throw::type> ::call(::boost::tuples::get<6>(args), CALL_ACTUAL_ARGS); } } }; // 7 catch types case template class lambda_functor_base, detail::catch_block, detail::catch_block, detail::catch_block, detail::catch_block, detail::catch_block, detail::catch_block > > >, Args> { public: Args args; public: explicit lambda_functor_base(const Args& a) : args(a) {} template struct sig { typedef typename as_lambda_functor< typename boost::tuples::element<0, Args>::type >::type lf_type; typedef typename lf_type::inherited::template sig::type type; }; template 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::type> ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e); } catch (Catch2& e) { return detail::return_or_throw::type> ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS_NO_ENV, e); } catch (Catch3& e) { return detail::return_or_throw::type> ::call(::boost::tuples::get<3>(args), CALL_ACTUAL_ARGS_NO_ENV, e); } catch (Catch4& e) { return detail::return_or_throw::type> ::call(::boost::tuples::get<4>(args), CALL_ACTUAL_ARGS_NO_ENV, e); } catch (Catch5& e) { return detail::return_or_throw::type> ::call(::boost::tuples::get<5>(args), CALL_ACTUAL_ARGS_NO_ENV, e); } catch (Catch6& e) { return detail::return_or_throw::type> ::call(::boost::tuples::get<6>(args), CALL_ACTUAL_ARGS_NO_ENV, e); } catch (Catch7& e) { return detail::return_or_throw::type> ::call(::boost::tuples::get<7>(args), CALL_ACTUAL_ARGS_NO_ENV, e); } } }; template class lambda_functor_base, detail::catch_block, detail::catch_block, detail::catch_block, detail::catch_block, detail::catch_block, detail::catch_all_block> > >, Args> { public: Args args; public: explicit lambda_functor_base(const Args& a) : args(a) {} template struct sig { typedef typename as_lambda_functor< typename boost::tuples::element<0, Args>::type >::type lf_type; typedef typename lf_type::inherited::template sig::type type; }; template 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::type> ::call(::boost::tuples::get<1>(args), CALL_ACTUAL_ARGS_NO_ENV, e); } catch (Catch2& e) { return detail::return_or_throw::type> ::call(::boost::tuples::get<2>(args), CALL_ACTUAL_ARGS_NO_ENV, e); } catch (Catch3& e) { return detail::return_or_throw::type> ::call(::boost::tuples::get<3>(args), CALL_ACTUAL_ARGS_NO_ENV, e); } catch (Catch4& e) { return detail::return_or_throw::type> ::call(::boost::tuples::get<4>(args), CALL_ACTUAL_ARGS_NO_ENV, e); } catch (Catch5& e) { return detail::return_or_throw::type> ::call(::boost::tuples::get<5>(args), CALL_ACTUAL_ARGS_NO_ENV, e); } catch (Catch6& e) { return detail::return_or_throw::type> ::call(::boost::tuples::get<6>(args), CALL_ACTUAL_ARGS_NO_ENV, e); } catch (...) { return detail::return_or_throw::type> ::call(::boost::tuples::get<7>(args), CALL_ACTUAL_ARGS); } } }; // 8 catch types case template class lambda_functor_base, detail::catch_block, detail::catch_block, detail::catch_block, detail::catch_block, detail::catch_block, detail::catch_block, detail::catch_block > > >, Args> { public: Args args; public: explicit lambda_functor_base(const Args& a) : args(a) {} template