Real data loader for Q/R/E reflectometry CSV files. More...

Inheritance diagram for QREDataLoader:

Collaboration diagram for QREDataLoader:

Classes
struct	ColumnDefinition

struct	ErrorDefinition
	Contains a line related error (stored in the import result). More...

struct	ImportResult
	Result of the file import. More...

struct	ImportSettings
	Settings for importing the file. More...

Signals
void	contentsProcessed ()
	Emitted whenever contents have been processed. More...

void	importSettingsChanged ()
	Emitted whenever an import setting changed. More...

Public Member Functions
	QREDataLoader ()

virtual void	applyImportSettings () override
	Read all values from the properties UI into the internal variables. More...

virtual AbstractDataLoader *	clone () const override
	Create a complete clone, including all internal states. More...

virtual AbstractDataLoaderResultModel *	createResultModel () const override
	Create a table model which contains the import information like original file content, raw content, processed content The returned pointer will be owned by the caller. More...

virtual QByteArray	defaultImportSettings () const
	Return the default import settings. More...

virtual void	deserialize (const QByteArray &data) override
	Initialize from serialization data. More...

virtual QByteArray	fileContent () const override
	Returns the original file content. More...

virtual void	guessSettings () override
	Guess appropriate settings (for example the separator in a CSV file). More...

virtual void	initWithDefaultImportSettings () override
	Set import settings to defaults. More...

virtual QStringList	lineUnrelatedErrors () const override
	Errors not related to a particular line. More...

virtual QString	name () const override
	The name shown in the format selection combo. More...

virtual int	numErrors () const override
	Number of errors found while processing the content. More...

virtual int	numLineRelatedErrors () const override
	Number of errors related to a specific line. More...

virtual QString	persistentClassName () const override
	A name which can be used for save/load purposes (which will not change ever more) More...

virtual void	populateImportSettingsWidget (QWidget *parent) override
	Fills the widget on the import dialog pane. More...

virtual void	processContents () override
	Process the file contents. More...

RealDataItem *	realDataItem ()
	The real data item on which the import shall work. More...

const RealDataItem *	realDataItem () const
	The real data item on which the import shall work. More...

virtual QByteArray	serialize () const override
	Returns every internal setting so it can be restored completely. More...

virtual void	setFileContents (const QByteArray &fileContent) override
	Sets the file contents to be imported. More...

void	setRealDataItem (RealDataItem *item)
	Define the real data item on which the import shall work. More...

Protected Types
enum class	Error { DifferendNumberOfColumns }

Protected Attributes
RealDataItem *	m_item

Private Types
enum class	DataType { Q , R , dR }

enum class	UnitInFile { none , perNanoMeter , perAngstrom , other }

Private Member Functions
void	calculateFromParseResult () const

void	createOutputDataFromParsingResult (RealDataItem *item) const

void	parseFileContent () const

Private Attributes
QByteArray	m_fileContent

ImportResult	m_importResult

struct QREDataLoader::ImportSettings	m_importSettings

QPointer< QREDataLoaderProperties >	m_propertiesWidget

Friends
QDataStream &	operator<< (QDataStream &stream, const QREDataLoader::ErrorDefinition &s)

QDataStream &	operator<< (QDataStream &stream, const QREDataLoader::ImportSettings &s)

QDataStream &	operator>> (QDataStream &stream, QREDataLoader::ErrorDefinition &s)

QDataStream &	operator>> (QDataStream &stream, QREDataLoader::ImportSettings &s)

class	QREDataLoaderResultModel

Detailed Description

Real data loader for Q/R/E reflectometry CSV files.

Definition at line 27 of file QREDataLoader.h.

Member Enumeration Documentation

◆ DataType

enum QREDataLoader::DataType

strongprivate

Enumerator
Q
R
dR

Definition at line 64 of file QREDataLoader.h.

64 { Q, R, dR };

◆ Error

enum AbstractDataLoader::Error

strongprotectedinherited

Enumerator
DifferendNumberOfColumns

Definition at line 119 of file AbstractDataLoader.h.

119 { DifferendNumberOfColumns };

◆ UnitInFile

enum QREDataLoader::UnitInFile

strongprivate

Enumerator
none
perNanoMeter
perAngstrom
other

Definition at line 53 of file QREDataLoader.h.

53 { none, perNanoMeter, perAngstrom, other };

ModelView::ConverterMode::none

@ none

undefined converter mode

Constructor & Destructor Documentation

◆ QREDataLoader()

QREDataLoader::QREDataLoader ( )

Definition at line 78 of file QREDataLoader.cpp.

                              : m_propertiesWidget(nullptr)
 {
     initWithDefaultImportSettings();
 }

References initWithDefaultImportSettings().

Referenced by clone().

Here is the call graph for this function:

Member Function Documentation

◆ applyImportSettings()

void QREDataLoader::applyImportSettings ( )

overridevirtual

Read all values from the properties UI into the internal variables.

