Gamedev Framework (gf)  0.12.0
A C++14 framework for 2D games
SerializationOps.h
1 /*
2  * Gamedev Framework (gf)
3  * Copyright (C) 2016-2019 Julien Bernard
4  *
5  * This software is provided 'as-is', without any express or implied
6  * warranty. In no event will the authors be held liable for any damages
7  * arising from the use of this software.
8  *
9  * Permission is granted to anyone to use this software for any purpose,
10  * including commercial applications, and to alter it and redistribute it
11  * freely, subject to the following restrictions:
12  *
13  * 1. The origin of this software must not be misrepresented; you must not
14  * claim that you wrote the original software. If you use this software
15  * in a product, an acknowledgment in the product documentation would be
16  * appreciated but is not required.
17  * 2. Altered source versions must be plainly marked as such, and must not be
18  * misrepresented as being the original software.
19  * 3. This notice may not be removed or altered from any source distribution.
20  */
21 #ifndef GF_SERIALIZATION_OPS_H
22 #define GF_SERIALIZATION_OPS_H
23 
24 #include <cstdint>
25 #include <cstring>
26 
27 #include <array>
28 #include <map>
29 #include <set>
30 #include <type_traits>
31 #include <unordered_map>
32 #include <unordered_set>
33 #include <vector>
34 
35 #include "BufferRef.h"
36 #include "Portability.h"
37 #include "Serialization.h"
38 
39 namespace gf {
40 #ifndef DOXYGEN_SHOULD_SKIP_THIS
41 inline namespace v1 {
42 #endif
43 
48  GF_API Serializer& operator|(Serializer& ar, bool data);
49 
54  GF_API Serializer& operator|(Serializer& ar, char data);
55 
60  GF_API Serializer& operator|(Serializer& ar, uint8_t data);
61 
66  GF_API Serializer& operator|(Serializer& ar, uint16_t data);
67 
72  GF_API Serializer& operator|(Serializer& ar, uint32_t data);
73 
78  GF_API Serializer& operator|(Serializer& ar, uint64_t data);
79 
84  GF_API Serializer& operator|(Serializer& ar, int8_t data);
85 
90  GF_API Serializer& operator|(Serializer& ar, int16_t data);
91 
96  GF_API Serializer& operator|(Serializer& ar, int32_t data);
97 
102  GF_API Serializer& operator|(Serializer& ar, int64_t data);
103 
108  template<typename T, typename E = typename std::enable_if<std::is_enum<T>::value, T>::type>
109  inline
111  using U = typename std::underlying_type<T>::type;
112  return ar | static_cast<U>(data);
113  }
114 
119  GF_API Serializer& operator|(Serializer& ar, float data);
120 
125  GF_API Serializer& operator|(Serializer& ar, double data);
126 
131  GF_API Serializer& operator|(Serializer& ar, const char *str);
132 
137  GF_API Serializer& operator|(Serializer& ar, const std::string& str);
138 
143  template<typename T, std::size_t N>
144  inline
145  Serializer& operator|(Serializer& ar, const T (&array)[N]) {
146  ar.writeSizeHeader(N);
147 
148  for (auto& item : array) {
149  ar | const_cast<T&>(item);
150  }
151 
152  return ar;
153  }
154 
159  template<typename T>
160  inline
161  Serializer& operator|(Serializer& ar, const std::vector<T>& array) {
162  ar.writeSizeHeader(array.size());
163 
164  for (auto& item : array) {
165  ar | const_cast<T&>(item);
166  }
167 
168  return ar;
169  }
170 
175  template<typename T, std::size_t N>
176  inline
177  Serializer& operator|(Serializer& ar, const std::array<T, N>& array) {
178  ar.writeSizeHeader(array.size());
179 
180  for (auto& item : array) {
181  ar | const_cast<T&>(item);
182  }
183 
184  return ar;
185  }
186 
191  template<typename T>
192  inline
193  Serializer& operator|(Serializer& ar, const std::set<T>& set) {
194  ar.writeSizeHeader(set.size());
195 
196  for (auto& item : set) {
197  ar | const_cast<T&>(item);
198  }
199 
200  return ar;
201  }
202 
207  template<typename T>
208  inline
209  Serializer& operator|(Serializer& ar, const std::unordered_set<T>& set) {
210  ar.writeSizeHeader(set.size());
211 
212  for (auto& item : set) {
213  ar | const_cast<T&>(item);
214  }
215 
216  return ar;
217  }
218 
223  template<typename K, typename V>
224  inline
225  Serializer& operator|(Serializer& ar, const std::map<K, V>& map) {
226  ar.writeSizeHeader(map.size());
227 
228  for (auto& item : map) {
229  ar | const_cast<K&>(item.first) | const_cast<V&>(item.second);
230  }
231 
232  return ar;
233  }
234 
239  template<typename K, typename V>
240  inline
241  Serializer& operator|(Serializer& ar, const std::unordered_map<K, V>& map) {
242  ar.writeSizeHeader(map.size());
243 
244  for (auto& item : map) {
245  ar | const_cast<K&>(item.first) | const_cast<V&>(item.second);
246  }
247 
248  return ar;
249  }
250 
251 
252 
257  GF_API Deserializer& operator|(Deserializer& ar, bool& data);
258 
263  GF_API Deserializer& operator|(Deserializer& ar, char& data);
264 
269  GF_API Deserializer& operator|(Deserializer& ar, uint8_t& data);
270 
275  GF_API Deserializer& operator|(Deserializer& ar, uint16_t& data);
276 
281  GF_API Deserializer& operator|(Deserializer& ar, uint32_t& data);
282 
287  GF_API Deserializer& operator|(Deserializer& ar, uint64_t& data);
288 
293  GF_API Deserializer& operator|(Deserializer& ar, int8_t& data);
294 
299  GF_API Deserializer& operator|(Deserializer& ar, int16_t& data);
300 
305  GF_API Deserializer& operator|(Deserializer& ar, int32_t& data);
306 
311  GF_API Deserializer& operator|(Deserializer& ar, int64_t& data);
312 
313  template<typename T, typename E = typename std::enable_if<std::is_enum<T>::value, T>::type>
314  inline
316  using U = typename std::underlying_type<T>::type;
317  U underlying;
318  ar | underlying;
319  data = static_cast<T>(underlying);
320  return ar;
321  }
322 
327  GF_API Deserializer& operator|(Deserializer& ar, float& data);
328 
333  GF_API Deserializer& operator|(Deserializer& ar, double& data);
334 
340 
345  GF_API Deserializer& operator|(Deserializer& ar, std::string& str);
346 
351  template<typename T>
352  inline
354  std::size_t size;
355 
356  if (!ar.readSizeHeader(size)) {
357  return ar;
358  }
359 
360  if (size != array.getSize()) {
361  return ar;
362  }
363 
364  for (auto& item : array) {
365  ar | item;
366  }
367 
368  return ar;
369  }
370 
375  template<typename T, std::size_t N>
376  inline
377  Deserializer& operator|(Deserializer& ar, T (&array)[N]) {
378  return ar | BufferRef<T>(array);
379  }
380 
385  template<typename T, std::size_t N>
386  inline
387  Deserializer& operator|(Deserializer& ar, std::array<T, N>& array) {
388  return ar | BufferRef<T>(array);
389  }
390 
395  template<typename T>
396  inline
397  Deserializer& operator|(Deserializer& ar, std::vector<T>& array) {
398  std::size_t size;
399 
400  if (!ar.readSizeHeader(size)) {
401  return ar;
402  }
403 
404  array.clear();
405 
406  for (std::size_t i = 0; i < size; ++i) {
407  T item;
408  ar | item;
409  array.emplace_back(std::move(item));
410  }
411 
412  return ar;
413  }
414 
419  template<typename T>
420  inline
421  Deserializer& operator|(Deserializer& ar, std::set<T>& set) {
422  std::size_t size;
423 
424  if (!ar.readSizeHeader(size)) {
425  return ar;
426  }
427 
428  set.clear();
429 
430  for (std::size_t i = 0; i < size; ++i) {
431  T item;
432  ar | item;
433  set.emplace(std::move(item));
434  }
435 
436  return ar;
437  }
438 
443  template<typename T>
444  inline
445  Deserializer& operator|(Deserializer& ar, std::unordered_set<T>& set) {
446  std::size_t size;
447 
448  if (!ar.readSizeHeader(size)) {
449  return ar;
450  }
451 
452  set.clear();
453 
454  for (std::size_t i = 0; i < size; ++i) {
455  T item;
456  ar | item;
457  set.emplace(std::move(item));
458  }
459 
460  return ar;
461  }
462 
467  template<typename K, typename V>
468  inline
469  Deserializer& operator|(Deserializer& ar, std::map<K,V>& map) {
470  std::size_t size;
471 
472  if (!ar.readSizeHeader(size)) {
473  return ar;
474  }
475 
476  map.clear();
477 
478  for (std::size_t i = 0; i < size; ++i) {
479  K key;
480  ar | key;
481  V value;
482  ar | value;
483 
484  map.emplace(std::move(key), std::move(value));
485  }
486 
487  return ar;
488  }
489 
494  template<typename K, typename V>
495  inline
496  Deserializer& operator|(Deserializer& ar, std::unordered_map<K,V>& map) {
497  std::size_t size;
498 
499  if (!ar.readSizeHeader(size)) {
500  return ar;
501  }
502 
503  map.clear();
504 
505  for (std::size_t i = 0; i < size; ++i) {
506  K key;
507  ar | key;
508  V value;
509  ar | value;
510 
511  map.emplace(std::move(key), std::move(value));
512  }
513 
514  return ar;
515  }
516 
517 #ifndef DOXYGEN_SHOULD_SKIP_THIS
518 }
519 #endif
520 }
521 
522 #endif // GF_SERIALIZATION_OPS_H
A deserializer from a binary file.
Definition: Serialization.h:153
void writeSizeHeader(std::size_t size)
Write a size header.
Deserializer & operator|(Deserializer &ar, std::unordered_map< K, V > &map)
Deserialize a map object.
Definition: SerializationOps.h:496
constexpr std::size_t getSize() const noexcept
Get the number of elements.
Definition: BufferRef.h:136
Deserializer & operator|(Deserializer &ar, T(&array)[N])
Deserialize an array object.
Definition: SerializationOps.h:377
Deserializer & operator|(Deserializer &ar, std::set< T > &set)
Deserialize a set object.
Definition: SerializationOps.h:421
A reference to a modifiable buffer and its size.
Definition: BufferRef.h:43
bool readSizeHeader(std::size_t &size)
Read a size header.
Serializer & operator|(Serializer &ar, const std::vector< T > &array)
Serialize an array object.
Definition: SerializationOps.h:161
Serializer & operator|(Serializer &ar, const std::map< K, V > &map)
Serialize a map object.
Definition: SerializationOps.h:225
A serializer to a binary file.
Definition: Serialization.h:45
The namespace for gf classes.
Definition: Action.h:35
Serializer & operator|(Serializer &ar, const std::array< T, N > &array)
Serialize an array object.
Definition: SerializationOps.h:177
Deserializer & operator|(Deserializer &ar, std::array< T, N > &array)
Deserialize an array object.
Definition: SerializationOps.h:387
Deserializer & operator|(Deserializer &ar, std::unordered_set< T > &set)
Deserialize a set object.
Definition: SerializationOps.h:445
Serializer & operator|(Serializer &ar, const std::unordered_set< T > &set)
Serialize a set object.
Definition: SerializationOps.h:209
Deserializer & operator|(Deserializer &ar, BufferRef< T > array)
Deserialize an array object.
Definition: SerializationOps.h:353
Deserializer & operator|(Deserializer &ar, std::vector< T > &array)
Deserialize an array object.
Definition: SerializationOps.h:397
Deserializer & operator|(Deserializer &ar, std::map< K, V > &map)
Deserialize a map object.
Definition: SerializationOps.h:469
Deserializer & operator|(Deserializer &ar, T &data)
Definition: SerializationOps.h:315
Serializer & operator|(Serializer &ar, T data)
Serialize an enum object.
Definition: SerializationOps.h:110
Serializer & operator|(Serializer &ar, const T(&array)[N])
Serialize an array object.
Definition: SerializationOps.h:145
Serializer & operator|(Serializer &ar, const std::set< T > &set)
Serialize a set object.
Definition: SerializationOps.h:193
Serializer & operator|(Serializer &ar, const std::unordered_map< K, V > &map)
Serialize a map object.
Definition: SerializationOps.h:241