GIT_REPOSITORIES/LPP/Users/mperrinel/SCIQLOP-Initialisation Commit - r227:e94f13bbc48f

Correction for pull request

perrinel -

r227:e94f13bbc48f

parent child

Context file:

r227:e94f13bbc48f

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

             #ifndef SCIQLOP_DATASERIES_H
             #define SCIQLOP_DATASERIES_H
             #include <Data/ArrayData.h>
             #include <Data/IDataSeries.h>
+            #include <QLoggingCategory>
             #include <memory>
+            Q_DECLARE_LOGGING_CATEGORY(LOG_DataSeries)
+            Q_LOGGING_CATEGORY(LOG_DataSeries, "DataSeries")
             /**
              * @brief The DataSeries class is the base (abstract) implementation of IDataSeries.
              *
              * It proposes to set a dimension for the values data
              *
              * @tparam Dim The dimension of the values data
              *
              */
             template <int Dim>
             class DataSeries : public IDataSeries {
             public:
                 /// @sa IDataSeries::xAxisData()
                 std::shared_ptr<ArrayData<1> > xAxisData() override { return m_XAxisData; }
                 /// @sa IDataSeries::xAxisUnit()
                 Unit xAxisUnit() const override { return m_XAxisUnit; }
                 /// @return the values dataset
                 std::shared_ptr<ArrayData<Dim> > valuesData() const { return m_ValuesData; }
                 /// @sa IDataSeries::valuesUnit()
                 Unit valuesUnit() const override { return m_ValuesUnit; }
                 /// @sa IDataSeries::merge()
                 void merge(IDataSeries *dataSeries) override
                 {
                     if (auto dimDataSeries = dynamic_cast<DataSeries<Dim> *>(dataSeries)) {
                         m_XAxisData->merge(dimDataSeries->xAxisData().get());
                         m_ValuesData->merge(dimDataSeries->valuesData().get());
                     }
+                    else {
+                        qCWarning(LOG_DataSeries())
+                            << QObject::tr("Dection of a type of IDataSeries we cannot merge with !");
+                    }
                 }
             protected:
                 /// Protected ctor (DataSeries is abstract)
                 explicit DataSeries(std::shared_ptr<ArrayData<1> > xAxisData, const Unit &xAxisUnit,
                                     std::shared_ptr<ArrayData<Dim> > valuesData, const Unit &valuesUnit)
                         : m_XAxisData{xAxisData},
                           m_XAxisUnit{xAxisUnit},
                           m_ValuesData{valuesData},
                           m_ValuesUnit{valuesUnit}
                 {
                 }
             private:
                 std::shared_ptr<ArrayData<1> > m_XAxisData;
                 Unit m_XAxisUnit;
                 std::shared_ptr<ArrayData<Dim> > m_ValuesData;
                 Unit m_ValuesUnit;
             };
             #endif // SCIQLOP_DATASERIES_H

core/include/Data/IDataProvider.h +1 -1

             #ifndef SCIQLOP_IDATAPROVIDER_H
             #define SCIQLOP_IDATAPROVIDER_H
             #include <memory>
             #include <QObject>
             #include <Data/SqpDateTime.h>
             class DataProviderParameters;
             class IDataSeries;
             /**
              * @brief The IDataProvider interface aims to declare a data provider.
              *
              * A data provider is an entity that generates data and returns it according to various parameters
              * (time interval, product to retrieve the data, etc.)
              *
              * @sa IDataSeries
              */
             class IDataProvider : public QObject {
                 Q_OBJECT
             public:
                 virtual ~IDataProvider() noexcept = default;
                 virtual std::unique_ptr<IDataSeries>
                 retrieveData(const DataProviderParameters &parameters) const = 0;
                 virtual void requestDataLoading(const QVector<SqpDateTime> &dateTimeList) = 0;
             signals:
-                void dataProvided(std::shared_ptr<IDataSeries> dateSerie, SqpDateTime dateTime);
+                void dataProvided(std::shared_ptr<IDataSeries> dateSerie, const SqpDateTime &dateTime);
             };
             // Required for using shared_ptr in signals/slots
             Q_DECLARE_METATYPE(std::shared_ptr<IDataProvider>)
             #endif // SCIQLOP_IDATAPROVIDER_H

core/include/Variable/Variable.h +1 -1

             #ifndef SCIQLOP_VARIABLE_H
             #define SCIQLOP_VARIABLE_H
             #include <Data/SqpDateTime.h>
             #include <QLoggingCategory>
             #include <QObject>
             #include <Common/spimpl.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_Variable)
             class IDataSeries;
             class QString;
             /**
              * @brief The Variable class represents a variable in SciQlop.
              */
             class Variable : public QObject {
                 Q_OBJECT
             public:
                 explicit Variable(const QString &name, const QString &unit, const QString &mission,
                                   const SqpDateTime &dateTime);
                 QString name() const noexcept;
                 QString mission() const noexcept;
                 QString unit() const noexcept;
                 SqpDateTime dateTime() const noexcept;
                 /// @return the data of the variable, nullptr if there is no data
                 IDataSeries *dataSeries() const noexcept;
-                bool contains(SqpDateTime dateTime);
+                bool contains(const SqpDateTime &dateTime);
                 void setDataSeries(std::unique_ptr<IDataSeries> dataSeries) noexcept;
             public slots:
                 void onAddDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept;
             signals:
                 void dataCacheUpdated();
             private:
                 class VariablePrivate;
                 spimpl::unique_impl_ptr<VariablePrivate> impl;
             };
             // Required for using shared_ptr in signals/slots
             Q_DECLARE_METATYPE(std::shared_ptr<Variable>)
             #endif // SCIQLOP_VARIABLE_H

core/include/Variable/VariableCacheController.h +1 -1

             #ifndef SCIQLOP_VARIABLECACHECONTROLLER_H
             #define SCIQLOP_VARIABLECACHECONTROLLER_H
             #include <QObject>
             #include <Data/SqpDateTime.h>
             #include <Common/spimpl.h>
             class Variable;
-            /// This class aims to store in the cash all of the dateTime already requested to the variable.
+            /// This class aims to store in the cache all of the dateTime already requested to the variable.
             class VariableCacheController : public QObject {
                 Q_OBJECT
             public:
                 explicit VariableCacheController(QObject *parent = 0);
                 void addDateTime(std::shared_ptr<Variable> variable, const SqpDateTime &dateTime);
                 /// Return all of the SqpDataTime part of the dateTime whose are not in the cache
                 QVector<SqpDateTime> provideNotInCacheDateTimeList(std::shared_ptr<Variable> variable,
                                                                    const SqpDateTime &dateTime);
                 QVector<SqpDateTime> dateCacheList(std::shared_ptr<Variable> variable) const noexcept;
             private:
                 class VariableCacheControllerPrivate;
                 spimpl::unique_impl_ptr<VariableCacheControllerPrivate> impl;
             };
             #endif // SCIQLOP_VARIABLECACHECONTROLLER_H

