GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r649:8ba2e73bb18a

Merge pull request from SCIQLOP-Initialisation develop...

perrinel -

r649:8ba2e73bb18a

parent child

Context file:

r649:8ba2e73bb18a

core/include/Data/ArrayDataIterator.h created 644 +56 0

@@ -0,0 +1,56
	1	#ifndef SCIQLOP_ARRAYDATAITERATOR_H
	2	#define SCIQLOP_ARRAYDATAITERATOR_H
	3
	4	#include "CoreGlobal.h"
	5	#include "Data/SqpIterator.h"
	6
	7	#include <memory>
	8
	9	/**
	10	* @brief The ArrayDataIteratorValue class represents the current value of an array data iterator.
	11	* It offers standard access methods for the data in the series (at(), first()), but it is up to
	12	* each array data to define its own implementation of how to retrieve this data (one-dim or two-dim
	13	* array), by implementing the ArrayDataIteratorValue::Impl interface
	14	* @sa ArrayDataIterator
	15	*/
	16	class SCIQLOP_CORE_EXPORT ArrayDataIteratorValue {
	17	public:
	18	struct Impl {
	19	virtual ~Impl() noexcept = default;
	20	virtual std::unique_ptr<Impl> clone() const = 0;
	21	virtual bool equals(const Impl &other) const = 0;
	22	virtual void next() = 0;
	23	virtual void prev() = 0;
	24	virtual double at(int componentIndex) const = 0;
	25	virtual double first() const = 0;
	26	virtual double min() const = 0;
	27	virtual double max() const = 0;
	28	};
	29
	30	explicit ArrayDataIteratorValue(std::unique_ptr<Impl> impl);
	31	ArrayDataIteratorValue(const ArrayDataIteratorValue &other);
	32	ArrayDataIteratorValue(ArrayDataIteratorValue &&other) = default;
	33	ArrayDataIteratorValue &operator=(ArrayDataIteratorValue other);
	34
	35	bool equals(const ArrayDataIteratorValue &other) const;
	36
	37	/// Advances to the next value
	38	void next();
	39	/// Moves back to the previous value
	40	void prev();
	41	/// Gets value of a specified component
	42	double at(int componentIndex) const;
	43	/// Gets value of first component
	44	double first() const;
	45	/// Gets min value among all components
	46	double min() const;
	47	/// Gets max value among all components
	48	double max() const;
	49
	50	private:
	51	std::unique_ptr<Impl> m_Impl;
	52	};
	53
	54	using ArrayDataIterator = SqpIterator<ArrayDataIteratorValue>;
	55
	56	#endif // SCIQLOP_ARRAYDATAITERATOR_H

core/include/Data/SqpIterator.h created 644 +54 0

@@ -0,0 +1,54
	1	#ifndef SCIQLOP_SQPITERATOR_H
	2	#define SCIQLOP_SQPITERATOR_H
	3
	4	#include "CoreGlobal.h"
	5
	6	/**
	7	* @brief The SqpIterator class represents an iterator used in SciQlop. It defines all operators
	8	* needed for a standard forward iterator
	9	* @tparam T the type of object handled in iterator
	10	* @sa http://www.cplusplus.com/reference/iterator/
	11	*/
	12	template <typename T>
	13	class SCIQLOP_CORE_EXPORT SqpIterator {
	14	public:
	15	using iterator_category = std::forward_iterator_tag;
	16	using value_type = const T;
	17	using difference_type = std::ptrdiff_t;
	18	using pointer = value_type *;
	19	using reference = value_type &;
	20
	21	explicit SqpIterator(T value) : m_CurrentValue{std::move(value)} {}
	22
	23	virtual ~SqpIterator() noexcept = default;
	24	SqpIterator(const SqpIterator &) = default;
	25	SqpIterator(SqpIterator &&) = default;
	26	SqpIterator &operator=(const SqpIterator &) = default;
	27	SqpIterator &operator=(SqpIterator &&) = default;
	28
	29	SqpIterator &operator++()
	30	{
	31	m_CurrentValue.next();
	32	return *this;
	33	}
	34
	35	SqpIterator &operator--()
	36	{
	37	m_CurrentValue.prev();
	38	return *this;
	39	}
	40
	41	pointer operator->() const { return &m_CurrentValue; }
	42	reference operator*() const { return m_CurrentValue; }
	43
	44	bool operator==(const SqpIterator &other) const
	45	{
	46	return m_CurrentValue.equals(other.m_CurrentValue);
	47	}
	48	bool operator!=(const SqpIterator &other) const { return !(*this == other); }
	49
	50	private:
	51	T m_CurrentValue;
	52	};
	53
	54	#endif // SCIQLOP_SQPITERATOR_H

core/src/Data/ArrayDataIterator.cpp created 644 +52 0

@@ -0,0 +1,52
	1	#include "Data/ArrayDataIterator.h"
	2
	3	ArrayDataIteratorValue::ArrayDataIteratorValue(std::unique_ptr<ArrayDataIteratorValue::Impl> impl)
	4	: m_Impl{std::move(impl)}
	5	{
	6	}
	7
	8	ArrayDataIteratorValue::ArrayDataIteratorValue(const ArrayDataIteratorValue &other)
	9	: m_Impl{other.m_Impl->clone()}
	10	{
	11	}
	12
	13	ArrayDataIteratorValue &ArrayDataIteratorValue::operator=(ArrayDataIteratorValue other)
	14	{
	15	std::swap(m_Impl, other.m_Impl);
	16	return *this;
	17	}
	18
	19	bool ArrayDataIteratorValue::equals(const ArrayDataIteratorValue &other) const
	20	{
	21	return m_Impl->equals(*other.m_Impl);
	22	}
	23
	24	void ArrayDataIteratorValue::next()
	25	{
	26	m_Impl->next();
	27	}
	28
	29	void ArrayDataIteratorValue::prev()
	30	{
	31	m_Impl->prev();
	32	}
	33
	34	double ArrayDataIteratorValue::at(int componentIndex) const
	35	{
	36	return m_Impl->at(componentIndex);
	37	}
	38
	39	double ArrayDataIteratorValue::first() const
	40	{
	41	return m_Impl->first();
	42	}
	43
	44	double ArrayDataIteratorValue::min() const
	45	{
	46	return m_Impl->min();
	47	}
	48
	49	double ArrayDataIteratorValue::max() const
	50	{
	51	return m_Impl->max();
	52	}

