include/boost/corosio/native/native_random_access_file.hpp

100.0% Lines (27 / 27) 100.0% Functions (14 / 14)

[ ] prev/next file

native_random_access_file.hpp

f(x) Functions (14)

Function Calls Lines Blocks

Line	Hits	Source Code
1		//
2		// Copyright (c) 2026 Steve Gerbino
3		// Copyright (c) 2026 Michael Vandeberg
4		//
5		// Distributed under the Boost Software License, Version 1.0. (See accompanying
6		// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
7		//
8		// Official repository: https://github.com/cppalliance/corosio
9		//
10
11		#ifndef BOOST_COROSIO_NATIVE_NATIVE_RANDOM_ACCESS_FILE_HPP
12		#define BOOST_COROSIO_NATIVE_NATIVE_RANDOM_ACCESS_FILE_HPP
13
14		#include <boost/corosio/random_access_file.hpp>
15		#include <boost/corosio/backend.hpp>
16		#include <boost/corosio/detail/op_base.hpp>
17
18		#ifndef BOOST_COROSIO_MRDOCS
19		#if BOOST_COROSIO_HAS_EPOLL \|\| BOOST_COROSIO_HAS_SELECT \|\| \
20		BOOST_COROSIO_HAS_KQUEUE
21		#include <boost/corosio/native/detail/posix/posix_random_access_file_service.hpp>
22		#endif
23
24		#if BOOST_COROSIO_HAS_URING
25		#include <boost/corosio/native/detail/uring/uring_random_access_file.hpp>
26		#endif
27
28		#if BOOST_COROSIO_HAS_IOCP
29		#include <boost/corosio/native/detail/iocp/win_random_access_file_service.hpp>
30		#endif
31		#endif // !BOOST_COROSIO_MRDOCS
32
33		namespace boost::corosio {
34
35		/** A random-access file with devirtualized async I/O operations.
36
37		This class template inherits from @ref random_access_file and
38		shadows `read_some_at` / `write_some_at` with versions that
39		call the backend implementation directly, allowing the compiler
40		to inline through the entire call chain.
41
42		Non-async operations (`open`, `close`, `size`, `resize`,
43		`sync_data`, `sync_all`) remain unchanged and dispatch through
44		the compiled library.
45
46		A `native_random_access_file` IS-A `random_access_file` and
47		can be passed to any function expecting `random_access_file&`,
48		in which case virtual dispatch is used transparently.
49
50		@note On POSIX platforms, file I/O is dispatched to a thread
51		pool regardless of the chosen reactor backend, so all three
52		reactor tags (`epoll`, `select`, `kqueue`) resolve to the same
53		underlying implementation. The `Backend` template parameter
54		exists for API symmetry with @ref native_tcp_socket and friends.
55		The vtable savings are smaller relative to the thread-pool /
56		overlapped-I/O cost than they are for socket operations.
57
58		@tparam Backend A backend tag value (e.g., `epoll`, `iocp`).
59
60		@par Thread Safety
61		Same as @ref random_access_file.
62
63		@par Example
64		@par !example native_random_access_file
65
66		@see random_access_file, epoll_t, iocp_t
67		*/
68		template<auto Backend>
69		class native_random_access_file : public random_access_file
70		{
71		using backend_type = decltype(Backend);
72		using impl_type = typename backend_type::random_access_file_type;
73		using service_type = typename backend_type::random_access_file_service_type;
74
75	10x	impl_type& get_impl() noexcept
76		{
77	10x	return static_cast<impl_type>(h_.get());
78		}
79
80		template<class MutableBufferSequence>
81		struct native_read_at_awaitable
82		: detail::bytes_op_base<native_read_at_awaitable<MutableBufferSequence>>
83		{
84		native_random_access_file& self_;
85		std::uint64_t offset_;
86		MutableBufferSequence buffers_;
87
88	8x	native_read_at_awaitable(
89		native_random_access_file& self,
90		std::uint64_t offset,
91		MutableBufferSequence buffers) noexcept
92	8x	: self_(self)
93	8x	, offset_(offset)
94	8x	, buffers_(std::move(buffers))
95		{
96	8x	}
97
98		std::coroutine_handle<>
99	6x	dispatch(std::coroutine_handle<> h, capy::executor_ref ex) const
100		{
101	12x	return self_.get_impl().read_some_at(
102	6x	offset_, h, ex, buffers_, this->token_, &this->ec_,
103	12x	&this->bytes_);
104		}
105		};
106
107		template<class ConstBufferSequence>
108		struct native_write_at_awaitable
109		: detail::bytes_op_base<native_write_at_awaitable<ConstBufferSequence>>
110		{
111		native_random_access_file& self_;
112		std::uint64_t offset_;
113		ConstBufferSequence buffers_;
114
115	6x	native_write_at_awaitable(
116		native_random_access_file& self,
117		std::uint64_t offset,
118		ConstBufferSequence buffers) noexcept
119	6x	: self_(self)
120	6x	, offset_(offset)
121	6x	, buffers_(std::move(buffers))
122		{
123	6x	}
124
125		std::coroutine_handle<>
126	4x	dispatch(std::coroutine_handle<> h, capy::executor_ref ex) const
127		{
128	8x	return self_.get_impl().write_some_at(
129	4x	offset_, h, ex, buffers_, this->token_, &this->ec_,
130	8x	&this->bytes_);
131		}
132		};
133
134		public:
135		/** Construct a native random-access file from an execution context.
136
137		@param ctx The execution context that will own this file.
138		*/
139	16x	explicit native_random_access_file(capy::execution_context& ctx)
140	16x	: random_access_file(create_handle<service_type>(ctx))
141		{
142	16x	}
143
144		/** Construct a native random-access file from an executor.
145
146		@param ex The executor whose context will own this file.
147		*/
148		template<class Ex>
149		requires(!std::same_as<
150		std::remove_cvref_t<Ex>,
151		native_random_access_file>) &&
152		capy::Executor<Ex>
153		explicit native_random_access_file(Ex const& ex)
154		: native_random_access_file(ex.context())
155		{
156		}
157
158		/// Move construct.
159		native_random_access_file(native_random_access_file&&) noexcept = default;
160
161		/// Move assign.
162		native_random_access_file&
163		operator=(native_random_access_file&&) noexcept = default;
164
165		native_random_access_file(native_random_access_file const&) = delete;
166		native_random_access_file&
167		operator=(native_random_access_file const&) = delete;
168
169		/** Asynchronously read at the given offset.
170
171		Calls the backend implementation directly, bypassing virtual
172		dispatch. Otherwise identical to @ref random_access_file::read_some_at.
173		*/
174		template<capy::MutableBufferSequence MB>
175	8x	[[nodiscard]] auto read_some_at(std::uint64_t offset, MB const& buffers)
176		{
177	8x	return native_read_at_awaitable<MB>(*this, offset, buffers);
178		}
179
180		/** Asynchronously write at the given offset.
181
182		Calls the backend implementation directly, bypassing virtual
183		dispatch. Otherwise identical to @ref random_access_file::write_some_at.
184		*/
185		template<capy::ConstBufferSequence CB>
186	6x	[[nodiscard]] auto write_some_at(std::uint64_t offset, CB const& buffers)
187		{
188	6x	return native_write_at_awaitable<CB>(*this, offset, buffers);
189		}
190		};
191
192		} // namespace boost::corosio
193
194		#endif // BOOST_COROSIO_NATIVE_NATIVE_RANDOM_ACCESS_FILE_HPP
195