Serializable.h

#pragma once
 
// Standard.
#include <filesystem>
#include <memory>
#include <variant>
#include <optional>
#include <set>
#include <format>
 
// Custom.
#include "misc/Error.h"
#include "io/Logger.h"
#include "misc/ProjectPaths.h"
#include "io/ConfigManager.h"
#include "io/properties/GuidProperty.h"
#include "io/properties/SerializeProperty.h"
#include "io/serializers/SerializableObjectFieldSerializer.h"
#include "io/FieldSerializerManager.h"
 
// External.
#include "Refureku/Object.h"
#include "GcPtr.h"
 
#include "Serializable.generated.h"
 
namespace ne RNAMESPACE() {
    class Serializable;
 
    struct SerializableObjectInformation {
    public:
        SerializableObjectInformation() = delete;
 
        SerializableObjectInformation(
            Serializable* pObject,
            const std::string& sObjectUniqueId,
            const std::unordered_map<std::string, std::string>& customAttributes = {},
            Serializable* pOriginalObject = nullptr) {
            this->pObject = pObject;
            this->sObjectUniqueId = sObjectUniqueId;
            this->customAttributes = customAttributes;
            this->pOriginalObject = pOriginalObject;
        }
 
        Serializable* pObject = nullptr;
 
        Serializable* pOriginalObject = nullptr;
 
        std::string sObjectUniqueId;
 
        std::unordered_map<std::string, std::string> customAttributes;
    };
 
    template <typename SmartPointer, typename InnerType = typename SmartPointer::element_type>
        requires std::same_as<SmartPointer, sgc::GcPtr<Serializable>> ||
                 std::same_as<SmartPointer, std::unique_ptr<Serializable>>
    struct DeserializedObjectInformation {
    public:
        DeserializedObjectInformation() = delete;
 
        DeserializedObjectInformation(
            SmartPointer pObject,
            std::string sObjectUniqueId,
            std::unordered_map<std::string, std::string> customAttributes) {
            this->pObject = std::move(pObject);
            this->sObjectUniqueId = sObjectUniqueId;
            this->customAttributes = customAttributes;
        }
 
        SmartPointer pObject;
 
        std::string sObjectUniqueId;
 
        std::unordered_map<std::string, std::string> customAttributes;
    };
 
    class RCLASS(Guid("f5a59b47-ead8-4da4-892e-cf05abb2f3cc")) Serializable : public rfk::Object {
        // This field serializer will call `onAfterDeserialized` after deserialization.
        friend class SerializableObjectFieldSerializer;
 
    public:
        Serializable() = default;
        virtual ~Serializable() override = default;
 
        [[nodiscard]] std::optional<Error> serialize(
            std::filesystem::path pathToFile,
            bool bEnableBackup,
            const std::unordered_map<std::string, std::string>& customAttributes = {});
 
        [[nodiscard]] static std::optional<Error> serializeMultiple(
            std::filesystem::path pathToFile,
            std::vector<SerializableObjectInformation> vObjects,
            bool bEnableBackup);
 
        [[nodiscard]] std::variant<std::string, Error> serialize(
            toml::value& tomlData,
            const std::string& sEntityId = "",
            const std::unordered_map<std::string, std::string>& customAttributes = {},
            const std::optional<std::filesystem::path>& optionalPathToFile = {},
            bool bEnableBackup = false);
 
        [[nodiscard]] std::variant<std::string, Error> serialize(
            toml::value& tomlData,
            Serializable* pOriginalObject,
            std::string sEntityId = "",
            const std::unordered_map<std::string, std::string>& customAttributes = {},
            const std::optional<std::filesystem::path>& optionalPathToFile = {},
            bool bEnableBackup = false);
 
        static std::variant<std::set<std::string>, Error> getIdsFromFile(std::filesystem::path pathToFile);
 
        template <typename SmartPointer, typename InnerType = typename SmartPointer::element_type>
            requires std::derived_from<InnerType, Serializable> &&
                     (std::same_as<SmartPointer, sgc::GcPtr<InnerType>> ||
                      std::same_as<SmartPointer, std::unique_ptr<InnerType>>)
        static std::variant<SmartPointer, Error> deserialize(const std::filesystem::path& pathToFile);
 
