HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/SciQLOPCore Commit - r16:5da3a19e8770

Made Variable data update atomic ease thread safety and avoid mixing...

jeandet -

r16:5da3a19e8770

parent child

Context file:

r16:5da3a19e8770

include/Data/DataSeries.h +7 -4

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

include/Data/IDataSeries.h +10 -4

             #ifndef SCIQLOP_IDATASERIES_H
             #define SCIQLOP_IDATASERIES_H
+            #include <memory>
+            #include <QReadWriteLock>
+            #include <QString>
             #include <Common/MetaTypes.h>
             #include <Data/DataSeriesIterator.h>
             #include <Data/DateTimeRange.h>
             #include <Data/Unit.h>
+            #include <Common/deprecate.h>
-            #include <memory>
-            #include <QString>
             template <int Dim>
             class ArrayData;
             /**
              * @brief The IDataSeries aims to declare a data series.
              *
              * A data series is an entity that contains at least :
              * - one dataset representing the x-axis
              * - one dataset representing the values
              *
              * Each dataset is represented by an ArrayData, and is associated with a unit.
              *
              * An ArrayData can be unidimensional or two-dimensional, depending on the implementation of the
              * IDataSeries. The x-axis dataset is always unidimensional.
              *
              * @sa ArrayData
              */
             class IDataSeries {
             public:
                 virtual ~IDataSeries() noexcept = default;
                 /// Returns the x-axis dataset
                 virtual std::shared_ptr<ArrayData<1> > xAxisData() = 0;
                 /// Returns the x-axis dataset (as const)
                 virtual const std::shared_ptr<ArrayData<1> > xAxisData() const = 0;
                 virtual Unit xAxisUnit() const = 0;
                 /// @return the y-axis unit, if axis is defined, default unit otherwise
                 virtual Unit yAxisUnit() const = 0;
                 virtual Unit valuesUnit() const = 0;
                 virtual void merge(IDataSeries *dataSeries) = 0;
                 /// Removes from data series all entries whose value on the x-axis is not between min and max
                 virtual void purge(double min, double max) = 0;
                 /// @todo Review the name and signature of this method
                 virtual std::shared_ptr<IDataSeries> subDataSeries(const DateTimeRange &range) = 0;
                 virtual std::unique_ptr<IDataSeries> clone() const = 0;
                 /// @return the total number of points contained in the data series
                 virtual int nbPoints() const = 0;
                 /// @return the bounds of the y-axis axis (if defined)
                 virtual std::pair<double, double> yBounds() const = 0;
                 // ///////// //
                 // Iterators //
                 // ///////// //
                 virtual DataSeriesIterator cbegin() const = 0;
                 virtual DataSeriesIterator cend() const = 0;
                 virtual DataSeriesIterator begin() = 0;
                 virtual DataSeriesIterator end() = 0;
                 /// @return the iterator to the first entry of the data series whose x-axis data is greater than
                 /// or equal to the value passed in parameter, or the end iterator if there is no matching value
                 virtual DataSeriesIterator minXAxisData(double minXAxisData) const = 0;
                 /// @return the iterator to the last entry of the data series whose x-axis data is less than or
                 /// equal to the value passed in parameter, or the end iterator if there is no matching value
                 virtual DataSeriesIterator maxXAxisData(double maxXAxisData) const = 0;
                 /// @return the iterators pointing to the range of data whose x-axis values are between min and
                 /// max passed in parameters
                 virtual std::pair<DataSeriesIterator, DataSeriesIterator>
                 xAxisRange(double minXAxisData, double maxXAxisData) const = 0;
                 /// @return two iterators pointing to the data that have respectively the min and the max value
                 /// data of a data series' range. The search is performed for a given x-axis range.
                 /// @sa xAxisRange()
                 virtual std::pair<DataSeriesIterator, DataSeriesIterator>
                 valuesBounds(double minXAxisData, double maxXAxisData) const = 0;
                 // /////// //
                 // Mutexes //
                 // /////// //
+                virtual QReadLocker getReadLock() = 0;
+                virtual QWriteLocker getWriteLock() = 0;
+            DEPRECATE(
                 virtual void lockRead() = 0;
                 virtual void lockWrite() = 0;
                 virtual void unlock() = 0;
+                )
             };
             // Required for using shared_ptr in signals/slots
             SCIQLOP_REGISTER_META_TYPE(IDATASERIES_PTR_REGISTRY, std::shared_ptr<IDataSeries>)
             #endif // SCIQLOP_IDATASERIES_H

include/Data/VectorSeries.h +1 -1

             #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 with three vectors (one per component). The vectors must have the same size, otherwise a
                  * 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(std::vector<double> xAxisData, std::vector<double> xValuesData,
                                       std::vector<double> yValuesData, std::vector<double> zValuesData,
                                       const Unit &xAxisUnit, const Unit &valuesUnit);
                 /// Default Ctor
                 explicit VectorSeries(std::vector<double> xAxisData, std::vector<double> valuesData,
                                       const Unit &xAxisUnit, const Unit &valuesUnit);
-                std::unique_ptr<IDataSeries> clone() const;
+                std::unique_ptr<IDataSeries> clone() const override;
                 std::shared_ptr<IDataSeries> subDataSeries(const DateTimeRange &range) override;
             };
             #endif // SCIQLOP_VECTORSERIES_H

include/Variable/Variable.h +10 -5

             #ifndef SCIQLOP_VARIABLE_H
             #define SCIQLOP_VARIABLE_H
-            #include "CoreGlobal.h"
+            #include <QLoggingCategory>
+            #include <QObject>
+            #include <QUuid>
+            #include <QReadWriteLock>
+            #include "CoreGlobal.h"
             #include <Data/DataSeriesIterator.h>
             #include <Data/DataSeriesType.h>
             #include <Data/DateTimeRange.h>
