Serialization.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "Forward.hpp"
 
#include "CeresEngine/DataTypes.hpp"
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/Exception.hpp"
#include "CeresEngine/Foundation/Flags.hpp"
#include "CeresEngine/Foundation/Function.hpp"
#include "CeresEngine/Foundation/Container/Map.hpp"
#include "CeresEngine/Foundation/Container/MultiMap.hpp"
#include "CeresEngine/Foundation/Container/Optional.hpp"
 
#include "CeresEngine/Reflection/Box.hpp"
#include "CeresEngine/Reflection/Type.hpp"
 
namespace CeresEngine {
 
    enum class SerializedObjectMetadataFlag : UInt32 {
        None = 0,
 
        Polymorphic = (1u << 0u),
 
        Custom = (1u << 1u),
    };
 
    using SerializedObjectMetadataFlags = Flags<SerializedObjectMetadataFlag>;
 
    struct SerializedObjectMetadata {
        SerializedObjectMetadataFlags flags = SerializedObjectMetadataFlag::None;
 
        Type type;
 
        Optional<SerializedObjectID> objectID = nullopt;
    };
 
    // ---------------------------------------------------------------------------------------------
 
    enum class SerializedPropertyMetadataFlag : UInt32 {
        None = 0,
    };
 
    using SerializedPropertyMetadataFlags = Flags<SerializedPropertyMetadataFlag>;
 
    struct SerializedPropertyMetadata final {
        SerializedPropertyMetadataFlags flags = SerializedPropertyMetadataFlag::None;
 
        StringView name;
    };
 
    // ---------------------------------------------------------------------------------------------
 
    enum class SerializedCustomObjectMetadataFlag : UInt32 {
        None = 0,
    };
 
    using SerializedCustomObjectMetadataFlags = Flags<SerializedCustomObjectMetadataFlag>;
 
    struct SerializedCustomObjectMetadata {
        SerializedCustomObjectMetadataFlags flags = SerializedCustomObjectMetadataFlag::None;
    };
 
    // ---------------------------------------------------------------------------------------------
 
    enum class SerializedArrayMetadataFlag : UInt32 {
        None = 0,
    };
 
    using SerializedArrayMetadataFlags = Flags<SerializedArrayMetadataFlag>;
 
    struct SerializedArrayMetadata final {
        SerializedArrayMetadataFlags flags = SerializedArrayMetadataFlag::None;
 
        TypeID elementType;
 
        UInt32 length = ~0u;
    };
 
    // ---------------------------------------------------------------------------------------------
 
    enum class SerializedMapMetadataFlag : UInt32 {
        None = 0,
    };
 
    using SerializedMapMetadataFlags = Flags<SerializedMapMetadataFlag>;
 
    struct SerializedMapMetadata final {
        SerializedMapMetadataFlags flags = SerializedMapMetadataFlag::None;
 
        TypeID keyType;
 
        TypeID valueType;
 
        UInt32 length = ~0u;
    };
 
    // ---------------------------------------------------------------------------------------------
    // ---------------------------------------------------------------------------------------------
 
    class SerializationContext;
 
    using DeserializerConstructor = UniqueFunction<Box(const SerializationContext& context, SerializationState& state, const Type& type) const>;
 
    using DeserializerPropertyMigrator = UniqueFunction<Box(const SerializationContext& context, SerializationState& state, Box& object,
        const SerializedPropertyMetadata& property, Box& value) const>;
 
    using CustomSerializer = UniqueFunction<void(Serializer&, const Box&) const>;
 
    using CustomDeserializer = UniqueFunction<Box(Deserializer&, Box&&) const>;
 
    struct CustomSerializationOptions {
        UInt16 version = 0;
    };
 
    class SerializationContext {
    private:
        const SerializationContext* mParent = nullptr;
 
        using Constructor = DeserializerConstructor;
 
        HashMap<TypeID, Constructor> mConstructors;
 
        using PropertyMigration = DeserializerPropertyMigrator;
        HashMap<TypeID, HashMap<String, PropertyMigration>> mPropertyMigrations;
 
        struct CustomSerialization {
            CustomSerializationOptions options;
 
            CustomSerializer serializer;
 
            CustomDeserializer deserializer;
        };
 
        HashMap<TypeID, CustomSerialization> mCustomSerialization;
 
    public:
        explicit SerializationContext() noexcept = default;
 
        SerializationContext(const SerializationContext& parent) : mParent(&parent) {}
 
    public: // Constructors
        template<typename T> void addConstructor(Constructor&& constructor) {
            const TypeID typeID = getTypeID<T>();
            CE_ASSERT(mConstructors.find(typeID) == mConstructors.end());
            mConstructors[typeID] = std::move(constructor);
        }
 
        [[nodiscard]] Box construct(SerializationState& state, const Type& type) const;
 
        template<typename T> [[nodiscard]] Box construct(SerializationState& state) const { return construct(state, getType<T>()); }
 
    public: // Property migrations
        template<typename T> void addPropertyMigration(const StringView propertyName, PropertyMigration&& migration) {
            const TypeID typeID = getTypeID<T>();
            HashMap<String, PropertyMigration>& propertyMigrationsForType = mPropertyMigrations[typeID];
            propertyMigrationsForType[String(propertyName)] = std::move(migration);
        }
 
