port_factory_publisher.hpp

Go to the documentation of this file.

// Copyright (c) 2024 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_PUBLISHER_HPP
#define IOX2_PORTFACTORY_PUBLISHER_HPP
 
#include "iox2/allocation_strategy.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/internal/iceoryx2.hpp"
#include "iox2/publisher.hpp"
#include "iox2/service_type.hpp"
 
#include <cstdint>
 
namespace iox2 {
template <ServiceType S, typename Payload, typename UserHeader>
class PortFactoryPublisher {
  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_samples(const uint64_t value) -> decltype(auto);
#else
    IOX2_BUILDER_OPTIONAL(uint64_t, max_loaned_samples);
#endif
 
  public:
    PortFactoryPublisher(const PortFactoryPublisher&) = delete;
    PortFactoryPublisher(PortFactoryPublisher&&) = default;
    auto operator=(const PortFactoryPublisher&) -> PortFactoryPublisher& = delete;
    auto operator=(PortFactoryPublisher&&) -> PortFactoryPublisher& = default;
    ~PortFactoryPublisher() = default;
 
    auto override_sample_preallocation(const OverridePreallocationCallback& callback) && -> PortFactoryPublisher&&;
 
    template <typename T = Payload, typename = std::enable_if_t<bb::IsSlice<T>::VALUE, void>>
    auto initial_max_slice_len(uint64_t value) && -> PortFactoryPublisher&&;
 
    template <typename T = Payload, typename = std::enable_if_t<bb::IsSlice<T>::VALUE, void>>
    auto allocation_strategy(AllocationStrategy value) && -> PortFactoryPublisher&&;
 
    auto set_degradation_handler(DegradationHandler* handler) && -> PortFactoryPublisher&&;
 
    auto set_backpressure_handler(BackpressureHandler* handler) && -> PortFactoryPublisher&&;
 
    auto create() && -> bb::Expected<Publisher<S, Payload, UserHeader>, PublisherCreateError>;
 
  private:
    template <ServiceType, typename, typename>
    friend class PortFactoryPublishSubscribe;
 
    explicit PortFactoryPublisher(iox2_port_factory_publisher_builder_h handle);
 
    iox2_port_factory_publisher_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_degradation_handler;
    bb::Optional<BackpressureHandler* const> m_backpressure_handler;
};
 
template <ServiceType S, typename Payload, typename UserHeader>
inline PortFactoryPublisher<S, Payload, UserHeader>::PortFactoryPublisher(iox2_port_factory_publisher_builder_h handle)
    : m_handle { handle } {
}
 
template <ServiceType S, typename Payload, typename UserHeader>
template <typename T, typename>
inline auto
PortFactoryPublisher<S, Payload, UserHeader>::initial_max_slice_len(uint64_t value) && -> PortFactoryPublisher&& {
    m_max_slice_len.emplace(value);
    return std::move(*this);
}
 
template <ServiceType S, typename Payload, typename UserHeader>
inline auto PortFactoryPublisher<S, Payload, UserHeader>::override_sample_preallocation(
    const OverridePreallocationCallback& callback) && -> PortFactoryPublisher&& {
    m_override_preallocation_callback.emplace(callback);
    return std::move(*this);
}
 
template <ServiceType S, typename Payload, typename UserHeader>
template <typename T, typename>
inline auto PortFactoryPublisher<S, Payload, UserHeader>::allocation_strategy(
    AllocationStrategy value) && -> PortFactoryPublisher&& {
    m_allocation_strategy.emplace(value);
    return std::move(*this);
}
 
template <ServiceType S, typename Payload, typename UserHeader>
inline auto PortFactoryPublisher<S, Payload, UserHeader>::set_degradation_handler(
    DegradationHandler* handler) && -> PortFactoryPublisher&& {
    m_degradation_handler.emplace(handler);
    return std::move(*this);
}
 
template <ServiceType S, typename Payload, typename UserHeader>
inline auto PortFactoryPublisher<S, Payload, UserHeader>::set_backpressure_handler(
    BackpressureHandler* handler) && -> PortFactoryPublisher&& {
    m_backpressure_handler.emplace(handler);
    return std::move(*this);
}
 
template <ServiceType S, typename Payload, typename UserHeader>
inline auto PortFactoryPublisher<S, Payload, UserHeader>::create() && -> bb::Expected<Publisher<S, Payload, UserHeader>,
                                                                                      PublisherCreateError> {
    if (m_backpressure_strategy.has_value()) {
        iox2_port_factory_publisher_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_publisher_builder_set_initial_max_slice_len(&m_handle, m_max_slice_len.value());
    } else {
        iox2_port_factory_publisher_builder_set_initial_max_slice_len(&m_handle, 1);
    }
    if (m_max_loaned_samples.has_value()) {
        iox2_port_factory_publisher_builder_set_max_loaned_samples(&m_handle, m_max_loaned_samples.value());
    }
    if (m_allocation_strategy.has_value()) {
        iox2_port_factory_publisher_builder_set_allocation_strategy(
            &m_handle, bb::into<iox2_allocation_strategy_e>(m_allocation_strategy.value()));
    }
 
    if (m_degradation_handler.has_value()) {
        iox2_port_factory_publisher_builder_set_degradation_handler(
            &m_handle, detail::degradation_handler_delegate, static_cast<void*>(m_degradation_handler.value()));
    }
 
    if (m_backpressure_handler.has_value()) {
        iox2_port_factory_publisher_builder_set_backpressure_handler(
            &m_handle, detail::backpressure_handler_delegate, static_cast<void*>(m_backpressure_handler.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_publisher_builder_override_samples_preallocation(
            &m_handle, internal::override_callback, static_cast<void*>(ctx));
    }
 
 
    iox2_publisher_h pub_handle {};
 
    auto result = iox2_port_factory_publisher_builder_create(m_handle, nullptr, &pub_handle);
 
    if (result == IOX2_OK) {
        return Publisher<S, Payload, UserHeader>(pub_handle);
    }
 
    return bb::err(bb::into<PublisherCreateError>(result));
}
} // namespace iox2
 
#endif