core/include/Common/SortUtils.h +28 -6

             #ifndef SCIQLOP_SORTUTILS_H
             #define SCIQLOP_SORTUTILS_H
             #include <algorithm>
             #include <cmath>
             #include <numeric>
             #include <vector>
             /**
              * Utility class with methods for sorting data
              */
             struct SortUtils {
                 /**
                  * Generates a vector representing the index of insertion of each data of a container if this
                  * one had to be sorted according to a comparison function.
                  *
                  * For example:
                  * If the container is a vector {1; 4; 2; 5; 3} and the comparison function is std::less, the
                  * result would be : {0; 3; 1; 4; 2}
                  *
                  * @tparam Container the type of the container.
                  * @tparam Compare the type of the comparison function
                  * @param container the container from which to generate the result. The container must have a
                  * at() method that returns a value associated to an index
                  * @param compare the comparison function
                  */
                 template <typename Container, typename Compare>
                 static std::vector<int> sortPermutation(const Container &container, const Compare &compare)
                 {
                     auto permutation = std::vector<int>{};
                     permutation.resize(container.size());
                     std::iota(permutation.begin(), permutation.end(), 0);
                     std::sort(permutation.begin(), permutation.end(),
                               [&](int i, int j) { return compare(container.at(i), container.at(j)); });
                     return permutation;
                 }
                 /**
-                 * Sorts a container according to indices passed in parameter
+                 * Sorts a container according to indices passed in parameter. The number of data in the
+                 * container must be a multiple of the number of indices used to sort the container.
+                 *
+                 * Example 1:
+                 * container: {1, 2, 3, 4, 5, 6}
+                 * sortPermutation: {1, 0}
+                 *
+                 * Values will be sorted three by three, and the result will be:
+                 * {4, 5, 6, 1, 2, 3}
+                 *
+                 * Example 2:
+                 * container: {1, 2, 3, 4, 5, 6}
+                 * sortPermutation: {2, 0, 1}
+                 *
+                 * Values will be sorted two by two, and the result will be:
+                 * {5, 6, 1, 2, 3, 4}
+                 *
                  * @param container the container sorted
                  * @param sortPermutation the indices used to sort the container
                  * @return the container sorted
                  * @warning no verification is made on validity of sortPermutation (i.e. the vector has unique
                  * indices and its range is [0 ; vector.size()[ )
                  */
                 template <typename Container>
-                static Container sort(const Container &container, const std::vector<int> &sortPermutation)
+                static Container sort(const Container &container, int nbValues,
+                                      const std::vector<int> &sortPermutation)
                 {
-                    if (container.size() != sortPermutation.size()) {
+                    auto containerSize = container.size();
+                    if (containerSize % nbValues != 0
+                        || ((containerSize / nbValues) != sortPermutation.size())) {
                         return Container{};
                     }
                     // Inits result
                     auto sortedData = Container{};
-                    sortedData.resize(container.size());
+                    sortedData.reserve(containerSize);
-                    std::transform(sortPermutation.cbegin(), sortPermutation.cend(), sortedData.begin(),
+                    for (auto i = 0, componentIndex = 0, permutationIndex = 0; i < containerSize;
-                                   [&container](int i) { return container.at(i); });
+                         ++i, componentIndex = i % nbValues, permutationIndex = i / nbValues) {
+                        auto insertIndex = sortPermutation.at(permutationIndex) * nbValues + componentIndex;
+                        sortedData.append(container.at(insertIndex));
+                    }
                     return sortedData;
                 }
                 /**
                  * Compares two values that can be NaN. This method is intended to be used as a compare function
                  * for searching min value by excluding NaN values.
                  *
                  * Examples of use:
                  * - f({1, 3, 2, 4, 5}) will return 1
                  * - f({NaN, 3, 2, 4, 5}) will return 2 (NaN is excluded)
                  * - f({NaN, NaN, 3, NaN, NaN}) will return 3 (NaN are excluded)
                  * - f({NaN, NaN, NaN, NaN, NaN}) will return NaN (no existing value)
                  *
                  * @param v1 first value
                  * @param v2 second value
                  * @return true if v1 < v2, false otherwise
                  * @sa std::min_element
                  */
                 template <typename T>
                 static bool minCompareWithNaN(const T &v1, const T &v2)
                 {
                     // Table used with NaN values:
                     // NaN < v2 -> false
                     // v1 < NaN -> true
                     // NaN < NaN -> false
                     // v1 < v2 -> v1 < v2
                     return std::isnan(v1) ? false : std::isnan(v2) || (v1 < v2);
                 }
                 /**
                  * Compares two values that can be NaN. This method is intended to be used as a compare function
                  * for searching max value by excluding NaN values.
                  *
                  * Examples of use:
                  * - f({1, 3, 2, 4, 5}) will return 5
                  * - f({1, 3, 2, 4, NaN}) will return 4 (NaN is excluded)
                  * - f({NaN, NaN, 3, NaN, NaN}) will return 3 (NaN are excluded)
                  * - f({NaN, NaN, NaN, NaN, NaN}) will return NaN (no existing value)
                  *
                  * @param v1 first value
                  * @param v2 second value
                  * @return true if v1 < v2, false otherwise
                  * @sa std::max_element
                  */
                 template <typename T>
                 static bool maxCompareWithNaN(const T &v1, const T &v2)
                 {
                     // Table used with NaN values:
                     // NaN < v2 -> true
                     // v1 < NaN -> false
                     // NaN < NaN -> false
                     // v1 < v2 -> v1 < v2
                     return std::isnan(v1) ? true : !std::isnan(v2) && (v1 < v2);
                 }
             };
             #endif // SCIQLOP_SORTUTILS_H

core/include/Data/ArrayData.h +118 -195

@@ -1,348 +1,271
1	#ifndef SCIQLOP_ARRAYDATA_H	1	#ifndef SCIQLOP_ARRAYDATA_H
2	#define SCIQLOP_ARRAYDATA_H	2	#define SCIQLOP_ARRAYDATA_H
3		3
		4	#include "Data/ArrayDataIterator.h"
4	#include <Common/SortUtils.h>	5	#include <Common/SortUtils.h>
5		6
6	#include <QReadLocker>	7	#include <QReadLocker>
7	#include <QReadWriteLock>	8	#include <QReadWriteLock>
8	#include <QVector>	9	#include <QVector>
9		10
10	#include <memory>	11	#include <memory>
11		12
12	template <int Dim>	13	template <int Dim>
13	class ArrayData;	14	class ArrayData;
14		15
15	using DataContainer = QVector<~~QVector~~<double> >;	16	using DataContainer = QVector<double>;
16		17
17	namespace arraydata_detail {	18	namespace arraydata_detail {
18		19
19	/// Struct used to sort ArrayData	20	/// Struct used to sort ArrayData
20	template <int Dim>	21	template <int Dim>
21	struct Sort {	22	struct Sort {
22	static std::shared_ptr<ArrayData<Dim> > sort(const DataContainer &data,	23	static std::shared_ptr<ArrayData<Dim> > sort(const DataContainer &data, int nbComponents,
23	const std::vector<int> &sortPermutation)	24	const std::vector<int> &sortPermutation)
24	{	25	{
25	auto nbComponents = data.size();	26	return std::make_shared<ArrayData<Dim> >(
26	auto sortedData = DataContainer(nbComponents);	27	SortUtils::sort(data, nbComponents, sortPermutation), nbComponents);
27
28	for (auto i = 0; i < nbComponents; ++i) {
29	sortedData[i] = SortUtils::sort(data.at(i), sortPermutation);
30	}
31
32	return std::make_shared<ArrayData<Dim> >(std::move(sortedData));
33	}	28	}
34	};	29	};
35		30
36	/// Specialization for uni-dimensional ArrayData	31	/// Specialization for uni-dimensional ArrayData
37	template <>	32	template <>
38	struct Sort<1> {	33	struct Sort<1> {
39	static std::shared_ptr<ArrayData<1> > sort(const DataContainer &data,	34	static std::shared_ptr<ArrayData<1> > sort(const DataContainer &data, int nbComponents,
40	const std::vector<int> &sortPermutation)	35	const std::vector<int> &sortPermutation)
41	{	36	{
42	return std::make_shared<ArrayData<1> >(SortUtils::sort(data.at(0), sortPermutation));	37	Q_UNUSED(nbComponents)
		38	return std::make_shared<ArrayData<1> >(SortUtils::sort(data, 1, sortPermutation));
		39	}
		40	};
		41
		42	template <int Dim>
		43	class IteratorValue : public ArrayDataIteratorValue::Impl {
		44	public:
		45	explicit IteratorValue(const DataContainer &container, int nbComponents, bool begin)
		46	: m_It{begin ? container.cbegin() : container.cend()}, m_NbComponents{nbComponents}
		47	{
		48	}
		49
		50	IteratorValue(const IteratorValue &other) = default;
		51
		52	std::unique_ptr<ArrayDataIteratorValue::Impl> clone() const override
		53	{
		54	return std::make_unique<IteratorValue<Dim> >(*this);
		55	}
		56
		57	bool equals(const ArrayDataIteratorValue::Impl &other) const override try {
		58	const auto &otherImpl = dynamic_cast<const IteratorValue &>(other);
		59	return std::tie(m_It, m_NbComponents) == std::tie(otherImpl.m_It, otherImpl.m_NbComponents);
		60	}
		61	catch (const std::bad_cast &) {
		62	return false;
		63	}
		64
		65	void next() override { std::advance(m_It, m_NbComponents); }
		66	void prev() override { std::advance(m_It, -m_NbComponents); }
		67
		68	double at(int componentIndex) const override { return *(m_It + componentIndex); }
		69	double first() const override { return *m_It; }
		70	double min() const override
		71	{
		72	auto values = this->values();
		73	auto end = values.cend();
		74	auto it = std::min_element(values.cbegin(), end, [](const auto &v1, const auto &v2) {
		75	return SortUtils::minCompareWithNaN(v1, v2);
		76	});
		77
		78	return it != end ? *it : std::numeric_limits<double>::quiet_NaN();
		79	}
		80	double max() const override
		81	{
		82	auto values = this->values();
		83	auto end = values.cend();
		84	auto it = std::max_element(values.cbegin(), end, [](const auto &v1, const auto &v2) {
		85	return SortUtils::maxCompareWithNaN(v1, v2);
		86	});
		87	return it != end ? *it : std::numeric_limits<double>::quiet_NaN();
		88	}
		89
		90	private:
		91	std::vector<double> values() const
		92	{
		93	auto result = std::vector<double>{};
		94	for (auto i = 0; i < m_NbComponents; ++i) {
		95	result.push_back(*(m_It + i));
		96	}
		97
		98	return result;
43	}	99	}
		100
		101	DataContainer::const_iterator m_It;
		102	int m_NbComponents;
44	};	103	};
45		104
46	} // namespace arraydata_detail	105	} // namespace arraydata_detail
47		106
48	/**	107	/**
49	* @brief The ArrayData class represents a dataset for a data series.	108	* @brief The ArrayData class represents a dataset for a data series.
50	*	109	*
51	* A dataset can be unidimensional or two-dimensional. This property is determined by the Dim	110	* A dataset can be unidimensional or two-dimensional. This property is determined by the Dim
52	* template-parameter. In a case of a two-dimensional dataset, each dataset component has the same	111	* template-parameter. In a case of a two-dimensional dataset, each dataset component has the same
53	* number of values	112	* number of values
54	*	113	*
55	* @tparam Dim the dimension of the ArrayData (one or two)	114	* @tparam Dim the dimension of the ArrayData (one or two)
56	* @sa IDataSeries	115	* @sa IDataSeries
57	*/	116	*/
58	template <int Dim>	117	template <int Dim>
59	class ArrayData {	118	class ArrayData {
60	public:	119	public:
61	class IteratorValue {
62	public:
63	explicit IteratorValue(const DataContainer &container, bool begin) : m_Its{}
64	{
65	for (auto i = 0; i < container.size(); ++i) {
66	m_Its.push_back(begin ? container.at(i).cbegin() : container.at(i).cend());
67	}
68	}
69
70	double at(int index) const { return *m_Its.at(index); }
71	double first() const { return *m_Its.front(); }
72
73	/// @return the min value among all components
74	double min() const
75	{
76	auto end = m_Its.cend();
77	auto it = std::min_element(m_Its.cbegin(), end, [](const auto &it1, const auto &it2) {
78	return SortUtils::minCompareWithNaN(it1, it2);
79	});
80	return it != end ? **it : std::numeric_limits<double>::quiet_NaN();
81	}
82
83	/// @return the max value among all components
84	double max() const
85	{
86	auto end = m_Its.cend();
87	auto it = std::max_element(m_Its.cbegin(), end, [](const auto &it1, const auto &it2) {
88	return SortUtils::maxCompareWithNaN(it1, it2);
89	});
90	return it != end ? **it : std::numeric_limits<double>::quiet_NaN();
91	}
92
93	void next()
94	{
95	for (auto &it : m_Its) {
96	++it;
97	}
98	}
99
100	void prev()
101	{
102	for (auto &it : m_Its) {
103	--it;
104	}
105	}
106
107	bool operator==(const IteratorValue &other) const { return m_Its == other.m_Its; }
108
109	private:
110	std::vector<DataContainer::value_type::const_iterator> m_Its;
111	};
112
113	class Iterator {
114	public:
115	using iterator_category = std::forward_iterator_tag;
116	using value_type = const IteratorValue;
117	using difference_type = std::ptrdiff_t;
118	using pointer = value_type *;
119	using reference = value_type &;
120
121	Iterator(const DataContainer &container, bool begin) : m_CurrentValue{container, begin} {}
122
123	virtual ~Iterator() noexcept = default;
124	Iterator(const Iterator &) = default;
125	Iterator(Iterator &&) = default;
126	Iterator &operator=(const Iterator &) = default;
127	Iterator &operator=(Iterator &&) = default;
128
129	Iterator &operator++()
130	{
131	m_CurrentValue.next();
132	return *this;
133	}
134
135	Iterator &operator--()
136	{
137	m_CurrentValue.prev();
138	return *this;
139	}
140
141	pointer operator->() const { return &m_CurrentValue; }
142	reference operator*() const { return m_CurrentValue; }
143
144	bool operator==(const Iterator &other) const
145	{
146	return m_CurrentValue == other.m_CurrentValue;
147	}
148
149	bool operator!=(const Iterator &other) const { return !(*this == other); }
150
151	private:
152	IteratorValue m_CurrentValue;
153	};
154
155	// ///// //	120	// ///// //
156	// Ctors //	121	// Ctors //
157	// ///// //	122	// ///// //
158		123
159	/**	124	/**
160	* Ctor for a unidimensional ArrayData	125	* Ctor for a unidimensional ArrayData
161	* @param data the data the ArrayData will hold	126	* @param data the data the ArrayData will hold
162	*/	127	*/
163	template <int D = Dim, typename = std::enable_if_t<D == 1> >	128	template <int D = Dim, typename = std::enable_if_t<D == 1> >
164	explicit ArrayData(QVector<double> data) : m_Data{1, QVector<double>{}}	129	explicit ArrayData(DataContainer data) : m_Data{std::move(data)}, m_NbComponents{1}
165	{	130	{
166	m_Data[0] = std::move(data);
167	}	131	}
168		132
169	/**	133	/**
170	* Ctor for a two-dimensional ArrayData. The number of components (number of ~~vector~~s) must be	134	* Ctor for a two-dimensional ArrayData. The number of components (number of lines) must be
171	* greater than 2 and ~~each component must have the same~~ number of ~~values~~	135	* greater than 2 and must be a divisor of the total number of data in the vector
172	* @param data the data the ArrayData will hold	136	* @param data the data the ArrayData will hold
173	* @~~throws std::invalid_argument if~~ the number of components ~~is less than 2~~	137	* @param nbComponents the number of components
174	* @remarks if the number of values is not the same for each component, no value is set	138	* @throws std::invalid_argument if the number of components is less than 2 or is not a divisor
		139	* of the size of the data
175	*/	140	*/
176	template <int D = Dim, typename = std::enable_if_t<D == 2> >	141	template <int D = Dim, typename = std::enable_if_t<D == 2> >
177	explicit ArrayData(DataContainer data)	142	explicit ArrayData(DataContainer data, int nbComponents)
		143	: m_Data{std::move(data)}, m_NbComponents{nbComponents}
178	{	144	{
179	auto nbComponents = data.size();
180	if (nbComponents < 2) {	145	if (nbComponents < 2) {
181	throw std::invalid_argument{	146	throw std::invalid_argument{
182	QString{"A multidimensional ArrayData must have at least 2 components (found: %1"}	147	QString{"A multidimensional ArrayData must have at least 2 components (found: %1)"}
183	.arg(~~data~~.~~size~~())	148	.arg(nbComponents)
184	.toStdString()};	149	.toStdString()};
185	}	150	}
186		151
187	auto nbValues = data.front().size();	152	if (m_Data.size() % m_NbComponents != 0) {
188	if (std::all_of(data.cbegin(), data.cend(), [nbValues](const auto &component) {	153	throw std::invalid_argument{QString{
189	return component.size() == nbValues;	154	"The number of components (%1) is inconsistent with the total number of data (%2)"}
190	})) {	155	.arg(m_Data.size(), nbComponents)
191	m_Data = std::move(data);	156	.toStdString()};
192	}
193	else {
194	m_Data = DataContainer{nbComponents, QVector<double>{}};
195	}	157	}
196	}	158	}
197		159
198	/// Copy ctor	160	/// Copy ctor
199	explicit ArrayData(const ArrayData &other)	161	explicit ArrayData(const ArrayData &other)
200	{	162	{
201	QReadLocker otherLocker{&other.m_Lock};	163	QReadLocker otherLocker{&other.m_Lock};
202	m_Data = other.m_Data;	164	m_Data = other.m_Data;
		165	m_NbComponents = other.m_NbComponents;
203	}	166	}
204		167
205	// /////////////// //	168	// /////////////// //
206	// General methods //	169	// General methods //
207	// /////////////// //	170	// /////////////// //
208		171
209	/**	172	/**
210	* Merges into the array data an other array data. The two array datas must have the same number	173	* Merges into the array data an other array data. The two array datas must have the same number
211	* of components so the merge can be done	174	* of components so the merge can be done
212	* @param other the array data to merge with	175	* @param other the array data to merge with
213	* @param prepend if true, the other array data is inserted at the beginning, otherwise it is	176	* @param prepend if true, the other array data is inserted at the beginning, otherwise it is
214	* inserted at the end	177	* inserted at the end
215	*/	178	*/
216	void add(const ArrayData<Dim> &other, bool prepend = false)	179	void add(const ArrayData<Dim> &other, bool prepend = false)
217	{	180	{
218	QWriteLocker locker{&m_Lock};	181	QWriteLocker locker{&m_Lock};
219	QReadLocker otherLocker{&other.m_Lock};	182	QReadLocker otherLocker{&other.m_Lock};
220		183
221	auto nbComponents = m_Data.size();	184	if (m_NbComponents != other.componentCount()) {
222	if (nbComponents != other.m_Data.size()) {
223	return;	185	return;
224	}	186	}
225		187
226	for (auto componentIndex = 0; componentIndex < nbComponents; ++componentIndex) {	188	if (prepend) {
227	if (prepend) {	189	auto otherDataSize = other.m_Data.size();
228	const auto &otherData = other.data(componentIndex);	190	m_Data.insert(m_Data.begin(), otherDataSize, 0.);
229	const auto otherDataSize = otherData.size();	191	for (auto i = 0; i < otherDataSize; ++i) {
230		192	m_Data.replace(i, other.m_Data.at(i));
231	auto &data = m_Data[componentIndex];
232	data.insert(data.begin(), otherDataSize, 0.);
233
234	for (auto i = 0; i < otherDataSize; ++i) {
235	data.replace(i, otherData.at(i));
236	}
237	}
238	else {
239	m_Data[componentIndex] += other.data(componentIndex);
240	}	193	}
241	}	194	}
		195	else {
		196	m_Data.append(other.m_Data);
		197	}
242	}	198	}
243		199
244	void clear()	200	void clear()
245	{	201	{
246	QWriteLocker locker{&m_Lock};	202	QWriteLocker locker{&m_Lock};
247		203	m_Data.clear();
248	auto nbComponents = m_Data.size();
249	for (auto i = 0; i < nbComponents; ++i) {
250	m_Data[i].clear();
251	}
252	}	204	}
253		205
254	int componentCount() const noexcept { return m_~~Data~~.~~size~~(); }	206	int componentCount() const noexcept { return m_NbComponents; }
255
256	/**
257	* @return the data of a component
258	* @param componentIndex the index of the component to retrieve the data
259	* @return the component's data, empty vector if the index is invalid
260	*/
261	QVector<double> data(int componentIndex) const noexcept
262	{
263	QReadLocker locker{&m_Lock};
264
265	return (componentIndex >= 0 && componentIndex < m_Data.size()) ? m_Data.at(componentIndex)
266	: QVector<double>{};
267	}
268		207
269	/// @return the size (i.e. number of values) of a single component	208	/// @return the size (i.e. number of values) of a single component
270	/// @remarks in a case of a two-dimensional ArrayData, each component has the same size	209	/// @remarks in a case of a two-dimensional ArrayData, each component has the same size
271	int size() const	210	int size() const
272	{	211	{
273	QReadLocker locker{&m_Lock};	212	QReadLocker locker{&m_Lock};
274	return m_Data[0].size();	213	return m_Data.size() / m_NbComponents;
275	}	214	}
276		215
277	std::shared_ptr<ArrayData<Dim> > sort(const std::vector<int> &sortPermutation)	216	std::shared_ptr<ArrayData<Dim> > sort(const std::vector<int> &sortPermutation)
278	{	217	{
279	QReadLocker locker{&m_Lock};	218	QReadLocker locker{&m_Lock};
280	return arraydata_detail::Sort<Dim>::sort(m_Data, sortPermutation);	219	return arraydata_detail::Sort<Dim>::sort(m_Data, m_NbComponents, sortPermutation);
281	}	220	}
282		221
283	// ///////// //	222	// ///////// //
284	// Iterators //	223	// Iterators //
285	// ///////// //	224	// ///////// //
286		225
287	Iterator cbegin() const { return Iterator{m_Data, true}; }	226	ArrayDataIterator cbegin() const
288	Iterator cend() const { return Iterator{m_Data, false}; }	227	{
		228	return ArrayDataIterator{ArrayDataIteratorValue{
		229	std::make_unique<arraydata_detail::IteratorValue<Dim> >(m_Data, m_NbComponents, true)}};
		230	}
		231	ArrayDataIterator cend() const
		232	{
		233	return ArrayDataIterator{
		234	ArrayDataIteratorValue{std::make_unique<arraydata_detail::IteratorValue<Dim> >(
		235	m_Data, m_NbComponents, false)}};
		236	}
289		237
290	// ///////////// //
291	// 1-dim methods //
292	// ///////////// //
293		238
294	/**	239	/**
295	* @return the data at a specified index	240	* @return the data at a specified index
296	* @remarks index must be a valid position	241	* @remarks index must be a valid position
297	* @remarks this method is only available for a unidimensional ArrayData
298	*/	242	*/
299	template <int D = Dim, typename = std::enable_if_t<D == 1> >
300	double at(int index) const noexcept	243	double at(int index) const noexcept
301	{	244	{
302	QReadLocker locker{&m_Lock};	245	QReadLocker locker{&m_Lock};
303	return m_Data[0].at(index);	246	return m_Data.at(index);
304	}	247	}
305		248
		249	// ///////////// //
		250	// 1-dim methods //
		251	// ///////////// //
		252
306	/**	253	/**
307	* @return the data as a vector, as a const reference	254	* @return the data as a vector, as a const reference
308	* @remarks this method is only available for a unidimensional ArrayData	255	* @remarks this method is only available for a unidimensional ArrayData
309	*/	256	*/
310	template <int D = Dim, typename = std::enable_if_t<D == 1> >	257	template <int D = Dim, typename = std::enable_if_t<D == 1> >
311	const QVector<double> &cdata() const noexcept	258	const QVector<double> &cdata() const noexcept
312	{	259	{
313	QReadLocker locker{&m_Lock};	260	QReadLocker locker{&m_Lock};
314	return m_Data.at(0);
315	}
316
317	/**
318	* @return the data as a vector
319	* @remarks this method is only available for a unidimensional ArrayData
320	*/
321	template <int D = Dim, typename = std::enable_if_t<D == 1> >
322	QVector<double> data() const noexcept
323	{
324	QReadLocker locker{&m_Lock};
325	return m_Data[0];
326	}
327
328	// ///////////// //
329	// 2-dim methods //
330	// ///////////// //
331
332	/**
333	* @return the data
334	* @remarks this method is only available for a two-dimensional ArrayData
335	*/
336	template <int D = Dim, typename = std::enable_if_t<D == 2> >
337	DataContainer data() const noexcept
338	{
339	QReadLocker locker{&m_Lock};
340	return m_Data;	261	return m_Data;
341	}	262	}
342		263
343	private:	264	private:
344	DataContainer m_Data;	265	DataContainer m_Data;
		266	/// Number of components (lines). Is always 1 in a 1-dim ArrayData
		267	int m_NbComponents;
345	mutable QReadWriteLock m_Lock;	268	mutable QReadWriteLock m_Lock;
346	};	269	};
347		270
348	#endif // SCIQLOP_ARRAYDATA_H	271	#endif // SCIQLOP_ARRAYDATA_H

core/include/Data/DataSeries.h +2 -2

             #ifndef SCIQLOP_DATASERIES_H
             #define SCIQLOP_DATASERIES_H
             #include "CoreGlobal.h"
             #include <Common/SortUtils.h>
             #include <Data/ArrayData.h>
             #include <Data/IDataSeries.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>
             class IteratorValue : public DataSeriesIteratorValue::Impl {
             public:
                 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())
                 {
                 }
                 IteratorValue(const IteratorValue &other) = default;
                 std::unique_ptr<DataSeriesIteratorValue::Impl> clone() const override
                 {
                     return std::make_unique<IteratorValue<Dim> >(*this);
                 }
                 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);
                 }
                 catch (const std::bad_cast &) {
                     return false;
                 }
                 void next() override
                 {
                     ++m_XIt;
                     ++m_ValuesIt;
                 }
                 void prev() override
                 {
                     --m_XIt;
                     --m_ValuesIt;
                 }
                 double x() const override { return m_XIt->at(0); }
                 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(); }
             private:
