SessionXML.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/Model/Model/SessionXML.cpp
//! @brief     Implements reader and writer classes for SessionModel
//!
//! @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/Model/Model/SessionXML.h"
#include "GUI/Model/BaseItem/GroupItem.h"
#include "GUI/Model/Model/SessionModel.h"
#include "GUI/Model/Sample/MaterialItem.h"
#include "GUI/Support/Data/SessionFlags.h"
#include "GUI/Support/Data/SessionItemTags.h"
#include "GUI/Support/XML/UtilXML.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 report_error(MessageService* messageService, SessionModel* model, const QString& message)
{
    if (!messageService)
        throw Error(QString("Warning: ") + message);
    messageService->addWarning(model, message);
}
 
SessionItem* createItem(SessionItem* parent, const QString& modelType, const QString& tag)
{
    ASSERT(parent);
    if (parent->hasModelType<GroupItem>()) {
        if (const auto* groupItem = dynamic_cast<const GroupItem*>(parent))
            return groupItem->getItemOfType(modelType);
        return nullptr;
    }
    if (parent->sessionItemTags()->isSingleItemTag(tag))
        return parent->getItem(tag);
    try {
        return parent->model()->insertNewItem(modelType, parent, -1, tag);
    } catch (const std::exception&) {
        return nullptr; // error will be reported later
    }
}
 
} // namespace
 
 
void GUI::Session::XML::writeModel(QXmlStreamWriter* writer, SessionItem* modelRootItem)
{
    ASSERT(writer);
    ASSERT(modelRootItem);
    writer->writeStartElement(modelRootItem->model()->getModelTag());
 
    writeItemAndChildItems(writer, modelRootItem);
 
    writer->writeEndElement(); // m_model_tag
}
 
void GUI::Session::XML::writeItemAndChildItems(QXmlStreamWriter* writer, const SessionItem* item)
{
    ASSERT(item);
    if (item->parentItem()) {
        writer->writeStartElement(ItemTag);
        writer->writeAttribute(ModelTypeAttribute, item->modelType());
        QString tag = item->parentItem()->tagFromItem(item);
        writer->writeAttribute(Tags::TagAttribute, tag);
        writer->writeAttribute(Tags::DisplayNameAttribute,
                               item->roleProperty(SessionFlags::DisplayNameRole).toString());
        for (int role : item->getRoles()) {
            if (role == Qt::DisplayRole || role == Qt::EditRole)
                writeVariant(writer, item->value(), role);
        }
    }
 
    for (auto* child : item->children())
        if (item->allowWritingChildToXml(child))
            writeItemAndChildItems(writer, child);
 
    QByteArray a = item->serializeBinaryData();
    if (!a.isEmpty()) {
        writer->writeStartElement(Tags::BinaryData);
        writer->writeAttribute(XML::Version, "1");
        writer->writeCharacters(a.toBase64());
        writer->writeEndElement();
    }
 
    QString nonSessionItemContent;
    QXmlStreamWriter nonSessionItemStream(&nonSessionItemContent);
    nonSessionItemStream.writeStartElement(Tags::NonSessionItemData); // for following writeAttrib
    const auto sizeBefore = nonSessionItemContent.size();
    item->writeNonSessionItems(&nonSessionItemStream);
    if (sizeBefore != nonSessionItemContent.size()) {
        writer->writeStartElement(Tags::NonSessionItemData);
        item->writeNonSessionItems(writer);
        writer->writeEndElement();
    }
 
    if (item->parentItem())
        writer->writeEndElement(); // ItemTag
}
 
