service_builder_publish_subscribe.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_SERVICE_BUILDER_PUBLISH_SUBSCRIBE_HPP
#define IOX2_SERVICE_BUILDER_PUBLISH_SUBSCRIBE_HPP
 
#include "iox2/attribute_specifier.hpp"
#include "iox2/attribute_verifier.hpp"
#include "iox2/bb/detail/builder.hpp"
#include "iox2/bb/expected.hpp"
#include "iox2/bb/file_path.hpp"
#include "iox2/bb/layout.hpp"
#include "iox2/bb/slice.hpp"
#include "iox2/internal/iceoryx2.hpp"
#include "iox2/internal/service_builder_internal.hpp"
#include "iox2/marker.hpp"
#include "iox2/message_type_details.hpp"
#include "iox2/payload_info.hpp"
#include "iox2/port_factory_publish_subscribe.hpp"
#include "iox2/service_builder_publish_subscribe_error.hpp"
#include "iox2/service_type.hpp"
#include "iox2/type_variant.hpp"
 
#include <cstring>
#include <type_traits>
 
namespace iox2 {
template <typename Payload, typename UserHeader, ServiceType S>
class ServiceBuilderPublishSubscribe;
 
template <typename Payload, typename UserHeader, ServiceType S>
auto set_payload_type_details(ServiceBuilderPublishSubscribe<Payload, UserHeader, S>& builder, const TypeDetail& value)
    -> std::enable_if_t<std::is_same<Payload, bb::Slice<CustomPayloadMarker>>::value>;
 
template <typename Payload, typename UserHeader, ServiceType S>
auto set_user_header_type_details(ServiceBuilderPublishSubscribe<Payload, UserHeader, S>& builder,
                                  const TypeDetail& value)
    -> std::enable_if_t<std::is_same<UserHeader, CustomHeaderMarker>::value>;
 
template <typename Payload, typename UserHeader, ServiceType S>
class ServiceBuilderPublishSubscribe {
  public:
#ifdef DOXYGEN_MACRO_FIX
    auto payload_alignment(const uint64_t value) -> decltype(auto);
#else
    IOX2_BUILDER_OPTIONAL(uint64_t, payload_alignment);
#endif
 
#ifdef DOXYGEN_MACRO_FIX
    auto enable_safe_overflow(const bool value) -> decltype(auto);
#else
    IOX2_BUILDER_OPTIONAL(bool, enable_safe_overflow);
#endif
 
#ifdef DOXYGEN_MACRO_FIX
    auto subscriber_max_borrowed_samples(const uint64_t value) -> decltype(auto);
#else
    IOX2_BUILDER_OPTIONAL(uint64_t, subscriber_max_borrowed_samples);
#endif
 
#ifdef DOXYGEN_MACRO_FIX
    auto history_size(const uint64_t value) -> decltype(auto);
#else
    IOX2_BUILDER_OPTIONAL(uint64_t, history_size);
#endif
 
#ifdef DOXYGEN_MACRO_FIX
    auto subscriber_max_buffer_size(const uint64_t value) -> decltype(auto);
#else
    IOX2_BUILDER_OPTIONAL(uint64_t, subscriber_max_buffer_size);
#endif
 
#ifdef DOXYGEN_MACRO_FIX
    auto max_subscribers(const uint64_t value) -> decltype(auto);
#else
    IOX2_BUILDER_OPTIONAL(uint64_t, max_subscribers);
#endif
 
#ifdef DOXYGEN_MACRO_FIX
    auto max_publishers(const uint64_t value) -> decltype(auto);
#else
    IOX2_BUILDER_OPTIONAL(uint64_t, max_publishers);
#endif
 
#ifdef DOXYGEN_MACRO_FIX
    auto max_nodes(const uint64_t value) -> decltype(auto);
#else
    IOX2_BUILDER_OPTIONAL(uint64_t, max_nodes);
#endif
 
  public:
    template <typename U = Payload, typename = std::enable_if_t<has_flatbuffer_marker<U>(), void>>
    auto flatbuffer_schema_path(const bb::FilePath& value) && -> ServiceBuilderPublishSubscribe<U, UserHeader, S>&&;
 