Reimplemented from AbstractDataLoader.

Definition at line 591 of file QREDataLoader.cpp.

 {
     if (!m_propertiesWidget)
         return;
  
     const auto ui = m_propertiesWidget->m_ui;
  
     m_importSettings.separator = ui->separatorCombo->currentText();
     if (m_importSettings.separator == "<TAB>")
         m_importSettings.separator = "\t";
     if (m_importSettings.separator == "<SPACE>")
         m_importSettings.separator = " ";
  
     m_importSettings.headerPrefix = ui->headerPrefixEdit->text();
     m_importSettings.linesToSkip = ui->linesToSkipEdit->text();
  
     for (const auto dataType : m_importSettings.columnDefinitions.keys()) {
         auto& colDef = m_importSettings.columnDefinitions[dataType];
  
         colDef.column = m_propertiesWidget->columnSpinBox((int)dataType)->value() - 1;
         colDef.factor = m_propertiesWidget->factor((int)dataType);
     }
  
     m_importSettings.columnDefinitions[DataType::Q].unit =
         m_propertiesWidget->m_ui->qUnitCombo->currentIndex() == 0 ? UnitInFile::perNanoMeter
                                                                   : UnitInFile::perAngstrom;
  
     m_importSettings.columnDefinitions[DataType::dR].enabled =
         m_propertiesWidget->m_ui->enableErrorCheckBox->isChecked();
 }

References QREDataLoader::ImportSettings::columnDefinitions, dR, QREDataLoader::ImportSettings::headerPrefix, QREDataLoader::ImportSettings::linesToSkip, m_importSettings, m_propertiesWidget, perAngstrom, perNanoMeter, Q, and QREDataLoader::ImportSettings::separator.

◆ calculateFromParseResult()

void QREDataLoader::calculateFromParseResult ( ) const

private

Definition at line 445 of file QREDataLoader.cpp.

 {
     m_importResult.clearCalculatedValues();
     m_importResult.qValues.resize(m_importResult.lines.size());
     m_importResult.rValues.resize(m_importResult.lines.size());
     m_importResult.eValues.resize(m_importResult.lines.size());
  
     // -- calculate the Q/R/E values (take from specified column, use factor)
     const auto& c = m_importSettings.columnDefinitions; // easier access
     const bool errorColumnIsEnabled = c[DataType::dR].enabled;
     const double unitFac = (c[DataType::Q].unit == UnitInFile::perAngstrom) ? 10.0 : 1.0;
     const double qFactor = c[DataType::Q].factor * unitFac;
     const double rFactor = c[DataType::R].factor;
     const double eFactor = c[DataType::dR].factor;
  
     const int qCol = c[DataType::Q].column;
     const int rCol = c[DataType::R].column;
     const int eCol = c[DataType::dR].column;
  
     QSet<double> foundQValues;
     double lastFoundQ = std::numeric_limits<double>::quiet_NaN();
  
     for (int lineNr = 0; lineNr < m_importResult.lines.size(); lineNr++) {
         const bool skipLine = m_importResult.lines[lineNr].first;
         if (skipLine)
             continue;
  
         const auto& rawValues = m_importResult.rawValues[lineNr];
  
         const bool qColIsValid = qCol >= 0 && qCol < rawValues.size();
         const bool rColIsValid = rCol >= 0 && rCol < rawValues.size();
         const bool eColIsValid = eCol >= 0 && eCol < rawValues.size();
  
         const double q =
             qColIsValid ? rawValues[qCol] * qFactor : std::numeric_limits<double>::quiet_NaN();
         const double r =
             rColIsValid ? rawValues[rCol] * rFactor : std::numeric_limits<double>::quiet_NaN();
         const double e =
             eColIsValid ? rawValues[eCol] * eFactor : std::numeric_limits<double>::quiet_NaN();
  
         if (std::isnan(q)) {
             m_importResult.addError(lineNr, ErrorDefinition::columnDoesNotContainValidNumber,
                                     qCol + 1);
             continue;
         }
  
         if (std::isnan(r)) {
             m_importResult.addError(lineNr, ErrorDefinition::columnDoesNotContainValidNumber,
                                     rCol + 1);
             continue;
         }
  
         if (std::isnan(e) && errorColumnIsEnabled) {
             m_importResult.addError(lineNr, ErrorDefinition::columnDoesNotContainValidNumber,
                                     eCol + 1);
             continue;
         }
  
         if (foundQValues.contains(q)) {
             m_importResult.addError(lineNr, ErrorDefinition::duplicateQ, q);
             continue;
         }
  
         if (!std::isnan(lastFoundQ) && q <= lastFoundQ) {
             m_importResult.addError(lineNr, ErrorDefinition::wrongQOrder);
             continue;
         }
  
         if (r > 1.0) {
             m_importResult.addError(lineNr, ErrorDefinition::RGreaterOne, r);
             continue;
         }
  
         if (r < 0.0) {
             m_importResult.addError(lineNr, ErrorDefinition::RLessZero, r);
             continue;
         }
  
         m_importResult.qValues[lineNr] = q;
         m_importResult.rValues[lineNr] = r;
         m_importResult.eValues[lineNr] = e;
         m_importResult.validCalculatedLines++;
         foundQValues << q;
         lastFoundQ = q;
     }
 }

