AxesItems: upd r/w

GUI/Model/Device/AxesItems.cpp

@@ -17,7 +17,6 @@
 #include "GUI/Support/XML/UtilXML.h"
 
 namespace {
-
 namespace Tag {
 
 const QString IsVisible("IsVisible");
@@ -25,18 +24,11 @@ const QString Nbins("Nbins");
 const QString MinDeg("MinDeg");
 const QString MaxDeg("MaxDeg");
 const QString Title("Title");
-
+const QString BaseData("BaseData");
 const QString LockMinMax("LockMinMax");
 const QString LogScale("LogScale");
 
 } // namespace Tag
-
-namespace Attrib {
-
-const QString value("value");
-
-}
-
 } // namespace
 
 BasicAxisItem::BasicAxisItem(QObject* parent)
@@ -112,69 +104,72 @@ void BasicAxisItem::setVisible(bool b)
     emit axisVisibilityChanged();
 }
 
-void BasicAxisItem::writeTo(QXmlStreamWriter* writer) const
+void BasicAxisItem::writeTo(QXmlStreamWriter* w) const
 {
+    XML::writeAttribute(w, XML::Attrib::version, uint(1));
+
     // visibility
-    writer->writeStartElement(Tag::IsVisible);
-    XML::writeAttribute(writer, Attrib::value, m_visible);
-    writer->writeEndElement();
+    w->writeStartElement(Tag::IsVisible);
+    XML::writeAttribute(w, XML::Attrib::value, m_visible);
+    w->writeEndElement();
 
     // nbins
-    writer->writeStartElement(Tag::Nbins);
-    XML::writeAttribute(writer, Attrib::value, m_nbins);
-    writer->writeEndElement();
+    w->writeStartElement(Tag::Nbins);
+    XML::writeAttribute(w, XML::Attrib::value, m_nbins);
+    w->writeEndElement();
 
     // min
-    writer->writeStartElement(Tag::MinDeg);
-    XML::writeAttribute(writer, Attrib::value, m_minDeg);
-    writer->writeEndElement();
+    w->writeStartElement(Tag::MinDeg);
+    XML::writeAttribute(w, XML::Attrib::value, m_minDeg);
+    w->writeEndElement();
 
     // max
-    writer->writeStartElement(Tag::MaxDeg);
-    XML::writeAttribute(writer, Attrib::value, m_maxDeg);
-    writer->writeEndElement();
+    w->writeStartElement(Tag::MaxDeg);
+    XML::writeAttribute(w, XML::Attrib::value, m_maxDeg);
+    w->writeEndElement();
 
     // title
-    writer->writeStartElement(Tag::Title);
-    XML::writeAttribute(writer, Attrib::value, m_title);
-    writer->writeEndElement();
+    w->writeStartElement(Tag::Title);
+    XML::writeAttribute(w, XML::Attrib::value, m_title);
+    w->writeEndElement();
 }
 
-void BasicAxisItem::readFrom(QXmlStreamReader* reader)
+void BasicAxisItem::readFrom(QXmlStreamReader* r)
 {
-    while (reader->readNextStartElement())
-        readBasicTags(reader);
-}
+    const uint version = XML::readUIntAttribute(r, XML::Attrib::version);
+    Q_UNUSED(version)
 
-void BasicAxisItem::readBasicTags(QXmlStreamReader* reader)
-{
-    // visibility
-    if (reader->name() == Tag::IsVisible) {
-        XML::readAttribute(reader, Attrib::value, &m_visible);
-        XML::gotoEndElementOfTag(reader, Tag::IsVisible);
+    while (r->readNextStartElement()) {
+        QString tag = r->name().toString();
 
-        // nbins
-    } else if (reader->name() == Tag::Nbins) {
-        XML::readAttribute(reader, Attrib::value, &m_nbins);
-        XML::gotoEndElementOfTag(reader, Tag::Nbins);
+        // visibility?
+        if (tag == Tag::IsVisible) {
+            XML::readAttribute(r, XML::Attrib::value, &m_visible);
+            XML::gotoEndElementOfTag(r, tag);
 
-        // min
-    } else if (reader->name() == Tag::MinDeg) {
-        XML::readAttribute(reader, Attrib::value, &m_minDeg);
-        XML::gotoEndElementOfTag(reader, Tag::MinDeg);
+            // nbins
+        } else if (tag == Tag::Nbins) {
+            XML::readAttribute(r, XML::Attrib::value, &m_nbins);
+            XML::gotoEndElementOfTag(r, tag);
 
-        // max
-    } else if (reader->name() == Tag::MaxDeg) {
-        XML::readAttribute(reader, Attrib::value, &m_maxDeg);
-        XML::gotoEndElementOfTag(reader, Tag::MaxDeg);
+            // min
+        } else if (tag == Tag::MinDeg) {
+            XML::readAttribute(r, XML::Attrib::value, &m_minDeg);
+            XML::gotoEndElementOfTag(r, tag);
 
-        // title
-    } else if (reader->name() == Tag::Title) {
-        XML::readAttribute(reader, Attrib::value, &m_title);
-        XML::gotoEndElementOfTag(reader, Tag::Title);
+            // max
+        } else if (tag == Tag::MaxDeg) {
+            XML::readAttribute(r, XML::Attrib::value, &m_maxDeg);
+            XML::gotoEndElementOfTag(r, tag);
 
-    } else
-        reader->skipCurrentElement();
+            // title
+        } else if (tag == Tag::Title) {
+            XML::readAttribute(r, XML::Attrib::value, &m_title);
+            XML::gotoEndElementOfTag(r, tag);
+
+        } else
+            r->skipCurrentElement();
+    }
 }
 
 // ---------------------------------------------------------------------------------------------- //
