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/internal/internal_utils.h"
#include "uvco/loop/loop.h"
 
#include <boost/assert.hpp>
#include <fmt/core.h>
#include <fmt/format.h>
 
#include <coroutine>
#include <cstdio>
#include <exception>
#include <optional>
#include <typeinfo>
#include <utility>
#include <uv.h>
#include <variant>
 
namespace uvco {
 
enum class PromiseState {
  init = 0,
  waitedOn = 1,
  resuming = 2,
  finished = 3,
};
 
template <typename T> class PromiseCore : public RefCounted<PromiseCore<T>> {
public:
  PromiseCore() = default;
 
  // The promise core is pinned in memory until the coroutine has finished.
  PromiseCore(const PromiseCore &) = delete;
  PromiseCore(PromiseCore &&) = delete;
  PromiseCore &operator=(const PromiseCore &) = delete;
  PromiseCore &operator=(PromiseCore &&) = delete;
  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");
    }
    handle_ = handle;
    state_ = PromiseState::waitedOn;
  }
 
  void resetHandle() {
    BOOST_ASSERT((state_ == PromiseState::waitedOn && handle_) ||
                 (state_ == PromiseState::finished && !handle_) ||
                 (state_ == PromiseState::init && !handle_));
    if (state_ == PromiseState::waitedOn) {
      handle_.reset();
      state_ = PromiseState::init;
    }
  }
 
  void cancel() {
    if (state_ == PromiseState::init || state_ == PromiseState::waitedOn) {
      BOOST_ASSERT(!ready());
      // Fill the slot with an exception, so that the coroutine can be resumed.
      // Double-check `if` for release builds.
      if (!slot) {
        slot = std::make_exception_ptr(
            UvcoException(UV_ECANCELED, "Promise cancelled"));
      }
      resume();
    }
    // else: the underlying coroutine has already returned, so there is no need
    // to cancel it.
  }
 
  bool willResume() { return handle_.has_value(); }
  [[nodiscard]] bool ready() const { return slot.has_value(); }
  [[nodiscard]] bool stale() const {
    return state_ == PromiseState::finished && !ready();
  }
 
  virtual void resume() {
    if (handle_) {
      BOOST_ASSERT(state_ == PromiseState::waitedOn);
      state_ = PromiseState::resuming;
      auto resume = *handle_;
      handle_.reset();
      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)
    }
 
    switch (state_) {
    case PromiseState::init:
      // Coroutine returns but nobody has awaited yet. This is fine.
      state_ = PromiseState::finished;
      break;
    case PromiseState::resuming:
      // Not entirely correct, but the resumed awaiting coroutine is not coming
      // back to us.
      state_ = PromiseState::finished;
      break;
    case PromiseState::waitedOn:
      // state is waitedOn, but no handle is set - that's an error.
      BOOST_ASSERT_MSG(
          false,
          "PromiseCore::resume() called without handle in state waitedOn");
      break;
    case PromiseState::finished:
      // Happens in MultiPromiseCore on co_return if the co_awaiter has lost
      // interest. Harmless if !handle_ (asserted above).
      break;
    }
  }
 
  virtual ~PromiseCore() {
    if (state_ != PromiseState::finished) {
      fmt::print(
          stderr,
          "PromiseCore destroyed without ever being resumed ({}, state = {})\n",
          typeid(T).name(), static_cast<int>(state_));
    }
    // This only happens if the awaiting coroutine has never been resumed, but
    // the last promise provided by it is gone (in turn calling
    // ~PromiseCore()). Important: we may only destroy a suspended coroutine,
    // not a finished one.
    if (handle_) {
      handle_->destroy();
    }
  }
 
  void except(const std::exception_ptr &exc) { slot = exc; }
 
  std::optional<std::variant<T, std::exception_ptr>> slot;
 
protected:
  std::optional<std::coroutine_handle<>> handle_;
  PromiseState state_ = PromiseState::init;
};
 
template <> class PromiseCore<void> : public RefCounted<PromiseCore<void>> {
public:
  PromiseCore() = default;
  PromiseCore(const PromiseCore &) = delete;
  PromiseCore(PromiseCore &&) = delete;
  PromiseCore<void> &operator=(const PromiseCore &) = delete;
  PromiseCore<void> &operator=(PromiseCore &&) = delete;
  ~PromiseCore() override;
 
  void cancel();
 
  void setHandle(std::coroutine_handle<> handle);
 
  void resetHandle();
  [[nodiscard]] bool willResume() const;
  [[nodiscard]] bool ready() const;
  [[nodiscard]] bool stale() const;
 
  void resume();
 
  void except(std::exception_ptr exc);
 
  bool ready_ = false;
 
  std::optional<std::exception_ptr> exception_;
 
private:
  std::optional<std::coroutine_handle<>> handle_;
  PromiseState state_ = PromiseState::init;
};
 
 
} // namespace uvco