Pyrogenesis  trunk
SerializeTemplates.h
Go to the documentation of this file.
1 /* Copyright (C) 2016 Wildfire Games.
2  * This file is part of 0 A.D.
3  *
4  * 0 A.D. is free software: you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License as published by
6  * the Free Software Foundation, either version 2 of the License, or
7  * (at your option) any later version.
8  *
9  * 0 A.D. is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with 0 A.D. If not, see <http://www.gnu.org/licenses/>.
16  */
17 
18 #ifndef INCLUDED_SERIALIZETEMPLATES
19 #define INCLUDED_SERIALIZETEMPLATES
20 
21 /**
22  * @file
23  * Helper templates for serializing/deserializing common objects.
24  */
25 
27 
28 template<typename ELEM>
30 {
31  template<typename T>
32  void operator()(ISerializer& serialize, const char* name, std::vector<T>& value)
33  {
34  size_t len = value.size();
35  serialize.NumberU32_Unbounded("length", (u32)len);
36  for (size_t i = 0; i < len; ++i)
37  ELEM()(serialize, name, value[i]);
38  }
39 
40  template<typename T>
41  void operator()(IDeserializer& deserialize, const char* name, std::vector<T>& value)
42  {
43  value.clear();
44  u32 len;
45  deserialize.NumberU32_Unbounded("length", len);
46  value.reserve(len); // TODO: watch out for out-of-memory
47  for (size_t i = 0; i < len; ++i)
48  {
49  T el;
50  ELEM()(deserialize, name, el);
51  value.push_back(el);
52  }
53  }
54 };
55 
56 template<typename ELEM>
58 {
59  template<typename T>
60  void operator()(ISerializer& serialize, const char* name, std::vector<T>& value)
61  {
62  size_t len = value.size();
63  serialize.NumberU32_Unbounded("length", (u32)len);
64  if (len == 0)
65  return;
66  u32 count = 1;
67  T prevVal = value[0];
68  for (size_t i = 1; i < len; ++i)
69  {
70  if (prevVal == value[i])
71  {
72  count++;
73  continue;
74  }
75  serialize.NumberU32_Unbounded("#", count);
76  ELEM()(serialize, name, prevVal);
77  count = 1;
78  prevVal = value[i];
79  }
80  serialize.NumberU32_Unbounded("#", count);
81  ELEM()(serialize, name, prevVal);
82  }
83 
84  template<typename T>
85  void operator()(IDeserializer& deserialize, const char* name, std::vector<T>& value)
86  {
87  value.clear();
88  u32 len;
89  deserialize.NumberU32_Unbounded("length", len);
90  value.reserve(len); // TODO: watch out for out-of-memory
91  for (size_t i = 0; i < len;)
92  {
93  u32 count;
94  deserialize.NumberU32_Unbounded("#", count);
95  T el;
96  ELEM()(deserialize, name, el);
97  i += count;
98  value.insert(value.end(), count, el);
99  }
100  }
101 };
102 
103 template<typename KS, typename VS>
105 {
106  template<typename K, typename V>
107  void operator()(ISerializer& serialize, const char* UNUSED(name), std::map<K, V>& value)
108  {
109  size_t len = value.size();
110  serialize.NumberU32_Unbounded("length", (u32)len);
111  for (typename std::map<K, V>::iterator it = value.begin(); it != value.end(); ++it)
112  {
113  KS()(serialize, "key", it->first);
114  VS()(serialize, "value", it->second);
115  }
116  }
117 
118  template<typename K, typename V, typename C>
119  void operator()(ISerializer& serialize, const char* UNUSED(name), std::map<K, V>& value, C& context)
120  {
121  size_t len = value.size();
122  serialize.NumberU32_Unbounded("length", (u32)len);
123  for (typename std::map<K, V>::iterator it = value.begin(); it != value.end(); ++it)
124  {
125  KS()(serialize, "key", it->first);
126  VS()(serialize, "value", it->second, context);
127  }
128  }
129 
130  template<typename M>
131  void operator()(IDeserializer& deserialize, const char* UNUSED(name), M& value)
132  {
133  typedef typename M::key_type K;
134  typedef typename M::value_type::second_type V; // M::data_type gives errors with gcc
135  value.clear();
136  u32 len;
137  deserialize.NumberU32_Unbounded("length", len);
138  for (size_t i = 0; i < len; ++i)
139  {
140  K k;
141  V v;
142  KS()(deserialize, "key", k);
143  VS()(deserialize, "value", v);
144  value.insert(std::make_pair(k, v));
145  }
146  }
147 
148  template<typename M, typename C>
149  void operator()(IDeserializer& deserialize, const char* UNUSED(name), M& value, C& context)
150  {
151  typedef typename M::key_type K;
152  typedef typename M::value_type::second_type V; // M::data_type gives errors with gcc
153  value.clear();
154  u32 len;
155  deserialize.NumberU32_Unbounded("length", len);
156  for (size_t i = 0; i < len; ++i)
157  {
158  K k;
159  V v;
160  KS()(deserialize, "key", k);
161  VS()(deserialize, "value", v, context);
162  value.insert(std::make_pair(k, v));
163  }
164  }
165 };
166 
167 // We have to order the map before serializing to make things consistent
168 template<typename KS, typename VS>
170 {
171  template<typename K, typename V>
172  void operator()(ISerializer& serialize, const char* name, boost::unordered_map<K, V>& value)
173  {
174  std::map<K, V> ordered_value(value.begin(), value.end());
175  SerializeMap<KS, VS>()(serialize, name, ordered_value);
176  }
177 
178  template<typename K, typename V>
179  void operator()(IDeserializer& deserialize, const char* name, boost::unordered_map<K, V>& value)
180  {
181  SerializeMap<KS, VS>()(deserialize, name, value);
182  }
183 };
184 
185 template<typename T, T max>
187 {
188  void operator()(ISerializer& serialize, const char* name, T value)
189  {
190  serialize.NumberU8(name, value, 0, max);
191  }
192 
193  void operator()(IDeserializer& deserialize, const char* name, T& value)
194  {
195  u8 val;
196  deserialize.NumberU8(name, val, 0, max);
197  value = (T)val;
198  }
199 };
200 
202 {
203  void operator()(ISerializer& serialize, const char* name, u8 value)
204  {
205  serialize.NumberU8_Unbounded(name, value);
206  }
207 
208  void operator()(IDeserializer& deserialize, const char* name, u8& value)
209  {
210  deserialize.NumberU8_Unbounded(name, value);
211  }
212 };
213 
215 {
216  void operator()(ISerializer& serialize, const char* name, u16 value)
217  {
218  serialize.NumberU16_Unbounded(name, value);
219  }
220 
221  void operator()(IDeserializer& deserialize, const char* name, u16& value)
222  {
223  deserialize.NumberU16_Unbounded(name, value);
224  }
225 };
226 
228 {
229  void operator()(ISerializer& serialize, const char* name, u32 value)
230  {
231  serialize.NumberU32_Unbounded(name, value);
232  }
233 
234  void operator()(IDeserializer& deserialize, const char* name, u32& value)
235  {
236  deserialize.NumberU32_Unbounded(name, value);
237  }
238 };
239 
241 {
242  void operator()(ISerializer& serialize, const char* name, i32 value)
243  {
244  serialize.NumberI32_Unbounded(name, value);
245  }
246 
247  void operator()(IDeserializer& deserialize, const char* name, i32& value)
248  {
249  deserialize.NumberI32_Unbounded(name, value);
250  }
251 };
252 
254 {
255  void operator()(ISerializer& serialize, const char* name, bool value)
256  {
257  serialize.Bool(name, value);
258  }
259 
260  void operator()(IDeserializer& deserialize, const char* name, bool& value)
261  {
262  deserialize.Bool(name, value);
263  }
264 };
265 
267 {
268  void operator()(ISerializer& serialize, const char* name, const std::string& value)
269  {
270  serialize.StringASCII(name, value, 0, UINT32_MAX);
271  }
272 
273  void operator()(IDeserializer& deserialize, const char* name, std::string& value)
274  {
275  deserialize.StringASCII(name, value, 0, UINT32_MAX);
276  }
277 };
278 
280 {
281  void operator()(ISerializer& serialize, const char* UNUSED(name), const Waypoint& value)
282  {
283  serialize.NumberFixed_Unbounded("waypoint x", value.x);
284  serialize.NumberFixed_Unbounded("waypoint z", value.z);
285  }
286 
287  void operator()(IDeserializer& deserialize, const char* UNUSED(name), Waypoint& value)
288  {
289  deserialize.NumberFixed_Unbounded("waypoint x", value.x);
290  deserialize.NumberFixed_Unbounded("waypoint z", value.z);
291  }
292 };
293 
295 {
296  template<typename S>
297  void operator()(S& serialize, const char* UNUSED(name), PathGoal& value)
298  {
300  serialize.NumberFixed_Unbounded("goal x", value.x);
301  serialize.NumberFixed_Unbounded("goal z", value.z);
302  serialize.NumberFixed_Unbounded("goal u x", value.u.X);
303  serialize.NumberFixed_Unbounded("goal u z", value.u.Y);
304  serialize.NumberFixed_Unbounded("goal v x", value.v.X);
305  serialize.NumberFixed_Unbounded("goal v z", value.v.Y);
306  serialize.NumberFixed_Unbounded("goal hw", value.hw);
307  serialize.NumberFixed_Unbounded("goal hh", value.hh);
308  serialize.NumberFixed_Unbounded("maxdist", value.maxdist);
309  }
310 };
311 
312 #endif // INCLUDED_SERIALIZETEMPLATES
void operator()(IDeserializer &deserialize, const char *name, std::string &value)
Definition: SerializeTemplates.h:273
virtual void StringASCII(const char *name, std::string &out, uint32_t minlength, uint32_t maxlength)
Definition: IDeserializer.cpp:162
void operator()(IDeserializer &deserialize, const char *name, std::vector< T > &value)
Definition: SerializeTemplates.h:41
void operator()(IDeserializer &deserialize, const char *name, std::vector< T > &value)
Definition: SerializeTemplates.h:85
void NumberFixed_Unbounded(const char *name, fixed value)
Serialize a number.
Definition: ISerializer.h:191
virtual void Bool(const char *name, bool &out)
Definition: IDeserializer.cpp:155
#define UNUSED(param)
mark a function parameter as unused and avoid the corresponding compiler warning. ...
Definition: code_annotation.h:38
void operator()(ISerializer &serialize, const char *name, boost::unordered_map< K, V > &value)
Definition: SerializeTemplates.h:172
enum PathGoal::Type type
Definition: SerializeTemplates.h:227
Definition: SerializeTemplates.h:169
uint16_t u16
Definition: types.h:38
void operator()(IDeserializer &deserialize, const char *name, u16 &value)
Definition: SerializeTemplates.h:221
Serialization interface; see serialization overview.
Definition: ISerializer.h:120
entity_pos_t hw
Definition: PathGoal.h:47
void NumberU8_Unbounded(const char *name, uint8_t value)
Serialize a number.
Definition: ISerializer.h:150
Definition: Pathfinding.h:31
virtual void NumberU32_Unbounded(const char *name, uint32_t &out)
Definition: IDeserializer.cpp:124
Pathfinder goal.
Definition: PathGoal.h:32
Definition: SerializeTemplates.h:104
virtual void NumberFixed_Unbounded(const char *name, fixed &out)
Definition: IDeserializer.cpp:148
virtual void NumberU8_Unbounded(const char *name, uint8_t &out)
Definition: IDeserializer.cpp:100
Definition: SerializeTemplates.h:240
uint8_t u8
Definition: types.h:37
void operator()(IDeserializer &deserialize, const char *name, M &value, C &context)
Definition: SerializeTemplates.h:149
#define UINT32_MAX
Definition: wposix_types.h:73
Definition: SerializeTemplates.h:29
fixed Y
Definition: FixedVector2D.h:27
void operator()(ISerializer &serialize, const char *name, const std::string &value)
Definition: SerializeTemplates.h:268
entity_pos_t z
Definition: Pathfinding.h:33
void operator()(ISerializer &serialize, const char *name, u8 value)
Definition: SerializeTemplates.h:203
void operator()(ISerializer &serialize, const char *name, std::vector< T > &value)
Definition: SerializeTemplates.h:60
uint32_t u32
Definition: types.h:39
void operator()(IDeserializer &deserialize, const char *name, bool &value)
Definition: SerializeTemplates.h:260
Definition: SerializeTemplates.h:57
void StringASCII(const char *name, const std::string &value, uint32_t minlength, uint32_t maxlength)
Serialize an ASCII string.
Definition: ISerializer.cpp:70
Definition: SerializeTemplates.h:214
Definition: SerializeTemplates.h:266
entity_pos_t hh
Definition: PathGoal.h:47
void Bool(const char *name, bool value)
Serialize a boolean.
Definition: ISerializer.h:199
entity_pos_t x
Definition: PathGoal.h:43
#define T(string_literal)
Definition: secure_crt.cpp:76
Definition: SerializeTemplates.h:186
void NumberU32_Unbounded(const char *name, uint32_t value)
Serialize a number.
Definition: ISerializer.h:171
void operator()(S &serialize, const char *name, PathGoal &value)
Definition: SerializeTemplates.h:297
void operator()(ISerializer &serialize, const char *name, u32 value)
Definition: SerializeTemplates.h:229
void operator()(ISerializer &serialize, const char *name, u16 value)
Definition: SerializeTemplates.h:216
int32_t i32
Definition: types.h:34
CFixedVector2D v
Definition: PathGoal.h:45
void operator()(IDeserializer &deserialize, const char *name, i32 &value)
Definition: SerializeTemplates.h:247
CFixedVector2D u
Definition: PathGoal.h:45
void operator()(IDeserializer &deserialize, const char *name, M &value)
Definition: SerializeTemplates.h:131
void operator()(ISerializer &serialize, const char *name, std::map< K, V > &value)
Definition: SerializeTemplates.h:107
virtual void NumberU8(const char *name, uint8_t &out, uint8_t lower, uint8_t upper)
Definition: IDeserializer.cpp:30
void operator()(ISerializer &serialize, const char *name, i32 value)
Definition: SerializeTemplates.h:242
Definition: SerializeTemplates.h:294
void operator()(ISerializer &serialize, const char *name, T value)
Definition: SerializeTemplates.h:188
entity_pos_t maxdist
Definition: PathGoal.h:49
void operator()(IDeserializer &deserialize, const char *name, T &value)
Definition: SerializeTemplates.h:193
void operator()(ISerializer &serialize, const char *name, bool value)
Definition: SerializeTemplates.h:255
fixed X
Definition: FixedVector2D.h:27
void NumberI32_Unbounded(const char *name, int32_t value)
Serialize a number.
Definition: ISerializer.h:176
void operator()(IDeserializer &deserialize, const char *name, boost::unordered_map< K, V > &value)
Definition: SerializeTemplates.h:179
void operator()(ISerializer &serialize, const char *name, std::map< K, V > &value, C &context)
Definition: SerializeTemplates.h:119
Definition: SerializeTemplates.h:253
entity_pos_t x
Definition: Pathfinding.h:33
void operator()(ISerializer &serialize, const char *name, const Waypoint &value)
Definition: SerializeTemplates.h:281
Definition: SerializeTemplates.h:279
void operator()(IDeserializer &deserialize, const char *name, u32 &value)
Definition: SerializeTemplates.h:234
void NumberU16_Unbounded(const char *name, uint16_t value)
Serialize a number.
Definition: ISerializer.h:161
void operator()(ISerializer &serialize, const char *name, std::vector< T > &value)
Definition: SerializeTemplates.h:32
void operator()(IDeserializer &deserialize, const char *name, u8 &value)
Definition: SerializeTemplates.h:208
void NumberU8(const char *name, uint8_t value, uint8_t lower, uint8_t upper)
Serialize a number, which must be lower <= value <= upper.
Definition: ISerializer.cpp:28
void operator()(IDeserializer &deserialize, const char *name, Waypoint &value)
Definition: SerializeTemplates.h:287
entity_pos_t z
Definition: PathGoal.h:43
Definition: SerializeTemplates.h:201
virtual void NumberU16_Unbounded(const char *name, uint16_t &out)
Definition: IDeserializer.cpp:110
Deserialization interface; see serialization overview.
Definition: IDeserializer.h:34
virtual void NumberI32_Unbounded(const char *name, int32_t &out)
Definition: IDeserializer.cpp:131