CPrimitiveTypesSerializer.h

Go to the documentation of this file.

/********************************************************************************
**  This file is part of the ICF Framework. Copyright (C) Witold Gantzke & Kirill Lepskiy
**  ICF Framework may be used under the terms of the LGPL License v. 2.1 by the Free Software Foundation.
********************************************************************************/
 
#pragma once
 
 
// STL includes
#include <typeinfo>
 
// Qt includes
#include <QtCore/QDateTime>
#include <QtCore/QPointF>
#include <QtCore/QMetaObject>
#include <QtCore/QMetaEnum>
 
// ICF includes
#include <istd/TRange.h>
#include <istd/TRanges.h>
#include <istd/TIndex.h>
#include <iser/IArchive.h>
#include <iser/CArchiveTag.h>
 
 
namespace iser
{
 
 
class CPrimitiveTypesSerializer
{
public:
    static bool SerializeRange(iser::IArchive& archive, istd::CRange& range);
 
    static bool SerializeIntRange(iser::IArchive& archive, istd::CIntRange& range);
 
    static bool SerializeRanges(iser::IArchive& archive, istd::CRanges& ranges);
 
    static bool SerializeIntRanges(iser::IArchive& archive, istd::CIntRanges& ranges);
 
    static bool SerializeDateTime(iser::IArchive& archive, QDateTime& dateTime);
 
    static bool SerializeDate(iser::IArchive& archive, QDate& date);
 
    template <int Dimensions>
    static bool SerializeIndex(iser::IArchive& archive, istd::TIndex<Dimensions>& index);
 
    static bool SerializeQPointF(iser::IArchive& archive, QPointF& point);
 
    template <typename ContainterType>
    static bool SerializeSimpleContainer(
                iser::IArchive& archive,
                ContainterType& container,
                const iser::CArchiveTag& elementsTag,
                const iser::CArchiveTag& elementTag);
 
    template <typename ContainterType>
    static bool SerializeContainer(
        iser::IArchive& archive,
        ContainterType& container,
        const iser::CArchiveTag& elementsTag,
        const iser::CArchiveTag& elementTag);
 
    template <typename EnumType, QByteArray (*ToString)(EnumType), bool (*FromString)(const QByteArray&, EnumType&)>
    static bool SerializeEnum(
                iser::IArchive& archive,
                EnumType& enumValue);
 
