promise_core.h

Go to the documentation of this file.

// uvco (c) 2023 Lewin Bormann. See LICENSE for specific terms.
 
#pragma once
 
#include "uvco/exception.h"
#include "uvco/loop/loop.h"
 
#include <boost/assert.hpp>
#include <fmt/core.h>
#include <fmt/format.h>
 
#include <coroutine>
#include <exception>
#include <optional>
#include <utility>
#include <uv.h>
#include <variant>
 
namespace uvco {

enum class PromiseState {
  init = 0,
  waitedOn = 1,
  finished = 2,
};

template <typename T> class PromiseCore {
public:
  PromiseCore() = default;
  PromiseCore(const PromiseCore &) = delete;
  PromiseCore(PromiseCore &&) = delete;
  PromiseCore &operator=(const PromiseCore &) = delete;
  PromiseCore &operator=(PromiseCore &&) = delete;
  virtual ~PromiseCore() = default;
 
  explicit PromiseCore(T &&value)
      : slot{std::move(value)}, state_{PromiseState::finished} {}

  virtual void setHandle(std::coroutine_handle<> handle) {
    if (state_ != PromiseState::init) {
      throw UvcoException("PromiseCore is already awaited or has finished");
    }
    waitingHandle_ = handle;
    state_ = PromiseState::waitedOn;
  }

  void setRunning(std::coroutine_handle<> handle) {
    BOOST_ASSERT(state_ == PromiseState::init);
    coroutine_ = handle;
  }

  void resetHandle() {
    BOOST_ASSERT((state_ == PromiseState::waitedOn && waitingHandle_) ||
                 (state_ == PromiseState::finished && !waitingHandle_) ||
                 (state_ == PromiseState::init && !waitingHandle_));
    if (state_ == PromiseState::waitedOn) {
      waitingHandle_ = nullptr;
      state_ = PromiseState::init;
    }
  }

  bool isAwaited() { return waitingHandle_ != nullptr; }

  [[nodiscard]] bool ready() const { return slot.has_value(); }

  [[nodiscard]] bool stale() const {
    return state_ == PromiseState::finished && !ready();
  }

  void resume() {
    if (waitingHandle_) {
      BOOST_ASSERT(state_ == PromiseState::waitedOn);
      const std::coroutine_handle<> resume = waitingHandle_;
      waitingHandle_ = nullptr;
      Loop::enqueue(resume);
    } else {
      // This occurs if no co_await has occured until resume. Either the
      // promise was not co_awaited, or the producing coroutine immediately
      // returned a value. (await_ready() == true)
    }
    state_ = PromiseState::finished;
  }
 
  void destroyCoroutine() {
    if (coroutine_) {
      Loop::cancel(coroutine_);
      coroutine_.destroy();
    }
  }
 
  void except(const std::exception_ptr &exc) { slot = exc; }

  std::optional<std::variant<T, std::exception_ptr>> slot;
 
protected:
  std::coroutine_handle<> coroutine_;
  std::coroutine_handle<> waitingHandle_;
  static_assert(sizeof(std::coroutine_handle<>) <= sizeof(void *),
                "coroutine_handle is unusually large");
  PromiseState state_ = PromiseState::init;
};

template <> class PromiseCore<void> {
public:
  PromiseCore() = default;
  PromiseCore(const PromiseCore &) = delete;
  PromiseCore(PromiseCore &&) = delete;
  PromiseCore<void> &operator=(const PromiseCore &) = delete;
  PromiseCore<void> &operator=(PromiseCore &&) = delete;
  ~PromiseCore() = default;

  void setHandle(std::coroutine_handle<> handle);

  void resetHandle();
  [[nodiscard]] bool isAwaited() const;
  [[nodiscard]] bool ready() const;
  [[nodiscard]] bool stale() const;

  void resume();

  void except(std::exception_ptr exc);
 
  // Managing coroutine state.
  void setRunning(std::coroutine_handle<> handle);
 
  // Destroy the coroutine state associated with this core. Must be routinely
  // invoked after coroutine completion (due to suspend_always returned from
  // final_suspend).
  void destroyCoroutine() {
    if (coroutine_) {
      Loop::cancel(coroutine_);
      coroutine_.destroy();
    }
  }

  bool ready_ = false;

  std::optional<std::exception_ptr> exception_;
 
private:
  std::coroutine_handle<> coroutine_;
  std::coroutine_handle<> waitingHandle_;
  PromiseState state_ = PromiseState::init;
};

 
} // namespace uvco