request_reply.h

Go to the documentation of this file.

 
#pragma once
 
#include "./memory_promise.h"
#include "./owning_coroutine_handle.h"
 
#include <coroutine>
#include <optional>
 
namespace emlabcpp::coro
{
 
template < typename RequestType, typename ReplyType >
class request_reply
{
public:
        using request_type = RequestType;
        using reply_type   = ReplyType;
 
        struct promise_type;
 
        struct awaiter
        {
                promise_type* prom_;
 
                bool await_ready()
                {
                        return false;
                }
 
                void await_suspend( std::coroutine_handle<> )
                {
                }
 
                ReplyType const& await_resume()
                {
                        // NOLINTNEXTLINE
                        return *prom_->reply;
                }
        };
 
        struct promise_type : memory_promise< promise_type >
        {
                std::optional< RequestType > request;
                std::optional< ReplyType >   reply;
 
                static request_reply get_return_object_on_allocation_failure()
                {
                        return {};
                }
 
                request_reply get_return_object()
                {
                        return { handle::from_promise( *this ) };
                }
 
                std::suspend_never initial_suspend()
                {
                        return {};
                }
 
                std::suspend_always final_suspend() noexcept
                {
                        return {};
                }
 
                void unhandled_exception()
                {
                }
 
                void return_void()
                {
                }
 
                awaiter yield_value( RequestType out )
                {
                        request = out;
                        return { this };
                }
        };
 
        using handle        = std::coroutine_handle< promise_type >;
        using owning_handle = owning_coroutine_handle< promise_type >;
 
        request_reply() = default;
 
        request_reply( handle const cor )
          : h_( cor )
        {
        }
 
        request_reply( request_reply const& )            = delete;
        request_reply& operator=( request_reply const& ) = delete;
 
        request_reply( request_reply&& ) noexcept            = default;
        request_reply& operator=( request_reply&& ) noexcept = default;
 
        RequestType const* get_request()
        {
                if ( !h_ )
                        return nullptr;
                std::optional< RequestType >& opt_val = h_.promise().request;
                if ( !opt_val.has_value() )
                        return nullptr;
                return &*opt_val;
        }
 
        bool has_reply()
        {
                if ( h_ )
                        return h_.promise().reply.has_value();
                else
                        return false;
        }
 
        void store_reply( ReplyType const& inpt )
        {
                if ( h_ )
                        h_.promise().reply = inpt;
        }
 
        [[nodiscard]] operator bool() const
        {
                return h_.done();
        }
 
        [[nodiscard]] bool done() const
        {
                return h_.done();
        }
 
        [[nodiscard]] bool tick()
        {
                if ( !h_.promise().reply )
                        return false;
                if ( !h_ )
                        return false;
                if ( h_.done() )
                        return false;
                h_.promise().request.reset();
                h_();
                h_.promise().reply.reset();
                return true;
        }
 
        [[nodiscard]] void* address() const
        {
                return h_.address();
        }
 
private:
        owning_handle h_;
};
 
}  // namespace emlabcpp::coro