diff -r 000000000000 -r bde4ae8d615e os/ossrv/ossrv_pub/boost_apis/boost/lambda/exceptions.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/ossrv/ossrv_pub/boost_apis/boost/lambda/exceptions.hpp Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,1740 @@ +// -- Boost Lambda Library -- exceptions.hpp ---------------- +// +// Copyright (C) 2000 Gary Powell (gwpowell@hotmail.com) +// Copyright (C) 1999, 2000 Jaakko Järvi (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/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