hmon: add C++ interface to logic monitor

.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"

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;
@@ -155,6 +176,18 @@ score::cpp::expected<HeartbeatMonitor, Error> HealthMonitor::get_heartbeat_monit
     return score::cpp::expected<HeartbeatMonitor, Error>(HeartbeatMonitor{handle});
 }
 
+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});
+}
+
 void HealthMonitor::start()
 {
     auto result{health_monitor_start(health_monitor_)};

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) &&;
@@ -78,6 +82,7 @@ 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();
 

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

src/health_monitoring_lib/cpp/logic_monitor.cpp

@@ -0,0 +1,94 @@
+/********************************************************************************
+ * 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
+ ********************************************************************************/
+#include "score/hm/logic/logic_monitor.h"
+#include <score/assert.hpp>
+
+namespace
+{
+extern "C" {
+using namespace score::hm;
+using namespace score::hm::internal;
+using namespace score::hm::logic;
+
+FFICode logic_monitor_builder_create(const StateTag* initial_state, FFIHandle* logic_monitor_builder_handle_out);
+FFICode logic_monitor_builder_destroy(FFIHandle logic_monitor_builder_handle);
+FFICode logic_monitor_builder_add_state(FFIHandle logic_monitor_builder_handle,
+                                        const StateTag* state,
+                                        const StateTag* allowed_states,
+                                        size_t num_allowed_states);
+FFICode logic_monitor_destroy(FFIHandle logic_monitor_handle);
+FFICode logic_monitor_transition(FFIHandle logic_monitor_handle, const StateTag* target_state);
+FFICode logic_monitor_state(FFIHandle logic_monitor_handle, StateTag* state_out);
+}
+
+FFIHandle logic_monitor_builder_create_wrapper(const StateTag& initial_state)
+{
+    FFIHandle handle{nullptr};
+    auto result{logic_monitor_builder_create(&initial_state, &handle)};
+    SCORE_LANGUAGE_FUTURECPP_ASSERT(result == kSuccess);
+    return handle;
+}
+}  // namespace
+
+namespace score::hm::logic
+{
+LogicMonitorBuilder::LogicMonitorBuilder(const StateTag& initial_state)
+    : monitor_builder_handle_{logic_monitor_builder_create_wrapper(initial_state), &logic_monitor_builder_destroy}
+{
+}
+
+LogicMonitorBuilder LogicMonitorBuilder::add_state(const StateTag& state,
+                                                   const std::vector<StateTag>& allowed_states) &&
+{
+    auto monitor_builder_handle{monitor_builder_handle_.as_rust_handle()};
+    SCORE_LANGUAGE_FUTURECPP_PRECONDITION(monitor_builder_handle.has_value());
+
+    auto result{logic_monitor_builder_add_state(
+        monitor_builder_handle.value(), &state, allowed_states.data(), allowed_states.size())};
+    SCORE_LANGUAGE_FUTURECPP_ASSERT(result == kSuccess);
+
+    return std::move(*this);
+}
+
+LogicMonitor::LogicMonitor(FFIHandle monitor_handle) : monitor_handle_{monitor_handle, &logic_monitor_destroy} {}
+
+score::cpp::expected<StateTag, Error> LogicMonitor::transition(const StateTag& state)
+{
+    auto monitor_handle{monitor_handle_.as_rust_handle()};
+    SCORE_LANGUAGE_FUTURECPP_PRECONDITION(monitor_handle.has_value());
+
+    auto result{logic_monitor_transition(monitor_handle.value(), &state)};
+    if (result != kSuccess)
+    {
+        return score::cpp::unexpected(static_cast<Error>(result));
+    }
+
+    return score::cpp::expected<StateTag, Error>(state);
+}
+
+score::cpp::expected<StateTag, Error> LogicMonitor::state()
+{
+    auto monitor_handle{monitor_handle_.as_rust_handle()};
+    SCORE_LANGUAGE_FUTURECPP_PRECONDITION(monitor_handle.has_value());
+
+    StateTag state_tag;
+    auto result{logic_monitor_state(monitor_handle.value(), &state_tag)};
+    if (result != kSuccess)
+    {
+        return score::cpp::unexpected(static_cast<Error>(result));
+    }
+
+    return score::cpp::expected<StateTag, Error>(state_tag);
+}
+
+}  // namespace score::hm::logic

src/health_monitoring_lib/cpp/tests/health_monitor_test.cpp

@@ -49,9 +49,17 @@ TEST_F(HealthMonitorTest, TestName)
     const TimeRange heartbeat_range{std::chrono::milliseconds{100}, std::chrono::milliseconds{200}};
     auto heartbeat_monitor_builder = heartbeat::HeartbeatMonitorBuilder(heartbeat_range);
 
+    // Setup logic monitor construction.
+    const MonitorTag logic_monitor_tag{"logic_monitor"};
+    StateTag from_state{"from_state"};
+    StateTag to_state{"to_state"};
+    auto logic_monitor_builder =
+        logic::LogicMonitorBuilder{from_state}.add_state(from_state, std::vector{to_state}).add_state(to_state, {});
+
     auto hm = HealthMonitorBuilder()
                   .add_deadline_monitor(deadline_monitor_tag, std::move(deadline_monitor_builder))
                   .add_heartbeat_monitor(heartbeat_monitor_tag, std::move(heartbeat_monitor_builder))
+                  .add_logic_monitor(logic_monitor_tag, std::move(logic_monitor_builder))
                   .with_internal_processing_cycle(std::chrono::milliseconds(50))
                   .with_supervisor_api_cycle(std::chrono::milliseconds(50))
                   .build();
@@ -80,11 +88,25 @@ TEST_F(HealthMonitorTest, TestName)
 
     auto heartbeat_monitor{std::move(*heartbeat_monitor_res)};
 
+    // Obtain logic monitor from HMON.
+    auto logic_monitor_res{hm.get_logic_monitor(logic_monitor_tag)};
+    EXPECT_TRUE(logic_monitor_res.has_value());
+
+    {
+        // Try again to get the same monitor.
+        auto logic_monitor_res{hm.get_logic_monitor(logic_monitor_tag)};
+        EXPECT_FALSE(logic_monitor_res.has_value());
+    }
+
+    auto logic_monitor{std::move(*logic_monitor_res)};
+
     // Start HMON.
     hm.start();
 
     heartbeat_monitor.heartbeat();
 
+    EXPECT_TRUE(logic_monitor.transition(to_state).has_value());
+
     auto deadline_res = deadline_mon.get_deadline(DeadlineTag("deadline_1"));
 
     {