-                ArrayData<1>::Iterator m_XIt;
+                ArrayDataIterator m_XIt;
-                typename ArrayData<Dim>::Iterator m_ValuesIt;
+                ArrayDataIterator m_ValuesIt;
             };
             } // namespace dataseries_detail
             /**
              * @brief The DataSeries class is the base (abstract) implementation of IDataSeries.
              *
              * It proposes to set a dimension for the values data.
              *
              * A DataSeries is always sorted on its x-axis data.
              *
              * @tparam Dim The dimension of the values data
              *
              */
             template <int Dim>
             class SCIQLOP_CORE_EXPORT DataSeries : public IDataSeries {
             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; }
                 /// @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; }
                 SqpRange range() const override
                 {
                     if (!m_XAxisData->cdata().isEmpty()) {
                         return SqpRange{m_XAxisData->cdata().first(), m_XAxisData->cdata().last()};
                     }
                     return SqpRange{};
                 }
                 void clear()
                 {
                     m_XAxisData->clear();
                     m_ValuesData->clear();
                 }
                 /// Merges into the data series an other data series
                 /// @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)) {
                         const auto &otherXAxisData = other->xAxisData()->cdata();
                         const auto &xAxisData = m_XAxisData->cdata();
                         // As data series are sorted, we can improve performances of merge, by call the sort
                         // method only if the two data series overlap.
                         if (!otherXAxisData.empty()) {
                             auto firstValue = otherXAxisData.front();
                             auto lastValue = otherXAxisData.back();
                             auto xAxisDataBegin = xAxisData.cbegin();
                             auto xAxisDataEnd = xAxisData.cend();
                             bool prepend;
                             bool sortNeeded;
                             if (std::lower_bound(xAxisDataBegin, xAxisDataEnd, firstValue) == xAxisDataEnd) {
                                 // Other data series if after data series
                                 prepend = false;
                                 sortNeeded = false;
                             }
                             else if (std::upper_bound(xAxisDataBegin, xAxisDataEnd, lastValue)
                                      == xAxisDataBegin) {
                                 // Other data series if before data series
                                 prepend = true;
                                 sortNeeded = false;
                             }
                             else {
                                 // The two data series overlap
                                 prepend = false;
                                 sortNeeded = true;
                             }
                             // Makes the merge
                             m_XAxisData->add(*other->xAxisData(), prepend);
                             m_ValuesData->add(*other->valuesData(), prepend);
                             if (sortNeeded) {
                                 sort();
                             }
                         }
                         // Clears the other data series
                         other->clear();
                     }
                     else {
                         qCWarning(LOG_DataSeries())
                             << QObject::tr("Detection of a type of IDataSeries we cannot merge with !");
                     }
                     unlock();
                     dataSeries->unlock();
                 }
                 // ///////// //
                 // Iterators //
                 // ///////// //
                 DataSeriesIterator cbegin() const override
                 {
                     return DataSeriesIterator{DataSeriesIteratorValue{
                         std::make_unique<dataseries_detail::IteratorValue<Dim> >(*this, true)}};
                 }
                 DataSeriesIterator cend() const override
                 {
                     return DataSeriesIterator{DataSeriesIteratorValue{
                         std::make_unique<dataseries_detail::IteratorValue<Dim> >(*this, false)}};
                 }
                 /// @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(
                         begin, 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);
                 }
                 // /////// //
                 // 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). The vectors must have the same size, otherwise a
                 /// DataSeries with no values will be created.
                 /// @remarks data series is automatically sorted on its x-axis data
                 explicit DataSeries(std::shared_ptr<ArrayData<1> > xAxisData, const Unit &xAxisUnit,
                                     std::shared_ptr<ArrayData<Dim> > valuesData, const Unit &valuesUnit)
                         : m_XAxisData{xAxisData},
                           m_XAxisUnit{xAxisUnit},
                           m_ValuesData{valuesData},
                           m_ValuesUnit{valuesUnit}
                 {
                     if (m_XAxisData->size() != m_ValuesData->size()) {
                         clear();
                     }
                     // 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}
                 {
                     // 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);
                     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);
                 }
                 std::shared_ptr<ArrayData<1> > m_XAxisData;
                 Unit m_XAxisUnit;
                 std::shared_ptr<ArrayData<Dim> > m_ValuesData;
                 Unit m_ValuesUnit;
                 QReadWriteLock m_Lock;
             };
             #endif // SCIQLOP_DATASERIES_H

core/include/Data/DataSeriesIterator.h +2 -30

             #ifndef SCIQLOP_DATASERIESITERATOR_H
             #define SCIQLOP_DATASERIESITERATOR_H
             #include "CoreGlobal.h"
