Class coroutine

| Home | Libraries | People | FAQ | More

### 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).