include/boost/corosio/detail/op_base.hpp

100.0% Lines (42 / 42) 98.8% Functions (494 / 500)

[ ] prev/next file

op_base.hpp

f(x) Functions (500)

Function Calls Lines Blocks

Line	Hits	Source Code
1		//
2		// Copyright (c) 2026 Michael Vandeberg
3		//
4		// Distributed under the Boost Software License, Version 1.0. (See accompanying
5		// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
6		//
7		// Official repository: https://github.com/cppalliance/corosio
8		//
9
10		#ifndef BOOST_COROSIO_DETAIL_OP_BASE_HPP
11		#define BOOST_COROSIO_DETAIL_OP_BASE_HPP
12
13		#include <boost/capy/error.hpp>
14		#include <boost/capy/continuation.hpp>
15		#include <boost/capy/results.hpp>
16		#include <boost/capy/ex/executor_ref.hpp>
17		#include <boost/capy/ex/await_context.hpp>
18
19		#include <coroutine>
20		#include <cstddef>
21		#include <stop_token>
22		#include <system_error>
23
24		namespace boost::corosio::detail {
25
26		/* CRTP base for awaitables that return results<std::size_t>.
27
28		Derived classes must provide:
29
30		std::coroutine_handle<> dispatch(
31		capy::continuation& cont,
32		capy::executor_ref ex) const;
33
34		which forwards to the backend implementation method, passing
35		token_, &ec_, and &bytes_ as the cancellation/output parameters.
36		*/
37		template<class Derived>
38		class bytes_op_base
39		{
40		friend Derived;
41	713857x	bytes_op_base() = default;
42
43		public:
44		std::stop_token token_;
45		mutable std::error_code ec_;
46		mutable std::size_t bytes_ = 0;
47		// Lives in the awaiting frame until resumption, so a completion
48		// posted through an executor never shares the object's state.
49		mutable capy::continuation cont_;
50
51	713857x	bool await_ready() const noexcept
52		{
53		// A pre-set ec_ means the initiator failed before dispatch
54		// (e.g. a closed object); complete immediately with that error.
55	713857x	return static_cast<bool>(ec_);
56		}
57
58	713153x	[[nodiscard]] capy::results<std::size_t> await_resume() const noexcept
59		{
60	713153x	return {ec_, bytes_};
61		}
62
63	713803x	auto await_suspend(std::coroutine_handle<> h, capy::await_context const* env)
64		-> std::coroutine_handle<>
65		{
66	713803x	token_ = env->stop_token;
67		// A pre-stopped token short-circuits before dispatch so no I/O
68		// is performed. A stop landing after dispatch is decoded by the
69		// backend, and a completed transfer is reported verbatim: the
70		// stream contracts forbid discarding the byte count.
71	713803x	if (token_.stop_requested())
72		{
73	427x	ec_ = capy::error::canceled;
74	427x	return h;
75		}
76	713376x	cont_.h = h;
77	713376x	cont_.owner = env->owner;
78	713376x	return static_cast<Derived const*>(this)->dispatch(
79	713376x	cont_, env->executor);
80		}
81		};
82
83		/* CRTP base for awaitables that return results<Value> for a
84		moved-out result object (e.g. the resolver's result lists).
85
86		Derived classes must provide:
87
88		std::coroutine_handle<> dispatch(
89		capy::continuation& cont,
90		capy::executor_ref ex) const;
91
92		which forwards to the backend implementation method, passing
93		token_, &ec_, and &value_ as the cancellation/output parameters.
94		*/
95		template<class Derived, class Value>
96		class value_op_base
97		{
98		friend Derived;
99	309361x	value_op_base() = default;
100
101		public:
102		std::stop_token token_;
103		mutable std::error_code ec_;
104		mutable Value value_{};
105		// See bytes_op_base::cont_.
106		mutable capy::continuation cont_;
107
108	309361x	bool await_ready() const noexcept
109		{
110		// A pre-set ec_ means the initiator failed before dispatch;
111		// complete immediately with that error.
112	309361x	return static_cast<bool>(ec_);
113		}
114
115	304523x	[[nodiscard]] capy::results<Value> await_resume() const noexcept
116		{
117	304523x	return {ec_, std::move(value_)};
118		}
119
120	309361x	auto await_suspend(std::coroutine_handle<> h, capy::await_context const* env)
121		-> std::coroutine_handle<>
122		{
123	309361x	token_ = env->stop_token;
124		// A pre-stopped token short-circuits before dispatch; a stop
125		// landing after dispatch leaves the completed result intact.
126	309361x	if (token_.stop_requested())
127		{
128	67x	ec_ = capy::error::canceled;
129	67x	return h;
130		}
131	309294x	cont_.h = h;
132	309294x	cont_.owner = env->owner;
133	309294x	return static_cast<Derived const*>(this)->dispatch(
134	309294x	cont_, env->executor);
135		}
136		};
137
138		/* CRTP base for awaitables that return results<>.
139
140		Derived classes must provide:
141
142		std::coroutine_handle<> dispatch(
143		capy::continuation& cont,
144		capy::executor_ref ex) const;
145
146		which forwards to the backend implementation method, passing
147		token_ and &ec_ as the cancellation/output parameters.
148		*/
149		template<class Derived>
150		class void_op_base
151		{
152		friend Derived;
153	30868x	void_op_base() = default;
154
155		public:
156		std::stop_token token_;
157		mutable std::error_code ec_;
158		// See bytes_op_base::cont_.
159		mutable capy::continuation cont_;
160
161	30868x	bool await_ready() const noexcept
162		{
163		// A pre-set ec_ means the initiator failed before dispatch
164		// (e.g. auto-open); complete immediately with that error.
165	30868x	return static_cast<bool>(ec_);
166		}
167
168	16360x	[[nodiscard]] capy::results<> await_resume() const noexcept
169		{
170	16360x	return {ec_};
171		}
172
173	30828x	auto await_suspend(std::coroutine_handle<> h, capy::await_context const* env)
174		-> std::coroutine_handle<>
175		{
176	30828x	token_ = env->stop_token;
177		// A pre-stopped token short-circuits before dispatch; a stop
178		// landing after dispatch leaves the completed result intact.
179	30828x	if (token_.stop_requested())
180		{
181	1158x	ec_ = capy::error::canceled;
182	1158x	return h;
183		}
184	29670x	cont_.h = h;
185	29670x	cont_.owner = env->owner;
186	29670x	return static_cast<Derived const*>(this)->dispatch(
187	29670x	cont_, env->executor);
188		}
189		};
190
191		} // namespace boost::corosio::detail
192
193		#endif // BOOST_COROSIO_DETAIL_OP_BASE_HPP
194