using unordered_map for values and registry of blackboard

Author: mgonzs13

yasmin/include/yasmin/blackboard.hpp

@@ -23,6 +23,7 @@
 #include <mutex>
 #include <stdexcept>
 #include <string>
+#include <unordered_map>
 
 #include "yasmin/logs.hpp"
 
@@ -64,9 +65,9 @@ class Blackboard {
   /// Mutex for thread safety.
   mutable std::recursive_mutex mutex;
   /// Storage for key-value pairs.
-  std::map<std::string, std::shared_ptr<void>> values;
+  std::unordered_map<std::string, std::shared_ptr<void>> values;
   /// Storage for type information for each key.
-  std::map<std::string, std::string> type_registry;
+  std::unordered_map<std::string, std::string> type_registry;
   /// Storage for key remappings.
   std::map<std::string, std::string> remappings;
 

yasmin/include/yasmin/concurrence.hpp

@@ -63,7 +63,7 @@ class Concurrence : public State {
   OutcomeMap outcome_map;
 
   /// Stores the intermediate outcomes of the concurrent states
-  std::map<std::string, std::shared_ptr<std::string>> intermediate_outcome_map;
+  std::map<std::string, std::string> intermediate_outcome_map;
 
   /// The set of possible outcomes
   std::set<std::string> possible_outcomes;

yasmin/src/yasmin/concurrence.cpp

@@ -75,7 +75,7 @@ Concurrence::Concurrence(
             state->to_string() + "'");
       }
 
-      intermediate_outcome_map.insert({state_name, nullptr});
+      intermediate_outcome_map.insert({state_name, ""});
     }
   }
 }
@@ -90,8 +90,7 @@ Concurrence::execute(std::shared_ptr<yasmin::Blackboard> blackboard) {
                                          blackboard]() {
       std::string outcome = (*state.get())(blackboard);
       const std::lock_guard<std::mutex> lock(this->intermediate_outcome_mutex);
-      this->intermediate_outcome_map[state_name] =
-          std::make_shared<std::string>(outcome);
+      this->intermediate_outcome_map[state_name] = outcome;
     }));
   }
 
@@ -113,14 +112,13 @@ Concurrence::execute(std::shared_ptr<yasmin::Blackboard> blackboard) {
     bool satisfied = true;
     for (const auto &[state_name, expected_intermediate_outcome] :
          requirements) {
-      std::shared_ptr<std::string> actual_intermediate_outcome =
+      std::string actual_intermediate_outcome =
           intermediate_outcome_map.find(state_name)->second;
-      if (actual_intermediate_outcome == nullptr) {
+      if (actual_intermediate_outcome.empty()) {
         throw std::runtime_error("An intermediate outcome for state '" +
                                  state_name + "' was not received.");
       }
-      satisfied &=
-          *actual_intermediate_outcome == expected_intermediate_outcome;
+      satisfied &= actual_intermediate_outcome == expected_intermediate_outcome;
     }
     if (satisfied) {
       satisfied_outcomes.insert(outcome);

yasmin_factory/include/yasmin_factory/yasmin_factory.hpp

@@ -16,7 +16,6 @@
 #ifndef YASMIN_FACTORY__YASMIN_FACTORY_HPP
 #define YASMIN_FACTORY__YASMIN_FACTORY_HPP
 
-#include <map>
 #include <memory>
 #include <set>
 #include <string>