/[svn]/libgig/trunk/src/Serialization.h
ViewVC logotype

Diff of /libgig/trunk/src/Serialization.h

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 3156 by schoenebeck, Mon May 8 17:18:07 2017 UTC revision 3168 by schoenebeck, Tue May 9 19:12:32 2017 UTC
# Line 35  Line 35 
35  #include <vector>  #include <vector>
36  #include <map>  #include <map>
37  #include <time.h>  #include <time.h>
38    #if __cplusplus < 201103L
39    # include <tr1/type_traits>
40    # define LIBGIG_IS_CLASS(type) std::tr1::__is_union_or_class<type>::value //NOTE: without compiler support we cannot distinguish union from class
41    #else
42    # define LIBGIG_IS_CLASS(type) __is_class(type)
43    #endif
44    
45  /** @brief Serialization / deserialization framework.  /** @brief Serialization / deserialization framework.
46   *   *
# Line 110  namespace Serialization { Line 116  namespace Serialization {
116    
117      template<typename T>      template<typename T>
118      bool IsEnum(const T& data) {      bool IsEnum(const T& data) {
119            #if __cplusplus < 201103L
120            return std::tr1::is_enum<T>::value;
121            #else
122          return __is_enum(T);          return __is_enum(T);
123            #endif
124      }      }
125    
126      template<typename T>      template<typename T>
127      bool IsUnion(const T& data) {      bool IsUnion(const T& data) {
128            #if __cplusplus < 201103L
129            return false; // without compiler support we cannot distinguish union from class
130            #else
131          return __is_union(T);          return __is_union(T);
132            #endif
133      }      }
134    
135      template<typename T>      template<typename T>
136      bool IsClass(const T& data) {      bool IsClass(const T& data) {
137            #if __cplusplus < 201103L
138            return std::tr1::__is_union_or_class<T>::value; // without compiler support we cannot distinguish union from class
139            #else
140          return __is_class(T);          return __is_class(T);
141            #endif
142      }      }
143    
144      /*template<typename T>      /*template<typename T>
# Line 162  namespace Serialization { Line 180  namespace Serialization {
180          template<typename T>          template<typename T>
181          struct Resolver {          struct Resolver {
182              static UID resolve(const T& obj) {              static UID resolve(const T& obj) {
183                  return (UID) { (ID) &obj, sizeof(obj) };                  const UID uid = { (ID) &obj, sizeof(obj) };
184                    return uid;
185              }              }
186          };          };
187    
# Line 170  namespace Serialization { Line 189  namespace Serialization {
189          template<typename T>          template<typename T>
190          struct Resolver<T*> {          struct Resolver<T*> {
191              static UID resolve(const T* const & obj) {              static UID resolve(const T* const & obj) {
192                  return (UID) { (ID) obj, sizeof(*obj) };                  const UID uid = { (ID) obj, sizeof(*obj) };
193                    return uid;
194              }              }
195          };          };
196      };      };
# Line 622  namespace Serialization { Line 642  namespace Serialization {
642          class UIDChainResolver<T*> {          class UIDChainResolver<T*> {
643          public:          public:
644              UIDChainResolver(const T*& data) {              UIDChainResolver(const T*& data) {
645                  m_uid.push_back((UID) { &data, sizeof(data) });                  const UID uids[2] = {
646                  m_uid.push_back((UID) { data, sizeof(*data) });                      { &data, sizeof(data) },
647                        { data, sizeof(*data) }
648                    };
649                    m_uid.push_back(uids[0]);
650                    m_uid.push_back(uids[1]);
651              }              }
652    
653              operator UIDChain() const { return m_uid; }              operator UIDChain() const { return m_uid; }
# Line 663  namespace Serialization { Line 687  namespace Serialization {
687    
688          // Automatically handles recursion for class/struct types, while ignoring all primitive types.          // Automatically handles recursion for class/struct types, while ignoring all primitive types.
689          template<typename T>          template<typename T>
690          struct SerializationRecursion : SerializationRecursionImpl<T, __is_class(T)> {          struct SerializationRecursion : SerializationRecursionImpl<T, LIBGIG_IS_CLASS(T)> {
691          };          };
692    
693          class ObjectPool : public std::map<UID,Object> {          class ObjectPool : public std::map<UID,Object> {
Legend:
Removed from v.3156  
changed lines
  Added in v.3168
  ViewVC Help
Powered by ViewVC