ESA JPIP server  0.1
serialize.h
Go to the documentation of this file.
1 #ifndef _DATA_SERIALIZE_H_
2 #define _DATA_SERIALIZE_H_
3 
4 
5 #include <stdint.h>
6 #include <string>
7 #include <vector>
8 #include <map>
9 #include "file.h"
10 
11 
12 namespace data
13 {
14  using namespace std;
15 
24  {
28  inline static const char *FileAccess()
29  {
30  return "rb";
31  }
32 
40  inline static bool SerializeBytes(File& file, void *ptr, int num_bytes)
41  {
42  return file.Read(ptr, num_bytes);
43  }
44  };
45 
54  {
58  inline static const char *FileAccess()
59  {
60  return "wb";
61  }
62 
70  inline static bool SerializeBytes(File& file, void *ptr, int num_bytes)
71  {
72  return file.Write(ptr, num_bytes);
73  }
74  };
75 
106  template<typename StreamClass, typename StreamOperator> class BaseStream
107  {
108  protected:
110  bool result_;
111 
112  public:
117  {
118  result_ = false;
119  }
120 
126  StreamClass& Open(const char *file_name)
127  {
128  result_ = file_.Open(file_name, StreamOperator::FileAccess());
129  return (StreamClass&) (*this);
130  }
131 
138  StreamClass& Open(const char *file_name, const char *access)
139  {
140  result_ = file_.Open(file_name, access);
141  return (StreamClass&) (*this);
142  }
143 
148  StreamClass& Close()
149  {
150  file_.Close();
151  result_ = false;
152  return (StreamClass&) (*this);
153  }
154 
163  StreamClass& SerializeBytes(void *ptr, int num_bytes)
164  {
165  result_ = (result_ && StreamOperator::SerializeBytes(file_, ptr, num_bytes));
166  return (StreamClass&) (*this);
167  }
168 
173  template<typename T> StreamClass& operator&(T& var)
174  {
175  return ((StreamClass&) (*this)).Serialize(var);
176  }
177 
181  bool result() const
182  {
183  return result_;
184  }
185 
189  operator bool() const
190  {
191  return result_;
192  }
193 
197  virtual ~BaseStream()
198  {
199  file_.Close();
200  }
201  };
202 
203  class InputStream;
204  class OutputStream;
205 
217  template<typename T> struct Serializer
218  {
219  static InputStream& Load(InputStream& stream, T& var)
220  {
221  return var.SerializeWith(stream);
222  }
223 
224  static OutputStream& Save(OutputStream& stream, T& var)
225  {
226  return var.SerializeWith(stream);
227  }
228  };
229 
236  class InputStream: public BaseStream<InputStream, InputOperator>
237  {
238  public:
239  template<typename T> InputStream& Serialize(T& var)
240  {
241  return Serializer<T>::Load(*this, var);
242  }
243  };
244 
251  class OutputStream: public BaseStream<OutputStream, OutputOperator>
252  {
253  public:
254  template<typename T> OutputStream& Serialize(T& var)
255  {
256  return Serializer<T>::Save(*this, var);
257  }
258  };
259 
265  template<> struct Serializer<bool>
266  {
267  static InputStream& Load(InputStream& stream, bool& var)
268  {
269  return stream.SerializeBytes(&var, sizeof(var));
270  }
271 
272  static OutputStream& Save(OutputStream& stream, bool& var)
273  {
274  return stream.SerializeBytes(&var, sizeof(var));
275  }
276  };
277 
283  template<> struct Serializer<int>
284  {
285  static InputStream& Load(InputStream& stream, int& var)
286  {
287  return stream.SerializeBytes(&var, sizeof(var));
288  }
289 
290  static OutputStream& Save(OutputStream& stream, int& var)
291  {
292  return stream.SerializeBytes(&var, sizeof(var));
293  }
294  };
295 
301  template<> struct Serializer<uint64_t>
302  {
303  static InputStream& Load(InputStream& stream, uint64_t& var)
304  {
305  return stream.SerializeBytes(&var, sizeof(var));
306  }
307 
308  static OutputStream& Save(OutputStream& stream, uint64_t& var)
309  {
310  return stream.SerializeBytes(&var, sizeof(var));
311  }
312  };
313 
319  template<> struct Serializer<string>
320  {
321  static InputStream& Load(InputStream& stream, string& var)
322  {
323  int num = 0;
324 
325  if (stream.Serialize(num))
326  {
327  var.clear();
328 
329  if (num > 0)
330  {
331  var.reserve(num);
332  char *buf = new char[num];
333 
334  if (stream.SerializeBytes(buf, num)) var.append(buf, num);
335 
336  delete[] buf;
337  }
338  }
339 
340  return stream;
341  }
342 
343  static OutputStream& Save(OutputStream& stream, string& var)
344  {
345  int num = var.size();
346 
347  if (stream.Serialize(num)) stream.SerializeBytes((void *) var.c_str(), num);
348 
349  return stream;
350  }
351  };
352 
358  template<typename T> struct Serializer< vector<T> >
359  {
360  static InputStream& Load(InputStream& stream, vector<T>& var)
361  {
362  T item;
363  int num = 0;
364 
365  var.clear();
366 
367  if (stream.Serialize(num))
368  {
369  for (int i = 0; i < num; i++)
370  {
371  if (!stream.Serialize(item)) break;
372  var.push_back(item);
373  }
374  }
375 
376  return stream;
377  }
378 
379  static OutputStream& Save(OutputStream& stream, vector<T>& var)
380  {
381  T item;
382  int num = 0;
383 
384  num = var.size();
385 
386  if (stream.Serialize(num))
387  {
388  for (int i = 0; i < num; i++)
389  {
390  item = var[i];
391  if (!stream.Serialize(item)) break;
392  }
393  }
394 
395  return stream;
396  }
397  };
398 
404  template<> struct Serializer< multimap<string, int> >
405  {
406  static InputStream& Load(InputStream& stream, multimap<string, int>& var)
407  {
408  string key;
409  int value, num = 0;
410 
411  var.clear();
412 
413  if (stream.Serialize(num))
414  {
415  for (int i = 0; i < num; i++)
416  {
417  if ((!stream.Serialize(key)) || (!stream.Serialize(value))) break;
418  var.insert(pair<string, int> (key, value));
419  }
420  }
421 
422  return stream;
423  }
424 
425  static OutputStream& Save(OutputStream& stream, multimap<string, int>& var)
426  {
427  string key;
428  int value, num = 0;
429 
430  num = var.size();
431 
432  if (stream.Serialize(num))
433  {
434  for (multimap<string, int>::const_iterator i = var.begin(); i != var.end(); i++)
435  {
436  key = (*i).first;
437  value = (*i).second;
438  if ((!stream.Serialize(key)) || (!stream.Serialize(value))) break;
439  }
440  }
441 
442  return stream;
443  }
444  };
445 }
446 
447 #endif /* _DATA_SERIALIZE_H_ */
bool Write(T *value, int num_bytes=sizeof(T)) const
Writes a value to the file.
Definition: file.h:376
BaseStream()
Initializes the status to false.
Definition: serialize.h:116
This template class allows to define a "serializer".
Definition: serialize.h:217
File file_
File used for the serialization.
Definition: serialize.h:109
static bool SerializeBytes(File &file, void *ptr, int num_bytes)
Performs an output (write) serialization of bytes for a file.
Definition: serialize.h:70
Contains a set of classes to easy the handling of data and files, as well as the serialization.
Definition: data.h:9
static OutputStream & Save(OutputStream &stream, T &var)
Definition: serialize.h:224
static OutputStream & Save(OutputStream &stream, int &var)
Definition: serialize.h:290
StreamClass & Open(const char *file_name, const char *access)
Opens a file for serialization.
Definition: serialize.h:138
static InputStream & Load(InputStream &stream, multimap< string, int > &var)
Definition: serialize.h:406
static InputStream & Load(InputStream &stream, string &var)
Definition: serialize.h:321
STL namespace.
static const char * FileAccess()
Returns the required file access for this operator.
Definition: serialize.h:58
StreamClass & Close()
Closes the file of the serialization and finish the serialization.
Definition: serialize.h:148
static OutputStream & Save(OutputStream &stream, uint64_t &var)
Definition: serialize.h:308
static InputStream & Load(InputStream &stream, int &var)
Definition: serialize.h:285
OutputStream & Serialize(T &var)
Definition: serialize.h:254
This template is used as the base for the input/output stream classes.
Definition: serialize.h:106
static InputStream & Load(InputStream &stream, vector< T > &var)
Definition: serialize.h:360
static OutputStream & Save(OutputStream &stream, string &var)
Definition: serialize.h:343
bool result_
Internal current status of the serialization.
Definition: serialize.h:110
static OutputStream & Save(OutputStream &stream, multimap< string, int > &var)
Definition: serialize.h:425
bool Read(T *value, int num_bytes=sizeof(T)) const
Reads a value from the file.
Definition: file.h:335
void Close()
Closes the file.
Definition: file.h:264
StreamClass & operator&(T &var)
This operator overloading is the key of the serialization mechanism.
Definition: serialize.h:173
InputStream & Serialize(T &var)
Definition: serialize.h:239
static InputStream & Load(InputStream &stream, uint64_t &var)
Definition: serialize.h:303
bool Open(const char *file_name, const char *access)
Opens a file with a specific access mode.
Definition: file.h:142
static const char * FileAccess()
Returns the required file access for this operator.
Definition: serialize.h:28
StreamClass & SerializeBytes(void *ptr, int num_bytes)
Serializes a number of bytes.
Definition: serialize.h:163
This struct identifies a basic output operator to be applied to a File object.
Definition: serialize.h:53
bool result() const
Returns the internal serialization status.
Definition: serialize.h:181
static OutputStream & Save(OutputStream &stream, vector< T > &var)
Definition: serialize.h:379
static OutputStream & Save(OutputStream &stream, bool &var)
Definition: serialize.h:272
Specialization of the BaseStream for input serializations.
Definition: serialize.h:236
static bool SerializeBytes(File &file, void *ptr, int num_bytes)
Performs an input (read) serialization of bytes for a file.
Definition: serialize.h:40
static InputStream & Load(InputStream &stream, T &var)
Definition: serialize.h:219
Specialization of the BaseStream for output serializations.
Definition: serialize.h:251
static InputStream & Load(InputStream &stream, bool &var)
Definition: serialize.h:267
StreamClass & Open(const char *file_name)
Opens a file for serialization.
Definition: serialize.h:126
This struct identifies a basic input operator to be applied to a File object.
Definition: serialize.h:23
virtual ~BaseStream()
The destructor automatically closes the file-.
Definition: serialize.h:197