[#264] address last IOX_TODOs in C++ language binding

.github/workflows/build-test.yml

@@ -121,7 +121,7 @@ jobs:
   static-code-analysis-cpp:
     needs: preflight-check
     if: ${{ needs.changes.outputs.source-code == 'true' }}
-    timeout-minutes: 10
+    timeout-minutes: 20
     runs-on: ubuntu-latest
     steps:
       - name: Checkout sources

doc/release-notes/iceoryx2-unreleased.md

@@ -11,6 +11,8 @@
     conflicts when merging.
 -->
 
+* Full C/C++ Language bindings for all features
+    [#264](https://github.com/eclipse-iceoryx/iceoryx2/issues/264)
 * Read LogLevel from environment variable
     [#396](https://github.com/eclipse-iceoryx/iceoryx2/issues/396)
 * Lookup config file in default locations

iceoryx2-ffi/cxx/CMakeLists.txt

@@ -41,6 +41,8 @@ add_library(iceoryx2-cxx-object-lib OBJECT
     src/attribute_specifier.cpp
     src/attribute_verifier.cpp
     src/config.cpp
+    src/dynamic_config_event.cpp
+    src/dynamic_config_publish_subscribe.cpp
     src/event_id.cpp
     src/file_descriptor.cpp
     src/header_publish_subscribe.cpp
@@ -59,6 +61,7 @@ add_library(iceoryx2-cxx-object-lib OBJECT
     src/port_factory_notifier.cpp
     src/service.cpp
     src/service_builder_event.cpp
+    src/service_id.cpp
     src/service_name.cpp
     src/static_config.cpp
     src/static_config_event.cpp

iceoryx2-ffi/cxx/include/iox2/attribute_set.hpp

@@ -20,6 +20,8 @@
 #include <iostream>
 
 namespace iox2 {
+class AttributeSet;
+
 /// Represents all service attributes. They can be set when the service is created.
 ///
 /// @attention The parent from which the view was extracted MUST live longer than the
@@ -49,20 +51,69 @@ class AttributeSetView {
     void get_key_values(const Attribute::Key& key,
                         const iox::function<CallbackProgression(const Attribute::Value&)>& callback) const;
 
+    /// Creates a copy of the [`AttributeSetView`] that owns the attributes.
+    auto to_owned() const -> AttributeSet;
+
   private:
     template <ServiceType, typename, typename>
     friend class PortFactoryPublishSubscribe;
     template <ServiceType>
     friend class PortFactoryEvent;
     friend class AttributeVerifier;
     friend class AttributeSpecifier;
+    friend class StaticConfig;
+    friend class AttributeSet;
 
-    explicit AttributeSetView(iox2_attribute_set_h_ref handle);
+    explicit AttributeSetView(iox2_attribute_set_ptr handle);
 
-    iox2_attribute_set_h_ref m_handle = nullptr;
+    iox2_attribute_set_ptr m_handle = nullptr;
 };
+
+/// Represents all service attributes. They can be set when the service is created.
+class AttributeSet {
+  public:
+    AttributeSet(const AttributeSet&) = delete;
+    AttributeSet(AttributeSet&& rhs) noexcept;
+    auto operator=(const AttributeSet&) -> AttributeSet& = delete;
+    auto operator=(AttributeSet&& rhs) noexcept -> AttributeSet&;
+    ~AttributeSet();
+
+    /// Returns the number of [`Attribute`]s stored inside the [`AttributeSet`].
+    auto len() const -> uint64_t;
+
+    /// Returns a [`AttributeView`] at a specific index. The number of indices is returned via
+    /// [`AttributeSet::len()`].
+    auto at(uint64_t index) const -> AttributeView;
+
+    /// Returns the number of values stored under a specific key. If the key does not exist it
+    /// returns 0.
+    auto get_key_value_len(const Attribute::Key& key) const -> uint64_t;
+
+    /// Returns a value of a key at a specific index. The index enumerates the values of the key
+    /// if the key has multiple values. The values are always stored at the same position during
+    /// the lifetime of the service but they can change when the process is recreated by another
+    /// process when the system restarts.
+    /// If the key does not exist or it does not have a value at the specified index, it returns
+    /// [`None`].
+    auto get_key_value_at(const Attribute::Key& key, uint64_t idx) -> iox::optional<Attribute::Value>;
+
+    /// Returns all values to a specific key
+    void get_key_values(const Attribute::Key& key,
+                        const iox::function<CallbackProgression(const Attribute::Value&)>& callback) const;
+
+  private:
+    friend class AttributeSetView;
+
+    explicit AttributeSet(iox2_attribute_set_h handle);
+    void drop();
+
+    iox2_attribute_set_h m_handle = nullptr;
+    AttributeSetView m_view;
+};
+
 } // namespace iox2
 
 auto operator<<(std::ostream& stream, const iox2::AttributeSetView& value) -> std::ostream&;
+auto operator<<(std::ostream& stream, const iox2::AttributeSet& value) -> std::ostream&;
 
 #endif

iceoryx2-ffi/cxx/include/iox2/dynamic_config_event.hpp

@@ -13,19 +13,32 @@
 #ifndef IOX2_DYNAMIC_CONFIG_EVENT_HPP
 #define IOX2_DYNAMIC_CONFIG_EVENT_HPP
 
-#include "iox/assertions_addendum.hpp"
+#include "iox2/internal/iceoryx2.hpp"
 
 #include <cstdint>
 
 namespace iox2 {
 class DynamicConfigEvent {
   public:
-    auto number_of_listeners() const -> uint64_t {
-        IOX_TODO();
-    }
-    auto number_of_notifiers() const -> uint64_t {
-        IOX_TODO();
-    }
+    DynamicConfigEvent(const DynamicConfigEvent&) = delete;
+    DynamicConfigEvent(DynamicConfigEvent&&) = delete;
+    auto operator=(const DynamicConfigEvent&) -> DynamicConfigEvent& = delete;
+    auto operator=(DynamicConfigEvent&&) -> DynamicConfigEvent& = delete;
+    ~DynamicConfigEvent() = default;
+
+    /// Returns how many [`Listener`] ports are currently connected.
+    auto number_of_listeners() const -> uint64_t;
+
+    /// Returns how many [`Notifier`] ports are currently connected.
+    auto number_of_notifiers() const -> uint64_t;
+
+  private:
+    template <ServiceType>
+    friend class PortFactoryEvent;
+
+    explicit DynamicConfigEvent(iox2_port_factory_event_h handle);
+
+    iox2_port_factory_event_h m_handle = nullptr;
 };
 } // namespace iox2
 

iceoryx2-ffi/cxx/include/iox2/dynamic_config_publish_subscribe.hpp

@@ -13,19 +13,36 @@
 #ifndef IOX2_DYNAMIC_CONFIG_PUBLISH_SUBSCRIBE_HPP
 #define IOX2_DYNAMIC_CONFIG_PUBLISH_SUBSCRIBE_HPP
 
-#include "iox/assertions_addendum.hpp"
+#include "iox2/internal/iceoryx2.hpp"
 
 #include <cstdint>
 
 namespace iox2 {
+
+/// The dynamic configuration of an
+/// [`MessagingPattern::PublishSubscribe`] based service. Contains dynamic
+/// parameters like the connected endpoints etc..
 class DynamicConfigPublishSubscribe {
   public:
-    auto number_of_publishers() const -> uint64_t {
-        IOX_TODO();
-    }
-    auto number_of_subscribers() const -> uint64_t {
-        IOX_TODO();
-    }
+    DynamicConfigPublishSubscribe(const DynamicConfigPublishSubscribe&) = delete;
+    DynamicConfigPublishSubscribe(DynamicConfigPublishSubscribe&&) = delete;
+    auto operator=(const DynamicConfigPublishSubscribe&) -> DynamicConfigPublishSubscribe& = delete;
+    auto operator=(DynamicConfigPublishSubscribe&&) -> DynamicConfigPublishSubscribe& = delete;
+    ~DynamicConfigPublishSubscribe() = default;
+
+    /// Returns how many [`Publisher`] ports are currently connected.
+    auto number_of_publishers() const -> uint64_t;
+
+    /// Returns how many [`Subscriber`] ports are currently connected.
+    auto number_of_subscribers() const -> uint64_t;
+
+  private:
+    template <ServiceType, typename, typename>
+    friend class PortFactoryPublishSubscribe;
+
+    explicit DynamicConfigPublishSubscribe(iox2_port_factory_pub_sub_h handle);
+
+    iox2_port_factory_pub_sub_h m_handle = nullptr;
 };
 } // namespace iox2
 

iceoryx2-ffi/cxx/include/iox2/internal/callback_context.hpp

@@ -13,7 +13,33 @@
 #ifndef IOX2_INTERNAL_CALLBACK_CONTEXT_HPP
 #define IOX2_INTERNAL_CALLBACK_CONTEXT_HPP
 
+#include "iox/optional.hpp"
+#include "iox2/internal/iceoryx2.hpp"
+#include "iox2/node_details.hpp"
+#include "iox2/node_id.hpp"
+#include "iox2/node_name.hpp"
+#include "iox2/node_state.hpp"
+#include "iox2/service_type.hpp"
+
 namespace iox2::internal {
+
+/// Building block to provide a type-safe context pointer to a C callback
+/// that has a `void*` context argument.
+/// The context could be hereby a user provided clojure with capture or
+/// any other C++ object.
+///
+/// # Example
+///
+/// ```
+/// void some_c_callback(void* context) {
+///    auto ctx = internal::ctx_cast<SomeType>(context);
+///    ctx->value(); // access underlying my_context_object
+/// }
+///
+/// SomeType my_context_object;
+/// auto ctx = internal::ctx(my_context_object);
+/// some_c_callback(static_cast<void*>(&ctx));
+/// ```
 template <typename T>
 class CallbackContext {
   public:
@@ -30,14 +56,59 @@ class CallbackContext {
 };
 
 template <typename T>
-auto ctx(const T& ptr) -> CallbackContext<T> {
+inline auto ctx(const T& ptr) -> CallbackContext<T> {
     return CallbackContext<T>(ptr);
 }
 
 template <typename T>
-auto ctx_cast(void* ptr) -> CallbackContext<T>* {
+inline auto ctx_cast(void* ptr) -> CallbackContext<T>* {
     return static_cast<CallbackContext<T>*>(ptr);
 }
+
+template <ServiceType T>
+// NOLINTBEGIN(readability-function-size)
+auto list_callback(iox2_node_state_e node_state,
+                   iox2_node_id_ptr node_id_ptr,
+                   const char* executable,
+                   iox2_node_name_ptr node_name,
+                   iox2_config_ptr config,
+                   iox2_callback_context context) -> iox2_callback_progression_e {
+    auto node_details = [&] {
+        if (node_id_ptr == nullptr || config == nullptr) {
+            return iox::optional<NodeDetails>();
+        }
+
+        return iox::optional<NodeDetails>(NodeDetails {
+            iox::FileName::create(iox::string<iox::FileName::capacity()>(iox::TruncateToCapacity, executable))
+                .expect("The executable file name is always valid."),
+            NodeNameView { node_name }.to_owned(),
+            Config {} });
+    }();
+
+    iox2_node_id_h node_id_handle = nullptr;
+    iox2_node_id_clone_from_ptr(nullptr, node_id_ptr, &node_id_handle);
+    NodeId node_id { node_id_handle };
+
+    auto node_state_object = [&] {
+        switch (node_state) {
+        case iox2_node_state_e_ALIVE:
+            return NodeState<T> { AliveNodeView<T> { node_id, node_details } };
+        case iox2_node_state_e_DEAD:
+            return NodeState<T> { DeadNodeView<T> { AliveNodeView<T> { node_id, node_details } } };
+        case iox2_node_state_e_UNDEFINED:
+            return NodeState<T> { iox2_node_state_e_UNDEFINED, node_id };
+        case iox2_node_state_e_INACCESSIBLE:
+            return NodeState<T> { iox2_node_state_e_INACCESSIBLE, node_id };
+        }
+
+        IOX_UNREACHABLE();
+    }();
+
+    auto* callback = internal::ctx_cast<iox::function<CallbackProgression(NodeState<T>)>>(context);
+    return iox::into<iox2_callback_progression_e>(callback->value()(node_state_object));
+}
+// NOLINTEND(readability-function-size)
+
 } // namespace iox2::internal
 
 #endif

iceoryx2-ffi/cxx/include/iox2/node_details.hpp

@@ -30,12 +30,12 @@ class NodeDetails {
 
   private:
     template <ServiceType>
-    friend auto list_callback(iox2_node_state_e,
-                              iox2_node_id_ptr,
-                              const char* executable,
-                              iox2_node_name_ptr,
-                              iox2_config_ptr,
-                              iox2_callback_context) -> iox2_callback_progression_e;
+    friend auto internal::list_callback(iox2_node_state_e,
+                                        iox2_node_id_ptr,
+                                        const char* executable,
+                                        iox2_node_name_ptr,
+                                        iox2_config_ptr,
+                                        iox2_callback_context) -> iox2_callback_progression_e;
 
     NodeDetails(iox::FileName executable, NodeName name, Config config);
 

iceoryx2-ffi/cxx/include/iox2/node_id.hpp

@@ -21,6 +21,13 @@
 #include <iostream>
 
 namespace iox2 {
+namespace internal {
+template <ServiceType>
+auto list_callback(
+    iox2_node_state_e, iox2_node_id_ptr, const char*, iox2_node_name_ptr, iox2_config_ptr, iox2_callback_context)
+    -> iox2_callback_progression_e;
+}
+
 /// The system-wide unique id of a [`Node`]
 class NodeId {
   public:
@@ -48,11 +55,10 @@ class NodeId {
     template <ServiceType>
     friend class DeadNodeView;
     template <ServiceType>
-    friend auto list_callback(
+    friend auto internal::list_callback(
         iox2_node_state_e, iox2_node_id_ptr, const char*, iox2_node_name_ptr, iox2_config_ptr, iox2_callback_context)
         -> iox2_callback_progression_e;
 
-
     explicit NodeId(iox2_node_id_h handle);
     void drop();
 

iceoryx2-ffi/cxx/include/iox2/node_name.hpp

@@ -19,6 +19,15 @@
 #include "iox2/semantic_string.hpp"
 
 namespace iox2 {
+namespace internal {
+template <ServiceType>
+auto list_callback(iox2_node_state_e,
+                   iox2_node_id_ptr,
+                   const char* executable,
+                   iox2_node_name_ptr,
+                   iox2_config_ptr,
+                   iox2_callback_context) -> iox2_callback_progression_e;
+}
 class NodeName;
 
 /// Non-owning view of a [`NodeName`].
@@ -41,12 +50,12 @@ class NodeNameView {
     friend class Node;
     friend class NodeName;
     template <ServiceType>
-    friend auto list_callback(iox2_node_state_e,
-                              iox2_node_id_ptr,
-                              const char* executable,
-                              iox2_node_name_ptr,
-                              iox2_config_ptr,
-                              iox2_callback_context) -> iox2_callback_progression_e;
+    friend auto internal::list_callback(iox2_node_state_e,
+                                        iox2_node_id_ptr,
+                                        const char* executable,
+                                        iox2_node_name_ptr,
+                                        iox2_config_ptr,
+                                        iox2_callback_context) -> iox2_callback_progression_e;
 
     explicit NodeNameView(iox2_node_name_ptr ptr);
     iox2_node_name_ptr m_ptr = nullptr;

iceoryx2-ffi/cxx/include/iox2/node_state.hpp

@@ -102,7 +102,7 @@ class NodeState {
 
   private:
     template <ServiceType>
-    friend auto list_callback(
+    friend auto internal::list_callback(
         iox2_node_state_e, iox2_node_id_ptr, const char*, iox2_node_name_ptr, iox2_config_ptr, iox2_callback_context)
         -> iox2_callback_progression_e;