[ceph.git] / ceph / src / boost / libs / coroutine2 / include / boost / coroutine2 / detail / pull_control_block_ecv2.ipp


//          Copyright Oliver Kowalke 2014.
// 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)

#ifndef BOOST_COROUTINES2_DETAIL_PULL_CONTROL_BLOCK_IPP
#define BOOST_COROUTINES2_DETAIL_PULL_CONTROL_BLOCK_IPP

#include <algorithm>
#include <exception>
#include <memory>
#include <tuple>

#include <boost/assert.hpp>
#include <boost/config.hpp>

#include <boost/context/execution_context.hpp>

#include <boost/coroutine2/detail/config.hpp>
#include <boost/coroutine2/detail/forced_unwind.hpp>

#ifdef BOOST_HAS_ABI_HEADERS
#  include BOOST_ABI_PREFIX
#endif

namespace boost {
namespace coroutines2 {
namespace detail {

// pull_coroutine< T >

template< typename T >
void
pull_coroutine< T >::control_block::destroy( control_block * cb) noexcept {
    boost::context::execution_context< T * > ctx = std::move( cb->ctx);
    // destroy control structure
    cb->~control_block();
    // destroy coroutine's stack
    cb->state |= state_t::destroy;
    ctx( nullptr);
}

template< typename T >
template< typename StackAllocator, typename Fn >
pull_coroutine< T >::control_block::control_block( context::preallocated palloc, StackAllocator salloc,
                                                   Fn && fn) :
#if defined(BOOST_NO_CXX14_GENERIC_LAMBDAS)
    ctx{ std::allocator_arg, palloc, salloc,
        std::move(
         std::bind(
             [this]( typename std::decay< Fn >::type & fn_, boost::context::execution_context< T * > ctx, T *) mutable {
                // create synthesized push_coroutine< T >
                typename push_coroutine< T >::control_block synthesized_cb{ this, ctx };
                push_coroutine< T > synthesized{ & synthesized_cb };
                other = & synthesized_cb;
                if ( state_t::none == ( state & state_t::destroy) ) {
                    try {
                        auto fn = std::move( fn_);
                        // call coroutine-fn with synthesized push_coroutine as argument
                        fn( synthesized);
                    } catch ( boost::context::detail::forced_unwind const&) {
                        throw;
                    } catch (...) {
                        // store other exceptions in exception-pointer
                        except = std::current_exception();
                    }
                }
                // set termination flags
                state |= state_t::complete;
                // jump back to ctx
                auto result = other->ctx( nullptr);
                other->ctx = std::move( std::get< 0 >( result) );
                return std::move( other->ctx);
             },
             std::forward< Fn >( fn),
             std::placeholders::_1,
             std::placeholders::_2))},
#else
    ctx{ std::allocator_arg, palloc, salloc,
         [this,fn_=std::forward< Fn >( fn)]( boost::context::execution_context< T * > ctx, T *) mutable {
            // create synthesized push_coroutine< T >
            typename push_coroutine< T >::control_block synthesized_cb{ this, ctx };
            push_coroutine< T > synthesized{ & synthesized_cb };
            other = & synthesized_cb;
            if ( state_t::none == ( state & state_t::destroy) ) {
                try {
                    auto fn = std::move( fn_);
                    // call coroutine-fn with synthesized push_coroutine as argument
                    fn( synthesized);
                } catch ( boost::context::detail::forced_unwind const&) {
                    throw;
                } catch (...) {
                    // store other exceptions in exception-pointer
                    except = std::current_exception();
                }
            }
            // set termination flags
            state |= state_t::complete;
            // jump back to ctx
            auto result = other->ctx( nullptr);
            other->ctx = std::move( std::get< 0 >( result) );
            return std::move( other->ctx);
         }},
#endif
    other{ nullptr },
    state{ state_t::unwind },
    except{},
    bvalid{ false },
    storage{} {
    // enter coroutine-fn in order to have first value available after ctor (of `*this`) returns
    resume();
}

template< typename T >
pull_coroutine< T >::control_block::control_block( typename push_coroutine< T >::control_block * cb,
                                                   boost::context::execution_context< T * > & ctx_) noexcept :
    ctx{ std::move( ctx_) },
    other{ cb },
    state{ state_t::none },
    except{},
    bvalid{ false },
    storage{} {
}

template< typename T >
pull_coroutine< T >::control_block::~control_block() {
    // destroy data if set
    if ( bvalid) {
        reinterpret_cast< T * >( std::addressof( storage) )->~T();
    }
}

template< typename T >
void
pull_coroutine< T >::control_block::deallocate() noexcept {
    if ( state_t::none != ( state & state_t::unwind) ) {
        destroy( this);
    }
}

template< typename T >
void
pull_coroutine< T >::control_block::resume() {
    auto result = ctx( nullptr);
    ctx = std::move( std::get< 0 >( result) );
    set( std::get< 1 >( result) );
    if ( except) {
        std::rethrow_exception( except);
    }
}

template< typename T >
void
pull_coroutine< T >::control_block::set( T * t) {
    // destroy data if set
    if ( bvalid) {
        reinterpret_cast< T * >( std::addressof( storage) )->~T();
    }
    if ( nullptr != t) {
        ::new ( static_cast< void * >( std::addressof( storage) ) ) T( std::move( * t) );
        bvalid = true;
    } else {
        bvalid = false;
    }
}

template< typename T >
T &
pull_coroutine< T >::control_block::get() noexcept {
    return * reinterpret_cast< T * >( std::addressof( storage) );
}

template< typename T >
bool
pull_coroutine< T >::control_block::valid() const noexcept {
    return nullptr != other && state_t::none == ( state & state_t::complete) && bvalid;
}


// pull_coroutine< T & >

template< typename T >
void
pull_coroutine< T & >::control_block::destroy( control_block * cb) noexcept {
    boost::context::execution_context< T * > ctx = std::move( cb->ctx);
    // destroy control structure
    cb->~control_block();
    // destroy coroutine's stack
    cb->state |= state_t::destroy;
    ctx( nullptr);
}

template< typename T >
template< typename StackAllocator, typename Fn >
pull_coroutine< T & >::control_block::control_block( context::preallocated palloc, StackAllocator salloc,
                                                     Fn && fn) :
#if defined(BOOST_NO_CXX14_GENERIC_LAMBDAS)
    ctx{ std::allocator_arg, palloc, salloc,
        std::move(
         std::bind(
             [this]( typename std::decay< Fn >::type & fn_, boost::context::execution_context< T *> ctx, T *) mutable {
                // create synthesized push_coroutine< T & >
                typename push_coroutine< T & >::control_block synthesized_cb{ this, ctx };
                push_coroutine< T & > synthesized{ & synthesized_cb };
                other = & synthesized_cb;
                if ( state_t::none == ( state & state_t::destroy) ) {
                    try {
                        auto fn = std::move( fn_);
                        // call coroutine-fn with synthesized push_coroutine as argument
                        fn( synthesized);
                    } catch ( boost::context::detail::forced_unwind const&) {
                        throw;
                    } catch (...) {
                        // store other exceptions in exception-pointer
                        except = std::current_exception();
                    }
                }
                // set termination flags
                state |= state_t::complete;
                // jump back to ctx
                auto result = other->ctx( nullptr);
                other->ctx = std::move( std::get< 0 >( result) );
                return std::move( other->ctx);
             },
             std::forward< Fn >( fn),
             std::placeholders::_1,
             std::placeholders::_2))},
#else
    ctx{ std::allocator_arg, palloc, salloc,
         [this,fn_=std::forward< Fn >( fn)]( boost::context::execution_context< T * > ctx, T *) mutable {
            // create synthesized push_coroutine< T & >
            typename push_coroutine< T & >::control_block synthesized_cb{ this, ctx };
            push_coroutine< T & > synthesized{ & synthesized_cb };
            other = & synthesized_cb;
            if ( state_t::none == ( state & state_t::destroy) ) {
                try {
                    auto fn = std::move( fn_);
                    // call coroutine-fn with synthesized push_coroutine as argument
                    fn( synthesized);
                } catch ( boost::context::detail::forced_unwind const&) {
                    throw;
                } catch (...) {
                    // store other exceptions in exception-pointer
                    except = std::current_exception();
                }
            }
            // set termination flags
            state |= state_t::complete;
            // jump back to ctx
            auto result = other->ctx( nullptr);
            other->ctx = std::move( std::get< 0 >( result) );
            return std::move( other->ctx);
         }},
#endif
    other{ nullptr },
    state{ state_t::unwind },
    except{},
    t{ nullptr } {
    // enter coroutine-fn in order to have first value available after ctor (of `*this`) returns
    resume();
}

template< typename T >
pull_coroutine< T & >::control_block::control_block( typename push_coroutine< T & >::control_block * cb,
                                                     boost::context::execution_context< T * > & ctx_) noexcept :
    ctx{ std::move( ctx_) },
    other{ cb },
    state{ state_t::none },
    except{},
    t{ nullptr } {
}

template< typename T >
void
pull_coroutine< T & >::control_block::deallocate() noexcept {
    if ( state_t::none != ( state & state_t::unwind) ) {
        destroy( this);
    }
}

template< typename T >
void
pull_coroutine< T & >::control_block::resume() {
    auto result = ctx( nullptr);
    ctx = std::move( std::get< 0 >( result) );
    t = std::get< 1 >( result);
    if ( except) {
        std::rethrow_exception( except);
    }
}

template< typename T >
T &
pull_coroutine< T & >::control_block::get() noexcept {
    return * t;
}

template< typename T >
bool
pull_coroutine< T & >::control_block::valid() const noexcept {
    return nullptr != other && state_t::none == ( state & state_t::complete) && nullptr != t;
}


// pull_coroutine< void >

inline
void
pull_coroutine< void >::control_block::destroy( control_block * cb) noexcept {
    boost::context::execution_context< void > ctx = std::move( cb->ctx);
    // destroy control structure
    cb->~control_block();
    // destroy coroutine's stack
    cb->state |= state_t::destroy;
    ctx();
}

template< typename StackAllocator, typename Fn >
pull_coroutine< void >::control_block::control_block( context::preallocated palloc, StackAllocator salloc,
                                                      Fn && fn) :
#if defined(BOOST_NO_CXX14_GENERIC_LAMBDAS)
    ctx{ std::allocator_arg, palloc, salloc,
        std::move(
         std::bind(
             [this]( typename std::decay< Fn >::type & fn_, boost::context::execution_context< void > ctx) mutable {
                // create synthesized push_coroutine< void >
                typename push_coroutine< void >::control_block synthesized_cb{ this, ctx };
                push_coroutine< void > synthesized{ & synthesized_cb };
                other = & synthesized_cb;
                if ( state_t::none == ( state & state_t::destroy) ) {
                    try {
                        auto fn = std::move( fn_);
                        // call coroutine-fn with synthesized push_coroutine as argument
                        fn( synthesized);
                    } catch ( boost::context::detail::forced_unwind const&) {
                        throw;
                    } catch (...) {
                        // store other exceptions in exception-pointer
                        except = std::current_exception();
                    }
                }
                // set termination flags
                state |= state_t::complete;
                // jump back to ctx
                other->ctx = other->ctx();
                return std::move( other->ctx);
             },
             std::forward< Fn >( fn),
             std::placeholders::_1))},
#else
    ctx{ std::allocator_arg, palloc, salloc,
         [this,fn_=std::forward< Fn >( fn)]( boost::context::execution_context< void > ctx) mutable {
            // create synthesized push_coroutine< void >
            typename push_coroutine< void >::control_block synthesized_cb{ this, ctx };
            push_coroutine< void > synthesized{ & synthesized_cb };
            other = & synthesized_cb;
            if ( state_t::none == ( state & state_t::destroy) ) {
                try {
                    auto fn = std::move( fn_);
                    // call coroutine-fn with synthesized push_coroutine as argument
                    fn( synthesized);
                } catch ( boost::context::detail::forced_unwind const&) {
                    throw;
                } catch (...) {
                    // store other exceptions in exception-pointer
                    except = std::current_exception();
                }
            }
            // set termination flags
            state |= state_t::complete;
            // jump back to ctx
            other->ctx = other->ctx();
            return std::move( other->ctx);
         }},
#endif
    other{ nullptr },
    state{ state_t::unwind },
    except{} {
    // enter coroutine-fn in order to have first value available after ctor (of `*this`) returns
    resume();
}

inline
pull_coroutine< void >::control_block::control_block( push_coroutine< void >::control_block * cb,
                                                      boost::context::execution_context< void > & ctx_) noexcept :
    ctx{ std::move( ctx_) },
    other{ cb },
    state{ state_t::none },
    except{} {
}

inline
void
pull_coroutine< void >::control_block::deallocate() noexcept {
    if ( state_t::none != ( state & state_t::unwind) ) {
        destroy( this);
    }
}

inline
void
pull_coroutine< void >::control_block::resume() {
    ctx = ctx();
    if ( except) {
        std::rethrow_exception( except);
    }
}

inline
bool
pull_coroutine< void >::control_block::valid() const noexcept {
    return nullptr != other && state_t::none == ( state & state_t::complete);
}

}}}

