DAXMLFileInterface.h

#ifndef DAXMLFILEINTERFACE_H
#define DAXMLFILEINTERFACE_H
#include <QString>
#include "DAUtilsAPI.h"
// #include "DAStringUtil.h"
#include <QPen>
#include <QFont>
#include <QBrush>
#include <QDomElement>
#include <QPointF>
#include <QVariant>
#include <QIODevice>
#include <QVector3D>
#include <QVersionNumber>
#include "da_qstring_cast.h"
class QDomDocument;
#ifndef DAXMLFILEINTERFACE_POD_NUMBER_H
#define DAXMLFILEINTERFACE_TYPE_MAKE_H(pod_type)                                                                       \
    static QDomElement makeElement(const pod_type& v, const QString& tagName, QDomDocument* doc);                      \
    static bool loadElement(pod_type& p, const QDomElement* ele);
#endif
namespace DA
{
 
class DAUTILS_API DAXMLFileInterface
{
public:
    DAXMLFileInterface();
    virtual ~DAXMLFileInterface();
    // 保存到xml中
    virtual bool saveToXml(QDomDocument* doc, QDomElement* parentElement, const QVersionNumber& ver) const = 0;
    virtual bool loadFromXml(const QDomElement* parentElement, const QVersionNumber& ver)                  = 0;
 
public:
 
    DAXMLFILEINTERFACE_TYPE_MAKE_H(short)
    DAXMLFILEINTERFACE_TYPE_MAKE_H(unsigned short)
    DAXMLFILEINTERFACE_TYPE_MAKE_H(int)
    DAXMLFILEINTERFACE_TYPE_MAKE_H(unsigned int)
    DAXMLFILEINTERFACE_TYPE_MAKE_H(long)
    DAXMLFILEINTERFACE_TYPE_MAKE_H(unsigned long)
    DAXMLFILEINTERFACE_TYPE_MAKE_H(long long)
    DAXMLFILEINTERFACE_TYPE_MAKE_H(unsigned long long)
    DAXMLFILEINTERFACE_TYPE_MAKE_H(double)
    DAXMLFILEINTERFACE_TYPE_MAKE_H(float)
    DAXMLFILEINTERFACE_TYPE_MAKE_H(std::string)
 
    // 标准保存—— QString
    DAXMLFILEINTERFACE_TYPE_MAKE_H(QString)
    DAXMLFILEINTERFACE_TYPE_MAKE_H(QColor)
    DAXMLFILEINTERFACE_TYPE_MAKE_H(QRect)
    DAXMLFILEINTERFACE_TYPE_MAKE_H(QRectF)
    DAXMLFILEINTERFACE_TYPE_MAKE_H(QPoint)
    DAXMLFILEINTERFACE_TYPE_MAKE_H(QPointF)
    DAXMLFILEINTERFACE_TYPE_MAKE_H(QPen)
    DAXMLFILEINTERFACE_TYPE_MAKE_H(QBrush)
    DAXMLFILEINTERFACE_TYPE_MAKE_H(QFont)
    DAXMLFILEINTERFACE_TYPE_MAKE_H(QVector3D)
    DAXMLFILEINTERFACE_TYPE_MAKE_H(QVariant)
 
 
    // stl类型 这是针对stl类型的xml保存
    template< typename std_container_like >
    static QDomElement makeElement(const std_container_like& v, const QString& tagName, QDomDocument* doc);
    template< typename std_container_like >
    static bool loadElement(std_container_like& v, const QDomElement* ele);
 
 
    // 系统信息保存到xml
    static QDomElement makeSysInfoElement(const QString& tagName, QDomDocument* doc);
 
