HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r392:cae900f78dff

Creates constructor for ScalarSeries that directly takes vectors...

Alexandre Leroux -

r392:cae900f78dff

parent child

Context file:

r392:cae900f78dff

Collapse all files

core/include/Data/ArrayData.h +11 0

             #ifndef SCIQLOP_ARRAYDATA_H
             #define SCIQLOP_ARRAYDATA_H
             #include <QReadLocker>
             #include <QReadWriteLock>
             #include <QVector>
             /**
              * @brief The ArrayData class represents a dataset for a data series.
              *
              * A dataset can be unidimensional or two-dimensional. This property is determined by the Dim
              * template-parameter.
              *
              * @tparam Dim the dimension of the ArrayData (one or two)
              * @sa IDataSeries
              */
             template <int Dim>
             class ArrayData {
             public:
                 /**
                  * Ctor for a unidimensional ArrayData
                  * @param nbColumns the number of values the ArrayData will hold
                  */
                 template <int D = Dim, typename = std::enable_if_t<D == 1> >
                 explicit ArrayData(int nbColumns) : m_Data{1, QVector<double>{}}
                 {
                     QWriteLocker locker{&m_Lock};
                     m_Data[0].resize(nbColumns);
                 }
+                /**
+                 * Ctor for a unidimensional ArrayData
+                 * @param data the data the ArrayData will hold
+                 */
+                template <int D = Dim, typename = std::enable_if_t<D == 1> >
+                explicit ArrayData(QVector<double> data) : m_Data{1, QVector<double>{}}
+                {
+                    QWriteLocker locker{&m_Lock};
+                    m_Data[0] = std::move(data);
+                }
                 /// Copy ctor
                 explicit ArrayData(const ArrayData &other)
                 {
                     QReadLocker otherLocker{&other.m_Lock};
                     QWriteLocker locker{&m_Lock};
                     m_Data = other.m_Data;
                 }
                 /**
                  * Sets a data at a specified index. The index has to be valid to be effective
                  * @param index the index to which the data will be set
                  * @param data the data to set
                  * @remarks this method is only available for a unidimensional ArrayData
                  */
                 template <int D = Dim, typename = std::enable_if_t<D == 1> >
                 void setData(int index, double data) noexcept
                 {
                     QWriteLocker locker{&m_Lock};
                     if (index >= 0 && index < m_Data.at(0).size()) {
                         m_Data[0].replace(index, data);
                     }
                 }
                 /**
                  * @return the data as a vector
                  * @remarks this method is only available for a unidimensional ArrayData
                  */
                 template <int D = Dim, typename = std::enable_if_t<D == 1> >
                 QVector<double> data() const noexcept
                 {
                     QReadLocker locker{&m_Lock};
                     return m_Data[0];
                 }
                 /**
                  * @return the data as a vector
                  * @remarks this method is only available for a unidimensional ArrayData
                  */
                 template <int D = Dim, typename = std::enable_if_t<D == 1> >
                 QVector<double> data(double tStart, double tEnd) const noexcept
                 {
                     QReadLocker locker{&m_Lock};
                     return m_Data.at(tStart);
                 }
                 // TODO Comment
                 template <int D = Dim, typename = std::enable_if_t<D == 1> >
                 void merge(const ArrayData<1> &arrayData)
                 {
                     QWriteLocker locker{&m_Lock};
                     if (!m_Data.empty()) {
                         QReadLocker otherLocker{&arrayData.m_Lock};
                         m_Data[0] += arrayData.data();
                     }
                 }
                 template <int D = Dim, typename = std::enable_if_t<D == 1> >
                 int size() const
                 {
                     QReadLocker locker{&m_Lock};
                     return m_Data[0].size();
                 }
                 void clear()
                 {
                     QWriteLocker locker{&m_Lock};
                     m_Data.clear();
                 }
             private:
                 QVector<QVector<double> > m_Data;
                 mutable QReadWriteLock m_Lock;
             };
             #endif // SCIQLOP_ARRAYDATA_H