    public:
        template<typename T, typename CustomSerializer, typename CustomDeserializer>
        void addCustomSerialization(CustomSerializer&& customSerializer, CustomDeserializer&& customDeserializer) {
            return addCustomSerialization<T>(CustomSerializationOptions{}, std::forward<CustomSerializer>(customSerializer), std::forward<CustomDeserializer>(customDeserializer));
        }
 
        template<typename T, typename CustomSerializer, typename CustomDeserializer>
        void addCustomSerialization(const CustomSerializationOptions& options, CustomSerializer&& customSerializer, CustomDeserializer&& customDeserializer) {
            addCustomSerialization(
                getType<T>(), options,
                [customSerializer = std::move(customSerializer)](Serializer& serializer, const Box& value) {
                    customSerializer(serializer, value.cref<T>());
                },
                [customDeserializer = std::move(customDeserializer)](Deserializer& deserializer, Box&& value) {
                    customDeserializer(deserializer, value.ref<T>());
                    return std::move(value);
                });
        }
 
        void addCustomSerialization(const Type& type, CustomSerializer&& customSerializer, CustomDeserializer&& customDeserializer) {
            return addCustomSerialization(type, CustomSerializationOptions{}, std::move(customSerializer), std::move(customDeserializer));
        }
 
        void addCustomSerialization(const Type& type, const CustomSerializationOptions& options, CustomSerializer&& customSerializer, CustomDeserializer&& customDeserializer);
 
        [[nodiscard]] const CustomSerializationOptions& getCustomSerializationOptions(const Type& type) const;
 
        [[nodiscard]] const CustomSerializer& getCustomSerializer(const Type& type) const;
 
        [[nodiscard]] const CustomDeserializer& getCustomDeserializer(const Type& type) const;
 
    public: // Serialization callbacks
        void willSerialize(const Box& object) const;
 
        void didSerialize(const Box& object) const;
 
        void willSerializeProperty(const Box& object, const ClassProperty& property) const;
 
        void didSerializeProperty(const Box& object, const ClassProperty& property) const;
        
    public: // Deserialization callbacks
        void willDeserialize(const Box& object) const;
 
        void didDeserialize(const Box& object) const;
 
        void willDeserializeProperty(const Box& object, const ClassProperty& property) const;
 
        void didDeserializeProperty(const Box& object, const ClassProperty& property) const;
 
    public:
        static const SerializationContext& getDefault();
 
    private:
        template<typename Func> using ForEachContextReturnType = std::invoke_result_t<Func, const SerializationContext&>;
 
        template<typename Func> [[nodiscard]] ForEachContextReturnType<Func> forEachContext(Func&& func, const ForEachContextReturnType<Func>& defaultValue = {}) const;
 
        template<typename K, typename V, typename Hash, typename KeyEqual, typename RawAllocator> [[nodiscard]] const V* recursiveLookup(HashMap<K, V, Hash, KeyEqual, RawAllocator> SerializationContext::*ptr, const K& key) const;
    };
 
    class SerializationState {
    private:
        MultiMap<Type, Box> mObjects;
 
    public:
        virtual ~SerializationState() noexcept = default;
 
    public:
        [[nodiscard]] virtual bool isSerializerState() const noexcept { return false; };
 
        [[nodiscard]] virtual bool isDeserializerState() const noexcept { return false; };
 
    public: // State object stack
        template<typename T, typename... Args> T& pushObjectValue(Args&&... args) {
            const auto iterator = mObjects.emplace( //
                std::piecewise_construct, //
                std::forward_as_tuple(getType<T>().getDecayType()), //
                std::forward_as_tuple(args...));
            return iterator->second.template ref<T>();
        }
 
        template<typename T> T& pushObject(T& object) {
            mObjects.emplace( //
                std::piecewise_construct, //
                std::forward_as_tuple(getType<T>().getDecayType()), //
                std::forward_as_tuple(std::ref(object)));
            return object;
        }
 
        template<typename T> T& getObject() {
            if(T* const object = getObjectIf<T>()) {
                return *object;
            }
 
            throw RuntimeError("Failed to get object with type. The object with the given type is not present on the map.");
        }
 
        template<typename T> const T& getObject() const { return const_cast<SerializationState*>(this)->getObject<T>(); }
 
        template<typename T> T* getObjectIf() {
            if(mObjects.count(getType<T>().getDecayType()) == 0) {
                return nullptr;
            }
 
            auto found = mObjects.upper_bound(getType<T>().getDecayType());
            if(found != mObjects.begin()) {
                --found;
            } else if(found == mObjects.end()) {
                return nullptr;
            }
 
            return &(found->second.template ref<T>());
        }
 
        template<typename T> const T* getObjectIf() const { return const_cast<SerializationState*>(this)->getObjectIf<T>(); }
 
        template<typename T> void popObject() {
            auto found = mObjects.upper_bound(getType<T>().getDecayType());
 
            if(found != mObjects.begin()) {
                --found;
            } else if(found == mObjects.end()) {
                throw RuntimeError("Unable to pop object. The object type is not present on the object map.");
            }
 
            mObjects.erase(found);
        }
    };
 
    template<typename T> struct SerializationStateObject {
        SerializationState& state;
 
        SerializationStateObject(SerializationState& state, T& object) : state(state) { state.pushObject<T>(object); }
 
        ~SerializationStateObject() { state.popObject<T>(); }
    };
 
    CE_EXCEPTION_DECL2(SerializationError, RuntimeError);
 
} // namespace CeresEngine