Referenced by processContents().

Here is the call graph for this function:

◆ clone()

AbstractDataLoader * QREDataLoader::clone ( ) const

overridevirtual

Create a complete clone, including all internal states.

Implements AbstractDataLoader.

Definition at line 213 of file QREDataLoader.cpp.

 {
     auto loader = new QREDataLoader();
     loader->deserialize(serialize());
     return loader;
 }

References QREDataLoader(), and serialize().

Here is the call graph for this function:

◆ contentsProcessed

void AbstractDataLoader::contentsProcessed ( )

signalinherited

Emitted whenever contents have been processed.

Referenced by AutomaticDataLoader1D::processContents(), processContents(), and RealDataItem::setDataLoader().

◆ createOutputDataFromParsingResult()

void QREDataLoader::createOutputDataFromParsingResult ( RealDataItem * item ) const

private

Definition at line 532 of file QREDataLoader.cpp.

 {
     // -- create OutputData
     std::vector<double> qVec;
     std::vector<double> rVec;
  
     for (int lineNr = 0; lineNr < m_importResult.lines.size(); lineNr++) {
         const bool skipLine = m_importResult.lines[lineNr].first;
         const bool lineHasError = m_importResult.calculationErrors.contains(lineNr);
         if (skipLine || lineHasError)
             continue;
  
         qVec.push_back(m_importResult.qValues[lineNr]);
         rVec.push_back(m_importResult.rValues[lineNr]);
     }
  
     OutputData<double>* oData = new OutputData<double>();
     oData->addAxis(PointwiseAxis("qVector", qVec));
     oData->setRawDataVector(rVec);
  
     // -- Replacement of item->setImportData(std::move(data));
     item->initNativeData();
  
     QString units_name = JobItemUtils::nameFromAxesUnits(Axes::Units::QSPACE);
  
     // -- Replacement of specularItem->reset(std::move(data));
     SpecularDataItem* specularItem = item->specularDataItem();
     ComboProperty combo = ComboProperty() << units_name;
  
     specularItem->setItemValue(SpecularDataItem::P_AXES_UNITS, combo.variant());
     specularItem->getItem(SpecularDataItem::P_AXES_UNITS)->setVisible(true);
  
     auto label_map = AxisNames::InitSpecAxis();
     const auto xAxisTitle = QString::fromStdString(label_map[Axes::Units::QSPACE]);
     const auto yAxisTitle = "Signal [a.u.]"; // taken from ImportDataInfo::axisLabel
  
     specularItem->setXaxisTitle(xAxisTitle);
     specularItem->setYaxisTitle(yAxisTitle);
     specularItem->setOutputData(oData); // takes ownership of odata
     specularItem->setAxesRangeToData();
  
     item->setNativeDataUnits(units_name);
     item->setNativeOutputData(oData->clone()); // takes ownership of odata
 }

References OutputData< T >::addAxis(), QREDataLoader::ImportResult::calculationErrors, OutputData< T >::clone(), SessionItem::getItem(), RealDataItem::initNativeData(), AxisNames::InitSpecAxis(), QREDataLoader::ImportResult::lines, m_importResult, JobItemUtils::nameFromAxesUnits(), DataItem::P_AXES_UNITS, QREDataLoader::ImportResult::qValues, QREDataLoader::ImportResult::rValues, SpecularDataItem::setAxesRangeToData(), SessionItem::setItemValue(), RealDataItem::setNativeDataUnits(), RealDataItem::setNativeOutputData(), SpecularDataItem::setOutputData(), OutputData< T >::setRawDataVector(), SessionItem::setVisible(), SpecularDataItem::setXaxisTitle(), SpecularDataItem::setYaxisTitle(), RealDataItem::specularDataItem(), and ComboProperty::variant().

Referenced by processContents().

Here is the call graph for this function:

◆ createResultModel()

AbstractDataLoaderResultModel * QREDataLoader::createResultModel ( ) const

overridevirtual

Create a table model which contains the import information like original file content, raw content, processed content The returned pointer will be owned by the caller.

This base class' implementation does nothing (return nullptr).

Reimplemented from AbstractDataLoader.

Definition at line 293 of file QREDataLoader.cpp.

 {
     return new QREDataLoaderResultModel(&m_importResult);
 }

References m_importResult, and QREDataLoaderResultModel.

◆ defaultImportSettings()

QByteArray AbstractDataLoader::defaultImportSettings ( ) const

virtualinherited

Return the default import settings.

Definition at line 31 of file AbstractDataLoader.cpp.

 {
     std::unique_ptr<AbstractDataLoader> cloned(clone());
     cloned->initWithDefaultImportSettings();
     return cloned->serialize();
 }

