Impl & unit test to print string in IdentifierHash

Author: TimoSteuerwaldETAS

examples/control_application/control_daemon.cpp

@@ -40,7 +40,7 @@ int main(int argc, char** argv) {
     }
 
     score::lcm::ControlClient client([](const score::lcm::ExecutionErrorEvent& event) {
-        std::cerr << "Undefined state callback invoked for process group id: " << event.processGroup.data() << std::endl;
+        std::cerr << "Undefined state callback invoked for process group id: " << event.processGroup << std::endl;
     });
 
     score::safecpp::Scope<> scope{};

src/launch_manager_daemon/BUILD

@@ -12,6 +12,8 @@
 # *******************************************************************************
 load("//config:common_cc.bzl", "cc_binary_with_common_opts", "cc_library_with_common_opts")
 
+package(default_visibility = ["//tests:__subpackages__"])
+
 cc_library(
     name = "config",
     hdrs = ["config/lm_flatcfg_generated.h"],

src/launch_manager_daemon/common/include/score/lcm/identifier_hash.hpp

@@ -11,18 +11,21 @@
  * SPDX-License-Identifier: Apache-2.0
  ********************************************************************************/
 
-
 #ifndef IDENTIFIER_HASH_H_
 #define IDENTIFIER_HASH_H_
 
 #include <cstddef>
-
+#include <optional>
+#include <ostream>
 #include <string>
 #include <string_view>
+#include <unordered_map>
 
-namespace score {
+namespace score
+{
 
-namespace lcm {
+namespace lcm
+{
 
 /// @file identifier_hash.hpp
 /// @brief This file contains the declaration of the IdentifierHash class,
@@ -36,8 +39,9 @@ namespace lcm {
 /// @details The class is designed to be used in contexts where IDs needs to be managed,
 /// compared, and manipulated. It ensures that IDs are handled efficiently and provides
 /// necessary operators and functions for common operations.
-class IdentifierHash final {
-   public:
+class IdentifierHash final
+{
+  public:
     /// @brief Constructs an IdentifierHash object from the given ID.
     /// @param id A const reference to std::string representing an ID.
     explicit IdentifierHash(const std::string& id);
@@ -85,8 +89,8 @@ class IdentifierHash final {
     bool operator<(const IdentifierHash& other) const;  // Overloaded operator for comparison
 
     ///@brief Default constructor for the IdentifierHash class.
-    ///This constructor initializes the IdentifierHash object with a default ID value.
-    ///The ID value is calculated by hashing an empty string using std::hash<std::string>.
+    /// This constructor initializes the IdentifierHash object with a default ID value.
+    /// The ID value is calculated by hashing an empty string using std::hash<std::string>.
 
     // this constructor is used in the code that is not part of the POC
     // not sure if we should have this constructor or not, but there is code like this:
@@ -116,11 +120,46 @@ class IdentifierHash final {
     /// @return A constant reference to the data stored in the IdentifierHash object.
     std::size_t data() const;
 
-   private:
+    /// @brief Returns the registry mapping hash values to their corresponding string representations.
+    ///
+    /// Static registry, which gets initialized per process.
+    ///
+    /// @return A reference to the static unordered_map that serves as the registry.
+    static std::unordered_map<std::size_t, std::string>& get_registry();
+
+  private:
     /// internal representation of the ID, that was passed in constructor
     std::size_t hash_id_ = 0;
 };
 
+/// @brief Overloaded stream insertion operator for IdentifierHash.
+///
+/// This operator allows IdentifierHash objects to be output to an ostream.
+/// It uses the the static registry to find the string representation of the hash ID.
+///
+/// If there is no value stored in the registry for the given hash
+/// (i.e. the IdentifierHash is not constructed in this process,
+/// instead it has been transferred from another process via e.g. shared memory),
+/// it outputs an error message.
+///
+/// @param os The output stream.
+/// @param id The IdentifierHash object to output.
+/// @return A reference to the output stream.
+inline std::ostream& operator<<(std::ostream& os, const IdentifierHash& id)
+{
+    const auto& reg = IdentifierHash::get_registry();
+    const auto it = reg.find(id.data());
+    if (it != reg.end())
+    {
+        os << it->second;
+    }
+    else
+    {
+        os << "<Unknown IdentifierHash: " << id.data() << ">";
+    }
+    return os;
+}
+
 }  // namespace lcm
 
 }  // namespace score

src/launch_manager_daemon/common/src/identifier_hash.cpp

@@ -13,10 +13,13 @@
 
 #include <score/lcm/identifier_hash.hpp>
 #include <functional>
+#include <unordered_map>
 
-namespace score {
+namespace score
+{
 
-namespace lcm {
+namespace lcm
+{
 
 // Please note that a lot of the following info, would normally belong to identifier_hash.hpp file.
 // However, decision was made to publish identifier_hash.hpp alongside other headers.
@@ -55,47 +58,68 @@ namespace lcm {
 // One thing to note: hashing function is implementation specific.
 // So if this should work between different compilers, we may need to go for our own hash function.
 
-IdentifierHash::IdentifierHash(const std::string& id) {
+IdentifierHash::IdentifierHash(const std::string& id)
+{
     hash_id_ = std::hash<std::string>{}(id);
+    get_registry()[hash_id_] = id;
 }
 
-IdentifierHash::IdentifierHash(std::string_view id) {
+IdentifierHash::IdentifierHash(std::string_view id)
+{
     hash_id_ = std::hash<std::string_view>{}(id);
+    get_registry()[hash_id_] = id;
 }
 
-IdentifierHash::IdentifierHash(const char* id) {
-    hash_id_ =
-        std::hash<std::string_view>{}(id != nullptr ? std::string_view(id) : std::string_view(""));
+IdentifierHash::IdentifierHash(const char* id)
+{
+    const std::string_view sv = (id != nullptr) ? std::string_view(id) : std::string_view("");
+    hash_id_ = std::hash<std::string_view>{}(sv);
+    get_registry()[hash_id_] = sv;
 }
 
-bool IdentifierHash::operator==(const IdentifierHash& other) const {
+bool IdentifierHash::operator==(const IdentifierHash& other) const
+{
     return hash_id_ == other.hash_id_;
 }
 
-bool IdentifierHash::operator!=(const IdentifierHash& other) const {
+bool IdentifierHash::operator!=(const IdentifierHash& other) const
+{
     return !operator==(other);
 }
 
-bool IdentifierHash::operator==(const std::string_view& other) const {
+bool IdentifierHash::operator==(const std::string_view& other) const
+{
     return hash_id_ == (IdentifierHash{other}).hash_id_;
 }
 
-bool IdentifierHash::operator!=(const std::string_view& other) const {
+bool IdentifierHash::operator!=(const std::string_view& other) const
+{
     return !operator==(IdentifierHash{other});
 }
 
-bool IdentifierHash::operator<(const IdentifierHash& other) const {
+bool IdentifierHash::operator<(const IdentifierHash& other) const
+{
     return hash_id_ < other.hash_id_;
 }
 
-IdentifierHash::IdentifierHash() {
+IdentifierHash::IdentifierHash()
+{
     hash_id_ = std::hash<std::string_view>{}(std::string_view(""));
+    get_registry()[hash_id_] = "";
 }
 
-std::size_t IdentifierHash::data() const {
+std::size_t IdentifierHash::data() const
+{
     return hash_id_;
 }
 
+std::unordered_map<std::size_t, std::string>& IdentifierHash::get_registry()
+{
+    /// Static registry, which gets initialized per process.
+    static std::unordered_map<std::size_t, std::string> registry;
+    return registry;
+}
+
 }  // namespace lcm
 
 }  // namespace score

src/launch_manager_daemon/health_monitor_lib/src/score/lcm/saf/ifexm/ProcessStateReader.cpp

@@ -79,8 +79,8 @@ bool ProcessStateReader::distributeChanges(const timers::NanoSecondType f_syncTi
             const auto changedPosixProcess{resultChangedProcess.value()};
             if (changedPosixProcess)
             {
-                logger_r.LogDebug() << "Process with Id" << changedPosixProcess->id.data() << "changed state PG"
-                                    << changedPosixProcess->processGroupStateId.data() << "PS"
+                logger_r.LogDebug() << "Process with Id" << changedPosixProcess->id << "changed state PG"
+                                    << changedPosixProcess->processGroupStateId << "PS"
                                     << static_cast<int>(changedPosixProcess->processStateId);
                 isPushPending = pushUpdateTill(*changedPosixProcess, f_syncTimestamp);
                 flagContinue = (!isPushPending);

src/launch_manager_daemon/src/configuration_manager/configurationmanager.cpp

@@ -126,10 +126,10 @@ std::optional<const ProcessGroupStateID*> ConfigurationManager::getMainPGStartup
         if (pg_state) {
             result = &main_pg_startup_state_;
         } else {
-            LM_LOG_DEBUG() << "Process group state not found:" << main_pg_startup_state_.pg_state_name_.data();
+            LM_LOG_DEBUG() << "Process group state not found:" << main_pg_startup_state_.pg_state_name_;
         }
     } else {
-        LM_LOG_DEBUG() << "Process group not found:" << main_pg_startup_state_.pg_name_.data();
+        LM_LOG_DEBUG() << "Process group not found:" << main_pg_startup_state_.pg_name_;
     }
 
     return result;
@@ -154,8 +154,8 @@ std::optional<const std::vector<uint32_t>*> ConfigurationManager::getProcessInde
     if (state) {
         result = &state->process_indexes_;
     } else {
-        LM_LOG_DEBUG() << "Process group state '" << pg_state_id.pg_state_name_.data() << "' not found in group '"
-                       << pg_state_id.pg_name_.data() << "'.";
+        LM_LOG_DEBUG() << "Process group state '" << pg_state_id.pg_state_name_ << "' not found in group '"
+                       << pg_state_id.pg_name_ << "'.";
     }
 
     return result;
@@ -168,7 +168,7 @@ std::optional<const OsProcess*> ConfigurationManager::getOsProcessConfiguration(
     if (auto pg = getProcessGroupByNameAndIndex(pg_name, index)) {
         result = &(*pg)->processes_[index];
     } else {
-        LM_LOG_DEBUG() << "Unable to retrieve process configuration for process group" << pg_name.data()
+        LM_LOG_DEBUG() << "Unable to retrieve process configuration for process group" << pg_name
                        << "with index" << index;
     }
 
@@ -182,7 +182,7 @@ std::optional<const DependencyList*> ConfigurationManager::getOsProcessDependenc
     if (auto pg = getProcessGroupByNameAndIndex(pg_name, index)) {
         result = &(*pg)->processes_[index].dependencies_;
     } else {
-        LM_LOG_DEBUG() << "Unable to retrieve process dependencies for process group" << pg_name.data() << "with index"
+        LM_LOG_DEBUG() << "Unable to retrieve process dependencies for process group" << pg_name << "with index"
                        << index;
     }
 
@@ -304,7 +304,7 @@ bool ConfigurationManager::parseMachineConfigurations(const ModeGroup* node, con
         process_group_data.name_ = getStringViewFromFlatBuffer(node->identifier());
         process_group_data.sw_cluster_ = cluster;
         LM_LOG_DEBUG() << "FlatBufferParser::getModeGroupPgName:" << getStringFromFlatBuffer(node->identifier())
-                       << "( IdentifierHash:" << process_group_data.name_.data() << ")";
+                       << "( IdentifierHash:" << process_group_data.name_ << ")";
 
         if (process_group_data.name_ != score::lcm::IdentifierHash(std::string_view(""))) {
             // Add process group name to the PG name list
@@ -339,7 +339,7 @@ bool ConfigurationManager::parseModeGroups(const ModeGroup* node, ProcessGroup&
                 pg_state.name_ = getStringViewFromFlatBuffer(flatbuffer_string);
                 LM_LOG_DEBUG() << "FlatBufferParser::getModeGroupPgStateName:"
                                << mode_declaration_node->identifier()->c_str()
-                               << "( IdentifierHash:" << pg_state.name_.data() << ")";
+                               << "( IdentifierHash:" << pg_state.name_ << ")";
                 process_group_data.states_.push_back(pg_state);
                 // Is this the "Off" state, i.e. does it end with "/Off" ?
                 auto str_len = string_name.length();
@@ -593,8 +593,8 @@ void ConfigurationManager::parseProcessGroup(
                 ProcessGroupStateID pg_info;
                 pg_info.pg_name_ = getStringViewFromFlatBuffer(process_pg_node->stateMachine_name());
                 pg_info.pg_state_name_ = getStringViewFromFlatBuffer(process_pg_node->stateName());
-                LM_LOG_DEBUG() << "ParseProcessProcessGroup: id:::pg_name_:" << pg_info.pg_name_.data()
-                               << ", pg_state_name_:" << pg_info.pg_state_name_.data();
+                LM_LOG_DEBUG() << "ParseProcessProcessGroup: id:::pg_name_:" << pg_info.pg_name_
+                               << ", pg_state_name_:" << pg_info.pg_state_name_;
 
                 // Assign OsProcess instance to the process group
                 AssignOsProcessInstanceToProcessGroup(pg_info, process_instance);
@@ -618,7 +618,7 @@ void ConfigurationManager::parseExecutionDependency(
                 dep.target_process_id_ = getStringViewFromFlatBuffer(process_dependency_node->targetProcess_identifier());
                 LM_LOG_DEBUG() << "ParseProcessExecutionDependency: target process path:"
                                 << getStringFromFlatBuffer(process_dependency_node->targetProcess_identifier())
-                                << "ID:" << dep.target_process_id_.data();
+                                << "ID:" << dep.target_process_id_;
                 process_instance.dependencies_.push_back(dep);
 
             }
@@ -715,10 +715,10 @@ void ConfigurationManager::AssignOsProcessInstanceToProcessGroup(const ProcessGr
                 state->process_indexes_.push_back(index_in_pg);
             }
         } else {
-            LM_LOG_WARN() << "Process group state not found:" << process_pg.pg_state_name_.data();
+            LM_LOG_WARN() << "Process group state not found:" << process_pg.pg_state_name_;
         }
     } else {
-        LM_LOG_WARN() << "Process group not found:", process_pg.pg_name_.data();
+        LM_LOG_WARN() << "Process group not found:" << process_pg.pg_name_;
     }
 }
 
@@ -827,10 +827,10 @@ osal::CommsType ConfigurationManager::isReportingProcess(const ExecutionStateRep
 
     if (reporting_behaviour == ExecutionStateReportingBehaviorEnum::ExecutionStateReportingBehaviorEnum_ReportsExecutionState) {
         reporting_status = osal::CommsType::kReporting;
-        LM_LOG_DEBUG() << "Process" << process_name.data() << "is Reporting execution state";
+        LM_LOG_DEBUG() << "Process" << process_name << "is Reporting execution state";
     } else {
         // ExecutionStateReportingBehaviorEnum::DoesNotReportExecutionState
-        LM_LOG_DEBUG() << "Process" << process_name.data() << "is NOT Reporting execution state";
+        LM_LOG_DEBUG() << "Process" << process_name << "is NOT Reporting execution state";
     }
 
     return reporting_status;
@@ -842,10 +842,10 @@ bool ConfigurationManager::isSelfTerminatingProcess(const TerminationBehaviorEnu
 
     if (termination_behavior == TerminationBehaviorEnum::TerminationBehaviorEnum_ProcessIsSelfTerminating) {
         termination_status = true;
-        LM_LOG_DEBUG() << "Process" << process_name.data() << "is Self terminating";
+        LM_LOG_DEBUG() << "Process" << process_name << "is Self terminating";
     } else {
         // TerminationBehaviorEnum::ProcessIsNotSelfTerminating
-        LM_LOG_DEBUG() << "Process" << process_name.data() << "is NOT Self terminating";
+        LM_LOG_DEBUG() << "Process" << process_name << "is NOT Self terminating";
     }
 
     return termination_status;
@@ -861,10 +861,10 @@ std::optional<const ProcessGroup*> ConfigurationManager::getProcessGroupByNameAn
         if (index < pg->processes_.size()) {
             result = pg;
         } else {
-            LM_LOG_DEBUG() << "Process index" << index << "is out of bounds in process group" << pg_name.data();
+            LM_LOG_DEBUG() << "Process index" << index << "is out of bounds in process group" << pg_name;
         }
     } else {
-        LM_LOG_DEBUG() << "Process group not found:" << pg_name.data();
+        LM_LOG_DEBUG() << "Process group not found:" << pg_name;
     }
 
     return result;