GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r1031:958f5923ee65

Updates access to y-axis properties of the data series (2)...

Alexandre Leroux -

r1031:958f5923ee65

parent child

Context file:

r1031:958f5923ee65

Collapse all files

core/include/Data/DataSeries.h +22 -3

             #ifndef SCIQLOP_DATASERIES_H
             #define SCIQLOP_DATASERIES_H
             #include "CoreGlobal.h"
             #include <Common/SortUtils.h>
             #include <Data/ArrayData.h>
             #include <Data/DataSeriesMergeHelper.h>
             #include <Data/IDataSeries.h>
             #include <Data/OptionalAxis.h>
             #include <QLoggingCategory>
             #include <QReadLocker>
             #include <QReadWriteLock>
             #include <memory>
             // We don't use the Qt macro since the log is used in the header file, which causes multiple log
             // definitions with inheritance. Inline method is used instead
             inline const QLoggingCategory &LOG_DataSeries()
             {
                 static const QLoggingCategory category{"DataSeries"};
                 return category;
             }
             template <int Dim>
             class DataSeries;
             namespace dataseries_detail {
             template <int Dim, bool IsConst>
             class IteratorValue : public DataSeriesIteratorValue::Impl {
             public:
                 friend class DataSeries<Dim>;
                 template <bool IC = IsConst, typename = std::enable_if_t<IC == false> >
                 explicit IteratorValue(DataSeries<Dim> &dataSeries, bool begin)
                         : m_XIt(begin ? dataSeries.xAxisData()->begin() : dataSeries.xAxisData()->end()),
-                          m_ValuesIt(begin ? dataSeries.valuesData()->begin() : dataSeries.valuesData()->end())
+                          m_ValuesIt(begin ? dataSeries.valuesData()->begin() : dataSeries.valuesData()->end()),
+                          m_YItBegin{dataSeries.yAxis().begin()},
+                          m_YItEnd{dataSeries.yAxis().end()}
                 {
                 }
                 template <bool IC = IsConst, typename = std::enable_if_t<IC == true> >
                 explicit IteratorValue(const DataSeries<Dim> &dataSeries, bool begin)
                         : m_XIt(begin ? dataSeries.xAxisData()->cbegin() : dataSeries.xAxisData()->cend()),
                           m_ValuesIt(begin ? dataSeries.valuesData()->cbegin()
-                                           : dataSeries.valuesData()->cend())
+                                           : dataSeries.valuesData()->cend()),
+                          m_YItBegin{dataSeries.yAxis().cbegin()},
+                          m_YItEnd{dataSeries.yAxis().cend()}
                 {
                 }
                 IteratorValue(const IteratorValue &other) = default;
                 std::unique_ptr<DataSeriesIteratorValue::Impl> clone() const override
                 {
                     return std::make_unique<IteratorValue<Dim, IsConst> >(*this);
                 }
                 int distance(const DataSeriesIteratorValue::Impl &other) const override try {
                     const auto &otherImpl = dynamic_cast<const IteratorValue &>(other);
                     return m_XIt->distance(*otherImpl.m_XIt);
                 }
                 catch (const std::bad_cast &) {
                     return 0;
                 }
                 bool equals(const DataSeriesIteratorValue::Impl &other) const override try {
                     const auto &otherImpl = dynamic_cast<const IteratorValue &>(other);
-                    return std::tie(m_XIt, m_ValuesIt) == std::tie(otherImpl.m_XIt, otherImpl.m_ValuesIt);
+                    return std::tie(m_XIt, m_ValuesIt, m_YItBegin, m_YItEnd)
+                           == std::tie(otherImpl.m_XIt, otherImpl.m_ValuesIt, otherImpl.m_YItBegin,
+                                       otherImpl.m_YItEnd);
                 }
                 catch (const std::bad_cast &) {
                     return false;
                 }
                 bool lowerThan(const DataSeriesIteratorValue::Impl &other) const override try {
                     const auto &otherImpl = dynamic_cast<const IteratorValue &>(other);
                     return m_XIt->lowerThan(*otherImpl.m_XIt);
                 }
                 catch (const std::bad_cast &) {
                     return false;
                 }
                 std::unique_ptr<DataSeriesIteratorValue::Impl> advance(int offset) const override
                 {
                     auto result = clone();
                     result->next(offset);
                     return result;
                 }
                 void next(int offset) override
                 {
                     m_XIt->next(offset);
                     m_ValuesIt->next(offset);
                 }
                 void prev() override
                 {
                     --m_XIt;
                     --m_ValuesIt;
                 }
                 double x() const override { return m_XIt->at(0); }
+                std::vector<double> y() const override
+                {
+                    std::vector<double> result{};
+                    std::transform(m_YItBegin, m_YItEnd, std::back_inserter(result),
+                                   [](const auto &it) { return it.first(); });
+                    return result;
+                }
                 double value() const override { return m_ValuesIt->at(0); }
                 double value(int componentIndex) const override { return m_ValuesIt->at(componentIndex); }
                 double minValue() const override { return m_ValuesIt->min(); }
                 double maxValue() const override { return m_ValuesIt->max(); }
                 QVector<double> values() const override { return m_ValuesIt->values(); }
                 void swap(DataSeriesIteratorValue::Impl &other) override
                 {
                     auto &otherImpl = dynamic_cast<IteratorValue &>(other);
                     m_XIt->impl()->swap(*otherImpl.m_XIt->impl());
                     m_ValuesIt->impl()->swap(*otherImpl.m_ValuesIt->impl());
+                    m_YItBegin->impl()->swap(*otherImpl.m_YItBegin->impl());
+                    m_YItEnd->impl()->swap(*otherImpl.m_YItEnd->impl());
                 }
             private:
                 ArrayDataIterator m_XIt;
                 ArrayDataIterator m_ValuesIt;
+                ArrayDataIterator m_YItBegin;
+                ArrayDataIterator m_YItEnd;
             };
             } // namespace dataseries_detail
             /**
              * @brief The DataSeries class is the base (abstract) implementation of IDataSeries.
              *
              * The DataSeries represents values on one or two axes, according to these rules:
              * - the x-axis is always defined
              * - an y-axis can be defined or not. If set, additional consistency checks apply to the values (see
              * below)
              * - the values are defined on one or two dimensions. In the case of 2-dim values, the data is
              * distributed into components (for example, a vector defines three components)
              * - New values can be added to the series, on the x-axis.
              * - Once initialized to the series creation, the y-axis (if defined) is no longer modifiable
              * - Data representing values and axes are associated with a unit
              * - The data series is always sorted in ascending order on the x-axis.
              *
              * Consistency checks are carried out between the axes and the values. These controls are provided
              * throughout the DataSeries lifecycle:
              * - the number of data on the x-axis must be equal to the number of values (in the case of
              * 2-dim ArrayData for values, the test is performed on the number of values per component)
              * - if the y-axis is defined, the number of components of the ArrayData for values must equal the
              * number of data on the y-axis.
              *
              * Examples:
              * 1)
              * - x-axis: [1 ; 2 ; 3]
              * - y-axis: not defined
              * - values: [10 ; 20 ; 30] (1-dim ArrayData)
              * => the DataSeries is valid, as x-axis and values have the same number of data
              *
              * 2)
              * - x-axis: [1 ; 2 ; 3]
              * - y-axis: not defined
              * - values: [10 ; 20 ; 30 ; 40] (1-dim ArrayData)
              * => the DataSeries is invalid, as x-axis and values haven't the same number of data
              *
              * 3)
              * - x-axis: [1 ; 2 ; 3]
              * - y-axis: not defined
              * - values: [10 ; 20 ; 30
              *            40 ; 50 ; 60] (2-dim ArrayData)
              * => the DataSeries is valid, as x-axis has 3 data and values contains 2 components with 3
              * data each
              *
              * 4)
              * - x-axis: [1 ; 2 ; 3]
              * - y-axis: [1 ; 2]
              * - values: [10 ; 20 ; 30
              *            40 ; 50 ; 60] (2-dim ArrayData)
              * => the DataSeries is valid, as:
              * - x-axis has 3 data and values contains 2 components with 3 data each AND
              * - y-axis has 2 data and values contains 2 components
              *
              * 5)
              * - x-axis: [1 ; 2 ; 3]
              * - y-axis: [1 ; 2 ; 3]
              * - values: [10 ; 20 ; 30
              *            40 ; 50 ; 60] (2-dim ArrayData)
              * => the DataSeries is invalid, as:
              * - x-axis has 3 data and values contains 2 components with 3 data each BUT
              * - y-axis has 3 data and values contains only 2 components
              *
              * @tparam Dim The dimension of the values data
              *
              */
             template <int Dim>
             class SCIQLOP_CORE_EXPORT DataSeries : public IDataSeries {
                 friend class DataSeriesMergeHelper;
             public:
                 /// @sa IDataSeries::xAxisData()
                 std::shared_ptr<ArrayData<1> > xAxisData() override { return m_XAxisData; }
                 const std::shared_ptr<ArrayData<1> > xAxisData() const { return m_XAxisData; }
                 /// @sa IDataSeries::xAxisUnit()
                 Unit xAxisUnit() const override { return m_XAxisUnit; }
                 /// @sa IDataSeries::yAxisUnit()
                 Unit yAxisUnit() const override { return m_YAxis.unit(); }
                 /// @return the values dataset
                 std::shared_ptr<ArrayData<Dim> > valuesData() { return m_ValuesData; }
                 const std::shared_ptr<ArrayData<Dim> > valuesData() const { return m_ValuesData; }
                 /// @sa IDataSeries::valuesUnit()
                 Unit valuesUnit() const override { return m_ValuesUnit; }
                 int nbPoints() const override { return m_ValuesData->totalSize(); }
                 std::pair<double, double> yBounds() const override { return m_YAxis.bounds(); }
                 void clear()
                 {
                     m_XAxisData->clear();
                     m_ValuesData->clear();
                 }
                 bool isEmpty() const noexcept { return m_XAxisData->size() == 0; }
                 /// Merges into the data series an other data series.
                 ///
                 /// The two dataseries:
                 /// - must be of the same dimension
                 /// - must have the same y-axis (if defined)
                 ///
                 /// If the prerequisites are not valid, the method does nothing
                 ///
                 /// @remarks the data series to merge with is cleared after the operation
                 void merge(IDataSeries *dataSeries) override
                 {
                     dataSeries->lockWrite();
                     lockWrite();
                     if (auto other = dynamic_cast<DataSeries<Dim> *>(dataSeries)) {
                         if (m_YAxis == other->m_YAxis) {
                             DataSeriesMergeHelper::merge(*other, *this);
                         }
                         else {
                             qCWarning(LOG_DataSeries())
                                 << QObject::tr("Can't merge data series that have not the same y-axis");
                         }
                     }
                     else {
                         qCWarning(LOG_DataSeries())
                             << QObject::tr("Detection of a type of IDataSeries we cannot merge with !");
                     }
                     unlock();
                     dataSeries->unlock();
                 }
                 void purge(double min, double max) override
                 {
                     // Nothing to purge if series is empty
                     if (isEmpty()) {
                         return;
                     }
                     if (min > max) {
                         std::swap(min, max);
                     }
                     // Nothing to purge if series min/max are inside purge range
                     auto xMin = cbegin()->x();
                     auto xMax = (--cend())->x();
                     if (xMin >= min && xMax <= max) {
                         return;
                     }
                     auto lowerIt = std::lower_bound(
                         begin(), end(), min, [](const auto &it, const auto &val) { return it.x() < val; });
                     erase(begin(), lowerIt);
                     auto upperIt = std::upper_bound(
                         begin(), end(), max, [](const auto &val, const auto &it) { return val < it.x(); });
                     erase(upperIt, end());
                 }
                 // ///////// //
                 // Iterators //
                 // ///////// //
                 DataSeriesIterator begin() override
                 {
                     return DataSeriesIterator{DataSeriesIteratorValue{
                         std::make_unique<dataseries_detail::IteratorValue<Dim, false> >(*this, true)}};
                 }
                 DataSeriesIterator end() override
                 {
                     return DataSeriesIterator{DataSeriesIteratorValue{
                         std::make_unique<dataseries_detail::IteratorValue<Dim, false> >(*this, false)}};
                 }
                 DataSeriesIterator cbegin() const override
                 {
                     return DataSeriesIterator{DataSeriesIteratorValue{
                         std::make_unique<dataseries_detail::IteratorValue<Dim, true> >(*this, true)}};
                 }
                 DataSeriesIterator cend() const override
                 {
                     return DataSeriesIterator{DataSeriesIteratorValue{
                         std::make_unique<dataseries_detail::IteratorValue<Dim, true> >(*this, false)}};
                 }
                 void erase(DataSeriesIterator first, DataSeriesIterator last)
                 {
                     auto firstImpl
                         = dynamic_cast<dataseries_detail::IteratorValue<Dim, false> *>(first->impl());
                     auto lastImpl = dynamic_cast<dataseries_detail::IteratorValue<Dim, false> *>(last->impl());
                     if (firstImpl && lastImpl) {
                         m_XAxisData->erase(firstImpl->m_XIt, lastImpl->m_XIt);
                         m_ValuesData->erase(firstImpl->m_ValuesIt, lastImpl->m_ValuesIt);
                     }
                 }
                 void insert(DataSeriesIterator first, DataSeriesIterator last, bool prepend = false)
                 {
                     auto firstImpl = dynamic_cast<dataseries_detail::IteratorValue<Dim, true> *>(first->impl());
                     auto lastImpl = dynamic_cast<dataseries_detail::IteratorValue<Dim, true> *>(last->impl());
                     if (firstImpl && lastImpl) {
                         m_XAxisData->insert(firstImpl->m_XIt, lastImpl->m_XIt, prepend);
                         m_ValuesData->insert(firstImpl->m_ValuesIt, lastImpl->m_ValuesIt, prepend);
                     }
                 }
                 /// @sa IDataSeries::minXAxisData()
                 DataSeriesIterator minXAxisData(double minXAxisData) const override
                 {
                     return std::lower_bound(
                         cbegin(), cend(), minXAxisData,
                         [](const auto &itValue, const auto &value) { return itValue.x() < value; });
                 }
                 /// @sa IDataSeries::maxXAxisData()
                 DataSeriesIterator maxXAxisData(double maxXAxisData) const override
                 {
                     // Gets the first element that greater than max value
                     auto it = std::upper_bound(
                         cbegin(), cend(), maxXAxisData,
                         [](const auto &value, const auto &itValue) { return value < itValue.x(); });
                     return it == cbegin() ? cend() : --it;
                 }
                 std::pair<DataSeriesIterator, DataSeriesIterator> xAxisRange(double minXAxisData,
                                                                              double maxXAxisData) const override
                 {
                     if (minXAxisData > maxXAxisData) {
                         std::swap(minXAxisData, maxXAxisData);
                     }
                     auto begin = cbegin();
                     auto end = cend();
                     auto lowerIt = std::lower_bound(
                         begin, end, minXAxisData,
                         [](const auto &itValue, const auto &value) { return itValue.x() < value; });
                     auto upperIt = std::upper_bound(
                         lowerIt, end, maxXAxisData,
                         [](const auto &value, const auto &itValue) { return value < itValue.x(); });
                     return std::make_pair(lowerIt, upperIt);
                 }
                 std::pair<DataSeriesIterator, DataSeriesIterator>
                 valuesBounds(double minXAxisData, double maxXAxisData) const override
                 {
                     // Places iterators to the correct x-axis range
                     auto xAxisRangeIts = xAxisRange(minXAxisData, maxXAxisData);
                     // Returns end iterators if the range is empty
                     if (xAxisRangeIts.first == xAxisRangeIts.second) {
                         return std::make_pair(cend(), cend());
                     }
                     // Gets the iterator on the min of all values data
                     auto minIt = std::min_element(
                         xAxisRangeIts.first, xAxisRangeIts.second, [](const auto &it1, const auto &it2) {
                             return SortUtils::minCompareWithNaN(it1.minValue(), it2.minValue());
                         });
                     // Gets the iterator on the max of all values data
                     auto maxIt = std::max_element(
                         xAxisRangeIts.first, xAxisRangeIts.second, [](const auto &it1, const auto &it2) {
                             return SortUtils::maxCompareWithNaN(it1.maxValue(), it2.maxValue());
                         });
                     return std::make_pair(minIt, maxIt);
                 }
                 /// @return the y-axis associated to the data series
                 const OptionalAxis &yAxis() const { return m_YAxis; }
                 OptionalAxis &yAxis() { return m_YAxis; }
                 // /////// //
                 // Mutexes //
                 // /////// //
                 virtual void lockRead() { m_Lock.lockForRead(); }
                 virtual void lockWrite() { m_Lock.lockForWrite(); }
                 virtual void unlock() { m_Lock.unlock(); }
             protected:
                 /// Protected ctor (DataSeries is abstract).
                 ///
                 /// Data vectors must be consistent with each other, otherwise an exception will be thrown (@sa
                 /// class description for consistent rules)
                 /// @remarks data series is automatically sorted on its x-axis data
                 /// @throws std::invalid_argument if the data are inconsistent with each other
                 explicit DataSeries(std::shared_ptr<ArrayData<1> > xAxisData, const Unit &xAxisUnit,
                                     std::shared_ptr<ArrayData<Dim> > valuesData, const Unit &valuesUnit,
                                     OptionalAxis yAxis = OptionalAxis{})
                         : m_XAxisData{xAxisData},
                           m_XAxisUnit{xAxisUnit},
                           m_ValuesData{valuesData},
                           m_ValuesUnit{valuesUnit},
                           m_YAxis{std::move(yAxis)}
                 {
                     if (m_XAxisData->size() != m_ValuesData->size()) {
                         throw std::invalid_argument{
                             "The number of values by component must be equal to the number of x-axis data"};
                     }
                     // Validates y-axis (if defined)
                     if (yAxis.isDefined() && (yAxis.size() != m_ValuesData->componentCount())) {
                         throw std::invalid_argument{
                             "As the y-axis is defined, the number of value components must be equal to the "
                             "number of y-axis data"};
                     }
                     // Sorts data if it's not the case
                     const auto &xAxisCData = m_XAxisData->cdata();
                     if (!std::is_sorted(xAxisCData.cbegin(), xAxisCData.cend())) {
                         sort();
                     }
                 }
                 /// Copy ctor
                 explicit DataSeries(const DataSeries<Dim> &other)
                         : m_XAxisData{std::make_shared<ArrayData<1> >(*other.m_XAxisData)},
                           m_XAxisUnit{other.m_XAxisUnit},
                           m_ValuesData{std::make_shared<ArrayData<Dim> >(*other.m_ValuesData)},
                           m_ValuesUnit{other.m_ValuesUnit},
                           m_YAxis{other.m_YAxis}
                 {
                     // Since a series is ordered from its construction and is always ordered, it is not
                     // necessary to call the sort method here ('other' is sorted)
                 }
                 /// Assignment operator
                 template <int D>
                 DataSeries &operator=(DataSeries<D> other)
                 {
                     std::swap(m_XAxisData, other.m_XAxisData);
                     std::swap(m_XAxisUnit, other.m_XAxisUnit);
                     std::swap(m_ValuesData, other.m_ValuesData);
                     std::swap(m_ValuesUnit, other.m_ValuesUnit);
                     std::swap(m_YAxis, other.m_YAxis);
                     return *this;
                 }
             private:
                 /**
                  * Sorts data series on its x-axis data
                  */
                 void sort() noexcept
                 {
                     auto permutation = SortUtils::sortPermutation(*m_XAxisData, std::less<double>());
                     m_XAxisData = m_XAxisData->sort(permutation);
                     m_ValuesData = m_ValuesData->sort(permutation);
                 }
                 // x-axis
                 std::shared_ptr<ArrayData<1> > m_XAxisData;
                 Unit m_XAxisUnit;
                 // values
                 std::shared_ptr<ArrayData<Dim> > m_ValuesData;
                 Unit m_ValuesUnit;
                 // y-axis (optional)
                 OptionalAxis m_YAxis;
                 QReadWriteLock m_Lock;
             };
             #endif // SCIQLOP_DATASERIES_H