core/include/Data/ScalarSeries.h +9 0

             #ifndef SCIQLOP_SCALARSERIES_H
             #define SCIQLOP_SCALARSERIES_H
             #include <Data/DataSeries.h>
             /**
              * @brief The ScalarSeries class is the implementation for a data series representing a scalar.
              */
             class ScalarSeries : public DataSeries<1> {
             public:
                 /**
                  * Ctor
                  * @param size the number of data the series will hold
                  * @param xAxisUnit x-axis unit
                  * @param valuesUnit values unit
                  */
                 explicit ScalarSeries(int size, const Unit &xAxisUnit, const Unit &valuesUnit);
                 /**
+                 * Ctor with two vectors. The vectors must have the same size, otherwise a ScalarSeries with no
+                 * values will be created.
+                 * @param xAxisData x-axis data
+                 * @param valuesData values data
+                 */
+                explicit ScalarSeries(QVector<double> xAxisData, QVector<double> valuesData,
+                                      const Unit &xAxisUnit, const Unit &valuesUnit);
+                /**
                  * Sets data for a specific index. The index has to be valid to be effective
                  * @param index the index to which the data will be set
                  * @param x the x-axis data
                  * @param value the value data
                  */
                 void setData(int index, double x, double value) noexcept;
                 std::unique_ptr<IDataSeries> clone() const;
             };
             #endif // SCIQLOP_SCALARSERIES_H

core/src/Data/ScalarSeries.cpp +7 0

             #include <Data/ScalarSeries.h>
             ScalarSeries::ScalarSeries(int size, const Unit &xAxisUnit, const Unit &valuesUnit)
                     : DataSeries{std::make_shared<ArrayData<1> >(size), xAxisUnit,
                                  std::make_shared<ArrayData<1> >(size), valuesUnit}
             {
             }
+            ScalarSeries::ScalarSeries(QVector<double> xAxisData, QVector<double> valuesData,
+                                       const Unit &xAxisUnit, const Unit &valuesUnit)
+                    : DataSeries{std::make_shared<ArrayData<1> >(std::move(xAxisData)), xAxisUnit,
+                                 std::make_shared<ArrayData<1> >(std::move(valuesData)), valuesUnit}
+            {
+            }
             void ScalarSeries::setData(int index, double x, double value) noexcept
             {
                 xAxisData()->setData(index, x);
                 valuesData()->setData(index, value);
             }
             std::unique_ptr<IDataSeries> ScalarSeries::clone() const
             {
                 return std::make_unique<ScalarSeries>(*this);
             }

plugins/amda/src/AmdaResultParser.cpp +2 -8

             #include "AmdaResultParser.h"
             #include <Data/ScalarSeries.h>
             #include <QDateTime>
             #include <QFile>
             Q_LOGGING_CATEGORY(LOG_AmdaResultParser, "AmdaResultParser")
             namespace {
             /// Format for dates in result files
             const auto DATE_FORMAT = QStringLiteral("yyyy-MM-ddThh:mm:ss.zzz");
             /// @todo ALX
             double doubleDate(const QString &stringDate) noexcept
             {
                 auto dateTime = QDateTime::fromString(stringDate, DATE_FORMAT);
                 return dateTime.toMSecsSinceEpoch() / 1000.;
             }
             } // namespace
             std::shared_ptr<IDataSeries> AmdaResultParser::readTxt(const QString &filePath) noexcept
             {
                 QFile file{filePath};
                 if (!file.open(QFile::ReadOnly | QIODevice::Text)) {
                     qCCritical(LOG_AmdaResultParser())
                         << QObject::tr("Can't retrieve AMDA data from file %1: %2")
                                .arg(filePath, file.errorString());
                     return nullptr;
                 }
                 auto xData = QVector<double>{};
                 auto valuesData = QVector<double>{};
                 QTextStream stream{&file};
                 // Ignore comment lines (3 lines)
                 stream.readLine();
                 stream.readLine();
                 stream.readLine();
                 QString line{};
                 auto lineRegex = QRegExp{QStringLiteral("\\s+")};
                 while (stream.readLineInto(&line)) {
                     auto lineData = line.split(lineRegex, QString::SkipEmptyParts);
                     if (lineData.size() == 2) {
                         // X : the data is converted from date to double (in secs)
                         xData.push_back(doubleDate(lineData.at(0)));
                         // Value
                         valuesData.push_back(lineData.at(1).toDouble());
                     }
                     else {
                         /// @todo ALX : log
                     }
                 }
                 /// @todo ALX : handle units
-                auto scalarSeries = std::make_shared<ScalarSeries>(xData.size(), Unit{"nT", true}, Unit{});
+                return std::make_shared<ScalarSeries>(std::move(xData), std::move(valuesData), Unit{"nT", true},
+                                                      Unit{});
-                const auto count = xData.size();
-                for (auto i = 0; i < count; ++i) {
-                    scalarSeries->setData(i, xData.at(i), valuesData.at(i));
-                return scalarSeries;
             }

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages