SerializationBinary.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "Internal/SerializationBinaryBuffer.h"
#include "Internal/SerializationBinaryReadVersioned.h"
#include "Internal/SerializationBinaryReadWriteExact.h"
 
#include "SerializationBinaryOptions.h"
 
namespace SC
{
 
 
struct SerializationBinary
{
 
    template <typename T>
    [[nodiscard]] static bool write(T& value, Vector<uint8_t>& buffer, size_t* numberOfWrites = nullptr)
    {
        SerializationBinaryBufferWriter writer(buffer);
        using Writer = Serialization::SerializerBinaryReadWriteExact<SerializationBinaryBufferWriter, T>;
        if (not Writer::serialize(value, writer))
            return false;
        if (numberOfWrites)
            *numberOfWrites = writer.numberOfOperations;
        return true;
    }
 
 
    template <typename T>
    [[nodiscard]] static bool loadExact(T& value, Span<const uint8_t> buffer, size_t* numberOfReads = nullptr)
    {
        SerializationBinaryBufferReader bufferReader(buffer);
        using Reader = Serialization::SerializerBinaryReadWriteExact<SerializationBinaryBufferReader, T>;
        if (not Reader::serialize(value, bufferReader))
            return false;
        if (numberOfReads)
            *numberOfReads = bufferReader.numberOfOperations;
        return bufferReader.positionIsAtEnd();
    }
 
    //
 
    template <typename T>
    [[nodiscard]] static bool loadVersioned(T& value, Span<const uint8_t> buffer,
                                            Span<const Reflection::TypeInfo> schema,
                                            SerializationBinaryOptions options = {}, size_t* numberOfReads = nullptr)
    {
        SerializationBinaryBufferReader readerBuffer(buffer);
        using Reader = Serialization::SerializerBinaryReadVersioned<SerializationBinaryBufferReader, T>;
        SerializationSchema versionSchema(schema);
        versionSchema.options = options;
        if (not Reader::readVersioned(value, readerBuffer, versionSchema))
            return false;
        if (numberOfReads)
            *numberOfReads = readerBuffer.numberOfOperations;
        return readerBuffer.positionIsAtEnd();
    }
 
    template <typename T>
    [[nodiscard]] static bool writeWithSchema(T& value, Vector<uint8_t>& buffer, size_t* numberOfWrites = nullptr)
    {
        constexpr auto     typeInfos = Reflection::Schema::template compile<T>().typeInfos;
        constexpr uint32_t numInfos  = typeInfos.size;
        static_assert(alignof(Reflection::TypeInfo) == sizeof(uint32_t), "Alignof TypeInfo");
        // Implying same endianness when reading here
        SC_TRY(buffer.append(Span<const uint8_t>::reinterpret_bytes(&numInfos, sizeof(numInfos))));
        SC_TRY(buffer.append(
            Span<const uint8_t>::reinterpret_bytes(typeInfos.values, typeInfos.size * sizeof(Reflection::TypeInfo))));
        return write(value, buffer, numberOfWrites);
    }
 
    template <typename T>
    [[nodiscard]] static bool loadVersionedWithSchema(T& value, Span<const uint8_t> buffer,
                                                      SerializationBinaryOptions options       = {},
                                                      size_t*                    numberOfReads = nullptr)
    {
        uint32_t numInfos = 0;
        // Read number of type info
        Span<const uint8_t> numInfosSlice;
        SC_TRY(buffer.sliceStartLength(0, sizeof(numInfos), numInfosSlice));
        memcpy(&numInfos, numInfosSlice.data(), sizeof(numInfos));
 
        // Cast first part of the buffer to a Span of TypeInfo.
        // It's possible as we've been serializing it with correct alignment (currently 32 bits).
        static_assert(alignof(Reflection::TypeInfo) == sizeof(uint32_t), "Alignof TypeInfo");
        Span<const uint8_t> typeInfos;
        SC_TRY(buffer.sliceStartLength(sizeof(numInfos), numInfos * sizeof(Reflection::TypeInfo), typeInfos));
        Span<const Reflection::TypeInfo> serializedSchema = typeInfos.reinterpret_as_array_of<Reflection::TypeInfo>();
 
        constexpr auto sourceSchema = Reflection::Schema::template compile<T>().typeInfos;
 
        // Get the slice of bytes where actual serialization data has been written by writeWithSchema
        Span<const uint8_t> serializedDataSlice;
        SC_TRY(buffer.sliceStart(sizeof(numInfos) + numInfos * sizeof(Reflection::TypeInfo), serializedDataSlice));
        if (sourceSchema.equals(serializedSchema))
        {
            // If the serialized schema matches current object schema, we can run the fast "loadExact" path
            return loadExact(value, serializedDataSlice);
        }
        else
        {
            // The two schemas differs, so resort to the "slower" versioned loader that tries to match field order
            return loadVersioned(value, serializedDataSlice, serializedSchema, options, numberOfReads);
        }
    }
};
 
 
} // namespace SC