+            #include "Data/SqpIterator.h"
             #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 bool equals(const Impl &other) const = 0;
                     virtual void next() = 0;
                     virtual void prev() = 0;
                     virtual double x() const = 0;
                     virtual double value() const = 0;
                     virtual double value(int componentIndex) const = 0;
                     virtual double minValue() const = 0;
                     virtual double maxValue() const = 0;
                 };
                 explicit DataSeriesIteratorValue(std::unique_ptr<Impl> impl);
                 DataSeriesIteratorValue(const DataSeriesIteratorValue &other);
                 DataSeriesIteratorValue(DataSeriesIteratorValue &&other) = default;
                 DataSeriesIteratorValue &operator=(DataSeriesIteratorValue other);
                 bool equals(const DataSeriesIteratorValue &other) const;
                 /// Advances to the next value
                 void next();
                 /// Moves back to the previous value
                 void prev();
                 /// Gets x-axis data
                 double x() 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;
             private:
                 std::unique_ptr<Impl> m_Impl;
             };
-            /**
+            using DataSeriesIterator = SqpIterator<DataSeriesIteratorValue>;
-             * @brief The DataSeriesIterator class represents an iterator used for data series. It defines all
-             * operators needed for a standard forward iterator
-             * @sa http://www.cplusplus.com/reference/iterator/
-             */
-            class SCIQLOP_CORE_EXPORT DataSeriesIterator {
-            public:
-                using iterator_category = std::forward_iterator_tag;
-                using value_type = const DataSeriesIteratorValue;
-                using difference_type = std::ptrdiff_t;
-                using pointer = value_type *;
-                using reference = value_type &;
-                explicit DataSeriesIterator(DataSeriesIteratorValue value);
-                virtual ~DataSeriesIterator() noexcept = default;
-                DataSeriesIterator(const DataSeriesIterator &) = default;
-                DataSeriesIterator(DataSeriesIterator &&) = default;
-                DataSeriesIterator &operator=(const DataSeriesIterator &) = default;
-                DataSeriesIterator &operator=(DataSeriesIterator &&) = default;
-                DataSeriesIterator &operator++();
-                DataSeriesIterator &operator--();
-                pointer operator->() const { return &m_CurrentValue; }
-                reference operator*() const { return m_CurrentValue; }
-                bool operator==(const DataSeriesIterator &other) const;
-                bool operator!=(const DataSeriesIterator &other) const;
-            private:
-                DataSeriesIteratorValue m_CurrentValue;
-            };
             #endif // SCIQLOP_DATASERIESITERATOR_H

core/include/Data/VectorSeries.h +6 -2

             #ifndef SCIQLOP_VECTORSERIES_H
             #define SCIQLOP_VECTORSERIES_H
             #include "CoreGlobal.h"
             #include <Data/DataSeries.h>
             /**
              * @brief The VectorSeries class is the implementation for a data series representing a vector.
              */
             class SCIQLOP_CORE_EXPORT VectorSeries : public DataSeries<2> {
             public:
                 /**
-                 * Ctor. The vectors must have the same size, otherwise a ScalarSeries with no values will be
+                 * Ctor with three vectors (one per component). The vectors must have the same size, otherwise a
-                 * created.
+                 * ScalarSeries with no values will be created.
                  * @param xAxisData x-axis data
                  * @param xvaluesData x-values data
                  * @param yvaluesData y-values data
                  * @param zvaluesData z-values data
                  */
                 explicit VectorSeries(QVector<double> xAxisData, QVector<double> xValuesData,
                                       QVector<double> yValuesData, QVector<double> zValuesData,
                                       const Unit &xAxisUnit, const Unit &valuesUnit);
+                /// Default Ctor
+                explicit VectorSeries(QVector<double> xAxisData, QVector<double> valuesData,
+                                      const Unit &xAxisUnit, const Unit &valuesUnit);
                 std::unique_ptr<IDataSeries> clone() const;
                 std::shared_ptr<IDataSeries> subDataSeries(const SqpRange &range) override;
             };
             #endif // SCIQLOP_VECTORSERIES_H

core/src/Data/DataSeriesIterator.cpp 0 -27

             #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)
             {
                 std::swap(m_Impl, other.m_Impl);
                 return *this;
             }
             bool DataSeriesIteratorValue::equals(const DataSeriesIteratorValue &other) const
             {
                 return m_Impl->equals(*other.m_Impl);
             }
             void DataSeriesIteratorValue::next()
             {
                 m_Impl->next();
             }
             void DataSeriesIteratorValue::prev()
             {
                 m_Impl->prev();
             }
             double DataSeriesIteratorValue::x() const
             {
                 return m_Impl->x();
             }
             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();
             }
-            DataSeriesIterator::DataSeriesIterator(DataSeriesIteratorValue value)
-                    : m_CurrentValue{std::move(value)}
-            DataSeriesIterator &DataSeriesIterator::operator++()
-                m_CurrentValue.next();
-                return *this;
-            DataSeriesIterator &DataSeriesIterator::operator--()
-                m_CurrentValue.prev();
-                return *this;
-            bool DataSeriesIterator::operator==(const DataSeriesIterator &other) const
-                return m_CurrentValue.equals(other.m_CurrentValue);
-            bool DataSeriesIterator::operator!=(const DataSeriesIterator &other) const
-                return !(*this == other);

core/src/Data/VectorSeries.cpp +47 -3

             #include "Data/VectorSeries.h"
+            namespace {
+            /**
+             * Flatten the three components of a vector to a single QVector that can be passed to an ArrayData
+             *
+             * Example:
+             * xValues = {1, 2, 3}
+             * yValues = {4, 5, 6}
+             * zValues = {7, 8, 9}
+             *
+             * result = {1, 4, 7, 2, 5, 8, 3, 6, 9}
+             *
+             * @param xValues the x-component values of the vector
+             * @param yValues the y-component values of the vector
+             * @param zValues the z-component values of the vector
+             * @return the single QVector
+             * @remarks the three components are consumed
+             * @sa ArrayData
+             */
+            QVector<double> flatten(QVector<double> xValues, QVector<double> yValues, QVector<double> zValues)
+            {
+                if (xValues.size() != yValues.size() || xValues.size() != zValues.size()) {
+                    /// @todo ALX : log
+                    return {};
+                }
+                auto result = QVector<double>{};
+                result.reserve(xValues.size() * 3);
+                while (!xValues.isEmpty()) {
+                    result.append({xValues.takeFirst(), yValues.takeFirst(), zValues.takeFirst()});
+                }
+                return result;
+            }
+            } // namespace
             VectorSeries::VectorSeries(QVector<double> xAxisData, QVector<double> xValuesData,
                                        QVector<double> yValuesData, QVector<double> zValuesData,
                                        const Unit &xAxisUnit, const Unit &valuesUnit)
+                    : VectorSeries{std::move(xAxisData), flatten(std::move(xValuesData), std::move(yValuesData),
+                                                                 std::move(zValuesData)),
+                                   xAxisUnit, valuesUnit}
+            {
+            }
+            VectorSeries::VectorSeries(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<2> >(QVector<QVector<double> >{
+                                 std::make_shared<ArrayData<2> >(std::move(valuesData), 3), valuesUnit}
-                                     std::move(xValuesData), std::move(yValuesData), std::move(zValuesData)}),
-                                 valuesUnit}
             {
             }
             std::unique_ptr<IDataSeries> VectorSeries::clone() const
             {
                 return std::make_unique<VectorSeries>(*this);
             }
             std::shared_ptr<IDataSeries> VectorSeries::subDataSeries(const SqpRange &range)
             {
                 auto subXAxisData = QVector<double>();
                 auto subXValuesData = QVector<double>();
                 auto subYValuesData = QVector<double>();
                 auto subZValuesData = QVector<double>();
                 this->lockRead();
                 {
                     auto bounds = xAxisRange(range.m_TStart, range.m_TEnd);
                     for (auto it = bounds.first; it != bounds.second; ++it) {
                         subXAxisData.append(it->x());
                         subXValuesData.append(it->value(0));
                         subYValuesData.append(it->value(1));
                         subZValuesData.append(it->value(2));
                     }
                 }
                 this->unlock();
                 return std::make_shared<VectorSeries>(subXAxisData, subXValuesData, subYValuesData,
                                                       subZValuesData, this->xAxisUnit(), this->valuesUnit());
             }

core/tests/Data/TestDataSeries.cpp +17 -20

             #include "Data/DataSeries.h"
             #include "Data/ScalarSeries.h"
             #include "Data/VectorSeries.h"
             #include <cmath>
             #include <QObject>
             #include <QtTest>
             Q_DECLARE_METATYPE(std::shared_ptr<ScalarSeries>)
             Q_DECLARE_METATYPE(std::shared_ptr<VectorSeries>)