        template <typename SmartPointer, typename InnerType = typename SmartPointer::element_type>
            requires std::derived_from<InnerType, Serializable> &&
                     (std::same_as<SmartPointer, sgc::GcPtr<InnerType>> ||
                      std::same_as<SmartPointer, std::unique_ptr<InnerType>>)
        static std::variant<SmartPointer, Error> deserialize(
            const std::filesystem::path& pathToFile,
            std::unordered_map<std::string, std::string>& customAttributes);
 
        template <typename SmartPointer, typename InnerType = typename SmartPointer::element_type>
            requires std::derived_from<InnerType, Serializable> &&
                     (std::same_as<SmartPointer, sgc::GcPtr<InnerType>> ||
                      std::same_as<SmartPointer, std::unique_ptr<InnerType>>)
        static std::variant<SmartPointer, Error> deserialize(
            std::filesystem::path pathToFile,
            std::unordered_map<std::string, std::string>& customAttributes,
            const std::string& sEntityId);
 
        template <typename SmartPointer, typename InnerType = typename SmartPointer::element_type>
            requires std::derived_from<InnerType, Serializable> &&
                     (std::same_as<SmartPointer, sgc::GcPtr<InnerType>> ||
                      std::same_as<SmartPointer, std::unique_ptr<InnerType>>)
        static std::variant<SmartPointer, Error> deserialize(
            const std::filesystem::path& pathToFile, const std::string& sEntityId);
 
        template <typename SmartPointer, typename InnerType = typename SmartPointer::element_type>
            requires std::same_as<SmartPointer, sgc::GcPtr<Serializable>> ||
                     std::same_as<SmartPointer, std::unique_ptr<Serializable>>
        static std::variant<std::vector<DeserializedObjectInformation<SmartPointer>>, Error>
        deserializeMultiple(std::filesystem::path pathToFile, const std::set<std::string>& ids);
 
        template <typename SmartPointer, typename InnerType = typename SmartPointer::element_type>
            requires std::derived_from<InnerType, Serializable> &&
                     (std::same_as<SmartPointer, sgc::GcPtr<InnerType>> ||
                      std::same_as<SmartPointer, std::unique_ptr<InnerType>>)
        static std::variant<SmartPointer, Error> deserialize(
            const toml::value& tomlData,
            std::unordered_map<std::string, std::string>& customAttributes,
            std::string sEntityId = "",
            std::optional<std::filesystem::path> optionalPathToFile = {});
 
        std::optional<std::pair<std::string, std::string>> getPathDeserializedFromRelativeToRes() const;
 
    protected:
        virtual void onAfterDeserialized() {}
 
    private:
        [[nodiscard]] static std::optional<Error> resolvePathToToml(std::filesystem::path& pathToFile);
 
        static const rfk::Class* getClassForGuid(const std::string& sGuid);
 
        static const rfk::Struct*
        getClassForGuid(const rfk::Struct* pArchetypeToAnalyze, const std::string& sGuid);
 
        std::optional<std::pair<std::string, std::string>> pathDeserializedFromRelativeToRes;
 
        static inline const auto sSubEntityFieldNameKey = ".field_name";
 
        static inline const auto sPathRelativeToResKey = ".path_relative_to_res";
 
        static inline const auto sNothingToSerializeKey = ".none";
 
        static constexpr std::string_view sCustomAttributePrefix = "..";
 
        ne_Serializable_GENERATED
    };
 
    template <typename SmartPointer, typename InnerType>
        requires std::derived_from<InnerType, Serializable> &&
                 (std::same_as<SmartPointer, sgc::GcPtr<InnerType>> ||
                  std::same_as<SmartPointer, std::unique_ptr<InnerType>>)
    std::variant<SmartPointer, Error> Serializable::deserialize(const std::filesystem::path& pathToFile) {
        std::unordered_map<std::string, std::string> foundCustomAttributes;
        return deserialize<SmartPointer>(pathToFile, foundCustomAttributes);
    }
 