core/src/Variable/Variable.cpp +1 -1

             #include "Variable/Variable.h"
             #include <Data/IDataSeries.h>
             #include <Data/SqpDateTime.h>
             Q_LOGGING_CATEGORY(LOG_Variable, "Variable")
             struct Variable::VariablePrivate {
                 explicit VariablePrivate(const QString &name, const QString &unit, const QString &mission,
                                          const SqpDateTime &dateTime)
                         : m_Name{name},
                           m_Unit{unit},
                           m_Mission{mission},
                           m_DateTime{dateTime},
                           m_DataSeries{nullptr}
                 {
                 }
                 QString m_Name;
                 QString m_Unit;
                 QString m_Mission;
                 SqpDateTime m_DateTime; // The dateTime available in the view and loaded. not the cache.
                 std::unique_ptr<IDataSeries> m_DataSeries;
             };
             Variable::Variable(const QString &name, const QString &unit, const QString &mission,
                                const SqpDateTime &dateTime)
                     : impl{spimpl::make_unique_impl<VariablePrivate>(name, unit, mission, dateTime)}
             {
             }
             QString Variable::name() const noexcept
             {
                 return impl->m_Name;
             }
             QString Variable::mission() const noexcept
             {
                 return impl->m_Mission;
             }
             QString Variable::unit() const noexcept
             {
                 return impl->m_Unit;
             }
             SqpDateTime Variable::dateTime() const noexcept
             {
                 return impl->m_DateTime;
             }
             void Variable::setDataSeries(std::unique_ptr<IDataSeries> dataSeries) noexcept
             {
                 if (!impl->m_DataSeries) {
                     impl->m_DataSeries = std::move(dataSeries);
                 }
             }
             void Variable::onAddDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept
             {
                 if (impl->m_DataSeries) {
                     impl->m_DataSeries->merge(dataSeries.get());
                     emit dataCacheUpdated();
                 }
             }
             IDataSeries *Variable::dataSeries() const noexcept
             {
                 return impl->m_DataSeries.get();
             }
-            bool Variable::contains(SqpDateTime dateTime)
+            bool Variable::contains(const SqpDateTime &dateTime)
             {
                 if (!impl->m_DateTime.contains(dateTime)) {
                     // The current variable dateTime isn't enough to display the dateTime requested.
                     // We have to update it to the new dateTime requested.
                     // the correspondant new data to display will be given by the cache if possible and the
                     // provider if necessary.
                     qCInfo(LOG_Variable()) << "NEW DATE NEEDED";
                     impl->m_DateTime = dateTime;
                     return false;
                 }
                 return true;
             }

core/src/Variable/VariableCacheController.cpp +3 -6

             #include "Variable/VariableCacheController.h"
             #include "Variable/Variable.h"
             #include <unordered_map>
             struct VariableCacheController::VariableCacheControllerPrivate {
                 std::unordered_map<std::shared_ptr<Variable>, QVector<SqpDateTime> >
                     m_VariableToSqpDateTimeListMap;
                 void addInCacheDataByEnd(const SqpDateTime &dateTime, QVector<SqpDateTime> &dateTimeList,
                                          QVector<SqpDateTime> &notInCache, int cacheIndex,
                                          double currentTStart);
                 void addInCacheDataByStart(const SqpDateTime &dateTime, QVector<SqpDateTime> &dateTimeList,
                                            QVector<SqpDateTime> &notInCache, int cacheIndex,
                                            double currentTStart);
                 void addDateTimeRecurse(const SqpDateTime &dateTime, QVector<SqpDateTime> &dateTimeList,
                                         int cacheIndex);
             };
             VariableCacheController::VariableCacheController(QObject *parent)
-                    : QObject(parent), impl{spimpl::make_unique_impl<VariableCacheControllerPrivate>()}
+                    : QObject{parent}, impl{spimpl::make_unique_impl<VariableCacheControllerPrivate>()}
             {
             }
             void VariableCacheController::addDateTime(std::shared_ptr<Variable> variable,
                                                       const SqpDateTime &dateTime)
             {
                 if (variable) {
                     auto findVariableIte = impl->m_VariableToSqpDateTimeListMap.find(variable);
                     if (findVariableIte == impl->m_VariableToSqpDateTimeListMap.end()) {
                         impl->m_VariableToSqpDateTimeListMap[variable].push_back(dateTime);
                     }
                     else {
                         // addDateTime modify the list<SqpDateTime> of the variable in a way to ensure
                         // that the list is ordered : l(0) < l(1). We assume also a < b
                         // (with a & b of type SqpDateTime) means ts(b) > te(a)
                         // The algorithm will try the merge of two interval:
                         // - dateTime will be compare with the first interval of the list:
                         //   A: if it is inferior, it will be inserted and it's finished.
                         //   B: if it is in intersection, it will be merge then the merged one
                         //      will be compared to the next interval. The old one is remove from the list
                         //   C: if it is superior, we do the same with the next interval of the list
-                        int cacheIndex = 0;
                         impl->addDateTimeRecurse(dateTime, impl->m_VariableToSqpDateTimeListMap.at(variable),
-                                                 cacheIndex);
+);
                     }
                 }
             }
             QVector<SqpDateTime>
             VariableCacheController::provideNotInCacheDateTimeList(std::shared_ptr<Variable> variable,
                                                                    const SqpDateTime &dateTime)
             {
                 auto notInCache = QVector<SqpDateTime>{};
                 // This algorithm is recursif. The idea is to localise the start time then the end time in the
                 // list of date time request associated to the variable
                 // We assume that the list is ordered in a way that l(0) < l(1). We assume also a < b
                 // (with a & b of type SqpDateTime) means ts(b) > te(a)
                 impl->addInCacheDataByStart(dateTime, impl->m_VariableToSqpDateTimeListMap.at(variable),
                                             notInCache, 0, dateTime.m_TStart);
                 return notInCache;
             }
             QVector<SqpDateTime>
             VariableCacheController::dateCacheList(std::shared_ptr<Variable> variable) const noexcept
             {
                 return impl->m_VariableToSqpDateTimeListMap.at(variable);
             }
             void VariableCacheController::VariableCacheControllerPrivate::addDateTimeRecurse(
                 const SqpDateTime &dateTime, QVector<SqpDateTime> &dateTimeList, int cacheIndex)
             {
                 const auto dateTimeListSize = dateTimeList.count();
                 if (cacheIndex >= dateTimeListSize) {
                     dateTimeList.push_back(dateTime);
                     // there is no anymore interval to compore, we can just push_back it
                     return;
                 }
                 auto currentDateTime = dateTimeList[cacheIndex];
                 if (dateTime.m_TEnd < currentDateTime.m_TStart) {
                     // The compared one is < to current one compared, we can insert it
                     dateTimeList.insert(cacheIndex, dateTime);
                 }
                 else if (dateTime.m_TStart > currentDateTime.m_TEnd) {
                     // The compared one is > to current one compared  we can comparet if to the next one
                     addDateTimeRecurse(dateTime, dateTimeList, ++cacheIndex);
                 }
                 else {
                     // Merge cases: we need to merge the two interval, remove the old one from the list then
                     // rerun the algo from this index with the merged interval
                     auto mTStart = std::min(dateTime.m_TStart, currentDateTime.m_TStart);
                     auto mTEnd = std::max(dateTime.m_TEnd, currentDateTime.m_TEnd);
                     auto mergeDateTime = SqpDateTime{mTStart, mTEnd};
                     dateTimeList.remove(cacheIndex);
                     addDateTimeRecurse(mergeDateTime, dateTimeList, cacheIndex);
                 }
             }
             void VariableCacheController::VariableCacheControllerPrivate::addInCacheDataByEnd(
                 const SqpDateTime &dateTime, QVector<SqpDateTime> &dateTimeList,
                 QVector<SqpDateTime> &notInCache, int cacheIndex, double currentTStart)
             {
                 const auto dateTimeListSize = dateTimeList.count();
                 if (cacheIndex >= dateTimeListSize) {
                     if (currentTStart < dateTime.m_TEnd) {
                         // te localised after all other interval: The last interval is [currentTsart, te]
                         notInCache.push_back(SqpDateTime{currentTStart, dateTime.m_TEnd});
                     }
                     return;
                 }
                 auto currentDateTimeJ = dateTimeList[cacheIndex];
                 if (dateTime.m_TEnd <= currentDateTimeJ.m_TStart) {
                     // te localised between to interval: The last interval is [currentTsart, te]
                     notInCache.push_back(SqpDateTime{currentTStart, dateTime.m_TEnd});
                 }
                 else {
                     notInCache.push_back(SqpDateTime{currentTStart, currentDateTimeJ.m_TStart});
                     if (dateTime.m_TEnd > currentDateTimeJ.m_TEnd) {
                         // te not localised before the current interval: we need to look at the next interval
                         addInCacheDataByEnd(dateTime, dateTimeList, notInCache, ++cacheIndex,
                                             currentDateTimeJ.m_TEnd);
                     }
                 }
             }
             void VariableCacheController::VariableCacheControllerPrivate::addInCacheDataByStart(
                 const SqpDateTime &dateTime, QVector<SqpDateTime> &dateTimeList,
                 QVector<SqpDateTime> &notInCache, int cacheIndex, double currentTStart)
             {
                 const auto dateTimeListSize = dateTimeList.count();
                 if (cacheIndex >= dateTimeListSize) {
                     // ts localised after all other interval: The last interval is [ts, te]
                     notInCache.push_back(SqpDateTime{currentTStart, dateTime.m_TEnd});
                     return;
                 }
                 auto currentDateTimeI = dateTimeList[cacheIndex];
-                auto cacheIndexJ = cacheIndex;
                 if (currentTStart < currentDateTimeI.m_TStart) {
                     // ts localised between to interval: let's localized te
-                    addInCacheDataByEnd(dateTime, dateTimeList, notInCache, cacheIndexJ, currentTStart);
+                    addInCacheDataByEnd(dateTime, dateTimeList, notInCache, cacheIndex, currentTStart);
                 }
                 else if (dateTime.m_TStart < currentDateTimeI.m_TEnd) {
                     // ts not localised before the current interval: we need to look at the next interval
                     // We can assume now current tstart is the last interval tend, because data between them are
                     // in the cache
                     addInCacheDataByStart(dateTime, dateTimeList, notInCache, ++cacheIndex,
                                           currentDateTimeI.m_TEnd);
                 }
                 else {
                     // ts not localised before the current interval: we need to look at the next interval
                     addInCacheDataByStart(dateTime, dateTimeList, notInCache, ++cacheIndex, currentTStart);
                 }
             }

