TLA Line data 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 HIT 10 : impl_type& get_impl() noexcept
76 : {
77 10 : 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 8 : native_read_at_awaitable(
89 : native_random_access_file& self,
90 : std::uint64_t offset,
91 : MutableBufferSequence buffers) noexcept
92 8 : : self_(self)
93 8 : , offset_(offset)
94 8 : , buffers_(std::move(buffers))
95 : {
96 8 : }
97 :
98 : std::coroutine_handle<>
99 6 : dispatch(std::coroutine_handle<> h, capy::executor_ref ex) const
100 : {
101 12 : return self_.get_impl().read_some_at(
102 6 : offset_, h, ex, buffers_, this->token_, &this->ec_,
103 12 : &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 6 : native_write_at_awaitable(
116 : native_random_access_file& self,
117 : std::uint64_t offset,
118 : ConstBufferSequence buffers) noexcept
119 6 : : self_(self)
120 6 : , offset_(offset)
121 6 : , buffers_(std::move(buffers))
122 : {
123 6 : }
124 :
125 : std::coroutine_handle<>
126 4 : dispatch(std::coroutine_handle<> h, capy::executor_ref ex) const
127 : {
128 8 : return self_.get_impl().write_some_at(
129 4 : offset_, h, ex, buffers_, this->token_, &this->ec_,
130 8 : &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 16 : explicit native_random_access_file(capy::execution_context& ctx)
140 16 : : random_access_file(create_handle<service_type>(ctx))
141 : {
142 16 : }
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 8 : [[nodiscard]] auto read_some_at(std::uint64_t offset, MB const& buffers)
176 : {
177 8 : 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 6 : [[nodiscard]] auto write_some_at(std::uint64_t offset, CB const& buffers)
187 : {
188 6 : 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
|
