ADD: added a simple threadsafe map class

CMakeLists.txt

@@ -38,6 +38,10 @@ add_library(SimCore STATIC
     include/SimCore/Position.hpp
     src/SimCore/Position.cpp
 
+    include/SimCore/SafeMap.hpp
+    src/SimCore/SafeMap.cpp
+
+
 )
 
 target_link_libraries(SimCore
@@ -89,5 +93,8 @@ IF (${TEST_SIMCORE_LIBRARY})
   target_link_libraries(test_TrackClass Catch2::Catch2 SimCore eigen loguru)
   catch_discover_tests(test_TrackClass)
 
+  add_executable(test_SafeMap tests/test_SafeMap.cpp)
+  target_link_libraries(test_SafeMap Catch2::Catch2 SimCore loguru)
+  catch_discover_tests(test_SafeMap)
 
 ENDIF()

include/SimCore/SafeMap.hpp

@@ -0,0 +1,97 @@
+#pragma once
+#include <mutex>
+#include <map>
+#include <condition_variable>
+
+
+
+namespace SimCore {
+
+    template<typename K, typename V>
+    class SafeMap {
+
+        private:
+            std::map<K, V> store;
+            mutable std::mutex mx;
+            std::condition_variable c;
+
+        protected:
+
+
+        public:
+            SafeMap()
+            {
+                store = std::map<K, V>();
+            }
+
+            void addValue(K key, V value )
+            {
+                std::lock_guard<std::mutex> lock(mx);
+                store.emplace(key,value);
+                c.notify_one();
+
+            }
+
+            void removePair(K key)
+            {
+                std::lock_guard<std::mutex> lock(mx);
+                auto search = store.find(key);
+                if (search != store.end()) {
+                    search = store.erase(search);
+                } 
+                c.notify_one();
+
+            }
+
+            void overRideValue(K key, V newValue)
+            {
+                std::lock_guard<std::mutex> lock(mx);
+                auto search = store.find(key);
+                if (search != store.end()) {
+                    store[key] = newValue;
+                } 
+                c.notify_one();
+
+
+            }
+
+
+            V getValue(K key)
+            {
+                std::lock_guard<std::mutex> lock(mx);
+                 V  value;
+                auto search = store.find(key);
+                if (search != store.end()) {
+                      value = store[key];
+                }
+                    return value;
+
+            }
+
+            bool hasKey(K key)
+            {
+                std::lock_guard<std::mutex> lock(mx);
+                auto search = store.find(key);
+                if (search != store.end()) {
+                      return true;
+                }else {
+                return false;
+                }
+
+            }
+
+
+            long size()
+            {
+
+                std::lock_guard<std::mutex> lock(std::mutex);
+                
+                return store.size();
+            }
+
+
+
+
+    };
+}
+

src/SimCore/SafeMap.cpp

@@ -0,0 +1,17 @@
+#include <SimCore/SafeMap.hpp>
+#include <map>
+#include <mutex>
+
+
+namespace SimCore {
+
+
+    // template<typename K, typename V>
+    // SafeMap< K,  V>::SafeMap(){
+    //     store = std::map<K, V>();
+        
+    // }
+    
+
+
+}

tests/test_SafeMap.cpp

@@ -0,0 +1,41 @@
+
+#include <memory>
+#define CATCH_CONFIG_MAIN
+#include <catch2/catch.hpp>
+#include <SimCore/SafeMap.hpp>
+#include <loguru.hpp>
+
+
+
+
+SCENARIO("Testing the SimCore Track")
+{
+  GIVEN("different Attributes for a Track in different forms")
+  {
+   
+    int i = 0;
+    WHEN("constructing Track Object with data")
+    {
+    auto store =  SimCore::SafeMap<std::string, int>();
+       
+    store.addValue("h1", 1);
+    store.addValue("h2", 2);
+    LOG_S(INFO)<<"store size = " << store.size();
+
+    store.removePair("h2");
+      THEN("check if Track attributes are correct")
+      {
+        REQUIRE(store.size() == 1);
+        REQUIRE(store.getValue("h1") == 1);
+
+        store.overRideValue("h1", 3);
+        REQUIRE(store.size() == 1);
+        REQUIRE(store.getValue("h1") == 3);
+
+
+
+
+      } //THEN
+    } // WHEN
+  } // GIVEN
+} //SCENARIO