    template <typename EnumType>
    static bool SerializeEnum(
                iser::IArchive& archive,
                EnumType& enumValue,
                const QObject* objectPtr);
};
 
 
// public template methods
 
template <int Dimensions>
bool CPrimitiveTypesSerializer::SerializeIndex(iser::IArchive& archive, istd::TIndex<Dimensions>& index)
{
    bool retVal = true;
 
    for (int i = 0; i < Dimensions; ++i){
        retVal = retVal && archive.Process(index[i]);
    }
 
    return retVal;
}
 
 
template <typename ContainerType>
bool CPrimitiveTypesSerializer::SerializeSimpleContainer(
        iser::IArchive& archive,
        ContainerType& container,
        const iser::CArchiveTag& elementsTag,
        const iser::CArchiveTag& elementTag)
{
    bool retVal = true;
 
    int elementsCount = container.count();
 
    retVal = retVal && archive.BeginMultiTag(elementsTag, elementTag, elementsCount);
    if (!retVal){
        return false;
    }
 
    if (archive.IsChanging()) {
        container.clear();
 
        for (int i = 0; i < elementsCount; ++i) {
            typename ContainerType::value_type element;
            retVal = retVal && archive.BeginTag(elementTag);
            retVal = retVal && archive.Process(element);
            retVal = retVal && archive.EndTag(elementTag);
 
            if (retVal) {
                container.push_back(element);
            }
        }
    }
    else{
        for (int i = 0; i < elementsCount; ++i) {
            typename ContainerType::value_type element = container[i];
 
            retVal = retVal && archive.BeginTag(elementTag);
            retVal = retVal && archive.Process(element);
            retVal = retVal && archive.EndTag(elementTag);
        }
    }
 
    retVal = retVal && archive.EndTag(elementsTag);
 
    return retVal;
}
 
 
template <typename ContainerType>
bool CPrimitiveTypesSerializer::SerializeContainer(
    iser::IArchive& archive,
    ContainerType& container,
    const iser::CArchiveTag& elementsTag,
    const iser::CArchiveTag& elementTag)
{
    bool retVal = true;
 
    int elementsCount = container.count();
 
    retVal = retVal && archive.BeginMultiTag(elementsTag, elementTag, elementsCount);
    if (!retVal){
        return false;
    }
 
    if (archive.IsChanging()) {
        container.clear();
 
        for (int i = 0; i < elementsCount; ++i) {
            typename ContainerType::value_type element;
            retVal = retVal && archive.BeginTag(elementTag);
            retVal = retVal && element.Serialize(archive);
            retVal = retVal && archive.EndTag(elementTag);
 
            if (retVal) {
                container.push_back(element);
            }
        }
    }
    else{
        for (int i = 0; i < elementsCount; ++i) {
            typename ContainerType::value_type element = container[i];
 
            retVal = retVal && archive.BeginTag(elementTag);
            retVal = retVal && element.Serialize(archive);
            retVal = retVal && archive.EndTag(elementTag);
        }
    }
 
    retVal = retVal && archive.EndTag(elementsTag);
 
    return retVal;
}
 
 
template <typename EnumType, QByteArray (*ToString)(EnumType), bool (*FromString)(const QByteArray&, EnumType&)>
bool CPrimitiveTypesSerializer::SerializeEnum(
            iser::IArchive& archive,
            EnumType& enumValue)
{
    QByteArray enumValueAsText;
 
    bool retVal = true;
 
    // Try to get enumeration text generated by I_DECLARE_ENUM macro:
    if (enumValueAsText.isEmpty() && (ToString != nullptr)){
        enumValueAsText = ToString(enumValue);
    }
 
    // Enum value is defined in textual form:
    if (!enumValueAsText.isEmpty()){
        retVal = retVal && archive.Process(enumValueAsText);
        
        if (retVal && archive.IsChanging()){
            if (FromString != nullptr){
                retVal = FromString(enumValueAsText, enumValue);
            }
            else{
                retVal = false;
            }
        }
    }
    else{
        int value = enumValue;
 
        retVal = retVal && archive.Process(value);
 
        if (archive.IsChanging()){
            // TODO: check if the readed value is in range of the enum values!
            enumValue = EnumType(value);
        }
    }
 
    return retVal;
}
 
 
template <typename EnumType>
bool CPrimitiveTypesSerializer::SerializeEnum(
            iser::IArchive& archive,
            EnumType& enumValue,
            const QObject* objectPtr)
{
    QByteArray enumValueAsText;
    QMetaEnum foundEnumMeta;
 
    QString enumTypeName = typeid(EnumType).name();
    enumTypeName = enumTypeName.mid(enumTypeName.lastIndexOf(":") + 1);
 
    if (objectPtr != nullptr){
        const QMetaObject* metaObjectPtr = objectPtr->metaObject();
 
        // Iterate over all enums of the class:
        int enumeratorsCount = metaObjectPtr->enumeratorCount();
        for (int enumeratorIndex = 0; enumeratorIndex < enumeratorsCount; ++enumeratorIndex){
            QMetaEnum enumMeta = metaObjectPtr->enumerator(enumeratorIndex);
            QString enumName = enumMeta.name();
 
            if (enumTypeName == enumName){
                foundEnumMeta = enumMeta;
 
                // Find the enum value:
                int keysCount = enumMeta.keyCount();
                for (int keyIndex = 0; keyIndex < keysCount; ++keyIndex){
                
                    if (enumMeta.value(keyIndex) == enumValue){
                        enumValueAsText = enumMeta.valueToKey(keyIndex);
                        break;
                    }
                }
            }
        }
    }
 
    bool retVal = true;
 
    // Enum value is defined in textual form:
    if (!enumValueAsText.isEmpty()){
        retVal = retVal && archive.Process(enumValueAsText);
        
        if (retVal && archive.IsChanging()){
            Q_ASSERT(foundEnumMeta.isValid());
 
            enumValue = EnumType(foundEnumMeta.keyToValue(enumValueAsText.constData(), &retVal));
        }
    }
    else{
        int value = enumValue;
 
        retVal = retVal && archive.Process(value);
 
        if (archive.IsChanging()){
            // TODO: check if the readed value is in range of the enum values!
            enumValue = EnumType(value);
        }
    }
 
    return retVal;
}
 
 
#define I_SERIALIZE_FLAG(Enum, archive, flag) iser::CPrimitiveTypesSerializer::SerializeEnum<int, Enum##ToString, Enum##FromString>(archive, flag);
#define I_SERIALIZE_ENUM(Enum, archive, enumValue) iser::CPrimitiveTypesSerializer::SerializeEnum<Enum, ToString, FromString>(archive, enumValue);
 
 
} // namespace iser