+            namespace {
+            void validateRange(DataSeriesIterator first, DataSeriesIterator last, const QVector<double> &xData,
+                               const QVector<double> &valuesData)
+            {
+                QVERIFY(std::equal(first, last, xData.cbegin(), xData.cend(),
+                                   [](const auto &it, const auto &expectedX) { return it.x() == expectedX; }));
+                QVERIFY(std::equal(
+                    first, last, valuesData.cbegin(), valuesData.cend(),
+                    [](const auto &it, const auto &expectedVal) { return it.value() == expectedVal; }));
+            }
+            } // namespace
             class TestDataSeries : public QObject {
                 Q_OBJECT
             private:
                 template <typename T>
                 void testValuesBoundsStructure()
                 {
                     // ////////////// //
                     // Test structure //
                     // ////////////// //
                     // Data series to get values bounds
                     QTest::addColumn<std::shared_ptr<T> >("dataSeries");
                     // x-axis range
                     QTest::addColumn<double>("minXAxis");
                     QTest::addColumn<double>("maxXAxis");
                     // Expected results
                     QTest::addColumn<bool>(
                         "expectedOK"); // Test is expected to be ok (i.e. method doesn't return end iterators)
                     QTest::addColumn<double>("expectedMinValue");
                     QTest::addColumn<double>("expectedMaxValue");
                 }
                 template <typename T>
                 void testValuesBounds()
                 {
                     QFETCH(std::shared_ptr<T>, dataSeries);
                     QFETCH(double, minXAxis);
                     QFETCH(double, maxXAxis);
                     QFETCH(bool, expectedOK);
                     QFETCH(double, expectedMinValue);
                     QFETCH(double, expectedMaxValue);
                     auto minMaxIts = dataSeries->valuesBounds(minXAxis, maxXAxis);
                     auto end = dataSeries->cend();
                     // Checks iterators with expected result
                     QCOMPARE(expectedOK, minMaxIts.first != end && minMaxIts.second != end);
                     if (expectedOK) {
                         auto compare = [](const auto &v1, const auto &v2) {
                             return (std::isnan(v1) && std::isnan(v2)) || v1 == v2;
                         };
                         QVERIFY(compare(expectedMinValue, minMaxIts.first->minValue()));
                         QVERIFY(compare(expectedMaxValue, minMaxIts.second->maxValue()));
                     }
                 }
             private slots:
                 /// Input test data
                 /// @sa testCtor()
                 void testCtor_data();
                 /// Tests construction of a data series
                 void testCtor();
                 /// Input test data
                 /// @sa testMerge()
                 void testMerge_data();
                 /// Tests merge of two data series
                 void testMerge();
                 /// Input test data
                 /// @sa testMinXAxisData()
                 void testMinXAxisData_data();
                 /// Tests get min x-axis data of a data series
                 void testMinXAxisData();
                 /// Input test data
                 /// @sa testMaxXAxisData()
                 void testMaxXAxisData_data();
                 /// Tests get max x-axis data of a data series
                 void testMaxXAxisData();
                 /// Input test data
                 /// @sa testXAxisRange()
                 void testXAxisRange_data();
                 /// Tests get x-axis range of a data series
                 void testXAxisRange();
                 /// Input test data
                 /// @sa testValuesBoundsScalar()
                 void testValuesBoundsScalar_data();
                 /// Tests get values bounds of a scalar series
                 void testValuesBoundsScalar();
                 /// Input test data
                 /// @sa testValuesBoundsVector()
                 void testValuesBoundsVector_data();
                 /// Tests get values bounds of a vector series
                 void testValuesBoundsVector();
             };
             void TestDataSeries::testCtor_data()
             {
                 // ////////////// //
                 // Test structure //
                 // ////////////// //
                 // x-axis data
                 QTest::addColumn<QVector<double> >("xAxisData");
                 // values data
                 QTest::addColumn<QVector<double> >("valuesData");
                 // expected x-axis data
                 QTest::addColumn<QVector<double> >("expectedXAxisData");
                 // expected values data
                 QTest::addColumn<QVector<double> >("expectedValuesData");
                 // ////////// //
                 // Test cases //
                 // ////////// //
                 QTest::newRow("invalidData (different sizes of vectors)")
                     << QVector<double>{1., 2., 3., 4., 5.} << QVector<double>{100., 200., 300.}
                     << QVector<double>{} << QVector<double>{};
                 QTest::newRow("sortedData") << QVector<double>{1., 2., 3., 4., 5.}
                                             << QVector<double>{100., 200., 300., 400., 500.}
                                             << QVector<double>{1., 2., 3., 4., 5.}
                                             << QVector<double>{100., 200., 300., 400., 500.};
                 QTest::newRow("unsortedData") << QVector<double>{5., 4., 3., 2., 1.}
                                               << QVector<double>{100., 200., 300., 400., 500.}
                                               << QVector<double>{1., 2., 3., 4., 5.}
                                               << QVector<double>{500., 400., 300., 200., 100.};
                 QTest::newRow("unsortedData2")
                     << QVector<double>{1., 4., 3., 5., 2.} << QVector<double>{100., 200., 300., 400., 500.}
                     << QVector<double>{1., 2., 3., 4., 5.} << QVector<double>{100., 500., 300., 200., 400.};
             }
             void TestDataSeries::testCtor()
             {
                 // Creates series
                 QFETCH(QVector<double>, xAxisData);
                 QFETCH(QVector<double>, valuesData);
                 auto series = std::make_shared<ScalarSeries>(std::move(xAxisData), std::move(valuesData),
                                                              Unit{}, Unit{});
                 // Validates results : we check that the data series is sorted on its x-axis data
                 QFETCH(QVector<double>, expectedXAxisData);
                 QFETCH(QVector<double>, expectedValuesData);
-                auto seriesXAxisData = series->xAxisData()->data();
+                validateRange(series->cbegin(), series->cend(), expectedXAxisData, expectedValuesData);
-                auto seriesValuesData = series->valuesData()->data();
-                QVERIFY(
-                    std::equal(expectedXAxisData.cbegin(), expectedXAxisData.cend(), seriesXAxisData.cbegin()));
-                QVERIFY(std::equal(expectedValuesData.cbegin(), expectedValuesData.cend(),
-                                   seriesValuesData.cbegin()));
             }
             namespace {
             std::shared_ptr<ScalarSeries> createScalarSeries(QVector<double> xAxisData,
                                                              QVector<double> valuesData)
             {
                 return std::make_shared<ScalarSeries>(std::move(xAxisData), std::move(valuesData), Unit{},
                                                       Unit{});
             }
             std::shared_ptr<VectorSeries> createVectorSeries(QVector<double> xAxisData,
                                                              QVector<double> xValuesData,
                                                              QVector<double> yValuesData,
                                                              QVector<double> zValuesData)
             {
                 return std::make_shared<VectorSeries>(std::move(xAxisData), std::move(xValuesData),
                                                       std::move(yValuesData), std::move(zValuesData), Unit{},
                                                       Unit{});
             }
             } // namespace
             void TestDataSeries::testMerge_data()
             {
                 // ////////////// //
                 // Test structure //
                 // ////////////// //
                 // Data series to merge
                 QTest::addColumn<std::shared_ptr<ScalarSeries> >("dataSeries");
                 QTest::addColumn<std::shared_ptr<ScalarSeries> >("dataSeries2");
                 // Expected values in the first data series after merge
                 QTest::addColumn<QVector<double> >("expectedXAxisData");
                 QTest::addColumn<QVector<double> >("expectedValuesData");
                 // ////////// //
                 // Test cases //
                 // ////////// //
                 QTest::newRow("sortedMerge")
                     << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
                     << createScalarSeries({6., 7., 8., 9., 10.}, {600., 700., 800., 900., 1000.})
                     << QVector<double>{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.}
                     << QVector<double>{100., 200., 300., 400., 500., 600., 700., 800., 900., 1000.};
                 QTest::newRow("unsortedMerge")
                     << createScalarSeries({6., 7., 8., 9., 10.}, {600., 700., 800., 900., 1000.})
                     << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
                     << QVector<double>{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.}
                     << QVector<double>{100., 200., 300., 400., 500., 600., 700., 800., 900., 1000.};
                 QTest::newRow("unsortedMerge2")
                     << createScalarSeries({1., 2., 8., 9., 10}, {100., 200., 300., 400., 500.})
                     << createScalarSeries({3., 4., 5., 6., 7.}, {600., 700., 800., 900., 1000.})
                     << QVector<double>{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.}
                     << QVector<double>{100., 200., 600., 700., 800., 900., 1000., 300., 400., 500.};
                 QTest::newRow("unsortedMerge3")
                     << createScalarSeries({3., 5., 8., 7., 2}, {100., 200., 300., 400., 500.})
                     << createScalarSeries({6., 4., 9., 10., 1.}, {600., 700., 800., 900., 1000.})
                     << QVector<double>{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.}
                     << QVector<double>{1000., 500., 100., 700., 200., 600., 400., 300., 800., 900.};
             }
             void TestDataSeries::testMerge()
             {
                 // Merges series
                 QFETCH(std::shared_ptr<ScalarSeries>, dataSeries);
                 QFETCH(std::shared_ptr<ScalarSeries>, dataSeries2);
                 dataSeries->merge(dataSeries2.get());
                 // Validates results : we check that the merge is valid and the data series is sorted on its
                 // x-axis data
                 QFETCH(QVector<double>, expectedXAxisData);
                 QFETCH(QVector<double>, expectedValuesData);
-                auto seriesXAxisData = dataSeries->xAxisData()->data();
+                validateRange(dataSeries->cbegin(), dataSeries->cend(), expectedXAxisData, expectedValuesData);
-                auto seriesValuesData = dataSeries->valuesData()->data();
-                QVERIFY(
-                    std::equal(expectedXAxisData.cbegin(), expectedXAxisData.cend(), seriesXAxisData.cbegin()));
-                QVERIFY(std::equal(expectedValuesData.cbegin(), expectedValuesData.cend(),
-                                   seriesValuesData.cbegin()));
             }
             void TestDataSeries::testMinXAxisData_data()
             {
                 // ////////////// //
                 // Test structure //
                 // ////////////// //
                 // Data series to get min data
                 QTest::addColumn<std::shared_ptr<ScalarSeries> >("dataSeries");
                 // Min data
                 QTest::addColumn<double>("min");
                 // Expected results
                 QTest::addColumn<bool>(
                     "expectedOK"); // if true, expects to have a result (i.e. the iterator != end iterator)
                 QTest::addColumn<double>(
                     "expectedMin"); // Expected value when method doesn't return end iterator
                 // ////////// //
                 // Test cases //
                 // ////////// //
                 QTest::newRow("minData1") << createScalarSeries({1., 2., 3., 4., 5.},
                                                                 {100., 200., 300., 400., 500.})
                                           << 0. << true << 1.;
                 QTest::newRow("minData2") << createScalarSeries({1., 2., 3., 4., 5.},
                                                                 {100., 200., 300., 400., 500.})
                                           << 1. << true << 1.;
                 QTest::newRow("minData3") << createScalarSeries({1., 2., 3., 4., 5.},
                                                                 {100., 200., 300., 400., 500.})
                                           << 1.1 << true << 2.;
                 QTest::newRow("minData4") << createScalarSeries({1., 2., 3., 4., 5.},
                                                                 {100., 200., 300., 400., 500.})
                                           << 5. << true << 5.;
                 QTest::newRow("minData5") << createScalarSeries({1., 2., 3., 4., 5.},
                                                                 {100., 200., 300., 400., 500.})
                                           << 5.1 << false << std::numeric_limits<double>::quiet_NaN();
                 QTest::newRow("minData6") << createScalarSeries({}, {}) << 1.1 << false
                                           << std::numeric_limits<double>::quiet_NaN();
             }
             void TestDataSeries::testMinXAxisData()
             {
                 QFETCH(std::shared_ptr<ScalarSeries>, dataSeries);
                 QFETCH(double, min);
                 QFETCH(bool, expectedOK);
                 QFETCH(double, expectedMin);
                 auto it = dataSeries->minXAxisData(min);
                 QCOMPARE(expectedOK, it != dataSeries->cend());
                 // If the method doesn't return a end iterator, checks with expected value
                 if (expectedOK) {
                     QCOMPARE(expectedMin, it->x());
                 }
             }
             void TestDataSeries::testMaxXAxisData_data()
             {
                 // ////////////// //
                 // Test structure //
                 // ////////////// //
                 // Data series to get max data
                 QTest::addColumn<std::shared_ptr<ScalarSeries> >("dataSeries");
                 // Max data
                 QTest::addColumn<double>("max");
                 // Expected results
                 QTest::addColumn<bool>(
                     "expectedOK"); // if true, expects to have a result (i.e. the iterator != end iterator)
                 QTest::addColumn<double>(
                     "expectedMax"); // Expected value when method doesn't return end iterator
                 // ////////// //
                 // Test cases //
                 // ////////// //
                 QTest::newRow("maxData1") << createScalarSeries({1., 2., 3., 4., 5.},
                                                                 {100., 200., 300., 400., 500.})
                                           << 6. << true << 5.;
                 QTest::newRow("maxData2") << createScalarSeries({1., 2., 3., 4., 5.},
                                                                 {100., 200., 300., 400., 500.})
                                           << 5. << true << 5.;
                 QTest::newRow("maxData3") << createScalarSeries({1., 2., 3., 4., 5.},
                                                                 {100., 200., 300., 400., 500.})
                                           << 4.9 << true << 4.;
                 QTest::newRow("maxData4") << createScalarSeries({1., 2., 3., 4., 5.},
                                                                 {100., 200., 300., 400., 500.})
                                           << 1.1 << true << 1.;
                 QTest::newRow("maxData5") << createScalarSeries({1., 2., 3., 4., 5.},
                                                                 {100., 200., 300., 400., 500.})
                                           << 1. << true << 1.;
                 QTest::newRow("maxData6") << createScalarSeries({}, {}) << 1.1 << false
                                           << std::numeric_limits<double>::quiet_NaN();
             }
             void TestDataSeries::testMaxXAxisData()
             {
                 QFETCH(std::shared_ptr<ScalarSeries>, dataSeries);
                 QFETCH(double, max);
                 QFETCH(bool, expectedOK);
                 QFETCH(double, expectedMax);
                 auto it = dataSeries->maxXAxisData(max);
                 QCOMPARE(expectedOK, it != dataSeries->cend());
                 // If the method doesn't return a end iterator, checks with expected value
                 if (expectedOK) {
                     QCOMPARE(expectedMax, it->x());
                 }
             }
             void TestDataSeries::testXAxisRange_data()
             {
                 // ////////////// //
                 // Test structure //
                 // ////////////// //
                 // Data series to get x-axis range
                 QTest::addColumn<std::shared_ptr<ScalarSeries> >("dataSeries");
                 // Min/max values
                 QTest::addColumn<double>("min");
                 QTest::addColumn<double>("max");
                 // Expected values
                 QTest::addColumn<QVector<double> >("expectedXAxisData");
                 QTest::addColumn<QVector<double> >("expectedValuesData");
                 // ////////// //
                 // Test cases //
                 // ////////// //
                 QTest::newRow("xAxisRange1") << createScalarSeries({1., 2., 3., 4., 5.},
                                                                    {100., 200., 300., 400., 500.})
                                              << -1. << 3.2 << QVector<double>{1., 2., 3.}
                                              << QVector<double>{100., 200., 300.};
                 QTest::newRow("xAxisRange2") << createScalarSeries({1., 2., 3., 4., 5.},
                                                                    {100., 200., 300., 400., 500.})
                                              << 1. << 4. << QVector<double>{1., 2., 3., 4.}
                                              << QVector<double>{100., 200., 300., 400.};
                 QTest::newRow("xAxisRange3") << createScalarSeries({1., 2., 3., 4., 5.},
                                                                    {100., 200., 300., 400., 500.})
                                              << 1. << 3.9 << QVector<double>{1., 2., 3.}
                                              << QVector<double>{100., 200., 300.};
                 QTest::newRow("xAxisRange4") << createScalarSeries({1., 2., 3., 4., 5.},
                                                                    {100., 200., 300., 400., 500.})
                                              << 0. << 0.9 << QVector<double>{} << QVector<double>{};
                 QTest::newRow("xAxisRange5") << createScalarSeries({1., 2., 3., 4., 5.},
                                                                    {100., 200., 300., 400., 500.})
                                              << 0. << 1. << QVector<double>{1.} << QVector<double>{100.};
                 QTest::newRow("xAxisRange6") << createScalarSeries({1., 2., 3., 4., 5.},
                                                                    {100., 200., 300., 400., 500.})
                                              << 2.1 << 6. << QVector<double>{3., 4., 5.}
                                              << QVector<double>{300., 400., 500.};
                 QTest::newRow("xAxisRange7") << createScalarSeries({1., 2., 3., 4., 5.},
                                                                    {100., 200., 300., 400., 500.})
                                              << 6. << 9. << QVector<double>{} << QVector<double>{};
                 QTest::newRow("xAxisRange8") << createScalarSeries({1., 2., 3., 4., 5.},
                                                                    {100., 200., 300., 400., 500.})
                                              << 5. << 9. << QVector<double>{5.} << QVector<double>{500.};
             }
             void TestDataSeries::testXAxisRange()
             {
                 QFETCH(std::shared_ptr<ScalarSeries>, dataSeries);
                 QFETCH(double, min);
                 QFETCH(double, max);
                 QFETCH(QVector<double>, expectedXAxisData);
                 QFETCH(QVector<double>, expectedValuesData);
                 auto bounds = dataSeries->xAxisRange(min, max);
-                QVERIFY(std::equal(bounds.first, bounds.second, expectedXAxisData.cbegin(),
+                validateRange(bounds.first, bounds.second, expectedXAxisData, expectedValuesData);
-                                   expectedXAxisData.cend(),
-                                   [](const auto &it, const auto &expectedX) { return it.x() == expectedX; }));
-                QVERIFY(std::equal(
-                    bounds.first, bounds.second, expectedValuesData.cbegin(), expectedValuesData.cend(),
-                    [](const auto &it, const auto &expectedVal) { return it.value() == expectedVal; }));
             }
             void TestDataSeries::testValuesBoundsScalar_data()
             {
                 testValuesBoundsStructure<ScalarSeries>();
                 // ////////// //
                 // Test cases //
                 // ////////// //
                 auto nan = std::numeric_limits<double>::quiet_NaN();
                 QTest::newRow("scalarBounds1")
                     << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.}) << 0. << 6.
                     << true << 100. << 500.;
                 QTest::newRow("scalarBounds2")
                     << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.}) << 2. << 4.
                     << true << 200. << 400.;
                 QTest::newRow("scalarBounds3")
                     << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.}) << 0. << 0.5
                     << false << nan << nan;
                 QTest::newRow("scalarBounds4")
                     << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.}) << 5.1 << 6.
                     << false << nan << nan;
                 QTest::newRow("scalarBounds5") << createScalarSeries({1.}, {100.}) << 0. << 2. << true << 100.
                                                << 100.;
                 QTest::newRow("scalarBounds6") << createScalarSeries({}, {}) << 0. << 2. << false << nan << nan;
                 // Tests with NaN values: NaN values are not included in min/max search
                 QTest::newRow("scalarBounds7")
                     << createScalarSeries({1., 2., 3., 4., 5.}, {nan, 200., 300., 400., nan}) << 0. << 6.
                     << true << 200. << 400.;
                 QTest::newRow("scalarBounds8")
                     << createScalarSeries({1., 2., 3., 4., 5.}, {nan, nan, nan, nan, nan}) << 0. << 6. << true
                     << std::numeric_limits<double>::quiet_NaN() << std::numeric_limits<double>::quiet_NaN();
             }
             void TestDataSeries::testValuesBoundsScalar()
             {
                 testValuesBounds<ScalarSeries>();
             }
             void TestDataSeries::testValuesBoundsVector_data()
             {
                 testValuesBoundsStructure<VectorSeries>();
                 // ////////// //
                 // Test cases //
                 // ////////// //
                 auto nan = std::numeric_limits<double>::quiet_NaN();
                 QTest::newRow("vectorBounds1")
                     << createVectorSeries({1., 2., 3., 4., 5.}, {10., 15., 20., 13., 12.},
                                           {35., 24., 10., 9., 0.3}, {13., 14., 12., 9., 24.})
                     << 0. << 6. << true << 0.3 << 35.; // min/max in same component
                 QTest::newRow("vectorBounds2")
                     << createVectorSeries({1., 2., 3., 4., 5.}, {2.3, 15., 20., 13., 12.},
                                           {35., 24., 10., 9., 4.}, {13., 14., 12., 9., 24.})
                     << 0. << 6. << true << 2.3 << 35.; // min/max in same entry
                 QTest::newRow("vectorBounds3")
                     << createVectorSeries({1., 2., 3., 4., 5.}, {2.3, 15., 20., 13., 12.},
                                           {35., 24., 10., 9., 4.}, {13., 14., 12., 9., 24.})
                     << 2. << 3. << true << 10. << 24.;
                 // Tests with NaN values: NaN values are not included in min/max search
                 QTest::newRow("vectorBounds4")
                     << createVectorSeries({1., 2.}, {nan, nan}, {nan, nan}, {nan, nan}) << 0. << 6. << true
                     << nan << nan;
             }
             void TestDataSeries::testValuesBoundsVector()
             {
                 testValuesBounds<VectorSeries>();
             }
             QTEST_MAIN(TestDataSeries)
             #include "TestDataSeries.moc"

