BlackboardEntry.hh

// Copyright QED Software 2023.
 
#ifndef GRAIL_BLACKBOARD_ENTRY_H
#define GRAIL_BLACKBOARD_ENTRY_H
 
#include "../GrailLogger/LoggerManager.hh"
 
#include <string>
#include <functional>
#include <iostream>
#include <memory>
#include <type_traits>
#include <string>
#include <functional>
#include <map>
#include <mutex>
#include <typeinfo>
#include <utility>
#include <cassert>
 
#ifndef BUILD_UNREAL
#include <any>
#endif
 
namespace grail
{
    class Blackboard;
    template<typename T>
    std::string SerializeData(const T& element);
 
    template <typename T>
    struct IsRawArray : std::false_type {};
 
    template <typename T>
    struct IsRawArray<T[]> : std::true_type {};
 
    template <typename T, std::size_t N>
    struct IsRawArray<T[N]> : std::true_type {};
 
    template <typename T>
    constexpr bool IsRawArrayValue = IsRawArray<T>::value;
 
    /*** 
    * Attribution 1: 
    * The code inside the macros below was written by Louis Delacroix.
    * The original publicly available link to repository:
    * https://gist.github.com/louisdx/1076849 
    ***/
    #define DECLARE_HAS_CONST_ITERATOR(NAME_SUFFIX, ITERATOR_TYPE) \
    template<typename T> \
    struct HasConstIterator_##NAME_SUFFIX \
    { \
    private: \
        typedef char One; \
        typedef struct { char array[2]; } Two; \
\
        template<typename C> \
        static One Test(typename C::ITERATOR_TYPE*); \
        template<typename C> \
        static Two Test(...); \
\
    public:\
        static const bool value = sizeof(Test<T>(0)) == sizeof(One);\
        typedef T type;\
    };
 
#define DECLARE_HAS_BEGIN_END(NAME_SUFFIX, ITERATOR_TYPE) \
    template <typename T>\
    struct HasBeginEnd_##NAME_SUFFIX\
    {\
        struct Dummy\
        {\
            typedef void ITERATOR_TYPE;\
        };\
\
        typedef typename std::conditional<HasConstIterator_##NAME_SUFFIX<T>::value, T, Dummy>::type TType;\
        typedef typename TType::ITERATOR_TYPE Iterator;\
\
        struct Fallback\
        {\
            Iterator begin() const;\
            Iterator end() const;\
        };\
\
        struct Derived : TType, Fallback\
        {\
        };\
\
        template<typename C, C> struct ChT;\
\
        template<typename C> static char(&f(ChT<Iterator(Fallback::*)() const, &C::begin>*))[1];\
        template<typename C> static char(&f(...))[2];\
        template<typename C> static char(&g(ChT<Iterator(Fallback::*)() const, &C::end>*))[1];\
        template<typename C> static char(&g(...))[2];\
\
        static const bool beginValue = sizeof(f<Derived>(0)) == 2;\
        static const bool endValue = sizeof(g<Derived>(0)) == 2;\
    };
    /*End of Attribution 1*/
 
    template <typename>
    struct IsPair : std::false_type { };
 
    template <typename T, typename U>
    struct IsPair<std::pair<T, U>> : std::true_type { };
 
    template <typename> struct IsTuple : std::false_type {};
 
    template <typename ...T> struct IsTuple<std::tuple<T...>> : std::true_type {};
 
    template <typename T>
    struct IsSharedPointer : std::false_type {};
 
    template <typename T>
    struct IsWeakPointer : std::false_type {};
 
    template <typename T>
    struct IsSharedPointer<std::shared_ptr<T>> : std::true_type {};
 
    template <typename T>
    struct IsWeakPointer<std::weak_ptr<T>> : std::true_type {};
 
/***
* Attribution 2:
* The code below has been inspired by:
https://stackoverflow.com/questions/9407367/determine-if-a-type-is-an-stl-container-at-compile-time
***/
#define DECLARE_IS_CONTAINER(NAME_SUFFIX, ITERATOR_TYPE) \
    DECLARE_HAS_CONST_ITERATOR(NAME_SUFFIX, ITERATOR_TYPE)\
    DECLARE_HAS_BEGIN_END(NAME_SUFFIX, ITERATOR_TYPE)\
    template <typename T>\
    struct IsContainer_##NAME_SUFFIX\
    {\
        static const bool value = HasConstIterator_##NAME_SUFFIX<T>::value &&\
            HasBeginEnd_##NAME_SUFFIX<T>::beginValue && HasBeginEnd_##NAME_SUFFIX<T>::endValue;\
    };
 
    DECLARE_IS_CONTAINER(Std, const_iterator)
 
    template<typename T, typename = void>
    struct CanToString : std::false_type {};
 
    template<typename T>
    struct CanToString<T, std::void_t<decltype(std::to_string(std::declval<T>()))>> : std::true_type {};
 
    template<typename T, typename = void>
    struct BelongsToLibraryTypeGroup : std::false_type {};
 