void GUI::Session::XML::readItems(QXmlStreamReader* reader, SessionItem* parent, QString topTag,
                                  MessageService* messageService)
{
    bool legacyDistributionFound = false;
    ASSERT(reader);
    ASSERT(parent);
    const QString start_type = parent->model()->getModelTag();
    while (!reader->atEnd()) {
        reader->readNext();
        if (reader->isStartElement()) {
            if (reader->name() == XML::ItemTag) {
                const QString model_type =
                    reader->attributes().value(Tags::ModelTypeAttribute).toString();
 
                if (model_type == "ParticleDistribution") {
                    if (!legacyDistributionFound) {
                        QString message(
                            "This file contains particle distributions in the sample. Elements of "
                            "this type are not supported any more. Reading the file will be "
                            "continued as much as possible, but you should review the sample.");
 
                        report_error(messageService, parent->model(), message);
                    }
                    legacyDistributionFound = true;
                    reader->skipCurrentElement();
                    continue;
                }
 
                QString tag = reader->attributes().value(Tags::TagAttribute).toString();
                QString displayName =
                    reader->attributes().value(Tags::DisplayNameAttribute).toString();
 
                if (!topTag.isEmpty()) {
                    // to handle copying of item to another parent
                    tag = topTag;
                    topTag.clear();
                }
                auto* newItem = createItem(parent, model_type, tag);
                if (!newItem) {
                    QString message = QString("Error while parsing XML. Can't create item of "
                                              "modelType '%1' for tag '%2', parent '%3'")
                                          .arg(model_type, tag, parent->itemName());
                    report_error(messageService, parent->model(), message);
                    // risky attempt to recover the rest of the project
                    reader->skipCurrentElement();
                } else {
                    parent = newItem;
                    parent->setDisplayName(displayName);
                }
                ASSERT(reader->name() == ItemTag);
            } else if (reader->name() == ParameterTag) {
                readProperty(reader, parent);
                gotoEndElementOfTag(reader, ParameterTag);
            } else if (reader->name() == Tags::BinaryData) {
                if (reader->attributes().value(XML::Version).toInt() == 1) {
                    QString valueAsBase64 =
                        reader->readElementText(QXmlStreamReader::SkipChildElements);
                    const auto data = QByteArray::fromBase64(
                        valueAsBase64.toLatin1()); // #baimport add a unit test for this!
                    parent->deserializeBinaryData(data);
                } else
                    throw DeserializationException::tooNew();
                gotoEndElementOfTag(reader, Tags::BinaryData);
            } else if (reader->name() == Tags::NonSessionItemData) {
                parent->readNonSessionItems(reader);
                gotoEndElementOfTag(reader, Tags::NonSessionItemData);
            }
        } else if (reader->isEndElement()) {
            if (reader->name() == XML::ItemTag && parent)
                parent = parent->parentItem();
            if (reader->name() == start_type)
                break;
        }
    }
}
 
QString GUI::Session::XML::readProperty(QXmlStreamReader* reader, SessionItem* item)
{
    ASSERT(reader);
    const QString parameter_name =
        reader->attributes().value(Tags::ParameterNameAttribute).toString();
    const QString parameter_type =
        reader->attributes().value(Tags::ParameterTypeAttribute).toString();
    const int role = reader->attributes().value(Tags::ParameterRoleAttribute).toInt();
 
    if (!item)
        throw Error(
            QString("Attempt to set property '%1' for non existing item").arg(parameter_name));
 
    QVariant variant;
    if (parameter_type == "double") {
        double parameter_value =
            reader->attributes().value(Tags::ParameterValueAttribute).toDouble();
        variant = parameter_value;
    } else if (parameter_type == "int") {
        int parameter_value = reader->attributes().value(Tags::ParameterValueAttribute).toInt();
        variant = parameter_value;
    } else if (parameter_type == "uint") {
        unsigned parameter_value =
            reader->attributes().value(Tags::ParameterValueAttribute).toUInt();
        variant = parameter_value;
    } else if (parameter_type == "bool") {
        bool parameter_value = reader->attributes().value(Tags::ParameterValueAttribute).toInt();
        variant = parameter_value;
    } else if (parameter_type == "QString") {
        QString parameter_value =
            reader->attributes().value(Tags::ParameterValueAttribute).toString();
        variant = parameter_value;
    } else if (parameter_type == "QColor") {
        QString parameter_value =
            reader->attributes().value(Tags::ParameterValueAttribute).toString();
        variant = QColor(parameter_value);
    } else if (parameter_type == "ExternalProperty") {
        const bool isMaterialItemColor =
            item->parentItem() != nullptr && dynamic_cast<MaterialItem*>(item->parentItem());
 
        if (isMaterialItemColor) {
            // This handles legacy XML files for MaterialItem:
            // In former times, the color of a MaterialItem was held as an "ExternalProperty". This
            // has been changed to a simple QColor property => use only the color value of the
            // "ExternalProperty" and store it as QColor in the variant
            const QString colorName =
                reader->attributes().value(Tags::ExternalPropertyColorAtt).toString();
            variant = QColor(colorName);
        } else {
            // This handles legacy XML files for items referring to a material:
            // In former times, the material in e.g. a ParticleItem was held as an
            // "ExternalProperty". This has been changed to the material's identifier only (as
            // QString)
            // => use only the identifier value of the "ExternalProperty" and store it as QString in
            // the variant
            const QString identifier =
                reader->attributes().value(Tags::ExternalPropertyIdentifierAtt).toString();
            variant = identifier;
        }
    } else if (parameter_type == "ComboProperty") {
        QString selections = reader->attributes().value(Tags::ParameterValueAttribute).toString();
        QString values = reader->attributes().value(Tags::ParameterExtAttribute).toString();
 
        ComboProperty combo_property;
        combo_property.setStringOfValues(values);
        combo_property.setStringOfSelections(selections);
 
        variant = combo_property.variant();
    } else {
        QString message = QString("SessionModel::readProperty: parameter type not supported '"
                                  + parameter_type + "'");
        throw Error(message);
    }
 
    if (variant.isValid())
        item->setRoleProperty(role, variant);
 
    return parameter_name;
}