References AbstractDataLoader::clone().

Here is the call graph for this function:

◆ deserialize()

void QREDataLoader::deserialize ( const QByteArray & data )

overridevirtual

Initialize from serialization data.

If any error occurred, then a DeserializationException has to be thrown. The complete state has to be restored. Therefore if e.g. errors occurred in the former serialization, but errors are not serialized, then they have to be regenerated/recalculated in here.

Reimplemented from AbstractDataLoader.

Definition at line 178 of file QREDataLoader.cpp.

 {
     m_importSettings.columnDefinitions.clear(); // sufficient
     m_importResult.clear();
  
     QDataStream s(data);
     s.setVersion(QDataStream::Qt_5_12);
  
     quint8 version;
     s >> version;
  
     if (version < 4) // anything smaller 4 was internal developer version => no backwards
                      // compatibility necessary
         throw DeserializationException::tooOld();
  
     if (version == 4) {
         s >> m_fileContent;
         s >> m_importSettings;
         s >> m_importResult.lines;
         s >> m_importResult.rawValues;
         s >> m_importResult.qValues;
         s >> m_importResult.rValues;
         s >> m_importResult.eValues;
         s >> m_importResult.validCalculatedLines;
         s >> m_importResult.maxColumnCount;
         s >> m_importResult.calculationErrors;
         s >> m_importResult.error;
         s >> m_importResult.importSettings;
     } else
         throw DeserializationException::tooNew();
  
     if (s.status() != QDataStream::Ok)
         throw DeserializationException::streamError();
 }

Here is the call graph for this function:

◆ fileContent()

QByteArray QREDataLoader::fileContent ( ) const

overridevirtual

Returns the original file content.

If not available any more (like for legacy project file import), then an empty array will be returned.

Reimplemented from AbstractDataLoader.

Definition at line 298 of file QREDataLoader.cpp.

 {
     return m_fileContent;
 }

References m_fileContent.

Referenced by setFileContents().

◆ guessSettings()

void QREDataLoader::guessSettings ( )

overridevirtual

Guess appropriate settings (for example the separator in a CSV file).

Is called only once, directly after setting the file content.

Reimplemented from AbstractDataLoader.

Definition at line 303 of file QREDataLoader.cpp.

 {
     // #baimport - move to utils; create unit test
     // search for lines which start with a number, then try the separators
  
     const auto isFirstNumberChar = [](const QChar& c) {
         return c.isNumber() || c == '.' || c == '+' || c == '-';
     };
  
     const auto belongsToNumber = [](const QChar& c) {
         return c.isNumber() || c == '.' || c == 'e' || c == 'E' || c == '+' || c == '-';
     };
  
     QTextStream in(m_fileContent);
     int lineNr = 0;
     const int maxLinesToExamine = 100;
     while (!in.atEnd() && lineNr < maxLinesToExamine) {
         lineNr++;
         QString line = in.readLine().trimmed();
         if (line.isEmpty())
             continue;
         if (!isFirstNumberChar(line[0]))
             continue;
  
         // line starts with a number => search gap after it
         int startOfGap = 1;
         while (startOfGap < line.size() && belongsToNumber(line[startOfGap]))
             startOfGap++;
  
         if (startOfGap == line.size())
             continue;
  
         int endOfGap = startOfGap;
         while (endOfGap < line.size() && !belongsToNumber(line[endOfGap])) {
             endOfGap++;
         }
  
         QStringRef gapContent(&line, startOfGap, endOfGap - startOfGap);
         if (gapContent.isEmpty())
             continue;
  
         if (gapContent.contains("\t")) {
             m_importSettings.separator = "\t";
             return;
         }
  
         gapContent = gapContent.trimmed();
         if (gapContent.isEmpty()) {
             m_importSettings.separator = " ";
             return;
         }
  
         if (gapContent.contains(";")) {
             m_importSettings.separator = ";";
             return;
         }
  
         if (gapContent.contains(",")) {
             m_importSettings.separator = ",";
             return;
         }
     }
 }

References m_fileContent, m_importSettings, and QREDataLoader::ImportSettings::separator.

◆ importSettingsChanged

void AbstractDataLoader::importSettingsChanged ( )

signalinherited

Emitted whenever an import setting changed.

Referenced by UserDefinedDataLoader1D::UserDefinedDataLoader1D(), SpecularDataImportWidget::onFormatSelectionChanged(), and SpecularDataImportWidget::setItem().

◆ initWithDefaultImportSettings()

void QREDataLoader::initWithDefaultImportSettings ( )

overridevirtual

Set import settings to defaults.

Reimplemented from AbstractDataLoader.