    template <typename NewHeader>
    auto user_header() && -> ServiceBuilderPublishSubscribe<Payload, NewHeader, S>&&;
 
    auto resume_build() & -> ServiceBuilderPublishSubscribe<Payload, UserHeader, S>&&;
 
    auto open_or_create() && -> bb::Expected<PortFactoryPublishSubscribe<S, Payload, UserHeader>,
                                             PublishSubscribeOpenOrCreateError>;
 
    auto open_or_create_with_attributes(const AttributeVerifier& required_attributes) && -> bb::
        Expected<PortFactoryPublishSubscribe<S, Payload, UserHeader>, PublishSubscribeOpenOrCreateError>;
 
    auto open() && -> bb::Expected<PortFactoryPublishSubscribe<S, Payload, UserHeader>, PublishSubscribeOpenError>;
 
    auto open_with_attributes(const AttributeVerifier& required_attributes) && -> bb::
        Expected<PortFactoryPublishSubscribe<S, Payload, UserHeader>, PublishSubscribeOpenError>;
 
    auto create() && -> bb::Expected<PortFactoryPublishSubscribe<S, Payload, UserHeader>, PublishSubscribeCreateError>;
 
    auto create_with_attributes(
        const AttributeSpecifier& attributes) && -> bb::Expected<PortFactoryPublishSubscribe<S, Payload, UserHeader>,
                                                                 PublishSubscribeCreateError>;
 
  private:
    template <ServiceType>
    friend class ServiceBuilder;
 
    template <typename P, typename U, ServiceType St>
    friend auto set_payload_type_details(ServiceBuilderPublishSubscribe<P, U, St>& builder, const TypeDetail& value)
        -> std::enable_if_t<std::is_same<P, bb::Slice<CustomPayloadMarker>>::value>;
    template <typename P, typename U, ServiceType St>
    friend auto set_user_header_type_details(ServiceBuilderPublishSubscribe<P, U, St>& builder, const TypeDetail& value)
        -> std::enable_if_t<std::is_same<U, CustomHeaderMarker>::value>;
 
    explicit ServiceBuilderPublishSubscribe(iox2_service_builder_h handle);
 
    template <typename U = Payload>
    auto set_type_definition_name_hint() -> std::enable_if_t<has_flatbuffer_marker<U>(), void>;
    template <typename U = Payload>
    auto set_type_definition_name_hint() -> std::enable_if_t<!has_flatbuffer_marker<U>(), void>;
 
    void set_parameters();
    void derive_payload_type_details();
    void override_payload_type_details(const TypeDetail& value);
    void derive_user_header_type_details();
    void override_user_header_type_details(const TypeDetail& value);
 
