libgig  4.1.0.svn8
Serialization.h
1 /***************************************************************************
2  * *
3  * Copyright (C) 2017 Christian Schoenebeck *
4  * <cuse@users.sourceforge.net> *
5  * *
6  * This library is part of libgig. *
7  * *
8  * This library is free software; you can redistribute it and/or modify *
9  * it under the terms of the GNU General Public License as published by *
10  * the Free Software Foundation; either version 2 of the License, or *
11  * (at your option) any later version. *
12  * *
13  * This library is distributed in the hope that it will be useful, *
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16  * GNU General Public License for more details. *
17  * *
18  * You should have received a copy of the GNU General Public License *
19  * along with this library; if not, write to the Free Software *
20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
21  * MA 02111-1307 USA *
22  ***************************************************************************/
23 
24 #ifndef LIBGIG_SERIALIZATION_H
25 #define LIBGIG_SERIALIZATION_H
26 
27 #ifdef HAVE_CONFIG_H
28 # include <config.h>
29 #endif
30 
31 #include <stdint.h>
32 #include <stdio.h>
33 #include <typeinfo>
34 #include <string>
35 #include <vector>
36 #include <map>
37 #include <time.h>
38 #include <stdarg.h>
39 
40 #ifndef __has_extension
41 # define __has_extension(x) 0
42 #endif
43 
44 #ifndef HAS_BUILTIN_TYPE_TRAITS
45 # if __cplusplus >= 201103L
46 # define HAS_BUILTIN_TYPE_TRAITS 1
47 # elif ( __has_extension(is_class) && __has_extension(is_enum) )
48 # define HAS_BUILTIN_TYPE_TRAITS 1
49 # elif ( __GNUC__ > 4 || ( __GNUC__ == 4 && __GNUC_MINOR__ >= 3 ) )
50 # define HAS_BUILTIN_TYPE_TRAITS 1
51 # elif _MSC_VER >= 1400 /* MS Visual C++ 8.0 (Visual Studio 2005) */
52 # define HAS_BUILTIN_TYPE_TRAITS 1
53 # elif __INTEL_COMPILER >= 1100
54 # define HAS_BUILTIN_TYPE_TRAITS 1
55 # else
56 # define HAS_BUILTIN_TYPE_TRAITS 0
57 # endif
58 #endif
59 
60 #if !HAS_BUILTIN_TYPE_TRAITS
61 # include <tr1/type_traits>
62 # define LIBGIG_IS_CLASS(type) std::tr1::__is_union_or_class<type>::value //NOTE: without compiler support we cannot distinguish union from class
63 #else
64 # define LIBGIG_IS_CLASS(type) __is_class(type)
65 #endif
66 
110 namespace Serialization {
111 
112  // just symbol prototyping
113  class DataType;
114  class Object;
115  class Member;
116  class Archive;
117  class ObjectPool;
118  class Exception;
119 
120  typedef std::string String;
121 
130  typedef std::vector<uint8_t> RawData;
131 
142  typedef void* ID;
143 
151  typedef uint32_t Version;
152 
158  enum time_base_t {
161  };
162 
170  template<typename T>
171  bool IsEnum(const T& data) {
172  #if !HAS_BUILTIN_TYPE_TRAITS
173  return std::tr1::is_enum<T>::value;
174  #else
175  return __is_enum(T);
176  #endif
177  }
178 
189  template<typename T>
190  bool IsUnion(const T& data) {
191  #if !HAS_BUILTIN_TYPE_TRAITS
192  return false; // without compiler support we cannot distinguish union from class
193  #else
194  return __is_union(T);
195  #endif
196  }
197 
207  template<typename T>
208  bool IsClass(const T& data) {
209  #if !HAS_BUILTIN_TYPE_TRAITS
210  return std::tr1::__is_union_or_class<T>::value; // without compiler support we cannot distinguish union from class
211  #else
212  return __is_class(T);
213  #endif
214  }
215 
216  /*template<typename T>
217  bool IsTrivial(T data) {
218  return __is_trivial(T);
219  }*/
220 
221  /*template<typename T>
222  bool IsPOD(T data) {
223  return __is_pod(T);
224  }*/
225 
241  class UID {
242  public:
243  ID id;
244  size_t size;
245 
246  bool isValid() const;
247  operator bool() const { return isValid(); }
248  //bool operator()() const { return isValid(); }
249  bool operator==(const UID& other) const { return id == other.id && size == other.size; }
250  bool operator!=(const UID& other) const { return id != other.id || size != other.size; }
251  bool operator<(const UID& other) const { return id < other.id || (id == other.id && size < other.size); }
252  bool operator>(const UID& other) const { return id > other.id || (id == other.id && size > other.size); }
253 
261  template<typename T>
262  static UID from(const T& obj) {
263  return Resolver<T>::resolve(obj);
264  }
265 
266  protected:
267  // UID resolver for non-pointer types
268  template<typename T>
269  struct Resolver {
270  static UID resolve(const T& obj) {
271  const UID uid = { (ID) &obj, sizeof(obj) };
272  return uid;
273  }
274  };
275 
276  // UID resolver for pointer types (of 1st degree)
277  template<typename T>
278  struct Resolver<T*> {
279  static UID resolve(const T* const & obj) {
280  const UID uid = { (ID) obj, sizeof(*obj) };
281  return uid;
282  }
283  };
284  };
285 
291  extern const UID NO_UID;
292 
324  typedef std::vector<UID> UIDChain;
325 
326 #if LIBGIG_SERIALIZATION_INTERNAL
327  // prototyping of private internal friend functions
328  static String _encodePrimitiveValue(const Object& obj);
329  static DataType _popDataTypeBlob(const char*& p, const char* end);
330  static Member _popMemberBlob(const char*& p, const char* end);
331  static Object _popObjectBlob(const char*& p, const char* end);
332  static void _popPrimitiveValue(const char*& p, const char* end, Object& obj);
333  static String _primitiveObjectValueToString(const Object& obj);
334  // |
335  template<typename T>
336  static T _primitiveObjectValueToNumber(const Object& obj);
337 #endif // LIBGIG_SERIALIZATION_INTERNAL
338 
355  class DataType {
356  public:
357  DataType();
358  size_t size() const { return m_size; }
359  bool isValid() const;
360  bool isPointer() const;
361  bool isClass() const;
362  bool isPrimitive() const;
363  bool isInteger() const;
364  bool isReal() const;
365  bool isBool() const;
366  bool isEnum() const;
367  bool isSigned() const;
368  operator bool() const { return isValid(); }
369  //bool operator()() const { return isValid(); }
370  bool operator==(const DataType& other) const;
371  bool operator!=(const DataType& other) const;
372  bool operator<(const DataType& other) const;
373  bool operator>(const DataType& other) const;
374  String asLongDescr() const;
375  String baseTypeName() const;
376  String customTypeName(bool demangle = false) const;
377 
388  template<typename T>
389  static DataType dataTypeOf(const T& data) {
390  return Resolver<T>::resolve(data);
391  }
392 
393  protected:
394  DataType(bool isPointer, int size, String baseType, String customType = "");
395 
396  template<typename T, bool T_isPointer>
397  struct ResolverBase {
398  static DataType resolve(const T& data) {
399  const std::type_info& type = typeid(data);
400  const int sz = sizeof(data);
401 
402  // for primitive types we are using our own type names instead of
403  // using std:::type_info::name(), because the precise output of the
404  // latter may vary between compilers
405  if (type == typeid(int8_t)) return DataType(T_isPointer, sz, "int8");
406  if (type == typeid(uint8_t)) return DataType(T_isPointer, sz, "uint8");
407  if (type == typeid(int16_t)) return DataType(T_isPointer, sz, "int16");
408  if (type == typeid(uint16_t)) return DataType(T_isPointer, sz, "uint16");
409  if (type == typeid(int32_t)) return DataType(T_isPointer, sz, "int32");
410  if (type == typeid(uint32_t)) return DataType(T_isPointer, sz, "uint32");
411  if (type == typeid(int64_t)) return DataType(T_isPointer, sz, "int64");
412  if (type == typeid(uint64_t)) return DataType(T_isPointer, sz, "uint64");
413  if (type == typeid(bool)) return DataType(T_isPointer, sz, "bool");
414  if (type == typeid(float)) return DataType(T_isPointer, sz, "real32");
415  if (type == typeid(double)) return DataType(T_isPointer, sz, "real64");
416 
417  if (IsEnum(data)) return DataType(T_isPointer, sz, "enum", rawCppTypeNameOf(data));
418  if (IsUnion(data)) return DataType(T_isPointer, sz, "union", rawCppTypeNameOf(data));
419  if (IsClass(data)) return DataType(T_isPointer, sz, "class", rawCppTypeNameOf(data));
420 
421  return DataType();
422  }
423  };
424 
425  // DataType resolver for non-pointer types
426  template<typename T>
427  struct Resolver : ResolverBase<T,false> {
428  static DataType resolve(const T& data) {
429  return ResolverBase<T,false>::resolve(data);
430  }
431  };
432 
433  // DataType resolver for pointer types (of 1st degree)
434  template<typename T>
435  struct Resolver<T*> : ResolverBase<T,true> {
436  static DataType resolve(const T*& data) {
437  return ResolverBase<T,true>::resolve(*data);
438  }
439  };
440 
441  template<typename T>
442  static String rawCppTypeNameOf(const T& data) {
443  #if defined _MSC_VER // Microsoft compiler ...
444  # warning type_info::raw_name() demangling has not been tested yet with Microsoft compiler! Feedback appreciated!
445  String name = typeid(data).raw_name(); //NOTE: I haven't checked yet what MSC actually outputs here exactly
446  #else // i.e. especially GCC and clang ...
447  String name = typeid(data).name();
448  #endif
449  //while (!name.empty() && name[0] >= 0 && name[0] <= 9)
450  // name = name.substr(1);
451  return name;
452  }
453 
454  private:
455  String m_baseTypeName;
456  String m_customTypeName;
457  int m_size;
458  bool m_isPointer;
459 
460 #if LIBGIG_SERIALIZATION_INTERNAL
461  friend DataType _popDataTypeBlob(const char*& p, const char* end);
462 #endif
463  friend class Archive;
464  };
465 
487  class Member {
488  public:
489  Member();
490  UID uid() const;
491  String name() const;
492  size_t offset() const;
493  const DataType& type() const;
494  bool isValid() const;
495  operator bool() const { return isValid(); }
496  //bool operator()() const { return isValid(); }
497  bool operator==(const Member& other) const;
498  bool operator!=(const Member& other) const;
499  bool operator<(const Member& other) const;
500  bool operator>(const Member& other) const;
501 
502  protected:
503  Member(String name, UID uid, size_t offset, DataType type);
504  friend class Archive;
505 
506  private:
507  UID m_uid;
508  size_t m_offset;
509  String m_name;
510  DataType m_type;
511 
512 #if LIBGIG_SERIALIZATION_INTERNAL
513  friend Member _popMemberBlob(const char*& p, const char* end);
514 #endif
515  };
516 
541  class Object {
542  public:
543  Object();
545 
546  UID uid(int index = 0) const;
547  const UIDChain& uidChain() const;
548  const DataType& type() const;
549  const RawData& rawData() const;
550  Version version() const;
551  Version minVersion() const;
552  bool isVersionCompatibleTo(const Object& other) const;
553  std::vector<Member>& members();
554  const std::vector<Member>& members() const;
555  Member memberNamed(String name) const;
556  Member memberByUID(const UID& uid) const;
557  std::vector<Member> membersOfType(const DataType& type) const;
558  int sequenceIndexOf(const Member& member) const;
559  bool isValid() const;
560  operator bool() const { return isValid(); }
561  //bool operator()() const { return isValid(); }
562  bool operator==(const Object& other) const;
563  bool operator!=(const Object& other) const;
564  bool operator<(const Object& other) const;
565  bool operator>(const Object& other) const;
566 
567  protected:
568  void remove(const Member& member);
569  void setVersion(Version v);
570  void setMinVersion(Version v);
571 
572  private:
573  DataType m_type;
574  UIDChain m_uid;
575  Version m_version;
576  Version m_minVersion;
577  RawData m_data;
578  std::vector<Member> m_members;
579 
580 #if LIBGIG_SERIALIZATION_INTERNAL
581  friend String _encodePrimitiveValue(const Object& obj);
582  friend Object _popObjectBlob(const char*& p, const char* end);
583  friend void _popPrimitiveValue(const char*& p, const char* end, Object& obj);
584  friend String _primitiveObjectValueToString(const Object& obj);
585  // |
586  template<typename T>
587  friend T _primitiveObjectValueToNumber(const Object& obj);
588 #endif // LIBGIG_SERIALIZATION_INTERNAL
589 
590  friend class Archive;
591  };
592 
710  class Archive {
711  public:
712  Archive();
713  Archive(const RawData& data);
714  Archive(const uint8_t* data, size_t size);
715  virtual ~Archive();
716 
742  template<typename T>
743  void serialize(const T* obj) {
744  m_operation = OPERATION_SERIALIZE;
745  m_allObjects.clear();
746  m_rawData.clear();
747  m_root = UID::from(obj);
748  const_cast<T*>(obj)->serialize(this);
749  encode();
750  m_operation = OPERATION_NONE;
751  }
752 
777  template<typename T>
778  void deserialize(T* obj) {
779  Archive a;
780  m_operation = OPERATION_DESERIALIZE;
781  obj->serialize(&a);
782  a.m_root = UID::from(obj);
783  Syncer s(a, *this);
784  m_operation = OPERATION_NONE;
785  }
786 
801  template<typename T>
802  void operator<<(const T& obj) {
803  serialize(&obj);
804  }
805 
824  template<typename T>
825  void operator>>(T& obj) {
826  deserialize(&obj);
827  }
828 
829  const RawData& rawData();
830  virtual String rawDataFormat() const;
831 
877  template<typename T_classType, typename T_memberType>
878  void serializeMember(const T_classType& nativeObject, const T_memberType& nativeMember, const char* memberName) {
879  const size_t offset =
880  ((const uint8_t*)(const void*)&nativeMember) -
881  ((const uint8_t*)(const void*)&nativeObject);
882  const UIDChain uids = UIDChainResolver<T_memberType>(nativeMember);
883  const DataType type = DataType::dataTypeOf(nativeMember);
884  const Member member(memberName, uids[0], offset, type);
885  const UID parentUID = UID::from(nativeObject);
886  Object& parent = m_allObjects[parentUID];
887  if (!parent) {
888  const UIDChain uids = UIDChainResolver<T_classType>(nativeObject);
889  const DataType type = DataType::dataTypeOf(nativeObject);
890  parent = Object(uids, type);
891  }
892  parent.members().push_back(member);
893  const Object obj(uids, type);
894  const bool bExistsAlready = m_allObjects.count(uids[0]);
895  const bool isValidObject = obj;
896  const bool bExistingObjectIsInvalid = !m_allObjects[uids[0]];
897  if (!bExistsAlready || (bExistingObjectIsInvalid && isValidObject)) {
898  m_allObjects[uids[0]] = obj;
899  // recurse serialization for all members of this member
900  // (only for struct/class types, noop for primitive types)
901  SerializationRecursion<T_memberType>::serializeObject(this, nativeMember);
902  }
903  }
904 
974  template<typename T_classType>
975  void setVersion(const T_classType& nativeObject, Version v) {
976  const UID uid = UID::from(nativeObject);
977  Object& obj = m_allObjects[uid];
978  if (!obj) {
979  const UIDChain uids = UIDChainResolver<T_classType>(nativeObject);
980  const DataType type = DataType::dataTypeOf(nativeObject);
981  obj = Object(uids, type);
982  }
983  setVersion(obj, v);
984  }
985 
1015  template<typename T_classType>
1016  void setMinVersion(const T_classType& nativeObject, Version v) {
1017  const UID uid = UID::from(nativeObject);
1018  Object& obj = m_allObjects[uid];
1019  if (!obj) {
1020  const UIDChain uids = UIDChainResolver<T_classType>(nativeObject);
1021  const DataType type = DataType::dataTypeOf(nativeObject);
1022  obj = Object(uids, type);
1023  }
1024  setMinVersion(obj, v);
1025  }
1026 
1027  virtual void decode(const RawData& data);
1028  virtual void decode(const uint8_t* data, size_t size);
1029  void clear();
1030  bool isModified() const;
1031  void removeMember(Object& parent, const Member& member);
1032  void remove(const Object& obj);
1033  Object& rootObject();
1034  Object& objectByUID(const UID& uid);
1035  void setAutoValue(Object& object, String value);
1036  void setIntValue(Object& object, int64_t value);
1037  void setRealValue(Object& object, double value);
1038  void setBoolValue(Object& object, bool value);
1039  void setEnumValue(Object& object, uint64_t value);
1040  String valueAsString(const Object& object);
1041  int64_t valueAsInt(const Object& object);
1042  double valueAsReal(const Object& object);
1043  bool valueAsBool(const Object& object);
1044  void setVersion(Object& object, Version v);
1045  void setMinVersion(Object& object, Version v);
1046  String name() const;
1047  void setName(String name);
1048  String comment() const;
1049  void setComment(String comment);
1050  time_t timeStampCreated() const;
1051  time_t timeStampModified() const;
1052  tm dateTimeCreated(time_base_t base = LOCAL_TIME) const;
1053  tm dateTimeModified(time_base_t base = LOCAL_TIME) const;
1054 
1055  protected:
1056  // UID resolver for non-pointer types
1057  template<typename T>
1058  class UIDChainResolver {
1059  public:
1060  UIDChainResolver(const T& data) {
1061  m_uid.push_back(UID::from(data));
1062  }
1063 
1064  operator UIDChain() const { return m_uid; }
1065  UIDChain operator()() const { return m_uid; }
1066  private:
1067  UIDChain m_uid;
1068  };
1069 
1070  // UID resolver for pointer types (of 1st degree)
1071  template<typename T>
1072  class UIDChainResolver<T*> {
1073  public:
1074  UIDChainResolver(const T*& data) {
1075  const UID uids[2] = {
1076  { &data, sizeof(data) },
1077  { data, sizeof(*data) }
1078  };
1079  m_uid.push_back(uids[0]);
1080  m_uid.push_back(uids[1]);
1081  }
1082 
1083  operator UIDChain() const { return m_uid; }
1084  UIDChain operator()() const { return m_uid; }
1085  private:
1086  UIDChain m_uid;
1087  };
1088 
1089  // SerializationRecursion for non-pointer class/struct types.
1090  template<typename T, bool T_isRecursive>
1091  struct SerializationRecursionImpl {
1092  static void serializeObject(Archive* archive, const T& obj) {
1093  const_cast<T&>(obj).serialize(archive);
1094  }
1095  };
1096 
1097  // SerializationRecursion for pointers (of 1st degree) to class/structs.
1098  template<typename T, bool T_isRecursive>
1099  struct SerializationRecursionImpl<T*,T_isRecursive> {
1100  static void serializeObject(Archive* archive, const T*& obj) {
1101  if (!obj) return;
1102  const_cast<T*&>(obj)->serialize(archive);
1103  }
1104  };
1105 
1106  // NOOP SerializationRecursion for primitive types.
1107  template<typename T>
1108  struct SerializationRecursionImpl<T,false> {
1109  static void serializeObject(Archive* archive, const T& obj) {}
1110  };
1111 
1112  // NOOP SerializationRecursion for pointers (of 1st degree) to primitive types.
1113  template<typename T>
1114  struct SerializationRecursionImpl<T*,false> {
1115  static void serializeObject(Archive* archive, const T*& obj) {}
1116  };
1117 
1118  // Automatically handles recursion for class/struct types, while ignoring all primitive types.
1119  template<typename T>
1120  struct SerializationRecursion : SerializationRecursionImpl<T, LIBGIG_IS_CLASS(T)> {
1121  };
1122 
1123  class ObjectPool : public std::map<UID,Object> {
1124  public:
1125  // prevent passing obvious invalid UID values from creating a new pair entry
1126  Object& operator[](const UID& k) {
1127  static Object invalid;
1128  if (!k.isValid()) {
1129  invalid = Object();
1130  return invalid;
1131  }
1132  return std::map<UID,Object>::operator[](k);
1133  }
1134  };
1135 
1136  friend String _encode(const ObjectPool& objects);
1137 
1138  private:
1139  String _encodeRootBlob();
1140  void _popRootBlob(const char*& p, const char* end);
1141  void _popObjectsBlob(const char*& p, const char* end);
1142 
1143  protected:
1144  class Syncer {
1145  public:
1146  Syncer(Archive& dst, Archive& src);
1147  protected:
1148  void syncObject(const Object& dst, const Object& src);
1149  void syncPrimitive(const Object& dst, const Object& src);
1150  void syncPointer(const Object& dst, const Object& src);
1151  void syncMember(const Member& dstMember, const Member& srcMember);
1152  static Member dstMemberMatching(const Object& dstObj, const Object& srcObj, const Member& srcMember);
1153  private:
1154  Archive& m_dst;
1155  Archive& m_src;
1156  };
1157 
1158  enum operation_t {
1159  OPERATION_NONE,
1160  OPERATION_SERIALIZE,
1161  OPERATION_DESERIALIZE
1162  };
1163 
1164  virtual void encode();
1165 
1166  ObjectPool m_allObjects;
1167  operation_t m_operation;
1168  UID m_root;
1169  RawData m_rawData;
1170  bool m_isModified;
1171  String m_name;
1172  String m_comment;
1173  time_t m_timeCreated;
1174  time_t m_timeModified;
1175  };
1176 
1181  class Exception {
1182  public:
1183  String Message;
1184 
1185  Exception(String format, ...);
1186  Exception(String format, va_list arg);
1187  void PrintMessage();
1188  virtual ~Exception() {}
1189 
1190  protected:
1191  Exception();
1192  static String assemble(String format, va_list arg);
1193  };
1194 
1195 } // namespace Serialization
1196 
1197 #endif // LIBGIG_SERIALIZATION_H
String customTypeName(bool demangle=false) const
The user defined C/C++ data type name of this data type.
bool isClass() const
Whether this is reflecting a C/C++ struct or class type.
String baseTypeName() const
The base type name of this data type.
Abstract reflection of some native serialized C/C++ data.
std::vector< Member > membersOfType(const DataType &type) const
Get all members of this Object with given data type.
static UID from(const T &obj)
Create an unique indentifier for a native C++ object/member/variable.
bool isPointer() const
Whether this is reflecting a C/C++ pointer type.
void setName(String name)
Assign a name to this archive.
Destination container for serialization, and source container for deserialization.
std::vector< UID > UIDChain
Chain of UIDs.
bool operator==(const Member &other) const
Comparison for equalness.
void clear()
Clear content of this archive.
static DataType dataTypeOf(const T &data)
Construct a DataType object for the given native C++ data.
Object & objectByUID(const UID &uid)
Access object by its unique identifier.
bool IsUnion(const T &data)
Check whether data is a C++ union type.
bool isVersionCompatibleTo(const Object &other) const
Check version compatibility between Object instances.
void * ID
Abstract identifier for serialized C++ objects.
String name() const
Optional name of this archive.
void serialize(const T *obj)
Initiate serialization.
virtual String rawDataFormat() const
Name of the encoding format used by this Archive class.
int64_t valueAsInt(const Object &object)
Get integer value of object.
bool valueAsBool(const Object &object)
Get boolean value of object.
void setAutoValue(Object &object, String value)
Automatically cast and assign appropriate value to object.
Abstract reflection of a native C++ data type.
const UIDChain & uidChain() const
Unique identifier chain of this Object.
void setMinVersion(const T_classType &nativeObject, Version v)
Set a minimum version number for your C++ class.
const RawData & rawData()
Raw data stream of this archive content.
time_t timeStampCreated() const
Date and time when this archive was initially created.
void deserialize(T *obj)
Initiate deserialization.
bool isSigned() const
Whether this is a signed integer C/C++ data type.
void setIntValue(Object &object, int64_t value)
Set new integer value for given integer object.
uint32_t Version
Version number data type.
bool operator<(const DataType &other) const
Smaller than comparison.
bool isValid() const
Check if this is a valid DataType object.
void setRealValue(Object &object, double value)
Set new floating point value for given floating point object.
void serializeMember(const T_classType &nativeObject, const T_memberType &nativeMember, const char *memberName)
Serialize a native C/C++ member variable.
time_base_t
To which time zone a certain timing information relates to.
bool operator==(const Object &other) const
Comparison for equalness.
bool isValid() const
Check whether this is a valid unique identifier.
void setVersion(const T_classType &nativeObject, Version v)
Set current version number for your C++ class.
Unique identifier referring to one specific native C++ object, member, fundamental variable,...
bool isValid() const
Check if this is a valid Object instance.
std::vector< Member > & members()
All members of the original native C/C++ struct or class instance.
void operator<<(const T &obj)
Initiate serialization of your C++ objects.
const DataType & type() const
C/C++ data type this Object is reflecting.
bool isBool() const
Whether this is a boolean C/C++ data type.
virtual void decode(const RawData &data)
Fill this archive with the given serialized raw data.
Object & rootObject()
Root C++ object of this archive.
ID id
Abstract non-unique ID of the object or member in question.
String comment() const
Optional comments for this archive.
bool operator<(const Object &other) const
Smaller than comparison.
std::vector< uint8_t > RawData
Raw data stream of serialized C++ objects.
The time stamp relates to the machine's local time zone. Request a time stamp in local time if you wa...
The time stamp relates to "Greenwhich Mean Time" zone, also known as "Coordinated Universal Time"....
Will be thrown whenever an error occurs during an serialization or deserialization process.
void operator>>(T &obj)
Initiate deserialization of your C++ objects.
Version minVersion() const
Minimum version of original user defined C/C++ struct or class.
String valueAsString(const Object &object)
Get value of object as string.
Version version() const
Version of original user defined C/C++ struct or class.
int sequenceIndexOf(const Member &member) const
Serialization/deserialization sequence number of the requested member.
tm dateTimeCreated(time_base_t base=LOCAL_TIME) const
Date and time when this archive was initially created.
const DataType & type() const
C/C++ Data type of this member.
bool operator>(const DataType &other) const
Greater than comparison.
bool operator!=(const Object &other) const
Comparison for inequalness.
bool isEnum() const
Whether this is a C/C++ enum data type.
Archive()
Create an "empty" archive.
bool isInteger() const
Whether this is an integer C/C++ data type.
bool operator==(const DataType &other) const
Comparison for equalness.
bool IsEnum(const T &data)
Check whether data is a C/C++ enum type.
bool isPrimitive() const
Whether this is reflecting a fundamental C/C++ data type.
Object()
Default constructor (for an "invalid" Object).
bool isReal() const
Whether this is a floating point based C/C++ data type.
UID uid() const
Unique identifier of this member instance.
void setBoolValue(Object &object, bool value)
Set new boolean value for given boolean object.
Member memberNamed(String name) const
Get the member of this Object with given name.
void PrintMessage()
Print exception message to stdout.
String asLongDescr() const
Human readable long description for this data type.
void setEnumValue(Object &object, uint64_t value)
Set new value for given enum object.
UID uid(int index=0) const
Unique identifier of this Object.
double valueAsReal(const Object &object)
Get floating point value of object.
bool IsClass(const T &data)
Check whether data is a C/C++ struct or C++ class type.
size_t size() const
Returns native memory size of the respective C++ object or variable.
tm dateTimeModified(time_base_t base=LOCAL_TIME) const
Date and time when this archive was modified for the last time.
bool isModified() const
Whether this archive was modified.
bool operator!=(const DataType &other) const
Comparison for inequalness.
bool isValid() const
Check if this is a valid Member object.
bool operator>(const Object &other) const
Greater than comparison.
void removeMember(Object &parent, const Member &member)
Remove a member variable from the given object.
const UID NO_UID
Reflects an invalid UID and behaves similar to NULL as invalid value for pointer types.
void setComment(String comment)
Assign a comment to this archive.
Serialization / deserialization framework.
Definition: gig.h:91
bool operator<(const Member &other) const
Smaller than comparison.
DataType()
Default constructor.
bool operator!=(const Member &other) const
Comparison for inequalness.
Member memberByUID(const UID &uid) const
Get the member of this Object with given unique identifier.
size_t size
Memory size of the object or member in question.
Abstract reflection of a native C++ class/struct's member variable.
time_t timeStampModified() const
Date and time when this archive was modified for the last time.
void remove(const Object &obj)
Remove an object from this archive.
const RawData & rawData() const
Raw data of the original native C/C++ data.
bool operator>(const Member &other) const
Greater than comparison.
Member()
Default constructor.
size_t offset() const
Offset of member in its containing parent data structure.
String name() const
Name of the member.