Definition at line 135 of file QREDataLoader.cpp.

 {
     m_importSettings.separator = ";";
     m_importSettings.headerPrefix = "#,//";
     m_importSettings.linesToSkip = "";
  
     for (const auto dataType : {DataType::Q, DataType::R, DataType::dR}) {
         m_importSettings.columnDefinitions[dataType].enabled = true;
         m_importSettings.columnDefinitions[dataType].column = (int)dataType;
         m_importSettings.columnDefinitions[dataType].unit = UnitInFile::none;
         m_importSettings.columnDefinitions[dataType].factor = 1.0;
     }
  
     m_importSettings.columnDefinitions[DataType::Q].unit = UnitInFile::perNanoMeter;
 }

References QREDataLoader::ImportSettings::columnDefinitions, dR, QREDataLoader::ImportSettings::headerPrefix, QREDataLoader::ImportSettings::linesToSkip, m_importSettings, none, perNanoMeter, Q, R, and QREDataLoader::ImportSettings::separator.

Referenced by QREDataLoader().

◆ lineUnrelatedErrors()

QStringList QREDataLoader::lineUnrelatedErrors ( ) const

overridevirtual

Errors not related to a particular line.

Reimplemented from AbstractDataLoader.

Definition at line 285 of file QREDataLoader.cpp.

 {
     if (!m_importResult.error.isEmpty())
         return {m_importResult.error};
  
     return {};
 }

References QREDataLoader::ImportResult::error, and m_importResult.

◆ name()

QString QREDataLoader::name ( ) const

overridevirtual

The name shown in the format selection combo.

Implements AbstractDataLoader.

Definition at line 83 of file QREDataLoader.cpp.

 {
     return "CSV file (Reflectometry - Q/R/sigma_R)";
 }

◆ numErrors()

int QREDataLoader::numErrors ( ) const

overridevirtual

Number of errors found while processing the content.

An error means that either a particular content (line) can't be used or may be suspicious (line related error), or that the whole content can't be used (e.g. only 1 line present).

Reimplemented from AbstractDataLoader.

Definition at line 275 of file QREDataLoader.cpp.

 {
     return (m_importResult.error.isEmpty() ? 0 : 1) + m_importResult.calculationErrors.size();
 }

References QREDataLoader::ImportResult::calculationErrors, QREDataLoader::ImportResult::error, and m_importResult.

◆ numLineRelatedErrors()

int QREDataLoader::numLineRelatedErrors ( ) const

overridevirtual

Number of errors related to a specific line.

Such an error means that a particular content (line) can't be used or may be suspicious.

Reimplemented from AbstractDataLoader.

Definition at line 280 of file QREDataLoader.cpp.

 {
     return m_importResult.calculationErrors.size();
 }

References QREDataLoader::ImportResult::calculationErrors, and m_importResult.

◆ parseFileContent()

void QREDataLoader::parseFileContent ( ) const

private

Definition at line 372 of file QREDataLoader.cpp.

 {
     m_importResult.clear();
  
     const QStringList headerPrefixes = (m_importSettings.headerPrefix.trimmed().isEmpty())
                                            ? QStringList()
                                            : m_importSettings.headerPrefix.split(",");
  
     const auto lineIsHeader = [headerPrefixes](const QString& line) {
         for (const auto& prefix : headerPrefixes) {
             if (line.startsWith(prefix.trimmed()))
                 return true;
         }
  
         return false;
     };
  
     const auto skippedLines = expandLineNumberPattern(m_importSettings.linesToSkip);
     const auto lineShouldBeSkipped = [skippedLines](int lineNr) {
         for (const auto pair : skippedLines) {
             if (lineNr >= pair.first && lineNr <= pair.second)
                 return true;
         }
         return false;
     };
  
     QTextStream in(m_fileContent);
     int lineNr = 0;
     // if separator is SPACE: e.g. three consecutive SPACEs do not represent 3 columns => delete
     // empty parts
     QString::SplitBehavior splitBehavior =
         m_importSettings.separator == " " ? QString::SkipEmptyParts : QString::KeepEmptyParts;
  
     while (!in.atEnd()) {
         lineNr++;
  
         QString line = in.readLine();
  
         const bool skip =
             lineIsHeader(line) || lineShouldBeSkipped(lineNr) || line.trimmed().isEmpty();
  
         m_importResult.lines << qMakePair(skip, line);
     }
  
     m_importResult.rawValues.resize(m_importResult.lines.size());
  
     for (int lineNr = 0; lineNr < m_importResult.lines.size(); lineNr++) {
  
         const bool skip = m_importResult.lines[lineNr].first;
         if (skip)
             continue;
  
         const QStringList lineEntries =
             m_importResult.lines[lineNr].second.split(m_importSettings.separator, splitBehavior);
  
         m_importResult.maxColumnCount =
             std::max(m_importResult.maxColumnCount, lineEntries.count());
  
         QVector<double> rowEntriesAsDouble;
  
         for (int col = 0; col < lineEntries.count(); col++) {
             bool ok = false;
             double val = lineEntries[col].toDouble(&ok);
             if (!ok)
                 val = std::numeric_limits<double>::quiet_NaN();
  
             rowEntriesAsDouble << val;
         }
  
         m_importResult.rawValues[lineNr] = rowEntriesAsDouble;
     }
 }