    template <typename SmartPointer, typename InnerType>
        requires std::derived_from<InnerType, Serializable> &&
                 (std::same_as<SmartPointer, sgc::GcPtr<InnerType>> ||
                  std::same_as<SmartPointer, std::unique_ptr<InnerType>>)
    std::variant<SmartPointer, Error> Serializable::deserialize(
        const std::filesystem::path& pathToFile,
        std::unordered_map<std::string, std::string>& customAttributes) {
        return deserialize<SmartPointer>(pathToFile, customAttributes, "");
    }
 
    template <typename SmartPointer, typename InnerType>
        requires std::derived_from<InnerType, Serializable> &&
                 (std::same_as<SmartPointer, sgc::GcPtr<InnerType>> ||
                  std::same_as<SmartPointer, std::unique_ptr<InnerType>>)
    std::variant<SmartPointer, Error> Serializable::deserialize(
        const std::filesystem::path& pathToFile, const std::string& sEntityId) {
        std::unordered_map<std::string, std::string> foundCustomAttributes;
        return deserialize<SmartPointer>(pathToFile, foundCustomAttributes, sEntityId);
    }
 
    template <typename SmartPointer, typename InnerType>
        requires std::same_as<SmartPointer, sgc::GcPtr<Serializable>> ||
                 std::same_as<SmartPointer, std::unique_ptr<Serializable>>
    std::variant<std::vector<DeserializedObjectInformation<SmartPointer>>, Error>
    Serializable::deserializeMultiple(std::filesystem::path pathToFile, const std::set<std::string>& ids) {
        // Check that specified IDs don't have dots in them.
        for (const auto& sId : ids) {
            if (sId.contains('.')) [[unlikely]] {
                return Error(
                    std::format("the specified object ID \"{}\" is not allowed to have dots in it", sId));
            }
        }
 
        // Resolve path.
        auto optionalError = resolvePathToToml(pathToFile);
        if (optionalError.has_value()) [[unlikely]] {
            auto error = std::move(optionalError.value());
            error.addCurrentLocationToErrorStack();
            return error;
        }
 
        // Parse file.
        toml::value tomlData;
        try {
            tomlData = toml::parse(pathToFile);
        } catch (std::exception& exception) {
            return Error(std::format(
                "failed to parse TOML file at \"{}\", error: {}", pathToFile.string(), exception.what()));
        }
 
        // Deserialize.
        std::vector<DeserializedObjectInformation<SmartPointer>> deserializedObjects;
        for (const auto& sEntityId : ids) {
            // Deserialize object with the specified entity ID.
            std::unordered_map<std::string, std::string> customAttributes;
            auto result = deserialize<SmartPointer>(tomlData, customAttributes, sEntityId, pathToFile);
            if (std::holds_alternative<Error>(result)) [[unlikely]] {
                auto error = std::get<Error>(std::move(result));
                error.addCurrentLocationToErrorStack();
                return error;
            }
 
            // Save object info.
            DeserializedObjectInformation objectInfo(
                std::get<SmartPointer>(std::move(result)), sEntityId, customAttributes);
            deserializedObjects.push_back(std::move(objectInfo));
        }
 
        return deserializedObjects;
    }
 
    template <typename SmartPointer, typename InnerType>
        requires std::derived_from<InnerType, Serializable> &&
                 (std::same_as<SmartPointer, sgc::GcPtr<InnerType>> ||
                  std::same_as<SmartPointer, std::unique_ptr<InnerType>>)
    std::variant<SmartPointer, Error> Serializable::deserialize(
        std::filesystem::path pathToFile,
        std::unordered_map<std::string, std::string>& customAttributes,
        const std::string& sEntityId) {
        // Resolve path.
        auto optionalError = resolvePathToToml(pathToFile);
        if (optionalError.has_value()) [[unlikely]] {
            auto error = std::move(optionalError.value());
            error.addCurrentLocationToErrorStack();
            return error;
        }
 
        // Parse file.
        toml::value tomlData;
        try {
            tomlData = toml::parse(pathToFile);
        } catch (std::exception& exception) {
            return Error(std::format(
                "failed to parse TOML file at \"{}\", error: {}", pathToFile.string(), exception.what()));
        }
 
        // Deserialize.
        return deserialize<SmartPointer>(tomlData, customAttributes, sEntityId, pathToFile);
    }
 