    template<typename T>
    struct BelongsToLibraryTypeGroup<T, std::void_t<decltype(SerializeLibraryType(std::declval<T>()))>> : std::true_type {};
 
    template<typename T, typename = void>
    struct BelongsToUserTypeGroup : std::false_type {};
 
    template<typename T>
    struct BelongsToUserTypeGroup<T, std::void_t<decltype(SerializeUserType(std::declval<T>()))>> : std::true_type {};
    
    template <size_t I>
    struct TupleVisitor
    {
        template <typename T>
        static std::string Serialize(T& tuple, size_t index)
        {
            if (index == I - 1)
            {
                return SerializeData(std::get<I - 1>(tuple));
            }
            else
            {
                return TupleVisitor<I - 1>::Serialize(tuple, index);
            }
        }
    };
 
    template <>
    struct TupleVisitor<0>
    {
        template <typename T>
        static std::string Serialize(T& tuple, size_t index) 
        {
            return SerializeData(tuple);
        }
    };
 
    template <typename... Ts>
    std::string ToString(std::tuple<Ts...> const& tuple, size_t index)
    {
        return TupleVisitor<sizeof...(Ts)>::Serialize(tuple, index);
    }
 
    template <typename... Ts>
    std::string ToString(std::tuple<Ts...>& tuple, size_t index)
    {
        return TupleVisitor<sizeof...(Ts)>::Serialize(tuple, index);
    }
 
    template <typename T>
    std::string SerializeContainer(const T& element)
    {
        std::string returnable = "{";
        for (const auto& elementPart : element)
        {
            returnable += SerializeData(elementPart);
            returnable += ",";
        }
 
        if (returnable.length() > 1)
        {
            returnable[returnable.length() - 1]='}';
        }
        else
        {
            returnable += "}";
        }
 
        return returnable;
    }
 
    template<typename T>
    std::string SerializeData(const T& element)
    {
        if constexpr (std::is_pointer<T>::value || IsSharedPointer<T>::value)
        {
            if (element == nullptr)
            {
                return "nullptr";
            }
 
            if (IsRawArrayValue<std::remove_pointer_t<T>>)
            {
                GRAIL_LOG(consts::DEFAULT_GRAIL_LOG_GROUP, logger::Severity::WARNING, "Attempted to serialize a raw array. Raw arrays are not supported for serialization.");
                return "Raw array not supported for serialization";
            }
 
            return SerializeData(*element);
        }
        else if constexpr (IsWeakPointer<T>::value)
        {
            return SerializeData(element.lock());
        }
        else if constexpr (IsContainer_Std<T>::value)
        {
            return SerializeContainer(element);
        }
        else if constexpr (CanToString<T>::value)
        {
            return std::to_string(element);
        }
        else if constexpr (IsPair<T>::value)
        {
            return "{" + SerializeData(element.first) + "," + SerializeData(element.second) + "}";
        }
        else if constexpr (IsTuple<T>::value)
        {
            std::string returnable = "{";
            for (int i = 0; i < std::tuple_size<T>::value; ++i)
            {
                if (i != 0)
                {
                    returnable += ",";
                }
 
                returnable += ToString(element, i);
            }
            return returnable + "}";
        }
 
        if constexpr (BelongsToLibraryTypeGroup<T>::value)
        {
            auto returnable = SerializeLibraryType(element);
            if(returnable != "")
            {
                return returnable;
            }
        }
        if constexpr (BelongsToUserTypeGroup<T>::value)
        {
            auto returnable = SerializeUserType(element);
            if(returnable != "")
            {
                return returnable;
            }
        }
 
        return "Serialization function for type not implemented.";
    }
 
    template<size_t N>
    std::string SerializeData(const char(&element)[N]);
 
    template<>
    std::string SerializeData<char*>(char* const& element);
 
    template<>
    std::string SerializeData(const char* const& element);
 
    template<>
    std::string SerializeData<std::string>(const std::string& element);
 
    template<>
    std::string SerializeData<Blackboard>(const Blackboard& element);
 
    struct BlackboardEntry
    {
        template <typename T>
        void SetValue(const T& value)
        {
#ifndef BUILD_UNREAL
            std::any any = value;
            data = any;
 
            serializationFunction = [](const std::any& value)
            {
                return SerializeData<T>(std::any_cast<const T&>(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 = UnsafeAny(new T{ value }, deleter, cloner);
            serializationFunction = [](const UnsafeAny& value)
            {
                return SerializeData(*static_cast<T*>(value.GetDataPointer()));
            };
#endif
        }
 
        template <typename T>
        const T& GetValue() const
        {
#ifndef BUILD_UNREAL
            return std::any_cast<const T&>(data);
#else
            return *static_cast<T*>(data.GetDataPointer());
#endif
        }
 
        std::string ToString() const
        {
            return serializationFunction(data);
        }
 
#ifndef BUILD_UNREAL
        std::any data;
        std::function<std::string(const std::any&)> serializationFunction;
#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; } };
        };
 
        UnsafeAny data;
        std::function<std::string(const UnsafeAny&)> serializationFunction;
#endif
    };
}
#endif  //GRAIL_BLACKBOARD_ENTRY_H