References QREDataLoader::ImportResult::clear(), QREDataLoader::ImportSettings::headerPrefix, QREDataLoader::ImportResult::lines, QREDataLoader::ImportSettings::linesToSkip, m_fileContent, m_importResult, m_importSettings, QREDataLoader::ImportResult::maxColumnCount, QREDataLoader::ImportResult::rawValues, and QREDataLoader::ImportSettings::separator.

Referenced by processContents().

Here is the call graph for this function:

◆ persistentClassName()

QString QREDataLoader::persistentClassName ( ) const

overridevirtual

A name which can be used for save/load purposes (which will not change ever more)

Implements AbstractDataLoader.

Definition at line 88 of file QREDataLoader.cpp.

 {
     return "QREDataLoader";
 }

◆ populateImportSettingsWidget()

void QREDataLoader::populateImportSettingsWidget ( QWidget * parent )

overridevirtual

Fills the widget on the import dialog pane.

This base class' implementation does nothing (meaning "no editable properties")

Reimplemented from AbstractDataLoader.

Definition at line 93 of file QREDataLoader.cpp.

 {
     if (m_propertiesWidget == nullptr)
         m_propertiesWidget = new QREDataLoaderProperties;
  
     QHBoxLayout* l = new QHBoxLayout(parent);
     l->setContentsMargins(0, 0, 0, 0);
     parent->setLayout(l);
     l->addWidget(m_propertiesWidget);
  
     if (m_importSettings.separator == " ")
         m_propertiesWidget->m_ui->separatorCombo->setCurrentText("<SPACE>");
     else if (m_importSettings.separator == "\t")
         m_propertiesWidget->m_ui->separatorCombo->setCurrentText("<TAB>");
     else
         m_propertiesWidget->m_ui->separatorCombo->setCurrentText(m_importSettings.separator);
  
     m_propertiesWidget->m_ui->headerPrefixEdit->setText(m_importSettings.headerPrefix);
     m_propertiesWidget->m_ui->linesToSkipEdit->setText(m_importSettings.linesToSkip);
  
     for (const auto dataType : {DataType::Q, DataType::R, DataType::dR}) {
         m_propertiesWidget->columnSpinBox((int)dataType)
             ->setValue(m_importSettings.columnDefinitions[dataType].column + 1); // view is 1-based
  
         m_propertiesWidget->factorSpinBox((int)dataType)
             ->setValue(m_importSettings.columnDefinitions[dataType].factor);
     }
  
     m_propertiesWidget->m_ui->enableErrorCheckBox->setChecked(
         m_importSettings.columnDefinitions[DataType::dR].enabled);
  
     if (m_importSettings.columnDefinitions[DataType::Q].unit == UnitInFile::perAngstrom)
         m_propertiesWidget->m_ui->qUnitCombo->setCurrentIndex(1);
     else
         m_propertiesWidget->m_ui->qUnitCombo->setCurrentIndex(0); // 1/nm
  
     QObject::connect(m_propertiesWidget, &QREDataLoaderProperties::propertiesChanged, [this]() {
         applyImportSettings();
         emit importSettingsChanged();
     });
 }

References QREDataLoader::ImportSettings::columnDefinitions, dR, QREDataLoader::ImportSettings::headerPrefix, QREDataLoader::ImportSettings::linesToSkip, m_importSettings, m_propertiesWidget, perAngstrom, QREDataLoaderProperties::propertiesChanged(), Q, R, and QREDataLoader::ImportSettings::separator.

◆ processContents()

void QREDataLoader::processContents ( )

overridevirtual

Process the file contents.

Can be called more than once, e.g. if the import settings have changed. Any error has to be stored in the loader (see numErrors()).

Implements AbstractDataLoader.

Definition at line 220 of file QREDataLoader.cpp.

 {
     AutoEmit emitter([this] { contentsProcessed(); }); // automatic signal calling in any return
  
     // Important: If the current options match the ones in m_parsingResult, then nothing should be
     // performed. Otherwise e.g. a linked instrument may have to be re-linked
  
     m_importResult.error.clear();
  
     ASSERT(m_item != nullptr);
     ASSERT(m_item->isSpecularData());
  
     const auto invalidateItemData = [this]() {
         m_item->removeNativeData();
         m_item->specularDataItem()->setOutputData(nullptr);
     };
  
     const bool parsingSettingsChanged =
         m_importResult.importSettings.headerPrefix != m_importSettings.headerPrefix
         || m_importResult.importSettings.linesToSkip != m_importSettings.linesToSkip
         || m_importResult.importSettings.separator != m_importSettings.separator;
     const bool calculationSettingsChanged =
         m_importResult.importSettings.columnDefinitions != m_importSettings.columnDefinitions;
     const bool calculationIsNecessary = (parsingSettingsChanged || calculationSettingsChanged);
     const bool creationOfOutputDataIsNecessary = calculationIsNecessary;
  
     if (parsingSettingsChanged)
         // everything has to be re-parsed
         parseFileContent();
  
     if (calculationIsNecessary)
         calculateFromParseResult();
  
     m_importResult.importSettings = m_importSettings;
  
     // -- make a few checks (mainly for fulfilling PointwiseAxis::sanityCheck())
     if (m_importResult.validCalculatedLines < 2)
         m_importResult.error = "At least two full rows must exist";
  
     if (!m_importResult.error.isEmpty()) {
         invalidateItemData();
         return;
     }
  
     if (creationOfOutputDataIsNecessary) {
  
         try {
             createOutputDataFromParsingResult(m_item);
         } catch (...) {
             m_importResult.error = "Import not successful - caught an exception.";
             invalidateItemData();
         }
     }
 }

