waitset.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_WAITSET_HPP
#define IOX2_WAITSET_HPP
 
#include "iox2/bb/detail/builder.hpp"
#include "iox2/bb/duration.hpp"
#include "iox2/bb/expected.hpp"
#include "iox2/callback_progression.hpp"
#include "iox2/file_descriptor.hpp"
#include "iox2/internal/iceoryx2.hpp"
#include "iox2/listener.hpp"
#include "iox2/service_type.hpp"
#include "iox2/signal_handling_mode.hpp"
#include "iox2/waitset_enums.hpp"
 
namespace iox2 {
template <ServiceType S>
class WaitSetGuard {
  public:
    WaitSetGuard(WaitSetGuard&&) noexcept;
    auto operator=(WaitSetGuard&& rhs) noexcept -> WaitSetGuard&;
    ~WaitSetGuard();
 
    WaitSetGuard(const WaitSetGuard&) = delete;
    auto operator=(const WaitSetGuard&) = delete;
 
  private:
    template <ServiceType>
    friend class WaitSet;
 
    template <ServiceType>
    friend class WaitSetAttachmentId;
    explicit WaitSetGuard(iox2_waitset_guard_h handle);
    void drop();
 
    iox2_waitset_guard_h m_handle = nullptr;
};
 
template <ServiceType S>
class WaitSetAttachmentId {
  public:
    WaitSetAttachmentId(const WaitSetAttachmentId& rhs) = delete;
    auto operator=(const WaitSetAttachmentId& rhs) -> WaitSetAttachmentId& = delete;
 
    WaitSetAttachmentId(WaitSetAttachmentId&& rhs) noexcept;
    auto operator=(WaitSetAttachmentId&& rhs) noexcept -> WaitSetAttachmentId&;
    ~WaitSetAttachmentId();
 
    static auto from_guard(const WaitSetGuard<S>& guard) -> WaitSetAttachmentId;
 
    auto has_event_from(const WaitSetGuard<S>& guard) const -> bool;
 
    auto has_missed_deadline(const WaitSetGuard<S>& guard) const -> bool;
 
    auto hash() const -> std::size_t;
 
  private:
    explicit WaitSetAttachmentId(iox2_waitset_attachment_id_h handle);
    template <ServiceType>
    friend auto run_callback(iox2_waitset_attachment_id_h, void*) -> iox2_callback_progression_e;
    template <ServiceType ST>
    friend auto operator==(const WaitSetAttachmentId<ST>&, const WaitSetAttachmentId<ST>&) -> bool;
    template <ServiceType ST>
    friend auto operator<(const WaitSetAttachmentId<ST>&, const WaitSetAttachmentId<ST>&) -> bool;
    template <ServiceType ST>
    friend auto operator<<(std::ostream& stream, const WaitSetAttachmentId<ST>& self) -> std::ostream&;
 
    void drop();
 
    iox2_waitset_attachment_id_h m_handle = nullptr;
};
 
template <ServiceType S>
auto operator==(const WaitSetAttachmentId<S>& lhs, const WaitSetAttachmentId<S>& rhs) -> bool;
 
template <ServiceType S>
auto operator<(const WaitSetAttachmentId<S>& lhs, const WaitSetAttachmentId<S>& rhs) -> bool;
 
template <ServiceType S>
auto operator<<(std::ostream& stream, const WaitSetAttachmentId<S>& self) -> std::ostream&;
 
template <ServiceType S>
class WaitSet {
  public:
    WaitSet(const WaitSet&) = delete;
    auto operator=(const WaitSet&) -> WaitSet& = delete;
    WaitSet(WaitSet&&) noexcept;
    auto operator=(WaitSet&&) noexcept -> WaitSet&;
    ~WaitSet();
 
    auto wait_and_process(const iox2::bb::StaticFunction<CallbackProgression(WaitSetAttachmentId<S>)>& fn_call)
        -> bb::Expected<WaitSetRunResult, WaitSetRunError>;
 
    auto wait_and_process_once(const iox2::bb::StaticFunction<CallbackProgression(WaitSetAttachmentId<S>)>& fn_call)
        -> bb::Expected<WaitSetRunResult, WaitSetRunError>;
 
    auto wait_and_process_once_with_timeout(
        const iox2::bb::StaticFunction<CallbackProgression(WaitSetAttachmentId<S>)>& fn_call,
        iox2::bb::Duration timeout) -> bb::Expected<WaitSetRunResult, WaitSetRunError>;
 
    auto capacity() const -> uint64_t;
 
    auto len() const -> uint64_t;
 
    auto is_empty() const -> bool;
 
    auto attach_notification(const Listener<S>& listener) -> bb::Expected<WaitSetGuard<S>, WaitSetAttachmentError>;
 
    auto attach_notification(const FileDescriptorBased& attachment)
        -> bb::Expected<WaitSetGuard<S>, WaitSetAttachmentError>;
 
    auto attach_deadline(const Listener<S>& listener, iox2::bb::Duration deadline)
        -> bb::Expected<WaitSetGuard<S>, WaitSetAttachmentError>;
 
    auto attach_deadline(const FileDescriptorBased& attachment, iox2::bb::Duration deadline)
        -> bb::Expected<WaitSetGuard<S>, WaitSetAttachmentError>;
 
    auto attach_interval(iox2::bb::Duration deadline) -> bb::Expected<WaitSetGuard<S>, WaitSetAttachmentError>;
 
    auto signal_handling_mode() const -> SignalHandlingMode;
 
  private:
    friend class WaitSetBuilder;
    explicit WaitSet(iox2_waitset_h handle);
    void drop();
 
    iox2_waitset_h m_handle = nullptr;
};
 
class WaitSetBuilder {
  public:
#ifdef DOXYGEN_MACRO_FIX
    auto signal_handling_mode(const SignalHandlingMode value) -> decltype(auto);
#else
    IOX2_BUILDER_OPTIONAL(SignalHandlingMode, signal_handling_mode);
#endif
 
  public:
    WaitSetBuilder();
    ~WaitSetBuilder() = default;
 
    WaitSetBuilder(const WaitSetBuilder&) = delete;
    WaitSetBuilder(WaitSetBuilder&&) = delete;
    auto operator=(const WaitSetBuilder&) -> WaitSetBuilder& = delete;
    auto operator=(WaitSetBuilder&&) -> WaitSetBuilder& = delete;
 
    template <ServiceType S>
    auto create() const&& -> bb::Expected<WaitSet<S>, WaitSetCreateError>;
 
  private:
    iox2_waitset_builder_h m_handle = nullptr;
};
} // namespace iox2
#endif