port_factory_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_PORTFACTORY_PUBLISH_SUBSCRIBE_HPP
#define IOX2_PORTFACTORY_PUBLISH_SUBSCRIBE_HPP
 
#include "iox2/attribute_set.hpp"
#include "iox2/bb/expected.hpp"
#include "iox2/bb/static_function.hpp"
#include "iox2/callback_progression.hpp"
#include "iox2/cleanup_state.hpp"
#include "iox2/dynamic_config_publish_subscribe.hpp"
#include "iox2/internal/callback_context.hpp"
#include "iox2/internal/iceoryx2.hpp"
#include "iox2/node_failure_enums.hpp"
#include "iox2/node_state.hpp"
#include "iox2/port_factory_publisher.hpp"
#include "iox2/port_factory_subscriber.hpp"
#include "iox2/service_hash.hpp"
#include "iox2/service_name.hpp"
#include "iox2/service_type.hpp"
#include "iox2/static_config_publish_subscribe.hpp"
 
namespace iox2 {
template <ServiceType S, typename Payload, typename UserHeader>
class PortFactoryPublishSubscribe {
  public:
    PortFactoryPublishSubscribe(PortFactoryPublishSubscribe&& rhs) noexcept;
    auto operator=(PortFactoryPublishSubscribe&& rhs) noexcept -> PortFactoryPublishSubscribe&;
    ~PortFactoryPublishSubscribe();
 
    PortFactoryPublishSubscribe(const PortFactoryPublishSubscribe&) = delete;
    auto operator=(const PortFactoryPublishSubscribe&) -> PortFactoryPublishSubscribe& = delete;
 
    auto name() const -> ServiceNameView;
 
    auto service_hash() const -> ServiceHash;
 
    auto attributes() const -> AttributeSetView;
 
    auto static_config() const -> StaticConfigPublishSubscribe;
 
    auto dynamic_config() const -> DynamicConfigPublishSubscribe;
 
    auto nodes(const iox2::bb::StaticFunction<CallbackProgression(NodeState<S>)>& callback) const
        -> bb::Expected<void, NodeListFailure>;
 
    auto subscriber_builder() const -> PortFactorySubscriber<S, Payload, UserHeader>;
 
    auto publisher_builder() const -> PortFactoryPublisher<S, Payload, UserHeader>;
 
    auto try_cleanup_dead_nodes() const -> CleanupState;
 
    auto blocking_cleanup_dead_nodes(iox2::bb::Duration timeout) const -> CleanupState;
 
  private:
    template <typename, typename, ServiceType>
    friend class ServiceBuilderPublishSubscribe;
 
    explicit PortFactoryPublishSubscribe(iox2_port_factory_pub_sub_h handle);
    void drop();
 
