[ceph.git] / ceph / src / boost / libs / coroutine / include / boost / coroutine / detail / symmetric_coroutine_yield.hpp


//          Copyright Oliver Kowalke 2009.
// 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_COROUTINES_DETAIL_SYMMETRIC_COROUTINE_YIELD_H
#define BOOST_COROUTINES_DETAIL_SYMMETRIC_COROUTINE_YIELD_H

#include <algorithm>

#include <boost/assert.hpp>
#include <boost/config.hpp>
#include <boost/move/move.hpp>
#include <boost/throw_exception.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/utility/explicit_operator_bool.hpp>

#include <boost/coroutine/detail/config.hpp>
#include <boost/coroutine/exceptions.hpp>

#ifdef BOOST_HAS_ABI_HEADERS
#  include BOOST_ABI_PREFIX
#endif

namespace boost {
namespace coroutines {
namespace detail {

template< typename R >
class symmetric_coroutine_yield
{
private:
    template< typename X, typename Y, typename Z >
    friend class symmetric_coroutine_object;

    typedef symmetric_coroutine_impl< R >       impl_type;

    struct dummy {};

    BOOST_MOVABLE_BUT_NOT_COPYABLE( symmetric_coroutine_yield)

    impl_type   *   impl_;
    R           *   result_;

    symmetric_coroutine_yield( impl_type * impl, R * result) BOOST_NOEXCEPT :
        impl_( impl),
        result_( result)
    {
        BOOST_ASSERT( 0 != impl_);
        BOOST_ASSERT( 0 != result_);
    }

public:
    symmetric_coroutine_yield() BOOST_NOEXCEPT :
        impl_( 0),
        result_( 0)
    {}

    symmetric_coroutine_yield( BOOST_RV_REF( symmetric_coroutine_yield) other) BOOST_NOEXCEPT :
        impl_( 0),
        result_( 0)
    { swap( other); }

    symmetric_coroutine_yield & operator=( BOOST_RV_REF( symmetric_coroutine_yield) other) BOOST_NOEXCEPT
    {
        symmetric_coroutine_yield tmp( boost::move( other) );
        swap( tmp);
        return * this;
    }

    BOOST_EXPLICIT_OPERATOR_BOOL();

    bool operator!() const BOOST_NOEXCEPT
    { return 0 == impl_; }

    void swap( symmetric_coroutine_yield & other) BOOST_NOEXCEPT
    {
        std::swap( impl_, other.impl_);
        std::swap( result_, other.result_);
    }

    symmetric_coroutine_yield & operator()()
    {
        result_ = impl_->yield();
        return * this;
    }

    template< typename Coro >
    symmetric_coroutine_yield & operator()( Coro & other, typename Coro::value_type x,
                                            typename disable_if<
                                                is_same< typename Coro::value_type, void >,
                                                dummy*
                                            >::type = 0)
    {
        BOOST_ASSERT( other);

        result_ = impl_->yield_to( other.impl_, x);
        return * this;
    }

    template< typename Coro >
    symmetric_coroutine_yield & operator()( Coro & other,
                                            typename enable_if<
                                                is_same< typename Coro::value_type, void >,
                                                dummy*
                                            >::type = 0)
    {
        BOOST_ASSERT( other);

        result_ = impl_->yield_to( other.impl_);
        return * this;
    }

    R get() const
    {
        if ( 0 == result_)
            boost::throw_exception(
                invalid_result() );

        return * result_; 
    }
};

template< typename R >
class symmetric_coroutine_yield< R & >
{
private:
    template< typename X, typename Y, typename Z >
    friend class symmetric_coroutine_object;

    typedef symmetric_coroutine_impl< R & >     impl_type;

    struct dummy {};

    BOOST_MOVABLE_BUT_NOT_COPYABLE( symmetric_coroutine_yield)

    impl_type   *   impl_;
    R           *   result_;

    symmetric_coroutine_yield( impl_type * impl, R * result) BOOST_NOEXCEPT :
        impl_( impl),
        result_( result)
    {
        BOOST_ASSERT( 0 != impl_);
        BOOST_ASSERT( 0 != result_);
    }

public:
    symmetric_coroutine_yield() BOOST_NOEXCEPT :
        impl_( 0),
        result_( 0)
    {}

    symmetric_coroutine_yield( BOOST_RV_REF( symmetric_coroutine_yield) other) BOOST_NOEXCEPT :
        impl_( 0),
        result_( 0)
    { swap( other); }