References ASSERT, calculateFromParseResult(), QREDataLoader::ImportSettings::columnDefinitions, AbstractDataLoader::contentsProcessed(), createOutputDataFromParsingResult(), QREDataLoader::ImportResult::error, QREDataLoader::ImportSettings::headerPrefix, QREDataLoader::ImportResult::importSettings, RealDataItem::isSpecularData(), QREDataLoader::ImportSettings::linesToSkip, m_importResult, m_importSettings, AbstractDataLoader::m_item, parseFileContent(), RealDataItem::removeNativeData(), QREDataLoader::ImportSettings::separator, SpecularDataItem::setOutputData(), RealDataItem::specularDataItem(), and QREDataLoader::ImportResult::validCalculatedLines.

Here is the call graph for this function:

◆ realDataItem() [1/2]

RealDataItem * AbstractDataLoader::realDataItem ( )

inherited

The real data item on which the import shall work.

Definition at line 70 of file AbstractDataLoader.cpp.

 {
     return m_item;
 }

References AbstractDataLoader::m_item.

◆ realDataItem() [2/2]

const RealDataItem * AbstractDataLoader::realDataItem ( ) const

inherited

The real data item on which the import shall work.

Definition at line 75 of file AbstractDataLoader.cpp.

 {
     return m_item;
 }

References AbstractDataLoader::m_item.

◆ serialize()

QByteArray QREDataLoader::serialize ( ) const

overridevirtual

Returns every internal setting so it can be restored completely.

Reimplemented from AbstractDataLoader.

Definition at line 151 of file QREDataLoader.cpp.

 {
     // changed in version 2: no file hash anymore (1 was only a developer version)
     // changed in version 3: refactored lists/vectors (2 was only a developer version)
     // changed in version 4: refactored lists/vectors (3 was only a developer version)
  
     QByteArray a;
     QDataStream s(&a, QIODevice::WriteOnly);
     s.setVersion(QDataStream::Qt_5_12);
  
     s << (quint8)4; // version
     s << m_fileContent;
     s << m_importSettings;
     s << m_importResult.lines;
     s << m_importResult.rawValues;
     s << m_importResult.qValues;
     s << m_importResult.rValues;
     s << m_importResult.eValues;
     s << m_importResult.validCalculatedLines;
     s << m_importResult.maxColumnCount;
     s << m_importResult.calculationErrors;
     s << m_importResult.error;
     s << m_importResult.importSettings;
  
     return a;
 }

References QREDataLoader::ImportResult::calculationErrors, QREDataLoader::ImportResult::error, QREDataLoader::ImportResult::eValues, QREDataLoader::ImportResult::importSettings, QREDataLoader::ImportResult::lines, m_fileContent, m_importResult, m_importSettings, QREDataLoader::ImportResult::maxColumnCount, QREDataLoader::ImportResult::qValues, QREDataLoader::ImportResult::rawValues, QREDataLoader::ImportResult::rValues, and QREDataLoader::ImportResult::validCalculatedLines.

Referenced by clone(), and QREDataLoader::ImportSettings::operator!=().

◆ setFileContents()

void QREDataLoader::setFileContents ( const QByteArray & fileContent )

overridevirtual

Sets the file contents to be imported.

If the file was a compressed file, here already the decompressed content will be overhanded.

Implements AbstractDataLoader.

Definition at line 367 of file QREDataLoader.cpp.

 {
     m_fileContent = fileContent;
 }

References fileContent(), and m_fileContent.

Here is the call graph for this function:

◆ setRealDataItem()

void AbstractDataLoader::setRealDataItem ( RealDataItem * item )

inherited

Define the real data item on which the import shall work.

Definition at line 65 of file AbstractDataLoader.cpp.

 {
     m_item = item;
 }

References AbstractDataLoader::m_item.

Referenced by ImportDataUtils::Import1dData(), and SpecularDataImportWidget::onFormatSelectionChanged().

Friends And Related Function Documentation

◆ operator<< [1/2]

QDataStream& operator<<	(	QDataStream &	stream,
		const QREDataLoader::ErrorDefinition &	s
	)

