Gamedev Framework (gf)  0.10.0
A C++14 framework for 2D games
SerializationOps.h
1 /*
2  * Gamedev Framework (gf)
3  * Copyright (C) 2016-2018 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  GF_API Serializer& operator|(Serializer& ar, T data) {
110  using U = typename std::underlying_type<T>::type;
111  return ar | static_cast<U>(data);
112  }
113 
118  GF_API Serializer& operator|(Serializer& ar, float data);
119 
124  GF_API Serializer& operator|(Serializer& ar, double data);
125 
130  GF_API Serializer& operator|(Serializer& ar, const char *str);
131 
136  GF_API Serializer& operator|(Serializer& ar, const std::string& str);
137 
142  template<typename T, std::size_t N>
143  inline
144  Serializer& operator|(Serializer& ar, const T (&array)[N]) {
145  ar.writeSizeHeader(N);
146 
147  for (auto& item : array) {
148  ar | const_cast<T&>(item);
149  }
150 
151  return ar;
152  }
153 
158  template<typename T>
159  inline
160  Serializer& operator|(Serializer& ar, const std::vector<T>& array) {
161  ar.writeSizeHeader(array.size());
162 
163  for (auto& item : array) {
164  ar | const_cast<T&>(item);
165  }
166 
167  return ar;
168  }
169 
174  template<typename T, std::size_t N>
175  inline
176  Serializer& operator|(Serializer& ar, const std::array<T, N>& array) {
177  ar.writeSizeHeader(array.size());
178 
179  for (auto& item : array) {
180  ar | const_cast<T&>(item);
181  }
182 
183  return ar;
184  }
185 
190  template<typename T>
191  inline
192  Serializer& operator|(Serializer& ar, const std::set<T>& set) {
193  ar.writeSizeHeader(set.size());
194 
195  for (auto& item : set) {
196  ar | const_cast<T&>(item);
197  }
198 
199  return ar;
200  }
201 
206  template<typename T>
207  inline
208  Serializer& operator|(Serializer& ar, const std::unordered_set<T>& set) {
209  ar.writeSizeHeader(set.size());
210 
211  for (auto& item : set) {
212  ar | const_cast<T&>(item);
213  }
214 
215  return ar;
216  }
217 
222  template<typename K, typename V>
223  inline
224  Serializer& operator|(Serializer& ar, const std::map<K, V>& map) {
225  ar.writeSizeHeader(map.size());
226 
227  for (auto& item : map) {
228  ar | const_cast<K&>(item.first) | const_cast<V&>(item.second);
229  }
230 
231  return ar;
232  }
233 
238  template<typename K, typename V>
239  inline
240  Serializer& operator|(Serializer& ar, const std::unordered_map<K, V>& map) {
241  ar.writeSizeHeader(map.size());
242 
243  for (auto& item : map) {
244  ar | const_cast<K&>(item.first) | const_cast<V&>(item.second);
245  }
246 
247  return ar;
248  }
249 
250 
251 
256  GF_API Deserializer& operator|(Deserializer& ar, bool& data);
257 
262  GF_API Deserializer& operator|(Deserializer& ar, char& data);
263 
268  GF_API Deserializer& operator|(Deserializer& ar, uint8_t& data);
269 
274  GF_API Deserializer& operator|(Deserializer& ar, uint16_t& data);
275 
280  GF_API Deserializer& operator|(Deserializer& ar, uint32_t& data);
281 
286  GF_API Deserializer& operator|(Deserializer& ar, uint64_t& data);
287 
292  GF_API Deserializer& operator|(Deserializer& ar, int8_t& data);
293 
298  GF_API Deserializer& operator|(Deserializer& ar, int16_t& data);
299 
304  GF_API Deserializer& operator|(Deserializer& ar, int32_t& data);
305 
310  GF_API Deserializer& operator|(Deserializer& ar, int64_t& data);
311 
312  template<typename T, typename E = typename std::enable_if<std::is_enum<T>::value, T>::type>
313  GF_API Deserializer& operator|(Deserializer& ar, T& data) {
314  using U = typename std::underlying_type<T>::type;
315  U underlying;
316  ar | underlying;
317  data = static_cast<T>(underlying);
318  return ar;
319  }
320 
325  GF_API Deserializer& operator|(Deserializer& ar, float& data);
326 
331  GF_API Deserializer& operator|(Deserializer& ar, double& data);
332 
338 
343  GF_API Deserializer& operator|(Deserializer& ar, std::string& str);
344 
349  template<typename T>
350  inline
352  std::size_t size;
353 
354  if (!ar.readSizeHeader(size)) {
355  return ar;
356  }
357 
358  if (size != array.getSize()) {
359  return ar;
360  }
361 
362  for (auto& item : array) {
363  ar | item;
364  }
365 
366  return ar;
367  }
368 
373  template<typename T, std::size_t N>
374  inline
375  Deserializer& operator|(Deserializer& ar, T (&array)[N]) {
376  return ar | BufferRef<T>(array);
377  }
378 
383  template<typename T, std::size_t N>
384  inline
385  Deserializer& operator|(Deserializer& ar, std::array<T, N>& array) {
386  return ar | BufferRef<T>(array);
387  }
388 
393  template<typename T>
394  inline
395  Deserializer& operator|(Deserializer& ar, std::vector<T>& array) {
396  std::size_t size;
397 
398  if (!ar.readSizeHeader(size)) {
399  return ar;
400  }
401 
402  array.clear();
403 
404  for (std::size_t i = 0; i < size; ++i) {
405  T item;
406  ar | item;
407  array.emplace_back(std::move(item));
408  }
409 
410  return ar;
411  }
412 
417  template<typename T>
418  inline
419  Deserializer& operator|(Deserializer& ar, std::set<T>& set) {
420  std::size_t size;
421 
422  if (!ar.readSizeHeader(size)) {
423  return ar;
424  }
425 
426  set.clear();
427 
428  for (std::size_t i = 0; i < size; ++i) {
429  T item;
430  ar | item;
431  set.emplace(std::move(item));
432  }
433 
434  return ar;
435  }
436 
441  template<typename T>
442  inline
443  Deserializer& operator|(Deserializer& ar, std::unordered_set<T>& set) {
444  std::size_t size;
445 
446  if (!ar.readSizeHeader(size)) {
447  return ar;
448  }
449 
450  set.clear();
451 
452  for (std::size_t i = 0; i < size; ++i) {
453  T item;
454  ar | item;
455  set.emplace(std::move(item));
456  }
457 
458  return ar;
459  }
460 
465  template<typename K, typename V>
466  inline
467  Deserializer& operator|(Deserializer& ar, std::map<K,V>& map) {
468  std::size_t size;
469 
470  if (!ar.readSizeHeader(size)) {
471  return ar;
472  }
473 
474  map.clear();
475 
476  for (std::size_t i = 0; i < size; ++i) {
477  K key;
478  ar | key;
479  V value;
480  ar | value;
481 
482  map.emplace(std::move(key), std::move(value));
483  }
484 
485  return ar;
486  }
487 
492  template<typename K, typename V>
493  inline
494  Deserializer& operator|(Deserializer& ar, std::unordered_map<K,V>& map) {
495  std::size_t size;
496 
497  if (!ar.readSizeHeader(size)) {
498  return ar;
499  }
500 
501  map.clear();
502 
503  for (std::size_t i = 0; i < size; ++i) {
504  K key;
505  ar | key;
506  V value;
507  ar | value;
508 
509  map.emplace(std::move(key), std::move(value));
510  }
511 
512  return ar;
513  }
514 
515 #ifndef DOXYGEN_SHOULD_SKIP_THIS
516 }
517 #endif
518 }
519 
520 #endif // GF_SERIALIZATION_OPS_H
A deserializer from a binary file.
Definition: Serialization.h:152
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:494
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:375
Deserializer & operator|(Deserializer &ar, std::set< T > &set)
Deserialize a set object.
Definition: SerializationOps.h:419
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:160
Serializer & operator|(Serializer &ar, const std::map< K, V > &map)
Serialize a map object.
Definition: SerializationOps.h:224
A serializer to a binary file.
Definition: Serialization.h:45
The namespace for gf classes.
Definition: Action.h:34
Serializer & operator|(Serializer &ar, const std::array< T, N > &array)
Serialize an array object.
Definition: SerializationOps.h:176
Deserializer & operator|(Deserializer &ar, std::array< T, N > &array)
Deserialize an array object.
Definition: SerializationOps.h:385
Deserializer & operator|(Deserializer &ar, std::unordered_set< T > &set)
Deserialize a set object.
Definition: SerializationOps.h:443
Serializer & operator|(Serializer &ar, const std::unordered_set< T > &set)
Serialize a set object.
Definition: SerializationOps.h:208
Deserializer & operator|(Deserializer &ar, BufferRef< T > array)
Deserialize an array object.
Definition: SerializationOps.h:351
Deserializer & operator|(Deserializer &ar, std::vector< T > &array)
Deserialize an array object.
Definition: SerializationOps.h:395
Deserializer & operator|(Deserializer &ar, std::map< K, V > &map)
Deserialize a map object.
Definition: SerializationOps.h:467
Deserializer & operator|(Deserializer &ar, T &data)
Definition: SerializationOps.h:313
Serializer & operator|(Serializer &ar, T data)
Serialize an enum object.
Definition: SerializationOps.h:109
Serializer & operator|(Serializer &ar, const T(&array)[N])
Serialize an array object.
Definition: SerializationOps.h:144
Serializer & operator|(Serializer &ar, const std::set< T > &set)
Serialize a set object.
Definition: SerializationOps.h:192
Serializer & operator|(Serializer &ar, const std::unordered_map< K, V > &map)
Serialize a map object.
Definition: SerializationOps.h:240