port_factory_client.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_CLIENT_HPP
#define IOX2_PORTFACTORY_CLIENT_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/client.hpp"
#include "iox2/client_error.hpp"
#include "iox2/degradation_handler.hpp"
#include "iox2/internal/callback_context.hpp"
#include "iox2/internal/iceoryx2.hpp"
#include "iox2/port_name.hpp"
#include "iox2/service_type.hpp"
 
namespace iox2 {
template <ServiceType Service,
          typename RequestPayload,
          typename RequestUserHeader,
          typename ResponsePayload,
          typename ResponseUserHeader>
class PortFactoryClient {
  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_active_requests(const uint64_t value) -> decltype(auto);
#else
    IOX2_BUILDER_OPTIONAL(uint64_t, max_active_requests);
#endif
 
#ifdef DOXYGEN_MACRO_FIX
    auto name(const PortName value) -> decltype(auto);
#else
    IOX2_BUILDER_OPTIONAL(PortName, name);
#endif
 
  public:
    PortFactoryClient(const PortFactoryClient&) = delete;
    PortFactoryClient(PortFactoryClient&&) = default;
    auto operator=(const PortFactoryClient&) -> PortFactoryClient& = delete;
    auto operator=(PortFactoryClient&&) -> PortFactoryClient& = default;
    ~PortFactoryClient() = default;
 
    template <typename T = RequestPayload, typename = std::enable_if_t<bb::IsSlice<T>::VALUE, void>>
    auto initial_max_slice_len(uint64_t value) && -> PortFactoryClient&&;
 
    template <typename T = RequestPayload, typename = std::enable_if_t<bb::IsSlice<T>::VALUE, void>>
    auto allocation_strategy(AllocationStrategy value) && -> PortFactoryClient&&;
 
    auto override_request_preallocation(const OverridePreallocationCallback& callback) && -> PortFactoryClient&&;
 
    auto set_request_degradation_handler(DegradationHandler* handler) && -> PortFactoryClient&&;
 
    auto set_response_degradation_handler(DegradationHandler* handler) && -> PortFactoryClient&&;
 
    auto set_backpressure_handler(BackpressureHandler* handler) && -> PortFactoryClient&&;
 
    auto
    create() && -> bb::Expected<Client<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>,
                                ClientCreateError>;
 
  private:
    template <ServiceType, typename, typename, typename, typename>
    friend class PortFactoryRequestResponse;
 
    explicit PortFactoryClient(iox2_port_factory_client_builder_h handle);
 
    iox2_port_factory_client_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 PortFactoryClient<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>::
    initial_max_slice_len(uint64_t value) && -> PortFactoryClient&& {
    m_max_slice_len.emplace(value);
    return std::move(*this);
}
 
template <ServiceType Service,
          typename RequestPayload,
          typename RequestUserHeader,
          typename ResponsePayload,
          typename ResponseUserHeader>
inline auto PortFactoryClient<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>::
    override_request_preallocation(const OverridePreallocationCallback& callback) && -> PortFactoryClient&& {
    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
PortFactoryClient<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>::allocation_strategy(
    AllocationStrategy value) && -> PortFactoryClient&& {
    m_allocation_strategy.emplace(value);
    return std::move(*this);
}
 
template <ServiceType Service,
          typename RequestPayload,
          typename RequestUserHeader,
          typename ResponsePayload,
          typename ResponseUserHeader>
inline auto PortFactoryClient<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>::
    set_request_degradation_handler(DegradationHandler* handler) && -> PortFactoryClient&& {
    m_request_degradation_handler.emplace(handler);
    return std::move(*this);
}
 
template <ServiceType Service,
          typename RequestPayload,
          typename RequestUserHeader,
          typename ResponsePayload,
          typename ResponseUserHeader>
inline auto PortFactoryClient<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>::
    set_response_degradation_handler(DegradationHandler* handler) && -> PortFactoryClient&& {
    m_response_degradation_handler.emplace(handler);
    return std::move(*this);
}
 
template <ServiceType Service,
          typename RequestPayload,
          typename RequestUserHeader,
          typename ResponsePayload,
          typename ResponseUserHeader>
inline auto PortFactoryClient<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>::
    set_backpressure_handler(BackpressureHandler* handler) && -> PortFactoryClient&& {
    m_backpressure_handler.emplace(handler);
    return std::move(*this);
}
 
template <ServiceType Service,
          typename RequestPayload,
          typename RequestUserHeader,
          typename ResponsePayload,
          typename ResponseUserHeader>
inline auto PortFactoryClient<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>::
    create() && -> bb::Expected<Client<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>,
                                ClientCreateError> {
    if (m_backpressure_strategy.has_value()) {
        iox2_port_factory_client_builder_backpressure_strategy(
            &m_handle, static_cast<iox2_backpressure_strategy_e>(bb::into<int>(m_backpressure_strategy.value())));
    }
    if (m_max_slice_len.has_value()) {
        iox2_port_factory_client_builder_set_initial_max_slice_len(&m_handle, m_max_slice_len.value());
    } else {
        iox2_port_factory_client_builder_set_initial_max_slice_len(&m_handle, 1);
    }
    if (m_allocation_strategy.has_value()) {
        iox2_port_factory_client_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_client_builder_override_requests_preallocation(
            &m_handle, internal::override_callback, static_cast<void*>(ctx));
    }
 
    if (m_request_degradation_handler.has_value()) {
        iox2_port_factory_client_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_client_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_client_builder_set_backpressure_handler(
            &m_handle, detail::backpressure_handler_delegate, static_cast<void*>(m_backpressure_handler.value()));
    }
 
    if (m_max_active_requests.has_value()) {
        iox2_port_factory_client_builder_set_max_active_requests(&m_handle, m_max_active_requests.value());
    }
 
    if (m_name.has_value()) {
        const auto* name_ptr = m_name.value().as_view().native_ptr();
        iox2_port_factory_client_builder_set_name(&m_handle, name_ptr);
    }
 
    iox2_client_h client_handle {};
    auto result = iox2_port_factory_client_builder_create(m_handle, nullptr, &client_handle);
 
    if (result == IOX2_OK) {
        return Client<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>(client_handle);
    }
 
    return bb::err(bb::into<ClientCreateError>(result));
}
 
template <ServiceType Service,
          typename RequestPayload,
          typename RequestUserHeader,
          typename ResponsePayload,
          typename ResponseUserHeader>
inline PortFactoryClient<Service, RequestPayload, RequestUserHeader, ResponsePayload, ResponseUserHeader>::
    PortFactoryClient(iox2_port_factory_client_builder_h handle)
    : m_handle { handle } {
}
} // namespace iox2
#endif