core/include/Data/DataSeriesIterator.h +3 0

             #ifndef SCIQLOP_DATASERIESITERATOR_H
             #define SCIQLOP_DATASERIESITERATOR_H
             #include "CoreGlobal.h"
             #include "Data/SqpIterator.h"
             #include <QVector>
             #include <memory>
             /**
              * @brief The DataSeriesIteratorValue class represents the current value of a data series iterator.
              * It offers standard access methods for the data in the series (x-axis, values), but it is up to
              * each series to define its own implementation of how to retrieve this data, by implementing the
              * DataSeriesIteratorValue::Impl interface
              *
              * @sa DataSeriesIterator
              */
             class SCIQLOP_CORE_EXPORT DataSeriesIteratorValue {
             public:
                 struct Impl {
                     virtual ~Impl() noexcept = default;
                     virtual std::unique_ptr<Impl> clone() const = 0;
                     virtual int distance(const Impl &other) const = 0;
                     virtual bool equals(const Impl &other) const = 0;
                     virtual bool lowerThan(const Impl &other) const = 0;
                     virtual std::unique_ptr<Impl> advance(int offset) const = 0;
                     virtual void next(int offset) = 0;
                     virtual void prev() = 0;
                     virtual double x() const = 0;
+                    virtual std::vector<double> y() const = 0;
                     virtual double value() const = 0;
                     virtual double value(int componentIndex) const = 0;
                     virtual double minValue() const = 0;
                     virtual double maxValue() const = 0;
                     virtual QVector<double> values() const = 0;
                     virtual void swap(Impl &other) = 0;
                 };
                 explicit DataSeriesIteratorValue(std::unique_ptr<Impl> impl);
                 DataSeriesIteratorValue(const DataSeriesIteratorValue &other);
                 DataSeriesIteratorValue &operator=(DataSeriesIteratorValue other);
                 int distance(const DataSeriesIteratorValue &other) const;
                 bool equals(const DataSeriesIteratorValue &other) const;
                 bool lowerThan(const DataSeriesIteratorValue &other) const;
                 DataSeriesIteratorValue advance(int offset) const;
                 /// Advances to the next value
                 void next(int offset = 1);
                 /// Moves back to the previous value
                 void prev();
                 /// Gets x-axis data
                 double x() const;
+                /// Gets y-axis data
+                std::vector<double> y() const;
                 /// Gets value data
                 double value() const;
                 /// Gets value data depending on an index
                 double value(int componentIndex) const;
                 /// Gets min of all values data
                 double minValue() const;
                 /// Gets max of all values data
                 double maxValue() const;
                 /// Gets all values data
                 QVector<double> values() const;
                 Impl *impl();
                 friend void swap(DataSeriesIteratorValue &lhs, DataSeriesIteratorValue &rhs)
                 {
                     std::swap(lhs.m_Impl, rhs.m_Impl);
                 }
             private:
                 std::unique_ptr<Impl> m_Impl;
             };
             using DataSeriesIterator = SqpIterator<DataSeriesIteratorValue>;
             #endif // SCIQLOP_DATASERIESITERATOR_H

