port_factory_server.hpp

Go to the documentation of this file.

// Copyright (c) 2025 Contributors to the Eclipse Foundation
//
// See the NOTICE file(s) distributed with this work for additional
// information regarding copyright ownership.
//
// This program and the accompanying materials are made available under the
// terms of the Apache Software License 2.0 which is available at
// https://www.apache.org/licenses/LICENSE-2.0, or the MIT license
// which is available at https://opensource.org/licenses/MIT.
//
// SPDX-License-Identifier: Apache-2.0 OR MIT
 
#ifndef IOX2_PORTFACTORY_SERVER_HPP
#define IOX2_PORTFACTORY_SERVER_HPP
 
#include "iox2/backpressure_handler.hpp"
#include "iox2/backpressure_strategy.hpp"
#include "iox2/bb/detail/builder.hpp"
#include "iox2/bb/expected.hpp"
#include "iox2/bb/optional.hpp"
#include "iox2/degradation_handler.hpp"
#include "iox2/internal/callback_context.hpp"
#include "iox2/server.hpp"
#include "iox2/server_error.hpp"
#include "iox2/service_type.hpp"
 
namespace iox2 {
template <ServiceType Service,
          typename RequestPayload,
          typename RequestUserHeader,
          typename ResponsePayload,
          typename ResponseUserHeader>
class PortFactoryServer {
  public:
#ifdef DOXYGEN_MACRO_FIX
    auto backpressure_strategy(const BackpressureStrategy value) -> decltype(auto);
#else
    IOX2_BUILDER_OPTIONAL(BackpressureStrategy, backpressure_strategy);
#endif
 
#ifdef DOXYGEN_MACRO_FIX
    auto max_loaned_responses_per_request(const uint64_t value) -> decltype(auto);
#else
    IOX2_BUILDER_OPTIONAL(uint64_t, max_loaned_responses_per_request);
#endif
 
  public:
    PortFactoryServer(const PortFactoryServer&) = delete;
    PortFactoryServer(PortFactoryServer&&) = default;
    auto operator=(const PortFactoryServer&) -> PortFactoryServer& = delete;
    auto operator=(PortFactoryServer&&) -> PortFactoryServer& = default;
    ~PortFactoryServer() = default;
 
    auto override_response_preallocation(const OverridePreallocationCallback& callback) && -> PortFactoryServer&&;
 
    template <typename T = ResponsePayload, typename = std::enable_if_t<bb::IsSlice<T>::VALUE, void>>
    auto initial_max_slice_len(uint64_t value) && -> PortFactoryServer&&;
 
    template <typename T = ResponsePayload, typename = std::enable_if_t<bb::IsSlice<T>::VALUE, void>>
    auto allocation_strategy(AllocationStrategy value) && -> PortFactoryServer&&;
 
    auto set_request_degradation_handler(DegradationHandler* handler) && -> PortFactoryServer&&;
 
    auto set_response_degradation_handler(DegradationHandler* handler) && -> PortFactoryServer&&;
 
    auto set_backpressure_handler(BackpressureHandler* handler) && -> PortFactoryServer&&;
 
    auto
    create() && -> bb::Expected<Server<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>,
                                ServerCreateError>;
 
  private:
    template <ServiceType, typename, typename, typename, typename>
    friend class PortFactoryRequestResponse;
 
    explicit PortFactoryServer(iox2_port_factory_server_builder_h handle);
 
