1 /*
2 Copyright 2013-2014 EditShare, 2013-2015 Skytechnology sp. z o.o.
3
4 This file is part of LizardFS.
5
6 LizardFS is free software: you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation, version 3.
9
10 LizardFS is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with LizardFS. If not, see <http://www.gnu.org/licenses/>.
17 */
18
19 #pragma once
20
21 #include "common/platform.h"
22
23 #include <array>
24 #include <cstring>
25 #include <map>
26 #include <memory>
27 #include <set>
28 #include <string>
29 #include <utility>
30 #include <vector>
31
32 #include "common/compact_vector.h"
33 #include "common/flat_set.h"
34 #include "common/flat_map.h"
35 #include "common/datapack.h"
36 #include "common/exception.h"
37 #include "common/massert.h"
38 #include "common/small_vector.h"
39
40 const uint32_t kMaxDeserializedBytesCount = 32 * 1024 * 1024; // 32MiB
41 const uint32_t kMaxDeserializedElementsCount = 1000 * 1000; // 1M
42
43 /*
44 * Exception thrown on deserialization error
45 */
46 class IncorrectDeserializationException : public Exception {
47 public:
IncorrectDeserializationException(const std::string & message)48 IncorrectDeserializationException(const std::string& message):
49 Exception("Deserialization error: " + message) {}
50 };
51
52 // serializedSize
53
serializedSize(bool)54 inline uint32_t serializedSize(bool) {
55 return 1;
56 }
57
serializedSize(char)58 inline uint32_t serializedSize(char) {
59 return 1;
60 }
61
serializedSize(signed char)62 inline uint32_t serializedSize(signed char) {
63 return 1;
64 }
65
serializedSize(unsigned char)66 inline uint32_t serializedSize(unsigned char) {
67 return 1;
68 }
69
serializedSize(uint16_t)70 inline uint32_t serializedSize(uint16_t) {
71 return 2;
72 }
73
serializedSize(uint32_t)74 inline uint32_t serializedSize(uint32_t) {
75 return 4;
76 }
77
serializedSize(uint64_t)78 inline uint32_t serializedSize(uint64_t) {
79 return 8;
80 }
81
serializedSize(int16_t)82 inline uint32_t serializedSize(int16_t) {
83 return 2;
84 }
85
serializedSize(int32_t)86 inline uint32_t serializedSize(int32_t) {
87 return 4;
88 }
89
serializedSize(int64_t)90 inline uint32_t serializedSize(int64_t) {
91 return 8;
92 }
93
serializedSize(const std::string & value)94 inline uint32_t serializedSize(const std::string& value) {
95 return serializedSize(uint32_t(value.size())) + value.size() + 1;
96 }
97
98 template <class T, int N>
99 inline uint32_t serializedSize(const T (&array)[N]);
100 template <class T, std::size_t N>
101 inline uint32_t serializedSize(const std::array<T, N>& array);
102 template<class T>
103 inline uint32_t serializedSize(const std::unique_ptr<T>& ptr);
104 template<class T, class A>
105 inline uint32_t serializedSize(const std::vector<T, A>& vector);
106 template<class T, size_t Size>
107 inline uint32_t serializedSize(const small_vector<T, Size> &vector);
108 template <typename K, typename C, typename A>
109 inline uint32_t serializedSize(const std::set<K, C, A>& set);
110 template<class T1, class T2>
111 inline uint32_t serializedSize(const std::pair<T1, T2>& pair);
112 template <typename K, typename T, typename C, typename A>
113 inline uint32_t serializedSize(const std::map<K, T, C, A>& map);
114 template<class T>
115 inline uint32_t serializedSize(const T& t);
116 template<class T, class ... Args>
117 inline uint32_t serializedSize(const T& t, const Args& ... args);
118
119 template <class T, int N>
serializedSize(const T (& array)[N])120 inline uint32_t serializedSize(const T (&array)[N]) {
121 uint32_t ret = 0;
122 for (const auto& element : array) {
123 ret += serializedSize(element);
124 }
125 return ret;
126 }
127
128 template <class T, std::size_t N>
serializedSize(const std::array<T,N> & array)129 inline uint32_t serializedSize(const std::array<T, N>& array) {
130 uint32_t ret = 0;
131 for (const auto& element : array) {
132 ret += serializedSize(element);
133 }
134 return ret;
135 }
136
137 template<class T1, class T2>
serializedSize(const std::pair<T1,T2> & pair)138 inline uint32_t serializedSize(const std::pair<T1, T2>& pair) {
139 return serializedSize(pair.first) + serializedSize(pair.second);
140 }
141
142 template<class T>
serializedSize(const std::unique_ptr<T> & ptr)143 inline uint32_t serializedSize(const std::unique_ptr<T>& ptr) {
144 if (ptr) {
145 return serializedSize(true) + serializedSize(*ptr);
146 } else {
147 return serializedSize(false);
148 }
149 }
150
151 template<class T, class A>
serializedSize(const std::vector<T,A> & vector)152 inline uint32_t serializedSize(const std::vector<T, A>& vector) {
153 uint32_t ret = 0;
154 ret += serializedSize(uint32_t(vector.size()));
155 for (const auto& t : vector) {
156 ret += serializedSize(t);
157 }
158 return ret;
159 }
160
161 template<class T, size_t Size>
serializedSize(const small_vector<T,Size> & vector)162 inline uint32_t serializedSize(const small_vector<T, Size> &vector) {
163 uint32_t ret = 0;
164 ret += serializedSize(uint32_t(vector.size()));
165 for (const auto& t : vector) {
166 ret += serializedSize(t);
167 }
168 return ret;
169 }
170
171 template <typename K, typename C, typename A>
serializedSize(const std::set<K,C,A> & set)172 inline uint32_t serializedSize(const std::set<K, C, A>& set) {
173 uint32_t ret = 0;
174 ret += serializedSize(uint32_t(set.size()));
175 for (const auto& t : set) {
176 ret += serializedSize(t);
177 }
178 return ret;
179 }
180
181 template <typename K, typename T, typename C, typename A>
serializedSize(const std::map<K,T,C,A> & map)182 inline uint32_t serializedSize(const std::map<K, T, C, A>& map) {
183 uint32_t ret = 0;
184 ret += serializedSize(uint32_t(map.size()));
185 for (const auto& t : map) {
186 ret += serializedSize(t);
187 }
188 return ret;
189 }
190
191 template <typename T, typename Size, typename Alloc>
serializedSize(const compact_vector<T,Size,Alloc> & vector)192 inline uint32_t serializedSize(const compact_vector<T, Size, Alloc>& vector) {
193 uint32_t ret = 0;
194 ret += serializedSize(uint32_t(vector.size()));
195 for (const auto& t : vector) {
196 ret += serializedSize(t);
197 }
198 return ret;
199 }
200
201 template <typename T, typename C, class Compare>
serializedSize(const flat_set<T,C,Compare> & set)202 inline uint32_t serializedSize(const flat_set<T, C, Compare>& set) {
203 return serializedSize(set.data());
204 }
205
206 template <typename Key, typename T, typename C, class Compare>
serializedSize(const flat_map<Key,T,C,Compare> & map)207 inline uint32_t serializedSize(const flat_map<Key, T, C, Compare>& map) {
208 return serializedSize(map.data());
209 }
210
211 template<class T>
serializedSize(const T & t)212 inline uint32_t serializedSize(const T& t) {
213 return t.serializedSize();
214 }
215
216 template<class T, class ... Args>
serializedSize(const T & t,const Args &...args)217 inline uint32_t serializedSize(const T& t, const Args& ... args) {
218 return serializedSize(t) + serializedSize(args...);
219 }
220
221 // serialize for simple types
222
223 // serialize bool
serialize(uint8_t ** destination,bool value)224 inline void serialize(uint8_t** destination, bool value) {
225 put8bit(destination, static_cast<uint8_t>(value ? 1 : 0));
226 }
227
serialize(uint8_t ** destination,char value)228 inline void serialize(uint8_t** destination, char value) {
229 put8bit(destination, value);
230 }
231
serialize(uint8_t ** destination,signed char value)232 inline void serialize(uint8_t** destination, signed char value) {
233 put8bit(destination, value);
234 }
235
serialize(uint8_t ** destination,unsigned char value)236 inline void serialize(uint8_t** destination, unsigned char value) {
237 put8bit(destination, value);
238 }
239
serialize(uint8_t ** destination,uint16_t value)240 inline void serialize(uint8_t** destination, uint16_t value) {
241 put16bit(destination, value);
242 }
243
serialize(uint8_t ** destination,uint32_t value)244 inline void serialize(uint8_t** destination, uint32_t value) {
245 put32bit(destination, value);
246 }
247
serialize(uint8_t ** destination,uint64_t value)248 inline void serialize(uint8_t** destination, uint64_t value) {
249 put64bit(destination, value);
250 }
251
serialize(uint8_t ** destination,int16_t value)252 inline void serialize(uint8_t** destination, int16_t value) {
253 put16bit(destination, value);
254 }
255
serialize(uint8_t ** destination,int32_t value)256 inline void serialize(uint8_t** destination, int32_t value) {
257 put32bit(destination, value);
258 }
259
serialize(uint8_t ** destination,int64_t value)260 inline void serialize(uint8_t** destination, int64_t value) {
261 put64bit(destination, value);
262 }
263
264 // serialize a string
serialize(uint8_t ** destination,const std::string & value)265 inline void serialize(uint8_t** destination, const std::string& value) {
266 serialize(destination, uint32_t(value.length() + 1));
267 memcpy(*destination, value.data(), value.length());
268 *destination += value.length();
269 serialize(destination, char(0));
270 }
271
272 template <class T, int N>
273 inline void serialize(uint8_t** destination, const T (&array)[N]);
274 template <class T, std::size_t N>
275 inline void serialize(uint8_t** destination, const std::array<T, N>& array);
276 template<class T1, class T2>
277 inline void serialize(uint8_t** destination, const std::pair<T1, T2>& pair);
278 template<class T>
279 inline void serialize(uint8_t** destination, const std::unique_ptr<T>& ptr);
280 template<class T, class A>
281 inline void serialize(uint8_t** destination, const std::vector<T, A>& vector);
282 template<class T, size_t Size>
283 inline void serialize(uint8_t **destination, const small_vector<T, Size> &vector);
284 template <typename K, typename C, typename A>
285 inline void serialize(uint8_t** destination, const std::set<K, C, A>& set);
286 template <typename K, typename T, typename C, typename A>
287 inline void serialize(uint8_t** destination, const std::map<K, T, C, A>& map);
288 template<class T>
289 inline void serialize(uint8_t** destination, const T& t);
290 template<class T, class... Args>
291 inline void serialize(uint8_t** destination, const T& t, const Args&... args);
292
293 // serialize fixed size array ("type name[number];")
294 template <class T, int N>
serialize(uint8_t ** destination,const T (& array)[N])295 inline void serialize(uint8_t** destination, const T (&array)[N]) {
296 for (int i = 0; i < N; i++) {
297 serialize(destination, array[i]);
298 }
299 }
300
301 template <class T, std::size_t N>
serialize(uint8_t ** destination,const std::array<T,N> & array)302 inline void serialize(uint8_t** destination, const std::array<T, N>& array) {
303 for (std::size_t i = 0; i < N; i++) {
304 serialize(destination, array[i]);
305 }
306 }
307
308 // serialize a pair
309 template<class T1, class T2>
serialize(uint8_t ** destination,const std::pair<T1,T2> & pair)310 inline void serialize(uint8_t** destination, const std::pair<T1, T2>& pair) {
311 serialize(destination, pair.first);
312 serialize(destination, pair.second);
313 }
314
315 // serialize a unique_ptr
316 template<class T>
serialize(uint8_t ** destination,const std::unique_ptr<T> & ptr)317 inline void serialize(uint8_t** destination, const std::unique_ptr<T>& ptr) {
318 if (ptr) {
319 serialize(destination, true);
320 serialize(destination, *ptr);
321 } else {
322 serialize(destination, false);
323 }
324 }
325
326 // serialize a vector
327 template<class T, class A>
serialize(uint8_t ** destination,const std::vector<T,A> & vector)328 inline void serialize(uint8_t** destination, const std::vector<T, A>& vector) {
329 serialize(destination, uint32_t(vector.size()));
330 for (const T& t : vector) {
331 serialize(destination, t);
332 }
333 }
334
335 template<class T, size_t Size>
serialize(uint8_t ** destination,const small_vector<T,Size> & vector)336 inline void serialize(uint8_t **destination, const small_vector<T, Size> &vector) {
337 serialize(destination, uint32_t(vector.size()));
338 for (const T& t : vector) {
339 serialize(destination, t);
340 }
341 }
342
343 template <typename K, typename C, typename A>
serialize(uint8_t ** destination,const std::set<K,C,A> & set)344 inline void serialize(uint8_t** destination, const std::set<K, C, A>& set) {
345 serialize(destination, uint32_t(set.size()));
346 for (const auto& t : set) {
347 serialize(destination, t);
348 }
349 }
350
351 template <typename K, typename T, typename C, typename A>
serialize(uint8_t ** destination,const std::map<K,T,C,A> & map)352 inline void serialize(uint8_t** destination, const std::map<K, T, C, A>& map) {
353 serialize(destination, uint32_t(map.size()));
354 for (const auto& t : map) {
355 serialize(destination, t);
356 }
357 }
358
359 template <typename T, typename Size, typename Alloc>
serialize(uint8_t ** destination,const compact_vector<T,Size,Alloc> & vector)360 inline void serialize(uint8_t** destination, const compact_vector<T, Size, Alloc>& vector) {
361 serialize(destination, uint32_t(vector.size()));
362 for (const T& t : vector) {
363 serialize(destination, t);
364 }
365 }
366
367 template <typename T, typename C, class Compare>
serialize(uint8_t ** destination,const flat_set<T,C,Compare> & set)368 inline void serialize(uint8_t** destination, const flat_set<T, C, Compare>& set) {
369 serialize(destination, set.data());
370 }
371 template <typename Key, typename T, typename C, class Compare>
serialize(uint8_t ** destination,const flat_map<Key,T,C,Compare> & map)372 inline void serialize(uint8_t** destination, const flat_map<Key, T, C, Compare>& map) {
373 serialize(destination, map.data());
374 }
375
376 // serialization
377 template<class T>
serialize(uint8_t ** destination,const T & t)378 inline void serialize(uint8_t** destination, const T& t) {
379 return t.serialize(destination);
380 }
381
382 template<class T, class... Args>
serialize(uint8_t ** destination,const T & t,const Args &...args)383 inline void serialize(uint8_t** destination, const T& t, const Args&... args) {
384 serialize(destination, t);
385 serialize(destination, args...);
386 }
387
388 // helpers
389
390 template <class T>
verifySize(const T & value,uint32_t bytesLeft)391 inline void verifySize(const T& value, uint32_t bytesLeft) {
392 if (bytesLeft < serializedSize(value)) {
393 throw IncorrectDeserializationException("unexpected end of buffer");
394 }
395 }
396
397 // deserialize functions for simple types
398
deserialize(const uint8_t ** source,uint32_t & bytesLeftInBuffer,bool & value)399 inline void deserialize(const uint8_t** source, uint32_t& bytesLeftInBuffer, bool& value) {
400 verifySize(value, bytesLeftInBuffer);
401 bytesLeftInBuffer -= 1;
402 uint8_t integerValue = get8bit(source);
403 if (integerValue > 1) {
404 throw IncorrectDeserializationException("corrupted boolean value");
405 }
406 value = static_cast<bool>(integerValue);
407 }
408
deserialize(const uint8_t ** source,uint32_t & bytesLeftInBuffer,char & value)409 inline void deserialize(const uint8_t** source, uint32_t& bytesLeftInBuffer, char& value) {
410 verifySize(value, bytesLeftInBuffer);
411 bytesLeftInBuffer -= 1;
412 value = get8bit(source);
413 }
414
deserialize(const uint8_t ** source,uint32_t & bytesLeftInBuffer,signed char & value)415 inline void deserialize(const uint8_t** source, uint32_t& bytesLeftInBuffer, signed char& value) {
416 verifySize(value, bytesLeftInBuffer);
417 bytesLeftInBuffer -= 1;
418 value = get8bit(source);
419 }
420
421
deserialize(const uint8_t ** source,uint32_t & bytesLeftInBuffer,unsigned char & value)422 inline void deserialize(const uint8_t** source, uint32_t& bytesLeftInBuffer, unsigned char& value) {
423 verifySize(value, bytesLeftInBuffer);
424 bytesLeftInBuffer -= 1;
425 value = get8bit(source);
426 }
427
428
deserialize(const uint8_t ** source,uint32_t & bytesLeftInBuffer,uint16_t & value)429 inline void deserialize(const uint8_t** source, uint32_t& bytesLeftInBuffer, uint16_t& value) {
430 verifySize(value, bytesLeftInBuffer);
431 bytesLeftInBuffer -= 2;
432 value = get16bit(source);
433 }
434
deserialize(const uint8_t ** source,uint32_t & bytesLeftInBuffer,uint32_t & value)435 inline void deserialize(const uint8_t** source, uint32_t& bytesLeftInBuffer, uint32_t& value) {
436 verifySize(value, bytesLeftInBuffer);
437 bytesLeftInBuffer -= 4;
438 value = get32bit(source);
439 }
440
deserialize(const uint8_t ** source,uint32_t & bytesLeftInBuffer,uint64_t & value)441 inline void deserialize(const uint8_t** source, uint32_t& bytesLeftInBuffer, uint64_t& value) {
442 verifySize(value, bytesLeftInBuffer);
443 bytesLeftInBuffer -= 8;
444 value = get64bit(source);
445 }
446
deserialize(const uint8_t ** source,uint32_t & bytesLeftInBuffer,int16_t & value)447 inline void deserialize(const uint8_t** source, uint32_t& bytesLeftInBuffer, int16_t& value) {
448 verifySize(value, bytesLeftInBuffer);
449 bytesLeftInBuffer -= 2;
450 value = get16bit(source);
451 }
452
deserialize(const uint8_t ** source,uint32_t & bytesLeftInBuffer,int32_t & value)453 inline void deserialize(const uint8_t** source, uint32_t& bytesLeftInBuffer, int32_t& value) {
454 verifySize(value, bytesLeftInBuffer);
455 bytesLeftInBuffer -= 4;
456 value = get32bit(source);
457 }
458
deserialize(const uint8_t ** source,uint32_t & bytesLeftInBuffer,int64_t & value)459 inline void deserialize(const uint8_t** source, uint32_t& bytesLeftInBuffer, int64_t& value) {
460 verifySize(value, bytesLeftInBuffer);
461 bytesLeftInBuffer -= 8;
462 value = get64bit(source);
463 }
464
465 // deserialize a string
deserialize(const uint8_t ** source,uint32_t & bytesLeftInBuffer,std::string & value)466 inline void deserialize(const uint8_t** source, uint32_t& bytesLeftInBuffer, std::string& value) {
467 sassert(value.size() == 0);
468 uint32_t size;
469 deserialize(source, bytesLeftInBuffer, size);
470 // size is length of the string + 1 -- the last byte is a null terminator
471 if (size > kMaxDeserializedElementsCount) {
472 throw IncorrectDeserializationException("untrustworthy string size");
473 }
474 if (bytesLeftInBuffer < size) {
475 throw IncorrectDeserializationException("unexpected end of buffer");
476 }
477 if ((*source)[size - 1] != 0) {
478 throw IncorrectDeserializationException("deserialized string not null-terminated");
479 }
480 // create a string from the buffer, but without the last (null) character
481 value.assign(reinterpret_cast<const char*>(*source), size - 1);
482 bytesLeftInBuffer -= size;
483 *source += size;
484 }
485
486 template <class T, int N>
487 inline void deserialize(const uint8_t** source, uint32_t& bytesLeftInBuffer, T (&array)[N]);
488 template <class T, std::size_t N>
489 inline void deserialize(const uint8_t** source, uint32_t& bytesLeftInBuffer,
490 std::array<T, N>& array);
491 template<class T1, class T2>
492 inline void deserialize(const uint8_t** source, uint32_t& bytesLeftInBuffer,
493 std::pair<T1, T2>& pair);
494 inline void deserialize(const uint8_t** source, uint32_t& bytesLeftInBuffer, const uint8_t*& value);
495 template<class T>
496 inline void deserialize(const uint8_t** source, uint32_t& bytesLeftInBuffer,
497 std::unique_ptr<T>& ptr);
498 template<class T, class A>
499 inline void deserialize(const uint8_t** source, uint32_t& bytesLeftInBuffer,
500 std::vector<T, A>& vec);
501 template<class T, size_t Size>
502 inline void deserialize(const uint8_t **source, uint32_t& bytesLeftInBuffer,
503 small_vector<T, Size> &vec);
504 template <typename K, typename C, typename A>
505 inline void deserialize(const uint8_t** source, uint32_t& bytesLeftInBuffer,
506 std::set<K, C, A>& set);
507 template <typename K, typename T, typename C, typename A>
508 inline void deserialize(const uint8_t** source, uint32_t& bytesLeftInBuffer,
509 std::map<K, T, C, A>& map);
510 template<class T>
511 inline void deserialize(const uint8_t** source, uint32_t& bytesLeftInBuffer, T& t);
512 template<class T, class... Args>
513 inline void deserialize(const uint8_t** source, uint32_t& bytesLeftInBuffer, T& t, Args&... args);
514
515 // deserialize fixed size array ("type name[number];")
516 template <class T, int N>
deserialize(const uint8_t ** source,uint32_t & bytesLeftInBuffer,T (& array)[N])517 inline void deserialize(const uint8_t** source, uint32_t& bytesLeftInBuffer, T (&array)[N]) {
518 for (int i = 0; i < N; i++) {
519 deserialize(source, bytesLeftInBuffer, array[i]);
520 }
521 }
522
523 template <class T, std::size_t N>
deserialize(const uint8_t ** source,uint32_t & bytesLeftInBuffer,std::array<T,N> & array)524 inline void deserialize(const uint8_t** source, uint32_t& bytesLeftInBuffer,
525 std::array<T, N>& array) {
526 for (std::size_t i = 0; i < N; i++) {
527 deserialize(source, bytesLeftInBuffer, array[i]);
528 }
529 }
530
531 // deserialize a pair
532 template<class T1, class T2>
deserialize(const uint8_t ** source,uint32_t & bytesLeftInBuffer,std::pair<T1,T2> & pair)533 inline void deserialize(const uint8_t** source, uint32_t& bytesLeftInBuffer,
534 std::pair<T1, T2>& pair) {
535 deserialize(source, bytesLeftInBuffer, pair.first);
536 deserialize(source, bytesLeftInBuffer, pair.second);
537 }
538
539 // deserialize uint8_t* (as a pointer to the serialized data)
deserialize(const uint8_t ** source,uint32_t & bytesLeftInBuffer,const uint8_t * & value)540 inline void deserialize(const uint8_t** source, uint32_t& bytesLeftInBuffer, const uint8_t*& value) {
541 if (bytesLeftInBuffer == 0) {
542 throw IncorrectDeserializationException("unexpected end of buffer");
543 }
544 bytesLeftInBuffer = 0;
545 value = *source;
546 }
547
548 // deserialize a unique_ptr
549 template<class T>
deserialize(const uint8_t ** source,uint32_t & bytesLeftInBuffer,std::unique_ptr<T> & ptr)550 inline void deserialize(const uint8_t** source, uint32_t& bytesLeftInBuffer,
551 std::unique_ptr<T>& ptr) {
552 sassert(!ptr);
553 bool isNotEmpty;
554 deserialize(source, bytesLeftInBuffer, isNotEmpty);
555 if (isNotEmpty) {
556 ptr.reset(new T());
557 deserialize(source, bytesLeftInBuffer, *ptr);
558 }
559 }
560
561 template<class T, class A>
deserialize(const uint8_t ** source,uint32_t & bytesLeftInBuffer,std::vector<T,A> & vec)562 inline void deserialize(const uint8_t** source, uint32_t& bytesLeftInBuffer,
563 std::vector<T, A>& vec) {
564 sassert(vec.size() == 0);
565 uint32_t size;
566 deserialize(source, bytesLeftInBuffer, size);
567 if (size > kMaxDeserializedElementsCount) {
568 throw IncorrectDeserializationException("untrustworthy vector size");
569 }
570 vec.resize(size);
571 for (unsigned i = 0; i < size; ++i) {
572 deserialize(source, bytesLeftInBuffer, vec[i]);
573 }
574 }
575
576 template<class T, size_t Size>
deserialize(const uint8_t ** source,uint32_t & bytesLeftInBuffer,small_vector<T,Size> & vec)577 inline void deserialize(const uint8_t **source, uint32_t& bytesLeftInBuffer,
578 small_vector<T, Size> &vec) {
579 sassert(vec.size() == 0);
580 uint32_t size;
581 deserialize(source, bytesLeftInBuffer, size);
582 if (size > kMaxDeserializedElementsCount) {
583 throw IncorrectDeserializationException("untrustworthy vector size");
584 }
585 vec.resize(size);
586 for (unsigned i = 0; i < size; ++i) {
587 deserialize(source, bytesLeftInBuffer, vec[i]);
588 }
589 }
590
591 template <typename K, typename C, typename A>
deserialize(const uint8_t ** source,uint32_t & bytesLeftInBuffer,std::set<K,C,A> & set)592 inline void deserialize(const uint8_t** source, uint32_t& bytesLeftInBuffer,
593 std::set<K, C, A>& set) {
594 sassert(set.size() == 0);
595 uint32_t size;
596 deserialize(source, bytesLeftInBuffer, size);
597 if (size > kMaxDeserializedElementsCount) {
598 throw IncorrectDeserializationException("untrustworthy set size");
599 }
600 for (unsigned i = 0; i < size; ++i) {
601 K element;
602 deserialize(source, bytesLeftInBuffer, element);
603 set.insert(std::move(element));
604 }
605 }
606
607 template <typename K, typename T, typename C, typename A>
deserialize(const uint8_t ** source,uint32_t & bytesLeftInBuffer,std::map<K,T,C,A> & map)608 inline void deserialize(const uint8_t** source, uint32_t& bytesLeftInBuffer,
609 std::map<K, T, C, A>& map) {
610 sassert(map.size() == 0);
611 uint32_t size;
612 deserialize(source, bytesLeftInBuffer, size);
613 if (size > kMaxDeserializedElementsCount) {
614 throw IncorrectDeserializationException("untrustworthy map size");
615 }
616 for (unsigned i = 0; i < size; ++i) {
617 std::pair<K, T> v;
618 deserialize(source, bytesLeftInBuffer, v);
619 map.insert(std::move(v));
620 }
621 }
622
623 template<typename T, typename Size, typename Alloc>
deserialize(const uint8_t ** source,uint32_t & bytesLeftInBuffer,compact_vector<T,Size,Alloc> & vec)624 inline void deserialize(const uint8_t** source, uint32_t& bytesLeftInBuffer,
625 compact_vector<T, Size, Alloc>& vec) {
626 sassert(vec.size() == 0);
627 uint32_t size;
628 deserialize(source, bytesLeftInBuffer, size);
629 if (size > kMaxDeserializedElementsCount) {
630 throw IncorrectDeserializationException("untrustworthy compact_vector size");
631 }
632 vec.resize(size);
633 for(auto &element : vec) {
634 deserialize(source, bytesLeftInBuffer, element);
635 }
636 }
637
638 template <typename T, typename C, class Compare>
deserialize(const uint8_t ** source,uint32_t & bytesLeftInBuffer,flat_set<T,C,Compare> & set)639 inline void deserialize(const uint8_t** source, uint32_t& bytesLeftInBuffer,
640 flat_set<T, C, Compare>& set) {
641 deserialize(source, bytesLeftInBuffer, set.data());
642 }
643
644 template <typename Key, typename T, typename C, class Compare>
deserialize(const uint8_t ** source,uint32_t & bytesLeftInBuffer,flat_map<Key,T,C,Compare> & map)645 inline void deserialize(const uint8_t** source, uint32_t& bytesLeftInBuffer,
646 flat_map<Key, T, C, Compare>& map) {
647 deserialize(source, bytesLeftInBuffer, map.data());
648 }
649
650 template<class T>
deserialize(const uint8_t ** source,uint32_t & bytesLeftInBuffer,T & t)651 inline void deserialize(const uint8_t** source, uint32_t& bytesLeftInBuffer, T& t) {
652 return t.deserialize(source, bytesLeftInBuffer);
653 }
654
655 template<class T, class... Args>
deserialize(const uint8_t ** source,uint32_t & bytesLeftInBuffer,T & t,Args &...args)656 inline void deserialize(const uint8_t** source, uint32_t& bytesLeftInBuffer, T& t, Args&... args) {
657 deserialize(source, bytesLeftInBuffer, t);
658 deserialize(source, bytesLeftInBuffer, args...);
659 }
660
661 /*
662 * Advances deserialization state without reading data
663 */
664 template <class T>
deserializeAndIgnore(const uint8_t ** source,uint32_t & bytesLeftInBuffer)665 inline void deserializeAndIgnore(const uint8_t** source, uint32_t& bytesLeftInBuffer) {
666 T dummy;
667 deserialize(source, bytesLeftInBuffer, dummy);
668 }
669
670 /*
671 * The main interface of the serialization framework
672 */
673
674 /*
675 * Serializes a tuple of variables into the buffer.
676 * The buffer must be empty when calling this function and will be properly resized
677 */
678 template <class... Args>
serialize(std::vector<uint8_t> & buffer,const Args &...args)679 void serialize(std::vector<uint8_t>& buffer, const Args&... args) {
680 sassert(buffer.empty());
681 buffer.resize(serializedSize(args...));
682 uint8_t* destination = buffer.data();
683 serialize(&destination, args...);
684 sassert(std::distance(buffer.data(), destination) == (int32_t)buffer.size());
685 }
686
687 /*
688 * Deserializes a tuple of variables from the data in the sourceBuffer.
689 * Throws IncorrectDeserializationException when buffer is too short or malformed (some types
690 * may check if the input bytes represent an acceptable value).
691 * Returns number of bytes that were not used in the deserialization process (ie. this value
692 * is greater than zero is the buffer is longer than size of all the deserialized data).
693 */
694 template<class... Args>
deserialize(const uint8_t * sourceBuffer,uint32_t sourceBufferSize,Args &...args)695 inline uint32_t deserialize(const uint8_t* sourceBuffer, uint32_t sourceBufferSize, Args&... args) {
696 if (sourceBufferSize > kMaxDeserializedBytesCount) {
697 throw IncorrectDeserializationException("too much data to deserialize");
698 }
699 deserialize(&sourceBuffer, sourceBufferSize, args...);
700 return sourceBufferSize;
701 }
702
703 /*
704 * The same as the function above, but with the std::vector interface
705 */
706 template<class... Args>
deserialize(const std::vector<uint8_t> & sourceBuffer,Args &...args)707 inline uint32_t deserialize(const std::vector<uint8_t>& sourceBuffer, Args&... args) {
708 return deserialize(sourceBuffer.data(), sourceBuffer.size(), args...);
709 }
710