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

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

Parent Directory | Revision Log | View Patch Patch

-revision 3185 by schoenebeck,
Wed May 17 15:42:58 2017 UTC
+revision 3775 by schoenebeck,
Tue May 19 15:23:11 2020 UTC
 Line 1
  /***************************************************************************
   *                                                                         *
-  *   Copyright (C) 2017 Christian Schoenebeck                              *
+  *   Copyright (C) 2017-2020 Christian Schoenebeck                         *
-  *                      <cuse@users.sourceforge.net>                       *
+  *                           <cuse@users.sourceforge.net>                  *
   *                                                                         *
   *   This library is part of libgig.                                       *
   *                                                                         *
 Line 21
   *   MA  02111-1307  USA                                                   *
   ***************************************************************************/
+ // enable implementation specific declarations in Serialization.h required to
+ // build this C++ unit, which should be ignored in the public API though
+ #define LIBGIG_SERIALIZATION_INTERNAL 1
  #include "Serialization.h"
  #include <iostream>
- #include <assert.h>
  #include <string.h> // for memcpy()
  #include <stdlib.h> // for atof()
- #include <cxxabi.h>
+ #ifdef _MSC_VER
+ # include <windows.h>
+ # include <dbghelp.h>
+ #else
+ # include <cxxabi.h>
+ #endif
  #include "helper.h"
  #define LIBGIG_EPOCH_TIME ((time_t)0)