#ifdef BOOST_HAS_ABI_HEADERS
#  include BOOST_ABI_SUFFIX
#endif

#endif // BOOST_COROUTINES2_DETAIL_PULL_CONTROL_BLOCK_IPP
Commit	Line	Data
7c673cae FG	1
	2	// Copyright Oliver Kowalke 2014.
	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_COROUTINES2_DETAIL_PULL_CONTROL_BLOCK_IPP
	8	#define BOOST_COROUTINES2_DETAIL_PULL_CONTROL_BLOCK_IPP
	9
	10	#include <algorithm>
	11	#include <exception>
	12	#include <memory>
	13	#include <tuple>
	14
	15	#include <boost/assert.hpp>
	16	#include <boost/config.hpp>
	17
	18	#include <boost/context/execution_context.hpp>
	19
	20	#include <boost/coroutine2/detail/config.hpp>
	21	#include <boost/coroutine2/detail/forced_unwind.hpp>
	22
	23	#ifdef BOOST_HAS_ABI_HEADERS
	24	# include BOOST_ABI_PREFIX
	25	#endif
	26
	27	namespace boost {
	28	namespace coroutines2 {
	29	namespace detail {
	30
	31	// pull_coroutine< T >
	32
	33	template< typename T >
	34	void
	35	pull_coroutine< T >::control_block::destroy( control_block * cb) noexcept {
	36	boost::context::execution_context< T * > ctx = std::move( cb->ctx);
	37	// destroy control structure
	38	cb->~control_block();
	39	// destroy coroutine's stack
	40	cb->state \|= state_t::destroy;
	41	ctx( nullptr);
	42	}
	43
	44	template< typename T >
	45	template< typename StackAllocator, typename Fn >
	46	pull_coroutine< T >::control_block::control_block( context::preallocated palloc, StackAllocator salloc,
	47	Fn && fn) :
	48	#if defined(BOOST_NO_CXX14_GENERIC_LAMBDAS)
	49	ctx{ std::allocator_arg, palloc, salloc,
	50	std::move(
	51	std::bind(
	52	[this]( typename std::decay< Fn >::type & fn_, boost::context::execution_context< T * > ctx, T *) mutable {
	53	// create synthesized push_coroutine< T >
	54	typename push_coroutine< T >::control_block synthesized_cb{ this, ctx };
	55	push_coroutine< T > synthesized{ & synthesized_cb };
	56	other = & synthesized_cb;
	57	if ( state_t::none == ( state & state_t::destroy) ) {
	58	try {
	59	auto fn = std::move( fn_);
	60	// call coroutine-fn with synthesized push_coroutine as argument
	61	fn( synthesized);
	62	} catch ( boost::context::detail::forced_unwind const&) {
	63	throw;
	64	} catch (...) {
65	// store other exceptions in exception-pointer
66	except = std::current_exception();
67	}
68	}
69	// set termination flags
70	state \|= state_t::complete;
71	// jump back to ctx
72	auto result = other->ctx( nullptr);
73	other->ctx = std::move( std::get< 0 >( result) );
74	return std::move( other->ctx);
75	},
76	std::forward< Fn >( fn),
77	std::placeholders::_1,
78	std::placeholders::_2))},
79	#else
80	ctx{ std::allocator_arg, palloc, salloc,
81	[this,fn_=std::forward< Fn >( fn)]( boost::context::execution_context< T * > ctx, T *) mutable {
82	// create synthesized push_coroutine< T >
83	typename push_coroutine< T >::control_block synthesized_cb{ this, ctx };
84	push_coroutine< T > synthesized{ & synthesized_cb };
85	other = & synthesized_cb;
86	if ( state_t::none == ( state & state_t::destroy) ) {
87	try {
88	auto fn = std::move( fn_);
89	// call coroutine-fn with synthesized push_coroutine as argument
90	fn( synthesized);
91	} catch ( boost::context::detail::forced_unwind const&) {
92	throw;
93	} catch (...) {
94	// store other exceptions in exception-pointer
95	except = std::current_exception();
96	}
97	}
98	// set termination flags
99	state \|= state_t::complete;
100	// jump back to ctx
101	auto result = other->ctx( nullptr);
102	other->ctx = std::move( std::get< 0 >( result) );
103	return std::move( other->ctx);
104	}},
105	#endif
106	other{ nullptr },
107	state{ state_t::unwind },
108	except{},
109	bvalid{ false },
110	storage{} {
111	// enter coroutine-fn in order to have first value available after ctor (of `*this`) returns
112	resume();
113	}
114
115	template< typename T >
116	pull_coroutine< T >::control_block::control_block( typename push_coroutine< T >::control_block * cb,
117	boost::context::execution_context< T * > & ctx_) noexcept :
118	ctx{ std::move( ctx_) },
119	other{ cb },
120	state{ state_t::none },
121	except{},
122	bvalid{ false },
123	storage{} {
124	}
125
126	template< typename T >
127	pull_coroutine< T >::control_block::~control_block() {
128	// destroy data if set
129	if ( bvalid) {
130	reinterpret_cast< T * >( std::addressof( storage) )->~T();
131	}
132	}
133
134	template< typename T >
135	void
136	pull_coroutine< T >::control_block::deallocate() noexcept {
137	if ( state_t::none != ( state & state_t::unwind) ) {
138	destroy( this);
139	}
140	}
141
142	template< typename T >
143	void
144	pull_coroutine< T >::control_block::resume() {
145	auto result = ctx( nullptr);
146	ctx = std::move( std::get< 0 >( result) );
147	set( std::get< 1 >( result) );
148	if ( except) {
149	std::rethrow_exception( except);
150	}
151	}
152
153	template< typename T >
154	void
155	pull_coroutine< T >::control_block::set( T * t) {
156	// destroy data if set
157	if ( bvalid) {
158	reinterpret_cast< T * >( std::addressof( storage) )->~T();
159	}
160	if ( nullptr != t) {
161	::new ( static_cast< void * >( std::addressof( storage) ) ) T( std::move( * t) );
162	bvalid = true;
163	} else {
164	bvalid = false;
165	}
166	}
167
168	template< typename T >
169	T &
170	pull_coroutine< T >::control_block::get() noexcept {
171	return * reinterpret_cast< T * >( std::addressof( storage) );
172	}
173
174	template< typename T >
175	bool
176	pull_coroutine< T >::control_block::valid() const noexcept {
177	return nullptr != other && state_t::none == ( state & state_t::complete) && bvalid;
178	}
179
180
181	// pull_coroutine< T & >
182
183	template< typename T >
184	void
185	pull_coroutine< T & >::control_block::destroy( control_block * cb) noexcept {
186	boost::context::execution_context< T * > ctx = std::move( cb->ctx);
187	// destroy control structure
188	cb->~control_block();
189	// destroy coroutine's stack
190	cb->state \|= state_t::destroy;
191	ctx( nullptr);
192	}
193
194	template< typename T >
195	template< typename StackAllocator, typename Fn >
196	pull_coroutine< T & >::control_block::control_block( context::preallocated palloc, StackAllocator salloc,
197	Fn && fn) :
198	#if defined(BOOST_NO_CXX14_GENERIC_LAMBDAS)
199	ctx{ std::allocator_arg, palloc, salloc,
200	std::move(
201	std::bind(
202	[this]( typename std::decay< Fn >::type & fn_, boost::context::execution_context< T > ctx, T ) mutable {
203	// create synthesized push_coroutine< T & >
204	typename push_coroutine< T & >::control_block synthesized_cb{ this, ctx };
205	push_coroutine< T & > synthesized{ & synthesized_cb };
206	other = & synthesized_cb;
207	if ( state_t::none == ( state & state_t::destroy) ) {
208	try {
209	auto fn = std::move( fn_);
210	// call coroutine-fn with synthesized push_coroutine as argument
211	fn( synthesized);
212	} catch ( boost::context::detail::forced_unwind const&) {
213	throw;
214	} catch (...) {
215	// store other exceptions in exception-pointer
216	except = std::current_exception();
217	}
218	}
219	// set termination flags
220	state \|= state_t::complete;
221	// jump back to ctx
222	auto result = other->ctx( nullptr);
223	other->ctx = std::move( std::get< 0 >( result) );
224	return std::move( other->ctx);
225	},
226	std::forward< Fn >( fn),
227	std::placeholders::_1,
228	std::placeholders::_2))},
229	#else
230	ctx{ std::allocator_arg, palloc, salloc,
231	[this,fn_=std::forward< Fn >( fn)]( boost::context::execution_context< T * > ctx, T *) mutable {
232	// create synthesized push_coroutine< T & >
233	typename push_coroutine< T & >::control_block synthesized_cb{ this, ctx };
234	push_coroutine< T & > synthesized{ & synthesized_cb };
235	other = & synthesized_cb;
236	if ( state_t::none == ( state & state_t::destroy) ) {
237	try {
238	auto fn = std::move( fn_);
239	// call coroutine-fn with synthesized push_coroutine as argument
240	fn( synthesized);
241	} catch ( boost::context::detail::forced_unwind const&) {
242	throw;
243	} catch (...) {
244	// store other exceptions in exception-pointer
245	except = std::current_exception();
246	}
247	}
248	// set termination flags
249	state \|= state_t::complete;
250	// jump back to ctx
251	auto result = other->ctx( nullptr);
252	other->ctx = std::move( std::get< 0 >( result) );
253	return std::move( other->ctx);
254	}},
255	#endif
256	other{ nullptr },
257	state{ state_t::unwind },
258	except{},
259	t{ nullptr } {
260	// enter coroutine-fn in order to have first value available after ctor (of `*this`) returns
261	resume();
262	}
263
264	template< typename T >
265	pull_coroutine< T & >::control_block::control_block( typename push_coroutine< T & >::control_block * cb,
266	boost::context::execution_context< T * > & ctx_) noexcept :
267	ctx{ std::move( ctx_) },
268	other{ cb },
269	state{ state_t::none },
270	except{},
271	t{ nullptr } {
272	}
273
274	template< typename T >
275	void
276	pull_coroutine< T & >::control_block::deallocate() noexcept {
277	if ( state_t::none != ( state & state_t::unwind) ) {
278	destroy( this);
279	}
280	}
281
282	template< typename T >
283	void
284	pull_coroutine< T & >::control_block::resume() {
285	auto result = ctx( nullptr);
286	ctx = std::move( std::get< 0 >( result) );
287	t = std::get< 1 >( result);
288	if ( except) {
289	std::rethrow_exception( except);
290	}
291	}
292
293	template< typename T >
294	T &
295	pull_coroutine< T & >::control_block::get() noexcept {
296	return * t;
297	}
298
299	template< typename T >
300	bool
301	pull_coroutine< T & >::control_block::valid() const noexcept {
302	return nullptr != other && state_t::none == ( state & state_t::complete) && nullptr != t;
303	}
304
305
306	// pull_coroutine< void >
307
308	inline
309	void
310	pull_coroutine< void >::control_block::destroy( control_block * cb) noexcept {
311	boost::context::execution_context< void > ctx = std::move( cb->ctx);
312	// destroy control structure
313	cb->~control_block();
314	// destroy coroutine's stack
315	cb->state \|= state_t::destroy;
316	ctx();
317	}
318
319	template< typename StackAllocator, typename Fn >
320	pull_coroutine< void >::control_block::control_block( context::preallocated palloc, StackAllocator salloc,
321	Fn && fn) :
322	#if defined(BOOST_NO_CXX14_GENERIC_LAMBDAS)
323	ctx{ std::allocator_arg, palloc, salloc,
324	std::move(
325	std::bind(
326	[this]( typename std::decay< Fn >::type & fn_, boost::context::execution_context< void > ctx) mutable {
327	// create synthesized push_coroutine< void >
328	typename push_coroutine< void >::control_block synthesized_cb{ this, ctx };
329	push_coroutine< void > synthesized{ & synthesized_cb };
330	other = & synthesized_cb;
331	if ( state_t::none == ( state & state_t::destroy) ) {
332	try {
333	auto fn = std::move( fn_);
334	// call coroutine-fn with synthesized push_coroutine as argument
335	fn( synthesized);
336	} catch ( boost::context::detail::forced_unwind const&) {
337	throw;
338	} catch (...) {
339	// store other exceptions in exception-pointer
340	except = std::current_exception();
341	}
342	}
343	// set termination flags
344	state \|= state_t::complete;
345	// jump back to ctx
346	other->ctx = other->ctx();
347	return std::move( other->ctx);
348	},
349	std::forward< Fn >( fn),
350	std::placeholders::_1))},
351	#else
352	ctx{ std::allocator_arg, palloc, salloc,
353	[this,fn_=std::forward< Fn >( fn)]( boost::context::execution_context< void > ctx) mutable {
354	// create synthesized push_coroutine< void >
355	typename push_coroutine< void >::control_block synthesized_cb{ this, ctx };
356	push_coroutine< void > synthesized{ & synthesized_cb };
357	other = & synthesized_cb;
358	if ( state_t::none == ( state & state_t::destroy) ) {
359	try {
360	auto fn = std::move( fn_);
361	// call coroutine-fn with synthesized push_coroutine as argument
362	fn( synthesized);
363	} catch ( boost::context::detail::forced_unwind const&) {
364	throw;
365	} catch (...) {
366	// store other exceptions in exception-pointer
367	except = std::current_exception();
368	}
369	}
370	// set termination flags
371	state \|= state_t::complete;
372	// jump back to ctx
373	other->ctx = other->ctx();
374	return std::move( other->ctx);
375	}},
376	#endif
377	other{ nullptr },
378	state{ state_t::unwind },
379	except{} {
380	// enter coroutine-fn in order to have first value available after ctor (of `*this`) returns
381	resume();
382	}
383
384	inline
385	pull_coroutine< void >::control_block::control_block( push_coroutine< void >::control_block * cb,
386	boost::context::execution_context< void > & ctx_) noexcept :
387	ctx{ std::move( ctx_) },
388	other{ cb },
389	state{ state_t::none },
390	except{} {
391	}
392
393	inline
394	void
395	pull_coroutine< void >::control_block::deallocate() noexcept {
396	if ( state_t::none != ( state & state_t::unwind) ) {
397	destroy( this);
398	}
399	}
400
401	inline
402	void
403	pull_coroutine< void >::control_block::resume() {
404	ctx = ctx();
405	if ( except) {
406	std::rethrow_exception( except);
407	}
408	}
409
410	inline
411	bool
412	pull_coroutine< void >::control_block::valid() const noexcept {
413	return nullptr != other && state_t::none == ( state & state_t::complete);
414	}
415
416	}}}
417
418	#ifdef BOOST_HAS_ABI_HEADERS
419	# include BOOST_ABI_SUFFIX
420	#endif
421
422	#endif // BOOST_COROUTINES2_DETAIL_PULL_CONTROL_BLOCK_IPP