friend

Definition at line 759 of file QREDataLoader.cpp.

 {
     stream << (quint8)s.type;
     if (std::holds_alternative<int>(s.data)) {
         stream << true;
         stream << quint32(std::get<int>(s.data));
     } else {
         stream << false;
         stream << qreal(std::get<double>(s.data));
     }
  
     return stream;
 }

◆ operator<< [2/2]

QDataStream& operator<<	(	QDataStream &	stream,
		const QREDataLoader::ImportSettings &	s
	)

friend

Definition at line 577 of file QREDataLoader.cpp.

 {
     stream << s.serialize();
     return stream;
 }

◆ operator>> [1/2]

QDataStream& operator>>	(	QDataStream &	stream,
		QREDataLoader::ErrorDefinition &	s
	)

friend

Definition at line 773 of file QREDataLoader.cpp.

 {
     quint8 t;
     stream >> t;
     s.type = QREDataLoader::ErrorDefinition::Type(t);
     bool isInt = false;
     stream >> isInt;
     if (isInt) {
         quint32 d;
         stream >> d;
         s.data = int(d);
     } else {
         qreal d;
         stream >> d;
         s.data = double(d);
     }
  
     return stream;
 }

◆ operator>> [2/2]

QDataStream& operator>>	(	QDataStream &	stream,
		QREDataLoader::ImportSettings &	s
	)

friend

Definition at line 583 of file QREDataLoader.cpp.

 {
     QByteArray b;
     stream >> b;
     s.deserialize(b);
     return stream;
 }

◆ QREDataLoaderResultModel

friend class QREDataLoaderResultModel

friend

Definition at line 134 of file QREDataLoader.h.

Referenced by createResultModel().

Member Data Documentation

◆ m_fileContent

QByteArray QREDataLoader::m_fileContent

private

Definition at line 126 of file QREDataLoader.h.

Referenced by deserialize(), fileContent(), guessSettings(), parseFileContent(), serialize(), and setFileContents().

◆ m_importResult

ImportResult QREDataLoader::m_importResult

mutableprivate

Definition at line 125 of file QREDataLoader.h.

Referenced by calculateFromParseResult(), createOutputDataFromParsingResult(), createResultModel(), deserialize(), lineUnrelatedErrors(), numErrors(), numLineRelatedErrors(), parseFileContent(), processContents(), and serialize().

◆ m_importSettings

struct QREDataLoader::ImportSettings QREDataLoader::m_importSettings

private

Referenced by applyImportSettings(), calculateFromParseResult(), deserialize(), guessSettings(), initWithDefaultImportSettings(), parseFileContent(), populateImportSettingsWidget(), processContents(), and serialize().

◆ m_item

RealDataItem* AbstractDataLoader::m_item

protectedinherited

Definition at line 122 of file AbstractDataLoader.h.

Referenced by AutomaticDataLoader1D::createResultModel(), AutomaticDataLoader1D::processContents(), processContents(), AbstractDataLoader::realDataItem(), and AbstractDataLoader::setRealDataItem().

◆ m_propertiesWidget

QPointer<QREDataLoaderProperties> QREDataLoader::m_propertiesWidget

private

Definition at line 128 of file QREDataLoader.h.

Referenced by applyImportSettings(), and populateImportSettingsWidget().

The documentation for this class was generated from the following files:

/home/www/ba/GUI/coregui/DataLoaders/QREDataLoader.h
/home/www/ba/GUI/coregui/DataLoaders/QREDataLoader.cpp

Classes

Signals

Public Member Functions

Protected Types

Protected Attributes

Private Types

Private Member Functions

Private Attributes

Friends

Detailed Description

Member Enumeration Documentation

◆ DataType

◆ Error

◆ UnitInFile

Constructor & Destructor Documentation

◆ QREDataLoader()

Member Function Documentation

◆ applyImportSettings()

◆ calculateFromParseResult()

◆ clone()

◆ contentsProcessed

◆ createOutputDataFromParsingResult()

◆ createResultModel()

◆ defaultImportSettings()

◆ deserialize()

◆ fileContent()

◆ guessSettings()

◆ importSettingsChanged

◆ initWithDefaultImportSettings()

◆ lineUnrelatedErrors()

◆ name()

◆ numErrors()

◆ numLineRelatedErrors()

◆ parseFileContent()

◆ persistentClassName()

◆ populateImportSettingsWidget()

◆ processContents()

◆ realDataItem() [1/2]

◆ realDataItem() [2/2]

◆ serialize()

◆ setFileContents()

◆ setRealDataItem()

Friends And Related Function Documentation

◆ operator<< [1/2]

◆ operator<< [2/2]

◆ operator>> [1/2]

◆ operator>> [2/2]

◆ QREDataLoaderResultModel

Member Data Documentation

◆ m_fileContent

◆ m_importResult

◆ m_importSettings

◆ m_item

◆ m_propertiesWidget