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