core/include/Data/OptionalAxis.h +8 -4

             #ifndef SCIQLOP_OPTIONALAXIS_H
             #define SCIQLOP_OPTIONALAXIS_H
+            #include <Data/ArrayDataIterator.h>
             #include "CoreGlobal.h"
             #include "Unit.h"
             #include <memory>
             template <int Dim>
             class ArrayData;
             /**
              * @brief The OptionalAxis class defines an optional data axis for a series of data.
              *
              * An optional data axis is an axis that can be defined or not for a data series. If defined, it
              * contains a unit and data (1-dim ArrayData). It is then possible to access the data or the unit.
              * In the case of an undefined axis, the axis has no data and no unit. The methods for accessing the
              * data or the unit are always callable but will return undefined values.
              *
              * @sa DataSeries
              * @sa ArrayData
              */
             class SCIQLOP_CORE_EXPORT OptionalAxis {
             public:
                 /// Ctor for an undefined axis
                 explicit OptionalAxis();
                 /// Ctor for a defined axis
                 /// @param data the axis' data
                 /// @param unit the axis' unit
                 /// @throws std::invalid_argument if no data is associated to the axis
                 explicit OptionalAxis(std::shared_ptr<ArrayData<1> > data, Unit unit);
                 /// Copy ctor
                 OptionalAxis(const OptionalAxis &other);
                 /// Assignment operator
                 OptionalAxis &operator=(OptionalAxis other);
                 /// @return the flag that indicates if the axis is defined or not
                 bool isDefined() const;
-                /// @return gets the data at the index passed in parameter, NaN if the index is outside the
-                /// bounds of the axis, or if the axis is undefined
-                double at(int index) const;
                 ///@return the min and max values of the data on the axis, NaN values if there is no data
                 std::pair<double, double> bounds() const;
                 /// @return the number of data on the axis, 0 if the axis is not defined
                 int size() const;
                 /// @return the unit of the axis, an empty unit if the axis is not defined
                 Unit unit() const;
                 bool operator==(const OptionalAxis &other);
                 bool operator!=(const OptionalAxis &other);
+                // Iterators on data
+                ArrayDataIterator begin();
+                ArrayDataIterator end();
+                ArrayDataIterator cbegin() const;
+                ArrayDataIterator cend() const;
             private:
                 bool m_Defined;                        ///< Axis is defined or not
                 std::shared_ptr<ArrayData<1> > m_Data; ///< Axis' data
                 Unit m_Unit;                           ///< Axis' unit
             };
             #endif // SCIQLOP_OPTIONALAXIS_H

