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