SerializationBinary.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "../Common/CompilerMacrosExport.h"
#ifndef SC_EXPORT_LIBRARY_SERIALIZATION_BINARY
#define SC_EXPORT_LIBRARY_SERIALIZATION_BINARY 0
#endif
#define SC_SERIALIZATION_BINARY_EXPORT SC_COMPILER_LIBRARY_EXPORT(SC_EXPORT_LIBRARY_SERIALIZATION_BINARY)
 
#include "../Common/Assert.h"
 
namespace SC
{
SC_DECLARE_ASSERT_PROVIDER(SerializationBinaryAssert, SC_SERIALIZATION_BINARY_EXPORT);
 
#define SC_SERIALIZATION_BINARY_ASSERT_RELEASE(e)        SC_ASSERT_PROVIDER_RELEASE(SC::SerializationBinaryAssert, e)
#define SC_SERIALIZATION_BINARY_ASSERT_DEBUG(e)          SC_ASSERT_PROVIDER_DEBUG(SC::SerializationBinaryAssert, e)
#define SC_SERIALIZATION_BINARY_TRUST_RESULT(expression) SC_SERIALIZATION_BINARY_ASSERT_RELEASE(expression)
} // namespace SC
 
#include "Internal/SerializationBinaryBuffer.h"
#include "Internal/SerializationBinaryReadVersioned.h"
#include "Internal/SerializationBinaryReadWriteExact.h"
 
#include "SerializationBinaryOptions.h"
 
namespace SC
{
 
 
struct SerializationBinary
{
 
 
    template <typename T, typename BufferType>
    [[nodiscard]] static bool write(T& value, BufferType& buffer, size_t* numberOfWrites = nullptr)
    {
        SerializationBinaryWriter<BufferType> writer(buffer);
        using Writer = Serialization::SerializerBinaryReadWriteExact<SerializationBinaryWriter<BufferType>, 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 char> buffer, size_t* numberOfReads = nullptr)
    {
        SerializationBinaryReader bufferReader(buffer);
        using Reader = Serialization::SerializerBinaryReadWriteExact<SerializationBinaryReader, 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 char> buffer, Span<const Reflection::TypeInfo> schema,
                                            SerializationBinaryOptions options = {}, size_t* numberOfReads = nullptr)
    {
        SerializationBinaryReader readerBuffer(buffer);
        using Reader = Serialization::SerializerBinaryReadVersioned<SerializationBinaryReader, T, void>;
        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, typename BufferType>
    [[nodiscard]] static bool writeWithSchema(T& value, BufferType& 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 char>::reinterpret_bytes(&numInfos, sizeof(numInfos))));
        SC_TRY(buffer.append(
            Span<const char>::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 char> buffer,
                                                      SerializationBinaryOptions options       = {},
                                                      size_t*                    numberOfReads = nullptr)
    {
        uint32_t numInfos = 0;
        // Read number of type info
        Span<const char> numInfosSlice;
        SC_TRY(buffer.sliceStartLength(0, sizeof(numInfos), numInfosSlice));
#if SC_COMPILER_MSVC
        ::memcpy(&numInfos, numInfosSlice.data(), sizeof(numInfos));
#else
        __builtin_memcpy(&numInfos, numInfosSlice.data(), sizeof(numInfos));
#endif
 
        // 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 char> typeInfos;
        SC_TRY(buffer.sliceStartLength(sizeof(numInfos), numInfos * sizeof(Reflection::TypeInfo), typeInfos));
        Span<const Reflection::TypeInfo> serializedSchema =
            typeInfos.reinterpret_as_span_of<const 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 char> 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