Deserializer.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 "Serialization.hpp"
 
#include "CeresEngine/DataTypes.hpp"
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/Container/Map.hpp"
#include "CeresEngine/Foundation/Container/Optional.hpp"
#include "CeresEngine/Foundation/Container/Stack.hpp"
#include "CeresEngine/Foundation/IO/Stream.hpp"
 
#include "CeresEngine/Reflection/Box.hpp"
#include "CeresEngine/Reflection/Type.hpp"
 
namespace CeresEngine {
 
#define CE_DESERIALIZER_PRIMITIVE_TYPES(F) \
    F(float, Float)                        \
    F(double, Double)                      \
    F(UInt8, UInt8)                        \
    F(UInt16, UInt16)                      \
    F(UInt32, UInt32)                      \
    F(UInt64, UInt64)                      \
    F(Int8, Int8)                          \
    F(Int16, Int16)                        \
    F(Int32, Int32)                        \
    F(Int64, Int64)                        \
    F(bool, Boolean)
 
    class IDeserializer {
    public:
        virtual ~IDeserializer() = default;
 
    public:
        virtual Optional<Box> deserialize() = 0;
    };
 
    class DeserializerState final : public SerializationState {
    public:
        HashMap<SerializedObjectID, Box> deserializedObjects;
    };
 
    class Deserializer : public IDeserializer {
    public:
        const SerializationContext& context;
 
        DeserializerState state;
 
    public:
        explicit Deserializer(const SerializationContext& context = SerializationContext::getDefault());
 
        ~Deserializer() noexcept override;
 
    public: // Deserializer interface
        [[nodiscard]] Optional<Box> deserialize() final;
 
        virtual void resetState();
 
    protected:
        struct Object final {
            friend class Deserializer;
 
            const SerializedObjectMetadata metadata;
 
            Box value;
            
            HashMap<String, Box> forgottenProperties;
        };
 
        struct Property final {
            friend class Deserializer;
 
            const SerializedPropertyMetadata metadata;
 
            const ClassProperty* const property;
 
            Box existingValue = {};
 
            const bool isInplaceSupported = false;
 
            const void* const existingValueRaw = nullptr;
 
            void cancelInplace() { const_cast<const void*&>(existingValueRaw) = nullptr; }
        };
 
        struct Array final {
            friend class Deserializer;
 
            const SerializedArrayMetadata metadata;
 
            Box value;
        };
 
        struct Map final {
            friend class Deserializer;
 
            const SerializedMapMetadata metadata;
 
            Box value;
        };
 
    public:
        [[nodiscard]] virtual Box decode(Box&& existingObject = {}) = 0;
 
    protected: // Decoding callbacks
        [[nodiscard]] Object beginObject(const SerializedObjectMetadata& metadata, Box&& existingObject = {});
 
        [[nodiscard]] Box endObject(Object& object);
 
        [[nodiscard]] Property beginObjectProperty(const Object& object, const SerializedPropertyMetadata& metadata);
 
        void endObjectProperty(Object& object, const Property& property, Box&& value);
 
        [[nodiscard]] Box objectReference(SerializedObjectID referenceID);
 
        [[nodiscard]] Box binary(InputStream& stream, Box&& existingObject);
 
        [[nodiscard]] Array beginArray(const SerializedArrayMetadata& metadata, Box&& existingObject = {});
 
        void arrayElement(const Array& array, Box&& value);
 
        [[nodiscard]] Box endArray(Array& array);
 
        Map beginMap(const SerializedMapMetadata& metadata, Box&& existingObject = {});
 
        void mapElement(const Map& map, Box&& key, Box&& value);
 
        [[nodiscard]] Box endMap(Map& map);
    };
 
} // namespace CeresEngine