    iox2_service_builder_pub_sub_h m_handle = nullptr;
    bool m_has_flatbuffer_schema_defined = false;
    bb::Optional<TypeDetail> m_user_header_type_details_override;
    bb::Optional<TypeDetail> m_payload_type_details_override;
};
 
template <typename Payload, typename UserHeader, ServiceType S>
inline ServiceBuilderPublishSubscribe<Payload, UserHeader, S>::ServiceBuilderPublishSubscribe(
    iox2_service_builder_h handle)
    : m_handle { iox2_service_builder_pub_sub(handle) } {
}
 
template <typename Payload, typename UserHeader, ServiceType S>
template <typename U>
inline auto ServiceBuilderPublishSubscribe<Payload, UserHeader, S>::set_type_definition_name_hint()
    -> std::enable_if_t<has_flatbuffer_marker<U>(), void> {
    auto type_name = iox2::internal::get_type_name<typename Payload::ValueType>();
    iox2_service_builder_pub_sub_type_definition_name_hint(
        &m_handle, type_name.unchecked_access().c_str(), type_name.size(), "", 0);
}
 
template <typename Payload, typename UserHeader, ServiceType S>
template <typename U>
inline auto ServiceBuilderPublishSubscribe<Payload, UserHeader, S>::set_type_definition_name_hint()
    -> std::enable_if_t<!has_flatbuffer_marker<U>(), void> {
}
 
template <typename Payload, typename UserHeader, ServiceType S>
inline void ServiceBuilderPublishSubscribe<Payload, UserHeader, S>::set_parameters() {
    if (m_enable_safe_overflow.has_value()) {
        iox2_service_builder_pub_sub_set_enable_safe_overflow(&m_handle, m_enable_safe_overflow.value());
    }
    if (m_subscriber_max_borrowed_samples.has_value()) {
        iox2_service_builder_pub_sub_set_subscriber_max_borrowed_samples(&m_handle,
                                                                         m_subscriber_max_borrowed_samples.value());
    }
    if (m_history_size.has_value()) {
        iox2_service_builder_pub_sub_set_history_size(&m_handle, m_history_size.value());
    }
    if (m_subscriber_max_buffer_size.has_value()) {
        iox2_service_builder_pub_sub_set_subscriber_max_buffer_size(&m_handle, m_subscriber_max_buffer_size.value());
    }
    if (m_max_subscribers.has_value()) {
        iox2_service_builder_pub_sub_set_max_subscribers(&m_handle, m_max_subscribers.value());
    }
    if (m_max_publishers.has_value()) {
        iox2_service_builder_pub_sub_set_max_publishers(&m_handle, m_max_publishers.value());
    }
    if (m_payload_alignment.has_value()) {
        iox2_service_builder_pub_sub_set_payload_alignment(&m_handle, m_payload_alignment.value());
    }
    if (m_max_nodes.has_value()) {
        iox2_service_builder_pub_sub_set_max_nodes(&m_handle, m_max_nodes.value());
    }
 
    if (m_user_header_type_details_override.has_value()) {
        override_user_header_type_details(m_user_header_type_details_override.value());
    } else {
        derive_user_header_type_details();
    }
 
    if (m_payload_type_details_override.has_value()) {
        override_payload_type_details(m_payload_type_details_override.value());
    } else {
        derive_payload_type_details();
    }
 
    set_type_definition_name_hint();
}
 
template <typename Payload, typename UserHeader, ServiceType S>
inline void ServiceBuilderPublishSubscribe<Payload, UserHeader, S>::derive_user_header_type_details() {
    // user header type details derived from the compile-time UserHeader
    const auto header_layout = bb::Layout::from<UserHeader>();
    const auto user_header_type_name = internal::get_type_name<UserHeader>();
 
    const auto result =
        iox2_service_builder_pub_sub_set_user_header_type_details(&m_handle,
                                                                  iox2_type_variant_e_FIXED_SIZE,
                                                                  user_header_type_name.unchecked_access().c_str(),
                                                                  user_header_type_name.size(),
                                                                  header_layout.size(),
                                                                  header_layout.alignment());
 
    if (result != IOX2_OK) {
        IOX2_PANIC("This should never happen! Implementation failure while setting the User-Header-Type.");
    }
}
 
template <typename Payload, typename UserHeader, ServiceType S>
inline void
ServiceBuilderPublishSubscribe<Payload, UserHeader, S>::override_user_header_type_details(const TypeDetail& value) {
    // user header type details provided at runtime
    const auto type_variant =
        value.variant() == TypeVariant::FixedSize ? iox2_type_variant_e_FIXED_SIZE : iox2_type_variant_e_DYNAMIC;
 
    const auto result = iox2_service_builder_pub_sub_set_user_header_type_details(
        &m_handle, type_variant, value.type_name(), std::strlen(value.type_name()), value.size(), value.alignment());
 
    if (result != IOX2_OK) {
        IOX2_PANIC("This should never happen! Implementation failure while setting the User-Header-Type.");
    }
}
 
template <typename Payload, typename UserHeader, ServiceType S>
inline void ServiceBuilderPublishSubscribe<Payload, UserHeader, S>::derive_payload_type_details() {
    using ValueType = typename PayloadInfo<Payload>::ValueType;
 
    // payload type details derived from the compile-time Payload
    const auto payload_type_name = internal::get_type_name<Payload>();
    const auto type_variant =
        bb::IsSlice<Payload>::VALUE ? iox2_type_variant_e_DYNAMIC : iox2_type_variant_e_FIXED_SIZE;
 
    const auto result =
        iox2_service_builder_pub_sub_set_payload_type_details(&m_handle,
                                                              type_variant,
                                                              payload_type_name.unchecked_access().c_str(),
                                                              payload_type_name.size(),
                                                              sizeof(ValueType),
                                                              alignof(ValueType));
 
    if (result != IOX2_OK) {
        IOX2_PANIC("This should never happen! Implementation failure while setting the Payload-Type.");
    }
}
 
template <typename Payload, typename UserHeader, ServiceType S>
inline void
ServiceBuilderPublishSubscribe<Payload, UserHeader, S>::override_payload_type_details(const TypeDetail& value) {
    // payload type details provided at runtime
    const auto type_variant =
        value.variant() == TypeVariant::FixedSize ? iox2_type_variant_e_FIXED_SIZE : iox2_type_variant_e_DYNAMIC;
 
    const auto result = iox2_service_builder_pub_sub_set_payload_type_details(
        &m_handle, type_variant, value.type_name(), std::strlen(value.type_name()), value.size(), value.alignment());
 
    if (result != IOX2_OK) {
        IOX2_PANIC("This should never happen! Implementation failure while setting the Payload-Type.");
    }
}
 
 
template <typename Payload, typename UserHeader, ServiceType S>
template <typename NewHeader>
inline auto ServiceBuilderPublishSubscribe<Payload, UserHeader, S>::
    user_header() && -> ServiceBuilderPublishSubscribe<Payload, NewHeader, S>&& {
    // required here since we just change the template header type but the builder structure stays the same
    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
    return std::move(*reinterpret_cast<ServiceBuilderPublishSubscribe<Payload, NewHeader, S>*>(this));
}
 
 
template <typename Payload, typename UserHeader, ServiceType S>
template <typename U, typename>
inline auto ServiceBuilderPublishSubscribe<Payload, UserHeader, S>::flatbuffer_schema_path(
    const bb::FilePath& value) && -> ServiceBuilderPublishSubscribe<U, UserHeader, S>&& {
    iox2_service_builder_pub_sub_set_flatbuffer_schema_path(&m_handle, value.as_string().unchecked_access().c_str());
    m_has_flatbuffer_schema_defined = true;
    return std::move(*this);
}
 
template <typename Payload, typename UserHeader, ServiceType S>
inline auto ServiceBuilderPublishSubscribe<Payload, UserHeader, S>::
    resume_build() & -> ServiceBuilderPublishSubscribe<Payload, UserHeader, S>&& {
    return std::move(*this);
}
 
template <typename Payload, typename UserHeader, ServiceType S>
inline auto set_user_header_type_details(ServiceBuilderPublishSubscribe<Payload, UserHeader, S>& builder,
                                         const TypeDetail& value)
    -> std::enable_if_t<std::is_same<UserHeader, CustomHeaderMarker>::value> {
    builder.m_user_header_type_details_override = bb::Optional<TypeDetail>(value);
}
 
template <typename Payload, typename UserHeader, ServiceType S>
inline auto set_payload_type_details(ServiceBuilderPublishSubscribe<Payload, UserHeader, S>& builder,
                                     const TypeDetail& value)
    -> std::enable_if_t<std::is_same<Payload, bb::Slice<CustomPayloadMarker>>::value> {
    builder.m_payload_type_details_override = bb::Optional<TypeDetail>(value);
}
 
template <typename Payload, typename UserHeader, ServiceType S>
inline auto ServiceBuilderPublishSubscribe<Payload, UserHeader, S>::open_or_create() && -> bb::
    Expected<PortFactoryPublishSubscribe<S, Payload, UserHeader>, PublishSubscribeOpenOrCreateError> {
    set_parameters();
 
    iox2_port_factory_pub_sub_h port_factory_handle {};
    auto result = iox2_service_builder_pub_sub_open_or_create(m_handle, nullptr, &port_factory_handle);
 
    if (result == IOX2_OK) {
        return PortFactoryPublishSubscribe<S, Payload, UserHeader>(port_factory_handle);
    }
 
    return bb::err(bb::into<PublishSubscribeOpenOrCreateError>(result));
}
 
template <typename Payload, typename UserHeader, ServiceType S>
inline auto ServiceBuilderPublishSubscribe<Payload, UserHeader, S>::open() && -> bb::
    Expected<PortFactoryPublishSubscribe<S, Payload, UserHeader>, PublishSubscribeOpenError> {
    set_parameters();
 
    iox2_port_factory_pub_sub_h port_factory_handle {};
    auto result = iox2_service_builder_pub_sub_open(m_handle, nullptr, &port_factory_handle);
 
    if (result == IOX2_OK) {
        return PortFactoryPublishSubscribe<S, Payload, UserHeader>(port_factory_handle);
    }
 
    return bb::err(bb::into<PublishSubscribeOpenError>(result));
}
 
template <typename Payload, typename UserHeader, ServiceType S>
inline auto ServiceBuilderPublishSubscribe<Payload, UserHeader, S>::create() && -> bb::
    Expected<PortFactoryPublishSubscribe<S, Payload, UserHeader>, PublishSubscribeCreateError> {
    set_parameters();
 
    iox2_port_factory_pub_sub_h port_factory_handle {};
    auto result = iox2_service_builder_pub_sub_create(m_handle, nullptr, &port_factory_handle);
 
    if (result == IOX2_OK) {
        return PortFactoryPublishSubscribe<S, Payload, UserHeader>(port_factory_handle);
    }
 
    return bb::err(bb::into<PublishSubscribeCreateError>(result));
}
 
template <typename Payload, typename UserHeader, ServiceType S>
inline auto ServiceBuilderPublishSubscribe<Payload, UserHeader, S>::open_or_create_with_attributes(
    const AttributeVerifier&
        required_attributes) && -> bb::Expected<PortFactoryPublishSubscribe<S, Payload, UserHeader>,
                                                PublishSubscribeOpenOrCreateError> {
    set_parameters();
 
    iox2_port_factory_pub_sub_h port_factory_handle {};
    auto result = iox2_service_builder_pub_sub_open_or_create_with_attributes(
        m_handle, &required_attributes.m_handle, nullptr, &port_factory_handle);
 
    if (result == IOX2_OK) {
        return PortFactoryPublishSubscribe<S, Payload, UserHeader>(port_factory_handle);
    }
 
    return bb::err(bb::into<PublishSubscribeOpenOrCreateError>(result));
}
 
template <typename Payload, typename UserHeader, ServiceType S>
inline auto ServiceBuilderPublishSubscribe<Payload, UserHeader, S>::open_with_attributes(
    const AttributeVerifier&
        required_attributes) && -> bb::Expected<PortFactoryPublishSubscribe<S, Payload, UserHeader>,
                                                PublishSubscribeOpenError> {
    set_parameters();
 
    iox2_port_factory_pub_sub_h port_factory_handle {};
    auto result = iox2_service_builder_pub_sub_open_with_attributes(
        m_handle, &required_attributes.m_handle, nullptr, &port_factory_handle);
 
    if (result == IOX2_OK) {
        return PortFactoryPublishSubscribe<S, Payload, UserHeader>(port_factory_handle);
    }
 
    return bb::err(bb::into<PublishSubscribeOpenError>(result));
}
 
template <typename Payload, typename UserHeader, ServiceType S>
inline auto ServiceBuilderPublishSubscribe<Payload, UserHeader, S>::create_with_attributes(
    const AttributeSpecifier& attributes) && -> bb::Expected<PortFactoryPublishSubscribe<S, Payload, UserHeader>,
                                                             PublishSubscribeCreateError> {
    set_parameters();
 
    iox2_port_factory_pub_sub_h port_factory_handle {};
    auto result = iox2_service_builder_pub_sub_create_with_attributes(
        m_handle, &attributes.m_handle, nullptr, &port_factory_handle);
 
    if (result == IOX2_OK) {
        return PortFactoryPublishSubscribe<S, Payload, UserHeader>(port_factory_handle);
    }
 
    return bb::err(bb::into<PublishSubscribeCreateError>(result));
}
} // namespace iox2
 
#endif