Blackboard.hh

#ifndef GRAIL_BLACKBOARD_H
#define GRAIL_BLACKBOARD_H
 
#include "consts.h"
#include "../GrailLogger/LoggerManager.hh"
 
#include <functional>
#include <map>
#include <mutex>
 
#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() = default;
        Blackboard(const Blackboard& other);
        Blackboard(Blackboard&& other) = delete;
 
        ~Blackboard() = default;
 
        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