@@ -186,39 +181,51 @@ AmplitudeAxisItem::AmplitudeAxisItem(QObject* parent)
 {
 }
 
-void AmplitudeAxisItem::writeTo(QXmlStreamWriter* writer) const
+void AmplitudeAxisItem::writeTo(QXmlStreamWriter* w) const
 {
-    BasicAxisItem::writeTo(writer);
+    XML::writeAttribute(w, XML::Attrib::version, uint(1));
+
+    // parameters from base class
+    w->writeStartElement(Tag::BaseData);
+    BasicAxisItem::writeTo(w);
+    w->writeEndElement();
 
     // lock min max
-    writer->writeStartElement(Tag::LockMinMax);
-    XML::writeAttribute(writer, Attrib::value, m_lockMinMax);
-    writer->writeEndElement();
+    w->writeStartElement(Tag::LockMinMax);
+    XML::writeAttribute(w, XML::Attrib::value, m_lockMinMax);
+    w->writeEndElement();
 
     // log scale
-    writer->writeStartElement(Tag::LogScale);
-    XML::writeAttribute(writer, Attrib::value, m_logScale);
-    writer->writeEndElement();
+    w->writeStartElement(Tag::LogScale);
+    XML::writeAttribute(w, XML::Attrib::value, m_logScale);
+    w->writeEndElement();
 }
 
-void AmplitudeAxisItem::readFrom(QXmlStreamReader* reader)
+void AmplitudeAxisItem::readFrom(QXmlStreamReader* r)
 {
-    while (reader->readNextStartElement()) {
+    const uint version = XML::readUIntAttribute(r, XML::Attrib::version);
+    Q_UNUSED(version)
+
+    while (r->readNextStartElement()) {
+        QString tag = r->name().toString();
 
-        // visibility
-        if (reader->name() == Tag::LockMinMax) {
-            XML::readAttribute(reader, Attrib::value, &m_lockMinMax);
-            XML::gotoEndElementOfTag(reader, Tag::LockMinMax);
+        // parameters from base class
+        if (tag == Tag::BaseData) {
+            BasicAxisItem::readFrom(r);
+            XML::gotoEndElementOfTag(r, tag);
+
+            // visibility
+        } else if (tag == Tag::LockMinMax) {
+            XML::readAttribute(r, XML::Attrib::value, &m_lockMinMax);
+            XML::gotoEndElementOfTag(r, tag);
 
             // title
-        } else if (reader->name() == Tag::LogScale) {
-            XML::readAttribute(reader, Attrib::value, &m_logScale);
-            XML::gotoEndElementOfTag(reader, Tag::LogScale);
-
-            // members from base class
-        } else {
-            BasicAxisItem::readBasicTags(reader);
-        }
+        } else if (tag == Tag::LogScale) {
+            XML::readAttribute(r, XML::Attrib::value, &m_logScale);
+            XML::gotoEndElementOfTag(r, tag);
+
+        } else
+            r->skipCurrentElement();
     }
 }
 

GUI/Model/Device/AxesItems.h

@@ -16,10 +16,9 @@
 #define BORNAGAIN_GUI_MODEL_DEVICE_AXESITEMS_H
 
 #include <QObject>
+#include <QXmlStreamWriter>
 
 class IAxis;
-class QXmlStreamReader;
-class QXmlStreamWriter;
 
 class BasicAxisItem : public QObject {
     Q_OBJECT
@@ -28,11 +27,8 @@ public:
     explicit BasicAxisItem(QObject* parent = nullptr);
     ~BasicAxisItem() override;
 
-    virtual void writeTo(QXmlStreamWriter* writer) const;
-    virtual void readFrom(QXmlStreamReader* reader);
-
-protected:
-    void readBasicTags(QXmlStreamReader* reader);
+    virtual void writeTo(QXmlStreamWriter* w) const;
+    virtual void readFrom(QXmlStreamReader* r);
 
 public:
     virtual std::unique_ptr<IAxis> createAxis(double scale) const;
@@ -81,8 +77,8 @@ class AmplitudeAxisItem : public BasicAxisItem {
 public:
     explicit AmplitudeAxisItem(QObject* parent = nullptr);
 
-    void writeTo(QXmlStreamWriter* writer) const override;
-    void readFrom(QXmlStreamReader* reader) override;
+    void writeTo(QXmlStreamWriter* w) const override;
+    void readFrom(QXmlStreamReader* r) override;
 
     bool isLogScale() const;
     void setLogScale(bool value);