SerializationBinaryTypeErased.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "Internal/SerializationBinaryTypeErasedReadVersioned.h"
#include "Internal/SerializationBinaryTypeErasedReadWriteExact.h"
namespace SC
{
 
 
 
struct SerializationBinaryTypeErased
{
    template <typename T>
    [[nodiscard]] static bool write(const T& object, Buffer& buffer, size_t* numberOfWrites = nullptr)
    {
        SerializationBinaryBufferWriter         binaryBuffer(buffer);
        SerializationBinaryTypeErasedWriteExact writer;
        if (not writer.write(object, binaryBuffer))
            return false;
        if (numberOfWrites)
            *numberOfWrites = binaryBuffer.numberOfOperations;
        return true;
    }
 
    template <typename T>
    [[nodiscard]] static bool loadExact(T& object, Span<const char> buffer, size_t* numberOfReads = nullptr)
    {
        SerializationBinaryBufferReader        bufferReader(buffer);
        SerializationBinaryTypeErasedReadExact reader;
        if (not reader.loadExact(object, bufferReader))
            return false;
        if (numberOfReads)
            *numberOfReads = bufferReader.numberOfOperations;
        return bufferReader.positionIsAtEnd();
    }
    template <typename T>
    [[nodiscard]] static bool loadVersioned(T& object, Span<const char> buffer, Span<const Reflection::TypeInfo> schema,
                                            SerializationBinaryOptions options = {}, size_t* numberOfReads = nullptr)
    {
        SerializationBinaryTypeErasedReadVersioned loader;
 
        SerializationSchema serializationSchema(schema);
        serializationSchema.options = options;
        SerializationBinaryBufferReader readerBuffer(buffer);
        if (not loader.loadVersioned(object, readerBuffer, serializationSchema))
            return false;
        if (numberOfReads)
            *numberOfReads = readerBuffer.numberOfOperations;
        return readerBuffer.positionIsAtEnd();
    }
};
} // namespace SC