[from_session_model] GUI: JobModel is refactored ()

Merging branch 'from_session_model'  into 'main'.

See merge request !1062

GUI/Model/Job/JobItem.cpp

@@ -42,6 +42,7 @@ const QString ParameterContainer("ParameterContainer");
 const QString Sample("Sample");
 const QString Instrument("Instrument");
 const QString value("value");
+const QString Name("Name");
 const QString Identifier("Id");
 const QString Comments("Comments");
 const QString PresentationType("PresentationType");
@@ -61,7 +62,6 @@ const QString FitSuite("FitSuite");
 JobItem::JobItem()
     : JobRealBase(M_TYPE)
 {
-    setItemName(M_TYPE);
     REFACTORED = true;
 }
 
@@ -77,12 +77,12 @@ void JobItem::setIdentifier(const QString& identifier)
 
 QString JobItem::jobName() const
 {
-    return itemName();
+    return m_name;
 }
 
 void JobItem::setJobName(const QString& name)
 {
-    setItemName(name);
+    m_name = name;
     updateDataFileName();
     emit jobNameChanged(name);
 }
@@ -428,10 +428,8 @@ void JobItem::cropRealData()
     intensityItem->updateDataRange();
 }
 
-void JobItem::writeNonSessionItems(QXmlStreamWriter* writer) const
+void JobItem::writeTo(QXmlStreamWriter* writer) const
 {
-    GUI::Session::XML::writeAttribute(writer, GUI::Session::XML::Version, int(1));
-
     // NOTE: The ordering of the XML elements are important in initialization
 
     // simulation options
@@ -453,60 +451,72 @@ void JobItem::writeNonSessionItems(QXmlStreamWriter* writer) const
     writer->writeEndElement();
 
     // data members
+    writer->writeStartElement(Tags::Name);
+    GUI::Session::XML::writeAttribute(writer, Tags::value, m_name);
+    writer->writeEndElement();
+
+    // identifier
     writer->writeStartElement(Tags::Identifier);
     GUI::Session::XML::writeAttribute(writer, Tags::value, m_identifier);
     writer->writeEndElement();
 
+    // activity
     writer->writeStartElement(Tags::Activity);
     GUI::Session::XML::writeAttribute(writer, Tags::value, m_activity);
     writer->writeEndElement();
 
+    // presentation type
     writer->writeStartElement(Tags::PresentationType);
     GUI::Session::XML::writeAttribute(writer, Tags::value, m_presentationType);
     writer->writeEndElement();
 
+    // begin time
     writer->writeStartElement(Tags::BeginTime);
     GUI::Session::XML::writeAttribute(writer, Tags::value, m_beginTime.toString(Qt::ISODateWithMs));
     writer->writeEndElement();
 
+    // end time
     writer->writeStartElement(Tags::EndTime);
     GUI::Session::XML::writeAttribute(writer, Tags::value, m_endTime.toString(Qt::ISODateWithMs));
     writer->writeEndElement();
 
+    // status
     writer->writeStartElement(Tags::Status);
     GUI::Session::XML::writeAttribute(writer, Tags::value, jobStatusToString(m_status));
     writer->writeEndElement();
 
+    // progress
     writer->writeStartElement(Tags::Progress);
     GUI::Session::XML::writeAttribute(writer, Tags::value, m_progress);
     writer->writeEndElement();
 
+    // comments
     writer->writeStartElement(Tags::Comments);
     GUI::Session::XML::writeAttribute(writer, Tags::value, m_comments);
     writer->writeEndElement();
 
-    // Output Data
+    // output data
     if (m_simulatedDataItem) {
         writer->writeStartElement(Tags::SimulatedData);
         GUI::Session::XML::writeItemAndChildItems(writer, m_simulatedDataItem.get());
         writer->writeEndElement();
     }
 
-    // Real Data
+    // real data
     if (m_realItem) {
         writer->writeStartElement(Tags::RealItem);
         GUI::Session::XML::writeItemAndChildItems(writer, m_realItem.get());
         writer->writeEndElement();
     }
 
-    // Diff Data
+    // diff data
     if (m_diffDataItem) {
         writer->writeStartElement(Tags::DiffData);
         GUI::Session::XML::writeItemAndChildItems(writer, m_diffDataItem.get());
         writer->writeEndElement();
     }
 
-    // Fit Suite
+    // fit suite
     if (m_fitSuiteItem) {
         writer->writeStartElement(Tags::FitSuite);
         GUI::Session::XML::writeItemAndChildItems(writer, m_fitSuiteItem.get());
@@ -514,7 +524,6 @@ void JobItem::writeNonSessionItems(QXmlStreamWriter* writer) const
     }
 }
 