-            #include <QLoggingCategory>
-            #include <QObject>
-            #include <QUuid>
             #include <Common/deprecate.h>
             #include <Common/MetaTypes.h>
             #include <Common/spimpl.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_Variable)
             class IDataSeries;
             class QString;
             /**
              * @brief The Variable class represents a variable in SciQlop.
              */
             class SCIQLOP_CORE_EXPORT Variable : public QObject {
                 Q_OBJECT
             public:
                 explicit Variable(const QString &name, const QVariantHash &metadata = {});
                 /// Copy ctor
                 explicit Variable(const Variable &other);
                 std::shared_ptr<Variable> clone() const;
                 QString name() const noexcept;
                 void setName(const QString &name) noexcept;
                 DateTimeRange range() const noexcept;
                 void setRange(const DateTimeRange &range, bool notify=false) noexcept;
                 DateTimeRange cacheRange() const noexcept;
                 void setCacheRange(const DateTimeRange &cacheRange) noexcept;
                 /// @return the number of points hold by the variable. The number of points is updated each time
                 /// the data series changes
                 unsigned int nbPoints() const noexcept;
                 /// Returns the real range of the variable, i.e. the min and max x-axis values of the data
                 /// series between the range of the variable. The real range is updated each time the variable
                 /// range or the data series changed
                 /// @return the real range, invalid range if the data series is null or empty
                 /// @sa setDataSeries()
                 /// @sa setRange()
                 std::optional<DateTimeRange> realRange() const noexcept;
                 /// @return the data of the variable, nullptr if there is no data
                 std::shared_ptr<IDataSeries> dataSeries() const noexcept;
                 /// @return the type of data that the variable holds
                 DataSeriesType type() const noexcept;
                 QVariantHash metadata() const noexcept;
             DEPRECATE(
                 bool contains(const DateTimeRange &range) const noexcept;
                 bool intersect(const DateTimeRange &range) const noexcept;
                 bool isInside(const DateTimeRange &range) const noexcept;
                 bool cacheContains(const DateTimeRange &range) const noexcept;
                 bool cacheIntersect(const DateTimeRange &range) const noexcept;
                 bool cacheIsInside(const DateTimeRange &range) const noexcept;
             )
             DEPRECATE(
                 QVector<DateTimeRange> provideNotInCacheRangeList(const DateTimeRange &range) const noexcept;
                 QVector<DateTimeRange> provideInCacheRangeList(const DateTimeRange &range) const noexcept;
             )
             DEPRECATE(
                 void mergeDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept;
                 )
-                void mergeDataSeries(IDataSeries* dataSeries, bool notify=false) noexcept;
+                void updateData(const std::vector<IDataSeries*>& dataSeries,
+                                const DateTimeRange& newRange, const DateTimeRange& newCacheRange,
+                                bool notify=true);
             DEPRECATE(
                 static QVector<DateTimeRange> provideNotInCacheRangeList(const DateTimeRange &oldRange,
                                                                     const DateTimeRange &nextRange);
                 static QVector<DateTimeRange> provideInCacheRangeList(const DateTimeRange &oldRange,
                                                                  const DateTimeRange &nextRange);
             )
                 QUuid ID(){return _uuid;}
             signals:
                 void updated();
             DEPRECATE(
                 /// Signal emitted when when the data series of the variable is loaded for the first time
                 void dataInitialized();
                 )
             private:
                 class VariablePrivate;
                 spimpl::unique_impl_ptr<VariablePrivate> impl;
                 QUuid _uuid;
+                QReadWriteLock m_lock;
             };
             // Required for using shared_ptr in signals/slots
             SCIQLOP_REGISTER_META_TYPE(VARIABLE_PTR_REGISTRY, std::shared_ptr<Variable>)
             SCIQLOP_REGISTER_META_TYPE(VARIABLE_PTR_VECTOR_REGISTRY, QVector<std::shared_ptr<Variable> >)
             #endif // SCIQLOP_VARIABLE_H

src/Variable/Variable.cpp +24 -35

             #include <optional>
             #include <QMutex>
             #include <QReadWriteLock>
             #include <QThread>
             #include "Variable/Variable.h"
             #include <Data/IDataSeries.h>
             #include <Data/DateTimeRange.h>
             #include <Common/debug.h>
             Q_LOGGING_CATEGORY(LOG_Variable, "Variable")
-            namespace {
             /**
              * Searches in metadata for a value that can be converted to DataSeriesType
              * @param metadata the metadata where to search
              * @return the value converted to a DataSeriesType if it was found, UNKNOWN type otherwise
              * @sa DataSeriesType
              */
-            DataSeriesType findDataSeriesType(const QVariantHash &metadata)
+            static DataSeriesType findDataSeriesType(const QVariantHash &metadata)
             {
                 auto dataSeriesType = DataSeriesType::UNKNOWN;
                 // Go through the metadata and stop at the first value that could be converted to DataSeriesType
                 for (auto it = metadata.cbegin(), end = metadata.cend();
                      it != end && dataSeriesType == DataSeriesType::UNKNOWN; ++it) {
                     dataSeriesType = DataSeriesTypeUtils::fromString(it.value().toString());
                 }
                 return dataSeriesType;
             }
-            } // namespace
             #define VP_PROPERTY(property,getter,setter,type) \
                 type getter() noexcept\
                 {\
                     QReadLocker lock{&m_Lock};\
                     return property;\
                 }\
                 void setter(const type& getter) noexcept\
                 {\
                     QWriteLocker lock{&m_Lock};\
                     property = getter;\
                 }\
                 type property;\
             #define V_FW_GETTER_SETTER(getter,setter, type)\
                 type Variable::getter() const noexcept \
                 {\
                     return impl->getter();\
                 }\
                 void Variable::setter(const type& getter) noexcept \
                 {\
                     impl->setter(getter);\
                 }\
             struct Variable::VariablePrivate {
                 explicit VariablePrivate(const QString &name, const QVariantHash &metadata)
                         : m_Name{name},
                           m_Range{INVALID_RANGE},
                           m_CacheRange{INVALID_RANGE},
                           m_Metadata{metadata},
                           m_DataSeries{nullptr},
                           m_RealRange{INVALID_RANGE},
                           m_NbPoints{0},
                           m_Type{findDataSeriesType(m_Metadata)}
                 {
                 }
                 VariablePrivate(const VariablePrivate &other)
                         : m_Name{other.m_Name},
                           m_Range{other.m_Range},
                           m_CacheRange{other.m_CacheRange},
                           m_Metadata{other.m_Metadata},
                           m_DataSeries{other.m_DataSeries != nullptr ? other.m_DataSeries->clone() : nullptr},
                           m_RealRange{other.m_RealRange},
                           m_NbPoints{other.m_NbPoints},
                           m_Type{findDataSeriesType(m_Metadata)}
                 {
                 }
                 void lockRead() { m_Lock.lockForRead(); }
                 void lockWrite() { m_Lock.lockForWrite(); }
                 void unlock() { m_Lock.unlock(); }
                 void purgeDataSeries()
                 {
                     if (m_DataSeries) {
                         m_DataSeries->purge(m_CacheRange.m_TStart, m_CacheRange.m_TEnd);
                     }
                     updateRealRange();
                     updateNbPoints();
                 }
+                void mergeDataSeries(const std::vector<IDataSeries*>& dataseries)
+                {
+                    QWriteLocker lock{&m_Lock};
+                    for(auto ds:dataseries)
+                    {
+                        if(m_DataSeries)
+                            m_DataSeries->merge(ds);
+                        else
+                            m_DataSeries = ds->clone();
+                    }
+                }
                 void updateNbPoints() { m_NbPoints = m_DataSeries ? m_DataSeries->nbPoints() : 0; }
                 /// Updates real range according to current variable range and data series
                 void updateRealRange()
                 {
                     if (m_DataSeries) {
-                        m_DataSeries->lockRead();
+                        auto lock = m_DataSeries->getReadLock();
                         auto end = m_DataSeries->cend();
                         auto minXAxisIt = m_DataSeries->minXAxisData(m_Range.m_TStart);
                         auto maxXAxisIt = m_DataSeries->maxXAxisData(m_Range.m_TEnd);
+                        if(minXAxisIt != end && maxXAxisIt != end && minXAxisIt->x() <= maxXAxisIt->x())
-                        m_RealRange
+                            m_RealRange = DateTimeRange{minXAxisIt->x(), maxXAxisIt->x()};
-                            = (minXAxisIt != end && maxXAxisIt != end && minXAxisIt->x() <= maxXAxisIt->x())
+                        else
-                                  ? DateTimeRange{minXAxisIt->x(), maxXAxisIt->x()}
+                            m_RealRange = std::nullopt;
-                                  : INVALID_RANGE;
-                        m_DataSeries->unlock();
                     }
                     else {
                         m_RealRange = std::nullopt;
                     }
                 }
                 VP_PROPERTY(m_Name, name, setName, QString)
                 VP_PROPERTY(m_Range, range, setRange, DateTimeRange)
                 VP_PROPERTY(m_CacheRange, cacheRange, setCacheRange, DateTimeRange)
                 VP_PROPERTY(m_Metadata, metadata, setMetadata, QVariantHash)
                 VP_PROPERTY(m_DataSeries, dataSeries, setDataSeries, std::shared_ptr<IDataSeries>)
                 VP_PROPERTY(m_RealRange, realRange, setRealRange, std::optional<DateTimeRange>)
                 unsigned int m_NbPoints;
                 VP_PROPERTY(m_Type, type, setType, DataSeriesType)
                 QReadWriteLock m_Lock;
             };
             Variable::Variable(const QString &name, const QVariantHash &metadata)
                     : impl{spimpl::make_unique_impl<VariablePrivate>(name, metadata)},
                       _uuid{QUuid::createUuid()}
             {
             }
             Variable::Variable(const Variable &other)
                     : impl{spimpl::make_unique_impl<VariablePrivate>(*other.impl)},
                       _uuid{QUuid::createUuid()} //is a clone but must have a != uuid
             {
             }
             std::shared_ptr<Variable> Variable::clone() const
             {
                 return std::make_shared<Variable>(*this);
             }
             V_FW_GETTER_SETTER(name,setName,QString)
             DateTimeRange Variable::range() const noexcept
             {
                 return impl->range();
             }
             void Variable::setRange(const DateTimeRange &range, bool notify) noexcept
             {
                 impl->setRange(range);
                 impl->updateRealRange();
                 if(notify)
                     emit this->updated();
             }
             V_FW_GETTER_SETTER(cacheRange, setCacheRange, DateTimeRange)
             unsigned int Variable::nbPoints() const noexcept
             {
                 return impl->m_NbPoints;
             }
             std::optional<DateTimeRange> Variable::realRange() const noexcept
             {
                 return impl->realRange();
             }
             void Variable::mergeDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept
             {
                 qCDebug(LOG_Variable()) << "TORM Variable::mergeDataSeries"
                                         << QThread::currentThread()->objectName();
                 if (!dataSeries) {
                     /// @todo ALX : log
                     return;
                 }
                 auto dataInit = false;
                 // Add or merge the data
                 impl->lockWrite();
                 if (!impl->m_DataSeries) {
                     impl->m_DataSeries = dataSeries->clone();
                     dataInit = true;
                 }
                 else {
                     impl->m_DataSeries->merge(dataSeries.get());
                 }
                 impl->purgeDataSeries();
                 impl->unlock();
                 if (dataInit) {
                     emit dataInitialized();
                 }
             }
-            void Variable::mergeDataSeries(IDataSeries *dataSeries, bool notify) noexcept
+            void Variable::updateData(const std::vector<IDataSeries *> &dataSeries, const DateTimeRange &newRange, const DateTimeRange &newCacheRange, bool notify)
             {
-                if (dataSeries==nullptr) {
-                    SCIQLOP_ERROR(Variable,"Given IDataSeries is nullptr");
+                    QWriteLocker lock{&m_lock};
-                    return;
+                    impl->mergeDataSeries(dataSeries);
+                    impl->setRange(newRange);
+                    impl->setCacheRange(newCacheRange);
-                auto dataInit = false;
-                // @TODO move impl to Pimpl this is what it stands for...
-                // Add or merge the data
-                impl->lockWrite();
-                if (!impl->m_DataSeries) {
-                    //@TODO find a better way
-                    impl->m_DataSeries = dataSeries->clone();
-                    dataInit = true;
-                    delete dataSeries;
-                else {
-                    impl->m_DataSeries->merge(dataSeries);
                     impl->purgeDataSeries();
-                impl->unlock();
-                if (dataInit) {
-                    emit dataInitialized();
                 }
                 if(notify)
-                    emit this->updated();
+                    emit updated();
             }
             std::shared_ptr<IDataSeries> Variable::dataSeries() const noexcept
             {
                 return impl->dataSeries();
             }
             DataSeriesType Variable::type() const noexcept
             {
                 return impl->type();
             }
             QVariantHash Variable::metadata() const noexcept
             {
                 impl->lockRead();
                 auto metadata = impl->m_Metadata;
                 impl->unlock();
                 return metadata;
             }
             bool Variable::contains(const DateTimeRange &range) const noexcept
             {
                 impl->lockRead();
                 auto res = impl->m_Range.contains(range);
                 impl->unlock();
                 return res;
             }
             bool Variable::intersect(const DateTimeRange &range) const noexcept
             {
                 impl->lockRead();
                 auto res = impl->m_Range.intersect(range);
                 impl->unlock();
                 return res;
             }
             bool Variable::isInside(const DateTimeRange &range) const noexcept
             {
                 impl->lockRead();
                 auto res = range.contains(DateTimeRange{impl->m_Range.m_TStart, impl->m_Range.m_TEnd});
                 impl->unlock();
                 return res;
             }
             bool Variable::cacheContains(const DateTimeRange &range) const noexcept
             {
                 impl->lockRead();
                 auto res = impl->m_CacheRange.contains(range);
                 impl->unlock();
                 return res;
             }
             bool Variable::cacheIntersect(const DateTimeRange &range) const noexcept
             {
                 impl->lockRead();
                 auto res = impl->m_CacheRange.intersect(range);
                 impl->unlock();
                 return res;
             }
             bool Variable::cacheIsInside(const DateTimeRange &range) const noexcept
             {
                 impl->lockRead();
                 auto res = range.contains(DateTimeRange{impl->m_CacheRange.m_TStart, impl->m_CacheRange.m_TEnd});
                 impl->unlock();
                 return res;
             }
             QVector<DateTimeRange> Variable::provideNotInCacheRangeList(const DateTimeRange &range) const noexcept
             {
                 // This code assume that cach in contigue. Can return 0, 1 or 2 SqpRange
                 auto notInCache = QVector<DateTimeRange>{};
                 if (impl->m_CacheRange != INVALID_RANGE) {
                     if (!this->cacheContains(range)) {
                         if (range.m_TEnd <= impl->m_CacheRange.m_TStart
                             || range.m_TStart >= impl->m_CacheRange.m_TEnd) {
                             notInCache << range;
                         }
                         else if (range.m_TStart < impl->m_CacheRange.m_TStart
                                  && range.m_TEnd <= impl->m_CacheRange.m_TEnd) {
                             notInCache << DateTimeRange{range.m_TStart, impl->m_CacheRange.m_TStart};
                         }
                         else if (range.m_TStart < impl->m_CacheRange.m_TStart
                                  && range.m_TEnd > impl->m_CacheRange.m_TEnd) {
                             notInCache << DateTimeRange{range.m_TStart, impl->m_CacheRange.m_TStart}
                                        << DateTimeRange{impl->m_CacheRange.m_TEnd, range.m_TEnd};
                         }
                         else if (range.m_TStart < impl->m_CacheRange.m_TEnd) {
                             notInCache << DateTimeRange{impl->m_CacheRange.m_TEnd, range.m_TEnd};
                         }
                         else {
                             qCCritical(LOG_Variable()) << tr("Detection of unknown case.")
                                                        << QThread::currentThread();
                         }
                     }
                 }
                 else {
                     notInCache << range;
                 }
                 return notInCache;
             }
             QVector<DateTimeRange> Variable::provideInCacheRangeList(const DateTimeRange &range) const noexcept
             {
                 // This code assume that cach in contigue. Can return 0 or 1 SqpRange
                 auto inCache = QVector<DateTimeRange>{};
                 if (impl->m_CacheRange != INVALID_RANGE) {
                     if (this->cacheIntersect(range)) {
                         if (range.m_TStart <= impl->m_CacheRange.m_TStart
                             && range.m_TEnd >= impl->m_CacheRange.m_TStart
                             && range.m_TEnd < impl->m_CacheRange.m_TEnd) {
                             inCache << DateTimeRange{impl->m_CacheRange.m_TStart, range.m_TEnd};
                         }
                         else if (range.m_TStart >= impl->m_CacheRange.m_TStart
                                  && range.m_TEnd <= impl->m_CacheRange.m_TEnd) {
                             inCache << range;
                         }
                         else if (range.m_TStart > impl->m_CacheRange.m_TStart
                                  && range.m_TEnd > impl->m_CacheRange.m_TEnd) {
                             inCache << DateTimeRange{range.m_TStart, impl->m_CacheRange.m_TEnd};
                         }
                         else if (range.m_TStart <= impl->m_CacheRange.m_TStart
                                  && range.m_TEnd >= impl->m_CacheRange.m_TEnd) {
                             inCache << impl->m_CacheRange;
                         }
                         else {
                             qCCritical(LOG_Variable()) << tr("Detection of unknown case.")
                                                        << QThread::currentThread();
                         }
                     }
                 }
                 return inCache;
             }
             QVector<DateTimeRange> Variable::provideNotInCacheRangeList(const DateTimeRange &oldRange,
                                                                    const DateTimeRange &nextRange)
             {
                 // This code assume that cach in contigue. Can return 0, 1 or 2 SqpRange
                 auto notInCache = QVector<DateTimeRange>{};
                 if (oldRange != INVALID_RANGE) {
                     if (!oldRange.contains(nextRange)) {
                         if (nextRange.m_TEnd <= oldRange.m_TStart || nextRange.m_TStart >= oldRange.m_TEnd) {
                             notInCache << nextRange;
                         }
                         else if (nextRange.m_TStart < oldRange.m_TStart
                                  && nextRange.m_TEnd <= oldRange.m_TEnd) {
                             notInCache << DateTimeRange{nextRange.m_TStart, oldRange.m_TStart};
                         }
                         else if (nextRange.m_TStart < oldRange.m_TStart && nextRange.m_TEnd > oldRange.m_TEnd) {
                             notInCache << DateTimeRange{nextRange.m_TStart, oldRange.m_TStart}
                                        << DateTimeRange{oldRange.m_TEnd, nextRange.m_TEnd};
                         }
                         else if (nextRange.m_TStart < oldRange.m_TEnd) {
                             notInCache << DateTimeRange{oldRange.m_TEnd, nextRange.m_TEnd};
                         }
                         else {
                             qCCritical(LOG_Variable()) << tr("Detection of unknown case.")
                                                        << QThread::currentThread();
                         }
                     }
                 }
                 else {
                     notInCache << nextRange;
                 }
                 return notInCache;
             }
             QVector<DateTimeRange> Variable::provideInCacheRangeList(const DateTimeRange &oldRange,
                                                                 const DateTimeRange &nextRange)
             {
                 // This code assume that cach is contigue. Can return 0 or 1 SqpRange
                 auto inCache = QVector<DateTimeRange>{};
                 if (oldRange != INVALID_RANGE) {
                     if (oldRange.intersect(nextRange)) {
                         if (nextRange.m_TStart <= oldRange.m_TStart && nextRange.m_TEnd >= oldRange.m_TStart
                             && nextRange.m_TEnd < oldRange.m_TEnd) {
                             inCache << DateTimeRange{oldRange.m_TStart, nextRange.m_TEnd};
                         }
                         else if (nextRange.m_TStart >= oldRange.m_TStart
                                  && nextRange.m_TEnd <= oldRange.m_TEnd) {
                             inCache << nextRange;
                         }
                         else if (nextRange.m_TStart > oldRange.m_TStart && nextRange.m_TEnd > oldRange.m_TEnd) {
                             inCache << DateTimeRange{nextRange.m_TStart, oldRange.m_TEnd};
                         }
                         else if (nextRange.m_TStart <= oldRange.m_TStart
                                  && nextRange.m_TEnd >= oldRange.m_TEnd) {
                             inCache << oldRange;
                         }
                         else {
                             qCCritical(LOG_Variable()) << tr("Detection of unknown case.")
                                                        << QThread::currentThread();
                         }
                     }
                 }
                 return inCache;
             }

src/Variable/VariableController2.cpp +3 -4

             #include "Variable/VariableController2.h"
             #include "Variable/VariableSynchronizationGroup2.h"
             #include <Common/containers.h>
             #include <Common/debug.h>
             #include <Data/DataProviderParameters.h>
             #include <Data/DateTimeRangeHelper.h>
             #include <Variable/VariableCacheStrategyFactory.h>
             class VariableController2::VariableController2Private
             {
                 QMap<QUuid,std::shared_ptr<Variable>> _variables;
                 QMap<QUuid,std::shared_ptr<IDataProvider>> _providers;
                 QMap<QUuid,std::shared_ptr<VariableSynchronizationGroup2>> _synchronizationGroups;
                 std::unique_ptr<VariableCacheStrategy> _cacheStrategy;
                 bool p_contains(const std::shared_ptr<Variable>& variable)
                 {
                     return _providers.contains(variable->ID());
                 }
                 bool v_contains(const std::shared_ptr<Variable>& variable)
                 {
                     return SciQLop::containers::contains(this->_variables, variable);
                 }
                 bool sg_contains(const std::shared_ptr<Variable>& variable)
                 {
                     return _synchronizationGroups.contains(variable->ID());
                 }
                 void _changeRange(const std::shared_ptr<Variable>& var, DateTimeRange r)
                 {
                     auto provider = _providers[var->ID()];
                     DateTimeRange newCacheRange;
                     std::vector<DateTimeRange> missingRanges;
                     if(DateTimeRangeHelper::hasnan(var->cacheRange()))
                     {
                         newCacheRange = _cacheStrategy->computeRange(r,r);
                         missingRanges = {newCacheRange};
                     }
                     else
                     {
                         newCacheRange = _cacheStrategy->computeRange(var->cacheRange(),r);
                         missingRanges = newCacheRange - var->cacheRange();
                     }
+                    std::vector<IDataSeries*> data;
                     for(auto range:missingRanges)
                     {
-                        auto data = provider->getData(DataProviderParameters{{range},var->metadata()});
+                        data.push_back(provider->getData(DataProviderParameters{{range},var->metadata()}));
-                        var->mergeDataSeries(data);
                     }
-                    var->setCacheRange(newCacheRange);
+                    var->updateData(data,r,newCacheRange,true);
-                    var->setRange(r);
                 }
             public:
                 VariableController2Private(QObject* parent=Q_NULLPTR)
                     :_cacheStrategy(VariableCacheStrategyFactory::createCacheStrategy(CacheStrategy::SingleThreshold))
                 {
                     Q_UNUSED(parent);
                 }
                 ~VariableController2Private() = default;
                 std::shared_ptr<Variable> createVariable(const QString &name, const QVariantHash &metadata, std::shared_ptr<IDataProvider> provider)
                 {
                     auto newVar = std::make_shared<Variable>(name,metadata);
                     this->_variables[newVar->ID()] = newVar;
                     this->_providers[newVar->ID()] = std::move(provider);
                     this->_synchronizationGroups[newVar->ID()] = std::make_shared<VariableSynchronizationGroup2>(newVar->ID());
                     return newVar;
                 }
                 void deleteVariable(const std::shared_ptr<Variable>& variable)
                 {
                     /*
                      * Removing twice a var is ok but a var without provider has to be a hard error
                      * this means we got the var controller in an inconsistent state
                      */
                     if(v_contains(variable))
                         this->_variables.remove(variable->ID());
                     if(p_contains(variable))
                         this->_providers.remove(variable->ID());
                     else
                         SCIQLOP_ERROR(VariableController2Private, "No provider found for given variable");
                 }
                 void asyncChangeRange(const std::shared_ptr<Variable>& variable, const DateTimeRange& r)
                 {
                 }
                 void changeRange(const std::shared_ptr<Variable>& variable, DateTimeRange r)
                 {
                     if(p_contains(variable))
                     {
                         if(!DateTimeRangeHelper::hasnan(r))
                         {
                             auto group = _synchronizationGroups[variable->ID()];
                             if(auto transformation = DateTimeRangeHelper::computeTransformation(variable->range(),r);
                                     transformation.has_value())
                             {
                                 for(auto varId:group->variables())
                                 {
                                     auto var = _variables[varId];
                                     auto newRange = var->range().transform(transformation.value());
                                     _changeRange(var,newRange);
                                 }
                             }
                             else // force new range to all variables -> may be weird if more than one var in the group
                                 // @TODO ensure that there is no side effects
                             {
                                 for(auto varId:group->variables())
                                 {
                                     auto var = _variables[varId];
                                     _changeRange(var,r);
                                 }
                             }
                         }
                         else
                         {
                             SCIQLOP_ERROR(VariableController2Private, "Invalid range containing NaN");
                         }
                     }
                     else
                     {
                         SCIQLOP_ERROR(VariableController2Private, "No provider found for given variable");
                     }
                 }
                 void synchronize(const std::shared_ptr<Variable>& var, const std::shared_ptr<Variable>& with)
                 {
                     if(v_contains(var) && v_contains(with))
                     {
                         if(sg_contains(var) && sg_contains(with))
                         {
                             auto dest_group = this->_synchronizationGroups[with->ID()];
                             this->_synchronizationGroups[var->ID()] = dest_group;
                             dest_group->addVariable(var->ID());
                         }
                         else
                         {
                             SCIQLOP_ERROR(VariableController2Private, "At least one of the given variables isn't in a sync group");
                         }
                     }
                     else
                     {
                         SCIQLOP_ERROR(VariableController2Private, "At least one of the given variables is not found");
                     }
                 }
                 const std::set<std::shared_ptr<Variable>> variables()
                 {
                     std::set<std::shared_ptr<Variable>> vars;
                     for(const auto  &var:_variables)
                     {
                         vars.insert(var);
                     }
                     return  vars;
                 }
             };
             VariableController2::VariableController2()
                 :impl{spimpl::make_unique_impl<VariableController2Private>()}
             {}
             std::shared_ptr<Variable> VariableController2::createVariable(const QString &name, const QVariantHash &metadata, const std::shared_ptr<IDataProvider>& provider, const DateTimeRange &range)
             {
                 auto var =  impl->createVariable(name, metadata, provider);
                 emit variableAdded(var);
                 if(!DateTimeRangeHelper::hasnan(range))
                     impl->changeRange(var,range);
                 else
                     SCIQLOP_ERROR(VariableController2, "Creating a variable with default constructed DateTimeRange is an error");
                 return var;
             }
             void VariableController2::deleteVariable(const std::shared_ptr<Variable>& variable)
             {
                 impl->deleteVariable(variable);
                 emit variableDeleted(variable);
             }
             void VariableController2::changeRange(const std::shared_ptr<Variable>& variable, const DateTimeRange& r)
             {
                 impl->changeRange(variable, r);
             }
             void VariableController2::asyncChangeRange(const std::shared_ptr<Variable> &variable, const DateTimeRange &r)
             {
                 impl->asyncChangeRange(variable, r);
             }
             const std::set<std::shared_ptr<Variable> > VariableController2::variables()
             {
                 return impl->variables();
             }
             void VariableController2::synchronize(const std::shared_ptr<Variable> &var, const std::shared_ptr<Variable> &with)
             {
                 impl->synchronize(var, with);
             }

tests/Variable/TestVariableController.cpp +1 -1

             #include <QObject>
             #include <QtTest>
             #include <Data/IDataProvider.h>
             #include <Time/TimeController.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <memory>
             namespace {
             /// Provider used for the tests
             class TestProvider : public IDataProvider {
-                std::shared_ptr<IDataProvider> clone() const { return std::make_shared<TestProvider>(); }
+                std::shared_ptr<IDataProvider> clone() const override { return std::make_shared<TestProvider>(); }
                 void requestDataLoading(QUuid acqIdentifier, const DataProviderParameters &parameters) override
                 {
                     // Does nothing
                 }
                 void requestDataAborting(QUuid acqIdentifier) override
                 {
                     // Does nothing
                 }
             };
             /// Generates a time controller for the tests
             std::unique_ptr<TimeController> defaultTimeController()
             {
                 auto timeController = std::make_unique<TimeController>();
                 QDateTime start{QDate{2017, 01, 01}, QTime{0, 0, 0, 0}};
                 QDateTime end{QDate{2017, 01, 02}, QTime{0, 0, 0, 0}};
                 timeController->setDateTimeRange(
                     DateTimeRange{DateUtils::secondsSinceEpoch(start), DateUtils::secondsSinceEpoch(end)});
                 return timeController;
             }
             } // namespace
             class TestVariableController : public QObject {
                 Q_OBJECT
             private slots:
                 void initTestCase() { QSKIP("Skip it"); }
                 /// Test removes variable from controller
                 void testDeleteVariable();
             };
             void TestVariableController::testDeleteVariable()
             {
                 // Creates variable controller
                 auto timeController = defaultTimeController();
                 VariableController variableController{};
                 //variableController.setTimeController(timeController.get());
                 // Creates a variable from the controller
                 auto variable
                     = variableController.createVariable("variable", {}, std::make_shared<TestProvider>(), timeController->dateTime());
                 qDebug() << QString::number(variable.use_count());
                 // Removes the variable from the controller
                 variableController.deleteVariable(variable);
                 // Verifies that the variable has been deleted: this implies that the number of shared_ptr
                 // objects referring to the variable is 1 (the reference of this scope). Otherwise, the deletion
                 // is considered invalid since the variable is still referenced in the controller
                 QVERIFY(variable.use_count() == 1);
             }
             QTEST_MAIN(TestVariableController)
             #include "TestVariableController.moc"

tests/Variable/TestVariableSync.cpp +1 -1

             #include <QObject>
             #include <QtTest>
             #include <memory>
             #include <Data/DataProviderParameters.h>
             #include <Data/IDataProvider.h>
             #include <Data/ScalarSeries.h>
             #include <Time/TimeController.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <Variable/VariableModel.h>
             namespace {
             /// Delay after each operation on the variable before validating it (in ms)
             const auto OPERATION_DELAY = 100;
             /**
              * Generates values according to a range. The value generated for a time t is the number of seconds
              * of difference between t and a reference value (which is midnight -> 00:00:00)
              *
              * Example: For a range between 00:00:10 and 00:00:20, the generated values are
              * {10,11,12,13,14,15,16,17,18,19,20}
              */
             std::vector<double> values(const DateTimeRange &range)
             {
                 QTime referenceTime{0, 0};
                 std::vector<double> result{};
                 for (auto i = range.m_TStart; i <= range.m_TEnd; ++i) {
                     auto time = DateUtils::dateTime(i).time();
                     result.push_back(referenceTime.secsTo(time));
                 }
                 return result;
             }
             void validateRanges(VariableController &variableController,
                                 const std::map<int, DateTimeRange> &expectedRanges)
             {
                 for (const auto &expectedRangeEntry : expectedRanges) {
                     auto variableIndex = expectedRangeEntry.first;
                     auto expectedRange = expectedRangeEntry.second;
                     // Gets the variable in the controller
                     auto variable = variableController.variableModel()->variable(variableIndex);
                     // Compares variable's range to the expected range
                     QVERIFY(variable != nullptr);
                     auto range = variable->range();
                     qInfo() << "range vs expected range" << range << expectedRange;
                     QCOMPARE(range, expectedRange);
                     // Compares variable's data with values expected for its range
                     auto dataSeries = variable->dataSeries();
                     QVERIFY(dataSeries != nullptr);
                     auto it = dataSeries->xAxisRange(range.m_TStart, range.m_TEnd);
                     auto expectedValues = values(range);
                     qInfo() << std::distance(it.first, it.second) << expectedValues.size();
                     QVERIFY(std::equal(it.first, it.second, expectedValues.cbegin(), expectedValues.cend(),
                                        [](const auto &dataSeriesIt, const auto &expectedValue) {
                                            return dataSeriesIt.value() == expectedValue;
                                        }));
                 }
             }
             /// Provider used for the tests
             class TestProvider : public IDataProvider {
-                std::shared_ptr<IDataProvider> clone() const { return std::make_shared<TestProvider>(); }
+                std::shared_ptr<IDataProvider> clone() const override { return std::make_shared<TestProvider>(); }
                 void requestDataLoading(QUuid acqIdentifier, const DataProviderParameters &parameters) override
                 {
                     const auto &ranges = parameters.m_Times;
                     for (const auto &range : ranges) {
                         // Generates data series
                         auto valuesData = values(range);
                         std::vector<double> xAxisData{};
                         for (auto i = range.m_TStart; i <= range.m_TEnd; ++i) {
                             xAxisData.push_back(i);
                         }
                         auto dataSeries = std::make_shared<ScalarSeries>(
                             std::move(xAxisData), std::move(valuesData), Unit{"t", true}, Unit{});
                         emit dataProvided(acqIdentifier, dataSeries, range);
                     }
                 }
                 void requestDataAborting(QUuid acqIdentifier) override
                 {
                     // Does nothing
                 }
             };
             /**
              * Interface representing an operation performed on a variable controller.
              * This interface is used in tests to apply a set of operations and check the status of the
              * controller after each operation
              */
             struct IOperation {
                 virtual ~IOperation() = default;
                 /// Executes the operation on the variable controller
                 virtual void exec(VariableController &variableController) const = 0;
             };
             /**
              *Variable creation operation in the controller
              */
             struct Create : public IOperation {
                 explicit Create(int index, const DateTimeRange &range) : m_Index{index},m_range(range) {}
                 void exec(VariableController &variableController) const override
                 {
                     auto variable = variableController.createVariable(QString::number(m_Index), {},
                                                                       std::make_unique<TestProvider>(), m_range);
                 }
                 int m_Index; ///< The index of the variable to create in the controller
                 DateTimeRange m_range;
             };
             /**
              * Variable move/shift operation in the controller
              */
             struct Move : public IOperation {
                 explicit Move(int index, const DateTimeRange &newRange, bool shift = false, int delayMS = 10)
                         : m_Index{index}, m_NewRange{newRange}, m_Shift{shift}, m_DelayMs{delayMS}
                 {
                 }
                 void exec(VariableController &variableController) const override
                 {
                     if (auto variable = variableController.variableModel()->variable(m_Index)) {
                         variableController.onRequestDataLoading({variable}, m_NewRange, !m_Shift);
                         QTest::qWait(m_DelayMs);
                     }
                 }
                 int m_Index;         ///< The index of the variable to move
                 DateTimeRange m_NewRange; ///< The new range of the variable
                 bool m_Shift;        ///< Performs a shift (
                 int m_DelayMs;       ///< wait the delay after running the request (
             };
             /**
              * Variable synchronization/desynchronization operation in the controller
              */
             struct Synchronize : public IOperation {
                 explicit Synchronize(int index, QUuid syncId, bool synchronize = true)
                         : m_Index{index}, m_SyncId{syncId}, m_Synchronize{synchronize}
                 {
                 }
                 void exec(VariableController &variableController) const override
                 {
                     if (auto variable = variableController.variableModel()->variable(m_Index)) {
                         if (m_Synchronize) {
                             variableController.onAddSynchronized(variable, m_SyncId);
                         }
                         else {
                             variableController.desynchronize(variable, m_SyncId);
                         }
                     }
                 }
                 int m_Index;        ///< The index of the variable to sync/desync
                 QUuid m_SyncId;     ///< The synchronization group of the variable
                 bool m_Synchronize; ///< Performs sync or desync operation
             };
             /**
              * Test Iteration
              *
              * A test iteration includes an operation to be performed, and a set of expected ranges after each
              * operation. Each range is tested after the operation to ensure that:
              * - the range of the variable is the expected range
              * - the data of the variable are those generated for the expected range
              */
             struct Iteration {
                 std::shared_ptr<IOperation> m_Operation;  ///< Operation to perform
                 std::map<int, DateTimeRange> m_ExpectedRanges; ///< Expected ranges (by variable index)
             };
             using Iterations = std::vector<Iteration>;
             } // namespace
             Q_DECLARE_METATYPE(Iterations)
             class TestVariableSync : public QObject {
                 Q_OBJECT
             private slots:
                 void initTestCase() { QSKIP("Temporarily disables TestVariableSync"); }
                 /// Input data for @sa testSync()
                 void testSync_data();
                 /// Input data for @sa testSyncOneVar()
                 void testSyncOneVar_data();
                 /// Tests synchronization between variables through several operations
                 void testSync();
                 /// Tests synchronization between variables through several operations
                 void testSyncOneVar();
             };
             namespace {
             void testSyncCase1()
             {
                 // Id used to synchronize variables in the controller
                 auto syncId = QUuid::createUuid();
                 /// Generates a range according to a start time and a end time (the date is the same)
                 auto range = [](const QTime &startTime, const QTime &endTime) {
                     return DateTimeRange{DateUtils::secondsSinceEpoch(QDateTime{{2017, 1, 1}, startTime, Qt::UTC}),
                                     DateUtils::secondsSinceEpoch(QDateTime{{2017, 1, 1}, endTime, Qt::UTC})};
                 };
                 auto initialRange = range({12, 0}, {13, 0});
                 Iterations iterations{};
                 // Creates variables var0, var1 and var2
                 iterations.push_back({std::make_shared<Create>(0, initialRange), {{0, initialRange}}});
                 iterations.push_back({std::make_shared<Create>(1, initialRange), {{0, initialRange}, {1, initialRange}}});
                 iterations.push_back(
                     {std::make_shared<Create>(2, initialRange), {{0, initialRange}, {1, initialRange}, {2, initialRange}}});
                 // Adds variables into the sync group (ranges don't need to be tested here)
                 iterations.push_back({std::make_shared<Synchronize>(0, syncId)});
                 iterations.push_back({std::make_shared<Synchronize>(1, syncId)});
                 iterations.push_back({std::make_shared<Synchronize>(2, syncId)});
                 // Moves var0: ranges of var0, var1 and var2 change
                 auto newRange = range({12, 30}, {13, 30});
                 iterations.push_back(
                     {std::make_shared<Move>(0, newRange), {{0, newRange}, {1, newRange}, {2, newRange}}});
                 // Moves var1: ranges of var0, var1 and var2 change
                 newRange = range({13, 0}, {14, 0});
                 iterations.push_back(
                     {std::make_shared<Move>(0, newRange), {{0, newRange}, {1, newRange}, {2, newRange}}});
                 // Moves var2: ranges of var0, var1 and var2 change
                 newRange = range({13, 30}, {14, 30});
                 iterations.push_back(
                     {std::make_shared<Move>(0, newRange), {{0, newRange}, {1, newRange}, {2, newRange}}});
                 // Desyncs var2 and moves var0:
                 // - ranges of var0 and var1 change
                 // - range of var2 doesn't change anymore
                 auto var2Range = newRange;
                 newRange = range({13, 45}, {14, 45});
                 iterations.push_back({std::make_shared<Synchronize>(2, syncId, false)});
                 iterations.push_back(
                     {std::make_shared<Move>(0, newRange), {{0, newRange}, {1, newRange}, {2, var2Range}}});
                 // Shifts var0: although var1 is synchronized with var0, its range doesn't change
                 auto var1Range = newRange;
                 newRange = range({14, 45}, {15, 45});
                 iterations.push_back({std::make_shared<Move>(0, newRange, true),
                                       {{0, newRange}, {1, var1Range}, {2, var2Range}}});
                 // Moves var0 through several operations:
                 // - range of var0 changes
                 // - range or var1 changes according to the previous shift (one hour)
                 auto moveVar0 = [&iterations](const auto &var0NewRange, const auto &var1ExpectedRange) {
                     iterations.push_back(
                         {std::make_shared<Move>(0, var0NewRange), {{0, var0NewRange}, {1, var1ExpectedRange}}});
                 };
                 // Pan left
                 moveVar0(range({14, 30}, {15, 30}), range({13, 30}, {14, 30}));
                 // Pan right
                 moveVar0(range({16, 0}, {17, 0}), range({15, 0}, {16, 0}));
                 // Zoom in
                 moveVar0(range({16, 30}, {16, 45}), range({15, 30}, {15, 45}));
                 // Zoom out
                 moveVar0(range({16, 15}, {17, 0}), range({15, 15}, {16, 0}));
                 QTest::newRow("sync1") << syncId << initialRange << std::move(iterations) << 200;
             }
             void testSyncCase2()
             {
                 // Id used to synchronize variables in the controller
                 auto syncId = QUuid::createUuid();
                 /// Generates a range according to a start time and a end time (the date is the same)
                 auto dateTime = [](int year, int month, int day, int hours, int minutes, int seconds) {
                     return DateUtils::secondsSinceEpoch(
                         QDateTime{{year, month, day}, QTime{hours, minutes, seconds}, Qt::UTC});
                 };
                 auto initialRange = DateTimeRange{dateTime(2017, 1, 1, 12, 0, 0), dateTime(2017, 1, 1, 13, 0, 0)};
                 Iterations iterations{};
                 // Creates variables var0 and var1
                 iterations.push_back({std::make_shared<Create>(0, initialRange), {{0, initialRange}}});
                 iterations.push_back({std::make_shared<Create>(1, initialRange), {{0, initialRange}, {1, initialRange}}});
                 // Adds variables into the sync group (ranges don't need to be tested here)
                 iterations.push_back({std::make_shared<Synchronize>(0, syncId)});
                 iterations.push_back({std::make_shared<Synchronize>(1, syncId)});
                 // Moves var0 through several operations:
                 // - range of var0 changes
                 // - range or var1 changes according to the previous shift (one hour)
                 auto moveVar0 = [&iterations](const auto &var0NewRange) {
                     iterations.push_back(
                         {std::make_shared<Move>(0, var0NewRange), {{0, var0NewRange}, {1, var0NewRange}}});
                 };
                 moveVar0(DateTimeRange{dateTime(2017, 1, 1, 12, 0, 0), dateTime(2017, 1, 1, 13, 0, 0)});
                 moveVar0(DateTimeRange{dateTime(2017, 1, 1, 14, 0, 0), dateTime(2017, 1, 1, 15, 0, 0)});
                 moveVar0(DateTimeRange{dateTime(2017, 1, 1, 8, 0, 0), dateTime(2017, 1, 1, 9, 0, 0)});
                 //    moveVar0(SqpRange{dateTime(2017, 1, 1, 7, 30, 0), dateTime(2017, 1, 1, 9, 30, 0)});
                 moveVar0(DateTimeRange{dateTime(2017, 1, 1, 2, 0, 0), dateTime(2017, 1, 1, 4, 0, 0)});
                 moveVar0(DateTimeRange{dateTime(2017, 1, 1, 6, 0, 0), dateTime(2017, 1, 1, 8, 0, 0)});
                 moveVar0(DateTimeRange{dateTime(2017, 1, 10, 6, 0, 0), dateTime(2017, 1, 15, 8, 0, 0)});
                 moveVar0(DateTimeRange{dateTime(2017, 1, 17, 6, 0, 0), dateTime(2017, 1, 25, 8, 0, 0)});
                 moveVar0(DateTimeRange{dateTime(2017, 1, 2, 6, 0, 0), dateTime(2017, 1, 8, 8, 0, 0)});
                 moveVar0(DateTimeRange{dateTime(2017, 4, 10, 6, 0, 0), dateTime(2017, 6, 15, 8, 0, 0)});
                 moveVar0(DateTimeRange{dateTime(2017, 1, 17, 6, 0, 0), dateTime(2017, 2, 25, 8, 0, 0)});
                 moveVar0(DateTimeRange{dateTime(2017, 7, 2, 6, 0, 0), dateTime(2017, 10, 8, 8, 0, 0)});
                 moveVar0(DateTimeRange{dateTime(2017, 4, 10, 6, 0, 0), dateTime(2017, 6, 15, 8, 0, 0)});
                 moveVar0(DateTimeRange{dateTime(2017, 1, 17, 6, 0, 0), dateTime(2017, 2, 25, 8, 0, 0)});
                 moveVar0(DateTimeRange{dateTime(2017, 7, 2, 6, 0, 0), dateTime(2017, 10, 8, 8, 0, 0)});
                 moveVar0(DateTimeRange{dateTime(2017, 4, 10, 6, 0, 0), dateTime(2017, 6, 15, 8, 0, 0)});
                 moveVar0(DateTimeRange{dateTime(2017, 1, 17, 6, 0, 0), dateTime(2017, 2, 25, 8, 0, 0)});
                 moveVar0(DateTimeRange{dateTime(2017, 7, 2, 6, 0, 0), dateTime(2017, 10, 8, 8, 0, 0)});
                 moveVar0(DateTimeRange{dateTime(2017, 4, 10, 6, 0, 0), dateTime(2017, 6, 15, 8, 0, 0)});
                 moveVar0(DateTimeRange{dateTime(2017, 1, 17, 6, 0, 0), dateTime(2017, 2, 25, 8, 0, 0)});
                 moveVar0(DateTimeRange{dateTime(2017, 7, 2, 6, 0, 0), dateTime(2017, 10, 8, 8, 0, 0)});
                 QTest::newRow("sync2") << syncId << initialRange << iterations << 4000;
                 //    QTest::newRow("sync3") << syncId << initialRange << iterations << 5000;
             }
             void testSyncOnVarCase1()
             {
                 // Id used to synchronize variables in the controller
                 auto syncId = QUuid::createUuid();
                 /// Generates a range according to a start time and a end time (the date is the same)
                 auto range = [](const QTime &startTime, const QTime &endTime) {
                     return DateTimeRange{DateUtils::secondsSinceEpoch(QDateTime{{2017, 1, 1}, startTime, Qt::UTC}),
                                     DateUtils::secondsSinceEpoch(QDateTime{{2017, 1, 1}, endTime, Qt::UTC})};
                 };
                 auto initialRange = range({12, 0}, {13, 0});
                 Iterations creations{};
                 // Creates variables var0, var1 and var2
                 creations.push_back({std::make_shared<Create>(0, initialRange), {{0, initialRange}}});
                 Iterations synchronization{};
                 // Adds variables into the sync group (ranges don't need to be tested here)
                 synchronization.push_back({std::make_shared<Synchronize>(0, syncId)});
                 Iterations iterations{};
                 //    Moves var0 through several operations
                 auto moveOp = [&iterations](const auto &requestedRange, const auto &expectedRange, auto delay) {
                     iterations.push_back(
                         {std::make_shared<Move>(0, requestedRange, true, delay), {{0, expectedRange}}});
                 };
                 // we assume here 300 ms is enough to finsh a operation
                 int delayToFinish = 300;
                 // jump to right, let's the operation time to finish
                 moveOp(range({14, 30}, {15, 30}), range({14, 30}, {15, 30}), delayToFinish);
                 // pan to right, let's the operation time to finish
                 moveOp(range({14, 45}, {15, 45}), range({14, 45}, {15, 45}), delayToFinish);
                 // jump to left, let's the operation time to finish
                 moveOp(range({03, 30}, {04, 30}), range({03, 30}, {04, 30}), delayToFinish);
                 // Pan to left, let's the operation time to finish
                 moveOp(range({03, 10}, {04, 10}), range({03, 10}, {04, 10}), delayToFinish);
                 // Zoom in, let's the operation time to finish
                 moveOp(range({03, 30}, {04, 00}), range({03, 30}, {04, 00}), delayToFinish);
                 // Zoom out left, let's the operation time to finish
                 moveOp(range({01, 10}, {18, 10}), range({01, 10}, {18, 10}), delayToFinish);
                 // Go back to initial range
                 moveOp(initialRange, initialRange, delayToFinish);
                 // jump to right, let's the operation time to finish
                 //    moveOp(range({14, 30}, {15, 30}), initialRange, delayToFinish);
                 // Zoom out left, let's the operation time to finish
                 moveOp(range({01, 10}, {18, 10}), initialRange, delayToFinish);
                 // Go back to initial range
                 moveOp(initialRange, initialRange, 300);
                 QTest::newRow("syncOnVarCase1") << syncId << initialRange << std::move(creations)
                                                 << std::move(iterations);
             }
             }
             void TestVariableSync::testSync_data()
             {
                 // ////////////// //
                 // Test structure //
                 // ////////////// //
                 QTest::addColumn<QUuid>("syncId");
                 QTest::addColumn<DateTimeRange>("initialRange");
                 QTest::addColumn<Iterations>("iterations");
                 QTest::addColumn<int>("operationDelay");
                 // ////////// //
                 // Test cases //
                 // ////////// //
                 testSyncCase1();
                 testSyncCase2();
             }
             void TestVariableSync::testSyncOneVar_data()
             {
                 // ////////////// //
                 // Test structure //
                 // ////////////// //
                 QTest::addColumn<QUuid>("syncId");
                 QTest::addColumn<DateTimeRange>("initialRange");
                 QTest::addColumn<Iterations>("creations");
                 QTest::addColumn<Iterations>("iterations");
                 // ////////// //
                 // Test cases //
                 // ////////// //
                 testSyncOnVarCase1();
             }
             void TestVariableSync::testSync()
             {
                 // Inits controllers
                 TimeController timeController{};
                 VariableController variableController{};
                 //variableController.setTimeController(&timeController);
                 QFETCH(QUuid, syncId);
                 QFETCH(DateTimeRange, initialRange);
                 timeController.setDateTimeRange(initialRange);
                 // Synchronization group used
                 variableController.onAddSynchronizationGroupId(syncId);
                 // For each iteration:
                 // - execute operation
                 // - compare the variables' state to the expected states
                 QFETCH(Iterations, iterations);
                 QFETCH(int, operationDelay);
                 for (const auto &iteration : iterations) {
                     iteration.m_Operation->exec(variableController);
                     QTest::qWait(operationDelay);
                     validateRanges(variableController, iteration.m_ExpectedRanges);
                 }
             }
             void TestVariableSync::testSyncOneVar()
             {
                 // Inits controllers
                 TimeController timeController{};
                 VariableController variableController{};
                 //variableController.setTimeController(&timeController);
                 QFETCH(QUuid, syncId);
                 QFETCH(DateTimeRange, initialRange);
                 timeController.setDateTimeRange(initialRange);
                 // Synchronization group used
                 variableController.onAddSynchronizationGroupId(syncId);
                 // For each iteration:
                 // - execute operation
                 // - compare the variables' state to the expected states
                 QFETCH(Iterations, iterations);
                 QFETCH(Iterations, creations);
                 for (const auto &creation : creations) {
                     creation.m_Operation->exec(variableController);
                     QTest::qWait(300);
                 }
                 for (const auto &iteration : iterations) {
                     iteration.m_Operation->exec(variableController);
                 }
                 if (!iterations.empty()) {
                     validateRanges(variableController, iterations.back().m_ExpectedRanges);
                 }
             }
             QTEST_MAIN(TestVariableSync)
             #include "TestVariableSync.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