config.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_CONFIG_HPP
#define IOX2_CONFIG_HPP
 
#include "iox2/backpressure_strategy.hpp"
#include "iox2/bb/duration.hpp"
#include "iox2/bb/expected.hpp"
#include "iox2/bb/file_name.hpp"
#include "iox2/bb/optional.hpp"
#include "iox2/bb/path.hpp"
#include "iox2/config_creation_error.hpp"
#include "iox2/internal/iceoryx2.hpp"
 
namespace iox2 {
class Config;
class NodeBuilder;
 
namespace config {
class Global;
 
class Node {
  public:
    auto directory() && -> const char*;
    void set_directory(const iox2::bb::Path& value) &&;
    auto monitor_suffix() && -> const char*;
    void set_monitor_suffix(const iox2::bb::FileName& value) &&;
    auto global_mgmt_suffix() && -> const char*;
    void set_global_mgmt_suffix(const iox2::bb::FileName& value) &&;
    auto static_config_suffix() && -> const char*;
    void set_static_config_suffix(const iox2::bb::FileName& value) &&;
    auto port_tag_suffix() && -> const char*;
    void set_port_tag_suffix(const iox2::bb::FileName& value) &&;
    auto service_tag_suffix() && -> const char*;
    void set_service_tag_suffix(const iox2::bb::FileName& value) &&;
    auto cleanup_dead_nodes_on_creation() && -> bool;
    void set_cleanup_dead_nodes_on_creation(bool value) &&;
    auto cleanup_dead_nodes_on_destruction() && -> bool;
    void set_cleanup_dead_nodes_on_destruction(bool value) &&;
 
  private:
    friend class Global;
    explicit Node(iox2_config_h* config);
 
    iox2_config_h* m_config = nullptr;
};
 
class Service {
  public:
    auto flatbuffer_schema_path() && -> bb::Optional<const char*>;
    void set_flatbuffer_schema_path(bb::Optional<bb::Path> value) &&;
    auto directory() && -> const char*;
    void set_directory(const iox2::bb::Path& value) &&;
    auto data_segment_suffix() && -> const char*;
    void set_data_segment_suffix(const iox2::bb::FileName& value) &&;
    auto static_config_storage_suffix() && -> const char*;
    void set_static_config_storage_suffix(const iox2::bb::FileName& value) &&;
    auto dynamic_config_storage_suffix() && -> const char*;
    void set_dynamic_config_storage_suffix(const iox2::bb::FileName& value) &&;
    auto connection_suffix() && -> const char*;
    void set_connection_suffix(const iox2::bb::FileName& value) &&;
    auto event_connection_suffix() && -> const char*;
    void set_event_connection_suffix(const iox2::bb::FileName& value) &&;
    auto cleanup_dead_nodes_on_open() && -> bool;
    void set_cleanup_dead_nodes_on_open(bool value) &&;
 
  private:
    friend class Global;
    explicit Service(iox2_config_h* config);
 
    iox2_config_h* m_config = nullptr;
};
 
class Global {
  public:
    auto prefix() && -> const char*;
    void set_prefix(const iox2::bb::FileName& value) &&;
    auto root_path() && -> const char*;
    void set_root_path(const iox2::bb::Path& value) &&;
    auto creation_timeout() && -> iox2::bb::Duration;
    void set_creation_timeout(const iox2::bb::Duration& value) &&;
 
    auto service() -> Service;
 
    auto node() -> Node;
 
  private:
    friend class ::iox2::Config;
    explicit Global(iox2_config_h* config);
 
    iox2_config_h* m_config = nullptr;
};
 
class PublishSubscribe {
  public:
    auto max_subscribers() && -> size_t;
    void set_max_subscribers(size_t value) &&;
    auto max_publishers() && -> size_t;
    void set_max_publishers(size_t value) &&;
    auto max_nodes() && -> size_t;
    void set_max_nodes(size_t value) &&;
    auto subscriber_max_buffer_size() && -> size_t;
    void set_subscriber_max_buffer_size(size_t value) &&;
    auto subscriber_max_borrowed_samples() && -> size_t;
    void set_subscriber_max_borrowed_samples(size_t value) &&;
    auto publisher_max_loaned_samples() && -> size_t;
    void set_publisher_max_loaned_samples(size_t value) &&;
    auto publisher_history_size() && -> size_t;
    void set_publisher_history_size(size_t value) &&;
    auto enable_safe_overflow() && -> bool;
    void set_enable_safe_overflow(bool value) &&;
    auto backpressure_strategy() && -> BackpressureStrategy;
    void set_backpressure_strategy(BackpressureStrategy value) &&;
    auto subscriber_expired_connection_buffer() && -> size_t;
    void set_subscriber_expired_connection_buffer(size_t value) &&;
 
  private:
    friend class Defaults;
    explicit PublishSubscribe(iox2_config_h* config);
 