-
 template <class T>
 inline T* readItemToEnd(QXmlStreamReader* reader, SessionItem* parent_item, const QString& tag)
 {
@@ -523,70 +532,100 @@ inline T* readItemToEnd(QXmlStreamReader* reader, SessionItem* parent_item, cons
     return item;
 }
 
-void JobItem::readNonSessionItems(QXmlStreamReader* reader)
+void JobItem::readFrom(QXmlStreamReader* reader)
 {
-    const int version = reader->attributes().value(GUI::Session::XML::Version).toInt();
-
-    if (version < 1)
-        throw DeserializationException::tooOld();
-
-    if (version > 1)
-        throw DeserializationException::tooNew();
-
     while (reader->readNextStartElement()) {
+
+        // simulation options
         if (reader->name() == Tags::SimulationOptions) {
             m_simulationOptionsItem.readContentFrom(reader);
             GUI::Session::XML::gotoEndElementOfTag(reader, Tags::SimulationOptions);
+
+            // instrument
         } else if (reader->name() == Tags::Instrument) {
             InstrumentItem* p = nullptr;
             Streamer(reader).read<InstrumentItemCatalog>(Tags::Instrument, p);
             m_instrument.reset(p);
+
+            // parameters
         } else if (reader->name() == Tags::ParameterContainer) {
             m_parameterContainer.readContentFrom(reader);
             GUI::Session::XML::gotoEndElementOfTag(reader, Tags::ParameterContainer);
+
+            // sample
         } else if (reader->name() == Tags::Sample) {
             m_sampleItem.readContentFrom(reader);
             GUI::Session::XML::gotoEndElementOfTag(reader, Tags::Sample);
+
+            // activity
         } else if (reader->name() == Tags::Activity) {
             GUI::Session::XML::readAttribute(reader, Tags::value, &m_activity);
             GUI::Session::XML::gotoEndElementOfTag(reader, Tags::Activity);
+
+            // presentation type
         } else if (reader->name() == Tags::PresentationType) {
             GUI::Session::XML::readAttribute(reader, Tags::value, &m_presentationType);
             GUI::Session::XML::gotoEndElementOfTag(reader, Tags::PresentationType);
+
+            // comments
         } else if (reader->name() == Tags::Comments) {
             GUI::Session::XML::readAttribute(reader, Tags::value, &m_comments);
             GUI::Session::XML::gotoEndElementOfTag(reader, Tags::Comments);
+
+            // status
         } else if (reader->name() == Tags::Status) {
             QString status_str;
             GUI::Session::XML::readAttribute(reader, Tags::value, &status_str);
             m_status = jobStatusFromString(status_str);
             GUI::Session::XML::gotoEndElementOfTag(reader, Tags::Status);
+
+            // progress
         } else if (reader->name() == Tags::Progress) {
             QString progress_str;
             GUI::Session::XML::readAttribute(reader, Tags::value, &progress_str);
             m_progress = progress_str.toInt();
             GUI::Session::XML::gotoEndElementOfTag(reader, Tags::Progress);
+
+            // begin time
         } else if (reader->name() == Tags::BeginTime) {
             QString begin_t_str;
             GUI::Session::XML::readAttribute(reader, Tags::value, &begin_t_str);
             m_beginTime = QDateTime::fromString(begin_t_str, Qt::ISODateWithMs);
             GUI::Session::XML::gotoEndElementOfTag(reader, Tags::BeginTime);
+
+            // end time
         } else if (reader->name() == Tags::EndTime) {
             QString end_t_str;
             GUI::Session::XML::readAttribute(reader, Tags::value, &end_t_str);
             m_endTime = QDateTime::fromString(end_t_str, Qt::ISODateWithMs);
             GUI::Session::XML::gotoEndElementOfTag(reader, Tags::EndTime);
+
+            // identifier
         } else if (reader->name() == Tags::Identifier) {
             GUI::Session::XML::readAttribute(reader, Tags::value, &m_identifier);
             GUI::Session::XML::gotoEndElementOfTag(reader, Tags::Identifier);
+
+            // name
+        } else if (reader->name() == Tags::Name) {
+            GUI::Session::XML::readAttribute(reader, Tags::value, &m_name);
+            GUI::Session::XML::gotoEndElementOfTag(reader, Tags::Name);
+
+            // simulated data
         } else if (reader->name() == Tags::SimulatedData) {
             m_simulatedDataItem.reset(readItemToEnd<DataItem>(reader, this, Tags::SimulatedData));
+
+            // real data
         } else if (reader->name() == Tags::RealItem) {
             m_realItem.reset(readItemToEnd<RealItem>(reader, this, Tags::RealItem));
+
+            // diff data
         } else if (reader->name() == Tags::DiffData) {
             m_diffDataItem.reset(readItemToEnd<DataItem>(reader, this, Tags::DiffData));
+
+            // fit suite
         } else if (reader->name() == Tags::FitSuite) {
             m_fitSuiteItem.reset(readItemToEnd<FitSuiteItem>(reader, this, Tags::FitSuite));
+
         } else {
             reader->skipCurrentElement();
         }
@@ -598,11 +637,11 @@ void JobItem::readNonSessionItems(QXmlStreamReader* reader)
 void JobItem::updateDataFileName()
 {
     if (DataItem* item = simulatedDataItem())
-        item->setFileName(GUI::Model::FilenameUtils::jobResultsFileName(itemName()));
+        item->setFileName(GUI::Model::FilenameUtils::jobResultsFileName(jobName()));
 
     if (RealItem* real = realItem()) {
         if (DataItem* item = real->dataItem())
-            item->setFileName(GUI::Model::FilenameUtils::jobReferenceFileName(itemName()));
+            item->setFileName(GUI::Model::FilenameUtils::jobReferenceFileName(jobName()));
 
         if (DataItem* item = real->nativeData())
             item->setFileName(GUI::Model::FilenameUtils::jobNativeDataFileName(getIdentifier()));

GUI/Model/Job/JobItem.h

@@ -131,8 +131,8 @@ public:
 
     // write/read
 
-    void writeNonSessionItems(QXmlStreamWriter* writer) const override;
-    void readNonSessionItems(QXmlStreamReader* reader) override;
+    void writeTo(QXmlStreamWriter* writer) const;
+    void readFrom(QXmlStreamReader* reader);
 
 signals:
     void jobNameChanged(const QString& name);
@@ -155,6 +155,7 @@ private:
         m_instrument; // TODO: Why own the pointer?
                       // ANSWER: job may exist even if the original instrument is deleted.
                       // For the uniformity purpose, it can be just "InstrumentItem m_instrument;"
+    QString m_name;
     QString m_identifier;
     JobStatus m_status = JobStatus::Idle;
     QString m_comments;

GUI/Model/Model/ApplicationModels.cpp

@@ -13,32 +13,28 @@
 //  ************************************************************************************************
 
 #include "GUI/Model/Model/ApplicationModels.h"
-#include "GUI/Model/Model/JobModel.h"
-#include "GUI/Model/Model/RealModel.h"
 #include "GUI/Support/Data/SimulationOptionsItem.h"
 #include "GUI/Util/DeserializationException.h"
 #include <QXmlStreamWriter>
 
 ApplicationModels::ApplicationModels()
-    : m_realDataModel(nullptr)
-    , m_jobModel(nullptr)
 {
     //! creates and initializes models, order is important
-    m_realDataModel = new RealModel(this);
-    m_jobModel = new JobModel(this);
+    m_realDataModel = std::make_unique<RealModel>(this);
+    m_jobModel = std::make_unique<JobModel>(this);
 
-    connectModel(m_realDataModel);
-    connectModel(m_jobModel);
+    connectModel(m_realDataModel.get());
+    connectModel(m_jobModel.get());
 }
 
 RealModel* ApplicationModels::realModel() const
 {
-    return m_realDataModel;
+    return m_realDataModel.get();
 }
 
 JobModel* ApplicationModels::jobModel() const
 {
-    return m_jobModel;
+    return m_jobModel.get();
 }
 
 //! Writes all model in file one by one
@@ -64,10 +60,10 @@ void ApplicationModels::readFrom(QXmlStreamReader* reader, MessageService* messa
 }
 
 
-QVector<SessionItem*> ApplicationModels::nonXMLItems() const
+QVector<DataItem*> ApplicationModels::dataItems() const
 {
     ASSERT(m_realDataModel && m_jobModel);
-    return QVector<SessionItem*>() << m_realDataModel->nonXMLItems() << m_jobModel->nonXMLItems();
+    return QVector<DataItem*>() << m_realDataModel->dataItems() << m_jobModel->dataItems();
 }
 
 void ApplicationModels::connectModel(SessionModel* model) const

GUI/Model/Model/ApplicationModels.h

@@ -15,14 +15,14 @@
 #ifndef BORNAGAIN_GUI_MODEL_MODEL_APPLICATIONMODELS_H
 #define BORNAGAIN_GUI_MODEL_MODEL_APPLICATIONMODELS_H
 
+#include "GUI/Model/Model/JobModel.h"
+#include "GUI/Model/Model/RealModel.h"
 #include <QObject>
 
 class SessionModel;
-class SessionItem;
+class DataItem;
 class DocumentModel;
 class InstrumentCollection;
-class RealModel;
-class JobModel;
 class MessageService;
 
 class ApplicationModels : public QObject {
@@ -36,8 +36,8 @@ public:
     void writeTo(class QXmlStreamWriter* writer);
     void readFrom(class QXmlStreamReader* reader, MessageService* messageService);
 
-    //! Returns all non-XML items
-    QVector<SessionItem*> nonXMLItems() const;
+    //! Returns all data items
+    QVector<DataItem*> dataItems() const;
 
 signals:
     void modelChanged();
@@ -45,8 +45,8 @@ signals:
 private:
     void connectModel(SessionModel* model) const;
 
-    RealModel* m_realDataModel;
-    JobModel* m_jobModel;
+    std::unique_ptr<RealModel> m_realDataModel;
+    std::unique_ptr<JobModel> m_jobModel;
 };
 
 #endif // BORNAGAIN_GUI_MODEL_MODEL_APPLICATIONMODELS_H

GUI/Model/Model/JobModel.cpp

@@ -13,32 +13,37 @@
 //  ************************************************************************************************
 
 #include "GUI/Model/Model/JobModel.h"
-#include "GUI/Model/Data/IntensityDataItem.h"
-#include "GUI/Model/Data/RealItem.h"
-#include "GUI/Model/Data/SpecularDataItem.h"
 #include "GUI/Model/Device/InstrumentItems.h"
 #include "GUI/Model/Device/PointwiseAxisItem.h"
 #include "GUI/Model/Job/FitSuiteItem.h"
-#include "GUI/Model/Job/JobItem.h"
-#include "GUI/Model/Model/JobQueueData.h"
 #include "GUI/Model/Model/ParameterTreeUtils.h"
 #include "GUI/Model/Model/SessionXML.h"
 #include "GUI/Model/Sample/ItemWithMaterial.h"
 #include "GUI/Model/Sample/MultiLayerItem.h"
+#include "GUI/Support/XML/UtilXML.h"
+#include "GUI/Util/Error.h"
+
+namespace {
+namespace Tags {
+
+const QString JobItemTag("JobItem");
+
+namespace Attributes {
+
+const QString JobNameAttribute("name");
+
+} // namespace Attributes
+} // namespace Tags
+} // namespace
 
 JobModel::JobModel(QObject* parent)
     : SessionModel(GUI::Session::XML::JobModelTag, parent)
-    , m_queue_data(nullptr)
 {
-    m_queue_data = new JobQueueData(this);
-    connect(m_queue_data, &JobQueueData::focusRequest, this, &JobModel::focusRequest);
-    connect(m_queue_data, &JobQueueData::globalProgress, this, &JobModel::globalProgress);
+    m_queue_data = std::make_unique<JobQueueData>(this);
+    connect(m_queue_data.get(), &JobQueueData::focusRequest, this, &JobModel::focusRequest);
+    connect(m_queue_data.get(), &JobQueueData::globalProgress, this, &JobModel::globalProgress);
     setObjectName(GUI::Session::XML::JobModelTag);
 }
-JobModel::~JobModel()
-{
-    delete m_queue_data;
-}
 
 JobItem* JobModel::getJobItemForIdentifier(const QString& identifier)
 {
@@ -49,6 +54,14 @@ JobItem* JobModel::getJobItemForIdentifier(const QString& identifier)
     return nullptr;
 }
 
+JobItem* JobModel::createJobItem()
+{
+    auto jobItem = std::make_unique<JobItem>();
+    jobItem->setParentAndModel(nullptr, this);
+    m_jobItems.push_back(std::move(jobItem));
+    return m_jobItems.back().get();
+}
+
 //! Main method to add a job
 JobItem* JobModel::addJob(const MultiLayerItem* sampleItem, const InstrumentItem* instrumentItem,
                           const RealItem* realItem, const SimulationOptionsItem& optionItem)
@@ -56,8 +69,8 @@ JobItem* JobModel::addJob(const MultiLayerItem* sampleItem, const InstrumentItem
     ASSERT(sampleItem);
     ASSERT(instrumentItem);
 
-    JobItem* jobItem = insertItem<JobItem>();
-    jobItem->setItemName(generateJobName());
+    JobItem* jobItem = createJobItem();
+    jobItem->setJobName(generateJobName());
     jobItem->setIdentifier(QUuid::createUuid().toString());
 
     jobItem->copySampleIntoJob(sampleItem);
@@ -80,7 +93,11 @@ JobItem* JobModel::addJob(const MultiLayerItem* sampleItem, const InstrumentItem
 
 QVector<JobItem*> JobModel::jobItems() const
 {
-    return topItems<JobItem>();
+    // QVector representation of unique pointers from m_jobItems
+    QVector<JobItem*> items(m_jobItems.size());
+    for (int i = 0; i < items.size(); i++)
+        items[i] = m_jobItems[i].get();
+    return items;
 }
 
 //! restore instrument and sample model from backup for given JobItem
@@ -105,15 +122,13 @@ void JobModel::clear()
 {
     for (auto* job : jobItems())
         removeJob(job);
-
-    SessionModel::clear();
 }
 
-QVector<SessionItem*> JobModel::nonXMLItems() const
+QVector<DataItem*> JobModel::dataItems() const
 {
-    QVector<SessionItem*> result;
+    QVector<DataItem*> result;
 
-    for (auto* jobItem : topItems<JobItem>()) {
+    for (auto* jobItem : jobItems()) {
         if (auto* dataItem = jobItem->simulatedDataItem())
             result.push_back(dataItem);
 
@@ -128,9 +143,46 @@ QVector<SessionItem*> JobModel::nonXMLItems() const
     return result;
 }
 
+void JobModel::writeTo(QXmlStreamWriter* writer)
+{
+    ASSERT(writer);
+    writer->writeStartElement(GUI::Session::XML::JobModelTag);
+    for (auto* job : jobItems()) {
+        writer->writeStartElement(Tags::JobItemTag);
+        // The following attribute is intended to simplify navigation in the project file. No need
+        // to read it.
+        writer->writeAttribute(Tags::Attributes::JobNameAttribute, job->jobName());
+
+        // write content
+        job->writeTo(writer);
+
+        writer->writeEndElement(); // JobItemTag
+    }
+    writer->writeEndElement(); // JobModelTag
+}
+
 void JobModel::readFrom(QXmlStreamReader* reader, MessageService* messageService /*= 0*/)
 {
-    SessionModel::readFrom(reader, messageService);
+    ASSERT(reader);
+
+    // we should check top-level tag
+    if (reader->name() != QString(GUI::Session::XML::JobModelTag))
+        throw Error("JobModel::readFrom() -> Format error in p1");
+
+    beginResetModel();
+    clear();
+    while (reader->readNextStartElement()) {
+        if (reader->name() == Tags::JobItemTag) {
+            JobItem* jobItem = createJobItem();
+
+            // read content
+            jobItem->readFrom(reader);
+            GUI::Session::XML::gotoEndElementOfTag(reader, Tags::JobItemTag);
+        }
+    }
+    if (reader->hasError())
+        throw Error(reader->errorString());
+    endResetModel();
 
     // Set & check instrument links. JobItem and realItem have to reference the same instrument
     // (which is the one contained in this job item, not contained in the instrument model)
@@ -157,16 +209,17 @@ void JobModel::removeJob(JobItem* jobItem)
 {
     ASSERT(jobItem);
     m_queue_data->removeJob(jobItem->getIdentifier());
-
-    removeRows(jobItem->index().row(), 1, QModelIndex());
+    int index = jobItems().indexOf(jobItem);
+    m_jobItems.erase(m_jobItems.begin() + index);
 }
 
 QString JobModel::generateJobName()
 {
     int maxJobIndex = 0;
     for (const auto* jobItem : jobItems()) {
-        if (jobItem->itemName().startsWith("job"))
-            maxJobIndex = std::max(maxJobIndex, jobItem->itemName().mid(3).toInt());
+        if (jobItem->jobName().startsWith("job")) {
+            maxJobIndex = std::max(maxJobIndex, jobItem->jobName().mid(3).toInt());
+        }
     }
     return QString("job%1").arg(maxJobIndex + 1);
 }

GUI/Model/Model/JobModel.h

@@ -15,13 +15,14 @@
 #ifndef BORNAGAIN_GUI_MODEL_MODEL_JOBMODEL_H
 #define BORNAGAIN_GUI_MODEL_MODEL_JOBMODEL_H
 
+#include "GUI/Model/Job/JobItem.h"
+#include "GUI/Model/Model/JobQueueData.h"
 #include "GUI/Model/Model/SessionModel.h"
 
 class InstrumentItem;
-class JobItem;
-class JobQueueData;
 class MultiLayerItem;
 class RealItem;
+class DataItem;
 class SimulationOptionsItem;
 
 class JobModel : public SessionModel {
@@ -29,10 +30,10 @@ class JobModel : public SessionModel {
 
 public:
     explicit JobModel(QObject* parent = nullptr);
-    ~JobModel() override;
 
     JobItem* getJobItemForIdentifier(const QString& identifier);
 
+    JobItem* createJobItem();
     JobItem* addJob(const MultiLayerItem* sampleItem, const InstrumentItem* instrumentItem,
                     const RealItem* realItem, const SimulationOptionsItem& optionItem);
 
@@ -43,7 +44,9 @@ public:
     bool hasUnfinishedJobs();
 
     void clear() override;
-    QVector<SessionItem*> nonXMLItems() const override;
+    QVector<DataItem*> dataItems() const;
+
+    void writeTo(QXmlStreamWriter* writer) override;
     void readFrom(QXmlStreamReader* reader, MessageService* messageService = nullptr) override;
 
     void runJob(JobItem* jobItem);
@@ -58,7 +61,8 @@ signals:
 private:
     //! generates numbered job name with new/unused number
     QString generateJobName();
-    JobQueueData* m_queue_data;
+    std::unique_ptr<JobQueueData> m_queue_data;
+    std::vector<std::unique_ptr<JobItem>> m_jobItems;
 };
 
 #endif // BORNAGAIN_GUI_MODEL_MODEL_JOBMODEL_H

GUI/Model/Model/RealModel.cpp

@@ -26,11 +26,11 @@ RealModel::RealModel(QObject* parent)
     connect(this, &SessionModel::rowsRemoved, this, &RealModel::onRowsChange);
 }
 
-QVector<SessionItem*> RealModel::nonXMLItems() const
+QVector<DataItem*> RealModel::dataItems() const
 {
-    QVector<SessionItem*> result;
+    QVector<DataItem*> result;
 
-    for (auto* realData : topItems<RealItem>()) {
+    for (auto* realData : realItems()) {
         if (auto* intensityItem = realData->dataItem())
             result.push_back(intensityItem);
         if (auto* native_data_item = realData->nativeData())
@@ -86,12 +86,24 @@ QVector<RealItem*> RealModel::realItems(int rank) const
 
 QVector<RealItem*> RealModel::realItems1D() const
 {
-    return topItems<RealItem>([](const RealItem& item) { return item.isSpecularData(); });
+    QVector<RealItem*> vec_1d;
+
+    for (auto* item : realItems())
+        if (item->isSpecularData())
+            vec_1d.push_back(item);
+
+    return vec_1d;
 }
 
 QVector<RealItem*> RealModel::realItems2D() const
 {
-    return topItems<RealItem>([](const RealItem& item) { return !item.isSpecularData(); });
+    QVector<RealItem*> vec_2d;
+
+    for (auto* item : realItems())
+        if (item->isIntensityData())
+            vec_2d.push_back(item);
+
+    return vec_2d;
 }
 
 void RealModel::remove(RealItem* item)
@@ -102,7 +114,7 @@ void RealModel::remove(RealItem* item)
 QStringList RealModel::realDataNames() const
 {
     QStringList result;
-    for (auto item : realItems())
+    for (auto* item : realItems())
         result.append(item->dataName());
     return result;
 }

GUI/Model/Model/RealModel.h

@@ -18,6 +18,7 @@
 #include "GUI/Model/Model/SessionModel.h"
 
 class RealItem;
+class DataItem;
 
 //! The RealModel class is a model to store all imported RealItem's.
 
@@ -27,7 +28,7 @@ class RealModel : public SessionModel {
 public:
     explicit RealModel(QObject* parent = nullptr);
 
-    QVector<SessionItem*> nonXMLItems() const override;
+    QVector<DataItem*> dataItems() const;
     void readFrom(QXmlStreamReader* reader, MessageService* messageService = nullptr) override;
 
     RealItem* insertSpecularDataItem();
@@ -44,6 +45,7 @@ public:
     QStringList realDataNames() const;
 
 signals:
+    // this signal is used only for testing
     void realDataAddedOrRemoved();
 
 private:

GUI/Model/Model/SessionXML.cpp

@@ -312,6 +312,7 @@ SessionItem* GUI::Session::XML::readItemAndChildItems(QXmlStreamReader* reader,
         }
     }
 
+
     ASSERT(newSessionItem)
 
     // inherit the model from the parent

GUI/Model/Project/IOService.cpp

@@ -113,9 +113,9 @@ QVector<SaveLoadInterface*> DatafieldIOService::dataInterfaces() const
     if (!m_applicationModels)
         return result;
 
-    for (auto* item : m_applicationModels->nonXMLItems())
-        if (auto* non_xml_item = dynamic_cast<SaveLoadInterface*>(item))
-            result.push_back(non_xml_item);
+    for (auto* item : m_applicationModels->dataItems())
+        if (auto* data_item = dynamic_cast<SaveLoadInterface*>(item))
+            result.push_back(data_item);
 
     return result;
 }

Tests/Unit/GUI/TestIOService.cpp

@@ -30,34 +30,34 @@ TEST_F(TestIOService, nonXMLData)
     ApplicationModels models;
 
     // initial state
-    auto dataItems = models.nonXMLItems();
+    auto dataItems = models.dataItems();
     EXPECT_EQ(dataItems.size(), 0);
 
     // adding RealItem
     auto* realData = models.realModel()->insertIntensityDataItem();
     realData->setDatafield(UTest::GUI::createData().release());
-    EXPECT_EQ(models.realModel()->nonXMLItems().size(), 1);
+    EXPECT_EQ(models.realModel()->dataItems().size(), 1);
 
     // adding JobItem
-    auto* jobItem = models.jobModel()->insertItem<JobItem>();
+    auto* jobItem = models.jobModel()->createJobItem();
     auto* instrumentItem = new GISASInstrumentItem();
     jobItem->copyInstrumentIntoJob(instrumentItem);
     jobItem->createSumulatedDataItem();
     auto* dataItem = jobItem->simulatedDataItem();
-    EXPECT_EQ(models.jobModel()->nonXMLItems().size(), 1);
+    EXPECT_EQ(models.jobModel()->dataItems().size(), 1);
 
     // adding RealItem to jobItem
     RealItem* realData2 = jobItem->createRealItem();
-    EXPECT_EQ(models.jobModel()->nonXMLItems().size(), 1);
+    EXPECT_EQ(models.jobModel()->dataItems().size(), 1);
     realData2->setDatafield(UTest::GUI::createData(0.0, UTest::GUI::DIM::D1).release());
-    EXPECT_EQ(models.jobModel()->nonXMLItems().size(), 2);
+    EXPECT_EQ(models.jobModel()->dataItems().size(), 2);
 
     // checking data items of DatafieldIOService
     DatafieldIOService service(&models);
     EXPECT_EQ(service.dataInterfaces().size(), 3);
 
     // checking data items of ApplicationModels
-    dataItems = models.nonXMLItems();
+    dataItems = models.dataItems();
     EXPECT_EQ(dataItems.size(), 3);
     EXPECT_EQ(dataItems.indexOf(realData->dataItem()), 0);
     EXPECT_EQ(dataItems.indexOf(dataItem), 1);
@@ -65,12 +65,12 @@ TEST_F(TestIOService, nonXMLData)
 
     // Replacing the data inside RealItem with the data of the same dimensions
     realData->setDatafield(UTest::GUI::createData(2.0).release());
-    EXPECT_EQ(models.realModel()->nonXMLItems().size(), 1);
+    EXPECT_EQ(models.realModel()->dataItems().size(), 1);
 
     // Replacing the data inside RealItem with the data of different dimensions
     auto data = UTest::GUI::createData(3.0, UTest::GUI::DIM::D1);
     EXPECT_THROW(dynamic_cast<RealItem*>(realData)->setDatafield(data.get()), Error);
-    EXPECT_EQ(models.realModel()->nonXMLItems().size(), 1);
+    EXPECT_EQ(models.realModel()->dataItems().size(), 1);
 }
 
 //! Tests DatafieldSaveInfo class intended for storing info about the last save.
@@ -234,33 +234,33 @@ TEST_F(TestIOService, RealDataItemWithNativeData)
     ApplicationModels models;
 
     // initial state
-    auto dataItems = models.nonXMLItems();
+    auto dataItems = models.dataItems();
     EXPECT_EQ(dataItems.size(), 0);
 
     // adding RealItem
     auto* realData = models.realModel()->insertIntensityDataItem();
-    EXPECT_EQ(models.realModel()->nonXMLItems().size(), 1);
+    EXPECT_EQ(models.realModel()->dataItems().size(), 1);
 
     ImportDataInfo import_data(std::unique_ptr<Datafield>(m_data.clone()), "nbins");
     realData->setImportData(std::move(import_data));
     // TODO: setImportData tested here with 2D data while main code uses it for 1D only.
 
     EXPECT_TRUE(realData->isIntensityData());
-    EXPECT_EQ(models.realModel()->nonXMLItems().size(), 2);
+    EXPECT_EQ(models.realModel()->dataItems().size(), 2);
     realData->setDataName("RealData");
 
     // adding JobItem
-    auto* jobItem = models.jobModel()->insertItem<JobItem>();
+    auto* jobItem = models.jobModel()->createJobItem();
     jobItem->setIdentifier(QUuid::createUuid().toString());
 
     auto* instrumentItem = new GISASInstrumentItem();
     jobItem->copyInstrumentIntoJob(instrumentItem);
     jobItem->createSumulatedDataItem();
-    EXPECT_EQ(models.jobModel()->nonXMLItems().size(), 1);
+    EXPECT_EQ(models.jobModel()->dataItems().size(), 1);
 
     // copying RealItem to JobItem
     jobItem->copyRealItemIntoJob(realData);
-    EXPECT_EQ(models.jobModel()->nonXMLItems().size(), 3);
+    EXPECT_EQ(models.jobModel()->dataItems().size(), 3);
 
     // checking data items of DatafieldIOService
     DatafieldIOService service(&models);