    iox2_port_factory_pub_sub_h m_handle = nullptr;
};
 
template <ServiceType S, typename Payload, typename UserHeader>
inline PortFactoryPublishSubscribe<S, Payload, UserHeader>::PortFactoryPublishSubscribe(
    iox2_port_factory_pub_sub_h handle)
    : m_handle { handle } {
}
 
template <ServiceType S, typename Payload, typename UserHeader>
inline void PortFactoryPublishSubscribe<S, Payload, UserHeader>::drop() {
    if (m_handle != nullptr) {
        iox2_port_factory_pub_sub_drop(m_handle);
        m_handle = nullptr;
    }
}
 
template <ServiceType S, typename Payload, typename UserHeader>
inline PortFactoryPublishSubscribe<S, Payload, UserHeader>::PortFactoryPublishSubscribe(
    PortFactoryPublishSubscribe&& rhs) noexcept {
    *this = std::move(rhs);
}
 
template <ServiceType S, typename Payload, typename UserHeader>
inline auto PortFactoryPublishSubscribe<S, Payload, UserHeader>::operator=(PortFactoryPublishSubscribe&& rhs) noexcept
    -> PortFactoryPublishSubscribe& {
    if (this != &rhs) {
        drop();
        m_handle = rhs.m_handle;
        rhs.m_handle = nullptr;
    }
 
    return *this;
}
 
template <ServiceType S, typename Payload, typename UserHeader>
inline PortFactoryPublishSubscribe<S, Payload, UserHeader>::~PortFactoryPublishSubscribe() {
    drop();
}
 
template <ServiceType S, typename Payload, typename UserHeader>
inline auto PortFactoryPublishSubscribe<S, Payload, UserHeader>::name() const -> ServiceNameView {
    const auto* service_name_ptr = iox2_port_factory_pub_sub_service_name(&m_handle);
    return ServiceNameView(service_name_ptr);
}
 
template <ServiceType S, typename Payload, typename UserHeader>
inline auto PortFactoryPublishSubscribe<S, Payload, UserHeader>::service_hash() const -> ServiceHash {
    iox2::legacy::UninitializedArray<char, IOX2_SERVICE_HASH_LENGTH> buffer;
    // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-avoid-unchecked-container-access) index 0 is guaranteed to be valid
    iox2_port_factory_pub_sub_service_hash(&m_handle, &buffer[0], IOX2_SERVICE_HASH_LENGTH);
 
    return ServiceHash(iox2::bb::StaticString<IOX2_SERVICE_HASH_LENGTH>::from_utf8_null_terminated_unchecked_truncated(
        // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-avoid-unchecked-container-access) index 0 is guaranteed to be valid
        &buffer[0],
        IOX2_SERVICE_HASH_LENGTH));
}
 
template <ServiceType S, typename Payload, typename UserHeader>
inline auto PortFactoryPublishSubscribe<S, Payload, UserHeader>::attributes() const -> AttributeSetView {
    return AttributeSetView(iox2_port_factory_pub_sub_attributes(&m_handle));
}
 
template <ServiceType S, typename Payload, typename UserHeader>
inline auto PortFactoryPublishSubscribe<S, Payload, UserHeader>::static_config() const -> StaticConfigPublishSubscribe {
    iox2_static_config_publish_subscribe_t static_config {};
    iox2_port_factory_pub_sub_static_config(&m_handle, &static_config);
 
    return StaticConfigPublishSubscribe(static_config);
}
 
template <ServiceType S, typename Payload, typename UserHeader>
inline auto PortFactoryPublishSubscribe<S, Payload, UserHeader>::dynamic_config() const
    -> DynamicConfigPublishSubscribe {
    return DynamicConfigPublishSubscribe(m_handle);
}
 
template <ServiceType S, typename Payload, typename UserHeader>
inline auto PortFactoryPublishSubscribe<S, Payload, UserHeader>::try_cleanup_dead_nodes() const -> CleanupState {
    iox2_cleanup_state_t cleanup_state {};
 
    iox2_port_factory_pub_sub_try_cleanup_dead_nodes(&m_handle, &cleanup_state);
 
    CleanupState ret_val {};
    ret_val.cleanups = cleanup_state.cleanups;
    ret_val.failed_cleanups = cleanup_state.failed_cleanups;
    return ret_val;
}
 
template <ServiceType T, typename Payload, typename UserHeader>
inline auto
PortFactoryPublishSubscribe<T, Payload, UserHeader>::blocking_cleanup_dead_nodes(iox2::bb::Duration timeout) const
    -> CleanupState {
    iox2_cleanup_state_t cleanup_state {};
 
    iox2_port_factory_pub_sub_blocking_cleanup_dead_nodes(
        &m_handle, &cleanup_state, timeout.as_secs(), timeout.subsec_nanos());
 
    CleanupState ret_val {};
    ret_val.cleanups = cleanup_state.cleanups;
    ret_val.failed_cleanups = cleanup_state.failed_cleanups;
    return ret_val;
}
 
template <ServiceType S, typename Payload, typename UserHeader>
inline auto PortFactoryPublishSubscribe<S, Payload, UserHeader>::nodes(
    const iox2::bb::StaticFunction<CallbackProgression(NodeState<S>)>& callback) const
    -> bb::Expected<void, NodeListFailure> {
    auto ctx = internal::ctx(callback);
 
    const auto ret_val =
        iox2_port_factory_pub_sub_nodes(&m_handle, internal::list_callback<S>, static_cast<void*>(&ctx));
 
    if (ret_val == IOX2_OK) {
        return {};
    }
 
    return bb::err(bb::into<NodeListFailure>(ret_val));
}
 
template <ServiceType S, typename Payload, typename UserHeader>
inline auto PortFactoryPublishSubscribe<S, Payload, UserHeader>::subscriber_builder() const
    -> PortFactorySubscriber<S, Payload, UserHeader> {
    return PortFactorySubscriber<S, Payload, UserHeader>(
        iox2_port_factory_pub_sub_subscriber_builder(&m_handle, nullptr));
}
 
template <ServiceType S, typename Payload, typename UserHeader>
inline auto PortFactoryPublishSubscribe<S, Payload, UserHeader>::publisher_builder() const
    -> PortFactoryPublisher<S, Payload, UserHeader> {
    return PortFactoryPublisher<S, Payload, UserHeader>(
        iox2_port_factory_pub_sub_publisher_builder(&m_handle, nullptr));
}
 
 
} // namespace iox2
 
#endif