core/src/Variable/VariableController.cpp +4 -4

             #include <Variable/Variable.h>
             #include <Variable/VariableCacheController.h>
             #include <Variable/VariableController.h>
             #include <Variable/VariableModel.h>
             #include <Data/DataProviderParameters.h>
             #include <Data/IDataProvider.h>
             #include <Data/IDataSeries.h>
             #include <Time/TimeController.h>
             #include <QDateTime>
             #include <QElapsedTimer>
             #include <QMutex>
             #include <QThread>
             #include <unordered_map>
             Q_LOGGING_CATEGORY(LOG_VariableController, "VariableController")
             namespace {
             /// @todo Generates default dataseries, according to the provider passed in parameter. This method
             /// will be deleted when the timerange is recovered from SciQlop
             std::unique_ptr<IDataSeries> generateDefaultDataSeries(const IDataProvider &provider,
                                                                    const SqpDateTime &dateTime) noexcept
             {
                 auto parameters = DataProviderParameters{dateTime};
                 return provider.retrieveData(parameters);
             }
             } // namespace
             struct VariableController::VariableControllerPrivate {
                 explicit VariableControllerPrivate(VariableController *parent)
                         : m_WorkingMutex{},
                           m_VariableModel{new VariableModel{parent}},
                           m_VariableCacheController{std::make_unique<VariableCacheController>()}
                 {
                 }
                 QMutex m_WorkingMutex;
                 /// Variable model. The VariableController has the ownership
                 VariableModel *m_VariableModel;
                 TimeController *m_TimeController{nullptr};
                 std::unique_ptr<VariableCacheController> m_VariableCacheController;
                 std::unordered_map<std::shared_ptr<Variable>, std::shared_ptr<IDataProvider> >
                     m_VariableToProviderMap;
             };
             VariableController::VariableController(QObject *parent)
                     : QObject{parent}, impl{spimpl::make_unique_impl<VariableControllerPrivate>(this)}
             {
                 qCDebug(LOG_VariableController()) << tr("VariableController construction")
                                                   << QThread::currentThread();
             }
             VariableController::~VariableController()
             {
                 qCDebug(LOG_VariableController()) << tr("VariableController destruction")
                                                   << QThread::currentThread();
                 this->waitForFinish();
             }
             VariableModel *VariableController::variableModel() noexcept
             {
                 return impl->m_VariableModel;
             }
             void VariableController::setTimeController(TimeController *timeController) noexcept
             {
                 impl->m_TimeController = timeController;
             }
             void VariableController::createVariable(const QString &name,
                                                     std::shared_ptr<IDataProvider> provider) noexcept
             {
                 if (!impl->m_TimeController) {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to create variable: The time controller is null");
                     return;
                 }
                 /// @todo : for the moment :
                 /// - the provider is only used to retrieve data from the variable for its initialization, but
                 /// it will be retained later
                 /// - default data are generated for the variable, without taking into account the timerange set
                 /// in sciqlop
                 auto dateTime = impl->m_TimeController->dateTime();
                 if (auto newVariable = impl->m_VariableModel->createVariable(
                         name, dateTime, generateDefaultDataSeries(*provider, dateTime))) {
                     // store the provider
                     impl->m_VariableToProviderMap[newVariable] = provider;
                     qRegisterMetaType<std::shared_ptr<IDataSeries> >();
                     qRegisterMetaType<SqpDateTime>();
                     connect(provider.get(), &IDataProvider::dataProvided, newVariable.get(),
                             &Variable::onAddDataSeries);
                     // store in cache
                     impl->m_VariableCacheController->addDateTime(newVariable, dateTime);
                     // notify the creation
                     emit variableCreated(newVariable);
                 }
             }
             void VariableController::requestDataLoading(std::shared_ptr<Variable> variable,
                                                         const SqpDateTime &dateTime)
             {
                 // we want to load data of the variable for the dateTime.
                 // First we check if the cache contains some of them.
                 // For the other, we ask the provider to give them.
                 if (variable) {
                     QElapsedTimer timer;
                     timer.start();
-                    qCInfo(LOG_VariableController()) << "The slow s0 operation took" << timer.elapsed()
+                    qCInfo(LOG_VariableController()) << "TORM: The slow s0 operation took" << timer.elapsed()
                                                      << "milliseconds";
                     auto dateTimeListNotInCache
                         = impl->m_VariableCacheController->provideNotInCacheDateTimeList(variable, dateTime);
-                    qCInfo(LOG_VariableController()) << "The slow s1 operation took" << timer.elapsed()
+                    qCInfo(LOG_VariableController()) << "TORM: The slow s1 operation took" << timer.elapsed()
                                                      << "milliseconds";
                     // Ask the provider for each data on the dateTimeListNotInCache
                     impl->m_VariableToProviderMap.at(variable)->requestDataLoading(dateTimeListNotInCache);
-                    qCInfo(LOG_VariableController()) << "The slow s2 operation took" << timer.elapsed()
+                    qCInfo(LOG_VariableController()) << "TORM: The slow s2 operation took" << timer.elapsed()
                                                      << "milliseconds";
                     // store in cache
                     impl->m_VariableCacheController->addDateTime(variable, dateTime);
-                    qCInfo(LOG_VariableController()) << "The slow s3 operation took" << timer.elapsed()
+                    qCInfo(LOG_VariableController()) << "TORM: The slow s3 operation took" << timer.elapsed()
                                                      << "milliseconds";
                 }
                 else {
                     qCCritical(LOG_VariableController()) << tr("Impossible to load data of a variable null");
                 }
             }
             void VariableController::initialize()
             {
                 qCDebug(LOG_VariableController()) << tr("VariableController init") << QThread::currentThread();
                 impl->m_WorkingMutex.lock();
                 qCDebug(LOG_VariableController()) << tr("VariableController init END");
             }
             void VariableController::finalize()
             {
                 impl->m_WorkingMutex.unlock();
             }
             void VariableController::waitForFinish()
             {
                 QMutexLocker locker{&impl->m_WorkingMutex};
             }

