]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | /*============================================================================= |
2 | Copyright (c) 2010 Christopher Schmidt | |
3 | Copyright (c) 2001-2011 Joel de Guzman | |
4 | ||
5 | Distributed under the Boost Software License, Version 1.0. (See accompanying | |
6 | file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) | |
7 | ||
8 | This is an auto-generated file. Do not edit! | |
9 | ==============================================================================*/ | |
10 | # if BOOST_WORKAROUND (BOOST_MSVC, < 1500) | |
11 | # define BOOST_FUSION_FOLD_IMPL_ENABLER(T) void | |
12 | # else | |
13 | # define BOOST_FUSION_FOLD_IMPL_ENABLER(T) typename T::type | |
14 | # endif | |
15 | namespace boost { namespace fusion | |
16 | { | |
17 | namespace detail | |
18 | { | |
19 | template<int SeqSize, typename It, typename State, typename F, typename = void | |
20 | # if BOOST_WORKAROUND (BOOST_MSVC, < 1500) | |
21 | ||
22 | , bool = SeqSize == 0 | |
23 | # endif | |
24 | > | |
25 | struct result_of_it_reverse_iter_fold | |
26 | {}; | |
27 | template<typename It, typename State, typename F> | |
28 | struct result_of_it_reverse_iter_fold<0,It,State,F | |
29 | , typename boost::enable_if_has_type<BOOST_FUSION_FOLD_IMPL_ENABLER(State)>::type | |
30 | # if BOOST_WORKAROUND (BOOST_MSVC, < 1500) | |
31 | , true | |
32 | # endif | |
33 | > | |
34 | { | |
35 | typedef typename State::type type; | |
36 | }; | |
37 | template<int SeqSize, typename It, typename State, typename F> | |
38 | struct result_of_it_reverse_iter_fold<SeqSize,It,State,F | |
39 | , typename boost::enable_if_has_type< | |
40 | # if BOOST_WORKAROUND (BOOST_MSVC, >= 1500) | |
41 | ||
42 | ||
43 | ||
44 | typename boost::disable_if_c<SeqSize == 0, State>::type::type | |
45 | # else | |
46 | BOOST_FUSION_FOLD_IMPL_ENABLER(State) | |
47 | # endif | |
48 | >::type | |
49 | # if BOOST_WORKAROUND (BOOST_MSVC, < 1500) | |
50 | , false | |
51 | # endif | |
52 | > | |
53 | : result_of_it_reverse_iter_fold< | |
54 | SeqSize-1 | |
55 | , typename result_of::prior<It>::type | |
56 | , boost::result_of< | |
57 | F( | |
58 | typename add_reference<typename State::type>::type, | |
59 | It const& | |
60 | ) | |
61 | > | |
62 | , F | |
63 | > | |
64 | {}; | |
65 | template<typename It, typename State, typename F> | |
66 | BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED | |
67 | inline typename result_of_it_reverse_iter_fold< | |
68 | 0 | |
69 | , It | |
70 | , State | |
71 | , F | |
72 | >::type | |
73 | it_reverse_iter_fold(mpl::int_<0>, It const&, typename State::type state, F&) | |
74 | { | |
75 | return state; | |
76 | } | |
77 | template<typename It, typename State, typename F, int SeqSize> | |
78 | BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED | |
79 | inline typename lazy_enable_if_c< | |
80 | SeqSize != 0 | |
81 | , result_of_it_reverse_iter_fold< | |
82 | SeqSize | |
83 | , It | |
84 | , State | |
85 | , F | |
86 | > | |
87 | >::type | |
88 | it_reverse_iter_fold(mpl::int_<SeqSize>, It const& it, typename State::type state, F& f) | |
89 | { | |
90 | return it_reverse_iter_fold< | |
91 | typename result_of::prior<It>::type | |
92 | , boost::result_of< | |
93 | F( | |
94 | typename add_reference<typename State::type>::type, | |
95 | It const& | |
96 | ) | |
97 | > | |
98 | , F | |
99 | >( | |
100 | mpl::int_<SeqSize-1>() | |
101 | , fusion::prior(it) | |
102 | , f(state, it) | |
103 | , f | |
104 | ); | |
105 | } | |
106 | template<typename Seq, typename State, typename F | |
107 | , bool = traits::is_sequence<Seq>::value | |
108 | , bool = traits::is_segmented<Seq>::value> | |
109 | struct result_of_reverse_iter_fold | |
110 | {}; | |
111 | template<typename Seq, typename State, typename F> | |
112 | struct result_of_reverse_iter_fold<Seq, State, F, true, false> | |
113 | : result_of_it_reverse_iter_fold< | |
114 | result_of::size<Seq>::value | |
115 | , typename fusion::result_of::prior< typename result_of::end<Seq>::type >::type | |
116 | , add_reference<State> | |
117 | , F | |
118 | > | |
119 | {}; | |
120 | template<typename Seq, typename State, typename F> | |
121 | BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED | |
122 | inline typename result_of_reverse_iter_fold<Seq, State, F>::type | |
123 | reverse_iter_fold(Seq& seq, State& state, F& f) | |
124 | { | |
125 | return it_reverse_iter_fold< | |
126 | typename fusion::result_of::prior< typename result_of::end<Seq>::type >::type | |
127 | , add_reference<State> | |
128 | , F | |
129 | >( | |
130 | typename result_of::size<Seq>::type() | |
131 | , fusion::prior( fusion::end(seq) ) | |
132 | , state | |
133 | , f | |
134 | ); | |
135 | } | |
136 | } | |
137 | namespace result_of | |
138 | { | |
139 | template<typename Seq, typename State, typename F> | |
140 | struct reverse_iter_fold | |
141 | : detail::result_of_reverse_iter_fold<Seq, State, F> | |
142 | {}; | |
143 | } | |
144 | template<typename Seq, typename State, typename F> | |
145 | BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED | |
146 | inline typename result_of::reverse_iter_fold< | |
147 | Seq | |
148 | , State const | |
149 | , F | |
150 | >::type | |
151 | reverse_iter_fold(Seq& seq, State const& state, F f) | |
152 | { | |
153 | return detail::reverse_iter_fold<Seq, State const, F>(seq, state, f); | |
154 | } | |
155 | template<typename Seq, typename State, typename F> | |
156 | BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED | |
157 | inline typename result_of::reverse_iter_fold< | |
158 | Seq const | |
159 | , State const | |
160 | , F | |
161 | >::type | |
162 | reverse_iter_fold(Seq const& seq, State const& state, F f) | |
163 | { | |
164 | return detail::reverse_iter_fold<Seq const, State const, F>(seq, state, f); | |
165 | } | |
166 | template<typename Seq, typename State, typename F> | |
167 | BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED | |
168 | inline typename result_of::reverse_iter_fold< | |
169 | Seq | |
170 | , State | |
171 | , F | |
172 | >::type | |
173 | reverse_iter_fold(Seq& seq, State& state, F f) | |
174 | { | |
175 | return detail::reverse_iter_fold<Seq, State, F>(seq, state, f); | |
176 | } | |
177 | template<typename Seq, typename State, typename F> | |
178 | BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED | |
179 | inline typename result_of::reverse_iter_fold< | |
180 | Seq const | |
181 | , State | |
182 | , F | |
183 | >::type | |
184 | reverse_iter_fold(Seq const& seq, State& state, F f) | |
185 | { | |
186 | return detail::reverse_iter_fold<Seq const, State, F>(seq, state, f); | |
187 | } | |
188 | }} |