    template <typename SmartPointer, typename InnerType>
        requires std::derived_from<InnerType, Serializable> &&
                 (std::same_as<SmartPointer, sgc::GcPtr<InnerType>> ||
                  std::same_as<SmartPointer, std::unique_ptr<InnerType>>)
    std::variant<SmartPointer, Error> Serializable::deserialize(
        const toml::value& tomlData,
        std::unordered_map<std::string, std::string>& customAttributes,
        std::string sEntityId,
        std::optional<std::filesystem::path> optionalPathToFile) {
        if (sEntityId.empty()) {
            // Put something as entity ID so it would not look weird.
            sEntityId = "0";
        }
 
        // Read TOML as table.
        const auto fileTable = tomlData.as_table();
 
        // Check that we have at least one section.
        if (fileTable.empty()) [[unlikely]] {
            return Error("provided toml value has 0 sections while expected at least 1 section");
        }
 
        // Find a section that starts with the specified entity ID.
        // Each entity section has the following format: [entityId.GUID]
        // For sub entities (field with reflected type) format: [parentEntityId.childEntityId.childGUID]
        std::string sTargetSection;
        std::string sTypeGuid;
        for (const auto& [sSectionName, value] : fileTable) {
            // We can't just use `sSectionName.starts_with(sEntityId)` because we might make a mistake in the
            // following situation: [100...] with entity ID equal to "10" and even if we add a dot
            // to `sEntityId` we still might make a mistake in the following situation:
            // [10.30.GUID] while we look for just [10.GUID].
 
            // Get ID end position (GUID start position).
            const auto iIdEndDotPos = sSectionName.rfind('.');
            if (iIdEndDotPos == std::string::npos) [[unlikely]] {
                return Error("provided toml value does not contain entity ID");
            }
            if (iIdEndDotPos + 1 == sSectionName.size()) [[unlikely]] {
                return Error(std::format("section name \"{}\" does not have a GUID", sSectionName));
            }
            if (iIdEndDotPos == 0) [[unlikely]] {
                return Error(std::format("section \"{}\" is not full", sSectionName));
            }
 
            // Get ID chain (either entity ID or something like "parentEntityId.childEntityId").
            if (std::string_view(sSectionName.data(), iIdEndDotPos) != sEntityId) { // compare without copy
                continue;
            }
 
            // Save target section name.
            sTargetSection = sSectionName;
 
            // Save this entity's GUID.
            sTypeGuid = sSectionName.substr(iIdEndDotPos + 1);
 
            break;
        }
 
        // Make sure something was found.
        if (sTargetSection.empty()) [[unlikely]] {
            return Error(std::format("could not find entity with ID \"{}\"", sEntityId));
        }
 
        // Get all keys (field names) from this section.
        const auto& targetSection = fileTable.at(sTargetSection);
        if (!targetSection.is_table()) [[unlikely]] {
            return Error(std::format("found \"{}\" section is not a section", sTargetSection));
        }
 
        // Collect keys from target section.
        const auto& sectionTable = targetSection.as_table();
        std::unordered_map<std::string_view, const toml::value*> fieldsToDeserialize;
        SmartPointer pOriginalEntity = nullptr;
        for (const auto& [sKey, value] : sectionTable) {
            if (sKey == sNothingToSerializeKey) {
                continue;
            } else if (sKey == sPathRelativeToResKey) {
                // Make sure the value is string.
                if (!value.is_string()) [[unlikely]] {
                    return Error(
                        std::format("found \"{}\" key's value is not string", sPathRelativeToResKey));
                }
 
                // Deserialize original entity.
                auto deserializeResult = Serializable::deserialize<SmartPointer>(
                    ProjectPaths::getPathToResDirectory(ResourceDirectory::ROOT) / value.as_string().str);
                if (std::holds_alternative<Error>(deserializeResult)) [[unlikely]] {
                    auto error = std::get<Error>(std::move(deserializeResult));
                    error.addCurrentLocationToErrorStack();
                    return error;
                }
                pOriginalEntity = std::get<SmartPointer>(std::move(deserializeResult));
            } else if (sKey.starts_with(sCustomAttributePrefix)) {
                // Custom attribute.
                // Make sure it's a string.
                if (!value.is_string()) [[unlikely]] {
                    return Error(std::format("found custom attribute \"{}\" is not a string", sKey));
                }
 
                // Add attribute.
                customAttributes[sKey.substr(sCustomAttributePrefix.size())] = value.as_string().str;
            } else {
                fieldsToDeserialize[sKey] = &value;
            }
        }
 
        // Get archetype for found GUID.
        const auto pType = getClassForGuid(sTypeGuid);
        if (pType == nullptr) [[unlikely]] {
            if (pOriginalEntity) {
                return Error(std::format(
                    "GUID \"{}\" was not found in the database, but "
                    "the original object at \"{}\" (ID \"{}\") was deserialized",
                    sTypeGuid,
                    pOriginalEntity->getPathDeserializedFromRelativeToRes().value().first,
                    pOriginalEntity->getPathDeserializedFromRelativeToRes().value().second));
            } else {
                return Error(std::format("no type found for GUID \"{}\"", sTypeGuid));
            }
        }
 
        // Make sure the type indeed derives from serializable.
        if (!SerializableObjectFieldSerializer::isDerivedFromSerializable(pType)) [[unlikely]] {
            if (pOriginalEntity) {
                return Error(std::format(
                    "deserialized type for \"{}\" does not derive from {}, but "
                    "the original object at \"{}\" (ID \"{}\") was deserialized",
                    sTypeGuid,
                    staticGetArchetype().getName(),
                    pOriginalEntity->getPathDeserializedFromRelativeToRes().value().first,
                    pOriginalEntity->getPathDeserializedFromRelativeToRes().value().second));
            } else {
                return Error(std::format(
                    "deserialized type with GUID \"{}\" does not derive from {}",
                    sTypeGuid,
                    staticGetArchetype().getName()));
            }
        }
 
        // Create instance.
        SmartPointer pSmartPointerInstance = nullptr;
        if (pOriginalEntity != nullptr) {
            // Use the original entity instead of creating a new one.
            pSmartPointerInstance = std::move(pOriginalEntity);
        }
        if (pSmartPointerInstance == nullptr) {
            if constexpr (std::is_same_v<SmartPointer, std::unique_ptr<InnerType>>) {
                // Create a unique instance.
                pSmartPointerInstance = pType->makeUniqueInstance<InnerType>();
                if (pSmartPointerInstance == nullptr) [[unlikely]] {
                    return Error(std::format(
                        "unable to make an object of type \"{}\" using type's default constructor "
                        "(does type \"{}\" has a default constructor?)",
                        pType->getName(),
                        pType->getName()));
                }
            }
            // NOTE: don't allow deserializing into a `shared_ptr` since it may create a false assumption
            // that this `shared_ptr` will also save/load its referenced entity or keep its reference
            // (you can easily convert a unique_ptr to a shared_ptr so it should not be an issue).
            else if (std::is_same_v<SmartPointer, sgc::GcPtr<InnerType>>) {
                // Create GC instance.
                // (this part is a temporary solution until we will add a `makeGcFromThisType` method to
                // `rfk::Struct`)
                std::unique_ptr<InnerType> pInstance = pType->makeUniqueInstance<InnerType>();
                if (pInstance == nullptr) [[unlikely]] {
                    return Error(std::format(
                        "unable to make an object of type \"{}\" using type's default constructor "
                        "(does type \"{}\" has a default constructor?)",
                        pType->getName(),
                        pType->getName()));
                }
                sgc::GcPtr<rfk::Object> pParentGcInstance = pInstance->makeGcFromThisType();
                pSmartPointerInstance = dynamic_cast<InnerType*>(pParentGcInstance.get());
                if (pSmartPointerInstance == nullptr) [[unlikely]] {
                    return Error(std::format(
                        "dynamic cast failed to cast the type \"{}\" to the specified template argument "
                        "(are you trying to deserialize into a wrong type?)",
                        pParentGcInstance->getArchetype().getName()));
                }
            } else [[unlikely]] {
                return Error("unexpected smart pointer type received");
            }
        }
 
        // Get field serializers.
        const auto vFieldSerializers = FieldSerializerManager::getFieldSerializers();
        const auto vBinaryFieldSerializers = FieldSerializerManager::getBinaryFieldSerializers();
 
        // Deserialize fields.
        for (auto& [sFieldName, pFieldTomlValue] : fieldsToDeserialize) {
            if (sFieldName == sSubEntityFieldNameKey) {
                // This field is used as section metadata and tells us what field of parent entity
                // this section describes.
                continue;
            }
 
            // Get field by name.
            rfk::Field const* pField =
                pType->getFieldByName(sFieldName.data(), rfk::EFieldFlags::Default, true);
            if (pField == nullptr) [[unlikely]] { // rarely happens
                Logger::get().warn(std::format(
                    "field name \"{}\" exists in the specified toml value but does not exist in the "
                    "actual object (if you removed/renamed this reflected field from your "
                    "class/struct - ignore this warning)",
                    sFieldName));
                continue;
            }
            const auto sFieldCanonicalTypeName = std::string(pField->getCanonicalTypeName());
 
            // Check if it's serializable.
            if (!SerializableObjectFieldSerializer::isFieldSerializable(*pField)) {
                continue;
            }
 
            // Check if we need to deserialize from external file.
            const auto pSerializeProperty = pField->getProperty<Serialize>();
            if (pSerializeProperty->getSerializationType() == FieldSerializationType::FST_AS_EXTERNAL_FILE ||
                pSerializeProperty->getSerializationType() ==
                    FieldSerializationType::FST_AS_EXTERNAL_BINARY_FILE) {
                // Make sure this field derives from `Serializable`.
                if (!SerializableObjectFieldSerializer::isDerivedFromSerializable(
                        pField->getType().getArchetype())) [[unlikely]] {
                    // Show an error so that the developer will instantly see the mistake.
                    auto error = Error("only fields of type derived from `Serializable` can use "
                                       "`SerializeAsExternal` property");
                    error.showError();
                    throw std::runtime_error(error.getFullErrorMessage());
                }
 
                // Make sure path to the main file is specified.
                if (!optionalPathToFile.has_value()) [[unlikely]] {
                    return Error("unable to deserialize field marked as `SerializeAsExternal` "
                                 "because path to the main file was not specified");
                }
 
                // Prepare path to the external file.
                if (!pFieldTomlValue->is_string()) [[unlikely]] {
                    return Error(std::format(
                        "expected field \"{}\" to store external filename in file \"{}\"",
                        pField->getName(),
                        optionalPathToFile.value().string()));
                }
                const auto sExternalFileName = pFieldTomlValue->as_string().str;
                const auto pathToExternalFile = optionalPathToFile.value().parent_path() / sExternalFileName;
 
                // Get field object.
                const auto pFieldObject =
                    reinterpret_cast<Serializable*>(pField->getPtrUnsafe(pSmartPointerInstance.get()));
 
                if (pSerializeProperty->getSerializationType() == FST_AS_EXTERNAL_FILE) {
                    // Deserialize external file.
                    auto result = deserialize<std::unique_ptr<Serializable>>(pathToExternalFile);
                    if (std::holds_alternative<Error>(result)) [[unlikely]] {
                        auto error = std::get<Error>(std::move(result));
                        error.addCurrentLocationToErrorStack();
                        return error;
                    }
                    const auto pDeserializedExternalField =
                        std::get<std::unique_ptr<Serializable>>(std::move(result));
 
                    // Clone deserialized data to field.
                    auto optionalError = SerializableObjectFieldSerializer::cloneSerializableObject(
                        pDeserializedExternalField.get(), pFieldObject, false);
                    if (optionalError.has_value()) [[unlikely]] {
                        auto error = optionalError.value();
                        error.addCurrentLocationToErrorStack();
                        return error;
                    }
                } else if (pSerializeProperty->getSerializationType() == FST_AS_EXTERNAL_BINARY_FILE) {
                    // Deserialize binary file.
                    bool bDeserialized = false;
                    for (const auto& pBinarySerializer : vBinaryFieldSerializers) {
                        if (!pBinarySerializer->isFieldTypeSupported(pField)) {
                            continue;
                        }
 
                        // Deserialize as binary.
                        auto optionalError = pBinarySerializer->deserializeField(
                            pathToExternalFile, pSmartPointerInstance.get(), pField);
                        if (optionalError.has_value()) [[unlikely]] {
                            auto error = optionalError.value();
                            error.addCurrentLocationToErrorStack();
                            return error;
                        }
 
                        // Finished.
                        bDeserialized = true;
                        break;
                    }
 
                    // Make sure we deserialized this field.
                    if (!bDeserialized) [[unlikely]] {
                        return Error(std::format(
                            "the field \"{}\" with type \"{}\" (maybe inherited) has "
                            "unsupported for deserialization type",
                            pField->getName(),
                            pField->getCanonicalTypeName()));
                    }
 
                    // Notify about deserialization.
                    pFieldObject->onAfterDeserialized();
                } else [[unlikely]] {
                    return Error(std::format("unhandled case on field \"{}\"", pField->getName()));
                }
 
                continue;
            }
 
            // Deserialize field value.
            bool bFoundSerializer = false;
            for (const auto& pSerializer : vFieldSerializers) {
                if (pSerializer->isFieldTypeSupported(pField)) {
                    bFoundSerializer = true;
                    auto optionalError = pSerializer->deserializeField(
                        &tomlData,
                        pFieldTomlValue,
                        pSmartPointerInstance.get(),
                        pField,
                        sTargetSection,
                        sEntityId,
                        customAttributes);
                    if (optionalError.has_value()) [[unlikely]] {
                        auto error = optionalError.value();
                        error.addCurrentLocationToErrorStack();
                        if (pOriginalEntity) {
                            Logger::get().error(std::format(
                                "an error occurred while deserializing "
                                "changed field (this field was not deserialized), error: {}",
                                error.getFullErrorMessage()));
                        } else {
                            return error;
                        }
                    }
                }
            }
 
            if (!bFoundSerializer) [[unlikely]] {
                Logger::get().warn(
                    std::format("unable to find a deserializer that supports field \"{}\"", sFieldName));
            }
        }
 
        if (optionalPathToFile.has_value() &&
            optionalPathToFile->string().starts_with(
                ProjectPaths::getPathToResDirectory(ResourceDirectory::ROOT).string())) {
            // File is located in the `res` directory, save a relative path to the `res` directory.
            auto sRelativePath = std::filesystem::relative(
                                     optionalPathToFile->string(),
                                     ProjectPaths::getPathToResDirectory(ResourceDirectory::ROOT))
                                     .string();
 
            // Replace all '\' characters with '/' just to be consistent.
            std::replace(sRelativePath.begin(), sRelativePath.end(), '\\', '/');
 
            // Remove the forward slash at the beginning (if exists).
            if (sRelativePath.starts_with('/')) {
                sRelativePath = sRelativePath.substr(1);
            }
 
            // Double check that everything is correct.
            const auto pathToOriginalFile =
                ProjectPaths::getPathToResDirectory(ResourceDirectory::ROOT) / sRelativePath;
            if (!std::filesystem::exists(pathToOriginalFile)) [[unlikely]] {
                return Error(std::format(
                    "failed to save the relative path to the `res` directory for the file at \"{}\", "
                    "reason: constructed path \"{}\" does not exist",
                    optionalPathToFile->string(),
                    pathToOriginalFile.string()));
            }
 
            // Save deserialization path.
            pSmartPointerInstance->pathDeserializedFromRelativeToRes = {sRelativePath, sEntityId};
        }
 
        // Notify about deserialization finished.
        Serializable* pTarget = dynamic_cast<Serializable*>(pSmartPointerInstance.get());
        pTarget->onAfterDeserialized();
 
        return pSmartPointerInstance;
    }
 
}; // namespace ne RNAMESPACE()
 
File_Serializable_GENERATED