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