core/src/Data/DataSeriesIterator.cpp +5 0

             #include "Data/DataSeriesIterator.h"
             DataSeriesIteratorValue::DataSeriesIteratorValue(
                 std::unique_ptr<DataSeriesIteratorValue::Impl> impl)
                     : m_Impl{std::move(impl)}
             {
             }
             DataSeriesIteratorValue::DataSeriesIteratorValue(const DataSeriesIteratorValue &other)
                     : m_Impl{other.m_Impl->clone()}
             {
             }
             DataSeriesIteratorValue &DataSeriesIteratorValue::operator=(DataSeriesIteratorValue other)
             {
                 m_Impl->swap(*other.m_Impl);
                 return *this;
             }
             int DataSeriesIteratorValue::distance(const DataSeriesIteratorValue &other) const
             {
                 return m_Impl->distance(*other.m_Impl);
             }
             bool DataSeriesIteratorValue::equals(const DataSeriesIteratorValue &other) const
             {
                 return m_Impl->equals(*other.m_Impl);
             }
             bool DataSeriesIteratorValue::lowerThan(const DataSeriesIteratorValue &other) const
             {
                 return m_Impl->lowerThan(*other.m_Impl);
             }
             DataSeriesIteratorValue DataSeriesIteratorValue::advance(int offset) const
             {
                 return DataSeriesIteratorValue{m_Impl->advance(offset)};
             }
             void DataSeriesIteratorValue::next(int offset)
             {
                 m_Impl->next(offset);
             }
             void DataSeriesIteratorValue::prev()
             {
                 m_Impl->prev();
             }
             double DataSeriesIteratorValue::x() const
             {
                 return m_Impl->x();
             }
+            std::vector<double> DataSeriesIteratorValue::y() const
+            {
+                return m_Impl->y();
+            }
             double DataSeriesIteratorValue::value() const
             {
                 return m_Impl->value();
             }
             double DataSeriesIteratorValue::value(int componentIndex) const
             {
                 return m_Impl->value(componentIndex);
             }
             double DataSeriesIteratorValue::minValue() const
             {
                 return m_Impl->minValue();
             }
             double DataSeriesIteratorValue::maxValue() const
             {
                 return m_Impl->maxValue();
             }
             QVector<double> DataSeriesIteratorValue::values() const
             {
                 return m_Impl->values();
             }
             DataSeriesIteratorValue::Impl *DataSeriesIteratorValue::impl()
             {
                 return m_Impl.get();
             }

core/src/Data/OptionalAxis.cpp +23 -15

             #include <Data/OptionalAxis.h>
             #include "Data/ArrayData.h"
-            OptionalAxis::OptionalAxis() : m_Defined{false}, m_Data{nullptr}, m_Unit{}
+            OptionalAxis::OptionalAxis()
+                    : m_Defined{false}, m_Data{std::make_shared<ArrayData<1> >(std::vector<double>{})}, m_Unit{}
             {
             }
             OptionalAxis::OptionalAxis(std::shared_ptr<ArrayData<1> > data, Unit unit)
                     : m_Defined{true}, m_Data{data}, m_Unit{std::move(unit)}
             {
                 if (m_Data == nullptr) {
                     throw std::invalid_argument{"Data can't be null for a defined axis"};
                 }
             }
             OptionalAxis::OptionalAxis(const OptionalAxis &other)
-                    : m_Defined{other.m_Defined},
+                    : m_Defined{other.m_Defined}, m_Data{other.m_Data}, m_Unit{other.m_Unit}
-                      m_Data{other.m_Data ? std::make_shared<ArrayData<1> >(*other.m_Data) : nullptr},
-                      m_Unit{other.m_Unit}
             {
             }
             OptionalAxis &OptionalAxis::operator=(OptionalAxis other)
             {
                 std::swap(m_Defined, other.m_Defined);
                 std::swap(m_Data, other.m_Data);
                 std::swap(m_Unit, other.m_Unit);
                 return *this;
             }
             bool OptionalAxis::isDefined() const
             {
                 return m_Defined;
             }