    iox2_port_factory_server_builder_h m_handle = nullptr;
    bb::Optional<uint64_t> m_max_slice_len;
    bb::Optional<AllocationStrategy> m_allocation_strategy;
    bb::Optional<OverridePreallocationCallback> m_override_preallocation_callback;
    bb::Optional<DegradationHandler* const> m_request_degradation_handler;
    bb::Optional<DegradationHandler* const> m_response_degradation_handler;
    bb::Optional<BackpressureHandler* const> m_backpressure_handler;
};
 
template <ServiceType Service,
          typename RequestPayload,
          typename RequestUserHeader,
          typename ResponsePayload,
          typename ResponseUserHeader>
template <typename T, typename>
inline auto PortFactoryServer<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>::
    initial_max_slice_len(uint64_t value) && -> PortFactoryServer&& {
    m_max_slice_len.emplace(value);
    return std::move(*this);
}
 
template <ServiceType Service,
          typename RequestPayload,
          typename RequestUserHeader,
          typename ResponsePayload,
          typename ResponseUserHeader>
inline auto PortFactoryServer<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>::
    override_response_preallocation(const OverridePreallocationCallback& callback) && -> PortFactoryServer&& {
    m_override_preallocation_callback.emplace(callback);
    return std::move(*this);
}
 
template <ServiceType Service,
          typename RequestPayload,
          typename RequestUserHeader,
          typename ResponsePayload,
          typename ResponseUserHeader>
template <typename T, typename>
inline auto
PortFactoryServer<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>::allocation_strategy(
    AllocationStrategy value) && -> PortFactoryServer&& {
    m_allocation_strategy.emplace(value);
    return std::move(*this);
}
 
template <ServiceType Service,
          typename RequestPayload,
          typename RequestUserHeader,
          typename ResponsePayload,
          typename ResponseUserHeader>
inline auto PortFactoryServer<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>::
    set_request_degradation_handler(DegradationHandler* handler) && -> PortFactoryServer&& {
    m_request_degradation_handler.emplace(handler);
    return std::move(*this);
}
 
template <ServiceType Service,
          typename RequestPayload,
          typename RequestUserHeader,
          typename ResponsePayload,
          typename ResponseUserHeader>
inline auto PortFactoryServer<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>::
    set_response_degradation_handler(DegradationHandler* handler) && -> PortFactoryServer&& {
    m_response_degradation_handler.emplace(handler);
    return std::move(*this);
}
 
template <ServiceType Service,
          typename RequestPayload,
          typename RequestUserHeader,
          typename ResponsePayload,
          typename ResponseUserHeader>
inline auto PortFactoryServer<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>::
    set_backpressure_handler(BackpressureHandler* handler) && -> PortFactoryServer&& {
    m_backpressure_handler.emplace(handler);
    return std::move(*this);
}
 
template <ServiceType Service,
          typename RequestPayload,
          typename RequestUserHeader,
          typename ResponsePayload,
          typename ResponseUserHeader>
inline auto PortFactoryServer<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>::
    create() && -> bb::Expected<Server<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>,
                                ServerCreateError> {
    if (m_backpressure_strategy.has_value()) {
        iox2_port_factory_server_builder_backpressure_strategy(
            &m_handle, static_cast<iox2_backpressure_strategy_e>(iox2::bb::into<int>(m_backpressure_strategy.value())));
    }
    if (m_max_slice_len.has_value()) {
        iox2_port_factory_server_builder_set_initial_max_slice_len(&m_handle, m_max_slice_len.value());
    } else {
        iox2_port_factory_server_builder_set_initial_max_slice_len(&m_handle, 1);
    }
    if (m_max_loaned_responses_per_request.has_value()) {
        iox2_port_factory_server_builder_set_max_loaned_responses_per_request(
            &m_handle, m_max_loaned_responses_per_request.value());
    }
    if (m_allocation_strategy.has_value()) {
        iox2_port_factory_server_builder_set_allocation_strategy(
            &m_handle, bb::into<iox2_allocation_strategy_e>(m_allocation_strategy.value()));
    }
    if (m_override_preallocation_callback.has_value()) {
        // NOLINTNEXTLINE(cppcoreguidelines-owning-memory) must be a raw pointer - crosses FFI boundary
        auto* callback = new OverridePreallocationCallback(m_override_preallocation_callback.value());
        // NOLINTNEXTLINE(cppcoreguidelines-owning-memory) must be a raw pointer - crosses FFI boundary
        auto* ctx = new internal::CallbackContext<OverridePreallocationCallback>(*callback);
        iox2_port_factory_server_builder_override_responses_preallocation(
            &m_handle, internal::override_callback, static_cast<void*>(ctx));
    }
 
    if (m_request_degradation_handler.has_value()) {
        iox2_port_factory_server_builder_set_request_degradation_handler(
            &m_handle, detail::degradation_handler_delegate, static_cast<void*>(m_request_degradation_handler.value()));
    }
 
    if (m_response_degradation_handler.has_value()) {
        iox2_port_factory_server_builder_set_response_degradation_handler(
            &m_handle,
            detail::degradation_handler_delegate,
            static_cast<void*>(m_response_degradation_handler.value()));
    }
 
    if (m_backpressure_handler.has_value()) {
        iox2_port_factory_server_builder_set_backpressure_handler(
            &m_handle, detail::backpressure_handler_delegate, static_cast<void*>(m_backpressure_handler.value()));
    }
 
    iox2_server_h server_handle {};
    auto result = iox2_port_factory_server_builder_create(m_handle, nullptr, &server_handle);
 
    if (result == IOX2_OK) {
        return Server<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>(server_handle);
    }
 
    return bb::err(bb::into<ServerCreateError>(result));
}
 
template <ServiceType Service,
          typename RequestPayload,
          typename RequestUserHeader,
          typename ResponsePayload,
          typename ResponseUserHeader>
inline PortFactoryServer<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>::
    PortFactoryServer(iox2_port_factory_server_builder_h handle)
    : m_handle { handle } {
}
} // namespace iox2
#endif