-Line 63 
 namespace Serialization {
+Line 70 
 namespace Serialization {
      // *************** DataType ***************
      // *
-     /** @brief Default constructor.
+     /** @brief Default constructor (as "invalid" DataType).
       *
       * Initializes a DataType object as being an "invalid" DataType object.
       * Thus calling isValid(), after creating a DataType object with this
-Line 77 
 namespace Serialization {
+Line 84 
 namespace Serialization {
          m_isPointer = false;
      }
+     /** @brief Constructs a valid DataType object.
+      *
+      * Initializes this object as "valid" DataType object, with specific and
+      * useful data type information.
+      *
+      * This is a protected constructor which should not be called directly by
+      * applications, as its argument list is somewhat implementation specific
+      * and might change at any time. Applications should call the static
+      * function DataType::dataTypeOf() instead.
+      *
+      * @param isPointer - whether pointer type (i.e. a simple memory address)
+      * @param size - native size of data type in bytes (i.e. according to
+      *               @c sizeof() C/C++ keyword)
+      * @param baseType - this framework's internal name for specifying the base
+      *                   type in a coarse way, which must be either one of:
+      *                   "int8", "uint8", "int16", "uint16", "int32", "uint32",
+      *                   "int64", "uint64", "bool", "real32", "real64",
+      *                   "String", "Array", "enum", "union" or "class"
+      * @param customType - this is only used for base types "enum", "union",
+      *                     "class" or "Array", in which case this identifies the
+      *                     user defined type name (e.g. "Foo" for
+      *                     @c class @c Foo or e.g. "Bar" for @c Array<Bar>
+      *                     respectively), for all other types this is empty
+      */
      DataType::DataType(bool isPointer, int size, String baseType, String customType) {
          m_size = size;
          m_isPointer = isPointer;
-Line 113 
 namespace Serialization {
+Line 144 
 namespace Serialization {
       * (this DataType instance is reflecting) is a C/C++ @c struct or @c class
       * 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
       * struct Foo {
-Line 137 
 namespace Serialization {
+Line 173 
 namespace Serialization {
       * (this DataType instance is reflecting) is a primitive, fundamental C/C++
       * data type. Those are fundamental data types which are already predefined
       * by the C/C++ language, for example: @c char, @c int, @c float, @c double,
-      * @c bool, but also @b any pointer types like @c int*, @c double**, but
+      * @c bool, but also @c String objects and @b any pointer types like
-      * including pointers to user defined types like:
+      * @c int*, @c double**, but including pointers to user defined types like:
       * @code
       * struct Foo {
       *     int  a;
-Line 152 
 namespace Serialization {
+Line 188 
 namespace Serialization {
       * @see isPointer()
       */
      bool DataType::isPrimitive() const {
-         return !isClass();
+         return !isClass() && !isArray();
+     }
+     /** @brief Whether this is a C++ @c String data type.
+      *
+      * Returns @c true if the respective native C/C++ object, member or variable
+      * (this DataType instance is reflecting) is a C++ @c String object (a.k.a.
+      * @c std::string from the C++ STL).
+      *
+      * Note that this framework handles @c String objects as if they were a
+      * fundamental, primitive C/C++ data type, so @c isPrimitive() returns
+      * @c true for strings.
+      */
+     bool DataType::isString() const {
+         return m_baseTypeName == "String";
      }
      /** @brief Whether this is an integer C/C++ data type.
-Line 220 
 namespace Serialization {
+Line 270 
 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 signed integer C/C++ data type.
       *
       * Returns @c true if the respective native C/C++ object, member or variable
-Line 250 
 namespace Serialization {
+Line 316 
 namespace Serialization {
       * characteristic is compared as well. So a @c double type and @c double*
       * type are also considered to be not equal data types and hence this method
       * would return @c false.
+      *
+      * As an exception here, classes and structs with the same class/struct name
+      * but different sizes are also considered to be "equal". This relaxed
+      * requirement is necessary to retain backward compatiblity to older
+      * versions of the same native C++ classes/structs.
       */
      bool DataType::operator==(const DataType& other) const {
          return m_baseTypeName   == other.m_baseTypeName &&
                 m_customTypeName == other.m_customTypeName &&
-                m_size           == other.m_size &&
+                (m_size == other.m_size || (isClass() && other.isClass())) &&
                 m_isPointer      == other.m_isPointer;
      }
-Line 281 
 namespace Serialization {
+Line 352 
 namespace Serialization {
      bool DataType::operator<(const DataType& other) const {
          return m_baseTypeName  < other.m_baseTypeName ||
                (m_baseTypeName == other.m_baseTypeName &&
-                m_customTypeName  < other.m_customTypeName ||
+               (m_customTypeName  < other.m_customTypeName ||
                (m_customTypeName == other.m_customTypeName &&
-                m_size  < other.m_size ||
+               (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 361 
 namespace Serialization {
+Line 432 
 namespace Serialization {
      /** @brief The 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 390 
 namespace Serialization {
+Line 461 
 namespace Serialization {
       * In the latter example @c customTypeName(true) would return for both
       * @c foo and @c pFoo the string @c "Foo" as return value of this method.
       *
+      * @b Windows: please note that the current implementation of this method
+      * on Windows is @b not thread safe!
+      *
       * @see isPointer(), baseTypeName()
       */
      String DataType::customTypeName(bool demangle) const {
          if (!demangle) return m_customTypeName;
+ #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(m_customTypeName.c_str() +1, result, MAXLENGTH, UNDNAME_32_BIT_DECODE | UNDNAME_NO_ARGUMENTS);
+         if (size)
+         {
+             return result;
+         }
+         return m_customTypeName;
+ #else
          int status;
-         const char* result =
+         char* result =
              abi::__cxa_demangle(m_customTypeName.c_str(), 0, 0, &status);
-         return (status == 0) ? result : m_customTypeName;
+         String sResult = result;
+         free(result);
+         return (status == 0) ? sResult : m_customTypeName;
+ #endif
      }
      // *************** Member ***************
-Line 420 
 namespace Serialization {
+Line 510 
 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 502 
 namespace Serialization {
+Line 592 
 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 568 
 namespace Serialization {
+Line 665 
 namespace Serialization {
      bool Member::operator<(const Member& other) const {
          return m_uid  < other.m_uid ||
                (m_uid == other.m_uid &&
-                m_offset  < other.m_offset ||
+               (m_offset  < other.m_offset ||
                (m_offset == other.m_offset &&
-                m_name  < other.m_name ||
+               (m_name  < other.m_name ||
                (m_name == other.m_name &&
-                m_type < other.m_type)));
+                m_type < other.m_type)))));
      }
      /** @brief Greater than comparison.
-Line 714 
 namespace Serialization {
+Line 811 
 namespace Serialization {
       * In case this Object is reflecting a native C/C++ @c struct or @c class
       * type, then this method returns the version of that native C/C++ @c struct
       * or @c class layout or implementation. For primitive, fundamental C/C++
-      * data types the return value of this method has no meaning.
+      * data types (including @c String objects) the return value of this method
+      * has no meaning.
       *
       * @see Archive::setVersion() for more details about this overall topic.
       */
-Line 727 
 namespace Serialization {
+Line 825 
 namespace Serialization {
       * In case this Object is reflecting a native C/C++ @c struct or @c class
       * type, then this method returns the "minimum" version of that native C/C++
       * @c struct or @c class layout or implementation which it may be compatible
-      * with. For primitive, fundamental C/C++ data types the return value of
+      * with. For primitive, fundamental C/C++ data types (including @c String
-      * this method has no meaning.
+      * objects) the return value of this method has no meaning.
       *
       * @see Archive::setVersion() and Archive::setMinVersion() for more details
       *      about this overall topic.
-Line 1058 
 namespace Serialization {
+Line 1156 
 namespace Serialization {
          m_root = NO_UID;
          m_isModified = false;
          m_timeCreated = m_timeModified = LIBGIG_EPOCH_TIME;
-         decode(m_rawData);
+         decode(data);
      }
      /** @brief Create and fill the archive with the given serialized raw C-buffer data.
-Line 1194 
 namespace Serialization {
+Line 1292 
 namespace Serialization {
                      assert(false /* unknown floating point type */);
              } else if (type.isBool()) {
                  s = ToString(*(bool*)ptr);
+             } else if (type.isString()) {
+                 s = obj.m_data.empty() ? *(String*)ptr : String((const char*)ptr);
              } else {
                  assert(false /* unknown primitive type */);
              }
          }
          return s;
      }
      template<typename T>
+     inline T _stringToNumber(const String& s) {
+         assert(false /* String cast to unknown primitive number type */);
+     }
+     template<>
+     inline int64_t _stringToNumber(const String& s) {
+         return atoll(s.c_str());
+     }
+     template<>
+     inline double _stringToNumber(const String& s) {
+         return atof(s.c_str());
+     }
+     template<>
+     inline bool _stringToNumber(const String& s) {
+         return (bool) atoll(s.c_str());
+     }
+     template<typename T>
      static T _primitiveObjectValueToNumber(const Object& obj) {
          T value = 0;
          const DataType& type = obj.type();
-Line 1244 
 namespace Serialization {
+Line 1363 
 namespace Serialization {
                      assert(false /* unknown floating point type */);
              } else if (type.isBool()) {
                  value = (T)*(bool*)ptr;
+             } else if (type.isString()) {
+                 value = _stringToNumber<T>(
+                     obj.m_data.empty() ? *(String*)ptr : String((const char*)ptr)
+                 );
              } else {
                  assert(false /* unknown primitive type */);
              }
-Line 1277 
 namespace Serialization {
+Line 1400 
 namespace Serialization {
          return _encodeBlob(s);
      }
+     /*
+      * Srx format history:
+      * - 1.0: Initial version.
+      * - 1.1: Adds "String" and "Array" data types.
+      */
      #define MAGIC_START "Srx1v"
-     #define ENCODING_FORMAT_MINOR_VERSION 0
+     #define ENCODING_FORMAT_MINOR_VERSION 1
      String Archive::_encodeRootBlob() {
          String s;
-Line 1404 
 namespace Serialization {
+Line 1532 
 namespace Serialization {
          return s;
      }
+     static void _popStringBlob(const char*& p, const char* end, RawData& rawData) {
+         String s = _popStringBlob(p, end);
+         rawData.resize(s.length() + 1);
+         strcpy((char*)&rawData[0], &s[0]);
+     }
      static time_t _popTimeBlob(const char*& p, const char* end) {
          const uint64_t i = _popIntBlob<uint64_t>(p, end);
          return (time_t) i;
      }
-     DataType _popDataTypeBlob(const char*& p, const char* end) {
+     static DataType _popDataTypeBlob(const char*& p, const char* end) {
          _Blob blob = _decodeBlob(p, end);
          p   = blob.p;
          end = blob.end;
-Line 1460 
 namespace Serialization {
+Line 1594 
 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 1522 
 namespace Serialization {
+Line 1656 
 namespace Serialization {
                      assert(false /* unknown floating point type */);
              } else if (type.isBool()) {
                  _popIntBlob<uint8_t>(p, end, obj.m_data);
+             } else if (type.isString()) {
+                 _popStringBlob(p, end, obj.m_data);
              } else {
                  assert(false /* unknown primitive type */);
              }
-Line 2062 
 namespace Serialization {
+Line 2198 
 namespace Serialization {
          m_isModified = true;
      }
+     /** @brief Set new textual string for given String object.
+      *
+      * Sets the new textual string @a value to the given String @a object.
+      *
+      * @param object - the String object to be changed
+      * @param value - the new textual string to be assigned to the @a object
+      * @throws Exception if @a object is not a String type.
+      */
+     void Archive::setStringValue(Object& object, String value) {
+         if (!object) return;
+         if (!object.type().isString())
+             throw Exception("Not a String data type");
+         Object* pObject = &object;
+         if (object.type().isPointer()) {
+             Object& obj = objectByUID(object.uid(1));
+             if (!obj) return;
+             pObject = &obj;
+         }
+         pObject->m_data.resize(value.length() + 1);
+         char* ptr = (char*) &pObject->m_data[0];
+         strcpy(ptr, &value[0]);
+         m_isModified = true;
+     }
      /** @brief Automatically cast and assign appropriate value to object.
       *
       * This method automatically converts the given @a value from textual string
-Line 2090 
 namespace Serialization {
+Line 2250 
 namespace Serialization {
                  setBoolValue(object, false);
              else
                  setBoolValue(object, atof(value.c_str()));
-         } else if (type.isEnum())
+         } else if (type.isString())
+             setStringValue(object, value);
+         else if (type.isEnum())
              setEnumValue(object, atoll(value.c_str()));
          else
              throw Exception("Not a primitive data type");
-Line 2187 
 namespace Serialization {
+Line 2349 
 namespace Serialization {
          return _primitiveObjectValueToNumber<bool>(*pObject);
      }
+     Archive::operation_t Archive::operation() const {
+         return m_operation;
+     }
      // *************** Archive::Syncer ***************
      // *
-Line 2208 
 namespace Serialization {
+Line 2374 
 namespace Serialization {
          memcpy(pDst, &srcObj.rawData()[0], dstObj.type().size());
      }
+     void Archive::Syncer::syncString(const Object& dstObj, const Object& srcObj) {
+         assert(dstObj.type().isString());
+         assert(dstObj.type() == srcObj.type());
+         String* pDst = (String*)(void*)dstObj.uid().id;
+         *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::syncPointer(const Object& dstObj, const Object& srcObj) {
          assert(dstObj.type().isPointer());
          assert(dstObj.type() == srcObj.type());
-Line 2234 
 namespace Serialization {
+Line 2413 
 namespace Serialization {
          m_dst.m_allObjects.erase(dstObj.uid());
          if (dstObj.type().isPrimitive() && !dstObj.type().isPointer()) {
-             syncPrimitive(dstObj, srcObj);
+             if (dstObj.type().isString())
+                 syncString(dstObj, srcObj);
+             else
+                 syncPrimitive(dstObj, srcObj);
              return; // end of recursion
          }
+         if (dstObj.type().isArray()) {
+             syncArray(dstObj, srcObj);
+             return;
+         }
          if (dstObj.type().isPointer()) {
              syncPointer(dstObj, srcObj);
              return;
-Line 2286 
 namespace Serialization {
+Line 2473 
 namespace Serialization {
      // *************** Exception ***************
      // *
+     Exception::Exception() {
+     }
+     Exception::Exception(String format, ...) {
+         va_list arg;
+         va_start(arg, format);
+         Message = assemble(format, arg);
+         va_end(arg);
+     }
+     Exception::Exception(String format, va_list arg) {
+         Message = assemble(format, arg);
+     }
      /** @brief Print exception message to stdout.
       *
       * Prints the message of this Exception to the currently defined standard
-Line 2295 
 namespace Serialization {
+Line 2496 
 namespace Serialization {
          std::cout << "Serialization::Exception: " << Message << std::endl;
      }
+     String Exception::assemble(String format, va_list arg) {
+         char* buf = NULL;
+         vasprintf(&buf, format.c_str(), arg);
+         String s = buf;
+         free(buf);
+         return s;
+     }
  } // namespace Serialization

 Legend:



Removed from v.3185
 


changed lines


 
Added in v.3775
 Legend:



Removed from v.3185
 


changed lines


 
Added in v.3775
-Removed from v.3185
+Added in v.3775

	ViewVC Help
Powered by ViewVC