iceoryx2
C++ Language 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/header_request_response.hpp"
20#include "iox2/payload_info.hpp"
21#include "iox2/response.hpp"
22#include "iox2/service_type.hpp"
23
24namespace iox2 {
25template <ServiceType, typename, typename, typename, typename>
26class RequestMut;
27
34template <ServiceType Service,
35 typename RequestPayload,
36 typename RequestUserHeader,
37 typename ResponsePayload,
38 typename ResponseUserHeader>
39class PendingResponse {
40 using ValueType = typename PayloadInfo<RequestPayload>::ValueType;
41
42 public:
43 PendingResponse(PendingResponse&& rhs) noexcept;
44 auto operator=(PendingResponse&& rhs) noexcept -> PendingResponse&;
45 ~PendingResponse() noexcept;
46
47 PendingResponse(const PendingResponse&) = delete;
48 auto operator=(const PendingResponse&) -> PendingResponse& = delete;
49
52 auto receive() -> bb::Expected<bb::Optional<Response<Service, ResponsePayload, ResponseUserHeader>>, ReceiveError>;
53
56 auto header() -> RequestHeader;
57
60 template <typename T = RequestUserHeader,
61 typename = std::enable_if_t<!std::is_same<void, RequestUserHeader>::value, T>>
62 auto user_header() -> const T&;
63
66 template <typename T = RequestPayload, typename = std::enable_if_t<!bb::IsSlice<T>::VALUE, void>>
67 auto payload() const -> const T&;
68
71 template <typename T = RequestPayload, typename = std::enable_if_t<bb::IsSlice<T>::VALUE, void>>
72 auto payload() const -> bb::ImmutableSlice<ValueType>;
73
76 auto number_of_server_connections() const -> size_t;
77
80 auto has_response() -> bool;
81
85 auto is_connected() const -> bool;
86
92 void set_disconnect_hint();
93
94 private:
95 template <ServiceType, typename, typename, typename, typename>
96 friend class Client;
97 template <ServiceType S,
98 typename RequestPayloadT,
99 typename RequestUserHeaderT,
100 typename ResponsePayloadT,
101 typename ResponseUserHeaderT>
102 friend auto
103 send(RequestMut<S, RequestPayloadT, RequestUserHeaderT, ResponsePayloadT, ResponseUserHeaderT>&& request)
104 -> bb::Expected<PendingResponse<S, RequestPayloadT, RequestUserHeaderT, ResponsePayloadT, ResponseUserHeaderT>,
105 RequestSendError>;
106
107 explicit PendingResponse(iox2_pending_response_h handle) noexcept;
108
109 void drop();
110
111 iox2_pending_response_h m_handle = nullptr;
112};
113
114template <ServiceType Service,
115 typename RequestPayload,
116 typename RequestUserHeader,
117 typename ResponsePayload,
118 typename ResponseUserHeader>
119inline PendingResponse<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>::
120 PendingResponse(PendingResponse&& rhs) noexcept {
121 *this = std::move(rhs);
122}
123
124template <ServiceType Service,
125 typename RequestPayload,
126 typename RequestUserHeader,
127 typename ResponsePayload,
128 typename ResponseUserHeader>
129inline auto PendingResponse<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>::operator=(
130 PendingResponse&& rhs) noexcept -> PendingResponse& {
131 if (this != &rhs) {
132 drop();
133 m_handle = rhs.m_handle;
134 rhs.m_handle = nullptr;
135 }
136
137 return *this;
138}
139
140template <ServiceType Service,
141 typename RequestPayload,
142 typename RequestUserHeader,
143 typename ResponsePayload,
144 typename ResponseUserHeader>
149
150template <ServiceType Service,
151 typename RequestPayload,
152 typename RequestUserHeader,
153 typename ResponsePayload,
154 typename ResponseUserHeader>
155inline auto PendingResponse<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>::receive()
156 -> bb::Expected<bb::Optional<Response<Service, ResponsePayload, ResponseUserHeader>>, ReceiveError> {
157 iox2_response_h response_handle {};
158 auto result = iox2_pending_response_receive(&m_handle, nullptr, &response_handle);
159
160 if (result == IOX2_OK) {
161 if (response_handle != nullptr) {
162 Response<Service, ResponsePayload, ResponseUserHeader> response(response_handle);
163 return bb::Optional<Response<Service, ResponsePayload, ResponseUserHeader>>(std::move(response));
164 }
165 return bb::Optional<Response<Service, ResponsePayload, ResponseUserHeader>>(bb::NULLOPT);
166 }
167 return bb::err(bb::into<ReceiveError>(result));
168}
169
170template <ServiceType Service,
171 typename RequestPayload,
172 typename RequestUserHeader,
173 typename ResponsePayload,
174 typename ResponseUserHeader>
175inline auto PendingResponse<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>::header()
176 -> RequestHeader {
177 iox2_request_header_h header_handle = nullptr;
178 iox2_pending_response_header(&m_handle, nullptr, &header_handle);
179 return RequestHeader { header_handle };
180}
181
182template <ServiceType Service,
183 typename RequestPayload,
184 typename RequestUserHeader,
185 typename ResponsePayload,
186 typename ResponseUserHeader>
187template <typename T, typename>
188inline auto
189PendingResponse<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>::user_header()
190 -> const T& {
191 const void* ptr = nullptr;
192 iox2_pending_response_user_header(&m_handle, &ptr);
193 return *static_cast<const T*>(ptr);
194}
195
196template <ServiceType Service,
197 typename RequestPayload,
198 typename RequestUserHeader,
199 typename ResponsePayload,
200 typename ResponseUserHeader>
201template <typename T, typename>
202inline auto
203PendingResponse<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>::payload() const
204 -> const T& {
205 const void* ptr = nullptr;
206 iox2_pending_response_payload(&m_handle, &ptr, nullptr);
207 return *static_cast<const T*>(ptr);
208}
209
210template <ServiceType Service,
211 typename RequestPayload,
212 typename RequestUserHeader,
213 typename ResponsePayload,
214 typename ResponseUserHeader>
215template <typename T, typename>
216inline auto
217PendingResponse<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>::payload() const
218 -> bb::ImmutableSlice<ValueType> {
219 const void* ptr = nullptr;
220 size_t number_of_elements = 0;
221
222 iox2_pending_response_payload(&m_handle, &ptr, &number_of_elements);
223
224 return bb::ImmutableSlice<ValueType>(static_cast<const ValueType*>(ptr), number_of_elements);
225}
226
227template <ServiceType Service,
228 typename RequestPayload,
229 typename RequestUserHeader,
230 typename ResponsePayload,
231 typename ResponseUserHeader>
232inline auto PendingResponse<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>::
233 number_of_server_connections() const -> size_t {
234 return iox2_pending_response_number_of_server_connections(&m_handle);
235}
236
237template <ServiceType Service,
238 typename RequestPayload,
239 typename RequestUserHeader,
240 typename ResponsePayload,
241 typename ResponseUserHeader>
242inline auto
243PendingResponse<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>::has_response()
244 -> bool {
245 return iox2_pending_response_has_response(&m_handle);
246}
247
248template <ServiceType Service,
249 typename RequestPayload,
250 typename RequestUserHeader,
251 typename ResponsePayload,
252 typename ResponseUserHeader>
253inline auto
254PendingResponse<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>::is_connected() const
255 -> bool {
256 return iox2_pending_response_is_connected(&m_handle);
257}
258
259template <ServiceType Service,
260 typename RequestPayload,
261 typename RequestUserHeader,
262 typename ResponsePayload,
263 typename ResponseUserHeader>
264inline void PendingResponse<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>::
265 set_disconnect_hint() {
266 iox2_pending_response_set_disconnect_hint(&m_handle);
267}
268
269template <ServiceType Service,
270 typename RequestPayload,
271 typename RequestUserHeader,
272 typename ResponsePayload,
273 typename ResponseUserHeader>
274inline PendingResponse<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>::
275 PendingResponse(iox2_pending_response_h handle) noexcept
276 : m_handle { handle } {
277}
278
279template <ServiceType Service,
280 typename RequestPayload,
281 typename RequestUserHeader,
282 typename ResponsePayload,
283 typename ResponseUserHeader>
284inline void PendingResponse<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>::drop() {
285 if (m_handle != nullptr) {
286 iox2_pending_response_drop(m_handle);
287 m_handle = nullptr;
288 }
289}
290} // namespace iox2
291#endif
iox2::Client
Sends [RequestMut]s to a [Server] in a request-response based communication.
Definition client.hpp:31
iox2::PendingResponse::operator=
auto operator=(PendingResponse &&rhs) noexcept -> PendingResponse &
Definition pending_response.hpp:129
iox2::PendingResponse::number_of_server_connections
auto number_of_server_connections() const -> size_t
Definition pending_response.hpp:233
iox2::PendingResponse::user_header
auto user_header() -> const T &
Definition pending_response.hpp:189
iox2::PendingResponse::payload
auto payload() const -> const T &
Definition pending_response.hpp:203
iox2::PendingResponse::PendingResponse
PendingResponse(const PendingResponse &)=delete
iox2::PendingResponse::PendingResponse
PendingResponse(PendingResponse &&rhs) noexcept
Definition pending_response.hpp:120
iox2::PendingResponse::send
friend auto send(RequestMut< S, RequestPayloadT, RequestUserHeaderT, ResponsePayloadT, ResponseUserHeaderT > &&request) -> bb::Expected< PendingResponse< S, RequestPayloadT, RequestUserHeaderT, ResponsePayloadT, ResponseUserHeaderT >, RequestSendError >
iox2::PendingResponse::header
auto header() -> RequestHeader
Definition pending_response.hpp:175
iox2::PendingResponse::is_connected
auto is_connected() const -> bool
Definition pending_response.hpp:254
iox2::PendingResponse::receive
auto receive() -> bb::Expected< bb::Optional< Response< Service, ResponsePayload, ResponseUserHeader > >, ReceiveError >
Definition pending_response.hpp:155
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::RequestSendError
RequestSendError
Failure that can be emitted when a [RequestMut] is sent.
Definition port_error.hpp:80
payload_info.hpp
service_type.hpp