SerializableObjectFieldSerializer.h

#pragma once
 
// Standard.
#include <variant>
 
// Custom.
#include "io/serializers/IFieldSerializer.hpp"
 
namespace rfk {
    class Struct;
    class Field;
    class Archetype;
} // namespace rfk
 
namespace ne {
    class SerializableObjectFieldSerializer : public IFieldSerializer {
        // Checks GUIDs uniqueness in debug builds.
        friend class GameManager;
 
    public:
        SerializableObjectFieldSerializer() = default;
        virtual ~SerializableObjectFieldSerializer() override = default;
 
        [[nodiscard]] static std::optional<Error> serializeFieldObject(
            Serializable* pObject,
            toml::value* pTomlData,
            const std::string& sFieldName,
            const std::string& sSectionName,
            const std::string& sEntityId,
            size_t& iSubEntityId,
            Serializable* pOriginalObject = nullptr);
 
        [[nodiscard]] static std::optional<Error>
        cloneSerializableObject(Serializable* pFrom, Serializable* pTo, bool bNotifyAboutDeserialized);
 
        static std::variant<std::unique_ptr<Serializable>, Error> deserializeSerializableObject(
            const toml::value* pTomlDocument,
            const toml::value* pTomlValue,
            const std::string& sFieldName,
            Serializable* pTarget,
            const std::string& sOwnerSectionName,
            const std::string& sEntityId,
            std::unordered_map<std::string, std::string>& customAttributes);
 
        static bool isSerializableObjectValueEqual(Serializable* pObjectA, Serializable* pObjectB);
 
        static bool isTypeDerivesFromSerializable(const std::string& sCanonicalTypeName);
 
        static bool isFieldSerializable(rfk::Field const& field);
 
        static bool isDerivedFromSerializable(rfk::Archetype const* pArchetype);
 
        virtual bool isFieldTypeSupported(const rfk::Field* pField) override;
 
        [[nodiscard]] virtual std::optional<Error> serializeField(
            toml::value* pTomlData,
            Serializable* pFieldOwner,
            const rfk::Field* pField,
            const std::string& sSectionName,
            const std::string& sEntityId,
            size_t& iSubEntityId,
            Serializable* pOriginalObject = nullptr) override;
 
        [[nodiscard]] virtual std::optional<Error> deserializeField(
            const toml::value* pTomlDocument,
            const toml::value* pTomlValue,
            Serializable* pFieldOwner,
            const rfk::Field* pField,
            const std::string& sOwnerSectionName,
            const std::string& sEntityId,
            std::unordered_map<std::string, std::string>& customAttributes) override;
 
        [[nodiscard]] virtual std::optional<Error> cloneField(
            Serializable* pFromInstance,
            const rfk::Field* pFromField,
            Serializable* pToInstance,
            const rfk::Field* pToField) override;
 
        virtual bool isFieldValueEqual(
            Serializable* pFieldAOwner,
            const rfk::Field* pFieldA,
            Serializable* pFieldBOwner,
            const rfk::Field* pFieldB) override;
 
    private:
#if defined(DEBUG)
        static void checkGuidUniqueness();
 
        static void collectGuids(
            const rfk::Struct* pArchetypeToAnalyze, std::unordered_map<std::string, std::string>& vAllGuids);
#endif
 
        static bool isTypeDerivesFromSerializable(
            const std::string& sCanonicalTypeName, const rfk::Namespace* pNamespace);
 
        static inline const auto sSubEntityFieldNameKey = ".field_name";
    };
} // namespace ne