-            double OptionalAxis::at(int index) const
-                if (m_Defined) {
-                    return (index >= 0 && index < m_Data->size()) ? m_Data->at(index)
-                                                                  : std::numeric_limits<double>::quiet_NaN();
-                else {
-                    return std::numeric_limits<double>::quiet_NaN();
             std::pair<double, double> OptionalAxis::bounds() const
             {
                 if (!m_Defined || m_Data->size() == 0) {
                     return std::make_pair(std::numeric_limits<double>::quiet_NaN(),
                                           std::numeric_limits<double>::quiet_NaN());
                 }
                 else {
                     auto minIt = std::min_element(
                         m_Data->cbegin(), m_Data->cend(), [](const auto &it1, const auto &it2) {
                             return SortUtils::minCompareWithNaN(it1.first(), it2.first());
                         });
                     // Gets the iterator on the max of all values data
                     auto maxIt = std::max_element(
                         m_Data->cbegin(), m_Data->cend(), [](const auto &it1, const auto &it2) {
                             return SortUtils::maxCompareWithNaN(it1.first(), it2.first());
                         });
                     return std::make_pair(minIt->first(), maxIt->first());
                 }
             }
             int OptionalAxis::size() const
             {
                 return m_Defined ? m_Data->size() : 0;
             }
             Unit OptionalAxis::unit() const
             {
                 return m_Defined ? m_Unit : Unit{};
             }
             bool OptionalAxis::operator==(const OptionalAxis &other)
             {
                 // Axis not defined
                 if (!m_Defined) {
                     return !other.m_Defined;
                 }
                 // Axis defined
                 return m_Unit == other.m_Unit
                        && std::equal(
                               m_Data->cbegin(), m_Data->cend(), other.m_Data->cbegin(), other.m_Data->cend(),
                               [](const auto &it1, const auto &it2) { return it1.values() == it2.values(); });
             }
             bool OptionalAxis::operator!=(const OptionalAxis &other)
             {
                 return !(*this == other);
             }
+            ArrayDataIterator OptionalAxis::begin()
+            {
+                return m_Data->begin();
+            }
+            ArrayDataIterator OptionalAxis::end()
+            {
+                return m_Data->end();
+            }
+            ArrayDataIterator OptionalAxis::cbegin() const
+            {
+                return m_Data->cbegin();
+            }
+            ArrayDataIterator OptionalAxis::cend() const
+            {
+                return m_Data->cend();
+            }

core/tests/Data/TestOptionalAxis.cpp 0 -37

             #include <Data/ArrayData.h>
             #include <Data/OptionalAxis.h>
             #include <QObject>
             #include <QtTest>
             Q_DECLARE_METATYPE(OptionalAxis)
             class TestOptionalAxis : public QObject {
                 Q_OBJECT
             private slots:
                 /// Tests the creation of a undefined axis
                 void testNotDefinedAxisCtor();
                 /// Tests the creation of a undefined axis
                 void testDefinedAxisCtor_data();
                 void testDefinedAxisCtor();
-                /// Tests @sa OptionalAxis::at() method
-                void testAt_data();
-                void testAt();
                 /// Tests @sa OptionalAxis::size() method
                 void testSize_data();
                 void testSize();
                 /// Tests @sa OptionalAxis::unit() method
                 void testUnit_data();
                 void testUnit();
             };
             void TestOptionalAxis::testNotDefinedAxisCtor()
             {
                 OptionalAxis notDefinedAxis{};
                 QVERIFY(!notDefinedAxis.isDefined());
             }
             void TestOptionalAxis::testDefinedAxisCtor_data()
             {
                 QTest::addColumn<bool>("noData"); // If set to true, nullptr is passed as data of the axis
                 QTest::addColumn<std::vector<double> >(
                     "data"); // Values assigned to the axis when 'noData' flag is set to false
                 QTest::addColumn<Unit>("unit"); // Unit assigned to the axis
                 QTest::newRow("validData") << false << std::vector<double>{1, 2, 3} << Unit{"Hz"};
                 QTest::newRow("invalidData") << true << std::vector<double>{} << Unit{"Hz"};
             }
             void TestOptionalAxis::testDefinedAxisCtor()
             {
                 QFETCH(bool, noData);
                 QFETCH(Unit, unit);
                 // When there is no data, we expect that the constructor returns exception
                 if (noData) {
                     QVERIFY_EXCEPTION_THROWN(OptionalAxis(nullptr, unit), std::invalid_argument);
                 }
                 else {
                     QFETCH(std::vector<double>, data);
                     OptionalAxis axis{std::make_shared<ArrayData<1> >(data), unit};
                     QVERIFY(axis.isDefined());
                 }
             }
-            void TestOptionalAxis::testAt_data()
-                QTest::addColumn<OptionalAxis>("axis");    // Axis used for test case (defined or not)
-                QTest::addColumn<int>("index");            // Index to test in the axis
-                QTest::addColumn<double>("expectedValue"); // Expected axis value for the index
-                OptionalAxis definedAxis{std::make_shared<ArrayData<1> >(std::vector<double>{1, 2, 3}),
-                                         Unit{"Hz"}};
-                QTest::newRow("data1") << definedAxis << 0 << 1.;
-                QTest::newRow("data2") << definedAxis << 1 << 2.;
-                QTest::newRow("data3") << definedAxis << 2 << 3.;
-                QTest::newRow("data4 (index out of bounds)")
-                    << definedAxis << 3
-                    << std::numeric_limits<double>::quiet_NaN(); // Expects NaN for out of bounds index
-                QTest::newRow("data5 (index out of bounds)")
-                    << definedAxis << -1
-                    << std::numeric_limits<double>::quiet_NaN(); // Expects NaN for out of bounds index
-                QTest::newRow("data6 (axis not defined)")
-                    << OptionalAxis{} << 0
-                    << std::numeric_limits<double>::quiet_NaN(); // Expects NaN for undefined axis
-            void TestOptionalAxis::testAt()
-                QFETCH(OptionalAxis, axis);
-                QFETCH(int, index);
-                QFETCH(double, expectedValue);
-                auto value = axis.at(index);
-                QVERIFY((std::isnan(value) && std::isnan(expectedValue)) || value == expectedValue);
             void TestOptionalAxis::testSize_data()
             {
                 QTest::addColumn<OptionalAxis>("axis"); // Axis used for test case (defined or not)
                 QTest::addColumn<int>("expectedSize");  // Expected number of data in the axis
                 // Lambda that creates default defined axis (with the values passed in parameter)
                 auto axis = [](std::vector<double> values) {
                     return OptionalAxis{std::make_shared<ArrayData<1> >(std::move(values)), Unit{"Hz"}};
                 };
                 QTest::newRow("data1") << axis({}) << 0;
                 QTest::newRow("data2") << axis({1, 2, 3}) << 3;
                 QTest::newRow("data3") << axis({1, 2, 3, 4}) << 4;
                 QTest::newRow("data4 (axis not defined)") << OptionalAxis{}
                                                           << 0; // Expects 0 for undefined axis
             }
             void TestOptionalAxis::testSize()
             {
                 QFETCH(OptionalAxis, axis);
                 QFETCH(int, expectedSize);
                 QCOMPARE(axis.size(), expectedSize);
             }
             void TestOptionalAxis::testUnit_data()
             {
                 QTest::addColumn<OptionalAxis>("axis"); // Axis used for test case (defined or not)
                 QTest::addColumn<Unit>("expectedUnit"); // Expected unit for the axis
                 // Lambda that creates default defined axis (with the unit passed in parameter)
                 auto axis = [](Unit unit) {
                     return OptionalAxis{std::make_shared<ArrayData<1> >(std::vector<double>{1, 2, 3}), unit};
                 };
                 QTest::newRow("data1") << axis(Unit{"Hz"}) << Unit{"Hz"};
                 QTest::newRow("data2") << axis(Unit{"t", true}) << Unit{"t", true};
                 QTest::newRow("data3 (axis not defined)") << OptionalAxis{}
                                                           << Unit{}; // Expects default unit for undefined axis
             }
             void TestOptionalAxis::testUnit()
             {
                 QFETCH(OptionalAxis, axis);
                 QFETCH(Unit, expectedUnit);
                 QCOMPARE(axis.unit(), expectedUnit);
             }
             QTEST_MAIN(TestOptionalAxis)
             #include "TestOptionalAxis.moc"

plugins/amda/tests/TestAmdaResultParser.cpp +4 -5

             #include "AmdaResultParser.h"
             #include <Data/ScalarSeries.h>
             #include <Data/SpectrogramSeries.h>
             #include <Data/VectorSeries.h>
             #include <QObject>
             #include <QtTest>
             namespace {
             /// Path for the tests
             const auto TESTS_RESOURCES_PATH
                 = QFileInfo{QString{AMDA_TESTS_RESOURCES_DIR}, "TestAmdaResultParser"}.absoluteFilePath();
             QDateTime dateTime(int year, int month, int day, int hours, int minutes, int seconds)
             {
                 return QDateTime{{year, month, day}, {hours, minutes, seconds}, Qt::UTC};
             }
             QString inputFilePath(const QString &inputFileName)
             {
                 return QFileInfo{TESTS_RESOURCES_PATH, inputFileName}.absoluteFilePath();
             }
             template <typename T>
             struct ExpectedResults {
                 ExpectedResults &setParsingOK(bool parsingOK)
                 {
                     m_ParsingOK = parsingOK;
                     return *this;
                 }
                 ExpectedResults &setXAxisUnit(Unit xAxisUnit)
                 {
                     m_XAxisUnit = std::move(xAxisUnit);
                     return *this;
                 }
                 ExpectedResults &setXAxisData(const QVector<QDateTime> &xAxisData)
                 {
                     m_XAxisData.clear();
                     // Converts QVector<QDateTime> to QVector<double>
                     std::transform(xAxisData.cbegin(), xAxisData.cend(), std::back_inserter(m_XAxisData),
                                    [](const auto &dateTime) { return dateTime.toMSecsSinceEpoch() / 1000.; });
                     return *this;
                 }
                 ExpectedResults &setValuesUnit(Unit valuesUnit)
                 {
                     m_ValuesUnit = std::move(valuesUnit);
                     return *this;
                 }
                 ExpectedResults &setValuesData(QVector<double> valuesData)
                 {
                     m_ValuesData.clear();
                     m_ValuesData.push_back(std::move(valuesData));
                     return *this;
                 }
                 ExpectedResults &setValuesData(QVector<QVector<double> > valuesData)
                 {
                     m_ValuesData = std::move(valuesData);
                     return *this;
                 }
                 ExpectedResults &setYAxisEnabled(bool yAxisEnabled)
                 {
                     m_YAxisEnabled = yAxisEnabled;
                     return *this;
                 }
                 ExpectedResults &setYAxisUnit(Unit yAxisUnit)
                 {
                     m_YAxisUnit = std::move(yAxisUnit);
                     return *this;
                 }
                 ExpectedResults &setYAxisData(QVector<double> yAxisData)
                 {
                     m_YAxisData = std::move(yAxisData);
                     return *this;
                 }
                 /**
                  * Validates a DataSeries compared to the expected results
                  * @param results the DataSeries to validate
                  */
                 void validate(std::shared_ptr<IDataSeries> results)
                 {
                     if (m_ParsingOK) {
                         auto dataSeries = dynamic_cast<T *>(results.get());
                         if (dataSeries == nullptr) {
                             // No unit detected, parsink ok but data is nullptr
                             // TODO, improve the test to verify that the data is null
                             return;
                         }
                         // Checks units
                         QVERIFY(dataSeries->xAxisUnit() == m_XAxisUnit);
                         QVERIFY(dataSeries->valuesUnit() == m_ValuesUnit);
                         auto verifyRange = [dataSeries](const auto &expectedData, const auto &equalFun) {
                             QVERIFY(std::equal(dataSeries->cbegin(), dataSeries->cend(), expectedData.cbegin(),
                                                expectedData.cend(),
                                                [&equalFun](const auto &dataSeriesIt, const auto &expectedX) {
                                                    return equalFun(dataSeriesIt, expectedX);
                                                }));
                         };
                         // Checks x-axis data
                         verifyRange(m_XAxisData, [](const auto &seriesIt, const auto &value) {
                             return seriesIt.x() == value;
                         });
                         // Checks values data of each component
                         for (auto i = 0; i < m_ValuesData.size(); ++i) {
                             verifyRange(m_ValuesData.at(i), [i](const auto &seriesIt, const auto &value) {
                                 auto itValue = seriesIt.value(i);
                                 return (std::isnan(itValue) && std::isnan(value)) || seriesIt.value(i) == value;
                             });
                         }
                         // Checks y-axis (if defined)
                         auto yAxis = dataSeries->yAxis();
                         QCOMPARE(yAxis.isDefined(), m_YAxisEnabled);
                         if (m_YAxisEnabled) {
                             // Unit
                             QCOMPARE(yAxis.unit(), m_YAxisUnit);
                             // Data
-                            auto yAxisSize = yAxis.size();
+                            QVERIFY(std::equal(yAxis.cbegin(), yAxis.cend(), m_YAxisData.cbegin(),
-                            QCOMPARE(yAxisSize, m_YAxisData.size());
+                                               m_YAxisData.cend(), [](const auto &it, const auto &expectedVal) {
-                            for (auto i = 0; i < yAxisSize; ++i) {
+                                                   return it.first() == expectedVal;
-                                QCOMPARE(yAxis.at(i), m_YAxisData.at(i));
+                                               }));
                         }
                     }
                     else {
                         QVERIFY(results == nullptr);
                     }
                 }
                 // Parsing was successfully completed
                 bool m_ParsingOK{false};
                 // Expected x-axis unit
                 Unit m_XAxisUnit{};
                 // Expected x-axis data
                 QVector<double> m_XAxisData{};
                 // Expected values unit
                 Unit m_ValuesUnit{};
                 // Expected values data
                 QVector<QVector<double> > m_ValuesData{};
                 // Expected data series has y-axis
                 bool m_YAxisEnabled{false};
                 // Expected y-axis unit (if axis defined)
                 Unit m_YAxisUnit{};
                 // Expected y-axis data (if axis defined)
                 QVector<double> m_YAxisData{};
             };
             } // namespace
             Q_DECLARE_METATYPE(ExpectedResults<ScalarSeries>)
             Q_DECLARE_METATYPE(ExpectedResults<SpectrogramSeries>)
             Q_DECLARE_METATYPE(ExpectedResults<VectorSeries>)
             class TestAmdaResultParser : public QObject {
                 Q_OBJECT
             private:
                 template <typename T>
                 void testReadDataStructure()
                 {
                     // ////////////// //
                     // Test structure //
                     // ////////////// //
                     // Name of TXT file to read
                     QTest::addColumn<QString>("inputFileName");
                     // Expected results
                     QTest::addColumn<ExpectedResults<T> >("expectedResults");
                 }
                 template <typename T>
                 void testRead(AmdaResultParser::ValueType valueType)
                 {
                     QFETCH(QString, inputFileName);
                     QFETCH(ExpectedResults<T>, expectedResults);
                     // Parses file
                     auto filePath = inputFilePath(inputFileName);
                     auto results = AmdaResultParser::readTxt(filePath, valueType);
                     // ///////////////// //
                     // Validates results //
                     // ///////////////// //
                     expectedResults.validate(results);
                 }
             private slots:
                 /// Input test data
                 /// @sa testReadScalarTxt()
                 void testReadScalarTxt_data();
                 /// Tests parsing scalar series of a TXT file
                 void testReadScalarTxt();
                 /// Input test data
                 /// @sa testReadSpectrogramTxt()
                 void testReadSpectrogramTxt_data();
                 /// Tests parsing spectrogram series of a TXT file
                 void testReadSpectrogramTxt();
                 /// Input test data
                 /// @sa testReadVectorTxt()
                 void testReadVectorTxt_data();
                 /// Tests parsing vector series of a TXT file
                 void testReadVectorTxt();
             };
             void TestAmdaResultParser::testReadScalarTxt_data()
             {
                 testReadDataStructure<ScalarSeries>();
                 // ////////// //
                 // Test cases //
                 // ////////// //
                 // Valid files
                 QTest::newRow("Valid file")
                     << QStringLiteral("ValidScalar1.txt")
                     << ExpectedResults<ScalarSeries>{}
                            .setParsingOK(true)
                            .setXAxisUnit(Unit{"nT", true})
                            .setXAxisData({dateTime(2013, 9, 23, 9, 0, 30), dateTime(2013, 9, 23, 9, 1, 30),
                                           dateTime(2013, 9, 23, 9, 2, 30), dateTime(2013, 9, 23, 9, 3, 30),
                                           dateTime(2013, 9, 23, 9, 4, 30), dateTime(2013, 9, 23, 9, 5, 30),
                                           dateTime(2013, 9, 23, 9, 6, 30), dateTime(2013, 9, 23, 9, 7, 30),
                                           dateTime(2013, 9, 23, 9, 8, 30), dateTime(2013, 9, 23, 9, 9, 30)})
                            .setValuesData({-2.83950, -2.71850, -2.52150, -2.57633, -2.58050, -2.48325, -2.63025,
                                            -2.55800, -2.43250, -2.42200});
                 QTest::newRow("Valid file (value of first line is invalid but it is converted to NaN")
                     << QStringLiteral("WrongValue.txt")
                     << ExpectedResults<ScalarSeries>{}
                            .setParsingOK(true)
                            .setXAxisUnit(Unit{"nT", true})
                            .setXAxisData({dateTime(2013, 9, 23, 9, 0, 30), dateTime(2013, 9, 23, 9, 1, 30),
                                           dateTime(2013, 9, 23, 9, 2, 30)})
                            .setValuesData({std::numeric_limits<double>::quiet_NaN(), -2.71850, -2.52150});
                 QTest::newRow("Valid file that contains NaN values")
                     << QStringLiteral("NaNValue.txt")
                     << ExpectedResults<ScalarSeries>{}
                            .setParsingOK(true)
                            .setXAxisUnit(Unit{("nT"), true})
                            .setXAxisData({dateTime(2013, 9, 23, 9, 0, 30), dateTime(2013, 9, 23, 9, 1, 30),
                                           dateTime(2013, 9, 23, 9, 2, 30)})
                            .setValuesData({std::numeric_limits<double>::quiet_NaN(), -2.71850, -2.52150});
                 // Valid files but with some invalid lines (wrong unit, wrong values, etc.)
                 QTest::newRow("No unit file")
                     << QStringLiteral("NoUnit.txt")
                     << ExpectedResults<ScalarSeries>{}.setParsingOK(true).setXAxisUnit(Unit{"", true});
                 QTest::newRow("Wrong unit file")
                     << QStringLiteral("WrongUnit.txt")
                     << ExpectedResults<ScalarSeries>{}
                            .setParsingOK(true)
                            .setXAxisUnit(Unit{"", true})
                            .setXAxisData({dateTime(2013, 9, 23, 9, 0, 30), dateTime(2013, 9, 23, 9, 1, 30),
                                           dateTime(2013, 9, 23, 9, 2, 30)})
                            .setValuesData({-2.83950, -2.71850, -2.52150});
                 QTest::newRow("Wrong results file (date of first line is invalid")
                     << QStringLiteral("WrongDate.txt")
                     << ExpectedResults<ScalarSeries>{}
                            .setParsingOK(true)
                            .setXAxisUnit(Unit{"nT", true})
                            .setXAxisData({dateTime(2013, 9, 23, 9, 1, 30), dateTime(2013, 9, 23, 9, 2, 30)})
                            .setValuesData({-2.71850, -2.52150});
                 QTest::newRow("Wrong results file (too many values for first line")
                     << QStringLiteral("TooManyValues.txt")
                     << ExpectedResults<ScalarSeries>{}
                            .setParsingOK(true)
                            .setXAxisUnit(Unit{"nT", true})
                            .setXAxisData({dateTime(2013, 9, 23, 9, 1, 30), dateTime(2013, 9, 23, 9, 2, 30)})
                            .setValuesData({-2.71850, -2.52150});
                 QTest::newRow("Wrong results file (x of first line is NaN")
                     << QStringLiteral("NaNX.txt")
                     << ExpectedResults<ScalarSeries>{}
                            .setParsingOK(true)
                            .setXAxisUnit(Unit{"nT", true})
                            .setXAxisData({dateTime(2013, 9, 23, 9, 1, 30), dateTime(2013, 9, 23, 9, 2, 30)})
                            .setValuesData({-2.71850, -2.52150});
                 QTest::newRow("Invalid file type (vector)")
                     << QStringLiteral("ValidVector1.txt")
                     << ExpectedResults<ScalarSeries>{}.setParsingOK(true).setXAxisUnit(Unit{"nT", true});
                 // Invalid files
                 QTest::newRow("Invalid file (unexisting file)")
                     << QStringLiteral("UnexistingFile.txt")
                     << ExpectedResults<ScalarSeries>{}.setParsingOK(false);
                 QTest::newRow("Invalid file (file not found on server)")
                     << QStringLiteral("FileNotFound.txt")
                     << ExpectedResults<ScalarSeries>{}.setParsingOK(false);
             }
             void TestAmdaResultParser::testReadScalarTxt()
             {
                 testRead<ScalarSeries>(AmdaResultParser::ValueType::SCALAR);
             }
             void TestAmdaResultParser::testReadSpectrogramTxt_data()
             {
                 testReadDataStructure<SpectrogramSeries>();
                 // ////////// //
                 // Test cases //
                 // ////////// //
                 // Valid files
                 QTest::newRow("Valid file (three bands)")
                     << QStringLiteral("spectro/ValidSpectrogram1.txt")
                     << ExpectedResults<SpectrogramSeries>{}
                            .setParsingOK(true)
                            .setXAxisUnit(Unit{"t", true})
                            .setXAxisData({dateTime(2012, 11, 6, 9, 14, 35), dateTime(2012, 11, 6, 9, 16, 10),
                                           dateTime(2012, 11, 6, 9, 17, 45), dateTime(2012, 11, 6, 9, 19, 20),
                                           dateTime(2012, 11, 6, 9, 20, 55)})
                            .setYAxisEnabled(true)
                            .setYAxisUnit(Unit{"eV"})
                            .setYAxisData({5.75, 7.6, 10.05}) // middle of the intervals of each band
                            .setValuesUnit(Unit{"eV/(cm^2-s-sr-eV)"})
                            .setValuesData(QVector<QVector<double> >{
                                {16313.780, 12631.465, 8223.368, 27595.301, 12820.613},
                                {15405.838, 11957.925, 15026.249, 25617.533, 11179.109},
                                {8946.475, 18133.158, 10875.621, 24051.619, 19283.221}});
                 auto fourBandsResult
                     = ExpectedResults<SpectrogramSeries>{}
                           .setParsingOK(true)
                           .setXAxisUnit(Unit{"t", true})
                           .setXAxisData({dateTime(2012, 11, 6, 9, 14, 35), dateTime(2012, 11, 6, 9, 16, 10),
                                          dateTime(2012, 11, 6, 9, 17, 45), dateTime(2012, 11, 6, 9, 19, 20),
                                          dateTime(2012, 11, 6, 9, 20, 55)})
                           .setYAxisEnabled(true)
                           .setYAxisUnit(Unit{"eV"})
                           .setYAxisData({5.75, 7.6, 10.05, 13.}) // middle of the intervals of each band
                           .setValuesUnit(Unit{"eV/(cm^2-s-sr-eV)"})
                           .setValuesData(QVector<QVector<double> >{
                               {16313.780, 12631.465, 8223.368, 27595.301, 12820.613},
                               {15405.838, 11957.925, 15026.249, 25617.533, 11179.109},
                               {8946.475, 18133.158, 10875.621, 24051.619, 19283.221},
                               {20907.664, 32076.725, 13008.381, 13142.759, 23226.998}});
                 QTest::newRow("Valid file (four bands)")
                     << QStringLiteral("spectro/ValidSpectrogram2.txt") << fourBandsResult;
                 QTest::newRow("Valid file (four unsorted bands)")
                     << QStringLiteral("spectro/ValidSpectrogram3.txt")
                     << fourBandsResult; // Bands and values are sorted
                 auto nan = std::numeric_limits<double>::quiet_NaN();
                 auto nanValuesResult
                     = ExpectedResults<SpectrogramSeries>{}
                           .setParsingOK(true)
                           .setXAxisUnit(Unit{"t", true})
                           .setXAxisData({dateTime(2012, 11, 6, 9, 14, 35), dateTime(2012, 11, 6, 9, 16, 10),
                                          dateTime(2012, 11, 6, 9, 17, 45), dateTime(2012, 11, 6, 9, 19, 20),
                                          dateTime(2012, 11, 6, 9, 20, 55)})
                           .setYAxisEnabled(true)
                           .setYAxisUnit(Unit{"eV"})
                           .setYAxisData({5.75, 7.6, 10.05, 13.}) // middle of the intervals of each band
                           .setValuesUnit(Unit{"eV/(cm^2-s-sr-eV)"})
                           .setValuesData(
                               QVector<QVector<double> >{{nan, 12631.465, 8223.368, 27595.301, 12820.613},
                                                         {15405.838, nan, nan, 25617.533, 11179.109},
                                                         {8946.475, 18133.158, 10875.621, 24051.619, 19283.221},
                                                         {nan, nan, nan, nan, nan}});
                 QTest::newRow("Valid file (containing NaN values)")
                     << QStringLiteral("spectro/ValidSpectrogramNaNValues.txt") << nanValuesResult;
                 QTest::newRow("Valid file (containing fill values)")
                     << QStringLiteral("spectro/ValidSpectrogramFillValues.txt")
                     << nanValuesResult; // Fill values are replaced by NaN values in the data series
                 QTest::newRow("Valid file (containing data holes, resolution = 3 minutes)")
                     << QStringLiteral("spectro/ValidSpectrogramDataHoles.txt")
                     << ExpectedResults<SpectrogramSeries>{}
                            .setParsingOK(true)
                            .setXAxisUnit(Unit{"t", true})
                            .setXAxisData({dateTime(2011, 12, 10, 12, 10, 54), //
                                           dateTime(2011, 12, 10, 12, 13, 54), // Data hole
                                           dateTime(2011, 12, 10, 12, 16, 54), // Data hole
                                           dateTime(2011, 12, 10, 12, 17, 23), //
                                           dateTime(2011, 12, 10, 12, 20, 23), // Data hole
                                           dateTime(2011, 12, 10, 12, 23, 23), // Data hole
                                           dateTime(2011, 12, 10, 12, 23, 51), //
                                           dateTime(2011, 12, 10, 12, 26, 51), // Data hole
                                           dateTime(2011, 12, 10, 12, 29, 51), // Data hole
                                           dateTime(2011, 12, 10, 12, 30, 19), //
                                           dateTime(2011, 12, 10, 12, 33, 19), // Data hole
                                           dateTime(2011, 12, 10, 12, 35, 04), //
                                           dateTime(2011, 12, 10, 12, 36, 41), //
                                           dateTime(2011, 12, 10, 12, 38, 18), //
                                           dateTime(2011, 12, 10, 12, 39, 55)})
                            .setYAxisEnabled(true)
                            .setYAxisUnit(Unit{"eV"})
                            .setYAxisData({16485.85, 20996.1}) // middle of the intervals of each band
                            .setValuesUnit(Unit{"eV/(cm^2-s-sr-eV)"})
                            .setValuesData(QVector<QVector<double> >{{2577578.000, //
                                                                      nan,         // Data hole
                                                                      nan,         // Data hole
                                                                      2314121.500, //
                                                                      nan,         // Data hole
                                                                      nan,         // Data hole
                                                                      2063608.750, //
                                                                      nan,         // Data hole
                                                                      nan,         // Data hole
                                                                      2234525.500, //
                                                                      nan,         // Data hole
                                                                      1670215.250, //
                                                                      1689243.250, //
                                                                      1654617.125, //
                                                                      1504983.750},
                                                                     {2336016.000, //
                                                                      nan,         // Data hole
                                                                      nan,         // Data hole
                                                                      1712093.125, //
                                                                      nan,         // Data hole
                                                                      nan,         // Data hole
                                                                      1614491.625, //
                                                                      nan,         // Data hole
                                                                      nan,         // Data hole
                                                                      1764516.500, //
                                                                      nan,         // Data hole
                                                                      1688078.500, //
                                                                      1743183.500, //
                                                                      1733603.250, //
                                                                      1708356.500}});
                 QTest::newRow(
                     "Valid file (containing data holes at the beginning and the end, resolution = 4 minutes)")
                     << QStringLiteral("spectro/ValidSpectrogramDataHoles2.txt")
                     << ExpectedResults<SpectrogramSeries>{}
                            .setParsingOK(true)
                            .setXAxisUnit(Unit{"t", true})
                            .setXAxisData({
                                dateTime(2011, 12, 10, 12, 2, 54),  // Data hole
                                dateTime(2011, 12, 10, 12, 6, 54),  // Data hole
                                dateTime(2011, 12, 10, 12, 10, 54), //
                                dateTime(2011, 12, 10, 12, 14, 54), // Data hole
                                dateTime(2011, 12, 10, 12, 17, 23), //
                                dateTime(2011, 12, 10, 12, 21, 23), // Data hole
                                dateTime(2011, 12, 10, 12, 23, 51), //
                                dateTime(2011, 12, 10, 12, 27, 51), // Data hole
                                dateTime(2011, 12, 10, 12, 30, 19), //
                                dateTime(2011, 12, 10, 12, 34, 19), // Data hole
                                dateTime(2011, 12, 10, 12, 35, 04), //
                                dateTime(2011, 12, 10, 12, 36, 41), //
                                dateTime(2011, 12, 10, 12, 38, 18), //
                                dateTime(2011, 12, 10, 12, 39, 55),
                                dateTime(2011, 12, 10, 12, 43, 55), // Data hole
                                dateTime(2011, 12, 10, 12, 47, 55), // Data hole
                                dateTime(2011, 12, 10, 12, 51, 55), // Data hole
                                dateTime(2011, 12, 10, 12, 55, 55), // Data hole
                                dateTime(2011, 12, 10, 12, 59, 55)  // Data hole
                            })
                            .setYAxisEnabled(true)
                            .setYAxisUnit(Unit{"eV"})
                            .setYAxisData({16485.85, 20996.1}) // middle of the intervals of each band
                            .setValuesUnit(Unit{"eV/(cm^2-s-sr-eV)"})
                            .setValuesData(QVector<QVector<double> >{{
                                                                         nan,         // Data hole
                                                                         nan,         // Data hole
                                                                         2577578.000, //
                                                                         nan,         // Data hole
                                                                         2314121.500, //
                                                                         nan,         // Data hole
                                                                         2063608.750, //
                                                                         nan,         // Data hole
                                                                         2234525.500, //
                                                                         nan,         // Data hole
                                                                         1670215.250, //
                                                                         1689243.250, //
                                                                         1654617.125, //
                                                                         1504983.750, //
                                                                         nan,         // Data hole
                                                                         nan,         // Data hole
                                                                         nan,         // Data hole
                                                                         nan,         // Data hole
                                                                         nan          // Data hole
                                                                     },
                                                                     {
                                                                         nan,         // Data hole
                                                                         nan,         // Data hole
                                                                         2336016.000, //
                                                                         nan,         // Data hole
                                                                         1712093.125, //
                                                                         nan,         // Data hole
                                                                         1614491.625, //
                                                                         nan,         // Data hole
                                                                         1764516.500, //
                                                                         nan,         // Data hole
                                                                         1688078.500, //
                                                                         1743183.500, //
                                                                         1733603.250, //
                                                                         1708356.500, //
                                                                         nan,         // Data hole
                                                                         nan,         // Data hole
                                                                         nan,         // Data hole
                                                                         nan,         // Data hole
                                                                         nan          // Data hole
                                                                     }});
                 // Invalid files
                 QTest::newRow("Invalid file (inconsistent bands)")
                     << QStringLiteral("spectro/InvalidSpectrogramWrongBands.txt")
                     << ExpectedResults<SpectrogramSeries>{}.setParsingOK(false);
             }
             void TestAmdaResultParser::testReadSpectrogramTxt()
             {
                 testRead<SpectrogramSeries>(AmdaResultParser::ValueType::SPECTROGRAM);
             }
             void TestAmdaResultParser::testReadVectorTxt_data()
             {
                 testReadDataStructure<VectorSeries>();
                 // ////////// //
                 // Test cases //
                 // ////////// //
                 // Valid files
                 QTest::newRow("Valid file")
                     << QStringLiteral("ValidVector1.txt")
                     << ExpectedResults<VectorSeries>{}
                            .setParsingOK(true)
                            .setXAxisUnit(Unit{"nT", true})
                            .setXAxisData({dateTime(2013, 7, 2, 9, 13, 50), dateTime(2013, 7, 2, 9, 14, 6),
                                           dateTime(2013, 7, 2, 9, 14, 22), dateTime(2013, 7, 2, 9, 14, 38),
                                           dateTime(2013, 7, 2, 9, 14, 54), dateTime(2013, 7, 2, 9, 15, 10),
                                           dateTime(2013, 7, 2, 9, 15, 26), dateTime(2013, 7, 2, 9, 15, 42),
                                           dateTime(2013, 7, 2, 9, 15, 58), dateTime(2013, 7, 2, 9, 16, 14)})
                            .setValuesData(
                                {{-0.332, -1.011, -1.457, -1.293, -1.217, -1.443, -1.278, -1.202, -1.22, -1.259},
                                 {3.206, 2.999, 2.785, 2.736, 2.612, 2.564, 2.892, 2.862, 2.859, 2.764},
                                 {0.058, 0.496, 1.018, 1.485, 1.662, 1.505, 1.168, 1.244, 1.15, 1.358}});
                 // Valid files but with some invalid lines (wrong unit, wrong values, etc.)
                 QTest::newRow("Invalid file type (scalar)")
                     << QStringLiteral("ValidScalar1.txt")
                     << ExpectedResults<VectorSeries>{}
                            .setParsingOK(true)
                            .setXAxisUnit(Unit{"nT", true})
                            .setXAxisData({})
                            .setValuesData(QVector<QVector<double> >{{}, {}, {}});
             }
             void TestAmdaResultParser::testReadVectorTxt()
             {
                 testRead<VectorSeries>(AmdaResultParser::ValueType::VECTOR);
             }
             QTEST_MAIN(TestAmdaResultParser)
             #include "TestAmdaResultParser.moc"

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