event.hpp

#ifndef MRS_LIB_CORO_EVENT_HPP_
#define MRS_LIB_CORO_EVENT_HPP_
 
 
#include <memory>
#include <coroutine>
#include <mutex>
#include <cassert>
#include <optional>
#include <utility>
 
#include "mrs_lib/coro/internal/continuation.hpp"
#include "mrs_lib/coro/internal/immediate_awaitable.hpp"
 
 
namespace mrs_lib::coro
{
 
  class Event;
  class EventAwaitable;
 
  std::pair<Event, EventAwaitable> make_event();
 
  class EventError : std::logic_error
  {
  public:
    enum class Type
    {
      empty_awaitable_state,
    };
 
    EventError(Type type);
 
  private:
    static const char* get_msg(Type type);
 
    Type type_;
  };
 
  namespace internal
  {
 
    class EventState
    {
    private:
      enum class Status
      {
        unset,
        set,
        cancelled,
      };
 
      struct StopCallbackCallable
      {
        EventState* event_state;
 
        void operator()();
      };
 
    public:
      bool try_trigger();
 
      bool try_cancel();
 
      bool add_continuation(CancellableContinuation continuation, bool token_cancelable, std::function<void()> callback);
 
      bool is_ready();
 
    private:
      std::mutex mutex_{};
      Status status_ = Status::unset;
      internal::CancellableContinuation continuation_{};
 
      std::optional<std::stop_callback<StopCallbackCallable>> stop_callback_{};
    };
 
    class LowLevelEventAwaitable
    {
    public:
      class [[nodiscard]] Awaiter
      {
      public:
        explicit Awaiter(std::shared_ptr<internal::EventState> state, bool token_cancellable, std::function<void()> callback);
 
        bool await_ready();
        template <typename T>
        bool await_suspend(std::coroutine_handle<T> handle)
        {
          return await_suspend(CancellableContinuation(handle));
        }
        bool await_suspend(CancellableContinuation continuation);
        void await_resume();
 
      private:
        std::shared_ptr<internal::EventState> state_;
        bool is_token_cancellable_ = true;
        std::function<void()> callback_;
      };
 
      enum class StopTokenBehavior
      {
        respect,
        ignore,
      };
 
 
      ~LowLevelEventAwaitable() = default;
 
      LowLevelEventAwaitable(const LowLevelEventAwaitable&) = delete;
      LowLevelEventAwaitable& operator=(const LowLevelEventAwaitable&) = delete;
      LowLevelEventAwaitable(LowLevelEventAwaitable&& other) noexcept;
      LowLevelEventAwaitable& operator=(LowLevelEventAwaitable&& other) noexcept;
 
      ImmediateAwaitable<Awaiter> get_awaitable() &&;
 
      ImmediateAwaitable<Awaiter> get_awaitable(StopTokenBehavior stop_token_behavior, std::function<void()> callback) &&;
 
    private:
      explicit LowLevelEventAwaitable(std::shared_ptr<internal::EventState> state);
 
      std::shared_ptr<internal::EventState> state_;
 
      friend std::pair<Event, EventAwaitable> mrs_lib::coro::make_event();
    };
 
    LowLevelEventAwaitable get_low_level_event_awaitable(EventAwaitable event_awaitable);
 
  } // namespace internal
 
  class Event
  {
  public:
    ~Event();
 
    Event(const Event&) = delete;
    Event& operator=(const Event&) = delete;
 
    Event(Event&& other) noexcept;
    Event& operator=(Event&& other) noexcept;
 
    bool try_trigger();
 
    bool try_cancel();
 
  private:
    explicit Event(std::shared_ptr<internal::EventState> state);
 
    std::shared_ptr<internal::EventState> state_;
 
    friend std::pair<Event, EventAwaitable> make_event();
  };
 
  class EventAwaitable
  {
  public:
    explicit EventAwaitable(internal::LowLevelEventAwaitable internal_awaitable);
 
    auto wait() && -> internal::ImmediateAwaitable<internal::LowLevelEventAwaitable::Awaiter>;
 
  private:
    internal::LowLevelEventAwaitable internal_awaitable_;
 
    friend internal::LowLevelEventAwaitable internal::get_low_level_event_awaitable(EventAwaitable event_awaitable);
  };
 
} // namespace mrs_lib::coro
 
#endif // MRS_LIB_CORO_EVENT_HPP_