task.hpp

#pragma once
 
#include <coroutine>
#include <exception>
#include <utility>
 
namespace ravel {
 
class Task {
 public:
  struct promise_type {
    Task get_return_object() noexcept {
      return Task(std::coroutine_handle<promise_type>::from_promise(*this));
    }
    std::suspend_always initial_suspend() const noexcept { return {}; }
    std::suspend_always final_suspend() const noexcept { return {}; }
    void return_void() const noexcept {}
    void unhandled_exception() noexcept { exception = std::current_exception(); }
 
    std::exception_ptr exception;
  };
 
  Task() noexcept = default;
  Task(Task&& other) noexcept : handle_(std::exchange(other.handle_, {})) {}
  Task& operator=(Task&& other) noexcept {
    if (this != &other) {
      destroy();
      handle_ = std::exchange(other.handle_, {});
    }
    return *this;
  }
  Task(const Task&) = delete;
  Task& operator=(const Task&) = delete;
  ~Task() { destroy(); }
 
  bool done() const noexcept { return !handle_ || handle_.done(); }
 
  void resume() { handle_.resume(); }
 
  std::exception_ptr exception() const noexcept {
    return handle_ ? handle_.promise().exception : nullptr;
  }
 
 private:
  explicit Task(std::coroutine_handle<promise_type> handle) noexcept : handle_(handle) {}
 
  void destroy() noexcept {
    if (handle_) handle_.destroy();
    handle_ = {};
  }
 
  std::coroutine_handle<promise_type> handle_;
};
 
}  // namespace ravel