    // 在parent下，插入一个tag，tag下包含文字text
    static void appendElementWithText(QDomElement& parent, const QString& tagName, const QString& text, QDomDocument* doc);
};
 
#ifndef DAXMLELEMENTSERIALIZATION_INOUT_H
#define DAXMLELEMENTSERIALIZATION_INOUT_H(type)                                                                        \
    DAXMLElementSerialization& operator<<(const type& t);                                                              \
    DAXMLElementSerialization& operator>>(type& t);
#endif
 
class DAUTILS_API DAXMLElementSerialization
{
public:
    DAXMLElementSerialization(QDomElement* parentElement);
    ~DAXMLElementSerialization();
    // clang-format off
    DAXMLELEMENTSERIALIZATION_INOUT_H(short) 
    DAXMLELEMENTSERIALIZATION_INOUT_H(unsigned short)
    DAXMLELEMENTSERIALIZATION_INOUT_H(int)
    DAXMLELEMENTSERIALIZATION_INOUT_H(unsigned int)
    DAXMLELEMENTSERIALIZATION_INOUT_H(long)
    DAXMLELEMENTSERIALIZATION_INOUT_H(unsigned long) 
    DAXMLELEMENTSERIALIZATION_INOUT_H(long long)
    DAXMLELEMENTSERIALIZATION_INOUT_H(unsigned long long) 
    DAXMLELEMENTSERIALIZATION_INOUT_H(double)
    DAXMLELEMENTSERIALIZATION_INOUT_H(float) 
    DAXMLELEMENTSERIALIZATION_INOUT_H(std::string)
    DAXMLELEMENTSERIALIZATION_INOUT_H(QString)
    DAXMLELEMENTSERIALIZATION_INOUT_H(QColor)
    DAXMLELEMENTSERIALIZATION_INOUT_H(QRect)
    DAXMLELEMENTSERIALIZATION_INOUT_H(QRectF) 
    DAXMLELEMENTSERIALIZATION_INOUT_H(QPoint)
    DAXMLELEMENTSERIALIZATION_INOUT_H(QPointF) 
    DAXMLELEMENTSERIALIZATION_INOUT_H(QPen)
    DAXMLELEMENTSERIALIZATION_INOUT_H(QBrush) 
    DAXMLELEMENTSERIALIZATION_INOUT_H(QFont)
    DAXMLELEMENTSERIALIZATION_INOUT_H(QVector3D) 
    DAXMLELEMENTSERIALIZATION_INOUT_H(QVariant)
    // clang-format on
private:
    QDomElement* mParentElement { nullptr };
    QDomElement mCurrentElement;
};
 
template< typename std_container_like >
QDomElement DAXMLFileInterface::makeElement(const std_container_like& v, const QString& tagName, QDomDocument* doc)
{
    // using T = std_container_like::value_type;
    auto ele = doc->createElement(tagName);
    ele.setAttribute("class", QString("%1").arg(typeid(std_container_like).name()));
    ele.setAttribute("size", v.size());
    for (const auto& r : v) {
        auto eleR     = doc->createElement("r");
        auto textNode = doc->createTextNode(toQString(r));
        eleR.appendChild(textNode);
        ele.appendChild(eleR);
    }
    return ele;
}
 
template< typename std_container_like >
bool DAXMLFileInterface::loadElement(std_container_like& v, const QDomElement* ele)
{
    using T   = typename std_container_like::value_type;
    bool isok = false;
    auto size = ele->attribute("size").toUInt(&isok);
    if (!isok) {
        return false;
    }
    v.resize(size);
    auto cns = ele->childNodes();
    for (int i = 0; i < cns.size(); ++i) {
        auto rEle = cns.at(i).toElement();
        if (rEle.tagName() != "r") {
            continue;
        }
        T r;
        if (!fromQString(rEle.text(), r)) {
            continue;
        }
 
        v[ i ] = r;
    }
    return true;
}
 
DAUTILS_API QString variantToString(const QVariant& var);
 
DAUTILS_API QVariant stringToVariant(const QString& var, const QString& typeName);
 
DAUTILS_API QString doubleToString(double a);
template< typename T >
QString converVariantToBase64String(const QVariant& var)
{
    if (var.canConvert< T >()) {
        QByteArray byte;
        QDataStream st(&byte, QIODevice::ReadWrite);
        T ba = var.value< T >();
        st << ba;
        return (QString(byte.toBase64()));
    }
    return (QString());
}
 
template< typename T >
QVariant converBase64StringToVariant(const QString& base64)
{
    QByteArray byte = QByteArray::fromBase64(base64.toLocal8Bit());
    QDataStream st(&byte, QIODevice::ReadWrite);
    T ba;
 
    st >> ba;
    return (QVariant::fromValue(ba));
}
 
// 获取qreal值
bool DAUTILS_API getStringIntValue(const QString& valuestring, int& v);
bool DAUTILS_API getStringUIntValue(const QString& valuestring, unsigned int& v);
bool DAUTILS_API getStringULongLongValue(const QString& valuestring, unsigned long long& v);
bool DAUTILS_API getStringRealValue(const QString& valuestring, qreal& v);
bool DAUTILS_API getStringBoolValue(const QString& valuestring);
 
}
 
#endif  // DAXMLFILEINTERFACE_H