hmon: rework Rust structure, align interfaces

.vscode/settings.json

@@ -12,6 +12,7 @@
     "rust-analyzer.cargo.features": [
         "stub_supervisor_api_client"
     ],
+    "rust-analyzer.cargo.noDefaultFeatures": true,
     "rust-analyzer.check.command": "clippy",
     "rust-analyzer.rustfmt.overrideCommand": [
         "${workspaceFolder}/.vscode/rustfmt.sh"

examples/cpp_supervised_app/main.cpp

@@ -128,11 +128,17 @@ int main(int argc, char** argv)
     MonitorTag ident("monitor");
 
     {
-        auto hm = HealthMonitorBuilder()
-                      .add_deadline_monitor(ident, std::move(builder_mon))
-                      .with_internal_processing_cycle(std::chrono::milliseconds(50))
-                      .with_supervisor_api_cycle(std::chrono::milliseconds(50))
-                      .build();
+        auto hm_res = HealthMonitorBuilder()
+                          .add_deadline_monitor(ident, std::move(builder_mon))
+                          .with_internal_processing_cycle(std::chrono::milliseconds(50))
+                          .with_supervisor_api_cycle(std::chrono::milliseconds(50))
+                          .build();
+        if (!hm_res.has_value())
+        {
+            std::cerr << "Failed to build health monitor" << std::endl;
+            return EXIT_FAILURE;
+        }
+        auto hm = std::move(*hm_res);
 
         auto deadline_monitor_res = hm.get_deadline_monitor(ident);
         if (!deadline_monitor_res.has_value())
@@ -141,7 +147,13 @@ int main(int argc, char** argv)
             return EXIT_FAILURE;
         }
 
-        hm.start();
+        auto start_res = hm.start();
+        if (!start_res.has_value())
+        {
+            std::cerr << "Failed to start health monitor" << std::endl;
+            return EXIT_FAILURE;
+        }
+
         score::lcm::LifecycleClient{}.ReportExecutionState(score::lcm::ExecutionState::kRunning);
 
         auto deadline_mon = std::move(*deadline_monitor_res);

src/health_monitoring_lib/BUILD

@@ -29,6 +29,7 @@ CC_SOURCES = [
     "cpp/common.cpp",
     "cpp/deadline_monitor.cpp",
     "cpp/heartbeat_monitor.cpp",
+    "cpp/logic_monitor.cpp",
     "cpp/health_monitor.cpp",
 ]
 
@@ -37,6 +38,7 @@ CC_HDRS = [
     "cpp/include/score/hm/tag.h",
     "cpp/include/score/hm/deadline/deadline_monitor.h",
     "cpp/include/score/hm/heartbeat/heartbeat_monitor.h",
+    "cpp/include/score/hm/logic/logic_monitor.h",
     "cpp/include/score/hm/health_monitor.h",
 ]
 

src/health_monitoring_lib/cpp/health_monitor.cpp

@@ -19,6 +19,7 @@ using namespace score::hm;
 using namespace score::hm::internal;
 using namespace score::hm::deadline;
 using namespace score::hm::heartbeat;
+using namespace score::hm::logic;
 
 // Functions below must match functions defined in `crate::ffi`.
 
@@ -34,12 +35,18 @@ FFICode health_monitor_builder_add_deadline_monitor(FFIHandle health_monitor_bui
 FFICode health_monitor_builder_add_heartbeat_monitor(FFIHandle health_monitor_builder_handle,
                                                      const MonitorTag* monitor_tag,
                                                      FFIHandle heartbeat_monitor_builder_handle);
+FFICode health_monitor_builder_add_logic_monitor(FFIHandle health_monitor_builder_handle,
+                                                 const MonitorTag* monitor_tag,
+                                                 FFIHandle logic_monitor_builder_handle);
 FFICode health_monitor_get_deadline_monitor(FFIHandle health_monitor_handle,
                                             const MonitorTag* monitor_tag,
                                             FFIHandle* deadline_monitor_handle_out);
 FFICode health_monitor_get_heartbeat_monitor(FFIHandle health_monitor_handle,
                                              const MonitorTag* monitor_tag,
                                              FFIHandle* heartbeat_monitor_handle_out);
+FFICode health_monitor_get_logic_monitor(FFIHandle health_monitor_handle,
+                                         const MonitorTag* monitor_tag,
+                                         FFIHandle* logic_monitor_handle_out);
 FFICode health_monitor_start(FFIHandle health_monitor_handle);
 FFICode health_monitor_destroy(FFIHandle health_monitor_handle);
 }
@@ -92,6 +99,20 @@ HealthMonitorBuilder HealthMonitorBuilder::add_heartbeat_monitor(const MonitorTa
     return std::move(*this);
 }
 
+HealthMonitorBuilder HealthMonitorBuilder::add_logic_monitor(const MonitorTag& monitor_tag,
+                                                             LogicMonitorBuilder&& monitor) &&
+{
+    auto monitor_handle = monitor.drop_by_rust();
+    SCORE_LANGUAGE_FUTURECPP_PRECONDITION(monitor_handle.has_value());
+    SCORE_LANGUAGE_FUTURECPP_PRECONDITION(health_monitor_builder_handle_.as_rust_handle().has_value());
+
+    auto result{health_monitor_builder_add_logic_monitor(
+        health_monitor_builder_handle_.as_rust_handle().value(), &monitor_tag, monitor_handle.value())};
+    SCORE_LANGUAGE_FUTURECPP_ASSERT(result == kSuccess);
+
+    return std::move(*this);
+}
+
 HealthMonitorBuilder HealthMonitorBuilder::with_internal_processing_cycle(std::chrono::milliseconds cycle_duration) &&
 {
     internal_processing_cycle_duration_ = cycle_duration;
@@ -104,7 +125,7 @@ HealthMonitorBuilder HealthMonitorBuilder::with_supervisor_api_cycle(std::chrono
     return std::move(*this);
 }
 
-HealthMonitor HealthMonitorBuilder::build() &&
+score::cpp::expected<HealthMonitor, Error> HealthMonitorBuilder::build() &&
 {
     auto health_monitor_builder_handle = health_monitor_builder_handle_.drop_by_rust();
     SCORE_LANGUAGE_FUTURECPP_PRECONDITION(health_monitor_builder_handle.has_value());
@@ -115,9 +136,12 @@ HealthMonitor HealthMonitorBuilder::build() &&
     FFIHandle health_monitor_handle{nullptr};
     auto result{health_monitor_builder_build(
         health_monitor_builder_handle.value(), supervisor_duration_ms, internal_duration_ms, &health_monitor_handle)};
-    SCORE_LANGUAGE_FUTURECPP_ASSERT(result == kSuccess);
+    if (result != kSuccess)
+    {
+        return score::cpp::unexpected(static_cast<Error>(result));
+    }
 
-    return HealthMonitor{health_monitor_handle};
+    return score::cpp::expected<HealthMonitor, Error>(HealthMonitor{health_monitor_handle});
 }
 
 HealthMonitor::HealthMonitor(FFIHandle handle) : health_monitor_(handle)
@@ -155,10 +179,27 @@ score::cpp::expected<HeartbeatMonitor, Error> HealthMonitor::get_heartbeat_monit
     return score::cpp::expected<HeartbeatMonitor, Error>(HeartbeatMonitor{handle});
 }
 
-void HealthMonitor::start()
+score::cpp::expected<LogicMonitor, Error> HealthMonitor::get_logic_monitor(const MonitorTag& monitor_tag)
+{
+    FFIHandle handle{nullptr};
+    auto result{health_monitor_get_logic_monitor(health_monitor_, &monitor_tag, &handle)};
+    if (result != kSuccess)
+    {
+        return score::cpp::unexpected(static_cast<Error>(result));
+    }
+
+    return score::cpp::expected<LogicMonitor, Error>(LogicMonitor{handle});
+}
+
+score::cpp::expected_blank<Error> HealthMonitor::start()
 {
     auto result{health_monitor_start(health_monitor_)};
-    SCORE_LANGUAGE_FUTURECPP_ASSERT(result == kSuccess);
+    if (result != kSuccess)
+    {
+        return score::cpp::unexpected(static_cast<Error>(result));
+    }
+
+    return score::cpp::expected_blank<Error>{};
 }
 
 HealthMonitor::~HealthMonitor()

src/health_monitoring_lib/cpp/include/score/hm/health_monitor.h

@@ -16,6 +16,7 @@
 #include <score/hm/common.h>
 #include <score/hm/deadline/deadline_monitor.h>
 #include <score/hm/heartbeat/heartbeat_monitor.h>
+#include <score/hm/logic/logic_monitor.h>
 #include <score/hm/tag.h>
 
 namespace score::hm
@@ -47,6 +48,9 @@ class HealthMonitorBuilder final
     HealthMonitorBuilder add_heartbeat_monitor(const MonitorTag& monitor_tag,
                                                heartbeat::HeartbeatMonitorBuilder&& monitor) &&;
 
+    /// Adds a logic monitor for a specific identifier tag.
+    HealthMonitorBuilder add_logic_monitor(const MonitorTag& monitor_tag, logic::LogicMonitorBuilder&& monitor) &&;
+
     /// Sets the cycle duration for supervisor API notifications.
     /// This duration determines how often the health monitor notifies the supervisor that the system is alive.
     HealthMonitorBuilder with_supervisor_api_cycle(std::chrono::milliseconds cycle_duration) &&;
@@ -56,7 +60,7 @@ class HealthMonitorBuilder final
     HealthMonitorBuilder with_internal_processing_cycle(std::chrono::milliseconds cycle_duration) &&;
 
     /// Build a new `HealthMonitor` instance based on provided parameters.
-    HealthMonitor build() &&;
+    score::cpp::expected<HealthMonitor, Error> build() &&;
 
   private:
     internal::DroppableFFIHandle health_monitor_builder_handle_;
@@ -78,8 +82,9 @@ class HealthMonitor final
 
     score::cpp::expected<deadline::DeadlineMonitor, Error> get_deadline_monitor(const MonitorTag& monitor_tag);
     score::cpp::expected<heartbeat::HeartbeatMonitor, Error> get_heartbeat_monitor(const MonitorTag& monitor_tag);
+    score::cpp::expected<logic::LogicMonitor, Error> get_logic_monitor(const MonitorTag& monitor_tag);
 
-    void start();
+    score::cpp::expected_blank<Error> start();
 
   private:
     // Allow only the builder to create HealthMonitor instances.

src/health_monitoring_lib/cpp/include/score/hm/logic/logic_monitor.h

@@ -0,0 +1,91 @@
+/********************************************************************************
+ * Copyright (c) 2026 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 License Version 2.0 which is available at
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ ********************************************************************************/
+#ifndef SCORE_HM_LOGIC_LOGIC_MONITOR_H
+#define SCORE_HM_LOGIC_LOGIC_MONITOR_H
+
+#include "score/hm/common.h"
+#include "score/hm/tag.h"
+#include <score/expected.hpp>
+#include <vector>
+
+namespace score::hm
+{
+// Forward declaration
+class HealthMonitor;
+class HealthMonitorBuilder;
+}  // namespace score::hm
+
+namespace score::hm::logic
+{
+
+class LogicMonitorBuilder final : public internal::RustDroppable<LogicMonitorBuilder>
+{
+  public:
+    /// Create a new `LogicMonitorBuilder`.
+    ///
+    /// - `initial_state` - starting point.
+    LogicMonitorBuilder(const StateTag& initial_state);
+
+    LogicMonitorBuilder(const LogicMonitorBuilder&) = delete;
+    LogicMonitorBuilder& operator=(const LogicMonitorBuilder&) = delete;
+
+    LogicMonitorBuilder(LogicMonitorBuilder&&) = default;
+    LogicMonitorBuilder& operator=(LogicMonitorBuilder&&) = delete;
+
+    /// Add state along with allowed transitions.
+    /// If state already exist - it is overwritten.
+    LogicMonitorBuilder add_state(const StateTag& state, const std::vector<StateTag>& allowed_states) &&;
+
+  protected:
+    std::optional<internal::FFIHandle> _drop_by_rust_impl()
+    {
+        return monitor_builder_handle_.drop_by_rust();
+    }
+
+  private:
+    internal::DroppableFFIHandle monitor_builder_handle_;
+
+    // Allow to hide drop_by_rust implementation
+    friend class internal::RustDroppable<LogicMonitorBuilder>;
+
+    // Allow HealthMonitorBuilder to access drop_by_rust implementation
+    friend class ::score::hm::HealthMonitorBuilder;
+};
+
+class LogicMonitor final
+{
+  public:
+    LogicMonitor(const LogicMonitor&) = delete;
+    LogicMonitor& operator=(const LogicMonitor&) = delete;
+
+    LogicMonitor(LogicMonitor&& other) noexcept = default;
+    LogicMonitor& operator=(LogicMonitor&& other) noexcept = default;
+
+    /// Perform transition to a new state.
+    /// On success, current state is returned.
+    score::cpp::expected<StateTag, Error> transition(const StateTag& state);
+
+    /// Current monitor state.
+    score::cpp::expected<StateTag, Error> state();
+
+  private:
+    explicit LogicMonitor(internal::FFIHandle monitor_handle);
+
+    // Only `HealthMonitor` is allowed to create `LogicMonitor` instances.
+    friend class score::hm::HealthMonitor;
+    internal::DroppableFFIHandle monitor_handle_;
+};
+
+}  // namespace score::hm::logic
+
+#endif  // SCORE_HM_LOGIC_LOGIC_MONITOR_H

src/health_monitoring_lib/cpp/include/score/hm/tag.h

@@ -23,6 +23,9 @@ namespace score::hm
 class Tag
 {
   public:
+    /// Create an empty tag.
+    Tag() : data_{nullptr}, length_{0} {}
+
     /// Create a new tag from a C-style string.
     template <size_t N>
     explicit Tag(const char (&tag)[N]) : data_(tag), length_(N - 1)
@@ -49,6 +52,13 @@ class DeadlineTag : public Tag
     using Tag::Tag;
 };
 
+/// State tag.
+class StateTag : public Tag
+{
+  public:
+    using Tag::Tag;
+};
+
 }  // namespace score::hm
 
 #endif  // SCORE_HM_TAG_H