Blackboard.hh

#ifndef GRAIL_BLACKBOARD_H
#define GRAIL_BLACKBOARD_H
 
#include "consts.h"
#include "Logger/LoggerManager.hh"
 
#include <map>
#include <mutex>
#include <functional>
 
#ifndef BUILD_UNREAL
#include <any>
#endif
 
namespace grail
{
 class Blackboard
 {
#ifdef BUILD_UNREAL
 class UnsafeAny;
 friend bool operator == (const UnsafeAny& first, const UnsafeAny& second);
#endif
 
 public:
 Blackboard();
 Blackboard(const Blackboard& other);
 Blackboard(Blackboard&& other) = delete;
 
 ~Blackboard();
 
 Blackboard& operator = (const Blackboard& other);
 Blackboard& operator = (Blackboard&& other) = delete;
 
#ifndef BUILD_UNREAL
 static void TwoWayMerge(Blackboard& first, Blackboard& second,
 std::function<const std::any&(const std::any&, const std::any&)> firstStrategy = OursStrategy,
 std::function<const std::any&(const std::any&, const std::any&)> secondStrategy = OursStrategy);
#else
 static void TwoWayMerge(Blackboard& first, Blackboard& second,
 std::function<const UnsafeAny&(const UnsafeAny&, const UnsafeAny&)> firstStrategy = OursStrategy,
 std::function<const UnsafeAny&(const UnsafeAny&, const UnsafeAny&)> secondStrategy = OursStrategy);
#endif
#ifndef BUILD_UNREAL
 static const std::any& OursStrategy(const std::any& ours, const std::any& theirs);
#else
 static const UnsafeAny& OursStrategy(const UnsafeAny& ours, const UnsafeAny& theirs);
#endif
 
#ifndef BUILD_UNREAL
 static const std::any& TheirsStrategy(const std::any& ours, const std::any& theirs);
#else
 static const UnsafeAny& TheirsStrategy(const UnsafeAny& ours, const UnsafeAny& theirs);
#endif
 
#ifndef BUILD_UNREAL
 void Merge(const Blackboard& other, std::function<const std::any&(const std::any&, const std::any&)> mergeStrategy = OursStrategy);
#else
 void Merge(const Blackboard& other, std::function<const UnsafeAny&(const UnsafeAny&, const UnsafeAny&)> mergeStrategy = OursStrategy);
#endif
 
 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};
#ifndef BUILD_UNREAL
 std::any any = value;
 data[key] = any;
#else
 auto deleter = [](void* memory)
 {
 T* dataPointer = static_cast<T*>(memory);
 delete dataPointer;
 };
 auto cloner = [](void* memory)
 {
 T* dataPointer = static_cast<T*>(memory);
 return new T{*dataPointer};
 };
 
 data[key] = UnsafeAny(new T{value}, deleter, cloner);
#endif
 }
 
 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};
#ifndef BUILD_UNREAL
 data[key] = std::any{value};
#else
 auto deleter = [](void* memory)
 {
 T* dataPointer = static_cast<T*>(memory);
 delete dataPointer;
 };
 auto cloner = [](void* memory)
 {
 T* dataPointer = static_cast<T*>(memory);
 return new T{*dataPointer};
 };
 data[key] = UnsafeAny(new T{value}, deleter, cloner);
#endif
 }
 
 template<typename T>
 void SetDefaultValue(const std::string& key)
 {
 std::lock_guard<std::mutex> lock{mutex};
#ifndef BUILD_UNREAL
 data[key] = std::any{T{}};
#else
 auto deleter = [](void* memory)
 {
 T* dataPointer = static_cast<T*>(memory);
 delete dataPointer;
 };
 auto cloner = [](void* memory)
 {
 T* dataPointer = static_cast<T*>(memory);
 return new T{*dataPointer};
 };
 data[key] = UnsafeAny(new T{}, deleter, cloner);
#endif
 }
 
 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, Severity::CRITICAL, "Invalid key (" + key + ")");
 }
#ifndef BUILD_UNREAL
 return std::any_cast<const T&>(iterator->second);
#else
 return *static_cast<T*>(iterator->second.GetDataPointer());
#endif
 }
 
 template<typename T>
 T& GetOrAddValue(const std::string& key)
 {
 std::lock_guard<std::mutex> lock{ mutex };
#ifndef BUILD_UNREAL
 return std::any_cast<T&>(data[key]);
#else
 auto iterator = data.find(key);
 if(iterator == data.end())
 {
 auto deleter = [](void* memory)
 {
 T* dataPointer = static_cast<T*>(memory);
 delete dataPointer;
 };
 auto cloner = [](void* memory)
 {
 T* dataPointer = static_cast<T*>(memory);
 return new T{*dataPointer};
 };
 iterator = data.emplace(std::piecewise_construct, std::forward_as_tuple(key),
 std::forward_as_tuple(new T{}, deleter, cloner)).first;
 }
 return *static_cast<T*>(iterator->second.GetDataPointer());
#endif
 }
 
 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())
 {
#ifndef BUILD_UNREAL
 outValue = std::any_cast<T>(iter->second);
#else
 outValue = *static_cast<T*>(iter->second.GetDataPointer());
#endif
 return true;
 }
 return false;
 }
 
 void AddDataToNameMap(std::map<std::string, std::string>& outMap) const;
 
 private:
#ifndef BUILD_UNREAL
 std::map<std::string, std::any> data{};
#else
 class UnsafeAny
 {
 friend bool operator == (const UnsafeAny& first, const UnsafeAny& second);
 
 public:
 UnsafeAny() = default;
 UnsafeAny(void* dataPointer, std::function<void(void*)> deleter, std::function<void*(void*)> cloner);
 
 UnsafeAny(const UnsafeAny& other);
 UnsafeAny(UnsafeAny&& other);
 
 ~UnsafeAny();
 
 UnsafeAny& operator = (const UnsafeAny& other);
 UnsafeAny& operator = (UnsafeAny&& other);
 
 void* GetDataPointer() const;
 
 private:
 void* dataPointer{nullptr};
 std::function<void(void*)> deleter{[](void*){}};
 std::function<void*(void*)> cloner{[](void*){ return nullptr; }};
 };
 
 std::map<std::string, UnsafeAny> data{};
#endif
 mutable std::mutex mutex{};
 };
}
 
#endif //GRAIL_BLACKBOARD_H