IFieldSerializer.hpp

#pragma once
 
// Standard.
#include <optional>
#include <format>
 
// Custom.
#include "misc/Error.h"
 
// External.
#include "Refureku/Refureku.h"
#include "toml11/single_include/toml.hpp"
 
namespace ne {
    class Serializable;
 
    inline std::string floatingToString(double value) { return std::format("{:.15f}", value); }
 
    class IFieldSerializer {
    public:
        IFieldSerializer() = default;
        virtual ~IFieldSerializer() = default;
 
        virtual bool isFieldTypeSupported(const rfk::Field* pField) = 0;
 
        [[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) = 0;
 
        [[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) = 0;
 
        [[nodiscard]] virtual std::optional<Error> cloneField(
            Serializable* pFromInstance,
            const rfk::Field* pFromField,
            Serializable* pToInstance,
            const rfk::Field* pToField) = 0;
 
        virtual bool isFieldValueEqual(
            Serializable* pFieldAOwner,
            const rfk::Field* pFieldA,
            Serializable* pFieldBOwner,
            const rfk::Field* pFieldB) = 0;
    };
} // namespace ne