/[svn]/libgig/trunk/src/Serialization.cpp

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

Parent Directory | Revision Log | View Patch Patch

-revision 3774 by schoenebeck,
Tue May 19 14:55:48 2020 UTC
+revision 3777 by schoenebeck,
Sat May 23 19:55:32 2020 UTC
 Line 101 
 namespace Serialization {
       *                   type in a coarse way, which must be either one of:
       *                   "int8", "uint8", "int16", "uint16", "int32", "uint32",
       *                   "int64", "uint64", "bool", "real32", "real64",
-      *                   "String", "enum", "union" or "class"
+      *                   "String", "Array", "Set", "enum", "union" or "class"
-      * @param customType - this is only used for base types "enum", "union" or
+      * @param customType1 - this is only used for base types "enum", "union",
-      *                     "class", in which case this identifies the user
+      *                     "class", "Array", "Set" or "Map", in which case this
-      *                     defined type name (e.g. "Foo" for @c class @c Foo ),
+      *                      identifies the user defined type name (e.g. "Foo" for
-      *                     for all other types this is empty
+      *                      @c class @c Foo or e.g. "Bar" for @c Array<Bar>
+      *                      respectively), for all other types this is empty
+      * @param customType2 - this is only used for @c Map<> objects in which case
+      *                      it identifies the map's value type (i.e. 2nd
+      *                      template parameter of map)
       */