    symmetric_coroutine_yield & operator=( BOOST_RV_REF( symmetric_coroutine_yield) other) BOOST_NOEXCEPT
    {
        symmetric_coroutine_yield tmp( boost::move( other) );
        swap( tmp);
        return * this;
    }

    BOOST_EXPLICIT_OPERATOR_BOOL();

    bool operator!() const BOOST_NOEXCEPT
    { return 0 == impl_; }

    void swap( symmetric_coroutine_yield & other) BOOST_NOEXCEPT
    {
        std::swap( impl_, other.impl_);
        std::swap( result_, other.result_);
    }

    symmetric_coroutine_yield & operator()()
    {
        result_ = impl_->yield();
        return * this;
    }

    template< typename Coro >
    symmetric_coroutine_yield & operator()( Coro & other, typename Coro::value_type & x,
                                            typename disable_if<
                                                is_same< typename Coro::value_type, void >,
                                                dummy*
                                            >::type = 0)
    {
        BOOST_ASSERT( other);

        result_ = impl_->yield_to( other.impl_, x);
        return * this;
    }

    template< typename Coro >
    symmetric_coroutine_yield & operator()( Coro & other,
                                            typename enable_if<
                                                is_same< typename Coro::value_type, void >,
                                                dummy*
                                            >::type = 0)
    {
        BOOST_ASSERT( other);

        result_ = impl_->yield_to( other.impl_);
        return * this;
    }

    R & get() const
    {
        if ( 0 == result_)
            boost::throw_exception(
                invalid_result() );

        return * result_; 
    }
};

template<>
class symmetric_coroutine_yield< void >
{
private:
    template< typename X, typename Y, typename Z >
    friend class symmetric_coroutine_object;

    typedef symmetric_coroutine_impl< void >    impl_type;

    struct dummy {};

    BOOST_MOVABLE_BUT_NOT_COPYABLE( symmetric_coroutine_yield)

    impl_type   *   impl_;

    symmetric_coroutine_yield( impl_type * impl) BOOST_NOEXCEPT :
        impl_( impl)
    { BOOST_ASSERT( 0 != impl_); }

public:
    symmetric_coroutine_yield() BOOST_NOEXCEPT :
        impl_( 0)
    {}

    symmetric_coroutine_yield( BOOST_RV_REF( symmetric_coroutine_yield) other) BOOST_NOEXCEPT :
        impl_( 0)
    { swap( other); }

    symmetric_coroutine_yield & operator=( BOOST_RV_REF( symmetric_coroutine_yield) other) BOOST_NOEXCEPT
    {
        symmetric_coroutine_yield tmp( boost::move( other) );
        swap( tmp);
        return * this;
    }

    BOOST_EXPLICIT_OPERATOR_BOOL();

    inline bool operator!() const BOOST_NOEXCEPT
    { return 0 == impl_; }

    inline void swap( symmetric_coroutine_yield & other) BOOST_NOEXCEPT
    { std::swap( impl_, other.impl_); }

    inline symmetric_coroutine_yield & operator()()
    {
        impl_->yield();
        return * this;
    }

    template< typename Coro >
    symmetric_coroutine_yield & operator()( Coro & other, typename Coro::value_type & x,
                                            typename disable_if<
                                                is_same< typename Coro::value_type, void >,
                                                dummy*
                                            >::type = 0)
    {
        BOOST_ASSERT( other);

        impl_->yield_to( other.impl_, x);
        return * this;
    }

    template< typename Coro >
    symmetric_coroutine_yield & operator()( Coro & other,
                                            typename enable_if<
                                                is_same< typename Coro::value_type, void >,
                                                dummy*
                                            >::type = 0)
    {
        BOOST_ASSERT( other);

        impl_->yield_to( other.impl_);
        return * this;
    }
};

template< typename R >
void swap( symmetric_coroutine_yield< R > & l, symmetric_coroutine_yield< R > & r)
{ l.swap( r); }

}}}

#ifdef BOOST_HAS_ABI_HEADERS
#  include BOOST_ABI_SUFFIX
#endif

