iceoryx2
C++ Bindings
Loading...
Searching...
No Matches
port_factory_server.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_PORTFACTORY_SERVER_HPP
14#define IOX2_PORTFACTORY_SERVER_HPP
15
16#include "iox2/backpressure_handler.hpp"
17#include "iox2/backpressure_strategy.hpp"
18#include "iox2/bb/detail/builder.hpp"
19#include "iox2/bb/expected.hpp"
20#include "iox2/bb/optional.hpp"
21#include "iox2/degradation_handler.hpp"
22#include "iox2/internal/callback_context.hpp"
23#include "iox2/marker.hpp"
24#include "iox2/port_name.hpp"
25#include "iox2/server.hpp"
26#include "iox2/server_error.hpp"
27#include "iox2/service_type.hpp"
28
29namespace iox2 {
33template <ServiceType Service,
34 typename RequestPayload,
35 typename RequestUserHeader,
36 typename ResponsePayload,
37 typename ResponseUserHeader>
38class PortFactoryServer {
39 public:
43#ifdef DOXYGEN_MACRO_FIX
44 auto backpressure_strategy(const BackpressureStrategy value) -> decltype(auto);
45#else
46 IOX2_BUILDER_OPTIONAL(BackpressureStrategy, backpressure_strategy);
47#endif
48
51#ifdef DOXYGEN_MACRO_FIX
52 auto max_loaned_responses_per_request(const uint64_t value) -> decltype(auto);
53#else
54 IOX2_BUILDER_OPTIONAL(uint64_t, max_loaned_responses_per_request);
55#endif
56
60#ifdef DOXYGEN_MACRO_FIX
61 auto name(const PortName value) -> decltype(auto);
62#else
63 IOX2_BUILDER_OPTIONAL(PortName, name);
64#endif
65
66 public:
67 PortFactoryServer(const PortFactoryServer&) = delete;
68 PortFactoryServer(PortFactoryServer&&) = default;
69 auto operator=(const PortFactoryServer&) -> PortFactoryServer& = delete;
70 auto operator=(PortFactoryServer&&) -> PortFactoryServer& = default;
71 ~PortFactoryServer() = default;
72
85 auto override_response_preallocation(const OverridePreallocationCallback& callback) && -> PortFactoryServer&&;
86
88 template <typename T = ResponsePayload, typename = std::enable_if_t<bb::IsSlice<T>::VALUE, void>>
89 auto initial_max_slice_len(uint64_t value) && -> PortFactoryServer&&;
90
93 template <typename T = ResponsePayload, typename = std::enable_if_t<has_flatbuffer_marker<T>(), void>>
94 auto initial_reserved_memory(uint64_t value) && -> PortFactoryServer&&;
95
100 template <typename T = ResponsePayload,
101 typename = std::enable_if_t<bb::IsSlice<T>::VALUE || has_flatbuffer_marker<T>(), void>>
102 auto allocation_strategy(AllocationStrategy value) && -> PortFactoryServer&&;
103
110 auto set_request_degradation_handler(DegradationHandler* handler) && -> PortFactoryServer&&;
111
118 auto set_response_degradation_handler(DegradationHandler* handler) && -> PortFactoryServer&&;
119
128 auto set_backpressure_handler(BackpressureHandler* handler) && -> PortFactoryServer&&;
129
131 auto
132 create() && -> bb::Expected<Server<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>,
133 ServerCreateError>;
134
135 private:
136 template <ServiceType, typename, typename, typename, typename>
137 friend class PortFactoryRequestResponse;
138
139 explicit PortFactoryServer(iox2_port_factory_server_builder_h handle);
140
141 iox2_port_factory_server_builder_h m_handle = nullptr;
142 bb::Optional<uint64_t> m_max_slice_len;
143 bb::Optional<AllocationStrategy> m_allocation_strategy;
144 bb::Optional<OverridePreallocationCallback> m_override_preallocation_callback;
145 bb::Optional<DegradationHandler* const> m_request_degradation_handler;
146 bb::Optional<DegradationHandler* const> m_response_degradation_handler;
147 bb::Optional<BackpressureHandler* const> m_backpressure_handler;
148};
149
150template <ServiceType Service,
151 typename RequestPayload,
152 typename RequestUserHeader,
153 typename ResponsePayload,
154 typename ResponseUserHeader>
155template <typename T, typename>
156inline auto PortFactoryServer<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>::
157 initial_max_slice_len(uint64_t value) && -> PortFactoryServer&& {
158 m_max_slice_len.emplace(value);
159 return std::move(*this);
160}
161
162template <ServiceType Service,
163 typename RequestPayload,
164 typename RequestUserHeader,
165 typename ResponsePayload,
166 typename ResponseUserHeader>
167template <typename T, typename>
168inline auto PortFactoryServer<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>::
169 initial_reserved_memory(uint64_t value) && -> PortFactoryServer&& {
170 m_max_slice_len.emplace(value);
171 return std::move(*this);
172}
173
174template <ServiceType Service,
175 typename RequestPayload,
176 typename RequestUserHeader,
177 typename ResponsePayload,
178 typename ResponseUserHeader>
179inline auto PortFactoryServer<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>::
180 override_response_preallocation(const OverridePreallocationCallback& callback) && -> PortFactoryServer&& {
181 m_override_preallocation_callback.emplace(callback);
182 return std::move(*this);
183}
184
185template <ServiceType Service,
186 typename RequestPayload,
187 typename RequestUserHeader,
188 typename ResponsePayload,
189 typename ResponseUserHeader>
190template <typename T, typename>
191inline auto
197
198template <ServiceType Service,
199 typename RequestPayload,
200 typename RequestUserHeader,
201 typename ResponsePayload,
202 typename ResponseUserHeader>
203inline auto PortFactoryServer<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>::
204 set_request_degradation_handler(DegradationHandler* handler) && -> PortFactoryServer&& {
205 m_request_degradation_handler.emplace(handler);
206 return std::move(*this);
207}
208
209template <ServiceType Service,
210 typename RequestPayload,
211 typename RequestUserHeader,
212 typename ResponsePayload,
213 typename ResponseUserHeader>
214inline auto PortFactoryServer<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>::
215 set_response_degradation_handler(DegradationHandler* handler) && -> PortFactoryServer&& {
216 m_response_degradation_handler.emplace(handler);
217 return std::move(*this);
218}
219
220template <ServiceType Service,
221 typename RequestPayload,
222 typename RequestUserHeader,
223 typename ResponsePayload,
224 typename ResponseUserHeader>
225inline auto PortFactoryServer<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>::
226 set_backpressure_handler(BackpressureHandler* handler) && -> PortFactoryServer&& {
227 m_backpressure_handler.emplace(handler);
228 return std::move(*this);
229}
230
231template <ServiceType Service,
232 typename RequestPayload,
233 typename RequestUserHeader,
234 typename ResponsePayload,
235 typename ResponseUserHeader>
236inline auto PortFactoryServer<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>::
237 create() && -> bb::Expected<Server<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>,
238 ServerCreateError> {
239 if (m_backpressure_strategy.has_value()) {
240 iox2_port_factory_server_builder_backpressure_strategy(
241 &m_handle, static_cast<iox2_backpressure_strategy_e>(iox2::bb::into<int>(m_backpressure_strategy.value())));
242 }
243 if (m_max_slice_len.has_value()) {
244 iox2_port_factory_server_builder_set_initial_max_slice_len(&m_handle, m_max_slice_len.value());
245 } else {
246 iox2_port_factory_server_builder_set_initial_max_slice_len(&m_handle, 1);
247 }
248 if (m_max_loaned_responses_per_request.has_value()) {
249 iox2_port_factory_server_builder_set_max_loaned_responses_per_request(
250 &m_handle, m_max_loaned_responses_per_request.value());
251 }
252 if (m_allocation_strategy.has_value()) {
253 iox2_port_factory_server_builder_set_allocation_strategy(
254 &m_handle, bb::into<iox2_allocation_strategy_e>(m_allocation_strategy.value()));
255 }
256 if (m_override_preallocation_callback.has_value()) {
257 // NOLINTNEXTLINE(cppcoreguidelines-owning-memory) must be a raw pointer - crosses FFI boundary
258 auto* callback = new OverridePreallocationCallback(m_override_preallocation_callback.value());
259 // NOLINTNEXTLINE(cppcoreguidelines-owning-memory) must be a raw pointer - crosses FFI boundary
260 auto* ctx = new internal::CallbackContext<OverridePreallocationCallback>(*callback);
261 iox2_port_factory_server_builder_override_responses_preallocation(
262 &m_handle, internal::override_callback, static_cast<void*>(ctx));
263 }
264
265 if (m_request_degradation_handler.has_value()) {
266 iox2_port_factory_server_builder_set_request_degradation_handler(
267 &m_handle, detail::degradation_handler_delegate, static_cast<void*>(m_request_degradation_handler.value()));
268 }
269
270 if (m_response_degradation_handler.has_value()) {
271 iox2_port_factory_server_builder_set_response_degradation_handler(
272 &m_handle,
273 detail::degradation_handler_delegate,
274 static_cast<void*>(m_response_degradation_handler.value()));
275 }
276
277 if (m_backpressure_handler.has_value()) {
278 iox2_port_factory_server_builder_set_backpressure_handler(
279 &m_handle, detail::backpressure_handler_delegate, static_cast<void*>(m_backpressure_handler.value()));
280 }
281
282 if (m_name.has_value()) {
283 const auto* name_ptr = m_name.value().as_view().native_ptr();
284 iox2_port_factory_server_builder_set_name(&m_handle, name_ptr);
285 }
286
287 iox2_server_h server_handle {};
288 auto result = iox2_port_factory_server_builder_create(m_handle, nullptr, &server_handle);
289
290 if (result == IOX2_OK) {
291 return Server<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>(server_handle);
292 }
293
294 return bb::err(bb::into<ServerCreateError>(result));
295}
296
297template <ServiceType Service,
298 typename RequestPayload,
299 typename RequestUserHeader,
300 typename ResponsePayload,
301 typename ResponseUserHeader>
302inline PortFactoryServer<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>::
303 PortFactoryServer(iox2_port_factory_server_builder_h handle)
304 : m_handle { handle } {
305}
306} // namespace iox2
307#endif
backpressure_handler.hpp
backpressure_strategy.hpp
IOX2_BUILDER_OPTIONAL
#define IOX2_BUILDER_OPTIONAL(type, name)
Definition builder.hpp:47
callback_context.hpp
iox2::PortFactoryServer::PortFactoryServer
PortFactoryServer(const PortFactoryServer &)=delete
iox2::PortFactoryServer::initial_max_slice_len
auto initial_max_slice_len(uint64_t value) &&-> PortFactoryServer &&
Sets the maximum initial slice length configured for this [Server].
Definition port_factory_server.hpp:157
iox2::PortFactoryServer::set_response_degradation_handler
auto set_response_degradation_handler(DegradationHandler *handler) &&-> PortFactoryServer &&
Definition port_factory_server.hpp:215
iox2::PortFactoryServer::allocation_strategy
auto allocation_strategy(AllocationStrategy value) &&-> PortFactoryServer &&
Definition port_factory_server.hpp:192
iox2::PortFactoryServer::set_backpressure_handler
auto set_backpressure_handler(BackpressureHandler *handler) &&-> PortFactoryServer &&
Definition port_factory_server.hpp:226
iox2::PortFactoryServer::PortFactoryServer
PortFactoryServer(PortFactoryServer &&)=default
iox2::PortFactoryServer::initial_reserved_memory
auto initial_reserved_memory(uint64_t value) &&-> PortFactoryServer &&
Definition port_factory_server.hpp:169
iox2::PortFactoryServer::operator=
auto operator=(PortFactoryServer &&) -> PortFactoryServer &=default
iox2::PortFactoryServer::operator=
auto operator=(const PortFactoryServer &) -> PortFactoryServer &=delete
iox2::PortFactoryServer::override_response_preallocation
auto override_response_preallocation(const OverridePreallocationCallback &callback) &&-> PortFactoryServer &&
Definition port_factory_server.hpp:180
iox2::PortFactoryServer::backpressure_strategy
auto backpressure_strategy(const BackpressureStrategy value) -> decltype(auto)
iox2::PortFactoryServer::create
auto create() &&-> bb::Expected< Server< Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader >, ServerCreateError >
Creates a new [Server] or returns a [ServerCreateError] on failure.
Definition port_factory_server.hpp:237
iox2::PortFactoryServer::name
auto name(const PortName value) -> decltype(auto)
iox2::PortFactoryServer::set_request_degradation_handler
auto set_request_degradation_handler(DegradationHandler *handler) &&-> PortFactoryServer &&
Definition port_factory_server.hpp:204
iox2::PortFactoryServer::max_loaned_responses_per_request
auto max_loaned_responses_per_request(const uint64_t value) -> decltype(auto)
iox2::PortName
Represent the name for a [Port].
Definition port_name.hpp:52
degradation_handler.hpp
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::detail::backpressure_handler_delegate
auto backpressure_handler_delegate(iox2_backpressure_info_h_ref info_handle, iox2_callback_context callback_cxt) -> iox2_backpressure_action_e
Definition backpressure_handler.hpp:86
iox2::detail::degradation_handler_delegate
auto degradation_handler_delegate(iox2_degradation_cause_e degradation_cause, iox2_degradation_info_h_ref info_handle, iox2_callback_context callback_cxt) -> iox2_degradation_action_e
Definition degradation_handler.hpp:78
iox2::internal::override_callback
auto override_callback(size_t value, iox2_callback_context ctx) -> size_t
Definition callback_context.hpp:71
iox2::ServerCreateError
ServerCreateError
Definition server_error.hpp:21
iox2::OverridePreallocationCallback
iox2::bb::StaticFunction< size_t(size_t)> OverridePreallocationCallback
Definition callback_context.hpp:26
port_name.hpp
server_error.hpp
service_type.hpp