Sane C++ Libraries
C++ Platform Abstraction Libraries
Loading...
Searching...
No Matches
SerializationBinary.h
1// Copyright (c) Stefano Cristiano
2// SPDX-License-Identifier: MIT
3#pragma once
4#include "Internal/SerializationBinaryBuffer.h"
5#include "Internal/SerializationBinaryReadVersioned.h"
6#include "Internal/SerializationBinaryReadWriteExact.h"
7
8#include "SerializationBinaryOptions.h"
9
10namespace SC
11{
18
21
24{
41
48
49 template <typename T>
50 [[nodiscard]] static bool write(T& value, Buffer& buffer, size_t* numberOfWrites = nullptr)
51 {
52 SerializationBinaryBufferWriter writer(buffer);
53 using Writer = Serialization::SerializerBinaryReadWriteExact<SerializationBinaryBufferWriter, T>;
54 if (not Writer::serialize(value, writer))
55 return false;
56 if (numberOfWrites)
57 *numberOfWrites = writer.numberOfOperations;
58 return true;
59 }
60
93 template <typename T>
94 [[nodiscard]] static bool loadExact(T& value, Span<const char> buffer, size_t* numberOfReads = nullptr)
95 {
96 SerializationBinaryBufferReader bufferReader(buffer);
97 using Reader = Serialization::SerializerBinaryReadWriteExact<SerializationBinaryBufferReader, T>;
98 if (not Reader::serialize(value, bufferReader))
99 return false;
100 if (numberOfReads)
101 *numberOfReads = bufferReader.numberOfOperations;
102 return bufferReader.positionIsAtEnd();
103 }
104
106 //
138 template <typename T>
139 [[nodiscard]] static bool loadVersioned(T& value, Span<const char> buffer, Span<const Reflection::TypeInfo> schema,
140 SerializationBinaryOptions options = {}, size_t* numberOfReads = nullptr)
141 {
142 SerializationBinaryBufferReader readerBuffer(buffer);
143 using Reader = Serialization::SerializerBinaryReadVersioned<SerializationBinaryBufferReader, T>;
144 SerializationSchema versionSchema(schema);
145 versionSchema.options = options;
146 if (not Reader::readVersioned(value, readerBuffer, versionSchema))
147 return false;
148 if (numberOfReads)
149 *numberOfReads = readerBuffer.numberOfOperations;
150 return readerBuffer.positionIsAtEnd();
151 }
152
158 template <typename T>
159 [[nodiscard]] static bool writeWithSchema(T& value, Buffer& buffer, size_t* numberOfWrites = nullptr)
160 {
161 constexpr auto typeInfos = Reflection::Schema::template compile<T>().typeInfos;
162 constexpr uint32_t numInfos = typeInfos.size;
163 static_assert(alignof(Reflection::TypeInfo) == sizeof(uint32_t), "Alignof TypeInfo");
164 // Implying same endianness when reading here
165 SC_TRY(buffer.append(Span<const char>::reinterpret_bytes(&numInfos, sizeof(numInfos))));
166 SC_TRY(buffer.append(
167 Span<const char>::reinterpret_bytes(typeInfos.values, typeInfos.size * sizeof(Reflection::TypeInfo))));
168 return write(value, buffer, numberOfWrites);
169 }
170
176 template <typename T>
177 [[nodiscard]] static bool loadVersionedWithSchema(T& value, Span<const char> buffer,
178 SerializationBinaryOptions options = {},
179 size_t* numberOfReads = nullptr)
180 {
181 uint32_t numInfos = 0;
182 // Read number of type info
183 Span<const char> numInfosSlice;
184 SC_TRY(buffer.sliceStartLength(0, sizeof(numInfos), numInfosSlice));
185 memcpy(&numInfos, numInfosSlice.data(), sizeof(numInfos));
186
187 // Cast first part of the buffer to a Span of TypeInfo.
188 // It's possible as we've been serializing it with correct alignment (currently 32 bits).
189 static_assert(alignof(Reflection::TypeInfo) == sizeof(uint32_t), "Alignof TypeInfo");
190 Span<const char> typeInfos;
191 SC_TRY(buffer.sliceStartLength(sizeof(numInfos), numInfos * sizeof(Reflection::TypeInfo), typeInfos));
192 Span<const Reflection::TypeInfo> serializedSchema =
193 typeInfos.reinterpret_as_span_of<const Reflection::TypeInfo>();
194
195 constexpr auto sourceSchema = Reflection::Schema::template compile<T>().typeInfos;
196
197 // Get the slice of bytes where actual serialization data has been written by writeWithSchema
198 Span<const char> serializedDataSlice;
199 SC_TRY(buffer.sliceStart(sizeof(numInfos) + numInfos * sizeof(Reflection::TypeInfo), serializedDataSlice));
200 if (sourceSchema.equals(serializedSchema))
201 {
202 // If the serialized schema matches current object schema, we can run the fast "loadExact" path
203 return loadExact(value, serializedDataSlice);
204 }
205 else
206 {
207 // The two schemas differs, so resort to the "slower" versioned loader that tries to match field order
208 return loadVersioned(value, serializedDataSlice, serializedSchema, options, numberOfReads);
209 }
210 }
211};
212
214
215} // namespace SC
unsigned int uint32_t
Platform independent (4) bytes unsigned int.
Definition PrimitiveTypes.h:38
#define SC_TRY(expression)
Checks the value of the given expression and if failed, returns this value to caller.
Definition Result.h:48
An heap allocated byte buffer that can optionally use an inline buffer.
Definition Buffer.h:29
Conversion options for the binary versioned deserializer.
Definition SerializationBinaryOptions.h:12
Loads or writes binary data with its associated reflection schema from or into a C++ object.
Definition SerializationBinary.h:24
static bool loadVersionedWithSchema(T &value, Span< const char > buffer, SerializationBinaryOptions options={}, size_t *numberOfReads=nullptr)
Loads object T using the schema information that has been prepended by SerializationBinary::writeWith...
Definition SerializationBinary.h:177
static bool loadExact(T &value, Span< const char > buffer, size_t *numberOfReads=nullptr)
Loads object T from binary buffer as written by SerializationBinary::write.
Definition SerializationBinary.h:94
static bool write(T &value, Buffer &buffer, size_t *numberOfWrites=nullptr)
Writes object T to a binary buffer.
Definition SerializationBinary.h:50
static bool writeWithSchema(T &value, Buffer &buffer, size_t *numberOfWrites=nullptr)
Writes the reflection schema of object T followed by contents of object T to a binary buffer.
Definition SerializationBinary.h:159
static bool loadVersioned(T &value, Span< const char > buffer, Span< const Reflection::TypeInfo > schema, SerializationBinaryOptions options={}, size_t *numberOfReads=nullptr)
Deserialize object T from a Binary buffer with a reflection schema not matching T schema.
Definition SerializationBinary.h:139
View over a contiguous sequence of items (pointer + size in elements).
Definition Span.h:29
Span< const T > reinterpret_as_span_of() const
Reinterprets the current span as an array of the specified type.
Definition Span.h:83
constexpr bool sliceStart(SizeType offsetInElements, Span &destination) const
Creates another Span, starting at an offset in elements from current Span, until end.
Definition Span.h:108
constexpr bool sliceStartLength(SizeType offsetInElements, SizeType lengthInElements, Span &destination) const
Creates another Span, starting at an offset in elements from current Span of specified length.
Definition Span.h:120