1742 lines
60 KiB
C++
1742 lines
60 KiB
C++
|
// -- 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
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|