Serialize.h

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/Support/XML/Serialize.h
//! @brief     Defines class Streamer
//!
//! @homepage  http://www.bornagainproject.org
//! @license   GNU General Public License v3 or higher (see COPYING)
//! @copyright Forschungszentrum Jülich GmbH 2021
//! @authors   Scientific Computing Group at MLZ (see CITATION, AUTHORS)
//
//  ************************************************************************************************
 
#ifndef BORNAGAIN_GUI_SUPPORT_XML_SERIALIZE_H
#define BORNAGAIN_GUI_SUPPORT_XML_SERIALIZE_H
 
#include "GUI/Support/XML/Streamer.h"
#include <memory>
 
//! Functions to serialize various data types.
//!
//! Serialization means writing to or reading from an XML stream.
//!
//! This namespace is spread over several source files
//! in order to keep include dependencies unidirectional.
 
namespace Serialize {
 
void rwValue(Streamer& s, const QString& tag, bool& val);
void rwValue(Streamer& s, const QString& tag, int& val);
void rwValue(Streamer& s, const QString& tag, double& val);
void rwValue(Streamer& s, const QString& tag, QString& val);
void rwValue(Streamer& s, const QString& tag, QColor& col);
void rwValue(Streamer& s, const QString& tag, QByteArray& val);
void rwValue(Streamer& s, const QString& tag, R3& val);
 
//! Serializes an item from a class that provides the function `void serialize(Streamer&)`.
template <typename T>
void rwClass(Streamer& s, const QString& tag, T& t);
 
//! Serializes part of an items that belongs to a given base class.
template <typename BaseClass>
void rwBaseClass(Streamer& s, const QString& tag, BaseClass* p);
 
//! Serializes a list of items of known and fixed type.
//! Passes optional arguments to the constructor.
template <typename T, typename... Args>
void rwVector(Streamer& s, const QString& tag, QVector<T>& vec, Args... argsForConstructor);
 
//! Serializes a list of items from a class hierarchy described by a catalog.
//! Passes optional arguments to the constructor.
template <typename Catalog, typename... Args>
void rwCatalogized(Streamer& s, const QString& tag, QVector<typename Catalog::CatalogedType*>& vec,
                   Args... argsForConstructor);
 
//! Serializes an optional item of known type.
//! Passes optional arguments to the constructor.
template <typename ItemClass, typename... ArgsForConstructor>
void rwOptional(Streamer& s, const QString& tag, std::unique_ptr<ItemClass>& up,
                ArgsForConstructor... argsForConstructor);
 
//! Serializes an optional item of known type that needs an initializer.
//!
//! The initializer will be called after creation and before de-serialization
template <typename ItemClass>
void rwInitializable(Streamer& s, const QString& tag, std::unique_ptr<ItemClass>& up,
                     const std::function<void(ItemClass*)>& initializer);
 
} // namespace Serialize
 
//  ************************************************************************************************
//  Templates implementation
//  ************************************************************************************************
 
template <typename T>
void Serialize::rwClass(Streamer& s, const QString& tag, T& t)
{
    s.start(tag);
    t.serialize(s);
    s.finish(tag);
}
 
template <typename BaseClass>
void Serialize::rwBaseClass(Streamer& s, const QString& tag, BaseClass* p)
{
    s.start(tag);
    p->BaseClass::serialize(s);
    s.finish(tag);
}
 
template <typename T, typename... Args>
void Serialize::rwVector(Streamer& s, const QString& tag, QVector<T>& vec,
                         Args... argsForConstructor)
{
    if (QXmlStreamWriter* w = s.xmlWriter()) {
        w->writeStartElement(tag);
        w->writeAttribute("n", QString::number(vec.size()));
        int i = 0;
        for (auto* p : vec)
            Serialize::rwClass(s, "E" + QString::number(i++), *p);
        w->writeEndElement();
    } else if (QXmlStreamReader* r = s.xmlReader()) {
        r->readNextStartElement();
        s.assertCurrentTag(tag);
        const int n = r->attributes().value("n").toInt();
        for (int i = 0; i < n; i++) {
            vec << new typename std::remove_pointer<T>::type(argsForConstructor...);
            Serialize::rwClass(s, "E" + QString::number(i), *vec.last());
        }
        s.gotoEndElementOfTag(tag);
    }
}
 
template <typename Catalog, typename... Args>
void Serialize::rwCatalogized(Streamer& s, const QString& tag,
                              QVector<typename Catalog::CatalogedType*>& vec,
                              Args... argsForConstructor)
{
    if (QXmlStreamWriter* w = s.xmlWriter()) {
        w->writeStartElement(tag);
        w->writeAttribute("n", QString::number(vec.size()));
        int i = 0;
        for (auto* p : vec) {
            s.write<Catalog>("E" + QString::number(i++), p);
        }
        w->writeEndElement();
    } else if (QXmlStreamReader* r = s.xmlReader()) {
        r->readNextStartElement();
        s.assertCurrentTag(tag);
        const int n = r->attributes().value("n").toInt();
        for (int i = 0; i < n; i++) {
            typename Catalog::CatalogedType* p = nullptr;
            s.read<Catalog>("E" + QString::number(i), p, argsForConstructor...);
            vec << p;
        }
        s.gotoEndElementOfTag(tag);
    }
}
 
template <typename ItemClass, typename... ArgsForConstructor>
void Serialize::rwOptional(Streamer& s, const QString& tag, std::unique_ptr<ItemClass>& up,
                           ArgsForConstructor... argsForConstructor)
{
    if (QXmlStreamWriter* w = s.xmlWriter()) {
        w->writeStartElement(tag);
        w->writeAttribute("valid", up ? "1" : "0");
        if (up)
            up->serialize(s);
        w->writeEndElement();
    } else if (QXmlStreamReader* r = s.xmlReader()) {
        s.gotoStartElementOfTag(tag);
        const bool valid = r->attributes().value("valid").toUInt() > 0;
        if (valid) {
            up.reset(new ItemClass(argsForConstructor...));
            up->serialize(s);
        } else
            up.reset();
        s.gotoEndElementOfTag(tag);
    }
}
 
template <typename ItemClass>
void Serialize::rwInitializable(Streamer& s, const QString& tag, std::unique_ptr<ItemClass>& up,
                                const std::function<void(ItemClass*)>& initializer)
{
    if (QXmlStreamWriter* w = s.xmlWriter()) {
        w->writeStartElement(tag);
        w->writeAttribute("valid", up ? "1" : "0");
        if (up)
            up->serialize(s);
        w->writeEndElement();
    } else if (QXmlStreamReader* r = s.xmlReader()) {
        s.gotoStartElementOfTag(tag);
        const bool valid = r->attributes().value("valid").toUInt() > 0;
        if (valid) {
            up.reset(new ItemClass());
            if (initializer)
                initializer(up.get());
            up->serialize(s);
        } else
            up.reset();
        s.gotoEndElementOfTag(tag);
    }
}
 
#endif // BORNAGAIN_GUI_SUPPORT_XML_SERIALIZE_H