core/tests/Variable/TestVariableCacheController.cpp +60 -60

             #include <Variable/Variable.h>
             #include <Variable/VariableCacheController.h>
             #include <QObject>
             #include <QtTest>
             #include <memory>
             class TestVariableCacheController : public QObject {
                 Q_OBJECT
             private slots:
                 void testProvideNotInCacheDateTimeList();
                 void testAddDateTime();
             };
             void TestVariableCacheController::testProvideNotInCacheDateTimeList()
             {
                 VariableCacheController variableCacheController{};
                 auto ts0 = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 0, 0}};
                 auto te0 = QDateTime{QDate{2017, 01, 01}, QTime{2, 4, 0, 0}};
                 auto sqp0 = SqpDateTime{static_cast<double>(ts0.toMSecsSinceEpoch()),
                                         static_cast<double>(te0.toMSecsSinceEpoch())};
                 auto ts1 = QDateTime{QDate{2017, 01, 01}, QTime{2, 6, 0, 0}};
                 auto te1 = QDateTime{QDate{2017, 01, 01}, QTime{2, 8, 0, 0}};
                 auto sqp1 = SqpDateTime{static_cast<double>(ts1.toMSecsSinceEpoch()),
                                         static_cast<double>(te1.toMSecsSinceEpoch())};
                 auto ts2 = QDateTime{QDate{2017, 01, 01}, QTime{2, 18, 0, 0}};
                 auto te2 = QDateTime{QDate{2017, 01, 01}, QTime{2, 20, 0, 0}};
                 auto sqp2 = SqpDateTime{static_cast<double>(ts2.toMSecsSinceEpoch()),
                                         static_cast<double>(te2.toMSecsSinceEpoch())};
                 auto var0 = std::make_shared<Variable>("", "", "", sqp0);
                 variableCacheController.addDateTime(var0, sqp0);
                 variableCacheController.addDateTime(var0, sqp1);
                 variableCacheController.addDateTime(var0, sqp2);
                 // first case [ts,te] < ts0
                 auto ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 0, 0, 0}};
                 auto te = QDateTime{QDate{2017, 01, 01}, QTime{2, 1, 0, 0}};
                 auto sqp = SqpDateTime{static_cast<double>(ts.toMSecsSinceEpoch()),
                                        static_cast<double>(te.toMSecsSinceEpoch())};
                 auto notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
                 QCOMPARE(notInCach.size(), 1);
-                auto notInCashSqp = notInCach.first();
+                auto notInCacheSqp = notInCach.first();
-                QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
-                QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
                 // second case ts < ts0 &&  ts0 < te <= te0
                 ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 0, 0, 0}};
                 te = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 30, 0}};
                 sqp = SqpDateTime{static_cast<double>(ts.toMSecsSinceEpoch()),
                                   static_cast<double>(te.toMSecsSinceEpoch())};
                 notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
                 QCOMPARE(notInCach.size(), 1);
-                notInCashSqp = notInCach.first();
+                notInCacheSqp = notInCach.first();
-                QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
-                QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(ts0.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(ts0.toMSecsSinceEpoch()));
                 // 3th case ts < ts0 &&  te0 < te <= ts1
                 ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 0, 0, 0}};
                 te = QDateTime{QDate{2017, 01, 01}, QTime{2, 5, 0, 0}};
                 sqp = SqpDateTime{static_cast<double>(ts.toMSecsSinceEpoch()),
                                   static_cast<double>(te.toMSecsSinceEpoch())};
                 notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
                 QCOMPARE(notInCach.size(), 2);
-                notInCashSqp = notInCach.first();
+                notInCacheSqp = notInCach.first();
-                QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
-                QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(ts0.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(ts0.toMSecsSinceEpoch()));
-                notInCashSqp = notInCach.at(1);
+                notInCacheSqp = notInCach.at(1);
-                QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(te0.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(te0.toMSecsSinceEpoch()));
-                QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
                 // 4th case ts < ts0 &&  ts1 < te <= te1
                 ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 0, 0, 0}};
                 te = QDateTime{QDate{2017, 01, 01}, QTime{2, 7, 0, 0}};
                 sqp = SqpDateTime{static_cast<double>(ts.toMSecsSinceEpoch()),
                                   static_cast<double>(te.toMSecsSinceEpoch())};
                 notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
                 QCOMPARE(notInCach.size(), 2);
-                notInCashSqp = notInCach.first();
+                notInCacheSqp = notInCach.first();
-                QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
-                QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(ts0.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(ts0.toMSecsSinceEpoch()));
-                notInCashSqp = notInCach.at(1);
+                notInCacheSqp = notInCach.at(1);
-                QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(te0.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(te0.toMSecsSinceEpoch()));
-                QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(ts1.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(ts1.toMSecsSinceEpoch()));
                 // 5th case ts < ts0 &&  te3 < te
                 ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 0, 0, 0}};
                 te = QDateTime{QDate{2017, 01, 01}, QTime{2, 22, 0, 0}};
                 sqp = SqpDateTime{static_cast<double>(ts.toMSecsSinceEpoch()),
                                   static_cast<double>(te.toMSecsSinceEpoch())};
                 notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
                 QCOMPARE(notInCach.size(), 4);
-                notInCashSqp = notInCach.first();
+                notInCacheSqp = notInCach.first();
-                QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
-                QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(ts0.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(ts0.toMSecsSinceEpoch()));
-                notInCashSqp = notInCach.at(1);
+                notInCacheSqp = notInCach.at(1);
-                QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(te0.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(te0.toMSecsSinceEpoch()));
-                QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(ts1.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(ts1.toMSecsSinceEpoch()));
-                notInCashSqp = notInCach.at(2);
+                notInCacheSqp = notInCach.at(2);
-                QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(te1.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(te1.toMSecsSinceEpoch()));
-                QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(ts2.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(ts2.toMSecsSinceEpoch()));
-                notInCashSqp = notInCach.at(3);
+                notInCacheSqp = notInCach.at(3);
-                QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(te2.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(te2.toMSecsSinceEpoch()));
-                QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
                 // 6th case ts2 < ts
                 ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 45, 0, 0}};
                 te = QDateTime{QDate{2017, 01, 01}, QTime{2, 47, 0, 0}};
                 sqp = SqpDateTime{static_cast<double>(ts.toMSecsSinceEpoch()),
                                   static_cast<double>(te.toMSecsSinceEpoch())};
                 notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
                 QCOMPARE(notInCach.size(), 1);
