SyncExecutionContext.hpp

#pragma once
 
#include "util/async/context/BasicExecutionContext.hpp"
#include "util/async/context/SystemExecutionContext.hpp"
#include "util/async/context/impl/Cancellation.hpp"
 
#include <boost/asio/error.hpp>
 
#include <cstddef>
 
namespace util::async {
namespace impl {
 
struct SameThreadContext {
    struct Executor {
        Executor(std::size_t)
        {
        }
 
        void
        stop() const noexcept
        {
        }
 
        void
        join() const noexcept
        {
        }
    };
 
    // Note: these types are not actually used but needed for compilation
    struct Timer {};
    struct Strand {
        struct Executor {};
        struct Timer {};
    };
 
    Executor executor;
 
    void
    stop() const noexcept
    {
        executor.stop();
    }
 
    void
    join() const noexcept
    {
        executor.join();
    }
 
    Executor&
    getExecutor()
    {
        return executor;
    }
 
    [[nodiscard]] Strand
    makeStrand() noexcept  // NOLINT(readability-convert-member-functions-to-static)
    {
        return {};
    }
};
 
struct SystemContextProvider {
    template <typename CtxType>
    [[nodiscard]] static constexpr auto&
    getContext([[maybe_unused]] CtxType& self) noexcept
    {
        return SystemExecutionContext::instance();
    }
};
 
}  // namespace impl

using SyncExecutionContext = BasicExecutionContext<
    impl::SameThreadContext,
    impl::BasicStopSource,
    impl::SyncDispatchStrategy,
    impl::SystemContextProvider>;
 
}  // namespace util::async