    iox2_config_h* m_config = nullptr;
};
 
class Event {
  public:
    auto max_listeners() && -> size_t;
    void set_max_listeners(size_t value) &&;
    auto max_notifiers() && -> size_t;
    void set_max_notifiers(size_t value) &&;
    auto max_nodes() && -> size_t;
    void set_max_nodes(size_t value) &&;
    auto event_id_max_value() && -> size_t;
    void set_event_id_max_value(size_t value) &&;
    auto notifier_created_event() && -> bb::Optional<size_t>;
    void set_notifier_created_event(bb::Optional<size_t> value) &&;
    auto notifier_dropped_event() && -> bb::Optional<size_t>;
    void set_notifier_dropped_event(bb::Optional<size_t> value) &&;
    auto notifier_dead_event() && -> bb::Optional<size_t>;
    void set_notifier_dead_event(bb::Optional<size_t> value) &&;
    auto deadline() && -> bb::Optional<iox2::bb::Duration>;
    void set_deadline(bb::Optional<iox2::bb::Duration> deadline) &&;
 
  private:
    friend class Defaults;
    explicit Event(iox2_config_h* config);
 
    iox2_config_h* m_config = nullptr;
};
 
class RequestResponse {
  public:
    auto enable_safe_overflow_for_requests() && -> bool;
    void set_enable_safe_overflow_for_requests(bool value) &&;
    auto enable_safe_overflow_for_responses() && -> bool;
    void set_enable_safe_overflow_for_responses(bool value) &&;
    auto max_active_requests_per_client() && -> size_t;
    void set_max_active_requests_per_client(size_t value) &&;
    auto max_response_buffer_size() && -> size_t;
    void set_max_response_buffer_size(size_t value) &&;
    auto max_servers() && -> size_t;
    void set_max_servers(size_t value) &&;
    auto max_clients() && -> size_t;
    void set_max_clients(size_t value) &&;
    auto max_nodes() && -> size_t;
    void set_max_nodes(size_t value) &&;
    auto max_borrowed_responses_per_pending_response() && -> size_t;
    void set_max_borrowed_responses_per_pending_response(size_t value) &&;
    auto max_loaned_requests() && -> size_t;
    void set_max_loaned_requests(size_t value) &&;
    auto server_max_loaned_responses_per_request() && -> size_t;
    void set_server_max_loaned_responses_per_request(size_t value) &&;
    auto client_backpressure_strategy() && -> BackpressureStrategy;
    void set_client_backpressure_strategy(BackpressureStrategy value) &&;
    auto server_backpressure_strategy() && -> BackpressureStrategy;
    void set_server_backpressure_strategy(BackpressureStrategy value) &&;
    auto client_expired_connection_buffer() && -> size_t;
    void set_client_expired_connection_buffer(size_t value) &&;
    auto server_expired_connection_buffer() && -> size_t;
    void set_server_expired_connection_buffer(size_t value) &&;
    auto enable_fire_and_forget_requests() && -> bool;
    void set_enable_fire_and_forget_requests(bool value) &&;
 
  private:
    friend class Defaults;
    explicit RequestResponse(iox2_config_h* config);
 
    iox2_config_h* m_config = nullptr;
};
 
class Blackboard {
  public:
    auto max_readers() && -> size_t;
    void set_max_readers(size_t value) &&;
    auto max_nodes() && -> size_t;
    void set_max_nodes(size_t value) &&;
 
  private:
    friend class Defaults;
    explicit Blackboard(iox2_config_h* config);
 
    iox2_config_h* m_config = nullptr;
};
 
class Defaults {
  public:
    auto publish_subscribe() && -> PublishSubscribe;
    auto event() && -> Event;
    auto request_response() && -> RequestResponse;
    auto blackboard() && -> Blackboard;
 
  private:
    friend class ::iox2::Config;
    explicit Defaults(iox2_config_h* config);
 
    iox2_config_h* m_config = nullptr;
};
} // namespace config
 
class ConfigView {
  public:
    ConfigView(const ConfigView&) = default;
    ConfigView(ConfigView&&) = default;
    auto operator=(const ConfigView&) -> ConfigView& = default;
    auto operator=(ConfigView&&) -> ConfigView& = default;
    ~ConfigView() = default;
 
    auto to_owned() const -> Config;
 
  private:
    friend class Config;
    template <ServiceType>
    friend class Node;
    template <typename, typename, ServiceType>
    friend class ServiceBuilderPublishSubscribe;
 
    template <ServiceType>
    friend class Service;
 
    explicit ConfigView(iox2_config_ptr ptr);
    iox2_config_ptr m_ptr = nullptr;
};
 
class Config {
  public:
    Config();
    Config(const Config& rhs);
    Config(Config&& rhs) noexcept;
    ~Config();
 
    auto operator=(const Config& rhs) -> Config&;
    auto operator=(Config&& rhs) noexcept -> Config&;
 
    static auto from_file(const iox2::bb::FilePath& file) -> iox2::bb::Expected<Config, ConfigCreationError>;
 
    static auto setup_global_config_from_file(const iox2::bb::FilePath& file)
        -> iox2::bb::Expected<ConfigView, ConfigCreationError>;
 
    auto global() -> config::Global;
    auto defaults() -> config::Defaults;
 
    static auto global_config() -> ConfigView;
 
    auto view() -> ConfigView;
 
  private:
    friend class ConfigView;
    friend class config::Global;
    friend class NodeBuilder;
    template <ServiceType>
    friend class DeadNodeView;
 
    explicit Config(iox2_config_h handle);
    void drop();
 
    iox2_config_h m_handle = nullptr;
};
} // namespace iox2
 
#endif