-                notInCashSqp = notInCach.first();
+                notInCacheSqp = notInCach.first();
-                QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
-                QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
                 // 7th case ts = te0 && te < ts1
                 ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 4, 0, 0}};
                 te = QDateTime{QDate{2017, 01, 01}, QTime{2, 5, 0, 0}};
                 sqp = SqpDateTime{static_cast<double>(ts.toMSecsSinceEpoch()),
                                   static_cast<double>(te.toMSecsSinceEpoch())};
                 notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
                 QCOMPARE(notInCach.size(), 1);
-                notInCashSqp = notInCach.first();
+                notInCacheSqp = notInCach.first();
-                QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(te0.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(te0.toMSecsSinceEpoch()));
-                QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
                 // 8th case ts0 < ts < te0 && te < ts1
                 ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 30, 0}};
                 te = QDateTime{QDate{2017, 01, 01}, QTime{2, 5, 0, 0}};
                 sqp = SqpDateTime{static_cast<double>(ts.toMSecsSinceEpoch()),
                                   static_cast<double>(te.toMSecsSinceEpoch())};
                 notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
                 QCOMPARE(notInCach.size(), 1);
-                notInCashSqp = notInCach.first();
+                notInCacheSqp = notInCach.first();
-                QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(te0.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(te0.toMSecsSinceEpoch()));
-                QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
                 // 9th case ts0 < ts < te0 &&  ts1 < te < te1
                 ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 30, 0}};
                 te = QDateTime{QDate{2017, 01, 01}, QTime{2, 7, 0, 0}};
                 sqp = SqpDateTime{static_cast<double>(ts.toMSecsSinceEpoch()),
                                   static_cast<double>(te.toMSecsSinceEpoch())};
                 notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
                 QCOMPARE(notInCach.size(), 1);
-                notInCashSqp = notInCach.first();
+                notInCacheSqp = notInCach.first();
-                QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(te0.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(te0.toMSecsSinceEpoch()));
-                QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(ts1.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(ts1.toMSecsSinceEpoch()));
                 // 10th case te1 < ts < te < ts2
                 ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 9, 0, 0}};
                 te = QDateTime{QDate{2017, 01, 01}, QTime{2, 10, 0, 0}};
                 sqp = SqpDateTime{static_cast<double>(ts.toMSecsSinceEpoch()),
                                   static_cast<double>(te.toMSecsSinceEpoch())};
                 notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
                 QCOMPARE(notInCach.size(), 1);
-                notInCashSqp = notInCach.first();
+                notInCacheSqp = notInCach.first();
-                QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
-                QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
                 // 11th case te0 < ts < ts1 &&  te3 < te
                 ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 5, 0, 0}};
                 te = QDateTime{QDate{2017, 01, 01}, QTime{2, 47, 0, 0}};
                 sqp = SqpDateTime{static_cast<double>(ts.toMSecsSinceEpoch()),
                                   static_cast<double>(te.toMSecsSinceEpoch())};
                 notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
                 QCOMPARE(notInCach.size(), 3);
-                notInCashSqp = notInCach.first();
+                notInCacheSqp = notInCach.first();
-                QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
-                QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(ts1.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(ts1.toMSecsSinceEpoch()));
-                notInCashSqp = notInCach.at(1);
+                notInCacheSqp = notInCach.at(1);
-                QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(te1.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(te1.toMSecsSinceEpoch()));
-                QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(ts2.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(ts2.toMSecsSinceEpoch()));
-                notInCashSqp = notInCach.at(2);
+                notInCacheSqp = notInCach.at(2);
-                QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(te2.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(te2.toMSecsSinceEpoch()));
-                QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
                 // 12th case te0 < ts < ts1 &&  te3 < te
                 ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 5, 0, 0}};
                 te = QDateTime{QDate{2017, 01, 01}, QTime{2, 10, 0, 0}};
                 sqp = SqpDateTime{static_cast<double>(ts.toMSecsSinceEpoch()),
                                   static_cast<double>(te.toMSecsSinceEpoch())};
                 notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
                 QCOMPARE(notInCach.size(), 2);
