Blackboard.hh

// Copyright QED Software 2023.
 
#ifndef GRAIL_BLACKBOARD_H
#define GRAIL_BLACKBOARD_H
 
#include "consts.h"
#include "../GrailLogger/LoggerManager.hh"
#include "BlackboardEntry.hh"
 
namespace grail
{
 class Blackboard
 {
 public:
 Blackboard() = default;
 Blackboard(const Blackboard& other);
 Blackboard(Blackboard&& other) = delete;
 
 ~Blackboard() = default;
 
 Blackboard& operator =(const Blackboard& other);
 Blackboard& operator =(Blackboard&& other) = delete;
 
 static void TwoWayMerge(Blackboard& first, Blackboard& second, 
 std::function<BlackboardEntry(const std::string&, const BlackboardEntry&, const BlackboardEntry&)> firstStrategy = OursStrategy,
 std::function<BlackboardEntry(const std::string&, const BlackboardEntry&, const BlackboardEntry&)> secondStrategy = OursStrategy);
 
 
 static BlackboardEntry OursStrategy(const std::string&, const BlackboardEntry& ours, const BlackboardEntry& theirs);
 
 static BlackboardEntry TheirsStrategy(const std::string&, const BlackboardEntry& ours, const BlackboardEntry& theirs);
 
 
 void Merge(const Blackboard& other, std::function<BlackboardEntry(const std::string&, const BlackboardEntry&, const BlackboardEntry&)> mergeStrategy = OursStrategy);
 
 void RemoveEntry(const std::string& key);
 
 bool ContainsKey(const std::string& key) const;
 
 size_t Size() const;
 
 template <typename T>
 void SetValue(const std::string& key, const T& value)
 {
 std::lock_guard<std::mutex> lock{mutex};
 SetValueInternal(key, value);
 }
 
 template <typename T, std::enable_if_t<!std::is_reference<T>::value>* = nullptr>
 void SetValue(const std::string& key, T&& value)
 {
 std::lock_guard<std::mutex> lock{mutex};
 SetValueInternal(key, value);
 }
 
 template <typename T>
 void SetDefaultValue(const std::string& key)
 {
 SetValue(key, T{});
 }
 
 template <typename T>
 const T& GetValue(const std::string& key) const
 {
 std::lock_guard<std::mutex> lock{mutex};
 auto iterator = data.find(key);
 if(iterator == data.end())
 {
 GRAIL_LOG(consts::DEFAULT_GRAIL_LOG_GROUP, logger::Severity::CRITICAL, "Invalid key (" + key + ")");
 }
 
 return iterator->second.GetValue<T>();
 }
 
 template <typename T>
 const T& GetOrAddValue(const std::string& key)
 {
 std::lock_guard<std::mutex> lock{ mutex };
 auto iterator = data.find(key);
 if (iterator == data.end())
 {
 data[key].SetValue(T{});
 return data[key].GetValue<T>();
 }
 
 return iterator->second.GetValue<T>();
 }
 
 template <typename T>
 bool TryGetValue(const std::string& key, T& outValue) const
 {
 std::lock_guard<std::mutex> lock{mutex};
 
 auto iter = data.find(key);
 if(iter != data.end())
 {
 outValue = iter->second.GetValue<T>();
 return true;
 }
 
 return false;
 }
 
 void SerializeToMap(std::map<std::string, std::string>& outMap) const;
 
 private:
 std::map<std::string, BlackboardEntry> data{};
 mutable std::mutex mutex{};
 
 template <typename T>
 void SetValueInternal(const std::string& key, const T& value)
 {
 data[key].SetValue(value);
 }
 };
}
 
#endif //GRAIL_BLACKBOARD_H