Fixes after review

Author: pawelrutkaq

MODULE.bazel

@@ -105,11 +105,6 @@ use_repo(toolchains_qnx, "toolchains_qnx_ifs")
 
 bazel_dep(name = "score_baselibs_rust", version = "0.0.3")
 bazel_dep(name = "score_baselibs", version = "0.2.2")
-# git_override(
-#     module_name = "score_baselibs",
-#     commit = "9925dba1fd2ca7f2d33300cd2c01e6af022024cd",
-#     remote = "https://github.com/eclipse-score/baselibs.git",
-# )
 
 # Hedron's Compile Commands Extractor for Bazel
 # https://github.com/hedronvision/bazel-compile-commands-extractor

scripts/generate_cpp_compile_commands.sh

@@ -1,3 +1,3 @@
 #!/bin/bash
 
-bazel run @hedron_compile_commands//:refresh_all
+bazel run @hedron_compile_commands//:refresh_all

src/health_monitoring_lib/BUILD

@@ -11,8 +11,9 @@
 # SPDX-License-Identifier: Apache-2.0
 # *******************************************************************************
 
+load("@rules_cc//cc:defs.bzl", "cc_library")
 load("@rules_rust//rust:defs.bzl", "rust_library", "rust_static_library", "rust_test")
-load("@score_baselibs//:bazel/unit_tests.bzl", "cc_gtest_unit_test", "cc_unit_test_suites_for_host_and_qnx")
+load("@score_baselibs//:bazel/unit_tests.bzl", "cc_gtest_unit_test")
 
 rust_library(
     name = "health_monitoring_lib",
@@ -52,7 +53,7 @@ cc_library(
     name = "health_monitoring_lib_cc",
     srcs = [
         "cpp/common.cpp",
-        "cpp/deadline/deadline_monitor.cpp",
+        "cpp/deadline_monitor.cpp",
         "cpp/ffi_helpers.h",
         "cpp/health_monitor.cpp",
     ],
@@ -61,9 +62,6 @@ cc_library(
         "cpp/include/score/hm/deadline/deadline_monitor.h",
         "cpp/include/score/hm/health_monitor.h",
     ],
-    copts = [
-        "-Isrc/health_monitoring_lib/cpp",  # private include path
-    ],
     strip_include_prefix = "cpp/include",
     visibility = ["//visibility:public"],
     deps = [

src/health_monitoring_lib/cpp/common.cpp

@@ -45,21 +45,21 @@ DroppableFFIHandle& DroppableFFIHandle::operator=(DroppableFFIHandle&& other) no
     return *this;
 }
 
-::score::cpp::optional<FFIHandle> DroppableFFIHandle::as_rust_handle() const
+std::optional<FFIHandle> DroppableFFIHandle::as_rust_handle() const
 {
     if (handle_ == nullptr)
     {
-        return ::score::cpp::nullopt;
+        return std::nullopt;
     }
 
     return handle_;
 }
 
-::score::cpp::optional<FFIHandle> DroppableFFIHandle::drop_by_rust()
+std::optional<FFIHandle> DroppableFFIHandle::drop_by_rust()
 {
     if (handle_ == nullptr)
     {
-        return ::score::cpp::nullopt;
+        return std::nullopt;
     }
 
     FFIHandle temp = handle_;

…ng_lib/cpp/deadline/deadline_monitor.cpp …_monitoring_lib/cpp/deadline_monitor.cppsrc/health_monitoring_lib/cpp/deadline/deadline_monitor.cpp renamed to src/health_monitoring_lib/cpp/deadline_monitor.cpp src/health_monitoring_lib/cpp/deadline/deadline_monitor.cpp renamed to src/health_monitoring_lib/cpp/deadline_monitor.cpp

@@ -43,7 +43,7 @@ DeadlineMonitorBuilder DeadlineMonitorBuilder::add_deadline(const IdentTag& tag,
     auto handle = monitor_builder_handler_.as_rust_handle();
     SCORE_LANGUAGE_FUTURECPP_PRECONDITION(handle.has_value());
 
-    deadline_monitor_builder_add_deadline(handle.value(), &tag, range.min_as_u32(), range.max_as_u32());
+    deadline_monitor_builder_add_deadline(handle.value(), &tag, range.min_ms(), range.max_ms());
 
     return std::move(*this);
 }
@@ -113,7 +113,7 @@ DeadlineHandle::DeadlineHandle(DeadlineHandle&& other)
     : was_stopped_(other.was_stopped_), deadline_(std::move(other.deadline_))
 {
     other.was_stopped_ = true;
-    other.deadline_ = ::score::cpp::optional<std::reference_wrapper<Deadline>>{};  // None
+    other.deadline_ = std::optional<std::reference_wrapper<Deadline>>{};  // None
 }
 
 DeadlineHandle::~DeadlineHandle()

src/health_monitoring_lib/cpp/ffi_helpers.h

@@ -13,6 +13,8 @@
 #ifndef SCORE_HM_FFI_HELPERS_HPP
 #define SCORE_HM_FFI_HELPERS_HPP
 
+#include <cassert>
+
 namespace score::hm::ffi
 {
 

src/health_monitoring_lib/cpp/health_monitor.cpp

@@ -61,6 +61,12 @@ HealthMonitor::HealthMonitor(internal::FFIHandle handle) : health_monitor_(handl
     // Initialize health monitor
 }
 
+HealthMonitor::HealthMonitor(HealthMonitor&& other)
+{
+    health_monitor_ = std::move(other.health_monitor_);
+    other.health_monitor_ = nullptr;
+}
+
 score::cpp::expected<deadline::DeadlineMonitor, Error> HealthMonitor::get_deadline_monitor(const IdentTag& tag)
 {
     auto maybe_monitor = health_monitor_get_deadline_monitor(health_monitor_, &tag);

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

@@ -13,12 +13,10 @@
 #ifndef SCORE_HM_COMMON_H
 #define SCORE_HM_COMMON_H
 
-#include <score/optional.hpp>
-#include <cassert>
 #include <chrono>
 #include <cstdint>
-#include <cstring>
-#include <iostream>
+#include <optional>
+
 namespace score::hm
 {
 
@@ -57,21 +55,21 @@ class IdentTag
 class TimeRange
 {
   public:
-    TimeRange(std::chrono::milliseconds min_ms, std::chrono::milliseconds max_ms) : min_ms(min_ms), max_ms(max_ms) {}
+    TimeRange(std::chrono::milliseconds min_ms, std::chrono::milliseconds max_ms) : min_ms_(min_ms), max_ms_(max_ms) {}
 
-    const uint32_t min_as_u32() const
+    const uint32_t min_ms() const
     {
-        return min_ms.count();
+        return min_ms_.count();
     }
 
-    const uint32_t max_as_u32() const
+    const uint32_t max_ms() const
     {
-        return max_ms.count();
+        return max_ms_.count();
     }
 
   private:
-    const std::chrono::milliseconds min_ms;
-    const std::chrono::milliseconds max_ms;
+    const std::chrono::milliseconds min_ms_;
+    const std::chrono::milliseconds max_ms_;
 };
 
 /// FFI internal helpers
@@ -86,10 +84,11 @@ template <typename T>
 class RustDroppable
 {
   public:
-    ~RustDroppable() = default;
+    virtual ~RustDroppable() = default;
 
+  protected:
     /// Marks object as no longer managed by C++ side, releasing handle to be passed to Rust side for dropping
-    ::score::cpp::optional<FFIHandle> drop_by_rust()
+    std::optional<FFIHandle> drop_by_rust()
     {
         return static_cast<T*>(this)->__drop_by_rust_impl();
     }
@@ -110,12 +109,12 @@ class DroppableFFIHandle
     DroppableFFIHandle& operator=(DroppableFFIHandle&& other) noexcept;
 
     /// Get the underlying FFI handle if it was not dropped before
-    ::score::cpp::optional<FFIHandle> as_rust_handle() const;
+    std::optional<FFIHandle> as_rust_handle() const;
 
     /// Marks object as no longer managed by C++ side, releasing handle to be passed to Rust side for dropping
-    ::score::cpp::optional<FFIHandle> drop_by_rust();
+    std::optional<FFIHandle> drop_by_rust();
 
-    ~DroppableFFIHandle();
+    virtual ~DroppableFFIHandle();
 
   private:
     FFIHandle handle_;

src/health_monitoring_lib/cpp/include/score/hm/deadline/deadline_monitor.h

@@ -15,11 +15,13 @@
 
 #include <score/expected.hpp>
 #include <score/hm/common.h>
+#include <functional>
 
 namespace score::hm
 {
 // Forward declaration
 class HealthMonitor;
+class HealthMonitorBuilder;
 }  // namespace score::hm
 
 namespace score::hm::deadline
@@ -31,7 +33,7 @@ class DeadlineHandle;
 class Deadline;
 
 /// DeadlineMonitorBuilder for constructing DeadlineMonitor instance
-class DeadlineMonitorBuilder : public internal::RustDroppable<DeadlineMonitorBuilder>
+class DeadlineMonitorBuilder final : public internal::RustDroppable<DeadlineMonitorBuilder>
 {
   public:
     /// Creates a new DeadlineMonitorBuilder
@@ -46,16 +48,23 @@ class DeadlineMonitorBuilder : public internal::RustDroppable<DeadlineMonitorBui
     /// Adds a deadline with the given tag and duration range to the monitor.
     DeadlineMonitorBuilder add_deadline(const IdentTag& tag, const TimeRange& range) &&;
 
-    ::score::cpp::optional<internal::FFIHandle> __drop_by_rust_impl()
+  protected:
+    std::optional<internal::FFIHandle> __drop_by_rust_impl()
     {
         return monitor_builder_handler_.drop_by_rust();
     }
 
   private:
     internal::DroppableFFIHandle monitor_builder_handler_;
+
+    // Allow to hide drop_by_rust implementation
+    friend class internal::RustDroppable<DeadlineMonitorBuilder>;
+
+    // Allow HealthMonitorBuilder to access drop_by_rust implementation
+    friend class ::score::hm::HealthMonitorBuilder;
 };
 
-class DeadlineMonitor
+class DeadlineMonitor final
 {
   public:
     // Delete copy, allow move
@@ -70,12 +79,13 @@ class DeadlineMonitor
   private:
     explicit DeadlineMonitor(internal::FFIHandle handle);
 
+    // Allow only HealthMonitor to create DeadlineMonitor instances.
     friend class score::hm::HealthMonitor;
     internal::DroppableFFIHandle monitor_handle_;
 };
 
 /// Deadline instance representing a specific deadline to be monitored.
-class Deadline
+class Deadline final
 {
   public:
     ~Deadline();
@@ -93,14 +103,17 @@ class Deadline
   private:
     explicit Deadline(internal::FFIHandle handle);
 
+    // Allow only DeadlineMonitor to create Deadline instances.
     friend class DeadlineMonitor;
+
+    // Allow DeadlineHandle to access internal members as its wrapper type only
     friend class DeadlineHandle;
     internal::DroppableFFIHandle deadline_handle_;
     bool has_handle_;
 };
 
 /// Deadline guard to manage the lifetime of a started deadline.
-class DeadlineHandle
+class DeadlineHandle final
 {
   public:
     /// Stops the deadline monitoring.
@@ -118,9 +131,10 @@ class DeadlineHandle
   private:
     DeadlineHandle(Deadline& deadline);
 
+    // Allow only Deadline to create DeadlineHandle instances.
     friend class Deadline;
     bool was_stopped_;
-    ::score::cpp::optional<std::reference_wrapper<Deadline>> deadline_;
+    std::optional<std::reference_wrapper<Deadline>> deadline_;
 };
 
 }  // namespace score::hm::deadline

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

@@ -24,7 +24,7 @@ class HealthMonitor;
 ///
 /// Builder for HealthMonitor instances.
 ///
-class HealthMonitorBuilder
+class HealthMonitorBuilder final
 {
   public:
     ///  Creates a new HealthMonitorBuilder
@@ -47,24 +47,21 @@ class HealthMonitorBuilder
     internal::DroppableFFIHandle health_monitor_builder_handle_;
 };
 
-class HealthMonitor
+class HealthMonitor final
 {
   public:
     HealthMonitor(const HealthMonitor&) = delete;
     HealthMonitor& operator=(const HealthMonitor&) = delete;
-    HealthMonitor(HealthMonitor&& other)
-    {
-        health_monitor_ = std::move(other.health_monitor_);
-        other.health_monitor_ = nullptr;
-    }
 
+    HealthMonitor(HealthMonitor&& other);
     HealthMonitor& operator=(HealthMonitor&&);
 
     ~HealthMonitor();
 
     score::cpp::expected<deadline::DeadlineMonitor, Error> get_deadline_monitor(const IdentTag& tag);
 
   private:
+    // Allow only the builder to create HealthMonitor instances.
     friend class HealthMonitorBuilder;
 
     HealthMonitor(internal::FFIHandle handle);