-                notInCashSqp = notInCach.first();
+                notInCacheSqp = notInCach.first();
-                QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
-                QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(ts1.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(ts1.toMSecsSinceEpoch()));
-                notInCashSqp = notInCach.at(1);
+                notInCacheSqp = notInCach.at(1);
-                QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(te1.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(te1.toMSecsSinceEpoch()));
-                QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
             }
             void TestVariableCacheController::testAddDateTime()
             {
                 VariableCacheController variableCacheController{};
                 auto ts0 = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 0, 0}};
                 auto te0 = QDateTime{QDate{2017, 01, 01}, QTime{2, 4, 0, 0}};
                 auto sqp0 = SqpDateTime{static_cast<double>(ts0.toMSecsSinceEpoch()),
                                         static_cast<double>(te0.toMSecsSinceEpoch())};
                 auto ts1 = QDateTime{QDate{2017, 01, 01}, QTime{2, 6, 0, 0}};
                 auto te1 = QDateTime{QDate{2017, 01, 01}, QTime{2, 8, 0, 0}};
                 auto sqp1 = SqpDateTime{static_cast<double>(ts1.toMSecsSinceEpoch()),
                                         static_cast<double>(te1.toMSecsSinceEpoch())};
                 auto ts2 = QDateTime{QDate{2017, 01, 01}, QTime{2, 18, 0, 0}};
                 auto te2 = QDateTime{QDate{2017, 01, 01}, QTime{2, 20, 0, 0}};
                 auto sqp2 = SqpDateTime{static_cast<double>(ts2.toMSecsSinceEpoch()),
                                         static_cast<double>(te2.toMSecsSinceEpoch())};
                 auto ts01 = QDateTime{QDate{2017, 01, 01}, QTime{2, 4, 0, 0}};
                 auto te01 = QDateTime{QDate{2017, 01, 01}, QTime{2, 6, 0, 0}};
                 auto sqp01 = SqpDateTime{static_cast<double>(ts01.toMSecsSinceEpoch()),
                                          static_cast<double>(te01.toMSecsSinceEpoch())};
                 auto ts3 = QDateTime{QDate{2017, 01, 01}, QTime{2, 14, 0, 0}};
                 auto te3 = QDateTime{QDate{2017, 01, 01}, QTime{2, 16, 0, 0}};
                 auto sqp3 = SqpDateTime{static_cast<double>(ts3.toMSecsSinceEpoch()),
                                         static_cast<double>(te3.toMSecsSinceEpoch())};
                 auto ts03 = QDateTime{QDate{2017, 01, 01}, QTime{2, 4, 0, 0}};
                 auto te03 = QDateTime{QDate{2017, 01, 01}, QTime{2, 22, 0, 0}};
                 auto sqp03 = SqpDateTime{static_cast<double>(ts03.toMSecsSinceEpoch()),
                                          static_cast<double>(te03.toMSecsSinceEpoch())};
                 auto var0 = std::make_shared<Variable>("", "", "", sqp0);
                 // First case: add the first interval to the variable :sqp0
                 variableCacheController.addDateTime(var0, sqp0);
                 auto dateCacheList = variableCacheController.dateCacheList(var0);
                 QCOMPARE(dateCacheList.count(), 1);
                 auto dateCache = dateCacheList.at(0);
                 QCOMPARE(dateCache.m_TStart, static_cast<double>(ts0.toMSecsSinceEpoch()));
                 QCOMPARE(dateCache.m_TEnd, static_cast<double>(te0.toMSecsSinceEpoch()));
                 // 2nd case: add a second interval : sqp1 > sqp0
                 variableCacheController.addDateTime(var0, sqp1);
                 dateCacheList = variableCacheController.dateCacheList(var0);
                 QCOMPARE(dateCacheList.count(), 2);
                 dateCache = dateCacheList.at(0);
                 QCOMPARE(dateCache.m_TStart, static_cast<double>(ts0.toMSecsSinceEpoch()));
                 QCOMPARE(dateCache.m_TEnd, static_cast<double>(te0.toMSecsSinceEpoch()));
                 dateCache = dateCacheList.at(1);
                 QCOMPARE(dateCache.m_TStart, static_cast<double>(ts1.toMSecsSinceEpoch()));
                 QCOMPARE(dateCache.m_TEnd, static_cast<double>(te1.toMSecsSinceEpoch()));
                 // 3th case: merge sqp0 & sqp1 with sqp01
                 variableCacheController.addDateTime(var0, sqp01);
                 dateCacheList = variableCacheController.dateCacheList(var0);
                 QCOMPARE(dateCacheList.count(), 1);
                 dateCache = dateCacheList.at(0);
                 QCOMPARE(dateCache.m_TStart, static_cast<double>(ts0.toMSecsSinceEpoch()));
                 QCOMPARE(dateCache.m_TEnd, static_cast<double>(te1.toMSecsSinceEpoch()));
                 // 4th case: add a second interval : sqp1 > sqp0
                 variableCacheController.addDateTime(var0, sqp2);
                 variableCacheController.addDateTime(var0, sqp3);
                 dateCacheList = variableCacheController.dateCacheList(var0);
                 QCOMPARE(dateCacheList.count(), 3);
                 dateCache = dateCacheList.at(0);
                 QCOMPARE(dateCache.m_TStart, static_cast<double>(ts0.toMSecsSinceEpoch()));
                 QCOMPARE(dateCache.m_TEnd, static_cast<double>(te1.toMSecsSinceEpoch()));
                 dateCache = dateCacheList.at(1);
                 QCOMPARE(dateCache.m_TStart, static_cast<double>(ts3.toMSecsSinceEpoch()));
                 QCOMPARE(dateCache.m_TEnd, static_cast<double>(te3.toMSecsSinceEpoch()));
                 dateCache = dateCacheList.at(2);
                 QCOMPARE(dateCache.m_TStart, static_cast<double>(ts2.toMSecsSinceEpoch()));
                 QCOMPARE(dateCache.m_TEnd, static_cast<double>(te2.toMSecsSinceEpoch()));
                 // 5th case: merge all interval
                 variableCacheController.addDateTime(var0, sqp03);
                 dateCacheList = variableCacheController.dateCacheList(var0);
                 QCOMPARE(dateCacheList.count(), 1);
                 dateCache = dateCacheList.at(0);
                 QCOMPARE(dateCache.m_TStart, static_cast<double>(ts0.toMSecsSinceEpoch()));
                 QCOMPARE(dateCache.m_TEnd, static_cast<double>(te03.toMSecsSinceEpoch()));
             }
             QTEST_MAIN(TestVariableCacheController)
             #include "TestVariableCacheController.moc"

gui/include/Visualization/VisualizationGraphHelper.h ~~gui/include/Visualization/GraphPlottablesFactory.h~~ renamed +6 -6

-            #ifndef SCIQLOP_GRAPHPLOTTABLESFACTORY_H
+            #ifndef SCIQLOP_VISUALIZATIONGRAPHHELPER_H
-            #define SCIQLOP_GRAPHPLOTTABLESFACTORY_H
+            #define SCIQLOP_VISUALIZATIONGRAPHHELPER_H
             #include <Data/SqpDateTime.h>
             #include <QLoggingCategory>
             #include <QVector>
             #include <memory>
-            Q_DECLARE_LOGGING_CATEGORY(LOG_GraphPlottablesFactory)
+            Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationGraphHelper)
             class IDataSeries;
             class QCPAbstractPlottable;
             class QCustomPlot;
             class Variable;
             /**
-             * @brief The GraphPlottablesFactory class aims to create the QCustomPlot components relative to a
+             * @brief The VisualizationGraphHelper class aims to create the QCustomPlot components relative to a
              * variable, depending on the data series of this variable
              */
