Serialization.cpp

/***************************************************************************
 *                                                                         *
 *   Copyright (C) 2017-2026 Christian Schoenebeck                         *
 *                           <cuse@users.sourceforge.net>                  *
 *                                                                         *
 *   This library is part of libgig.                                       *
 *                                                                         *
 *   This library is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this library; if not, write to the Free Software           *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   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 <string.h> // for memcpy()
#include <cstdint> // for uintptr_t
#ifdef _MSC_VER
# include <windows.h>
# include <dbghelp.h>
#else
# include <cxxabi.h>
#endif
#include "helper.h"
#include "srx/SrxFormat.h"
#include "srx/SrxJSONFormat.h"
 
#define LIBGIG_EPOCH_TIME ((time_t)0)
 
namespace Serialization {
 
    // *************** UID ***************
    // *
 
    static UID _createNullUID() {
        const UID uid = { NULL, 0 };
        return uid;
    }
 
    const UID NO_UID = _createNullUID();

    bool UID::isValid() const {
        return id != NULL && id != (void*)-1 && size;
    }
 
    // *************** DataType ***************
    // *

    std::map<String,DataType::NativeType> DataType::m_nativeTypes;

    DataType::DataType() {
        m_size = 0;
        m_isPointer = false;
    }

    DataType::DataType(bool isPointer, int size, String baseType,
                       String customType1, String customType2)
    {
        m_size = size;
        m_isPointer = isPointer;
        m_baseTypeName = baseType;
        m_customTypeName = customType1;
        m_customTypeName2 = customType2;
    }

    bool DataType::isValid() const {
        return m_size;
    }

    bool DataType::isPointer() const {
        return m_isPointer;
    }

    bool DataType::isClass() const {
        return m_baseTypeName == "class";
    }

    bool DataType::isPrimitive() const {
        return !isClass() && !isArray() && !isSet() && !isMap();
    }

    bool DataType::isString() const {
        return m_baseTypeName == "String";
    }

    bool DataType::isChar() const {
        return m_baseTypeName.substr(0, 4) == "char";
    }

    bool DataType::isInteger() const {
        return m_baseTypeName.substr(0, 3) == "int" ||
               m_baseTypeName.substr(0, 4) == "uint";
    }

    bool DataType::isReal() const {
        return m_baseTypeName.substr(0, 4) == "real";
    }

    bool DataType::isNumber() const {
        return isInteger() || isReal();
    }

    bool DataType::isBool() const {
        return m_baseTypeName == "bool";
    }

    bool DataType::isEnum() const {
        return m_baseTypeName == "enum";
    }

    bool DataType::isArray() const {
        return m_baseTypeName == "Array";
    }

    bool DataType::isSet() const {
        return m_baseTypeName == "Set";
    }

    bool DataType::isMap() const {
        return m_baseTypeName == "Map";
    }

    bool DataType::isSigned() const {
        return m_baseTypeName.substr(0, 3) == "int" ||
               isReal();
    }

    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;
    }

    String DataType::internalID() const {
        return m_baseTypeName + "," +
               m_customTypeName + "," +
               m_customTypeName2 + "," +
               ToString(isClass()) + "," +
               ToString(m_isPointer);
    }

    bool DataType::operator!=(const DataType& other) const {
        return !operator==(other);
    }

    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_customTypeName2  < other.m_customTypeName2 ||
              (m_customTypeName2 == other.m_customTypeName2 &&
              (m_size  < other.m_size ||
              (m_size == other.m_size &&
               m_isPointer < other.m_isPointer)))))));
    }

    bool DataType::operator>(const DataType& other) const {
        return !(operator==(other) || operator<(other));
    }

    String DataType::asLongDescr() const {
        String s = m_baseTypeName;
        if (!m_customTypeName.empty())
            s += " " + customTypeName(true);
        if (!m_customTypeName2.empty())
            s += " " + customTypeName2(true);
        if (isPointer())
            s += " pointer";
        return s;
    }

    String DataType::baseTypeName() const {
        return m_baseTypeName;
    }
 
    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
    }

    String DataType::customTypeName(bool demangle) const {
        if (!demangle) return m_customTypeName;
        return _demangleTypeName(m_customTypeName.c_str());
    }

    String DataType::customTypeName2(bool demangle) const {
        if (!demangle) return m_customTypeName2;
        return _demangleTypeName(m_customTypeName2.c_str());
    }

    Object DataType::newInstance(Archive* archive) const {
        const String id = internalID();
        auto itNativeType = m_nativeTypes.find(id);
        if (itNativeType == m_nativeTypes.end()) {
            fprintf(stderr,
                    "(De)serialization Failure: cannot create new instance of "
                    "unknown data type '%s' !\n",
                    asLongDescr().c_str());
            assert(false && "You may need to explicitly register this data "
                            "type by either calling "
                            "DataType::registerNativeType<T>() or using class "
                            "NativeDataTypeRegistry");
        }
        const std::function<Object(Archive*)>& allocFn = itNativeType->second.allocFn;
        return allocFn(archive);
    }
 
    // *************** Member ***************
    // *

    Member::Member() {
        m_uid = NO_UID;
        m_offset = 0;
        m_parentUID = NO_UID;
    }
 
    Member::Member(String name, UID uid, ssize_t offset, DataType type, const Object& parent) {
        m_name = name;
        m_uid  = uid;
        m_offset = offset;
        m_type = type;
        m_parentUID = parent.uid();
    }

    UID Member::uid() const {
        return m_uid;
    }

    UID Member::parentUID() const {
        return m_parentUID;
    }

    String Member::name() const {
        return m_name;
    }

    ssize_t Member::offset() const {
        return m_offset;
    }

    const DataType& Member::type() const {
        return m_type;
    }

    bool Member::isValid() const {
        return m_uid && !m_name.empty() && m_type;
    }

    bool Member::operator==(const Member& other) const {
        return m_uid    == other.m_uid &&
               m_offset == other.m_offset &&
               m_name   == other.m_name &&
               m_type   == other.m_type;
    }

    bool Member::operator!=(const Member& other) const {
        return !operator==(other);
    }

    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_name  < other.m_name ||
              (m_name == other.m_name &&
               m_type < other.m_type)))));
    }

    bool Member::operator>(const Member& other) const {
        return !(operator==(other) || operator<(other));
    }
 
    // *************** Object ***************
    // *

    Object::Object() {
        m_parentUID = NO_UID;
        m_version = 0;
        m_minVersion = 0;
    }

    Object::Object(UIDChain uidChain, DataType type, const Object& parent) {
        m_type = type;
        m_uid  = uidChain;
        m_parentUID = parent.uid();
        m_version = 0;
        m_minVersion = 0;
        //m_data.resize(type.size());
    }

    bool Object::isValid() const {
        return m_type && !m_uid.empty();
    }

    UID Object::uid(int index) const {
        return (index < m_uid.size()) ? m_uid[index] : NO_UID;
    }

    UID Object::parentUID() const {
        return m_parentUID;
    }
 
    static void _setNativeValueFromString(void* ptr, const DataType& type, const char* s) {
        if (type.isPointer()) {
            // assuming hex encoding
            uintptr_t addr = std::stoull(s, NULL, 16);
            *(void**)ptr = reinterpret_cast<void*>(addr);
        } else if (type.isPrimitive()) {
            if (type.isInteger() || type.isEnum()) {
                if (type.isSigned()) {
                    if (type.size() == 1)
                        *(int8_t*)ptr = strTo<int8_t>(s);
                    else if (type.size() == 2)
                        *(int16_t*)ptr = strTo<int16_t>(s);
                    else if (type.size() == 4)
                        *(int32_t*)ptr = strTo<int32_t>(s);
                    else if (type.size() == 8)
                        *(int64_t*)ptr = strTo<int64_t>(s);
                    else
                        assert(false /* unknown signed int type size */);
                } else {
                    if (type.size() == 1)
                        *(uint8_t*)ptr = strTo<uint8_t>(s);
                    else if (type.size() == 2)
                        *(uint16_t*)ptr = strTo<uint16_t>(s);
                    else if (type.size() == 4)
                        *(uint32_t*)ptr = strTo<uint32_t>(s);
                    else if (type.size() == 8)
                        *(uint64_t*)ptr = strTo<uint64_t>(s);
                    else
                        assert(false /* unknown unsigned int type size */);
                }
            } else if (type.isReal()) {
                if (type.size() == sizeof(float))
                    *(float*)ptr = strTo<float>(s);
                else if (type.size() == sizeof(double))
                    *(double*)ptr = strTo<double>(s);
                else
                    assert(false /* unknown floating point type */);
            } else if (type.isChar()) {
                *(char*)ptr = s[0];
            } 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 */);
            }
        }
    }

    void Object::setNativeValueFromString(const String& s) {
        const ID& id = uid().id;
        void* ptr = (void*)id;
        _setNativeValueFromString(ptr, m_type, s.c_str());
    }

    const UIDChain& Object::uidChain() const {
        return m_uid;
    }

    const DataType& Object::type() const {
        return m_type;
    }

    const RawData& Object::rawData() const {
        return m_data;
    }

    Version Object::version() const {
        return m_version;
    }

    Version Object::minVersion() const {
        return m_minVersion;
    }

    std::vector<Member>& Object::members() {
        return m_members;
    }

    const std::vector<Member>& Object::members() const {
        return m_members;
    }

    bool Object::operator==(const Object& other) const {
        // ignoring all other member variables here
        // (since UID stands for "unique" ;-) )
        return m_uid  == other.m_uid &&
               m_type == other.m_type;
    }

    bool Object::operator!=(const Object& other) const {
        return !operator==(other);
    }

    bool Object::operator<(const Object& other) const {
        // ignoring all other member variables here
        // (since UID stands for "unique" ;-) )
        return m_uid  < other.m_uid ||
              (m_uid == other.m_uid &&
               m_type < other.m_type);
    }

    bool Object::operator>(const Object& other) const {
        return !(operator==(other) || operator<(other));
    }

    bool Object::isVersionCompatibleTo(const Object& other) const {
        if (this->version() == other.version())
            return true;
        if (this->version() > other.version())
            return this->minVersion() <= other.version();
        else
            return other.minVersion() <= this->version();
    }
 
    void Object::setVersion(Version v) {
        m_version = v;
    }
 
    void Object::setMinVersion(Version v) {
        m_minVersion = v;
    }

    Member Object::memberNamed(String name) const {
        for (int i = 0; i < m_members.size(); ++i)
            if (m_members[i].name() == name)
                return m_members[i];
        return Member();
    }

    Member Object::memberByUID(const UID& uid) const {
        if (!uid) return Member();
        for (int i = 0; i < m_members.size(); ++i)
            if (m_members[i].uid() == uid)
                return m_members[i];
        return Member();
    }
 
    void Object::remove(const Member& member) {
        for (int i = 0; i < m_members.size(); ++i) {
            if (m_members[i] == member) {
                m_members.erase(m_members.begin() + i);
                return;
            }
        }
    }

    std::vector<Member> Object::membersOfType(const DataType& type) const {
        std::vector<Member> v;
        for (int i = 0; i < m_members.size(); ++i) {
            const Member& member = m_members[i];
            if (member.type() == type)
                v.push_back(member);
        }
        return v;
    }

    int Object::sequenceIndexOf(const Member& member) const {
        for (int i = 0; i < m_members.size(); ++i)
            if (m_members[i] == member)
                return i;
        return -1;
    }
 
    // *************** Archive ***************
    // *
 
    static Archive::format_t _autoDetectEncodingFormat(const RawData& data) {
        if (SrxFormat::checkMagicStart(data))
            return Archive::FORMAT_SRX;
        if (SrxJSONFormat::checkMagicStart(data))
            return Archive::FORMAT_SRX_JSON;
        return Archive::FORMAT_AUTO;
    }

    Archive::Archive(format_t format) {
        m_format = format;
        m_operation = OPERATION_NONE;
        m_root = NO_UID;
        m_isModified = false;
        m_timeCreated = m_timeModified = LIBGIG_EPOCH_TIME;
    }

    Archive::Archive(const RawData& data, format_t format) {
        m_format = format;
        m_operation = OPERATION_NONE;
        m_root = NO_UID;
        m_isModified = false;
        m_timeCreated = m_timeModified = LIBGIG_EPOCH_TIME;
        decode(data);
    }

    Archive::Archive(const uint8_t* data, size_t size, format_t format) {
        m_format = format;
        m_operation = OPERATION_NONE;
        m_root = NO_UID;
        m_isModified = false;
        m_timeCreated = m_timeModified = LIBGIG_EPOCH_TIME;
        decode(data, size);
    }
 
    Archive::~Archive() {
    }

    Object& Archive::rootObject() {
        return m_allObjects[m_root];
    }
 
    String Archive::primitiveObjectValueToString(const Object& obj) {
        String s;
        const DataType& type = obj.type();
        const ID& id = obj.uid().id;
        void* ptr = obj.m_data.empty() ? (void*)id : (void*)&obj.m_data[0];
        if (!obj.m_data.empty())
            assert(type.size() == obj.m_data.size());
        if (type.isPrimitive() && !type.isPointer()) {
            if (type.isInteger() || type.isEnum()) {
                if (type.isSigned()) {
                    if (type.size() == 1)
                        s = ToString((int16_t)*(int8_t*)ptr); // int16_t: prevent ToString() to render an ASCII character
                    else if (type.size() == 2)
                        s = ToString(*(int16_t*)ptr);
                    else if (type.size() == 4)
                        s = ToString(*(int32_t*)ptr);
                    else if (type.size() == 8)
                        s = ToString(*(int64_t*)ptr);
                    else
                        assert(false /* unknown signed int type size */);
                } else {
                    if (type.size() == 1)
                        s = ToString((uint16_t)*(uint8_t*)ptr); // uint16_t: prevent ToString() to render an ASCII character
                    else if (type.size() == 2)
                        s = ToString(*(uint16_t*)ptr);
                    else if (type.size() == 4)
                        s = ToString(*(uint32_t*)ptr);
                    else if (type.size() == 8)
                        s = ToString(*(uint64_t*)ptr);
                    else
                        assert(false /* unknown unsigned int type size */);
                }
            } else if (type.isReal()) {
                if (type.size() == sizeof(float))
                    s = ToString(*(float*)ptr);
                else if (type.size() == sizeof(double))
                    s = ToString(*(double*)ptr);
                else
                    assert(false /* unknown floating point type */);
            } else if (type.isChar()) {
                s.resize(1);
                s[0] = *(char*)ptr;
            } 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 strTo<int64_t>(s);
    }
 
    template<>
    inline double _stringToNumber(const String& s) {
        return strTo<double>(s);
    }
 
    template<>
    inline bool _stringToNumber(const String& s) {
        return strTo<bool>(s);
    }
 
    template<typename T>
    static T _primitiveObjectValueToNumber(const Object& obj) {
        T value = 0;
        const DataType& type = obj.type();
        const ID& id = obj.uid().id;
        void* ptr = obj.m_data.empty() ? (void*)id : (void*)&obj.m_data[0];
        if (!obj.m_data.empty())
            assert(type.size() == obj.m_data.size());
        if (type.isPrimitive() && !type.isPointer()) {
            if (type.isInteger() || type.isEnum()) {
                if (type.isSigned()) {
                    if (type.size() == 1)
                        value = (T)*(int8_t*)ptr;
                    else if (type.size() == 2)
                        value = (T)*(int16_t*)ptr;
                    else if (type.size() == 4)
                        value = (T)*(int32_t*)ptr;
                    else if (type.size() == 8)
                        value = (T)*(int64_t*)ptr;
                    else
                        assert(false /* unknown signed int type size */);
                } else {
                    if (type.size() == 1)
                        value = (T)*(uint8_t*)ptr;
                    else if (type.size() == 2)
                        value = (T)*(uint16_t*)ptr;
                    else if (type.size() == 4)
                        value = (T)*(uint32_t*)ptr;
                    else if (type.size() == 8)
                        value = (T)*(uint64_t*)ptr;
                    else
                        assert(false /* unknown unsigned int type size */);
                }
            } else if (type.isReal()) {
                if (type.size() == sizeof(float))
                    value = (T)*(float*)ptr;
                else if (type.size() == sizeof(double))
                    value = (T)*(double*)ptr;
                else
                    assert(false /* unknown floating point type */);
            } else if (type.isChar()) {
                value = (T)*(char*)ptr;
            } 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 */);
            }
        }
        return value;
    }
 
    void Archive::encode() {
        encode(m_format);
    }
 
    void Archive::encode(format_t format) {
        m_rawData.clear();
        m_timeModified = time(NULL);
        if (m_timeCreated == LIBGIG_EPOCH_TIME)
            m_timeCreated = m_timeModified;
    again:
        switch (format) {
            case FORMAT_AUTO:
                format = (m_format != FORMAT_AUTO) ? m_format : FORMAT_SRX;
                goto again;
            case FORMAT_SRX:
                m_rawData = SrxFormat::encode(*this);
                m_format = FORMAT_SRX;
                goto done;
            case FORMAT_SRX_JSON: {
                SrxJSONEncoder jsonEncoder;
                m_rawData = jsonEncoder.encode(*this);
                m_format = FORMAT_SRX_JSON;
                goto done;
            }
        }
        throw Exception("Requested encoding format unknown: %d", format);
    done:
        m_isModified = false;
    }

    void Archive::decode(const RawData& data) {
        decode(data, m_format);
    }

    void Archive::decode(const RawData& data, format_t format) {
        m_rawData = data;
        m_allObjects.clear();
        m_isModified = false;
        m_timeCreated = m_timeModified = LIBGIG_EPOCH_TIME;
    again:
        switch (format) {
            case FORMAT_AUTO:
                format = _autoDetectEncodingFormat(data);
                if (format == FORMAT_AUTO)
                    throw Exception("Unknown encoding format");
                goto again;
            case FORMAT_SRX:
                SrxFormat::decode(*this, data);
                m_format = format;
                return;
            case FORMAT_SRX_JSON: {
                SrxJSONDecoder::decode(*this, data);
                m_format = format;
                return;
            }
        }
        throw Exception("Requested encoding format unknown: %d", format);
    }

    void Archive::decode(const uint8_t* data, size_t size) {
        decode(data, size, m_format);
    }

    void Archive::decode(const uint8_t* data, size_t size, format_t format) {
        RawData rawData;
        rawData.resize(size);
        memcpy(&rawData[0], data, size);
        decode(rawData, format);
    }

    const RawData& Archive::rawData() {
        if (m_isModified) encode();
        return m_rawData;
    }

    String Archive::rawDataFormat() const {
        switch (m_format) {
            case FORMAT_AUTO:
            case FORMAT_SRX:
                return SrxFormat::name();
            case FORMAT_SRX_JSON:
                return SrxJSONFormat::name();
        }
        return "";
    }

    bool Archive::isModified() const {
        return m_isModified;
    }

    void Archive::clear() {
        m_allObjects.clear();
        m_operation = OPERATION_NONE;
        m_root = NO_UID;
        m_rawData.clear();
        m_isModified = false;
        m_timeCreated = m_timeModified = LIBGIG_EPOCH_TIME;
    }

    String Archive::name() const {
        return m_name;
    }

    void Archive::setName(String name) {
        if (m_name == name) return;
        m_name = name;
        m_isModified = true;
    }

    String Archive::comment() const {
        return m_comment;
    }

    void Archive::setComment(String comment) {
        if (m_comment == comment) return;
        m_comment = comment;
        m_isModified = true;
    }
 
    static tm _convertTimeStamp(const time_t& time, time_base_t base) {
        tm* pTm;
        switch (base) {
            case LOCAL_TIME:
                pTm = localtime(&time);
                break;
            case UTC_TIME:
                pTm = gmtime(&time);
                break;
            default:
                throw Exception("Time stamp with unknown time base (" + ToString((int64_t)base) + ") requested");
        }
        if (!pTm)
            throw Exception("Failed assembling time stamp structure");
        return *pTm;
    }

    time_t Archive::timeStampCreated() const {
        return m_timeCreated;
    }

    time_t Archive::timeStampModified() const {
        return m_timeModified;
    }

    tm Archive::dateTimeCreated(time_base_t base) const {
        return _convertTimeStamp(m_timeCreated, base);
    }

    tm Archive::dateTimeModified(time_base_t base) const {
        return _convertTimeStamp(m_timeModified, base);
    }

    void Archive::removeMember(Object& parent, const Member& member) {
        parent.remove(member);
        m_isModified = true;
    }

    void Archive::remove(const Object& obj) {
        //FIXME: Should traverse from root object and remove all members associated with this object
        if (!obj.uid()) return;
        m_allObjects.erase(obj.uid());
        m_isModified = true;
    }

    Object& Archive::objectByUID(const UID& uid) {
        return m_allObjects[uid];
    }

    Object& Archive::objectByBaseUID(const UID& uid) {
        ObjectPool::iterator it = m_allObjects.find(uid);
        if (it != m_allObjects.end())
            return it->second;
 
        // find all objects with the same ID (i.e. memory address) AND being
        // larger than expected by passed base UID
        std::map<size_t,UID> matches;
        for (const auto& it : m_allObjects)
            if (it.first.id == uid.id && it.first.size > uid.size)
                matches[it.first.size] = it.first;
 
        if (matches.empty())
            return ObjectPool::invalidObject();
 
        // return the next larger object found
        return m_allObjects[matches.begin()->second];
    }

    Object& Archive::parentObjectOf(const Object& obj) {
        return m_allObjects[obj.parentUID()];
    }

    Object& Archive::parentObjectOf(const Member& member) {
        return m_allObjects[member.parentUID()];
    }

    void Archive::setVersion(Object& object, Version v) {
        if (!object) return;
        object.setVersion(v);
        m_isModified = true;
    }

    void Archive::setMinVersion(Object& object, Version v) {
        if (!object) return;
        object.setMinVersion(v);
        m_isModified = true;
    }

    void Archive::setEnumValue(Object& object, uint64_t value) {
        if (!object) return;
        if (!object.type().isEnum())
            throw Exception("Not an enum data type");
        Object* pObject = &object;
        if (object.type().isPointer()) {
            Object& obj = objectByUID(object.uid(1));
            if (!obj) return;
            pObject = &obj;
        }
        const int nativeEnumSize = sizeof(enum operation_t);
        DataType& type = const_cast<DataType&>( pObject->type() );
        // original serializer ("sender") might have had a different word size
        // than this machine, adjust type object in this case
        if (type.size() != nativeEnumSize) {
            type.m_size = nativeEnumSize;
        }
        pObject->m_data.resize(type.size());
        void* ptr = &pObject->m_data[0];
        if (type.size() == 1)
            *(uint8_t*)ptr = (uint8_t)value;
        else if (type.size() == 2)
            *(uint16_t*)ptr = (uint16_t)value;
        else if (type.size() == 4)
            *(uint32_t*)ptr = (uint32_t)value;
        else if (type.size() == 8)
            *(uint64_t*)ptr = (uint64_t)value;
        else
            assert(false /* unknown enum type size */);
        m_isModified = true;
    }

    void Archive::setIntValue(Object& object, int64_t value) {
        if (!object) return;
        if (!object.type().isInteger())
            throw Exception("Not an integer data type");
        Object* pObject = &object;
        if (object.type().isPointer()) {
            Object& obj = objectByUID(object.uid(1));
            if (!obj) return;
            pObject = &obj;
        }
        const DataType& type = pObject->type();
        pObject->m_data.resize(type.size());
        void* ptr = &pObject->m_data[0];
        if (type.isSigned()) {
            if (type.size() == 1)
                *(int8_t*)ptr = (int8_t)value;
            else if (type.size() == 2)
                *(int16_t*)ptr = (int16_t)value;
            else if (type.size() == 4)
                *(int32_t*)ptr = (int32_t)value;
            else if (type.size() == 8)
                *(int64_t*)ptr = (int64_t)value;
            else
                assert(false /* unknown signed int type size */);
        } else {
            if (type.size() == 1)
                *(uint8_t*)ptr = (uint8_t)value;
            else if (type.size() == 2)
                *(uint16_t*)ptr = (uint16_t)value;
            else if (type.size() == 4)
                *(uint32_t*)ptr = (uint32_t)value;
            else if (type.size() == 8)
                *(uint64_t*)ptr = (uint64_t)value;
            else
                assert(false /* unknown unsigned int type size */);
        }
        m_isModified = true;
    }

    void Archive::setRealValue(Object& object, double value) {
        if (!object) return;
        if (!object.type().isReal())
            throw Exception("Not a real data type");
        Object* pObject = &object;
        if (object.type().isPointer()) {
            Object& obj = objectByUID(object.uid(1));
            if (!obj) return;
            pObject = &obj;
        }
        const DataType& type = pObject->type();
        pObject->m_data.resize(type.size());
        void* ptr = &pObject->m_data[0];
        if (type.size() == sizeof(float))
            *(float*)ptr = (float)value;
        else if (type.size() == sizeof(double))
            *(double*)ptr = (double)value;
        else
            assert(false /* unknown real type size */);
        m_isModified = true;
    }

    void Archive::setCharValue(Object& object, char value) {
        if (!object) return;
        if (!object.type().isChar())
            throw Exception("Not a char data type");
        Object* pObject = &object;
        if (object.type().isPointer()) {
            Object& obj = objectByUID(object.uid(1));
            if (!obj) return;
            pObject = &obj;
        }
        const DataType& type = pObject->type();
        pObject->m_data.resize(type.size());
        char* ptr = (char*)&pObject->m_data[0];
        *ptr = value;
        m_isModified = true;
    }

    void Archive::setBoolValue(Object& object, bool value) {
        if (!object) return;
        if (!object.type().isBool())
            throw Exception("Not a bool data type");
        Object* pObject = &object;
        if (object.type().isPointer()) {
            Object& obj = objectByUID(object.uid(1));
            if (!obj) return;
            pObject = &obj;
        }
        const DataType& type = pObject->type();
        pObject->m_data.resize(type.size());
        bool* ptr = (bool*)&pObject->m_data[0];
        *ptr = value;
        m_isModified = true;
    }

    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;
    }

    void Archive::setAutoValue(Object& object, String value) {
        if (!object) return;
        const DataType& type = object.type();
        if (type.isInteger())
            setIntValue(object, strTo<int64_t>(value));
        else if (type.isReal())
            setRealValue(object, strTo<double>(value));
        else if (type.isChar()) {
            if (value.empty())
                throw Exception("Empty string provided for char type");
            setCharValue(object, value[0]);
        } else if (type.isBool()) {
            String val = toLowerCase(value);
            if (val == "true" || val == "yes" || val == "1")
                setBoolValue(object, true);
            else if (val == "false" || val == "no" || val == "0")
                setBoolValue(object, false);
            else
                setBoolValue(object, strTo<bool>(value));
        } else if (type.isString())
            setStringValue(object, value);
        else if (type.isEnum())
            setEnumValue(object, strTo<uint64_t>(value));
        else
            throw Exception("Not a primitive data type");
    }

    String Archive::valueAsString(const Object& object) {
        if (!object)
            throw Exception("Invalid object");
        if (object.type().isClass())
            throw Exception("Object is class type");
        const Object* pObject = &object;
        if (object.type().isPointer()) {
            const Object& obj = objectByUID(object.uid(1));
            if (!obj) return "";
            pObject = &obj;
        }
        return primitiveObjectValueToString(*pObject);
    }

    int64_t Archive::valueAsInt(const Object& object) {
        if (!object)
            throw Exception("Invalid object");
        if (!object.type().isInteger() && !object.type().isEnum())
            throw Exception("Object is neither an integer nor an enum");
        const Object* pObject = &object;
        if (object.type().isPointer()) {
            const Object& obj = objectByUID(object.uid(1));
            if (!obj) return 0;
            pObject = &obj;
        }
        return _primitiveObjectValueToNumber<int64_t>(*pObject);
    }

    double Archive::valueAsReal(const Object& object) {
        if (!object)
            throw Exception("Invalid object");
        if (!object.type().isReal())
            throw Exception("Object is not an real type");
        const Object* pObject = &object;
        if (object.type().isPointer()) {
            const Object& obj = objectByUID(object.uid(1));
            if (!obj) return 0;
            pObject = &obj;
        }
        return _primitiveObjectValueToNumber<double>(*pObject);
    }

    char Archive::valueAsChar(const Object& object) {
        if (!object)
            throw Exception("Invalid object");
        if (!object.type().isChar())
            throw Exception("Object is not a char type");
        const Object* pObject = &object;
        if (object.type().isPointer()) {
            const Object& obj = objectByUID(object.uid(1));
            if (!obj) return 0;
            pObject = &obj;
        }
        return _primitiveObjectValueToNumber<char>(*pObject);
    }

    bool Archive::valueAsBool(const Object& object) {
        if (!object)
            throw Exception("Invalid object");
        if (!object.type().isBool())
            throw Exception("Object is not a bool type");
        const Object* pObject = &object;
        if (object.type().isPointer()) {
            const Object& obj = objectByUID(object.uid(1));
            if (!obj) return 0;
            pObject = &obj;
        }
        return _primitiveObjectValueToNumber<bool>(*pObject);
    }
 
    Archive::operation_t Archive::operation() const {
        return m_operation;
    }
 
    // *************** Archive::Syncer ***************
    // *
 
    Archive::Syncer::Syncer(Archive& dst, Archive& src)
       : m_dst(dst), m_src(src)
    {
        const Object srcRootObj = src.rootObject();
        const Object dstRootObj = dst.rootObject();
        if (!srcRootObj)
            throw Exception("No source root object!");
        if (!dstRootObj)
            throw Exception("Expected destination root object not found!");
        syncObject(dstRootObj, srcRootObj);
    }
 
    void Archive::Syncer::syncPrimitive(const Object& dstObj, const Object& srcObj) {
        assert(srcObj.rawData().size() == dstObj.type().size());
        void* pDst = (void*)dstObj.uid().id;
        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::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());
        void** ppDst = (void**)dstObj.uid().id;
        if (!srcObj.uid(1)) { // NULL pointer on source side ...
            *ppDst = NULL;
            return;
        }
        const Object& pointedSrcObject = m_src.m_allObjects[srcObj.uid(1)];
        assert(pointedSrcObject);
        std::map<UID,UID>::iterator uidRelation = m_counterparts.find(srcObj.uid(1));
        if (pointedSrcObject.parentUID() || uidRelation != m_counterparts.end()) { // "weak" pointer to object ...
            assert(uidRelation != m_counterparts.end());
            const Object& pointedDstObject = m_dst.m_allObjects[uidRelation->second];
            assert(pointedDstObject);
            *ppDst = (void*)pointedDstObject.uid().id;
        } else { // "strong" pointer to object, allocation required ...
            assert(pointedSrcObject.type());
            Object pointedDstObject = pointedSrcObject.type().newInstance(&m_dst);
            assert(pointedDstObject);
 
            m_dst.m_allObjects[pointedDstObject.uid()] = pointedDstObject;
            *ppDst = (void*)pointedDstObject.uid().id;
            syncObject(pointedDstObject, pointedSrcObject);
        }
    }
 
    void Archive::Syncer::syncObject(const Object& dstObj, const Object& srcObj) {
        assert(dstObj && srcObj);
 
        // remember UID mapping between source and destination side
        //
        // As UIDs differ between source archive side and destination archive
        // side (as UIDs always translate to native data's real memory address),
        // remember their relationship, such that we can later on translate
        // objects from source archive side correctly to objects on destination
        // side, which is required to sync native pointers correctly for
        // pointing to respective correct, real memory address.
        const bool alreadySynced =
            !m_counterparts.insert({srcObj.uid(), dstObj.uid()}).second;
 
        // Prevent syncing this object again, and thus also prevent endless
        // loop on data structures with cyclic relations.
        if (alreadySynced)
            return; // end of recursion
 
        if (dstObj.type() != srcObj.type())
            throw Exception("Incompatible data structure type (destination type " +
                            dstObj.type().asLongDescr() + " vs. source type " +
                            srcObj.type().asLongDescr() + ")");
        if (!dstObj.isVersionCompatibleTo(srcObj))
            throw Exception("Version incompatible (destination version " +
                            ToString(dstObj.version()) + " [min. version " +
                            ToString(dstObj.minVersion()) + "], source version " +
                            ToString(srcObj.version()) + " [min. version " +
                            ToString(srcObj.minVersion()) + "])");
 
        if (dstObj.type().isPrimitive() && !dstObj.type().isPointer()) {
            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().isSet()) {
            syncSet(dstObj, srcObj);
            return;
        }
 
        if (dstObj.type().isMap()) {
            syncMap(dstObj, srcObj);
            return;
        }
 
        if (dstObj.type().isPointer()) {
            syncPointer(dstObj, srcObj);
            return;
        }
 
        assert(dstObj.type().isClass());
        for (int iMember = 0; iMember < srcObj.members().size(); ++iMember) {
            const Member& srcMember = srcObj.members()[iMember];
            Member dstMember = dstMemberMatching(dstObj, srcObj, srcMember);
            if (!dstMember)
                throw Exception("Expected member missing in destination object");
            syncMember(dstMember, srcMember);
        }
    }
 
    Member Archive::Syncer::dstMemberMatching(const Object& dstObj, const Object& srcObj, const Member& srcMember) {
        Member dstMember = dstObj.memberNamed(srcMember.name());
        if (dstMember)
            return (dstMember.type() == srcMember.type()) ? dstMember : Member();
        std::vector<Member> members = dstObj.membersOfType(srcMember.type());
        if (members.size() <= 0)
            return Member();
        if (members.size() == 1)
            return members[0];
        for (int i = 0; i < members.size(); ++i)
            if (members[i].offset() == srcMember.offset())
                return members[i];
        const int srcSeqNr = srcObj.sequenceIndexOf(srcMember);
        assert(srcSeqNr >= 0); // should never happen, otherwise there is a bug
        for (int i = 0; i < members.size(); ++i) {
            const int dstSeqNr = dstObj.sequenceIndexOf(members[i]);
            if (dstSeqNr == srcSeqNr)
                return members[i];
        }
        return Member(); // give up!
    }
 
    void Archive::Syncer::syncMember(const Member& dstMember, const Member& srcMember) {
        assert(dstMember && srcMember);
        assert(dstMember.type() == srcMember.type());
        const Object dstObj = m_dst.m_allObjects[dstMember.uid()];
        const Object srcObj = m_src.m_allObjects[srcMember.uid()];
        syncObject(dstObj, srcObj);
    }
 
    // *************** 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);
    }

    void Exception::PrintMessage() const {
        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