coroutine.hpp

Go to the documentation of this file.

//SPDX-License-Identifier: Apache-2.0
//Author: Blayne Dennis 
#ifndef __MERCURY_COROUTINE_ENGINE_COROUTINE__
#define __MERCURY_COROUTINE_ENGINE_COROUTINE__
 
// c++
#include <thread>
#include <memory>
 
// boost
#include <boost/coroutine2/all.hpp>
 
// local
#include "function_utility.hpp"
 
// test, only uncomment for development of this library
//#include "dev_print.hpp"
 
namespace mce {
 
struct coroutine;
 
namespace detail {
 
// always points to the running coroutine
coroutine*& tl_this_coroutine();
 
}
 
//-----------------------------------------------------------------------------
// coroutine
//----------------------------------------------------------------------------- 
struct coroutine
{
    template <typename Callable, typename... As>
    static std::unique_ptr<coroutine> make(Callable&& cb, As&&... as)
    {
        return std::unique_ptr<coroutine>(
            new coroutine(
                make_thunk(
                    std::forward<Callable>(cb),
                    std::forward<As>(as)...)));
    }
 
    template <typename THUNK>
    coroutine(THUNK&& th) :
        yield_(nullptr),
        co_(co_t::pull_type(wrapper_functor{ yield_, std::forward<THUNK>(th) }))
    { }
 
    template <typename StackAllocator, typename THUNK>
    coroutine(StackAllocator&& sa, THUNK&& th) :
        yield_(nullptr),
        co_(std::forward<StackAllocator>(sa), 
            co_t::pull_type(wrapper_functor{ yield_, std::forward<THUNK>(th) }))
    { }
 
    // Copy Constructor (Not allowed)
    coroutine(const coroutine& source) = delete;
 
    coroutine(coroutine&& rhs) noexcept :
        yield_(std::move(rhs.yield_)),
        co_(std::move(rhs.co_))
    { }
 
    // Copy Assignment (Not allowed)
    coroutine& operator=(const coroutine& rhs) = delete;
 
    coroutine& operator=(coroutine&& rhs) noexcept
    {
        yield_ = std::move(rhs.yield_);
        co_ = std::move(rhs.co_);
        return *this;
    }
 
    virtual ~coroutine(){}
 
    virtual inline void run()
    {
        if(!complete())
        {
            auto& tl_co = detail::tl_this_coroutine();
 
            // store parent coroutine
            auto parent_co = tl_co;
 
            // set current coroutine ptr 
            tl_co = this; 
            
            // continue coroutine execution
            try { co_(); }
            catch(...)
            {
                // restore parent coroutine ptr
                tl_co = parent_co;
                std::rethrow_exception(std::current_exception());
            }
 
            // restore parent coroutine ptr
            tl_co = parent_co;
        };
    }
 
    inline void yield() 
    { 
        (*yield_)(); 
    }
 
    inline bool complete()
    { 
        return !(co_.operator bool());
    }
 
private:
    typedef boost::coroutines2::coroutine<void> co_t;
 
    struct wrapper_functor
    {
        inline void operator()(coroutine::co_t::push_type& yield)
        {
            yield_ = &yield;
            yield(); // yield after coroutine construction but before execution 
            th(); // execute thunk when coroutine resumes
        }
 
        co_t::push_type*& yield_;
        mce::thunk th;
    };
 
    co_t::push_type* yield_;
    co_t::pull_type co_;
};
 
inline bool in_coroutine()
{ 
    return detail::tl_this_coroutine() ? true : false; 
}
 
inline coroutine* this_coroutine()
{ 
    return detail::tl_this_coroutine(); 
}
 
inline void yield()
{ 
    coroutine* c = detail::tl_this_coroutine();
    if(c) { c->yield(); }
}
 
}
 
#endif