iceoryx2
C++ Bindings
Loading...
Searching...
No Matches
pending_response.hpp
Go to the documentation of this file.
1// Copyright (c) 2025 Contributors to the Eclipse Foundation
2//
3// See the NOTICE file(s) distributed with this work for additional
4// information regarding copyright ownership.
5//
6// This program and the accompanying materials are made available under the
7// terms of the Apache Software License 2.0 which is available at
8// https://www.apache.org/licenses/LICENSE-2.0, or the MIT license
9// which is available at https://opensource.org/licenses/MIT.
10//
11// SPDX-License-Identifier: Apache-2.0 OR MIT
12
13#ifndef IOX2_PENDING_RESPONSE_HPP
14#define IOX2_PENDING_RESPONSE_HPP
15
16#include "iox2/bb/expected.hpp"
17#include "iox2/bb/optional.hpp"
18#include "iox2/bb/slice.hpp"
19#include "iox2/deployment/iceoryx2_cxx_feature_flags.hpp"
20#include "iox2/header_request_response.hpp"
21#include "iox2/marker.hpp"
22#include "iox2/payload_info.hpp"
23#include "iox2/response.hpp"
24#include "iox2/service_type.hpp"
25
26namespace iox2 {
27template <ServiceType, typename, typename, typename, typename>
28class RequestMut;
29
36template <ServiceType Service,
37 typename RequestPayload,
38 typename RequestUserHeader,
39 typename ResponsePayload,
40 typename ResponseUserHeader>
41class PendingResponse {
42 using ValueType = typename PayloadInfo<RequestPayload>::ValueType;
43
44 public:
45 PendingResponse(PendingResponse&& rhs) noexcept;
46 auto operator=(PendingResponse&& rhs) noexcept -> PendingResponse&;
47 ~PendingResponse() noexcept;
48
49 PendingResponse(const PendingResponse&) = delete;
50 auto operator=(const PendingResponse&) -> PendingResponse& = delete;
51
54 auto receive() -> bb::Expected<bb::Optional<Response<Service, ResponsePayload, ResponseUserHeader>>, ReceiveError>;
55
58 auto header() const -> RequestHeader;
59
62 template <typename T = RequestUserHeader,
63 typename = std::enable_if_t<!std::is_same<void, RequestUserHeader>::value, T>>
64 auto user_header() const -> const T&;
65
68 template <typename T = RequestPayload,
69 typename = std::enable_if_t<!bb::IsSlice<T>::VALUE && !has_flatbuffer_marker<T>(), void>>
70 auto payload() const -> const T&;
71
74 template <typename T = RequestPayload, typename = std::enable_if_t<bb::IsSlice<T>::VALUE, void>>
75 auto payload() const -> bb::ImmutableSlice<ValueType>;
76
77#if IOX2_FEATURE_FLATBUFFERS
79 template <typename T = RequestPayload, typename = std::enable_if_t<has_flatbuffer_marker<T>(), void>>
80 auto payload_bytes() const -> bb::ImmutableSlice<uint8_t>;
81
83 template <typename T = RequestPayload, typename = std::enable_if_t<has_flatbuffer_marker<T>(), void>>
84 auto payload_root() const -> const typename T::ValueType*;
85#endif // IOX2_FEATURE_FLATBUFFERS
86
87
90 auto number_of_server_connections() const -> size_t;
91
94 auto has_response() -> bool;
95
99 auto is_connected() const -> bool;
100
106 void set_disconnect_hint();
107
108 private:
109 template <ServiceType, typename, typename, typename, typename>
110 friend class Client;
111 template <ServiceType S,
112 typename RequestPayloadT,
113 typename RequestUserHeaderT,
114 typename ResponsePayloadT,
115 typename ResponseUserHeaderT>
116 friend auto
117 send(RequestMut<S, RequestPayloadT, RequestUserHeaderT, ResponsePayloadT, ResponseUserHeaderT>&& request)
118 -> bb::Expected<PendingResponse<S, RequestPayloadT, RequestUserHeaderT, ResponsePayloadT, ResponseUserHeaderT>,
119 RequestSendError>;
120
121 explicit PendingResponse(iox2_pending_response_h handle) noexcept;
122
123 void drop();
124
125 iox2_pending_response_h m_handle = nullptr;
126};
127
128template <ServiceType Service,
129 typename RequestPayload,
130 typename RequestUserHeader,
131 typename ResponsePayload,
132 typename ResponseUserHeader>
133inline PendingResponse<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>::
134 PendingResponse(PendingResponse&& rhs) noexcept {
135 *this = std::move(rhs);
136}
137
138template <ServiceType Service,
139 typename RequestPayload,
140 typename RequestUserHeader,
141 typename ResponsePayload,
142 typename ResponseUserHeader>
143inline auto PendingResponse<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>::operator=(
144 PendingResponse&& rhs) noexcept -> PendingResponse& {
145 if (this != &rhs) {
146 drop();
147 m_handle = rhs.m_handle;
148 rhs.m_handle = nullptr;
149 }
150
151 return *this;
152}
153
154template <ServiceType Service,
155 typename RequestPayload,
156 typename RequestUserHeader,
157 typename ResponsePayload,
158 typename ResponseUserHeader>
163
164template <ServiceType Service,
165 typename RequestPayload,
166 typename RequestUserHeader,
167 typename ResponsePayload,
168 typename ResponseUserHeader>
169inline auto PendingResponse<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>::receive()
170 -> bb::Expected<bb::Optional<Response<Service, ResponsePayload, ResponseUserHeader>>, ReceiveError> {
171 iox2_response_h response_handle {};
172 auto result = iox2_pending_response_receive(&m_handle, nullptr, &response_handle);
173
174 if (result == IOX2_OK) {
175 if (response_handle != nullptr) {
176 Response<Service, ResponsePayload, ResponseUserHeader> response(response_handle);
177 return bb::Optional<Response<Service, ResponsePayload, ResponseUserHeader>>(std::move(response));
178 }
179 return bb::Optional<Response<Service, ResponsePayload, ResponseUserHeader>>(bb::NULLOPT);
180 }
181 return bb::err(bb::into<ReceiveError>(result));
182}
183
184template <ServiceType Service,
185 typename RequestPayload,
186 typename RequestUserHeader,
187 typename ResponsePayload,
188 typename ResponseUserHeader>
189inline auto
190PendingResponse<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>::header() const
191 -> RequestHeader {
192 iox2_request_header_h header_handle = nullptr;
193 iox2_pending_response_header(&m_handle, nullptr, &header_handle);
194 return RequestHeader { header_handle };
195}
196
197template <ServiceType Service,
198 typename RequestPayload,
199 typename RequestUserHeader,
200 typename ResponsePayload,
201 typename ResponseUserHeader>
202template <typename T, typename>
203inline auto
204PendingResponse<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>::user_header() const
205 -> const T& {
206 const void* ptr = nullptr;
207 iox2_pending_response_user_header(&m_handle, &ptr);
208 return *static_cast<const T*>(ptr);
209}
210
211template <ServiceType Service,
212 typename RequestPayload,
213 typename RequestUserHeader,
214 typename ResponsePayload,
215 typename ResponseUserHeader>
216template <typename T, typename>
217inline auto
218PendingResponse<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>::payload() const
219 -> const T& {
220 const void* ptr = nullptr;
221 iox2_pending_response_payload(&m_handle, &ptr, nullptr);
222 return *static_cast<const T*>(ptr);
223}
224
225template <ServiceType Service,
226 typename RequestPayload,
227 typename RequestUserHeader,
228 typename ResponsePayload,
229 typename ResponseUserHeader>
230template <typename T, typename>
231inline auto
232PendingResponse<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>::payload() const
233 -> bb::ImmutableSlice<ValueType> {
234 const void* ptr = nullptr;
235 size_t number_of_elements = 0;
236
237 iox2_pending_response_payload(&m_handle, &ptr, &number_of_elements);
238
239 return bb::ImmutableSlice<ValueType>(static_cast<const ValueType*>(ptr), number_of_elements);
240}
241
242#if IOX2_FEATURE_FLATBUFFERS
243template <ServiceType Service,
244 typename RequestPayload,
245 typename RequestUserHeader,
246 typename ResponsePayload,
247 typename ResponseUserHeader>
248template <typename T, typename>
249inline auto
250PendingResponse<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>::payload_bytes() const
251 -> bb::ImmutableSlice<uint8_t> {
252 const void* ptr = nullptr;
253 size_t number_of_elements = 0;
254
255 iox2_pending_response_payload(&m_handle, &ptr, &number_of_elements);
256 auto payload_offset = header().payload_offset();
257 auto payload_len = header().number_of_elements();
258
259 return bb::ImmutableSlice<uint8_t>(static_cast<const uint8_t*>(ptr) + payload_offset, payload_len - payload_offset);
260}
261
262template <ServiceType Service,
263 typename RequestPayload,
264 typename RequestUserHeader,
265 typename ResponsePayload,
266 typename ResponseUserHeader>
267template <typename T, typename>
268inline auto
269PendingResponse<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>::payload_root() const
270 -> const typename T::ValueType* {
271 return flatbuffers::GetRoot<typename T::ValueType>(payload_bytes().data());
272}
273#endif // IOX2_FEATURE_FLATBUFFERS
274
275template <ServiceType Service,
276 typename RequestPayload,
277 typename RequestUserHeader,
278 typename ResponsePayload,
279 typename ResponseUserHeader>
280inline auto PendingResponse<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>::
281 number_of_server_connections() const -> size_t {
282 return iox2_pending_response_number_of_server_connections(&m_handle);
283}
284
285template <ServiceType Service,
286 typename RequestPayload,
287 typename RequestUserHeader,
288 typename ResponsePayload,
289 typename ResponseUserHeader>
290inline auto
291PendingResponse<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>::has_response()
292 -> bool {
293 return iox2_pending_response_has_response(&m_handle);
294}
295
296template <ServiceType Service,
297 typename RequestPayload,
298 typename RequestUserHeader,
299 typename ResponsePayload,
300 typename ResponseUserHeader>
301inline auto
302PendingResponse<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>::is_connected() const
303 -> bool {
304 return iox2_pending_response_is_connected(&m_handle);
305}
306
307template <ServiceType Service,
308 typename RequestPayload,
309 typename RequestUserHeader,
310 typename ResponsePayload,
311 typename ResponseUserHeader>
312inline void PendingResponse<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>::
313 set_disconnect_hint() {
314 iox2_pending_response_set_disconnect_hint(&m_handle);
315}
316
317template <ServiceType Service,
318 typename RequestPayload,
319 typename RequestUserHeader,
320 typename ResponsePayload,
321 typename ResponseUserHeader>
322inline PendingResponse<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>::
323 PendingResponse(iox2_pending_response_h handle) noexcept
324 : m_handle { handle } {
325}
326
327template <ServiceType Service,
328 typename RequestPayload,
329 typename RequestUserHeader,
330 typename ResponsePayload,
331 typename ResponseUserHeader>
332inline void PendingResponse<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>::drop() {
333 if (m_handle != nullptr) {
334 iox2_pending_response_drop(m_handle);
335 m_handle = nullptr;
336 }
337}
338} // namespace iox2
339#endif
iox2::Client
Sends [RequestMut]s to a [Server] in a request-response based communication.
Definition client.hpp:33
iox2::PendingResponse::operator=
auto operator=(PendingResponse &&rhs) noexcept -> PendingResponse &
Definition pending_response.hpp:143
iox2::PendingResponse::header
auto header() const -> RequestHeader
Definition pending_response.hpp:190
iox2::PendingResponse::payload_root
auto payload_root() const -> const typename T::ValueType *
Returns the root of the flatbuffer.
Definition pending_response.hpp:269
iox2::PendingResponse::number_of_server_connections
auto number_of_server_connections() const -> size_t
Definition pending_response.hpp:281
iox2::PendingResponse::payload
auto payload() const -> const T &
Definition pending_response.hpp:218
iox2::PendingResponse::PendingResponse
PendingResponse(const PendingResponse &)=delete
iox2::PendingResponse::user_header
auto user_header() const -> const T &
Definition pending_response.hpp:204
iox2::PendingResponse::PendingResponse
PendingResponse(PendingResponse &&rhs) noexcept
Definition pending_response.hpp:134
iox2::PendingResponse::send
friend auto send(RequestMut< S, RequestPayloadT, RequestUserHeaderT, ResponsePayloadT, ResponseUserHeaderT > &&request) -> bb::Expected< PendingResponse< S, RequestPayloadT, RequestUserHeaderT, ResponsePayloadT, ResponseUserHeaderT >, RequestSendError >
iox2::PendingResponse::payload_bytes
auto payload_bytes() const -> bb::ImmutableSlice< uint8_t >
Returns the serialized flatbuffer data as bytes.
Definition pending_response.hpp:250
iox2::PendingResponse::is_connected
auto is_connected() const -> bool
Definition pending_response.hpp:302
iox2::PendingResponse::receive
auto receive() -> bb::Expected< bb::Optional< Response< Service, ResponsePayload, ResponseUserHeader > >, ReceiveError >
Definition pending_response.hpp:169
iox2::PendingResponse::operator=
auto operator=(const PendingResponse &) -> PendingResponse &=delete
iox2::RequestHeader
Request header used by [MessagingPattern::RequestResponse].
Definition header_request_response.hpp:20
iox2::bb::Slice
A class representing a slice of contiguous elements of type T.
Definition slice.hpp:31
header_request_response.hpp
iox2::bb::NULLOPT
constexpr NulloptT NULLOPT
Definition optional.hpp:28
iox2::bb::err
constexpr auto err(const E &error) -> Unexpected< E >
Definition expected.hpp:33
iox2::bb::Optional
iox2::bb::variation::Optional< T > Optional
Definition optional.hpp:25
iox2::bb::Expected
iox2::bb::variation::Expected< T, E > Expected
Definition expected.hpp:22
iox2::has_flatbuffer_marker
constexpr auto has_flatbuffer_marker() -> bool
Definition marker.hpp:53
iox2::RequestSendError
RequestSendError
Failure that can be emitted when a [RequestMut] is sent.
Definition port_error.hpp:80
payload_info.hpp
service_type.hpp