1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
|
/*
* 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.)
*
* See http://www.boost.org/libs/iostreams for documentation.
* File: boost/iostreams/detail/execute.hpp
* Date: Thu Dec 06 13:21:54 MST 2007
* Copyright: 2007-2008 CodeRage, LLC
* Author: Jonathan Turkanis
* Contact: turkanis at coderage dot com
* Defines the overloaded function template
* boost::iostreams::detail::execute_all() and the function template
* boost::iostreams::detail::execute_foreach().
*
* execute_all() invokes a primary operation and performs a sequence of cleanup
* operations, returning the result of the primary operation if no exceptions
* are thrown. If one of the operations throws an exception, performs the
* remaining operations and rethrows the initial exception.
*
* execute_foreach() is a variant of std::foreach which invokes a function
* object for each item in a sequence, catching all execptions and rethrowing
* the first caught exception after the function object has been invoked on each
* item.
*/
#ifndef BOOST_IOSTREAMS_DETAIL_EXECUTE_HPP_INCLUDED
#define BOOST_IOSTREAMS_DETAIL_EXECUTE_HPP_INCLUDED
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <boost/config.hpp>
#include <boost/detail/workaround.hpp>
#include <boost/iostreams/detail/config/limits.hpp> // MAX_EXECUTE_ARITY
#include <boost/preprocessor/arithmetic/dec.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/iteration/local.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
#include <boost/preprocessor/punctuation/comma_if.hpp>
#include <boost/utility/result_of.hpp>
namespace boost { namespace iostreams { namespace detail {
// Helper for class template execute_traits.
template<typename Result>
struct execute_traits_impl {
typedef Result result_type;
template<typename Op>
static Result execute(Op op) { return op(); }
};
// Specialization for void return. For simplicity, execute() returns int
// for operations returning void. This could be avoided with additional work.
template<>
struct execute_traits_impl<void> {
typedef int result_type;
template<typename Op>
static int execute(Op op) { op(); return 0; }
};
// Deduces the result type of Op and allows uniform treatment of operations
// returning void and non-void.
template< typename Op,
typename Result = // VC6.5 workaround.
#if !defined(BOOST_NO_RESULT_OF) && \
!BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
typename boost::result_of<Op()>::type
#else
BOOST_DEDUCED_TYPENAME Op::result_type
#endif
>
struct execute_traits
: execute_traits_impl<Result>
{ };
// Implementation with no cleanup operations.
template<typename Op>
typename execute_traits<Op>::result_type
execute_all(Op op)
{
return execute_traits<Op>::execute(op);
}
// Implementation with one or more cleanup operations
#define BOOST_PP_LOCAL_MACRO(n) \
template<typename Op, BOOST_PP_ENUM_PARAMS(n, typename C)> \
typename execute_traits<Op>::result_type \
execute_all(Op op, BOOST_PP_ENUM_BINARY_PARAMS(n, C, c)) \
{ \
typename execute_traits<Op>::result_type r; \
try { \
r = boost::iostreams::detail::execute_all( \
op BOOST_PP_COMMA_IF(BOOST_PP_DEC(n)) \
BOOST_PP_ENUM_PARAMS(BOOST_PP_DEC(n), c) \
); \
} catch (...) { \
try { \
BOOST_PP_CAT(c, BOOST_PP_DEC(n))(); \
} catch (...) { } \
throw; \
} \
BOOST_PP_CAT(c, BOOST_PP_DEC(n))(); \
return r; \
} \
/**/
#define BOOST_PP_LOCAL_LIMITS (1, BOOST_IOSTREAMS_MAX_EXECUTE_ARITY)
#include BOOST_PP_LOCAL_ITERATE()
#undef BOOST_PP_LOCAL_MACRO
template<class InIt, class Op>
Op execute_foreach(InIt first, InIt last, Op op)
{
if (first == last)
return op;
try {
op(*first);
} catch (...) {
try {
++first;
boost::iostreams::detail::execute_foreach(first, last, op);
} catch (...) { }
throw;
}
++first;
return boost::iostreams::detail::execute_foreach(first, last, op);
}
} } } // End namespaces detail, iostreams, boost.
#endif // #ifndef BOOST_IOSTREAMS_DETAIL_EXECUTE_HPP_INCLUDED
|
