Class coroutine

Class `coroutine`

#include <boost/coroutine/coroutine.hpp>

template< typename Signature >
class coroutine;

template<
    typename R,
    typename ArgTypes...
>
class coroutine< R ( ArgTypes...) >
{
public:
    typedef unspec-type caller_type;
    typedef unspec-type arguments;

    coroutine();

    template<
        typename Fn,
        typename StackAllocator = stack_allocator,
        typename Allocator = std::allocator< coroutine >
    >
    coroutine( Fn fn, attributes const& attr = attributes(),
               StackAllocator const& stack_alloc = StackAllocator(),
               Allocator const& alloc = Allocator() );

    template<
        typename Fn,
        typename StackAllocator = stack_allocator,
        typename Allocator = std::allocator< coroutine >
    >
    coroutine( Fn fn, arguments const& args,
               attributes const& attr = attributes(),
               StackAllocator const& stack_alloc = StackAllocator(),
               Allocator const& alloc = Allocator() );

    template<
        typename Fn,
        typename StackAllocator = stack_allocator,
        typename Allocator = std::allocator< coroutine >
    >
    coroutine( Fn && fn, attributes const& attr = attributes(),
               StackAllocator stack_alloc = StackAllocator(),
               Allocator const& alloc = Allocator() );

    template<
        typename Fn,
        typename StackAllocator = stack_allocator,
        typename Allocator = std::allocator< coroutine >
    >
    coroutine( Fn && fn arguments const& args,
               attributes const& attr = attributes(),
               StackAllocator stack_alloc = StackAllocator(),
               Allocator const& alloc = Allocator() );

    coroutine( coroutine && other);

    coroutine & operator=( coroutine && other);

    operator unspecified-bool-type() const;

    bool operator!() const;

    void swap( coroutine & other);

    bool empty() const;

    coroutine & operator()(A0 a0, ..., A9 a9);

    R get() const;
};

template< typename Signature >
void swap( coroutine< Signature > & l, coroutine< Signature > & r);

template< typename T >
range_iterator< coroutine< T() > >::type begin( coroutine< T() > &);
template< typename T >
range_iterator< coroutine< void(T) > >::type begin( coroutine< void(T) > &);

template< typename T >
range_iterator< coroutine< T() > >::type end( coroutine< T() > &);
template< typename T >
range_iterator< coroutine< void(T) > >::type end( coroutine< void(T) > &);

`coroutine()`

Effects:: Creates a coroutine representing not-a-coroutine.
Throws:: Nothing.

`template< typename Fn, typename StackAllocator, typename Allocator > coroutine( Fn fn, attributes const& attr, StackAllocator const& stack_alloc, Allocator const& alloc)`

Preconditions:: size > minimum_stacksize(), size < maximum_stacksize() when ! is_stack_unbound().
Effects:: Creates a coroutine which will execute fn. Argument attr determines stack clean-up and preserving floating-point registers. For allocating/deallocating the stack stack_alloc is used and internal data are allocated by Allocator.

`template< typename Fn, typename StackAllocator, typename Allocator > coroutine( Fn && fn, attributes const& attr, StackAllocator const& stack_alloc, Allocator const& alloc)`

Preconditions:: size > minimum_stacksize(), size < maximum_stacksize() when ! is_stack_unbound().
Effects:: Creates a coroutine which will execute fn. Argument attr determines stack clean-up and preserving floating-point registers. For allocating/deallocating the stack stack_alloc is used and internal data are allocated by Allocator.

`coroutine( coroutine && other)`

Effects:: Moves the internal data of other to *this. other becomes not-a-coroutine.
Throws:: Nothing.

`coroutine & operator=( coroutine && other)`

Effects:: Destroys the internal data of *this and moves the internal data of other to *this. other becomes not-a-coroutine.
Throws:: Nothing.

`operator unspecified-bool-type() const`

Returns:: If *this refers to not-a-coroutine or the coroutine-function has returned (completed), the function returns false. Otherwise true.
Throws:: Nothing.

`bool operator!() const`

Returns:: If *this refers to not-a-coroutine or the coroutine-function has returned (completed), the function returns true. Otherwise false.
Throws:: Nothing.

`bool empty()`

Returns:: If *this refers to not-a-coroutine, the function returns true. Otherwise false.
Throws:: Nothing.

`coroutine<> & operator()(A0 a0, A9 a9)`

Preconditions:

operator unspecified-bool-type() returns true for *this.

[Effects:

Execution control is transferred to coroutine-function and the arguments a0,..., are passed to the coroutine-function.

Throws:

Exceptions thrown inside coroutine-function.

`R get()()`

Preconditions:: *this is not a not-a-coroutine, ! is_complete().
Returns:: Returns data transferred from coroutine-function via boost::coroutines::coroutine<>::operator() of boost::coroutines::coroutine<>::caller_type.
Throws:: Nothing.

`void swap( coroutine & other)`

Effects:: Swaps the internal data from *this with the values of other.
Throws:: Nothing.

`T caller_type::operator()( R)`

Effects:: Gives execution control back to calling context by returning a value of type R. The return type of this function is a boost::tuple<> containing the arguments passed to boost::coroutines::coroutine<>::operator().
Throws:: Nothing.

Non-member function `swap()`

template< typename Signature >
void swap( coroutine< Signature > & l, coroutine< Signature > & r);

Effects:: As if 'l.swap( r)'.

Non-member function `begin( coroutine< T() > &)`

template< typename T >
range_iterator< coroutine< T() > >::type begin( coroutine< T() > &);

Returns:: Returns a range-iterator (input-iterator).

Non-member function `begin( coroutine< void(T) > &)`

template< typename T >
range_iterator< coroutine< void(T) > >::type begin( coroutine< void(T) > &);

Returns:: Returns a range-iterator (output-iterator).

Non-member function `end( coroutine< T() > &)`

template< typename T >
range_iterator< coroutine< T() > >::type end( coroutine< T() > &);

Returns:: Returns a end range-iterator (input-iterator).

Non-member function `end( coroutine< void(T) > &)`

template< typename T >
range_iterator< coroutine< void(T) > >::type end( coroutine< void(T) > &);

Returns:: Returns a end range-iterator (output-iterator).