core/tests/Data/TestOneDimArrayData.cpp +15 -33

             #include "Data/ArrayData.h"
             #include <QObject>
             #include <QtTest>
+            namespace {
+            void verifyArrayData(const ArrayData<1> &arrayData, const QVector<double> &expectedData)
+            {
+                QVERIFY(std::equal(
+                    arrayData.cbegin(), arrayData.cend(), expectedData.cbegin(), expectedData.cend(),
+                    [](const auto &it, const auto &expectedData) { return it.at(0) == expectedData; }));
+            }
+            } // namespace
             class TestOneDimArrayData : public QObject {
                 Q_OBJECT
             private slots:
                 /// Tests @sa ArrayData::data()
                 void testData_data();
                 void testData();
-                /// Tests @sa ArrayData::data(int componentIndex)
-                void testDataByComponentIndex_data();
-                void testDataByComponentIndex();
                 /// Tests @sa ArrayData::add()
                 void testAdd_data();
                 void testAdd();
                 /// Tests @sa ArrayData::at(int index)
                 void testAt_data();
                 void testAt();
                 /// Tests @sa ArrayData::clear()
                 void testClear_data();
                 void testClear();
                 /// Tests @sa ArrayData::size()
                 void testSize_data();
                 void testSize();
                 /// Tests @sa ArrayData::sort()
                 void testSort_data();
                 void testSort();
             };
             void TestOneDimArrayData::testData_data()
             {
                 // Test structure
                 QTest::addColumn<QVector<double> >("inputData");    // array's data input
                 QTest::addColumn<QVector<double> >("expectedData"); // expected data
                 // Test cases
                 QTest::newRow("data1") << QVector<double>{1., 2., 3., 4., 5.}
                                        << QVector<double>{1., 2., 3., 4., 5.};
             }
             void TestOneDimArrayData::testData()
             {
                 QFETCH(QVector<double>, inputData);
                 QFETCH(QVector<double>, expectedData);
                 ArrayData<1> arrayData{inputData};
-                QVERIFY(arrayData.data() == expectedData);
+                verifyArrayData(arrayData, expectedData);
-            void TestOneDimArrayData::testDataByComponentIndex_data()
-                // Test structure
-                QTest::addColumn<QVector<double> >("inputData");    // array data's input
-                QTest::addColumn<int>("componentIndex");            // component index to test
-                QTest::addColumn<QVector<double> >("expectedData"); // expected data
-                // Test cases
-                QTest::newRow("validIndex") << QVector<double>{1., 2., 3., 4., 5.} << 0
-                                            << QVector<double>{1., 2., 3., 4., 5.};
-                QTest::newRow("invalidIndex1") << QVector<double>{1., 2., 3., 4., 5.} << -1
-                                               << QVector<double>{};
-                QTest::newRow("invalidIndex2") << QVector<double>{1., 2., 3., 4., 5.} << 1 << QVector<double>{};
-            void TestOneDimArrayData::testDataByComponentIndex()
-                QFETCH(QVector<double>, inputData);
-                QFETCH(int, componentIndex);
-                QFETCH(QVector<double>, expectedData);
-                ArrayData<1> arrayData{inputData};
-                QVERIFY(arrayData.data(componentIndex) == expectedData);
             }
             void TestOneDimArrayData::testAdd_data()
             {
                 // Test structure
                 QTest::addColumn<QVector<double> >("inputData");    // array's data input
                 QTest::addColumn<QVector<double> >("otherData");    // array data's input to merge with
                 QTest::addColumn<bool>("prepend");                  // prepend or append merge
                 QTest::addColumn<QVector<double> >("expectedData"); // expected data after merge
                 // Test cases
                 QTest::newRow("appendMerge") << QVector<double>{1., 2., 3., 4., 5.}
                                              << QVector<double>{6., 7., 8.} << false
                                              << QVector<double>{1., 2., 3., 4., 5., 6., 7., 8.};
                 QTest::newRow("prependMerge") << QVector<double>{1., 2., 3., 4., 5.}
                                               << QVector<double>{6., 7., 8.} << true
                                               << QVector<double>{6., 7., 8., 1., 2., 3., 4., 5.};
             }
             void TestOneDimArrayData::testAdd()
             {
                 QFETCH(QVector<double>, inputData);
                 QFETCH(QVector<double>, otherData);
                 QFETCH(bool, prepend);
                 QFETCH(QVector<double>, expectedData);
                 ArrayData<1> arrayData{inputData};
                 ArrayData<1> other{otherData};
                 arrayData.add(other, prepend);
-                QVERIFY(arrayData.data() == expectedData);
+                verifyArrayData(arrayData, expectedData);
             }
             void TestOneDimArrayData::testAt_data()
             {
                 // Test structure
                 QTest::addColumn<QVector<double> >("inputData"); // array data's input
                 QTest::addColumn<int>("index");                  // index to retrieve data
                 QTest::addColumn<double>("expectedData");        // expected data at index
                 // Test cases
                 QTest::newRow("data1") << QVector<double>{1., 2., 3., 4., 5.} << 0 << 1.;
                 QTest::newRow("data2") << QVector<double>{1., 2., 3., 4., 5.} << 3 << 4.;
             }
             void TestOneDimArrayData::testAt()
             {
                 QFETCH(QVector<double>, inputData);
                 QFETCH(int, index);
                 QFETCH(double, expectedData);
                 ArrayData<1> arrayData{inputData};
                 QVERIFY(arrayData.at(index) == expectedData);
             }
             void TestOneDimArrayData::testClear_data()
             {
                 // Test structure
                 QTest::addColumn<QVector<double> >("inputData"); // array data's input
                 // Test cases
                 QTest::newRow("data1") << QVector<double>{1., 2., 3., 4., 5.};
             }
             void TestOneDimArrayData::testClear()
             {
                 QFETCH(QVector<double>, inputData);
                 ArrayData<1> arrayData{inputData};
                 arrayData.clear();
-                QVERIFY(arrayData.data() == QVector<double>{});
+                verifyArrayData(arrayData, QVector<double>{});
             }
             void TestOneDimArrayData::testSize_data()
             {
                 // Test structure
                 QTest::addColumn<QVector<double> >("inputData"); // array data's input
                 QTest::addColumn<int>("expectedSize");           // expected array data size
                 // Test cases
                 QTest::newRow("data1") << QVector<double>{1., 2., 3., 4., 5.} << 5;
             }
             void TestOneDimArrayData::testSize()
             {
                 QFETCH(QVector<double>, inputData);
                 QFETCH(int, expectedSize);
                 ArrayData<1> arrayData{inputData};
                 QVERIFY(arrayData.size() == expectedSize);
             }
             void TestOneDimArrayData::testSort_data()
             {
                 // Test structure
                 QTest::addColumn<QVector<double> >("inputData");        // array data's input
                 QTest::addColumn<std::vector<int> >("sortPermutation"); // permutation used to sort data
                 QTest::addColumn<QVector<double> >("expectedData");     // expected data after sorting
                 // Test cases
                 QTest::newRow("data1") << QVector<double>{1., 2., 3., 4., 5.} << std::vector<int>{0, 2, 3, 1, 4}
                                        << QVector<double>{1., 3., 4., 2., 5.};
                 QTest::newRow("data2") << QVector<double>{1., 2., 3., 4., 5.} << std::vector<int>{4, 1, 2, 3, 0}
                                        << QVector<double>{5., 2., 3., 4., 1.};
             }
             void TestOneDimArrayData::testSort()
             {
                 QFETCH(QVector<double>, inputData);
                 QFETCH(std::vector<int>, sortPermutation);
                 QFETCH(QVector<double>, expectedData);
                 ArrayData<1> arrayData{inputData};
                 auto sortedArrayData = arrayData.sort(sortPermutation);
                 QVERIFY(sortedArrayData != nullptr);
-                QVERIFY(sortedArrayData->data() == expectedData);
+                verifyArrayData(*sortedArrayData, expectedData);
             }
             QTEST_MAIN(TestOneDimArrayData)
             #include "TestOneDimArrayData.moc"