-     DataType::DataType(bool isPointer, int size, String baseType, String customType) {
+     DataType::DataType(bool isPointer, int size, String baseType,
+                        String customType1, String customType2)
+     {
          m_size = size;
          m_isPointer = isPointer;
          m_baseTypeName = baseType;
-         m_customTypeName = customType;
+         m_customTypeName = customType1;
+         m_customTypeName2 = customType2;
      }
      /** @brief Check if this is a valid DataType object.
-Line 141 
 namespace Serialization {
+Line 148 
 namespace Serialization {
       *
       * Returns @c true if the respective native C/C++ object, member or variable
       * (this DataType instance is reflecting) is a C/C++ @c struct or @c class
-      * type, with one exception: @c String objects are handled by this framework
+      * type.
-      * as if they were a primitive type.
+      *
+      * @note: Data types which enjoy out of the box serialization support by
+      * this framework, like @c String and @c Array<> are @b NOT handled as class
+      * data types by this framwork. So @c isClass() returns @c false for e.g.
+      * @c String and any @c Array<> based data type.
       *
       * Note that in the following example:
       * @code
-Line 183 
 namespace Serialization {
+Line 194 
 namespace Serialization {
       * @see isPointer()
       */
      bool DataType::isPrimitive() const {
-         return !isClass();
+         return !isClass() && !isArray() && !isSet() && !isMap();
      }
      /** @brief Whether this is a C++ @c String data type.
-Line 265 
 namespace Serialization {
+Line 276 
 namespace Serialization {
          return m_baseTypeName == "enum";
      }
+     /** @brief Whether this is a C++ @c Array<> object type.
+      *
+      * Returns @c true if the respective native C/C++ object, member or variable
+      * (this DataType instance is reflecting) is a C++ @c Array<> container
+      * object type.
+      *
+      * @note: This framework handles @c Array<> types neither as primitive
+      * types, nor as class types. So @c isPrimitive() and @c isClass() both
+      * return @c false for arrays.
+      *
+      * @see isPointer()
+      */
+     bool DataType::isArray() const {
+         return m_baseTypeName == "Array";
+     }
+     /** @brief Whether this is a C++ @c Set<> object type.
+      *
+      * Returns @c true if the respective native C/C++ object, member or variable
+      * (this DataType instance is reflecting) is a C++ @c Set<> unique container
+      * object type.
+      *
+      * @note: This framework handles @c Set<> types neither as primitive
+      * types, nor as class types. So @c isPrimitive() and @c isClass() both
+      * return @c false for sets.
+      *
+      * @see isPointer()
+      */
+     bool DataType::isSet() const {
+         return m_baseTypeName == "Set";
+     }
+     /** @brief Whether this is a C++ @c Map<> object type.
+      *
+      * Returns @c true if the respective native C/C++ object, member or variable
+      * (this DataType instance is reflecting) is an associative sorted C++
+      * @c Map<> container object type.
+      *
+      * @note: This framework handles @c Map<> types neither as primitive
+      * types, nor as class types. So @c isPrimitive() and @c isClass() both
+      * return @c false for maps.
+      *
+      * @see isPointer()
+      */
+     bool DataType::isMap() const {
+         return m_baseTypeName == "Map";
+     }
      /** @brief Whether this is a signed integer C/C++ data type.
       *
       * Returns @c true if the respective native C/C++ object, member or variable
-Line 304 
 namespace Serialization {
+Line 363 
 namespace Serialization {
      bool DataType::operator==(const DataType& other) const {
          return m_baseTypeName   == other.m_baseTypeName &&
                 m_customTypeName == other.m_customTypeName &&
+                m_customTypeName2 == other.m_customTypeName2 &&
                 (m_size == other.m_size || (isClass() && other.isClass())) &&
                 m_isPointer      == other.m_isPointer;
      }
-Line 333 
 namespace Serialization {
+Line 393 
 namespace Serialization {
                (m_baseTypeName == other.m_baseTypeName &&
                (m_customTypeName  < other.m_customTypeName ||
                (m_customTypeName == other.m_customTypeName &&
+               (m_customTypeName2  < other.m_customTypeName2 ||
+               (m_customTypeName2 == other.m_customTypeName2 &&
                (m_size  < other.m_size ||
                (m_size == other.m_size &&
-                m_isPointer < other.m_isPointer)))));
+                m_isPointer < other.m_isPointer)))))));
      }
      /** @brief Greater than comparison.
-Line 371 
 namespace Serialization {
+Line 433 
 namespace Serialization {
          String s = m_baseTypeName;
          if (!m_customTypeName.empty())
              s += " " + customTypeName(true);
+         if (!m_customTypeName2.empty())
+             s += " " + customTypeName2(true);
          if (isPointer())
              s += " pointer";
          return s;
-Line 403 
 namespace Serialization {
+Line 467 
 namespace Serialization {
       * @endcode
       * this method would return for both @c i and @c pi the string @c "uint64" !
       *
-      * @see isPointer(), customTypeName()
+      * @see isPointer(), customTypeName(), customTypeName2()
       */
      String DataType::baseTypeName() const {
          return m_baseTypeName;
      }
-     /** @brief The user defined C/C++ data type name of this data type.
+     static String _demangleTypeName(const char* name) {
+ #ifdef _MSC_VER
+         const size_t MAXLENGTH = 1024;
+         char result[MAXLENGTH];
+         //FIXME: calling UnDecorateSymbolName() is not thread safe!
+         //Skip the first char
+         size_t size = UnDecorateSymbolName(name + 1, result, MAXLENGTH, UNDNAME_32_BIT_DECODE | UNDNAME_NO_ARGUMENTS);
+         if (size)
+         {
+             return result;
+         }
+         return name;
+ #else
+         int status;
+         char* result =
+             abi::__cxa_demangle(name, 0, 0, &status);
+         String sResult = result;
+         free(result);
+         return (status == 0) ? sResult : name;
+ #endif
+     }
+     /** @brief The 1st user defined C/C++ data type name of this data type.
       *
-      * Call this method on user defined C/C++ data types like @c enum, @c struct
+      * Call this method on user defined C/C++ data types like @c enum,
-      * and @c class types to retrieve the user defined type name portion of
+      * @c struct, @c class or @c Array<> types to retrieve the user defined type
-      * those data types. Note that this method is only intended for such user
+      * name portion of those data types. Note that this method is only intended
-      * defined data types. For all fundamental, primitive data types (like i.e.
+      * for such user defined data types. For all fundamental, primitive data
-      * @c int) this method returns an empty string instead.
+      * types (like i.e. @c int) this method returns an empty string instead.
       *
       * This method takes an optional boolean argument @b demangle, which allows
       * you define whether you are interested in the raw C++ type name or rather
-Line 443 
 namespace Serialization {
+Line 530 
 namespace Serialization {
       * @b Windows: please note that the current implementation of this method
       * on Windows is @b not thread safe!
       *
-      * @see isPointer(), baseTypeName()
+      * @see baseTypeName(), customTypeName2(), isPointer()
       */
      String DataType::customTypeName(bool demangle) const {
          if (!demangle) return m_customTypeName;
- #ifdef _MSC_VER
+         return _demangleTypeName(m_customTypeName.c_str());
-         const size_t MAXLENGTH = 1024;
+     }
-         char result[MAXLENGTH];
-         //FIXME: calling UnDecorateSymbolName() is not thread safe!
+     /** @brief The 2nd user defined C/C++ data type name of this data type.
-         //Skip the first char
+      *
-         size_t size = UnDecorateSymbolName(m_customTypeName.c_str() +1, result, MAXLENGTH, UNDNAME_32_BIT_DECODE | UNDNAME_NO_ARGUMENTS);
+      * This is currently only used for @c Map<> data types in which case this
-         if (size)
+      * method returns the map's value type (i.e. map's 2nd template parameter).
-         {
+      *
-             return result;
+      * @see baseTypeName(), customTypeName()
-         }
+      */
-         return m_customTypeName;
+     String DataType::customTypeName2(bool demangle) const {
- #else
+         if (!demangle) return m_customTypeName2;
-         int status;
+         return _demangleTypeName(m_customTypeName2.c_str());
-         char* result =
-             abi::__cxa_demangle(m_customTypeName.c_str(), 0, 0, &status);
-         String sResult = result;
-         free(result);
-         return (status == 0) ? sResult : m_customTypeName;
- #endif
      }
      // *************** Member ***************
-Line 489 
 namespace Serialization {
+Line 569 
 namespace Serialization {
          m_offset = 0;
      }
-     Member::Member(String name, UID uid, size_t offset, DataType type) {
+     Member::Member(String name, UID uid, ssize_t offset, DataType type) {
          m_name = name;
          m_uid  = uid;
          m_offset = offset;
-Line 571 
 namespace Serialization {
+Line 651 
 namespace Serialization {
       * @c b and @c c instead. For most 64 bit architectures this example would
       * now still return @c 0 for member @c a, but @c 8 for member @c b and @c 16
       * for member @c c.
+      *
+      * @note Offset is intended for native members only, that is member
+      * variables which are memory located directly within the associated parent
+      * data structure. For members allocated on the heap @c offset() always
+      * returns @c -1 instead since there is no constant, static offset
+      * relationship between data on the heap and the parent structure owning
+      * their life-time control.
       */
-     size_t Member::offset() const {
+     ssize_t Member::offset() const {
          return m_offset;
      }
-Line 733 
 namespace Serialization {
+Line 820 
 namespace Serialization {
          return (index < m_uid.size()) ? m_uid[index] : NO_UID;
      }
+     static void _setNativeValueFromString(void* ptr, const DataType& type, const char* s) {
+         if (type.isPrimitive() && !type.isPointer()) {
+             if (type.isInteger() || type.isEnum()) {
+                 if (type.isSigned()) {
+                     if (type.size() == 1)
+                         *(int8_t*)ptr = (int8_t) atoll(s);
+                     else if (type.size() == 2)
+                         *(int16_t*)ptr = (int16_t) atoll(s);
+                     else if (type.size() == 4)
+                         *(int32_t*)ptr = (int32_t) atoll(s);
+                     else if (type.size() == 8)
+                         *(int64_t*)ptr = (int64_t) atoll(s);
+                     else
+                         assert(false /* unknown signed int type size */);
+                 } else {
+                     if (type.size() == 1)
+                         *(uint8_t*)ptr = (uint8_t) atoll(s);
+                     else if (type.size() == 2)
+                         *(uint16_t*)ptr = (uint16_t) atoll(s);
+                     else if (type.size() == 4)
+                         *(uint32_t*)ptr = (uint32_t) atoll(s);
+                     else if (type.size() == 8)
+                         *(uint64_t*)ptr = (uint64_t) atoll(s);
+                     else
+                         assert(false /* unknown unsigned int type size */);
+                 }
+             } else if (type.isReal()) {
+                 if (type.size() == sizeof(float))
+                     *(float*)ptr = (float) atof(s);
+                 else if (type.size() == sizeof(double))
+                     *(double*)ptr = (double) atof(s);
+                 else
+                     assert(false /* unknown floating point type */);
+             } else if (type.isBool()) {
+                 String lower = toLowerCase(s);
+                 const bool b = lower != "0" && lower != "false" && lower != "no";
+                 *(bool*)ptr = b;
+             } else if (type.isString()) {
+                 *(String*)ptr = s;
+             } else {
+                 assert(false /* no built-in cast from string support for this data type */);
+             }
+         }
+     }
+     /** @brief Cast from string to object's data type and assign value natively.
+      *
+      * The passed String @a s is decoded from its string representation to this
+      * object's corresponding native data type, then that casted value is
+      * assigned to the native memory location this Object is referring to.
+      *
+      * Note: This method may only be called for data types which enjoy built-in
+      * support for casting from string to their native data type, which are
+      * basically primitive data types (e.g. @c int, @c bool, @c double, etc.) or
+      * @c String objects. For all other data types calling this method will
+      * cause an assertion fault at runtime.
+      *
+      * @param s - textual string representation of the value to be assigned to
+      *            this object
+      */
+     void Object::setNativeValueFromString(const String& s) {
+         const ID& id = uid().id;
+         void* ptr = (void*)id;
+         _setNativeValueFromString(ptr, m_type, s.c_str());
+     }
      /** @brief Unique identifier chain of this Object.
       *
       * Returns the entire unique identifier chain of this Object.
-Line 1195 
 namespace Serialization {
+Line 1348 
 namespace Serialization {
          String s;
          s += _encodeBlob(type.baseTypeName());
          s += _encodeBlob(type.customTypeName());
+         if (!type.customTypeName2().empty())
+             s += _encodeBlob(type.customTypeName2());
          s += _encodeBlob(ToString(type.size()));
          s += _encodeBlob(ToString(type.isPointer()));
          return _encodeBlob(s);
-Line 1269 
 namespace Serialization {
+Line 1424 
 namespace Serialization {
              } else {
                  assert(false /* unknown primitive type */);
              }
          }
          return s;
      }
-Line 1376 
 namespace Serialization {
+Line 1530 
 namespace Serialization {
      /*
       * Srx format history:
       * - 1.0: Initial version.
-      * - 1.1: Adds "String" data type.
+      * - 1.1: Adds "String", "Array", "Set" and "Map" data types and an optional
+      *        2nd custom type name (e.g. "Map" types which always contain two
+      *        user defined types).
       */
      #define MAGIC_START "Srx1v"
      #define ENCODING_FORMAT_MINOR_VERSION 1
-Line 1524 
 namespace Serialization {
+Line 1680 
 namespace Serialization {
          DataType type;
          type.m_baseTypeName   = _popStringBlob(p, end);
          type.m_customTypeName = _popStringBlob(p, end);
+         if (type.isMap())
+             type.m_customTypeName2 = _popStringBlob(p, end);
          type.m_size           = _popIntBlob<int>(p, end);
          type.m_isPointer      = _popIntBlob<bool>(p, end);
          return type;
-Line 1567 
 namespace Serialization {
+Line 1725 
 namespace Serialization {
          if (p >= end) return m;
          m.m_uid    = _popUIDBlob(p, end);
-         m.m_offset = _popIntBlob<size_t>(p, end);
+         m.m_offset = _popIntBlob<ssize_t>(p, end);
          m.m_name   = _popStringBlob(p, end);
          m.m_type   = _popDataTypeBlob(p, end);
          assert(m.type());
-Line 2354 
 namespace Serialization {
+Line 2512 
 namespace Serialization {
          *pDst = (String) (const char*) &srcObj.rawData()[0];
      }
+     void Archive::Syncer::syncArray(const Object& dstObj, const Object& srcObj) {
+         assert(dstObj.type().isArray());
+         assert(dstObj.type() == srcObj.type());
+         dstObj.m_sync(const_cast<Object&>(dstObj), srcObj, this);
+     }
+     void Archive::Syncer::syncSet(const Object& dstObj, const Object& srcObj) {
+         assert(dstObj.type().isSet());
+         assert(dstObj.type() == srcObj.type());
+         dstObj.m_sync(const_cast<Object&>(dstObj), srcObj, this);
+     }
+     void Archive::Syncer::syncMap(const Object& dstObj, const Object& srcObj) {
+         assert(dstObj.type().isMap());
+         assert(dstObj.type() == srcObj.type());
+         dstObj.m_sync(const_cast<Object&>(dstObj), srcObj, this);
+     }
      void Archive::Syncer::syncPointer(const Object& dstObj, const Object& srcObj) {
          assert(dstObj.type().isPointer());
          assert(dstObj.type() == srcObj.type());
-Line 2387 
 namespace Serialization {
+Line 2563 
 namespace Serialization {
              return; // end of recursion
          }
+         if (dstObj.type().isArray()) {
+             syncArray(dstObj, srcObj);
+             return;
+         }
+         if (dstObj.type().isSet()) {
+             syncSet(dstObj, srcObj);
+             return;
+         }
+         if (dstObj.type().isMap()) {
+             syncMap(dstObj, srcObj);
+             return;
+         }
          if (dstObj.type().isPointer()) {
              syncPointer(dstObj, srcObj);
              return;

 Legend:



Removed from v.3774
 


changed lines


 
Added in v.3777
 Legend:



Removed from v.3774
 


changed lines


 
Added in v.3777
-Removed from v.3774
+Added in v.3777

	ViewVC Help
Powered by ViewVC