UtilXML.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/Support/XML/UtilXML.cpp
//! @brief     Implements
//!
//! @homepage  http://www.bornagainproject.org
//! @license   GNU General Public License v3 or higher (see COPYING)
//! @copyright Forschungszentrum Jülich GmbH 2018
//! @authors   Scientific Computing Group at MLZ (see CITATION, AUTHORS)
//
//  ************************************************************************************************
 
#include "GUI/Support/XML/UtilXML.h"
#include "Base/Util/Assert.h"
#include "GUI/Util/ComboProperty.h"
#include "GUI/Util/DeserializationException.h"
#include "GUI/Util/Error.h"
#include "GUI/Util/MessageService.h"
#include <QColor>
#include <QUuid>
#include <QXmlStreamWriter>
 
namespace {
 
void assertCurrentTag(QXmlStreamReader* reader, const QString& expectedTag)
{
 
    if (reader->name() != expectedTag) {
#ifdef _DEBUG
        // to simplify debugging: what is the current tag
        QString foundTag = reader->name().toString();
        Q_UNUSED(foundTag);
#endif
        throw DeserializationException::streamError();
    }
}
 
void assertCurrentToken(QXmlStreamReader* reader, QXmlStreamReader::TokenType token)
{
    if (reader->tokenType() != token)
        throw DeserializationException::streamError();
}
 
} // namespace
 
 
void GUI::Session::XML::gotoEndElementOfTag(QXmlStreamReader* reader, const QString& tag)
{
    ASSERT(reader);
    if (reader->name() != tag) {
        if (!reader->isEndElement())
            reader->skipCurrentElement();
        reader->skipCurrentElement();
    }
    assertCurrentTag(reader, tag);
    if (!reader->isEndElement())
        reader->skipCurrentElement();
 
    assertCurrentToken(reader, QXmlStreamReader::EndElement);
    assertCurrentTag(reader, tag);
}
 
void GUI::Session::XML::writeAttribute(QXmlStreamWriter* writer, const QString& attributeName,
                                       const QVariant& variant)
{
    ASSERT(writer);
    ASSERT(variant.isValid());
 
    if (variant.type() == QVariant::Double)
        writeAttribute(writer, attributeName, variant.toDouble());
    else if (variant.type() == QVariant::Int)
        writeAttribute(writer, attributeName, variant.toInt());
    else if (variant.type() == QVariant::UInt)
        writeAttribute(writer, attributeName, variant.toUInt());
    else if (variant.type() == QVariant::Bool)
        writer->writeAttribute(attributeName, QString::number(variant.toBool()));
    else if (variant.type() == QVariant::String)
        writer->writeAttribute(attributeName, variant.toString());
    else if (variant.type() == QVariant::Color) {
        const auto col = variant.value<QColor>();
        const QString tcol = col.isValid() ? col.name(QColor::HexArgb) : "";
        writer->writeAttribute(attributeName, tcol);
    } else if (QString(variant.typeName()) == "ComboProperty") {
        auto combo = variant.value<ComboProperty>();
        writer->writeAttribute(attributeName, combo.stringOfSelections());
        writer->writeAttribute(Tags::ParameterExtAttribute, combo.stringOfValues());
    } else
        throw Error("GUI::Session::XML::writeVariant: Parameter type not supported "
                    + QString(variant.typeName()));
}
 
void GUI::Session::XML::writeAttribute(QXmlStreamWriter* writer, const QString& attributeBaseName,
                                       const R3& vec)
{
    writeAttribute(writer, attributeBaseName + "X", vec.x());
    writeAttribute(writer, attributeBaseName + "Y", vec.y());
    writeAttribute(writer, attributeBaseName + "Z", vec.z());
}
 
void GUI::Session::XML::writeAttribute(QXmlStreamWriter* writer, const QString& attributeBaseName,
                                       const complex_t& c)
{
    writeAttribute(writer, attributeBaseName + "Re", c.real());
    writeAttribute(writer, attributeBaseName + "Im", c.imag());
}
 
void GUI::Session::XML::writeAttribute(QXmlStreamWriter* writer, const QString& attributeName,
                                       double d)
{
    writer->writeAttribute(attributeName, d == 0.0 ? "0" : QString::number(d, 'e', 12));
}
 
void GUI::Session::XML::writeAttribute(QXmlStreamWriter* writer, const QString& attributeName,
                                       int d)
{
    writer->writeAttribute(attributeName, QString::number(d));
}
 
void GUI::Session::XML::writeAttribute(QXmlStreamWriter* writer, const QString& attributeName,
                                       unsigned d)
{
    writer->writeAttribute(attributeName, QString::number(d));
}
 
void GUI::Session::XML::writeUid(QXmlStreamWriter* writer, const QString& id)
{
    writer->writeAttribute(Tags::Id, id);
}
 
void GUI::Session::XML::writeUid(QXmlStreamWriter* writer, const QUuid& id)
{
    writer->writeAttribute(Tags::Id, id.toString());
}
 
void GUI::Session::XML::writeVariant(QXmlStreamWriter* writer, QVariant variant, int role)
{
    ASSERT(writer);
    if (variant.isValid()) {
        writer->writeStartElement(Tags::ParameterTag);
        writer->writeAttribute(Tags::ParameterTypeAttribute, variant.typeName());
        writer->writeAttribute(Tags::ParameterRoleAttribute, QString::number(role));
        writeAttribute(writer, Tags::ParameterValueAttribute, variant);
        writer->writeEndElement(); // end ParameterTag
    }
}
 
bool GUI::Session::XML::readBoolAttribute(QXmlStreamReader* reader, const QString& attributeName)
{
    return reader->attributes().value(attributeName).toUInt() != 0;
}
 
unsigned GUI::Session::XML::readUIntAttribute(QXmlStreamReader* reader,
                                              const QString& attributeName)
{
    return reader->attributes().value(attributeName).toUInt();
}
 
void GUI::Session::XML::readAttribute(QXmlStreamReader* reader, const QString& attributeName,
                                      QString* s)
{
    *s = reader->attributes().value(attributeName).toString();
}
 
void GUI::Session::XML::readAttribute(QXmlStreamReader* reader, const QString& attributeName,
                                      QColor* c)
{
    const QString parameter_value = reader->attributes().value(attributeName).toString();
    *c = QColor(parameter_value);
}
 
void GUI::Session::XML::readAttribute(QXmlStreamReader* reader, const QString& attributeBaseName,
                                      R3* vec)
{
    double x, y, z;
    readAttribute(reader, attributeBaseName + "X", &x);
    readAttribute(reader, attributeBaseName + "Y", &y);
    readAttribute(reader, attributeBaseName + "Z", &z);
    *vec = {x, y, z};
}
 
void GUI::Session::XML::readAttribute(QXmlStreamReader* reader, const QString& attributeBaseName,
                                      complex_t* c)
{
    double r, i;
    readAttribute(reader, attributeBaseName + "Re", &r);
    readAttribute(reader, attributeBaseName + "Im", &i);
    c->real(r);
    c->imag(i);
}
 
void GUI::Session::XML::readAttribute(QXmlStreamReader* reader, const QString& attributeName,
                                      double* d)
{
    *d = reader->attributes().value(attributeName).toDouble();
}
 
void GUI::Session::XML::assertExpectedTag(QXmlStreamReader* reader, const QString& expectedTag)
{
    if (reader->name() != expectedTag) {
#ifdef _DEBUG
        // to simplify debugging: what is the current tag
        QString foundTag = reader->name().toString();
        Q_UNUSED(foundTag);
#endif
        throw DeserializationException::streamError();
    }
}