core/tests/Data/TestTwoDimArrayData.cpp +120 -105

             #include "Data/ArrayData.h"
             #include <QObject>
             #include <QtTest>
-            using DataContainer = QVector<QVector<double> >;
+            using Container = QVector<QVector<double> >;
+            using InputData = QPair<QVector<double>, int>;
+            namespace {
+            InputData flatten(const Container &container)
+            {
+                if (container.isEmpty()) {
+                    return {};
+                }
+                // We assume here that each component of the container have the same size
+                auto containerSize = container.size();
+                auto componentSize = container.first().size();
+                auto result = QVector<double>{};
+                result.reserve(componentSize * containerSize);
+                for (auto i = 0; i < componentSize; ++i) {
+                    for (auto j = 0; j < containerSize; ++j) {
+                        result.append(container.at(j).at(i));
+                    }
+                }
+                return {result, containerSize};
+            }
+            void verifyArrayData(const ArrayData<2> &arrayData, const Container &expectedData)
+            {
+                auto verifyComponent = [&arrayData](const auto &componentData, const auto &equalFun) {
+                    QVERIFY(std::equal(arrayData.cbegin(), arrayData.cend(), componentData.cbegin(),
+                                       componentData.cend(),
+                                       [&equalFun](const auto &dataSeriesIt, const auto &expectedValue) {
+                                           return equalFun(dataSeriesIt, expectedValue);
+                                       }));
+                };
+                for (auto i = 0; i < expectedData.size(); ++i) {
+                    verifyComponent(expectedData.at(i), [i](const auto &seriesIt, const auto &value) {
+                        return seriesIt.at(i) == value;
+                    });
+                }
+            }
+            } // namespace
             class TestTwoDimArrayData : public QObject {
                 Q_OBJECT
             private slots:
-                /// Tests @sa ArrayData::data(int componentIndex)
-                void testDataByComponentIndex_data();
-                void testDataByComponentIndex();
                 /// Tests @sa ArrayData ctor
                 void testCtor_data();
                 void testCtor();
                 /// Tests @sa ArrayData::add()
                 void testAdd_data();
                 void testAdd();
                 /// Tests @sa ArrayData::clear()
                 void testClear_data();
                 void testClear();
                 /// Tests @sa ArrayData::size()
                 void testSize_data();
                 void testSize();
                 /// Tests @sa ArrayData::sort()
                 void testSort_data();
                 void testSort();
             };
