@@ -39,19 +39,58 struct Sort<1> { | |||
|
39 | 39 | } |
|
40 | 40 | }; |
|
41 | 41 | |
|
42 | template <int Dim, bool IsConst> | |
|
43 | class IteratorValue; | |
|
44 | ||
|
45 | template <int Dim, bool IsConst> | |
|
46 | struct IteratorValueBuilder { | |
|
47 | }; | |
|
48 | ||
|
49 | template <int Dim> | |
|
50 | struct IteratorValueBuilder<Dim, true> { | |
|
51 | using DataContainerIterator = DataContainer::const_iterator; | |
|
52 | ||
|
53 | static void swap(IteratorValue<Dim, true> &o1, IteratorValue<Dim, true> &o2) {} | |
|
54 | }; | |
|
55 | ||
|
42 | 56 | template <int Dim> |
|
57 | struct IteratorValueBuilder<Dim, false> { | |
|
58 | using DataContainerIterator = DataContainer::iterator; | |
|
59 | ||
|
60 | static void swap(IteratorValue<Dim, false> &o1, IteratorValue<Dim, false> &o2) | |
|
61 | { | |
|
62 | for (auto i = 0; i < o1.m_NbComponents; ++i) { | |
|
63 | std::iter_swap(o1.m_It + i, o2.m_It + i); | |
|
64 | } | |
|
65 | } | |
|
66 | }; | |
|
67 | ||
|
68 | template <int Dim, bool IsConst> | |
|
43 | 69 | class IteratorValue : public ArrayDataIteratorValue::Impl { |
|
44 | 70 | public: |
|
71 | friend class ArrayData<Dim>; | |
|
72 | friend class IteratorValueBuilder<Dim, IsConst>; | |
|
73 | ||
|
74 | using DataContainerIterator = | |
|
75 | typename IteratorValueBuilder<Dim, IsConst>::DataContainerIterator; | |
|
76 | ||
|
77 | template <bool IC = IsConst, typename = std::enable_if_t<IC == true> > | |
|
45 | 78 | explicit IteratorValue(const DataContainer &container, int nbComponents, bool begin) |
|
46 | 79 | : m_It{begin ? container.cbegin() : container.cend()}, m_NbComponents{nbComponents} |
|
47 | 80 | { |
|
48 | 81 | } |
|
49 | 82 | |
|
83 | template <bool IC = IsConst, typename = std::enable_if_t<IC == false> > | |
|
84 | explicit IteratorValue(DataContainer &container, int nbComponents, bool begin) | |
|
85 | : m_It{begin ? container.begin() : container.end()}, m_NbComponents{nbComponents} | |
|
86 | { | |
|
87 | } | |
|
88 | ||
|
50 | 89 | IteratorValue(const IteratorValue &other) = default; |
|
51 | 90 | |
|
52 | 91 | std::unique_ptr<ArrayDataIteratorValue::Impl> clone() const override |
|
53 | 92 | { |
|
54 | return std::make_unique<IteratorValue<Dim> >(*this); | |
|
93 | return std::make_unique<IteratorValue<Dim, IsConst> >(*this); | |
|
55 | 94 | } |
|
56 | 95 | |
|
57 | 96 | bool equals(const ArrayDataIteratorValue::Impl &other) const override try { |
@@ -97,8 +136,14 public: | |||
|
97 | 136 | return result; |
|
98 | 137 | } |
|
99 | 138 | |
|
139 | void swap(ArrayDataIteratorValue::Impl &other) override | |
|
140 | { | |
|
141 | auto &otherImpl = dynamic_cast<IteratorValue &>(other); | |
|
142 | IteratorValueBuilder<Dim, IsConst>::swap(*this, otherImpl); | |
|
143 | } | |
|
144 | ||
|
100 | 145 | private: |
|
101 |
DataContainer |
|
|
146 | DataContainerIterator m_It; | |
|
102 | 147 | int m_NbComponents; |
|
103 | 148 | }; |
|
104 | 149 | |
@@ -223,18 +268,44 public: | |||
|
223 | 268 | // Iterators // |
|
224 | 269 | // ///////// // |
|
225 | 270 | |
|
271 | ArrayDataIterator begin() | |
|
272 | { | |
|
273 | return ArrayDataIterator{ | |
|
274 | ArrayDataIteratorValue{std::make_unique<arraydata_detail::IteratorValue<Dim, false> >( | |
|
275 | m_Data, m_NbComponents, true)}}; | |
|
276 | } | |
|
277 | ||
|
278 | ArrayDataIterator end() | |
|
279 | { | |
|
280 | return ArrayDataIterator{ | |
|
281 | ArrayDataIteratorValue{std::make_unique<arraydata_detail::IteratorValue<Dim, false> >( | |
|
282 | m_Data, m_NbComponents, false)}}; | |
|
283 | } | |
|
284 | ||
|
226 | 285 | ArrayDataIterator cbegin() const |
|
227 | 286 | { |
|
228 |
return ArrayDataIterator{ |
|
|
229 |
std::make_unique<arraydata_detail::IteratorValue<Dim> >( |
|
|
287 | return ArrayDataIterator{ | |
|
288 | ArrayDataIteratorValue{std::make_unique<arraydata_detail::IteratorValue<Dim, true> >( | |
|
289 | m_Data, m_NbComponents, true)}}; | |
|
230 | 290 | } |
|
291 | ||
|
231 | 292 | ArrayDataIterator cend() const |
|
232 | 293 | { |
|
233 | 294 | return ArrayDataIterator{ |
|
234 | ArrayDataIteratorValue{std::make_unique<arraydata_detail::IteratorValue<Dim> >( | |
|
295 | ArrayDataIteratorValue{std::make_unique<arraydata_detail::IteratorValue<Dim, true> >( | |
|
235 | 296 | m_Data, m_NbComponents, false)}}; |
|
236 | 297 | } |
|
237 | 298 | |
|
299 | void erase(ArrayDataIterator first, ArrayDataIterator last) | |
|
300 | { | |
|
301 | auto firstImpl = dynamic_cast<arraydata_detail::IteratorValue<Dim, false> *>(first->impl()); | |
|
302 | auto lastImpl = dynamic_cast<arraydata_detail::IteratorValue<Dim, false> *>(last->impl()); | |
|
303 | ||
|
304 | if (firstImpl && lastImpl) { | |
|
305 | m_Data.erase(firstImpl->m_It, lastImpl->m_It); | |
|
306 | } | |
|
307 | } | |
|
308 | ||
|
238 | 309 | /// Inserts at the end of the array data the values passed as a parameter. This |
|
239 | 310 | /// method is intended to be used in the context of generating a back insert iterator, or only |
|
240 | 311 | /// if it's ensured that the total size of the vector is consistent with the number of |
@@ -27,11 +27,12 public: | |||
|
27 | 27 | virtual double min() const = 0; |
|
28 | 28 | virtual double max() const = 0; |
|
29 | 29 | virtual QVector<double> values() const = 0; |
|
30 | ||
|
31 | virtual void swap(Impl &other) = 0; | |
|
30 | 32 | }; |
|
31 | 33 | |
|
32 | 34 | explicit ArrayDataIteratorValue(std::unique_ptr<Impl> impl); |
|
33 | 35 | ArrayDataIteratorValue(const ArrayDataIteratorValue &other); |
|
34 | ArrayDataIteratorValue(ArrayDataIteratorValue &&other) = default; | |
|
35 | 36 | ArrayDataIteratorValue &operator=(ArrayDataIteratorValue other); |
|
36 | 37 | |
|
37 | 38 | bool equals(const ArrayDataIteratorValue &other) const; |
@@ -51,6 +52,13 public: | |||
|
51 | 52 | /// Gets all values |
|
52 | 53 | QVector<double> values() const; |
|
53 | 54 | |
|
55 | Impl *impl(); | |
|
56 | ||
|
57 | friend void swap(ArrayDataIteratorValue &lhs, ArrayDataIteratorValue &rhs) | |
|
58 | { | |
|
59 | std::swap(lhs.m_Impl, rhs.m_Impl); | |
|
60 | } | |
|
61 | ||
|
54 | 62 | private: |
|
55 | 63 | std::unique_ptr<Impl> m_Impl; |
|
56 | 64 | }; |
@@ -27,20 +27,31 class DataSeries; | |||
|
27 | 27 | |
|
28 | 28 | namespace dataseries_detail { |
|
29 | 29 | |
|
30 | template <int Dim> | |
|
30 | template <int Dim, bool IsConst> | |
|
31 | 31 | class IteratorValue : public DataSeriesIteratorValue::Impl { |
|
32 | 32 | public: |
|
33 | friend class DataSeries<Dim>; | |
|
34 | ||
|
35 | template <bool IC = IsConst, typename = std::enable_if_t<IC == false> > | |
|
36 | explicit IteratorValue(DataSeries<Dim> &dataSeries, bool begin) | |
|
37 | : m_XIt(begin ? dataSeries.xAxisData()->begin() : dataSeries.xAxisData()->end()), | |
|
38 | m_ValuesIt(begin ? dataSeries.valuesData()->begin() : dataSeries.valuesData()->end()) | |
|
39 | { | |
|
40 | } | |
|
41 | ||
|
42 | template <bool IC = IsConst, typename = std::enable_if_t<IC == true> > | |
|
33 | 43 | explicit IteratorValue(const DataSeries<Dim> &dataSeries, bool begin) |
|
34 | 44 | : m_XIt(begin ? dataSeries.xAxisData()->cbegin() : dataSeries.xAxisData()->cend()), |
|
35 | 45 | m_ValuesIt(begin ? dataSeries.valuesData()->cbegin() |
|
36 | 46 | : dataSeries.valuesData()->cend()) |
|
37 | 47 | { |
|
38 | 48 | } |
|
49 | ||
|
39 | 50 | IteratorValue(const IteratorValue &other) = default; |
|
40 | 51 | |
|
41 | 52 | std::unique_ptr<DataSeriesIteratorValue::Impl> clone() const override |
|
42 | 53 | { |
|
43 | return std::make_unique<IteratorValue<Dim> >(*this); | |
|
54 | return std::make_unique<IteratorValue<Dim, IsConst> >(*this); | |
|
44 | 55 | } |
|
45 | 56 | |
|
46 | 57 | bool equals(const DataSeriesIteratorValue::Impl &other) const override try { |
@@ -70,6 +81,13 public: | |||
|
70 | 81 | double maxValue() const override { return m_ValuesIt->max(); } |
|
71 | 82 | QVector<double> values() const override { return m_ValuesIt->values(); } |
|
72 | 83 | |
|
84 | void swap(DataSeriesIteratorValue::Impl &other) override | |
|
85 | { | |
|
86 | auto &otherImpl = dynamic_cast<IteratorValue &>(other); | |
|
87 | m_XIt->impl()->swap(*otherImpl.m_XIt->impl()); | |
|
88 | m_ValuesIt->impl()->swap(*otherImpl.m_ValuesIt->impl()); | |
|
89 | } | |
|
90 | ||
|
73 | 91 | private: |
|
74 | 92 | ArrayDataIterator m_XIt; |
|
75 | 93 | ArrayDataIterator m_ValuesIt; |
@@ -145,20 +163,59 public: | |||
|
145 | 163 | dataSeries->unlock(); |
|
146 | 164 | } |
|
147 | 165 | |
|
166 | void purge(double min, double max) override | |
|
167 | { | |
|
168 | if (min > max) { | |
|
169 | std::swap(min, max); | |
|
170 | } | |
|
171 | ||
|
172 | lockWrite(); | |
|
173 | ||
|
174 | auto it = std::remove_if( | |
|
175 | begin(), end(), [min, max](const auto &it) { return it.x() < min || it.x() > max; }); | |
|
176 | erase(it, end()); | |
|
177 | ||
|
178 | unlock(); | |
|
179 | } | |
|
180 | ||
|
148 | 181 | // ///////// // |
|
149 | 182 | // Iterators // |
|
150 | 183 | // ///////// // |
|
151 | 184 | |
|
185 | DataSeriesIterator begin() override | |
|
186 | { | |
|
187 | return DataSeriesIterator{DataSeriesIteratorValue{ | |
|
188 | std::make_unique<dataseries_detail::IteratorValue<Dim, false> >(*this, true)}}; | |
|
189 | } | |
|
190 | ||
|
191 | DataSeriesIterator end() override | |
|
192 | { | |
|
193 | return DataSeriesIterator{DataSeriesIteratorValue{ | |
|
194 | std::make_unique<dataseries_detail::IteratorValue<Dim, false> >(*this, false)}}; | |
|
195 | } | |
|
196 | ||
|
152 | 197 | DataSeriesIterator cbegin() const override |
|
153 | 198 | { |
|
154 | 199 | return DataSeriesIterator{DataSeriesIteratorValue{ |
|
155 | std::make_unique<dataseries_detail::IteratorValue<Dim> >(*this, true)}}; | |
|
200 | std::make_unique<dataseries_detail::IteratorValue<Dim, true> >(*this, true)}}; | |
|
156 | 201 | } |
|
157 | 202 | |
|
158 | 203 | DataSeriesIterator cend() const override |
|
159 | 204 | { |
|
160 | 205 | return DataSeriesIterator{DataSeriesIteratorValue{ |
|
161 | std::make_unique<dataseries_detail::IteratorValue<Dim> >(*this, false)}}; | |
|
206 | std::make_unique<dataseries_detail::IteratorValue<Dim, true> >(*this, false)}}; | |
|
207 | } | |
|
208 | ||
|
209 | void erase(DataSeriesIterator first, DataSeriesIterator last) | |
|
210 | { | |
|
211 | auto firstImpl | |
|
212 | = dynamic_cast<dataseries_detail::IteratorValue<Dim, false> *>(first->impl()); | |
|
213 | auto lastImpl = dynamic_cast<dataseries_detail::IteratorValue<Dim, false> *>(last->impl()); | |
|
214 | ||
|
215 | if (firstImpl && lastImpl) { | |
|
216 | m_XAxisData->erase(firstImpl->m_XIt, lastImpl->m_XIt); | |
|
217 | m_ValuesData->erase(firstImpl->m_ValuesIt, lastImpl->m_ValuesIt); | |
|
218 | } | |
|
162 | 219 | } |
|
163 | 220 | |
|
164 | 221 | /// @sa IDataSeries::minXAxisData() |
@@ -29,11 +29,12 public: | |||
|
29 | 29 | virtual double minValue() const = 0; |
|
30 | 30 | virtual double maxValue() const = 0; |
|
31 | 31 | virtual QVector<double> values() const = 0; |
|
32 | ||
|
33 | virtual void swap(Impl &other) = 0; | |
|
32 | 34 | }; |
|
33 | 35 | |
|
34 | 36 | explicit DataSeriesIteratorValue(std::unique_ptr<Impl> impl); |
|
35 | 37 | DataSeriesIteratorValue(const DataSeriesIteratorValue &other); |
|
36 | DataSeriesIteratorValue(DataSeriesIteratorValue &&other) = default; | |
|
37 | 38 | DataSeriesIteratorValue &operator=(DataSeriesIteratorValue other); |
|
38 | 39 | |
|
39 | 40 | bool equals(const DataSeriesIteratorValue &other) const; |
@@ -55,6 +56,13 public: | |||
|
55 | 56 | /// Gets all values data |
|
56 | 57 | QVector<double> values() const; |
|
57 | 58 | |
|
59 | Impl *impl(); | |
|
60 | ||
|
61 | friend void swap(DataSeriesIteratorValue &lhs, DataSeriesIteratorValue &rhs) | |
|
62 | { | |
|
63 | std::swap(lhs.m_Impl, rhs.m_Impl); | |
|
64 | } | |
|
65 | ||
|
58 | 66 | private: |
|
59 | 67 | std::unique_ptr<Impl> m_Impl; |
|
60 | 68 | }; |
@@ -57,6 +57,9 public: | |||
|
57 | 57 | virtual Unit valuesUnit() const = 0; |
|
58 | 58 | |
|
59 | 59 | virtual void merge(IDataSeries *dataSeries) = 0; |
|
60 | /// Removes from data series all entries whose value on the x-axis is not between min and max | |
|
61 | virtual void purge(double min, double max) = 0; | |
|
62 | ||
|
60 | 63 | /// @todo Review the name and signature of this method |
|
61 | 64 | virtual std::shared_ptr<IDataSeries> subDataSeries(const SqpRange &range) = 0; |
|
62 | 65 | |
@@ -69,6 +72,8 public: | |||
|
69 | 72 | |
|
70 | 73 | virtual DataSeriesIterator cbegin() const = 0; |
|
71 | 74 | virtual DataSeriesIterator cend() const = 0; |
|
75 | virtual DataSeriesIterator begin() = 0; | |
|
76 | virtual DataSeriesIterator end() = 0; | |
|
72 | 77 | |
|
73 | 78 | /// @return the iterator to the first entry of the data series whose x-axis data is greater than |
|
74 | 79 | /// or equal to the value passed in parameter, or the end iterator if there is no matching value |
@@ -22,9 +22,7 public: | |||
|
22 | 22 | |
|
23 | 23 | virtual ~SqpIterator() noexcept = default; |
|
24 | 24 | SqpIterator(const SqpIterator &) = default; |
|
25 | SqpIterator(SqpIterator &&) = default; | |
|
26 | SqpIterator &operator=(const SqpIterator &) = default; | |
|
27 | SqpIterator &operator=(SqpIterator &&) = default; | |
|
25 | SqpIterator &operator=(SqpIterator other) { swap(m_CurrentValue, other.m_CurrentValue); } | |
|
28 | 26 | |
|
29 | 27 | SqpIterator &operator++() |
|
30 | 28 | { |
@@ -38,8 +36,10 public: | |||
|
38 | 36 | return *this; |
|
39 | 37 | } |
|
40 | 38 | |
|
41 |
|
|
|
42 |
|
|
|
39 | const T *operator->() const { return &m_CurrentValue; } | |
|
40 | const T &operator*() const { return m_CurrentValue; } | |
|
41 | T *operator->() { return &m_CurrentValue; } | |
|
42 | T &operator*() { return m_CurrentValue; } | |
|
43 | 43 | |
|
44 | 44 | bool operator==(const SqpIterator &other) const |
|
45 | 45 | { |
@@ -57,7 +57,6 public: | |||
|
57 | 57 | |
|
58 | 58 | QVector<SqpRange> provideNotInCacheRangeList(const SqpRange &range) const noexcept; |
|
59 | 59 | QVector<SqpRange> provideInCacheRangeList(const SqpRange &range) const noexcept; |
|
60 | void setDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept; | |
|
61 | 60 | void mergeDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept; |
|
62 | 61 | |
|
63 | 62 | signals: |
@@ -12,7 +12,7 ArrayDataIteratorValue::ArrayDataIteratorValue(const ArrayDataIteratorValue &oth | |||
|
12 | 12 | |
|
13 | 13 | ArrayDataIteratorValue &ArrayDataIteratorValue::operator=(ArrayDataIteratorValue other) |
|
14 | 14 | { |
|
15 |
|
|
|
15 | m_Impl->swap(*other.m_Impl); | |
|
16 | 16 | return *this; |
|
17 | 17 | } |
|
18 | 18 | |
@@ -55,3 +55,8 QVector<double> ArrayDataIteratorValue::values() const | |||
|
55 | 55 | { |
|
56 | 56 | return m_Impl->values(); |
|
57 | 57 | } |
|
58 | ||
|
59 | ArrayDataIteratorValue::Impl *ArrayDataIteratorValue::impl() | |
|
60 | { | |
|
61 | return m_Impl.get(); | |
|
62 | } |
@@ -13,7 +13,7 DataSeriesIteratorValue::DataSeriesIteratorValue(const DataSeriesIteratorValue & | |||
|
13 | 13 | |
|
14 | 14 | DataSeriesIteratorValue &DataSeriesIteratorValue::operator=(DataSeriesIteratorValue other) |
|
15 | 15 | { |
|
16 |
|
|
|
16 | m_Impl->swap(*other.m_Impl); | |
|
17 | 17 | return *this; |
|
18 | 18 | } |
|
19 | 19 | |
@@ -61,3 +61,8 QVector<double> DataSeriesIteratorValue::values() const | |||
|
61 | 61 | { |
|
62 | 62 | return m_Impl->values(); |
|
63 | 63 | } |
|
64 | ||
|
65 | DataSeriesIteratorValue::Impl *DataSeriesIteratorValue::impl() | |
|
66 | { | |
|
67 | return m_Impl.get(); | |
|
68 | } |
@@ -24,6 +24,14 struct Variable::VariablePrivate { | |||
|
24 | 24 | void lockWrite() { m_Lock.lockForWrite(); } |
|
25 | 25 | void unlock() { m_Lock.unlock(); } |
|
26 | 26 | |
|
27 | void purgeDataSeries() | |
|
28 | { | |
|
29 | if (m_DataSeries) { | |
|
30 | m_DataSeries->purge(m_CacheRange.m_TStart, m_CacheRange.m_TEnd); | |
|
31 | } | |
|
32 | updateRealRange(); | |
|
33 | } | |
|
34 | ||
|
27 | 35 | /// Updates real range according to current variable range and data series |
|
28 | 36 | void updateRealRange() |
|
29 | 37 | { |
@@ -94,7 +102,10 SqpRange Variable::cacheRange() const noexcept | |||
|
94 | 102 | void Variable::setCacheRange(const SqpRange &cacheRange) noexcept |
|
95 | 103 | { |
|
96 | 104 | impl->lockWrite(); |
|
97 | impl->m_CacheRange = cacheRange; | |
|
105 | if (cacheRange != impl->m_CacheRange) { | |
|
106 | impl->m_CacheRange = cacheRange; | |
|
107 | impl->purgeDataSeries(); | |
|
108 | } | |
|
98 | 109 | impl->unlock(); |
|
99 | 110 | } |
|
100 | 111 | |
@@ -103,20 +114,6 SqpRange Variable::realRange() const noexcept | |||
|
103 | 114 | return impl->m_RealRange; |
|
104 | 115 | } |
|
105 | 116 | |
|
106 | void Variable::setDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept | |
|
107 | { | |
|
108 | qCDebug(LOG_Variable()) << "TORM Variable::setDataSeries" | |
|
109 | << QThread::currentThread()->objectName(); | |
|
110 | if (!dataSeries) { | |
|
111 | /// @todo ALX : log | |
|
112 | return; | |
|
113 | } | |
|
114 | impl->lockWrite(); | |
|
115 | impl->m_DataSeries = dataSeries->clone(); | |
|
116 | impl->updateRealRange(); | |
|
117 | impl->unlock(); | |
|
118 | } | |
|
119 | ||
|
120 | 117 | void Variable::mergeDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept |
|
121 | 118 | { |
|
122 | 119 | qCDebug(LOG_Variable()) << "TORM Variable::mergeDataSeries" |
@@ -127,7 +124,6 void Variable::mergeDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept | |||
|
127 | 124 | } |
|
128 | 125 | |
|
129 | 126 | // Add or merge the data |
|
130 | // Inits the data series of the variable | |
|
131 | 127 | impl->lockWrite(); |
|
132 | 128 | if (!impl->m_DataSeries) { |
|
133 | 129 | impl->m_DataSeries = dataSeries->clone(); |
@@ -135,13 +131,8 void Variable::mergeDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept | |||
|
135 | 131 | else { |
|
136 | 132 | impl->m_DataSeries->merge(dataSeries.get()); |
|
137 | 133 | } |
|
134 | impl->purgeDataSeries(); | |
|
138 | 135 | impl->unlock(); |
|
139 | ||
|
140 | // sub the data | |
|
141 | auto subData = this->dataSeries()->subDataSeries(this->cacheRange()); | |
|
142 | qCDebug(LOG_Variable()) << "TORM: Variable::mergeDataSeries sub" << subData->range(); | |
|
143 | this->setDataSeries(subData); | |
|
144 | qCDebug(LOG_Variable()) << "TORM: Variable::mergeDataSeries set" << this->dataSeries()->range(); | |
|
145 | 136 | } |
|
146 | 137 | |
|
147 | 138 | std::shared_ptr<IDataSeries> Variable::dataSeries() const noexcept |
@@ -22,6 +22,20 void validateRange(DataSeriesIterator first, DataSeriesIterator last, const QVec | |||
|
22 | 22 | [](const auto &it, const auto &expectedVal) { return it.value() == expectedVal; })); |
|
23 | 23 | } |
|
24 | 24 | |
|
25 | void validateRange(DataSeriesIterator first, DataSeriesIterator last, const QVector<double> &xData, | |
|
26 | const QVector<QVector<double> > &valuesData) | |
|
27 | { | |
|
28 | QVERIFY(std::equal(first, last, xData.cbegin(), xData.cend(), | |
|
29 | [](const auto &it, const auto &expectedX) { return it.x() == expectedX; })); | |
|
30 | for (auto i = 0; i < valuesData.size(); ++i) { | |
|
31 | auto componentData = valuesData.at(i); | |
|
32 | ||
|
33 | QVERIFY(std::equal( | |
|
34 | first, last, componentData.cbegin(), componentData.cend(), | |
|
35 | [i](const auto &it, const auto &expectedVal) { return it.value(i) == expectedVal; })); | |
|
36 | } | |
|
37 | } | |
|
38 | ||
|
25 | 39 | } // namespace |
|
26 | 40 | |
|
27 | 41 | class TestDataSeries : public QObject { |
@@ -75,7 +89,42 private: | |||
|
75 | 89 | } |
|
76 | 90 | } |
|
77 | 91 | |
|
92 | template <typename T> | |
|
93 | void testPurgeStructure() | |
|
94 | { | |
|
95 | // ////////////// // | |
|
96 | // Test structure // | |
|
97 | // ////////////// // | |
|
98 | ||
|
99 | // Data series to purge | |
|
100 | QTest::addColumn<std::shared_ptr<T> >("dataSeries"); | |
|
101 | QTest::addColumn<double>("min"); | |
|
102 | QTest::addColumn<double>("max"); | |
|
103 | ||
|
104 | // Expected values after purge | |
|
105 | QTest::addColumn<QVector<double> >("expectedXAxisData"); | |
|
106 | QTest::addColumn<QVector<QVector<double> > >("expectedValuesData"); | |
|
107 | } | |
|
108 | ||
|
109 | template <typename T> | |
|
110 | void testPurge() | |
|
111 | { | |
|
112 | QFETCH(std::shared_ptr<T>, dataSeries); | |
|
113 | QFETCH(double, min); | |
|
114 | QFETCH(double, max); | |
|
115 | ||
|
116 | dataSeries->purge(min, max); | |
|
117 | ||
|
118 | // Validates results | |
|
119 | QFETCH(QVector<double>, expectedXAxisData); | |
|
120 | QFETCH(QVector<QVector<double> >, expectedValuesData); | |
|
121 | ||
|
122 | validateRange(dataSeries->cbegin(), dataSeries->cend(), expectedXAxisData, | |
|
123 | expectedValuesData); | |
|
124 | } | |
|
125 | ||
|
78 | 126 | private slots: |
|
127 | ||
|
79 | 128 | /// Input test data |
|
80 | 129 | /// @sa testCtor() |
|
81 | 130 | void testCtor_data(); |
@@ -91,6 +140,20 private slots: | |||
|
91 | 140 | void testMerge(); |
|
92 | 141 | |
|
93 | 142 | /// Input test data |
|
143 | /// @sa testPurgeScalar() | |
|
144 | void testPurgeScalar_data(); | |
|
145 | ||
|
146 | /// Tests purge of a scalar series | |
|
147 | void testPurgeScalar(); | |
|
148 | ||
|
149 | /// Input test data | |
|
150 | /// @sa testPurgeVector() | |
|
151 | void testPurgeVector_data(); | |
|
152 | ||
|
153 | /// Tests purge of a vector series | |
|
154 | void testPurgeVector(); | |
|
155 | ||
|
156 | /// Input test data | |
|
94 | 157 | /// @sa testMinXAxisData() |
|
95 | 158 | void testMinXAxisData_data(); |
|
96 | 159 | |
@@ -261,6 +324,62 void TestDataSeries::testMerge() | |||
|
261 | 324 | validateRange(dataSeries->cbegin(), dataSeries->cend(), expectedXAxisData, expectedValuesData); |
|
262 | 325 | } |
|
263 | 326 | |
|
327 | void TestDataSeries::testPurgeScalar_data() | |
|
328 | { | |
|
329 | testPurgeStructure<ScalarSeries>(); | |
|
330 | ||
|
331 | // ////////// // | |
|
332 | // Test cases // | |
|
333 | // ////////// // | |
|
334 | ||
|
335 | QTest::newRow("purgeScalar") << createScalarSeries({1., 2., 3., 4., 5.}, | |
|
336 | {100., 200., 300., 400., 500.}) | |
|
337 | << 2. << 4. << QVector<double>{2., 3., 4.} | |
|
338 | << QVector<QVector<double> >{{200., 300., 400.}}; | |
|
339 | QTest::newRow("purgeScalar2") << createScalarSeries({1., 2., 3., 4., 5.}, | |
|
340 | {100., 200., 300., 400., 500.}) | |
|
341 | << 0. << 2.5 << QVector<double>{1., 2.} | |
|
342 | << QVector<QVector<double> >{{100., 200.}}; | |
|
343 | QTest::newRow("purgeScalar3") << createScalarSeries({1., 2., 3., 4., 5.}, | |
|
344 | {100., 200., 300., 400., 500.}) | |
|
345 | << 3.5 << 7. << QVector<double>{4., 5.} | |
|
346 | << QVector<QVector<double> >{{400., 500.}}; | |
|
347 | QTest::newRow("purgeScalar4") << createScalarSeries({1., 2., 3., 4., 5.}, | |
|
348 | {100., 200., 300., 400., 500.}) | |
|
349 | << 0. << 7. << QVector<double>{1., 2., 3., 4., 5.} | |
|
350 | << QVector<QVector<double> >{{100., 200., 300., 400., 500.}}; | |
|
351 | QTest::newRow("purgeScalar5") << createScalarSeries({1., 2., 3., 4., 5.}, | |
|
352 | {100., 200., 300., 400., 500.}) | |
|
353 | << 5.5 << 7. << QVector<double>{} | |
|
354 | << QVector<QVector<double> >{{}}; | |
|
355 | } | |
|
356 | ||
|
357 | void TestDataSeries::testPurgeScalar() | |
|
358 | { | |
|
359 | testPurge<ScalarSeries>(); | |
|
360 | } | |
|
361 | ||
|
362 | void TestDataSeries::testPurgeVector_data() | |
|
363 | { | |
|
364 | testPurgeStructure<VectorSeries>(); | |
|
365 | ||
|
366 | // ////////// // | |
|
367 | // Test cases // | |
|
368 | // ////////// // | |
|
369 | ||
|
370 | QTest::newRow("purgeVector") << createVectorSeries({1., 2., 3., 4., 5.}, {6., 7., 8., 9., 10.}, | |
|
371 | {11., 12., 13., 14., 15.}, | |
|
372 | {16., 17., 18., 19., 20.}) | |
|
373 | << 2. << 4. << QVector<double>{2., 3., 4.} | |
|
374 | << QVector<QVector<double> >{ | |
|
375 | {7., 8., 9.}, {12., 13., 14.}, {17., 18., 19.}}; | |
|
376 | } | |
|
377 | ||
|
378 | void TestDataSeries::testPurgeVector() | |
|
379 | { | |
|
380 | testPurge<VectorSeries>(); | |
|
381 | } | |
|
382 | ||
|
264 | 383 | void TestDataSeries::testMinXAxisData_data() |
|
265 | 384 | { |
|
266 | 385 | // ////////////// // |
@@ -11,10 +11,14 DataSeriesMergeHelper\.h:\d+:.*IPSIS_S01.* | |||
|
11 | 11 | |
|
12 | 12 | # Ignore false positive relative to a template class |
|
13 | 13 | ArrayData\.h:\d+:.*IPSIS_S04_METHOD.*found: push_back |
|
14 | ArrayData\.h:\d+:.*IPSIS_S04_VARIABLE.*found: (const_iterator) | |
|
14 | 15 | ArrayData\.h:\d+:.*IPSIS_S04_VARIABLE.*found: (D) |
|
16 | ArrayData\.h:\d+:.*IPSIS_S04_VARIABLE.*found: (IC) | |
|
15 | 17 | ArrayData\.h:\d+:.*IPSIS_S04_NAMESPACE.*found: (arraydata_detail) |
|
16 | 18 | ArrayData\.h:\d+:.*IPSIS_S06.*found: (D) |
|
17 | 19 | ArrayData\.h:\d+:.*IPSIS_S06.*found: (Dim) |
|
20 | ArrayData\.h:\d+:.*IPSIS_S06.*found: (IC) | |
|
21 | ArrayData\.h:\d+:.*IPSIS_S06.*found: (IsConst) | |
|
18 | 22 | DataSeries\.h:\d+:.*IPSIS_S04_METHOD.*found: LOG_DataSeries |
|
19 | 23 | DataSeries\.h:\d+:.*IPSIS_S04_METHOD.*found: push_back |
|
20 | 24 | DataSeries\.h:\d+:.*IPSIS_S04_VARIABLE.* |
@@ -22,6 +26,9 DataSeries\.h:\d+:.*IPSIS_S04_NAMESPACE.*found: (dataseries_detail) | |||
|
22 | 26 | DataSeries\.h:\d+:.*IPSIS_S05.* |
|
23 | 27 | DataSeries\.h:\d+:.*IPSIS_S06.*found: (value_type) |
|
24 | 28 | DataSeries\.h:\d+:.*IPSIS_S06.*found: (DataSeriesIteratorValue) |
|
29 | DataSeries\.h:\d+:.*IPSIS_S06.*found: (Dim) | |
|
30 | DataSeries\.h:\d+:.*IPSIS_S06.*found: (IC) | |
|
31 | DataSeries\.h:\d+:.*IPSIS_S06.*found: (IsConst) | |
|
25 | 32 | |
|
26 | 33 | # Ignore false positive relative to iterators |
|
27 | 34 | SqpIterator\.h:\d+:.*IPSIS_S04_VARIABLE.*found: (forward_iterator_tag) |
General Comments 0
You need to be logged in to leave comments.
Login now