Orbit Framework 2.0.0
A high-performance asynchronous C++20 HTTP server framework.
Loading...
Searching...
No Matches
Task.hpp
Go to the documentation of this file.
1#pragma once
3#include <orbit/concurrency/Awaitable.hpp> // helpers that handlers co_await
4#include <coroutine>
5#include <cstdint>
6#include <exception>
7#include <memory>
8#include <type_traits>
9
10namespace orbit::http { class ResponseWriter; struct HttpRequest; }
11
12namespace orbit::concurrency {
13
14namespace detail {
15// Defined in src/concurrency/Task.cpp, so this header needs no HTTP headers.
16uint64_t writer_generation(const std::shared_ptr<http::ResponseWriter>& writer) noexcept;
17std::shared_ptr<void> keep_request_alive(const http::HttpRequest& request) noexcept;
18void report_task_exception(const std::shared_ptr<http::ResponseWriter>& writer, uint64_t generation,
19 std::exception_ptr error) noexcept;
20} // namespace detail
21
36struct Task {
37 struct promise_type {
38 promise_type() = default;
39
40 // The compiler passes the coroutine's parameters to the promise's
41 // constructor; that is how a handler's ResponseWriter and request
42 // are found.
43 template <typename First, typename... Rest>
44 explicit promise_type(First& first, Rest&... rest) {
45 capture(first);
46 (capture(rest), ...);
47 }
48
50 return Task(std::coroutine_handle<promise_type>::from_promise(*this));
51 }
52 std::suspend_never initial_suspend() { return {}; }
53 std::suspend_never final_suspend() noexcept { return {}; }
54
55 void return_void() {}
56 void unhandled_exception() noexcept {
57 detail::report_task_exception(writer_, generation_, std::current_exception());
58 }
59
60 private:
61 template <typename T>
62 void capture(T& value) {
63 if constexpr (std::is_same_v<std::remove_cv_t<T>, std::shared_ptr<http::ResponseWriter>>) {
64 if (!writer_) {
65 writer_ = value;
67 }
68 } else if constexpr (std::is_same_v<std::remove_cv_t<T>, http::HttpRequest>) {
70 }
71 }
72
73 std::shared_ptr<http::ResponseWriter> writer_;
74 uint64_t generation_ = 0;
75 std::shared_ptr<void> request_; // the request's storage, held until the coroutine ends (#200)
76 };
77
78 std::coroutine_handle<promise_type> handle;
79
80 Task(std::coroutine_handle<promise_type> h) : handle(h) {}
81};
82
83} // namespace concurrency
Abstract interface for writing HTTP responses.
Definition ResponseWriter.hpp:23
uint64_t writer_generation(const std::shared_ptr< http::ResponseWriter > &writer) noexcept
std::shared_ptr< void > keep_request_alive(const http::HttpRequest &request) noexcept
void report_task_exception(const std::shared_ptr< http::ResponseWriter > &writer, uint64_t generation, std::exception_ptr error) noexcept
Definition Awaitable.hpp:10
Definition Task.hpp:10
std::suspend_never initial_suspend()
Definition Task.hpp:52
std::shared_ptr< void > request_
Definition Task.hpp:75
Task get_return_object()
Definition Task.hpp:49
promise_type(First &first, Rest &... rest)
Definition Task.hpp:44
void unhandled_exception() noexcept
Definition Task.hpp:56
std::shared_ptr< http::ResponseWriter > writer_
Definition Task.hpp:73
void capture(T &value)
Definition Task.hpp:62
void return_void()
Definition Task.hpp:55
std::suspend_never final_suspend() noexcept
Definition Task.hpp:53
uint64_t generation_
Definition Task.hpp:74
Fire-and-forget coroutine type, used as the return type of coroutine route handlers.
Definition Task.hpp:36
Task(std::coroutine_handle< promise_type > h)
Definition Task.hpp:80
std::coroutine_handle< promise_type > handle
Definition Task.hpp:78
Represents an incoming HTTP request.
Definition HttpRequest.hpp:54