coroutine.hpp

Go to the documentation of this file.

 
#ifndef COROUTINE_HPP_INCLUDED
#define COROUTINE_HPP_INCLUDED
 
#include <coroutine>
#include <exception>
#include <expected>
#include <optional>
#include <string>
 
#include "iconnection.hpp"
 
namespace cpp_restapi
{
 
    namespace detail
    {
 
        struct FetchAwaitable
        {
            IConnection& connection;
            std::string request;
            std::optional<std::expected<Response, HttpError>> result;
            CancellationToken cancel;
 
            bool await_ready() const noexcept { return false; }
 
            void await_suspend(std::coroutine_handle<> h)
            {
                cancel = connection.fetch(request,
                    [this, h](Response resp) mutable
                    {
                        result.emplace(std::move(resp));
                        h.resume();
                    },
                    [this, h](HttpError err) mutable
                    {
                        result.emplace(std::unexpected(std::move(err)));
                        h.resume();
                    });
            }
 
            std::expected<Response, HttpError> await_resume()
            {
                return std::move(*result);
            }
        };
 
        struct PaginatedFetchAwaitable
        {
            IConnection& connection;
            std::string request;
            IPaginationStrategy& strategy;
            std::optional<std::expected<std::string, HttpError>> result;
            CancellationToken cancel;
 
            bool await_ready() const noexcept { return false; }
 
            void await_suspend(std::coroutine_handle<> h)
            {
                cancel = connection.fetch(request, strategy,
                    [this, h](std::string body) mutable
                    {
                        result.emplace(std::move(body));
                        h.resume();
                    },
                    [this, h](HttpError err) mutable
                    {
                        result.emplace(std::unexpected(std::move(err)));
                        h.resume();
                    });
            }
 
            std::expected<std::string, HttpError> await_resume()
            {
                return std::move(*result);
            }
        };
 
    } // namespace detail
 
    inline detail::FetchAwaitable
    coFetch(IConnection& connection, const std::string& request)
    {
        return {connection, request, {}, {}};
    }
 
    inline detail::PaginatedFetchAwaitable
    coFetch(IConnection& connection, const std::string& request, IPaginationStrategy& strategy)
    {
        return {connection, request, strategy, {}, {}};
    }
 
    struct Detached
    {
        struct promise_type
        {
            Detached get_return_object() { return {}; }
            std::suspend_never initial_suspend() noexcept { return {}; }
            std::suspend_never final_suspend() noexcept { return {}; }
            void return_void() {}
            void unhandled_exception() { std::terminate(); }
        };
    };
 
} // namespace cpp_restapi
 
#endif