#endif // BOOST_COROUTINES_DETAIL_SYMMETRIC_COROUTINE_YIELD_H
Commit	Line	Data
7c673cae FG	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_SYMMETRIC_COROUTINE_YIELD_H
	8	#define BOOST_COROUTINES_DETAIL_SYMMETRIC_COROUTINE_YIELD_H
	9
	10	#include <algorithm>
	11
	12	#include <boost/assert.hpp>
	13	#include <boost/config.hpp>
	14	#include <boost/move/move.hpp>
	15	#include <boost/throw_exception.hpp>
	16	#include <boost/type_traits/is_same.hpp>
	17	#include <boost/utility/enable_if.hpp>
	18	#include <boost/utility/explicit_operator_bool.hpp>
	19
	20	#include <boost/coroutine/detail/config.hpp>
	21	#include <boost/coroutine/exceptions.hpp>
	22
	23	#ifdef BOOST_HAS_ABI_HEADERS
	24	# include BOOST_ABI_PREFIX
	25	#endif
	26
	27	namespace boost {
	28	namespace coroutines {
	29	namespace detail {
	30
	31	template< typename R >
	32	class symmetric_coroutine_yield
	33	{
	34	private:
	35	template< typename X, typename Y, typename Z >
	36	friend class symmetric_coroutine_object;
	37
	38	typedef symmetric_coroutine_impl< R > impl_type;
	39
	40	struct dummy {};
	41
	42	BOOST_MOVABLE_BUT_NOT_COPYABLE( symmetric_coroutine_yield)
	43
	44	impl_type * impl_;
	45	R * result_;
	46
	47	symmetric_coroutine_yield( impl_type * impl, R * result) BOOST_NOEXCEPT :
	48	impl_( impl),
	49	result_( result)
	50	{
	51	BOOST_ASSERT( 0 != impl_);
	52	BOOST_ASSERT( 0 != result_);
	53	}
	54
	55	public:
	56	symmetric_coroutine_yield() BOOST_NOEXCEPT :
	57	impl_( 0),
	58	result_( 0)
	59	{}
	60
	61	symmetric_coroutine_yield( BOOST_RV_REF( symmetric_coroutine_yield) other) BOOST_NOEXCEPT :
	62	impl_( 0),
	63	result_( 0)
	64	{ swap( other); }
65
66	symmetric_coroutine_yield & operator=( BOOST_RV_REF( symmetric_coroutine_yield) other) BOOST_NOEXCEPT
67	{
68	symmetric_coroutine_yield tmp( boost::move( other) );
69	swap( tmp);
70	return * this;
71	}
72
73	BOOST_EXPLICIT_OPERATOR_BOOL();
74
75	bool operator!() const BOOST_NOEXCEPT
76	{ return 0 == impl_; }
77
78	void swap( symmetric_coroutine_yield & other) BOOST_NOEXCEPT
79	{
80	std::swap( impl_, other.impl_);
81	std::swap( result_, other.result_);
82	}
83
84	symmetric_coroutine_yield & operator()()
85	{
86	result_ = impl_->yield();
87	return * this;
88	}
89
90	template< typename Coro >
91	symmetric_coroutine_yield & operator()( Coro & other, typename Coro::value_type x,
92	typename disable_if<
93	is_same< typename Coro::value_type, void >,
94	dummy*
95	>::type = 0)
96	{
97	BOOST_ASSERT( other);
98
99	result_ = impl_->yield_to( other.impl_, x);
100	return * this;
101	}
102
103	template< typename Coro >
104	symmetric_coroutine_yield & operator()( Coro & other,
105	typename enable_if<
106	is_same< typename Coro::value_type, void >,
107	dummy*
108	>::type = 0)
109	{
110	BOOST_ASSERT( other);
111
112	result_ = impl_->yield_to( other.impl_);
113	return * this;
114	}
115
116	R get() const
117	{
118	if ( 0 == result_)
119	boost::throw_exception(
120	invalid_result() );
121
122	return * result_;
123	}
124	};
125
126	template< typename R >
127	class symmetric_coroutine_yield< R & >
128	{
129	private:
130	template< typename X, typename Y, typename Z >
131	friend class symmetric_coroutine_object;
132
133	typedef symmetric_coroutine_impl< R & > impl_type;
134
135	struct dummy {};
136
137	BOOST_MOVABLE_BUT_NOT_COPYABLE( symmetric_coroutine_yield)
138
139	impl_type * impl_;
140	R * result_;
141
142	symmetric_coroutine_yield( impl_type * impl, R * result) BOOST_NOEXCEPT :
143	impl_( impl),
144	result_( result)
145	{
146	BOOST_ASSERT( 0 != impl_);
147	BOOST_ASSERT( 0 != result_);
148	}
149
150	public:
151	symmetric_coroutine_yield() BOOST_NOEXCEPT :
152	impl_( 0),
153	result_( 0)
154	{}
155
156	symmetric_coroutine_yield( BOOST_RV_REF( symmetric_coroutine_yield) other) BOOST_NOEXCEPT :
157	impl_( 0),
158	result_( 0)
159	{ swap( other); }
160
161	symmetric_coroutine_yield & operator=( BOOST_RV_REF( symmetric_coroutine_yield) other) BOOST_NOEXCEPT
162	{
163	symmetric_coroutine_yield tmp( boost::move( other) );
164	swap( tmp);
165	return * this;
166	}
167
168	BOOST_EXPLICIT_OPERATOR_BOOL();
169
170	bool operator!() const BOOST_NOEXCEPT
171	{ return 0 == impl_; }
172
173	void swap( symmetric_coroutine_yield & other) BOOST_NOEXCEPT
174	{
175	std::swap( impl_, other.impl_);
176	std::swap( result_, other.result_);
177	}
178
179	symmetric_coroutine_yield & operator()()
180	{
181	result_ = impl_->yield();
182	return * this;
183	}
184
185	template< typename Coro >
186	symmetric_coroutine_yield & operator()( Coro & other, typename Coro::value_type & x,
187	typename disable_if<
188	is_same< typename Coro::value_type, void >,
189	dummy*
190	>::type = 0)
191	{
192	BOOST_ASSERT( other);
193
194	result_ = impl_->yield_to( other.impl_, x);
195	return * this;
196	}
197
198	template< typename Coro >
199	symmetric_coroutine_yield & operator()( Coro & other,
200	typename enable_if<
201	is_same< typename Coro::value_type, void >,
202	dummy*
203	>::type = 0)
204	{
205	BOOST_ASSERT( other);
206
207	result_ = impl_->yield_to( other.impl_);
208	return * this;
209	}
210
211	R & get() const
212	{
213	if ( 0 == result_)
214	boost::throw_exception(
215	invalid_result() );
216
217	return * result_;
218	}
219	};
220
221	template<>
222	class symmetric_coroutine_yield< void >
223	{
224	private:
225	template< typename X, typename Y, typename Z >
226	friend class symmetric_coroutine_object;
227
228	typedef symmetric_coroutine_impl< void > impl_type;
229
230	struct dummy {};
231
232	BOOST_MOVABLE_BUT_NOT_COPYABLE( symmetric_coroutine_yield)
233
234	impl_type * impl_;
235
236	symmetric_coroutine_yield( impl_type * impl) BOOST_NOEXCEPT :
237	impl_( impl)
238	{ BOOST_ASSERT( 0 != impl_); }
239
240	public:
241	symmetric_coroutine_yield() BOOST_NOEXCEPT :
242	impl_( 0)
243	{}
244
245	symmetric_coroutine_yield( BOOST_RV_REF( symmetric_coroutine_yield) other) BOOST_NOEXCEPT :
246	impl_( 0)
247	{ swap( other); }
248
249	symmetric_coroutine_yield & operator=( BOOST_RV_REF( symmetric_coroutine_yield) other) BOOST_NOEXCEPT
250	{
251	symmetric_coroutine_yield tmp( boost::move( other) );
252	swap( tmp);
253	return * this;
254	}
255
256	BOOST_EXPLICIT_OPERATOR_BOOL();
257
258	inline bool operator!() const BOOST_NOEXCEPT
259	{ return 0 == impl_; }
260
261	inline void swap( symmetric_coroutine_yield & other) BOOST_NOEXCEPT
262	{ std::swap( impl_, other.impl_); }
263
264	inline symmetric_coroutine_yield & operator()()
265	{
266	impl_->yield();
267	return * this;
268	}
269
270	template< typename Coro >
271	symmetric_coroutine_yield & operator()( Coro & other, typename Coro::value_type & x,
272	typename disable_if<
273	is_same< typename Coro::value_type, void >,
274	dummy*
275	>::type = 0)
276	{
277	BOOST_ASSERT( other);
278
279	impl_->yield_to( other.impl_, x);
280	return * this;
281	}
282
283	template< typename Coro >
284	symmetric_coroutine_yield & operator()( Coro & other,
285	typename enable_if<
286	is_same< typename Coro::value_type, void >,
287	dummy*
288	>::type = 0)
289	{
290	BOOST_ASSERT( other);
291
292	impl_->yield_to( other.impl_);
293	return * this;
294	}
295	};
296
297	template< typename R >
298	void swap( symmetric_coroutine_yield< R > & l, symmetric_coroutine_yield< R > & r)
299	{ l.swap( r); }
300
301	}}}
302
303	#ifdef BOOST_HAS_ABI_HEADERS
304	# include BOOST_ABI_SUFFIX
305	#endif
306
307	#endif // BOOST_COROUTINES_DETAIL_SYMMETRIC_COROUTINE_YIELD_H