1
2// Copyright Oliver Kowalke 2009.
3// Distributed under the Boost Software License, Version 1.0.
4// (See accompanying file LICENSE_1_0.txt or copy at
5// http://www.boost.org/LICENSE_1_0.txt)
6
7#ifndef BOOST_COROUTINES_DETAIL_PULL_COROUTINE_IMPL_H
8#define BOOST_COROUTINES_DETAIL_PULL_COROUTINE_IMPL_H
9
10#include <boost/assert.hpp>
11#include <boost/config.hpp>
12#include <boost/exception_ptr.hpp>
13#include <boost/throw_exception.hpp>
14#include <boost/utility.hpp>
15
16#include <boost/coroutine/detail/config.hpp>
17#include <boost/coroutine/detail/coroutine_context.hpp>
18#include <boost/coroutine/detail/flags.hpp>
19#include <boost/coroutine/detail/parameters.hpp>
20#include <boost/coroutine/detail/trampoline_pull.hpp>
21#include <boost/coroutine/exceptions.hpp>
22
23#ifdef BOOST_HAS_ABI_HEADERS
24# include BOOST_ABI_PREFIX
25#endif
26
27namespace boost {
28namespace coroutines {
29
30struct stack_context;
31
32namespace detail {
33
34template< typename R >
35class pull_coroutine_impl : private noncopyable
36{
37protected:
38 int flags_;
39 exception_ptr except_;
40 coroutine_context * caller_;
41 coroutine_context * callee_;
42 R * result_;
43
44public:
45 typedef parameters< R > param_type;
46
47 pull_coroutine_impl( coroutine_context * caller,
48 coroutine_context * callee,
49 bool unwind) :
50 flags_( 0),
51 except_(),
52 caller_( caller),
53 callee_( callee),
54 result_( 0)
55 {
56 if ( unwind) flags_ |= flag_force_unwind;
57 }
58
59 pull_coroutine_impl( coroutine_context * caller,
60 coroutine_context * callee,
61 bool unwind,
62 R * result) :
63 flags_( 0),
64 except_(),
65 caller_( caller),
66 callee_( callee),
67 result_( result)
68 {
69 if ( unwind) flags_ |= flag_force_unwind;
70 }
71
72 virtual ~pull_coroutine_impl() {}
73
74 bool force_unwind() const BOOST_NOEXCEPT
75 { return 0 != ( flags_ & flag_force_unwind); }
76
77 bool unwind_requested() const BOOST_NOEXCEPT
78 { return 0 != ( flags_ & flag_unwind_stack); }
79
80 bool is_started() const BOOST_NOEXCEPT
81 { return 0 != ( flags_ & flag_started); }
82
83 bool is_running() const BOOST_NOEXCEPT
84 { return 0 != ( flags_ & flag_running); }
85
86 bool is_complete() const BOOST_NOEXCEPT
87 { return 0 != ( flags_ & flag_complete); }
88
89 void unwind_stack() BOOST_NOEXCEPT
90 {
91 if ( is_started() && ! is_complete() && force_unwind() )
92 {
93 flags_ |= flag_unwind_stack;
94 param_type to( unwind_t::force_unwind);
95 caller_->jump(
96 * callee_,
97 & to);
98 flags_ &= ~flag_unwind_stack;
99
100 BOOST_ASSERT( is_complete() );
101 }
102 }
103
104 void pull()
105 {
106 BOOST_ASSERT( ! is_running() );
107 BOOST_ASSERT( ! is_complete() );
108
109 flags_ |= flag_running;
110 param_type to( this);
111 param_type * from(
112 static_cast< param_type * >(
113 caller_->jump(
114 * callee_,
115 & to) ) );
116 flags_ &= ~flag_running;
117 result_ = from->data;
118 if ( from->do_unwind) throw forced_unwind();
119 if ( except_) rethrow_exception( p: except_);
120 }
121
122 bool has_result() const
123 { return 0 != result_; }
124
125 R get() const
126 {
127 if ( ! has_result() )
128 boost::throw_exception(
129 e: invalid_result() );
130 return * result_;
131 }
132
133 R * get_pointer() const
134 {
135 if ( ! has_result() )
136 boost::throw_exception(
137 e: invalid_result() );
138 return result_;
139 }
140
141 virtual void destroy() = 0;
142};
143
144template< typename R >
145class pull_coroutine_impl< R & > : private noncopyable
146{
147protected:
148 int flags_;
149 exception_ptr except_;
150 coroutine_context * caller_;
151 coroutine_context * callee_;
152 R * result_;
153
154public:
155 typedef parameters< R & > param_type;
156
157 pull_coroutine_impl( coroutine_context * caller,
158 coroutine_context * callee,
159 bool unwind) :
160 flags_( 0),
161 except_(),
162 caller_( caller),
163 callee_( callee),
164 result_( 0)
165 {
166 if ( unwind) flags_ |= flag_force_unwind;
167 }
168
169 pull_coroutine_impl( coroutine_context * caller,
170 coroutine_context * callee,
171 bool unwind,
172 R * result) :
173 flags_( 0),
174 except_(),
175 caller_( caller),
176 callee_( callee),
177 result_( result)
178 {
179 if ( unwind) flags_ |= flag_force_unwind;
180 }
181
182 virtual ~pull_coroutine_impl() {}
183
184 bool force_unwind() const BOOST_NOEXCEPT
185 { return 0 != ( flags_ & flag_force_unwind); }
186
187 bool unwind_requested() const BOOST_NOEXCEPT
188 { return 0 != ( flags_ & flag_unwind_stack); }
189
190 bool is_started() const BOOST_NOEXCEPT
191 { return 0 != ( flags_ & flag_started); }
192
193 bool is_running() const BOOST_NOEXCEPT
194 { return 0 != ( flags_ & flag_running); }
195
196 bool is_complete() const BOOST_NOEXCEPT
197 { return 0 != ( flags_ & flag_complete); }
198
199 void unwind_stack() BOOST_NOEXCEPT
200 {
201 if ( is_started() && ! is_complete() && force_unwind() )
202 {
203 flags_ |= flag_unwind_stack;
204 param_type to( unwind_t::force_unwind);
205 caller_->jump(
206 * callee_,
207 & to);
208 flags_ &= ~flag_unwind_stack;
209
210 BOOST_ASSERT( is_complete() );
211 }
212 }
213
214 void pull()
215 {
216 BOOST_ASSERT( ! is_running() );
217 BOOST_ASSERT( ! is_complete() );
218
219 flags_ |= flag_running;
220 param_type to( this);
221 param_type * from(
222 static_cast< param_type * >(
223 caller_->jump(
224 * callee_,
225 & to) ) );
226 flags_ &= ~flag_running;
227 result_ = from->data;
228 if ( from->do_unwind) throw forced_unwind();
229 if ( except_) rethrow_exception( p: except_);
230 }
231
232 bool has_result() const
233 { return 0 != result_; }
234
235 R & get() const
236 {
237 if ( ! has_result() )
238 boost::throw_exception(
239 e: invalid_result() );
240 return * result_;
241 }
242
243 R * get_pointer() const
244 {
245 if ( ! has_result() )
246 boost::throw_exception(
247 e: invalid_result() );
248 return result_;
249 }
250
251 virtual void destroy() = 0;
252};
253
254template<>
255class pull_coroutine_impl< void > : private noncopyable
256{
257protected:
258 int flags_;
259 exception_ptr except_;
260 coroutine_context * caller_;
261 coroutine_context * callee_;
262
263public:
264 typedef parameters< void > param_type;
265
266 pull_coroutine_impl( coroutine_context * caller,
267 coroutine_context * callee,
268 bool unwind) :
269 flags_( 0),
270 except_(),
271 caller_( caller),
272 callee_( callee)
273 {
274 if ( unwind) flags_ |= flag_force_unwind;
275 }
276
277 virtual ~pull_coroutine_impl() {}
278
279 inline bool force_unwind() const BOOST_NOEXCEPT
280 { return 0 != ( flags_ & flag_force_unwind); }
281
282 inline bool unwind_requested() const BOOST_NOEXCEPT
283 { return 0 != ( flags_ & flag_unwind_stack); }
284
285 inline bool is_started() const BOOST_NOEXCEPT
286 { return 0 != ( flags_ & flag_started); }
287
288 inline bool is_running() const BOOST_NOEXCEPT
289 { return 0 != ( flags_ & flag_running); }
290
291 inline bool is_complete() const BOOST_NOEXCEPT
292 { return 0 != ( flags_ & flag_complete); }
293
294 inline void unwind_stack() BOOST_NOEXCEPT
295 {
296 if ( is_started() && ! is_complete() && force_unwind() )
297 {
298 flags_ |= flag_unwind_stack;
299 param_type to( unwind_t::force_unwind);
300 caller_->jump(
301 * callee_,
302 & to);
303 flags_ &= ~flag_unwind_stack;
304
305 BOOST_ASSERT( is_complete() );
306 }
307 }
308
309 inline void pull()
310 {
311 BOOST_ASSERT( ! is_running() );
312 BOOST_ASSERT( ! is_complete() );
313
314 flags_ |= flag_running;
315 param_type to( this);
316 param_type * from(
317 static_cast< param_type * >(
318 caller_->jump(
319 * callee_,
320 & to) ) );
321 flags_ &= ~flag_running;
322 if ( from->do_unwind) throw forced_unwind();
323 if ( except_) rethrow_exception( p: except_);
324 }
325
326 virtual void destroy() = 0;
327};
328
329}}}
330
331#ifdef BOOST_HAS_ABI_HEADERS
332# include BOOST_ABI_SUFFIX
333#endif
334
335#endif // BOOST_COROUTINES_DETAIL_PULL_COROUTINE_IMPL_H
336

source code of boost/libs/coroutine/include/boost/coroutine/detail/pull_coroutine_impl.hpp