-            struct GraphPlottablesFactory {
+            struct VisualizationGraphHelper {
                 /**
                  * Creates (if possible) the QCustomPlot components relative to the variable passed in
                  * parameter, and adds these to the plot passed in parameter.
                  * @param variable the variable for which to create the components
                  * @param plot the plot in which to add the created components. It takes ownership of these
                  * components.
                  * @return the list of the components created
                  */
                 static QVector<QCPAbstractPlottable *> create(std::shared_ptr<Variable> variable,
                                                               QCustomPlot &plot) noexcept;
                 static void updateData(QVector<QCPAbstractPlottable *> plotableVect, IDataSeries *dataSeries,
                                        const SqpDateTime &dateTime);
             };
-            #endif // SCIQLOP_GRAPHPLOTTABLESFACTORY_H
+            #endif // SCIQLOP_VISUALIZATIONGRAPHHELPER_H

gui/src/Visualization/VisualizationGraphHelper.cpp ~~gui/src/Visualization/GraphPlottablesFactory.cpp~~ renamed +14 -14

-            #include "Visualization/GraphPlottablesFactory.h"
+            #include "Visualization/VisualizationGraphHelper.h"
             #include "Visualization/qcustomplot.h"
             #include <Data/ScalarSeries.h>
             #include <Variable/Variable.h>
             #include <QElapsedTimer>
-            Q_LOGGING_CATEGORY(LOG_GraphPlottablesFactory, "GraphPlottablesFactory")
+            Q_LOGGING_CATEGORY(LOG_VisualizationGraphHelper, "VisualizationGraphHelper")
             namespace {
             /// Format for datetimes on a axis
             const auto DATETIME_TICKER_FORMAT = QStringLiteral("yyyy/MM/dd \nhh:mm:ss");
             /// Generates the appropriate ticker for an axis, depending on whether the axis displays time or
             /// non-time data
             QSharedPointer<QCPAxisTicker> axisTicker(bool isTimeAxis)
             {
                 if (isTimeAxis) {
                     auto dateTicker = QSharedPointer<QCPAxisTickerDateTime>::create();
                     dateTicker->setDateTimeFormat(DATETIME_TICKER_FORMAT);
                     return dateTicker;
                 }
                 else {
                     // default ticker
                     return QSharedPointer<QCPAxisTicker>::create();
                 }
             }
             void updateScalarData(QCPAbstractPlottable *component, ScalarSeries &scalarSeries,
                                   const SqpDateTime &dateTime)
             {
                 QElapsedTimer timer;
                 timer.start();
                 if (auto qcpGraph = dynamic_cast<QCPGraph *>(component)) {
                     // Clean the graph
-                    qCDebug(LOG_GraphPlottablesFactory()) << "The slow s1 operation took" << timer.elapsed()
+                    qCDebug(LOG_VisualizationGraphHelper()) << "The slow s1 operation took" << timer.elapsed()
-                                                          << "milliseconds";
+                                                            << "milliseconds";
                     // NAIVE approch
                     const auto &xData = scalarSeries.xAxisData()->data();
                     const auto &valuesData = scalarSeries.valuesData()->data();
                     auto xValue = QVector<double>();
                     auto vValue = QVector<double>();
                     const auto count = xData.count();
                     auto ite = 0;
                     for (auto i = 0; i < count; ++i) {
                         const auto x = xData.at(i);
                         if (x >= dateTime.m_TStart && x <= dateTime.m_TEnd) {
                             xValue.push_back(x);
                             vValue.push_back(valuesData.at(i));
                             ++ite;
                         }
                     }
                     qcpGraph->setData(xValue, vValue);
-                    qCDebug(LOG_GraphPlottablesFactory()) << "The slow s2 operation took" << timer.elapsed()
+                    qCDebug(LOG_VisualizationGraphHelper()) << "The slow s2 operation took" << timer.elapsed()
-                                                          << "milliseconds";
+                                                            << "milliseconds";
                 }
                 else {
                     /// @todo DEBUG
                 }
             }
             QCPAbstractPlottable *createScalarSeriesComponent(ScalarSeries &scalarSeries, QCustomPlot &plot,
                                                               const SqpDateTime &dateTime)
             {
                 auto component = plot.addGraph();
                 if (component) {
                     //        // Graph data
                     component->setData(scalarSeries.xAxisData()->data(), scalarSeries.valuesData()->data(),
                                        true);
                     updateScalarData(component, scalarSeries, dateTime);
                     // Axes properties
                     /// @todo : for the moment, no control is performed on the axes: the units and the tickers
                     /// are fixed for the default x-axis and y-axis of the plot, and according to the new graph
                     auto setAxisProperties = [](auto axis, const auto &unit) {
                         // label (unit name)
                         axis->setLabel(unit.m_Name);
                         // ticker (depending on the type of unit)
                         axis->setTicker(axisTicker(unit.m_TimeUnit));
                     };
                     setAxisProperties(plot.xAxis, scalarSeries.xAxisUnit());
                     setAxisProperties(plot.yAxis, scalarSeries.valuesUnit());
                     // Display all data
                     component->rescaleAxes();
                     plot.replot();
                 }
                 else {
-                    qCDebug(LOG_GraphPlottablesFactory())
+                    qCDebug(LOG_VisualizationGraphHelper())
                         << QObject::tr("Can't create graph for the scalar series");
                 }
                 return component;
             }
             } // namespace
-            QVector<QCPAbstractPlottable *> GraphPlottablesFactory::create(std::shared_ptr<Variable> variable,
+            QVector<QCPAbstractPlottable *> VisualizationGraphHelper::create(std::shared_ptr<Variable> variable,
-                                                                           QCustomPlot &plot) noexcept
+                                                                             QCustomPlot &plot) noexcept
             {
                 auto result = QVector<QCPAbstractPlottable *>{};
                 if (variable) {
                     // Gets the data series of the variable to call the creation of the right components
                     // according to its type
                     if (auto scalarSeries = dynamic_cast<ScalarSeries *>(variable->dataSeries())) {
                         result.append(createScalarSeriesComponent(*scalarSeries, plot, variable->dateTime()));
                     }
                     else {
-                        qCDebug(LOG_GraphPlottablesFactory())
+                        qCDebug(LOG_VisualizationGraphHelper())
                             << QObject::tr("Can't create graph plottables : unmanaged data series type");
                     }
                 }
                 else {
-                    qCDebug(LOG_GraphPlottablesFactory())
+                    qCDebug(LOG_VisualizationGraphHelper())
                         << QObject::tr("Can't create graph plottables : the variable is null");
                 }
                 return result;
             }
-            void GraphPlottablesFactory::updateData(QVector<QCPAbstractPlottable *> plotableVect,
+            void VisualizationGraphHelper::updateData(QVector<QCPAbstractPlottable *> plotableVect,
-                                                    IDataSeries *dataSeries, const SqpDateTime &dateTime)
+                                                      IDataSeries *dataSeries, const SqpDateTime &dateTime)
             {
                 if (auto scalarSeries = dynamic_cast<ScalarSeries *>(dataSeries)) {
                     if (plotableVect.size() == 1) {
                         updateScalarData(plotableVect.at(0), *scalarSeries, dateTime);
                     }
                     else {
-                        qCCritical(LOG_GraphPlottablesFactory()) << QObject::tr(
+                        qCCritical(LOG_VisualizationGraphHelper()) << QObject::tr(
                             "Can't update Data of a scalarSeries because there is not only one component "
                             "associated");
                     }
                 }
                 else {
                     /// @todo DEBUG
                 }
             }

gui/src/Visualization/VisualizationGraphWidget.cpp +14 -6

             #include "Visualization/VisualizationGraphWidget.h"
-            #include "Visualization/GraphPlottablesFactory.h"
             #include "Visualization/IVisualizationWidgetVisitor.h"
+            #include "Visualization/VisualizationGraphHelper.h"
             #include "ui_VisualizationGraphWidget.h"
             #include <Data/ArrayData.h>
             #include <Data/IDataSeries.h>
             #include <SqpApplication.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <unordered_map>
             Q_LOGGING_CATEGORY(LOG_VisualizationGraphWidget, "VisualizationGraphWidget")
             namespace {
             /// Key pressed to enable zoom on horizontal axis
             const auto HORIZONTAL_ZOOM_MODIFIER = Qt::NoModifier;
             /// Key pressed to enable zoom on vertical axis
             const auto VERTICAL_ZOOM_MODIFIER = Qt::ControlModifier;
             } // namespace
             struct VisualizationGraphWidget::VisualizationGraphWidgetPrivate {
                 // 1 variable -> n qcpplot
                 std::unordered_multimap<std::shared_ptr<Variable>, QCPAbstractPlottable *>
                     m_VariableToPlotMultiMap;
             };
             VisualizationGraphWidget::VisualizationGraphWidget(const QString &name, QWidget *parent)
                     : QWidget{parent},
                       ui{new Ui::VisualizationGraphWidget},
                       impl{spimpl::make_unique_impl<VisualizationGraphWidgetPrivate>()}
             {
                 ui->setupUi(this);
                 // qcpplot title
                 ui->widget->plotLayout()->insertRow(0);
                 ui->widget->plotLayout()->addElement(0, 0, new QCPTextElement{ui->widget, name});
                 // Set qcpplot properties :
                 // - Drag (on x-axis) and zoom are enabled
                 // - Mouse wheel on qcpplot is intercepted to determine the zoom orientation
                 ui->widget->setInteractions(QCP::iRangeDrag | QCP::iRangeZoom);
                 ui->widget->axisRect()->setRangeDrag(Qt::Horizontal);
                 connect(ui->widget, &QCustomPlot::mouseWheel, this, &VisualizationGraphWidget::onMouseWheel);
                 connect(ui->widget->xAxis, static_cast<void (QCPAxis::*)(const QCPRange &, const QCPRange &)>(
                                                &QCPAxis::rangeChanged),
                         this, &VisualizationGraphWidget::onRangeChanged);
             }
             VisualizationGraphWidget::~VisualizationGraphWidget()
             {
                 delete ui;
             }
             void VisualizationGraphWidget::addVariable(std::shared_ptr<Variable> variable)
             {
                 // Uses delegate to create the qcpplot components according to the variable
-                auto createdPlottables = GraphPlottablesFactory::create(variable, *ui->widget);
+                auto createdPlottables = VisualizationGraphHelper::create(variable, *ui->widget);
                 for (auto createdPlottable : qAsConst(createdPlottables)) {
                     impl->m_VariableToPlotMultiMap.insert({variable, createdPlottable});
                 }
                 connect(variable.get(), SIGNAL(dataCacheUpdated()), this, SLOT(onDataCacheVariableUpdated()));
             }
             void VisualizationGraphWidget::accept(IVisualizationWidgetVisitor *visitor)
             {
                 if (visitor) {
                     visitor->visit(this);
                 }
                 else {
                     qCCritical(LOG_VisualizationGraphWidget())
                         << tr("Can't visit widget : the visitor is null");
                 }
             }
             bool VisualizationGraphWidget::canDrop(const Variable &variable) const
             {
                 /// @todo : for the moment, a graph can always accomodate a variable
                 Q_UNUSED(variable);
                 return true;
             }
             void VisualizationGraphWidget::close()
             {
                 // The main view cannot be directly closed.
                 return;
             }
             QString VisualizationGraphWidget::name() const
             {
                 if (auto title = dynamic_cast<QCPTextElement *>(ui->widget->plotLayout()->elementAt(0))) {
                     return title->text();
                 }
                 else {
                     return QString{};
                 }
             }
             void VisualizationGraphWidget::onRangeChanged(const QCPRange &t1, const QCPRange &t2)
             {
                 qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::onRangeChanged");
                 for (auto it = impl->m_VariableToPlotMultiMap.cbegin();
                      it != impl->m_VariableToPlotMultiMap.cend(); ++it) {
                     auto variable = it->first;
                     auto tolerance = 0.1 * (t2.upper - t2.lower);
                     auto dateTime = SqpDateTime{t2.lower - tolerance, t2.upper + tolerance};
                     qCInfo(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::onRangeChanged")
                                                            << variable->dataSeries()->xAxisData()->size();
                     if (!variable->contains(dateTime)) {
                         sqpApp->variableController().requestDataLoading(variable, dateTime);
                     }
                 }
             }
             void VisualizationGraphWidget::onMouseWheel(QWheelEvent *event) noexcept
             {
                 auto zoomOrientations = QFlags<Qt::Orientation>{};
                 // Lambda that enables a zoom orientation if the key modifier related to this orientation has
                 // been pressed
                 auto enableOrientation
                     = [&zoomOrientations, event](const auto &orientation, const auto &modifier) {
                           auto orientationEnabled = event->modifiers().testFlag(modifier);
                           zoomOrientations.setFlag(orientation, orientationEnabled);
                       };
                 enableOrientation(Qt::Vertical, VERTICAL_ZOOM_MODIFIER);
                 enableOrientation(Qt::Horizontal, HORIZONTAL_ZOOM_MODIFIER);
                 ui->widget->axisRect()->setRangeZoom(zoomOrientations);
             }
             void VisualizationGraphWidget::onDataCacheVariableUpdated()
             {
+                // NOTE:
+                //    We don't want to call the method for each component of a variable unitarily, but for all
+                //    its components at once (eg its three components in the case of a vector).
+                //    The unordered_multimap does not do this easily, so the question is whether to:
+                //    - use an ordered_multimap and the algos of std to group the values by key
+                //    - use a map (unique keys) and store as values directly the list of components
                 for (auto it = impl->m_VariableToPlotMultiMap.cbegin();
                      it != impl->m_VariableToPlotMultiMap.cend(); ++it) {
                     auto variable = it->first;
-                    GraphPlottablesFactory::updateData(QVector<QCPAbstractPlottable *>{} << it->second,
+                    VisualizationGraphHelper::updateData(QVector<QCPAbstractPlottable *>{} << it->second,
-                                                       variable->dataSeries(), variable->dateTime());
+                                                         variable->dataSeries(), variable->dateTime());
                 }
             }
             void VisualizationGraphWidget::updateDisplay(std::shared_ptr<Variable> variable)
             {
                 auto abstractPlotableItPair = impl->m_VariableToPlotMultiMap.equal_range(variable);
                 auto abstractPlotableVect = QVector<QCPAbstractPlottable *>{};
                 for (auto it = abstractPlotableItPair.first; it != abstractPlotableItPair.second; ++it) {
                     abstractPlotableVect.push_back(it->second);
                 }
-                GraphPlottablesFactory::updateData(abstractPlotableVect, variable->dataSeries(),
+                VisualizationGraphHelper::updateData(abstractPlotableVect, variable->dataSeries(),
-                                                   variable->dateTime());
+                                                     variable->dateTime());
             }

plugins/mockplugin/src/CosinusProvider.cpp +1 -1

             #include "CosinusProvider.h"
             #include <Data/DataProviderParameters.h>
             #include <Data/ScalarSeries.h>
             #include <cmath>
             Q_LOGGING_CATEGORY(LOG_CosinusProvider, "CosinusProvider")
             std::unique_ptr<IDataSeries>
             CosinusProvider::retrieveData(const DataProviderParameters &parameters) const
             {
                 auto dateTime = parameters.m_Time;
                 // Gets the timerange from the parameters
                 auto start = dateTime.m_TStart;
                 auto end = dateTime.m_TEnd;
                 // We assure that timerange is valid
                 if (end < start) {
                     std::swap(start, end);
                 }
                 // Generates scalar series containing cosinus values (one value per second)
                 auto scalarSeries
                     = std::make_unique<ScalarSeries>(end - start, Unit{QStringLiteral("t"), true}, Unit{});
                 auto dataIndex = 0;
                 for (auto time = start; time < end; ++time, ++dataIndex) {
                     scalarSeries->setData(dataIndex, time, std::cos(time));
                 }
                 return scalarSeries;
             }
             void CosinusProvider::requestDataLoading(const QVector<SqpDateTime> &dateTimeList)
             {
                 // NOTE: Try to use multithread if possible
-                foreach (const auto &dateTime, dateTimeList) {
+                for (const auto &dateTime : dateTimeList) {
                     auto scalarSeries = this->retrieveDataSeries(dateTime);
                     emit dataProvided(scalarSeries, dateTime);
                 }
             }
             std::shared_ptr<IDataSeries> CosinusProvider::retrieveDataSeries(const SqpDateTime &dateTime)
             {
                 // Gets the timerange from the parameters
                 auto start = dateTime.m_TStart;
                 auto end = dateTime.m_TEnd;
                 // We assure that timerange is valid
                 if (end < start) {
                     std::swap(start, end);
                 }
                 // Generates scalar series containing cosinus values (one value per second)
                 auto scalarSeries
                     = std::make_shared<ScalarSeries>(end - start, Unit{QStringLiteral("t"), true}, Unit{});
                 auto dataIndex = 0;
                 for (auto time = start; time < end; ++time, ++dataIndex) {
                     scalarSeries->setData(dataIndex, time, std::cos(time));
                 }
                 return scalarSeries;
             }

General Comments 0

Write
Preview

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

No TODOs yet

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

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