-            void TestTwoDimArrayData::testDataByComponentIndex_data()
-                // Test structure
-                QTest::addColumn<DataContainer>("inputData");       // array data's input
-                QTest::addColumn<int>("componentIndex");            // component index to test
-                QTest::addColumn<QVector<double> >("expectedData"); // expected data
-                // Test cases
-                auto inputData
-                    = DataContainer{{1., 2., 3., 4., 5.}, {6., 7., 8., 9., 10.}, {11., 12., 13., 14., 15.}};
-                QTest::newRow("validIndex1") << inputData << 0 << QVector<double>{1., 2., 3., 4., 5.};
-                QTest::newRow("validIndex2") << inputData << 1 << QVector<double>{6., 7., 8., 9., 10.};
-                QTest::newRow("validIndex3") << inputData << 2 << QVector<double>{11., 12., 13., 14., 15.};
-                QTest::newRow("invalidIndex1") << inputData << -1 << QVector<double>{};
-                QTest::newRow("invalidIndex2") << inputData << 3 << QVector<double>{};
-            void TestTwoDimArrayData::testDataByComponentIndex()
-                QFETCH(DataContainer, inputData);
-                QFETCH(int, componentIndex);
-                QFETCH(QVector<double>, expectedData);
-                ArrayData<2> arrayData{inputData};
-                QVERIFY(arrayData.data(componentIndex) == expectedData);
             void TestTwoDimArrayData::testCtor_data()
             {
                 // Test structure
-                QTest::addColumn<DataContainer>("inputData");    // array data's input
+                QTest::addColumn<InputData>("inputData");    // array data's input
-                QTest::addColumn<bool>("success");               // array data has been successfully constructed
+                QTest::addColumn<bool>("success");           // array data has been successfully constructed
-                QTest::addColumn<DataContainer>("expectedData"); // expected array data (when success)
+                QTest::addColumn<Container>("expectedData"); // expected array data (when success)
                 // Test cases
-                QTest::newRow("validInput")
+                QTest::newRow("validInput") << flatten(Container{{1., 2., 3., 4., 5.},
-                    << DataContainer{{1., 2., 3., 4., 5.}, {6., 7., 8., 9., 10.}, {11., 12., 13., 14., 15.}}
+                                                                 {6., 7., 8., 9., 10.},
-                    << true
+                                                                 {11., 12., 13., 14., 15.}})
-                    << DataContainer{{1., 2., 3., 4., 5.}, {6., 7., 8., 9., 10.}, {11., 12., 13., 14., 15.}};
+                                            << true << Container{{1., 2., 3., 4., 5.},
-                QTest::newRow("malformedInput (components of the array data haven't the same size")
+                                                                 {6., 7., 8., 9., 10.},
-                    << DataContainer{{1., 2., 3., 4., 5.}, {6., 7., 8.}, {11., 12.}} << true
+                                                                 {11., 12., 13., 14., 15.}};
-                    << DataContainer{{}, {}, {}};
+                QTest::newRow("invalidInput (invalid data size")
-                QTest::newRow("invalidInput (less than tow components") << DataContainer{{1., 2., 3., 4., 5.}}
+                    << InputData{{1., 2., 3., 4., 5., 6., 7.}, 3} << false << Container{{}, {}, {}};
-                                                                        << false << DataContainer{{}, {}, {}};
+                QTest::newRow("invalidInput (less than two components")
+                    << flatten(Container{{1., 2., 3., 4., 5.}}) << false << Container{{}, {}, {}};
             }
             void TestTwoDimArrayData::testCtor()
             {
-                QFETCH(DataContainer, inputData);
+                QFETCH(InputData, inputData);
                 QFETCH(bool, success);
                 if (success) {
-                    QFETCH(DataContainer, expectedData);
+                    QFETCH(Container, expectedData);
-                    ArrayData<2> arrayData{inputData};
-                    for (auto i = 0; i < expectedData.size(); ++i) {
+                    ArrayData<2> arrayData{inputData.first, inputData.second};
-                        QVERIFY(arrayData.data(i) == expectedData.at(i));
+                    verifyArrayData(arrayData, expectedData);
                 }
                 else {
-                    QVERIFY_EXCEPTION_THROWN(ArrayData<2> arrayData{inputData}, std::invalid_argument);
+                    QVERIFY_EXCEPTION_THROWN(ArrayData<2>(inputData.first, inputData.second),
+                                             std::invalid_argument);
                 }
             }
             void TestTwoDimArrayData::testAdd_data()
             {
                 // Test structure
-                QTest::addColumn<DataContainer>("inputData");    // array's data input
+                QTest::addColumn<InputData>("inputData");    // array's data input
-                QTest::addColumn<DataContainer>("otherData");    // array data's input to merge with
+                QTest::addColumn<InputData>("otherData");    // array data's input to merge with
-                QTest::addColumn<bool>("prepend");               // prepend or append merge
+                QTest::addColumn<bool>("prepend");           // prepend or append merge
-                QTest::addColumn<DataContainer>("expectedData"); // expected data after merge
+                QTest::addColumn<Container>("expectedData"); // expected data after merge
                 // Test cases
-                auto inputData
+                auto inputData = flatten(
-                    = DataContainer{{1., 2., 3., 4., 5.}, {11., 12., 13., 14., 15.}, {21., 22., 23., 24., 25.}};
+                    Container{{1., 2., 3., 4., 5.}, {11., 12., 13., 14., 15.}, {21., 22., 23., 24., 25.}});
-                auto vectorContainer = DataContainer{{6., 7., 8.}, {16., 17., 18.}, {26., 27., 28}};
+                auto vectorContainer = flatten(Container{{6., 7., 8.}, {16., 17., 18.}, {26., 27., 28}});
-                auto tensorContainer = DataContainer{{6., 7., 8.},    {16., 17., 18.}, {26., 27., 28},
+                auto tensorContainer = flatten(Container{{6., 7., 8.},
-                                                     {36., 37., 38.}, {46., 47., 48.}, {56., 57., 58}};
+                                                         {16., 17., 18.},
+                                                         {26., 27., 28},
+                                                         {36., 37., 38.},
+                                                         {46., 47., 48.},
+                                                         {56., 57., 58}});
                 QTest::newRow("appendMerge") << inputData << vectorContainer << false
-                                             << DataContainer{{1., 2., 3., 4., 5., 6., 7., 8.},
+                                             << Container{{1., 2., 3., 4., 5., 6., 7., 8.},
-                                                              {11., 12., 13., 14., 15., 16., 17., 18.},
+                                                          {11., 12., 13., 14., 15., 16., 17., 18.},
-                                                              {21., 22., 23., 24., 25., 26., 27., 28}};
+                                                          {21., 22., 23., 24., 25., 26., 27., 28}};
                 QTest::newRow("prependMerge") << inputData << vectorContainer << true
-                                              << DataContainer{{6., 7., 8., 1., 2., 3., 4., 5.},
+                                              << Container{{6., 7., 8., 1., 2., 3., 4., 5.},
-                                                               {16., 17., 18., 11., 12., 13., 14., 15.},
+                                                           {16., 17., 18., 11., 12., 13., 14., 15.},
-                                                               {26., 27., 28, 21., 22., 23., 24., 25.}};
+                                                           {26., 27., 28, 21., 22., 23., 24., 25.}};
-                QTest::newRow("invalidMerge") << inputData << tensorContainer << false << inputData;
+                QTest::newRow("invalidMerge") << inputData << tensorContainer << false
+                                              << Container{{1., 2., 3., 4., 5.},
+                                                           {11., 12., 13., 14., 15.},
+                                                           {21., 22., 23., 24., 25.}};
             }
             void TestTwoDimArrayData::testAdd()
             {
-                QFETCH(DataContainer, inputData);
+                QFETCH(InputData, inputData);
-                QFETCH(DataContainer, otherData);
+                QFETCH(InputData, otherData);
                 QFETCH(bool, prepend);
-                QFETCH(DataContainer, expectedData);
+                QFETCH(Container, expectedData);
-                ArrayData<2> arrayData{inputData};
+                ArrayData<2> arrayData{inputData.first, inputData.second};
-                ArrayData<2> other{otherData};
+                ArrayData<2> other{otherData.first, otherData.second};
                 arrayData.add(other, prepend);
-                for (auto i = 0; i < expectedData.size(); ++i) {
+                verifyArrayData(arrayData, expectedData);
-                    QVERIFY(arrayData.data(i) == expectedData.at(i));
             }
             void TestTwoDimArrayData::testClear_data()
             {
                 // Test structure
-                QTest::addColumn<DataContainer>("inputData"); // array data's input
+                QTest::addColumn<InputData>("inputData"); // array data's input
                 // Test cases
-                QTest::newRow("data1") << DataContainer{
+                QTest::newRow("data1") << flatten(
-                    {1., 2., 3., 4., 5.}, {6., 7., 8., 9., 10.}, {11., 12., 13., 14., 15.}};
+                    Container{{1., 2., 3., 4., 5.}, {6., 7., 8., 9., 10.}, {11., 12., 13., 14., 15.}});
             }
             void TestTwoDimArrayData::testClear()
             {
-                QFETCH(DataContainer, inputData);
+                QFETCH(InputData, inputData);
-                ArrayData<2> arrayData{inputData};
+                ArrayData<2> arrayData{inputData.first, inputData.second};
                 arrayData.clear();
-                for (auto i = 0; i < inputData.size(); ++i) {
+                auto emptyData = Container(inputData.second, QVector<double>{});
-                    QVERIFY(arrayData.data(i) == QVector<double>{});
+                verifyArrayData(arrayData, emptyData);
             }
             void TestTwoDimArrayData::testSize_data()
             {
                 // Test structure
-                QTest::addColumn<QVector<QVector<double> > >("inputData"); // array data's input
+                QTest::addColumn<InputData>("inputData"); // array data's input
-                QTest::addColumn<int>("expectedSize");                     // expected array data size
+                QTest::addColumn<int>("expectedSize");    // expected array data size
                 // Test cases
-                QTest::newRow("data1") << DataContainer{{1., 2., 3., 4., 5.}, {6., 7., 8., 9., 10.}} << 5;
+                QTest::newRow("data1") << flatten(Container{{1., 2., 3., 4., 5.}, {6., 7., 8., 9., 10.}}) << 5;
-                QTest::newRow("data2") << DataContainer{{1., 2., 3., 4., 5.},
+                QTest::newRow("data2") << flatten(Container{{1., 2., 3., 4., 5.},
-                                                        {6., 7., 8., 9., 10.},
+                                                            {6., 7., 8., 9., 10.},
-                                                        {11., 12., 13., 14., 15.}}
+                                                            {11., 12., 13., 14., 15.}})
                                        << 5;
             }
             void TestTwoDimArrayData::testSize()
             {
-                QFETCH(DataContainer, inputData);
+                QFETCH(InputData, inputData);
                 QFETCH(int, expectedSize);
-                ArrayData<2> arrayData{inputData};
+                ArrayData<2> arrayData{inputData.first, inputData.second};
                 QVERIFY(arrayData.size() == expectedSize);
             }
             void TestTwoDimArrayData::testSort_data()
             {
                 // Test structure
-                QTest::addColumn<DataContainer>("inputData");           // array data's input
+                QTest::addColumn<InputData>("inputData");               // array data's input
                 QTest::addColumn<std::vector<int> >("sortPermutation"); // permutation used to sort data
-                QTest::addColumn<DataContainer>("expectedData");        // expected data after sorting
+                QTest::addColumn<Container>("expectedData");            // expected data after sorting
                 // Test cases
                 QTest::newRow("data1")
-                    << DataContainer{{1., 2., 3., 4., 5.}, {6., 7., 8., 9., 10.}, {11., 12., 13., 14., 15.}}
+                    << flatten(
+                           Container{{1., 2., 3., 4., 5.}, {6., 7., 8., 9., 10.}, {11., 12., 13., 14., 15.}})
                     << std::vector<int>{0, 2, 3, 1, 4}
-                    << DataContainer{{1., 3., 4., 2., 5.}, {6., 8., 9., 7., 10.}, {11., 13., 14., 12., 15.}};
+                    << Container{{1., 3., 4., 2., 5.}, {6., 8., 9., 7., 10.}, {11., 13., 14., 12., 15.}};
                 QTest::newRow("data2")
-                    << DataContainer{{1., 2., 3., 4., 5.}, {6., 7., 8., 9., 10.}, {11., 12., 13., 14., 15.}}
+                    << flatten(
+                           Container{{1., 2., 3., 4., 5.}, {6., 7., 8., 9., 10.}, {11., 12., 13., 14., 15.}})
                     << std::vector<int>{2, 4, 3, 0, 1}
-                    << DataContainer{{3., 5., 4., 1., 2.}, {8., 10., 9., 6., 7.}, {13., 15., 14., 11., 12.}};
+                    << Container{{3., 5., 4., 1., 2.}, {8., 10., 9., 6., 7.}, {13., 15., 14., 11., 12.}};
             }
             void TestTwoDimArrayData::testSort()
             {
-                QFETCH(DataContainer, inputData);
+                QFETCH(InputData, inputData);
                 QFETCH(std::vector<int>, sortPermutation);
-                QFETCH(DataContainer, expectedData);
+                QFETCH(Container, expectedData);
-                ArrayData<2> arrayData{inputData};
+                ArrayData<2> arrayData{inputData.first, inputData.second};
                 auto sortedArrayData = arrayData.sort(sortPermutation);
                 QVERIFY(sortedArrayData != nullptr);
-                for (auto i = 0; i < expectedData.size(); ++i) {
+                verifyArrayData(*sortedArrayData, expectedData);
-                    QVERIFY(sortedArrayData->data(i) == expectedData.at(i));
             }
             QTEST_MAIN(TestTwoDimArrayData)
             #include "TestTwoDimArrayData.moc"

plugins/amda/tests/TestAmdaResultParser.cpp +20 -49

             #include "AmdaResultParser.h"
             #include <Data/ScalarSeries.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};
             }
-            /// Compares two vectors that can potentially contain NaN values
-            bool compareVectors(const QVector<double> &v1, const QVector<double> &v2)
-                if (v1.size() != v2.size()) {
-                    return false;
-                auto result = true;
-                auto v2It = v2.cbegin();
-                for (auto v1It = v1.cbegin(), v1End = v1.cend(); v1It != v1End && result; ++v1It, ++v2It) {
-                    auto v1Value = *v1It;
-                    auto v2Value = *v2It;
-                    // If v1 is NaN, v2 has to be NaN too
-                    result = std::isnan(v1Value) ? std::isnan(v2Value) : (v1Value == v2Value);
-                return result;
-            bool compareVectors(const QVector<QVector<double> > &v1, const QVector<QVector<double> > &v2)
-                if (v1.size() != v2.size()) {
-                    return false;
-                auto result = true;
-                for (auto i = 0; i < v1.size() && result; ++i) {
-                    result &= compareVectors(v1.at(i), v2.at(i));
-                return result;
-            QVector<QVector<double> > valuesData(const ArrayData<1> &arrayData)
-                return QVector<QVector<double> >{arrayData.data()};
-            QVector<QVector<double> > valuesData(const ArrayData<2> &arrayData)
-                return arrayData.data();
             QString inputFilePath(const QString &inputFileName)
             {
                 return QFileInfo{TESTS_RESOURCES_PATH, inputFileName}.absoluteFilePath();
             }
             template <typename T>
             struct ExpectedResults {
                 explicit ExpectedResults() = default;
                 explicit ExpectedResults(Unit xAxisUnit, Unit valuesUnit, const QVector<QDateTime> &xAxisData,
                                          QVector<double> valuesData)
                         : ExpectedResults(xAxisUnit, valuesUnit, xAxisData,
                                           QVector<QVector<double> >{std::move(valuesData)})
                 {
                 }
                 /// Ctor with QVector<QDateTime> as x-axis data. Datetimes are converted to doubles
                 explicit ExpectedResults(Unit xAxisUnit, Unit valuesUnit, const QVector<QDateTime> &xAxisData,
                                          QVector<QVector<double> > valuesData)
                         : m_ParsingOK{true},
                           m_XAxisUnit{xAxisUnit},
                           m_ValuesUnit{valuesUnit},
                           m_XAxisData{},
                           m_ValuesData{std::move(valuesData)}
                 {
                     // Converts QVector<QDateTime> to QVector<double>
                     std::transform(xAxisData.cbegin(), xAxisData.cend(), std::back_inserter(m_XAxisData),
                                    [](const auto &dateTime) { return dateTime.toMSecsSinceEpoch() / 1000.; });
                 }
                 /**
                  * 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());
                         QVERIFY(dataSeries != nullptr);
                         // Checks units
                         QVERIFY(dataSeries->xAxisUnit() == m_XAxisUnit);
                         QVERIFY(dataSeries->valuesUnit() == m_ValuesUnit);
-                        // Checks values : as the vectors can potentially contain NaN values, we must use a
+                        auto verifyRange = [dataSeries](const auto &expectedData, const auto &equalFun) {
-                        // custom vector comparison method
+                            QVERIFY(std::equal(dataSeries->cbegin(), dataSeries->cend(), expectedData.cbegin(),
-                        QVERIFY(compareVectors(dataSeries->xAxisData()->data(), m_XAxisData));
+                                               expectedData.cend(),
-                        QVERIFY(compareVectors(valuesData(*dataSeries->valuesData()), m_ValuesData));
+                                               [&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;
+                            });
+                        }
                     }
                     else {
                         QVERIFY(results == nullptr);
                     }
                 }
                 // Parsing was successfully completed
                 bool m_ParsingOK{false};
                 // Expected x-axis unit
                 Unit m_XAxisUnit{};
                 // Expected values unit
                 Unit m_ValuesUnit{};
                 // Expected x-axis data
                 QVector<double> m_XAxisData{};
                 // Expected values data
                 QVector<QVector<double> > m_ValuesData{};
             };
             } // namespace
             Q_DECLARE_METATYPE(ExpectedResults<ScalarSeries>)
             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 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>{
                            Unit{QStringLiteral("nT"), true}, Unit{},
                            QVector<QDateTime>{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)},
                            QVector<double>{-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>{
                            Unit{QStringLiteral("nT"), true}, Unit{},
                            QVector<QDateTime>{dateTime(2013, 9, 23, 9, 0, 30), dateTime(2013, 9, 23, 9, 1, 30),
                                               dateTime(2013, 9, 23, 9, 2, 30)},
                            QVector<double>{std::numeric_limits<double>::quiet_NaN(), -2.71850, -2.52150}};
                 QTest::newRow("Valid file that contains NaN values")
                     << QStringLiteral("NaNValue.txt")
                     << ExpectedResults<ScalarSeries>{
                            Unit{QStringLiteral("nT"), true}, Unit{},
                            QVector<QDateTime>{dateTime(2013, 9, 23, 9, 0, 30), dateTime(2013, 9, 23, 9, 1, 30),
                                               dateTime(2013, 9, 23, 9, 2, 30)},
                            QVector<double>{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>{Unit{QStringLiteral(""), true},
                                                                                Unit{}, QVector<QDateTime>{},
                                                                                QVector<double>{}};
                 QTest::newRow("Wrong unit file")
                     << QStringLiteral("WrongUnit.txt")
                     << ExpectedResults<ScalarSeries>{Unit{QStringLiteral(""), true}, Unit{},
                                                      QVector<QDateTime>{dateTime(2013, 9, 23, 9, 0, 30),
                                                                         dateTime(2013, 9, 23, 9, 1, 30),
                                                                         dateTime(2013, 9, 23, 9, 2, 30)},
                                                      QVector<double>{-2.83950, -2.71850, -2.52150}};
                 QTest::newRow("Wrong results file (date of first line is invalid")
                     << QStringLiteral("WrongDate.txt")
                     << ExpectedResults<ScalarSeries>{
                            Unit{QStringLiteral("nT"), true}, Unit{},
                            QVector<QDateTime>{dateTime(2013, 9, 23, 9, 1, 30), dateTime(2013, 9, 23, 9, 2, 30)},
                            QVector<double>{-2.71850, -2.52150}};
                 QTest::newRow("Wrong results file (too many values for first line")
                     << QStringLiteral("TooManyValues.txt")
                     << ExpectedResults<ScalarSeries>{
                            Unit{QStringLiteral("nT"), true}, Unit{},
                            QVector<QDateTime>{dateTime(2013, 9, 23, 9, 1, 30), dateTime(2013, 9, 23, 9, 2, 30)},
                            QVector<double>{-2.71850, -2.52150}};
                 QTest::newRow("Wrong results file (x of first line is NaN")
                     << QStringLiteral("NaNX.txt")
                     << ExpectedResults<ScalarSeries>{
                            Unit{QStringLiteral("nT"), true}, Unit{},
                            QVector<QDateTime>{dateTime(2013, 9, 23, 9, 1, 30), dateTime(2013, 9, 23, 9, 2, 30)},
                            QVector<double>{-2.71850, -2.52150}};
                 QTest::newRow("Invalid file type (vector)")
                     << QStringLiteral("ValidVector1.txt")
                     << ExpectedResults<ScalarSeries>{Unit{QStringLiteral("nT"), true}, Unit{},
                                                      QVector<QDateTime>{}, QVector<double>{}};
                 // Invalid files
                 QTest::newRow("Invalid file (unexisting file)") << QStringLiteral("UnexistingFile.txt")
                                                                 << ExpectedResults<ScalarSeries>{};
                 QTest::newRow("Invalid file (file not found on server)") << QStringLiteral("FileNotFound.txt")
                                                                          << ExpectedResults<ScalarSeries>{};
             }
             void TestAmdaResultParser::testReadScalarTxt()
             {
                 testRead<ScalarSeries>(AmdaResultParser::ValueType::SCALAR);
             }
             void TestAmdaResultParser::testReadVectorTxt_data()
             {
                 testReadDataStructure<VectorSeries>();
                 // ////////// //
                 // Test cases //
                 // ////////// //
                 // Valid files
                 QTest::newRow("Valid file")
                     << QStringLiteral("ValidVector1.txt")
                     << ExpectedResults<VectorSeries>{
                            Unit{QStringLiteral("nT"), true}, Unit{},
                            QVector<QDateTime>{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)},
                            QVector<QVector<double> >{
                                {-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>{Unit{QStringLiteral("nT"), true}, Unit{},
                                                      QVector<QDateTime>{},
                                                      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