StormByte 3.0.0
C++26 foundation of the StormByte suite
Loading...
Searching...
No Matches
serializable.txx
Go to the documentation of this file.
1/*
2 * Copyright (C) 2024-2026 David C. Manuelda (StormBytePP)
3 *
4 * This is the base for StormByte Suite libraries.
5 *
6 * StormByte original source is dual-licensed:
7 *
8 * 1. GNU Lesser General Public License v3.0 (or later)
9 * You may redistribute and/or modify this file under the terms of the
10 * GNU Lesser General Public License as published by the Free Software
11 * Foundation, either version 3 of the License, or (at your option)
12 * any later version.
13 *
14 * 2. Commercial license
15 * Alternatively, this file may be used under the terms of a commercial
16 * license agreement with the copyright holder
17 * (David C. Manuelda <StormByte@gmail.com>).
18 *
19 * Both licenses apply only to original StormByte source in this repository.
20 * They do not cover other StormByte modules or any third-party material
21 * shipped with this repository (including everything under thirdparty/),
22 * which remains under its own license.
23 *
24 * Neither license grants any patent rights. Any patent licenses required
25 * to use this software or third-party components must be obtained separately
26 * from the patent holders.
27 *
28 * StormByte is distributed in the hope that it will be useful,
29 * but WITHOUT ANY WARRANTY; without even the implied warranty of
30 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
31 * GNU Lesser General Public License for more details.
32 *
33 * You should have received a copy of the GNU Lesser General Public License
34 * version 3 along with StormByte. If not, see
35 * <https://www.gnu.org/licenses/lgpl-3.0.html>.
36 *
37 * SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-StormByte-Commercial
38 */
39
40#pragma once
41
42#include <algorithm>
43#include <vector>
44
45namespace StormByte {
46 template<typename T>
47 Safe::Binary Serializable<T>::Serialize() const noexcept {
48 if constexpr (Type::Optional<T>) {
49 return SerializeOptional();
50 } else if constexpr (Type::Queue<T>) {
51 return SerializeQueue();
52 } else if constexpr (Type::Pair<T>) {
53 return SerializePair();
54 } else if constexpr (Type::Container<T>) {
55 return SerializeContainer();
56 } else if constexpr (Type::TriviallyCopyable<T>) {
57 return SerializeTrivial();
58 } else {
59 return Detail::Codec<DecayedT>::Write(m_data);
60 }
61 }
62
63 template<typename T>
64 Expected<T, DeserializeError> Serializable<T>::Deserialize(std::span<const std::byte> data) noexcept {
65 if constexpr (Type::Optional<T>) {
66 return DeserializeOptional(data);
67 } else if constexpr (Type::Queue<T>) {
68 return DeserializeQueue(data);
69 } else if constexpr (Type::Pair<T>) {
70 return DeserializePair(data);
71 } else if constexpr (Type::Container<T>) {
72 return DeserializeContainer(data);
73 } else if constexpr (Type::TriviallyCopyable<T>) {
74 return DeserializeTrivial(data);
75 } else {
76 return Detail::Codec<DecayedT>::Read(data);
77 }
78 }
79
80 template<typename T>
81 Expected<T, DeserializeError> Serializable<T>::Deserialize(const Safe::Binary& data) noexcept {
82 return Deserialize(data.span());
83 }
84
85 template<typename T>
86 ByteSize Serializable<T>::Size(const DecayedT& data) noexcept {
87 if constexpr (Type::Optional<T>) {
88 return SizeOptional(data);
89 } else if constexpr (Type::Queue<T>) {
90 return SizeQueue(data);
91 } else if constexpr (Type::Pair<T>) {
92 return SizePair(data);
93 } else if constexpr (Type::Container<T>) {
94 return SizeContainer(data);
95 } else if constexpr (Type::TriviallyCopyable<T>) {
96 return ByteSize{sizeof(DecayedT)};
97 } else {
98 return Detail::Codec<DecayedT>::Size(data);
99 }
100 }
101
102 template<typename T>
103 template<typename U>
104 Safe::Binary Serializable<T>::SerializeTrivial() const noexcept
105 requires Type::TriviallyCopyable<U> {
106 if constexpr (Type::SameAs<T, bool>) {
107 return Safe::Binary(ByteSize{1}, std::byte{m_data ? std::byte{1} : std::byte{0}});
108 }
109 auto value = m_data;
110 if constexpr (std::is_integral_v<T> && sizeof(T) > 1 &&
111 std::endian::native != std::endian::little) {
112 value = Type::Detail::swap_endian(value);
113 }
114
115 const auto* raw = reinterpret_cast<const std::byte*>(&value);
116 return Safe::Binary(raw, ByteSize{sizeof(value)});
117 }
118
119 template<typename T>
120 template<typename U>
121 Safe::Binary Serializable<T>::SerializeContainer() const noexcept
122 requires Type::Container<U> {
123 const std::uint64_t size = static_cast<std::uint64_t>(m_data.size());
124 Safe::Binary buffer = Serializable<std::uint64_t>(size).Serialize();
125 buffer.reserve(ByteSize{static_cast<std::size_t>(buffer.size())} + SizeContainer(m_data));
126 using ElementT = typename DecayedT::value_type;
127 if constexpr (requires { typename DecayedT::hasher; }) {
128 std::vector<const ElementT*> ordered;
129 ordered.reserve(m_data.size());
130 for (const auto& element : m_data)
131 ordered.push_back(&element);
132 std::sort(ordered.begin(), ordered.end(), [](const ElementT* left, const ElementT* right) {
133 if constexpr (requires { left->first < right->first; })
134 return left->first < right->first;
135 else
136 return *left < *right;
137 });
138 for (const ElementT* element : ordered)
139 append_bytes(buffer, Serializable<ElementT>(*element).Serialize());
140 } else {
141 for (const auto& element : m_data) {
142 ElementT snapshot = element;
143 Serializable<ElementT> element_serial(snapshot);
144 append_bytes(buffer, element_serial.Serialize());
145 }
146 }
147 return buffer;
148 }
149
150 template<typename T>
151 template<typename U>
152 Safe::Binary Serializable<T>::SerializePair() const noexcept
153 requires Type::Pair<U> {
154 Serializable<std::remove_cvref_t<typename T::first_type>> first_serial(m_data.first);
155 Serializable<std::remove_cvref_t<typename T::second_type>> second_serial(m_data.second);
156 Safe::Binary buffer;
157 buffer.reserve(SizePair(m_data));
158 append_bytes(buffer, first_serial.Serialize());
159 append_bytes(buffer, second_serial.Serialize());
160 return buffer;
161 }
162
163 template<typename T>
164 template<typename U>
165 Safe::Binary Serializable<T>::SerializeOptional() const noexcept
166 requires Type::Optional<U> {
167 const bool has_value = m_data.has_value();
168 Safe::Binary buffer;
169 buffer.reserve(SizeOptional(m_data));
170 append_bytes(buffer, Serializable<bool>(has_value).Serialize());
171 if (m_data.has_value()) {
172 using ValueT = typename DecayedT::value_type;
173 ValueT value = m_data.value();
174 Serializable<ValueT> value_serial(value);
175 append_bytes(buffer, value_serial.Serialize());
176 }
177 return buffer;
178 }
179
180 template<typename T>
181 template<typename U>
182 Safe::Binary Serializable<T>::SerializeQueue() const noexcept
183 requires Type::Queue<U> {
184 const std::uint64_t count = static_cast<std::uint64_t>(m_data.size());
185 Safe::Binary buffer = Serializable<std::uint64_t>(count).Serialize();
186 buffer.reserve(ByteSize{static_cast<std::size_t>(buffer.size())} + SizeQueue(m_data));
187 DecayedT queue = m_data;
188 using ElementT = typename DecayedT::value_type;
189 while (!queue.empty()) {
190 ElementT element = queue.front();
191 queue.pop();
192 Serializable<ElementT> element_serial(element);
193 append_bytes(buffer, element_serial.Serialize());
194 }
195 return buffer;
196 }
197
198 template<typename T>
199 template<typename U>
200 ByteSize Serializable<T>::SizeContainer(const DecayedT& data) noexcept
201 requires Type::Container<U> {
202 ByteSize size{sizeof(std::uint64_t)};
203 for (const auto& element : data) {
204 typename DecayedT::value_type snapshot = element;
205 size += Serializable<typename DecayedT::value_type>::Size(snapshot);
206 }
207 return size;
208 }
209
210 template<typename T>
211 template<typename U>
212 ByteSize Serializable<T>::SizePair(const DecayedT& data) noexcept
213 requires Type::Pair<U> {
214 return
215 Serializable<std::remove_cvref_t<typename T::first_type>>::Size(data.first) +
216 Serializable<std::remove_cvref_t<typename T::second_type>>::Size(data.second);
217 }
218
219 template<typename T>
220 template<typename U>
221 ByteSize Serializable<T>::SizeOptional(const DecayedT& data) noexcept
222 requires Type::Optional<U> {
223 ByteSize size{sizeof(bool)};
224 if (data.has_value()) {
225 size += Serializable<std::remove_cvref_t<decltype(data.value())>>::Size(data.value());
226 }
227 return size;
228 }
229
230 template<typename T>
231 template<typename U>
232 ByteSize Serializable<T>::SizeQueue(const DecayedT& data) noexcept
233 requires Type::Queue<U> {
234 ByteSize size{sizeof(std::uint64_t)};
235 DecayedT queue = data;
236 using ElementT = typename DecayedT::value_type;
237 while (!queue.empty()) {
238 ElementT element = queue.front();
239 queue.pop();
240 size += Serializable<ElementT>::Size(element);
241 }
242 return size;
243 }
244
245 template<typename T>
246 template<typename U>
247 Expected<T, DeserializeError> Serializable<T>::DeserializeTrivial(std::span<const std::byte> data) noexcept
248 requires Type::TriviallyCopyable<U> {
249 if constexpr (Type::SameAs<T, bool>) {
250 if (data.empty())
251 return Unexpected<DeserializeError>("Insufficient data for bool");
252
253 const auto raw = static_cast<unsigned char>(data[0]);
254 if (raw != 0 && raw != 1)
255 return Unexpected<DeserializeError>("Invalid bool value in stream");
256
257 return raw != 0;
258 } else {
259 if (data.size() < sizeof(T))
260 return Unexpected<DeserializeError>("Insufficient data for deserialization");
261
262 T result;
263 std::memcpy(&result, data.data(), sizeof(T));
264
265 if constexpr (std::endian::native != std::endian::little) {
266 result = Type::Detail::swap_endian(result);
267 }
268
269 return result;
270 }
271 }
272
273 template<typename T>
274 template<typename U>
275 Expected<T, DeserializeError> Serializable<T>::DeserializeContainer(std::span<const std::byte> data) noexcept
276 requires Type::Container<U> {
277 std::size_t offset = 0;
278
279 if (offset + sizeof(std::uint64_t) > data.size())
280 return Unexpected<DeserializeError>("Insufficient data for container size");
281
282 auto expected_container_size = Serializable<std::uint64_t>::Deserialize(
283 data.subspan(offset, sizeof(std::uint64_t)));
284 if (!expected_container_size)
285 return Unexpected(expected_container_size.error());
286
287 const std::uint64_t size = expected_container_size.value();
288 offset += sizeof(std::uint64_t);
289
290 if (size > static_cast<std::uint64_t>(data.size() - offset))
291 return Unexpected<DeserializeError>("Claimed container size exceeds remaining buffer");
292 if constexpr (Type::Array<T>) {
293 if (size != static_cast<std::uint64_t>(std::tuple_size_v<T>))
294 return Unexpected<DeserializeError>("Array size does not match serialized element count");
295 }
296
297 T container;
298 for (std::uint64_t i = 0; i < size; ++i) {
299 using ElementT = std::remove_cvref_t<typename T::value_type>;
300
301 if (offset >= data.size())
302 return Unexpected<DeserializeError>("Insufficient data for container element");
303
304 auto expected_element = Serializable<ElementT>::Deserialize(data.subspan(offset));
305 if (!expected_element)
306 return Unexpected(expected_element.error());
307
308 const ByteSize element_size = Serializable<ElementT>::Size(expected_element.value());
309 if constexpr (Type::Array<T>) {
310 container[static_cast<std::size_t>(i)] = std::move(expected_element.value());
311 } else if constexpr (requires(T& target, ElementT value) { target.push_back(std::move(value)); }) {
312 container.push_back(std::move(expected_element.value()));
313 } else if constexpr (requires(T& target, ElementT value) {
314 target.insert_or_assign(value.first, value.second);
315 }) {
316 container.insert_or_assign(expected_element.value().first, expected_element.value().second);
317 } else {
318 container.insert(container.end(), std::move(expected_element.value()));
319 }
320 offset += static_cast<std::size_t>(element_size);
321 }
322 return container;
323 }
324
325 template<typename T>
326 template<typename U>
327 Expected<T, DeserializeError> Serializable<T>::DeserializePair(std::span<const std::byte> data) noexcept
328 requires Type::Pair<U> {
329 using FirstT = std::remove_cvref_t<typename T::first_type>;
330 using SecondT = std::remove_cvref_t<typename T::second_type>;
331
332 auto expected_first = Serializable<FirstT>::Deserialize(data);
333 if (!expected_first)
334 return Unexpected(expected_first.error());
335
336 const ByteSize first_size = Serializable<FirstT>::Size(expected_first.value());
337 if (static_cast<std::size_t>(first_size) > data.size())
338 return Unexpected<DeserializeError>("Insufficient data for pair second");
339
340 auto expected_second = Serializable<SecondT>::Deserialize(data.subspan(static_cast<std::size_t>(first_size)));
341 if (!expected_second)
342 return Unexpected(expected_second.error());
343
344 return T{ std::move(expected_first.value()), std::move(expected_second.value()) };
345 }
346
347 template<typename T>
348 template<typename U>
349 Expected<T, DeserializeError> Serializable<T>::DeserializeOptional(std::span<const std::byte> data) noexcept
350 requires Type::Optional<U> {
351 auto expected_has = Serializable<bool>::Deserialize(data);
352 if (!expected_has)
353 return Unexpected(expected_has.error());
354
355 if (!expected_has.value())
356 return T{};
357
358 const ByteSize flag_size = Serializable<bool>::Size(true);
359 if (static_cast<std::size_t>(flag_size) > data.size())
360 return Unexpected<DeserializeError>("Insufficient data for optional value");
361
362 using ValueT = std::remove_cvref_t<typename T::value_type>;
363 auto expected_value = Serializable<ValueT>::Deserialize(data.subspan(static_cast<std::size_t>(flag_size)));
364 if (!expected_value)
365 return Unexpected(expected_value.error());
366
367 return T{ std::move(expected_value.value()) };
368 }
369
370 template<typename T>
371 template<typename U>
372 Expected<T, DeserializeError> Serializable<T>::DeserializeQueue(std::span<const std::byte> data) noexcept
373 requires Type::Queue<U> {
374 if (data.size() < sizeof(std::uint64_t))
375 return Unexpected<DeserializeError>("Insufficient data for queue size");
376 auto expected_count = Serializable<std::uint64_t>::Deserialize(data.first(sizeof(std::uint64_t)));
377 if (!expected_count)
378 return Unexpected(expected_count.error());
379
380 std::size_t offset = sizeof(std::uint64_t);
381 const std::uint64_t count = expected_count.value();
382 using ElementT = typename DecayedT::value_type;
383 constexpr std::uint64_t MaximumQueueElements = 1'048'576;
384 if (count > MaximumQueueElements)
385 return Unexpected<DeserializeError>("Queue element count exceeds the decoding resource limit");
386
387 try {
388 const auto readElement = [&]() -> Expected<ElementT, DeserializeError> {
389 if (offset > data.size())
390 return Unexpected<DeserializeError>("Queue element offset exceeds input");
391 auto expected_element = Serializable<ElementT>::Deserialize(data.subspan(offset));
392 if (!expected_element)
393 return Unexpected(expected_element.error());
394 const ByteSize element_size = Serializable<ElementT>::Size(expected_element.value());
395 if (static_cast<std::size_t>(element_size) > data.size() - offset)
396 return Unexpected<DeserializeError>("Queue element exceeds remaining buffer");
397 offset += static_cast<std::size_t>(element_size);
398 return std::move(expected_element.value());
399 };
400
401 if constexpr (Type::IsSafeQueue<DecayedT>::value) {
402 std::queue<ElementT> staged;
403 for (std::uint64_t i = 0; i < count; ++i) {
404 auto element = readElement();
405 if (!element)
406 return Unexpected(element.error());
407 staged.push(std::move(element.value()));
408 }
409 return T(std::move(staged));
410 } else {
411 T queue;
412 for (std::uint64_t i = 0; i < count; ++i) {
413 auto element = readElement();
414 if (!element)
415 return Unexpected(element.error());
416 queue.push(std::move(element.value()));
417 }
418 return queue;
419 }
420 } catch (...) {
421 return Unexpected<DeserializeError>("Queue allocation or insertion failed");
422 }
423 }
424}