GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r299:bc65aa8d09b9

Merge branch 'feature/DateTimeOfVariableAtInit' into develop

perrinel -

r299:bc65aa8d09b9

parent child

Context file:

r299:bc65aa8d09b9

core/include/Data/ArrayData.h +4 -4

             #ifndef SCIQLOP_ARRAYDATA_H
             #define SCIQLOP_ARRAYDATA_H
             #include <QVector>
             /**
              * @brief The ArrayData class represents a dataset for a data series.
              *
              * A dataset can be unidimensional or two-dimensional. This property is determined by the Dim
              * template-parameter.
              *
              * @tparam Dim the dimension of the ArrayData (one or two)
              * @sa IDataSeries
              */
             template <int Dim>
             class ArrayData {
             public:
                 /**
                  * Ctor for a unidimensional ArrayData
                  * @param nbColumns the number of values the ArrayData will hold
                  */
                 template <int D = Dim, typename = std::enable_if_t<D == 1> >
                 explicit ArrayData(int nbColumns) : m_Data{1, QVector<double>{}}
                 {
                     m_Data[0].resize(nbColumns);
                 }
                 /**
                  * Sets a data at a specified index. The index has to be valid to be effective
                  * @param index the index to which the data will be set
                  * @param data the data to set
                  * @remarks this method is only available for a unidimensional ArrayData
                  */
                 template <int D = Dim, typename = std::enable_if_t<D == 1> >
                 void setData(int index, double data) noexcept
                 {
                     if (index >= 0 && index < m_Data.at(0).size()) {
                         m_Data[0].replace(index, data);
                     }
                 }
                 /**
                  * @return the data as a vector
                  * @remarks this method is only available for a unidimensional ArrayData
                  */
                 template <int D = Dim, typename = std::enable_if_t<D == 1> >
-                QVector<double> data() const noexcept
+                const QVector<double> &data() const noexcept
                 {
-                    return m_Data.at(0);
+                    return m_Data[0];
                 }
                 /**
                  * @return the data as a vector
                  * @remarks this method is only available for a unidimensional ArrayData
                  */
                 template <int D = Dim, typename = std::enable_if_t<D == 1> >
                 const QVector<double> &data(double tStart, double tEnd) const noexcept
                 {
                     return m_Data.at(tStart);
                 }
                 // TODO Comment
                 template <int D = Dim, typename = std::enable_if_t<D == 1> >
-                void merge(ArrayData<1> *arrayData)
+                void merge(const ArrayData<1> &arrayData)
                 {
                     if (!m_Data.empty()) {
-                        m_Data[0] += arrayData->data();
+                        m_Data[0] += arrayData.data();
                     }
                 }
                 template <int D = Dim, typename = std::enable_if_t<D == 1> >
                 int size()
                 {
                     return m_Data[0].size();
                 }
             private:
                 QVector<QVector<double> > m_Data;
             };
             #endif // SCIQLOP_ARRAYDATA_H

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

             #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_XAxisData->merge(*dimDataSeries->xAxisData());
-                        m_ValuesData->merge(dimDataSeries->valuesData().get());
+                        m_ValuesData->merge(*dimDataSeries->valuesData());
                     }
                     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/SqpDateTime.h +14 0

             #ifndef SCIQLOP_SQPDATETIME_H
             #define SCIQLOP_SQPDATETIME_H
             #include <QObject>
+            #include <QDateTime>
+            #include <QDebug>
             /**
              * @brief The SqpDateTime struct holds the information of time parameters
              */
             struct SqpDateTime {
                 /// Start time
                 double m_TStart;
                 /// End time
                 double m_TEnd;
                 bool contains(const SqpDateTime &dateTime)
                 {
                     return (m_TStart <= dateTime.m_TStart && m_TEnd >= dateTime.m_TEnd);
                 }
                 bool intersect(const SqpDateTime &dateTime)
                 {
                     return (m_TEnd >= dateTime.m_TStart && m_TStart <= dateTime.m_TEnd);
                 }
             };
+            inline QDebug operator<<(QDebug d, SqpDateTime obj)
+            {
+                auto tendDateTimeStart = QDateTime::fromMSecsSinceEpoch(obj.m_TStart * 1000);
+                auto tendDateTimeEnd = QDateTime::fromMSecsSinceEpoch(obj.m_TEnd * 1000);
+                //        QDebug << "ts: " << tendDateTimeStart << " te: " << tendDateTimeEnd;
+                d << "ts: " << tendDateTimeStart << " te: " << tendDateTimeEnd;
+                return d;
+            }
             // Required for using shared_ptr in signals/slots
             Q_DECLARE_METATYPE(SqpDateTime)
             #endif // SCIQLOP_SQPDATETIME_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;
                 void setDateTime(const SqpDateTime &dateTime) noexcept;
                 /// @return the data of the variable, nullptr if there is no data
                 IDataSeries *dataSeries() const noexcept;
                 bool contains(const SqpDateTime &dateTime);
                 bool intersect(const SqpDateTime &dateTime);
                 void setDataSeries(std::unique_ptr<IDataSeries> dataSeries) noexcept;
             public slots:
                 void onAddDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept;
             signals:
-                void dataCacheUpdated();
+                void updated();
             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 +7 0

             #ifndef SCIQLOP_VARIABLECACHECONTROLLER_H
             #define SCIQLOP_VARIABLECACHECONTROLLER_H
             #include <QObject>
             #include <Data/SqpDateTime.h>
+            #include <QLoggingCategory>
             #include <Common/spimpl.h>
             class Variable;
+            Q_DECLARE_LOGGING_CATEGORY(LOG_VariableCacheController)
             /// 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;
+                void displayCache(std::shared_ptr<Variable> variable);
             private:
                 class VariableCacheControllerPrivate;
                 spimpl::unique_impl_ptr<VariableCacheControllerPrivate> impl;
             };
             #endif // SCIQLOP_VARIABLECACHECONTROLLER_H

core/include/Variable/VariableController.h +2 -3

             #ifndef SCIQLOP_VARIABLECONTROLLER_H
             #define SCIQLOP_VARIABLECONTROLLER_H
             #include <Data/SqpDateTime.h>
             #include <QLoggingCategory>
             #include <QObject>
             #include <Common/spimpl.h>
             class IDataProvider;
             class TimeController;
             class Variable;
             class VariableModel;
             Q_DECLARE_LOGGING_CATEGORY(LOG_VariableController)
             /**
              * @brief The VariableController class aims to handle the variables in SciQlop.
              */
             class VariableController : public QObject {
                 Q_OBJECT
             public:
                 explicit VariableController(QObject *parent = 0);
                 virtual ~VariableController();
                 VariableModel *variableModel() noexcept;
                 void setTimeController(TimeController *timeController) noexcept;
-                /// Request the data loading of the variable whithin dateTime
-                void requestDataLoading(std::shared_ptr<Variable> variable, const SqpDateTime &dateTime);
             signals:
                 /// Signal emitted when a variable has been created
                 void variableCreated(std::shared_ptr<Variable> variable);
             public slots:
+                /// Request the data loading of the variable whithin dateTime
+                void onRequestDataLoading(std::shared_ptr<Variable> variable, const SqpDateTime &dateTime);
                 /**
                  * Creates a new variable and adds it to the model
                  * @param name the name of the new variable
                  * @param provider the data provider for the new variable
                  */
                 void createVariable(const QString &name, std::shared_ptr<IDataProvider> provider) noexcept;
                 void initialize();
                 void finalize();
             private:
                 void waitForFinish();
                 class VariableControllerPrivate;
                 spimpl::unique_impl_ptr<VariableControllerPrivate> impl;
             };
             #endif // SCIQLOP_VARIABLECONTROLLER_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::setDateTime(const SqpDateTime &dateTime) noexcept
             {
                 impl->m_DateTime = 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();
+                    emit updated();
                 }
             }
             IDataSeries *Variable::dataSeries() const noexcept
             {
                 return impl->m_DataSeries.get();
             }
             bool Variable::contains(const SqpDateTime &dateTime)
             {
                 return impl->m_DateTime.contains(dateTime);
             }
             bool Variable::intersect(const SqpDateTime &dateTime)
             {
                 return impl->m_DateTime.intersect(dateTime);
             }

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

             #include "Variable/VariableCacheController.h"
             #include "Variable/Variable.h"
             #include <unordered_map>
+            Q_LOGGING_CATEGORY(LOG_VariableCacheController, "VariableCacheController")
             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>()}
             {
             }
             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
                         impl->addDateTimeRecurse(dateTime, impl->m_VariableToSqpDateTimeListMap.at(variable),
 );
                     }
                 }
             }
             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];
                 if (currentTStart < currentDateTimeI.m_TStart) {
                     // ts localised between to interval: let's localized te
                     addInCacheDataByEnd(dateTime, dateTimeList, notInCache, cacheIndex, currentTStart);
                 }
-                else if (dateTime.m_TStart < currentDateTimeI.m_TEnd) {
+                else if (currentTStart < currentDateTimeI.m_TEnd) {
-                    // ts not localised before the current interval: we need to look at the next interval
+                    if (dateTime.m_TEnd > currentDateTimeI.m_TEnd) {
-                    // We can assume now current tstart is the last interval tend, because data between them are
+                        // ts not localised before the current interval: we need to look at the next interval
-                    // in the cache
+                        // We can assume now current tstart is the last interval tend, because data between them
-                    addInCacheDataByStart(dateTime, dateTimeList, notInCache, ++cacheIndex,
+                        // are
-                                          currentDateTimeI.m_TEnd);
+                        // 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);
                 }
             }
+            void VariableCacheController::displayCache(std::shared_ptr<Variable> variable)
+            {
+                auto variableDateTimeList = impl->m_VariableToSqpDateTimeListMap.at(variable);
+                qCInfo(LOG_VariableCacheController()) << tr("VariableCacheController::displayCache")
+                                                      << variableDateTimeList;
+            }

core/src/Variable/VariableController.cpp +12 -19

             #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,
+            void VariableController::onRequestDataLoading(std::shared_ptr<Variable> variable,
-                                                        const SqpDateTime &dateTime)
+                                                          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()) << "TORM: The slow s0 operation took" << timer.elapsed()
-                                                     << "milliseconds";
                     auto dateTimeListNotInCache
                         = impl->m_VariableCacheController->provideNotInCacheDateTimeList(variable, dateTime);
-                    qCInfo(LOG_VariableController()) << "TORM: The slow s1 operation took" << timer.elapsed()
-                                                     << "milliseconds";
-                    // Ask the provider for each data on the dateTimeListNotInCache
+                    if (!dateTimeListNotInCache.empty()) {
-                    impl->m_VariableToProviderMap.at(variable)->requestDataLoading(dateTimeListNotInCache);
+                        // Ask the provider for each data on the dateTimeListNotInCache
+                        impl->m_VariableToProviderMap.at(variable)->requestDataLoading(
-                    qCInfo(LOG_VariableController()) << "TORM: The slow s2 operation took" << timer.elapsed()
+                            std::move(dateTimeListNotInCache));
-                                                     << "milliseconds";
+                        // store in cache
+                        impl->m_VariableCacheController->addDateTime(variable, dateTime);
-                    // store in cache
-                    impl->m_VariableCacheController->addDateTime(variable, dateTime);
+                    else {
-                    qCInfo(LOG_VariableController()) << "TORM: The slow s3 operation took" << timer.elapsed()
+                        emit variable->updated();
-                                                     << "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 +10 0

             #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 notInCacheSqp = notInCach.first();
                 QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(ts.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);
                 notInCacheSqp = notInCach.first();
                 QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(ts.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);
                 notInCacheSqp = notInCach.first();
                 QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
                 QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(ts0.toMSecsSinceEpoch()));
                 notInCacheSqp = notInCach.at(1);
                 QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(te0.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);
                 notInCacheSqp = notInCach.first();
                 QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
                 QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(ts0.toMSecsSinceEpoch()));
                 notInCacheSqp = notInCach.at(1);
                 QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(te0.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);
                 notInCacheSqp = notInCach.first();
                 QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
                 QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(ts0.toMSecsSinceEpoch()));
                 notInCacheSqp = notInCach.at(1);
                 QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(te0.toMSecsSinceEpoch()));
                 QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(ts1.toMSecsSinceEpoch()));
                 notInCacheSqp = notInCach.at(2);
                 QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(te1.toMSecsSinceEpoch()));
                 QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(ts2.toMSecsSinceEpoch()));
                 notInCacheSqp = notInCach.at(3);
                 QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(te2.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);
                 notInCacheSqp = notInCach.first();
                 QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(ts.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);
                 notInCacheSqp = notInCach.first();
                 QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(te0.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);
                 notInCacheSqp = notInCach.first();
                 QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(te0.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);
                 notInCacheSqp = notInCach.first();
                 QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(te0.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);
                 notInCacheSqp = notInCach.first();
                 QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(ts.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);
                 notInCacheSqp = notInCach.first();
                 QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
                 QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(ts1.toMSecsSinceEpoch()));
                 notInCacheSqp = notInCach.at(1);
                 QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(te1.toMSecsSinceEpoch()));
                 QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(ts2.toMSecsSinceEpoch()));
                 notInCacheSqp = notInCach.at(2);
                 QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(te2.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);
                 notInCacheSqp = notInCach.first();
                 QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
                 QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(ts1.toMSecsSinceEpoch()));
                 notInCacheSqp = notInCach.at(1);
                 QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(te1.toMSecsSinceEpoch()));
                 QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
+                // 12th case ts0 < ts < te0
+                ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 10, 0}};
+                te = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 50, 0}};
+                sqp = SqpDateTime{static_cast<double>(ts.toMSecsSinceEpoch()),
+                                  static_cast<double>(te.toMSecsSinceEpoch())};
+                notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
+                QCOMPARE(notInCach.size(), 0);
             }
             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/VisualizationGraphWidget.h +4 0

             #ifndef SCIQLOP_VISUALIZATIONGRAPHWIDGET_H
             #define SCIQLOP_VISUALIZATIONGRAPHWIDGET_H
             #include "Visualization/IVisualizationWidget.h"
             #include <QLoggingCategory>
             #include <QWidget>
             #include <memory>
             #include <Common/spimpl.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationGraphWidget)
             class QCPRange;
+            class SqpDateTime;
             class Variable;
             namespace Ui {
             class VisualizationGraphWidget;
             } // namespace Ui
             class VisualizationGraphWidget : public QWidget, public IVisualizationWidget {
                 Q_OBJECT
             public:
                 explicit VisualizationGraphWidget(const QString &name = {}, QWidget *parent = 0);
                 virtual ~VisualizationGraphWidget();
                 void addVariable(std::shared_ptr<Variable> variable);
                 /// Removes a variable from the graph
                 void removeVariable(std::shared_ptr<Variable> variable) noexcept;
                 // IVisualizationWidget interface
                 void accept(IVisualizationWidgetVisitor *visitor) override;
                 bool canDrop(const Variable &variable) const override;
                 QString name() const override;
                 void updateDisplay(std::shared_ptr<Variable> variable);
+            signals:
+                void requestDataLoading(std::shared_ptr<Variable> variable, const SqpDateTime &dateTime);
             private:
                 Ui::VisualizationGraphWidget *ui;
                 class VisualizationGraphWidgetPrivate;
                 spimpl::unique_impl_ptr<VisualizationGraphWidgetPrivate> impl;
             private slots:
                 /// Slot called when right clicking on the graph (displays a menu)
                 void onGraphMenuRequested(const QPoint &pos) noexcept;
                 void onRangeChanged(const QCPRange &t1, const QCPRange &t2);
                 /// Slot called when a mouse wheel was made, to perform some processing before the zoom is done
                 void onMouseWheel(QWheelEvent *event) noexcept;
                 void onDataCacheVariableUpdated();
             };
             #endif // SCIQLOP_VISUALIZATIONGRAPHWIDGET_H

gui/src/Visualization/VisualizationGraphHelper.cpp +15 -13

             #include "Visualization/VisualizationGraphHelper.h"
             #include "Visualization/qcustomplot.h"
             #include <Data/ScalarSeries.h>
             #include <Variable/Variable.h>
             #include <QElapsedTimer>
             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_VisualizationGraphHelper()) << "The slow s1 operation took" << timer.elapsed()
-                                                            << "milliseconds";
                     // NAIVE approch
                     const auto &xData = scalarSeries.xAxisData()->data();
                     const auto &valuesData = scalarSeries.valuesData()->data();
+                    const auto count = xData.count();
+                    qCInfo(LOG_VisualizationGraphHelper()) << "TORM: Current points in cache" << xData.count();
-                    auto xValue = QVector<double>();
+                    auto xValue = QVector<double>(count);
-                    auto vValue = QVector<double>();
+                    auto vValue = QVector<double>(count);
-                    const auto count = xData.count();
+                    int n = 0;
-                    auto ite = 0;
                     for (auto i = 0; i < count; ++i) {
-                        const auto x = xData.at(i);
+                        const auto x = xData[i];
                         if (x >= dateTime.m_TStart && x <= dateTime.m_TEnd) {
-                            xValue.push_back(x);
+                            xValue[n] = x;
-                            vValue.push_back(valuesData.at(i));
+                            vValue[n] = valuesData[i];
-                            ++ite;
+                            ++n;
                         }
                     }
-                    qcpGraph->setData(xValue, vValue);
+                    xValue.resize(n);
+                    vValue.resize(n);
-                    qCDebug(LOG_VisualizationGraphHelper()) << "The slow s2 operation took" << timer.elapsed()
+                    qCInfo(LOG_VisualizationGraphHelper()) << "TORM: Current points displayed"
-                                                            << "milliseconds";
+                                                           << xValue.count();
+                    qcpGraph->setData(xValue, vValue);
                 }
                 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_VisualizationGraphHelper())
                         << QObject::tr("Can't create graph for the scalar series");
                 }
                 return component;
             }
             } // namespace
             QVector<QCPAbstractPlottable *> VisualizationGraphHelper::create(std::shared_ptr<Variable> variable,
                                                                              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_VisualizationGraphHelper())
                             << QObject::tr("Can't create graph plottables : unmanaged data series type");
                     }
                 }
                 else {
                     qCDebug(LOG_VisualizationGraphHelper())
                         << QObject::tr("Can't create graph plottables : the variable is null");
                 }
                 return result;
             }
             void VisualizationGraphHelper::updateData(QVector<QCPAbstractPlottable *> plotableVect,
                                                       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_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 +5 -6

             #include "Visualization/VisualizationGraphWidget.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::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);
                 ui->graphNameLabel->setText(name);
                 // 'Close' options : widget is deleted when closed
                 setAttribute(Qt::WA_DeleteOnClose);
                 connect(ui->closeButton, &QToolButton::clicked, this, &VisualizationGraphWidget::close);
                 ui->closeButton->setIcon(sqpApp->style()->standardIcon(QStyle::SP_TitleBarCloseButton));
                 // 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);
                 // Activates menu when right clicking on the graph
                 ui->widget->setContextMenuPolicy(Qt::CustomContextMenu);
                 connect(ui->widget, &QCustomPlot::customContextMenuRequested, this,
                         &VisualizationGraphWidget::onGraphMenuRequested);
+                connect(this, &VisualizationGraphWidget::requestDataLoading, &sqpApp->variableController(),
+                        &VariableController::onRequestDataLoading);
             }
             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 = VisualizationGraphHelper::create(variable, *ui->widget);
                 for (auto createdPlottable : qAsConst(createdPlottables)) {
                     impl->m_VariableToPlotMultiMap.insert({variable, createdPlottable});
                 }
-                connect(variable.get(), SIGNAL(dataCacheUpdated()), this, SLOT(onDataCacheVariableUpdated()));
+                connect(variable.get(), SIGNAL(updated()), this, SLOT(onDataCacheVariableUpdated()));
             }
             void VisualizationGraphWidget::removeVariable(std::shared_ptr<Variable> variable) noexcept
             {
                 // Each component associated to the variable :
                 // - is removed from qcpplot (which deletes it)
                 // - is no longer referenced in the map
                 auto componentsIt = impl->m_VariableToPlotMultiMap.equal_range(variable);
                 for (auto it = componentsIt.first; it != componentsIt.second;) {
                     ui->widget->removePlottable(it->second);
                     it = impl->m_VariableToPlotMultiMap.erase(it);
                 }
                 // Updates graph
                 ui->widget->replot();
             }
             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;
             }
             QString VisualizationGraphWidget::name() const
             {
                 return ui->graphNameLabel->text();
             }
             void VisualizationGraphWidget::onGraphMenuRequested(const QPoint &pos) noexcept
             {
                 QMenu graphMenu{};
                 // Iterates on variables (unique keys)
                 for (auto it = impl->m_VariableToPlotMultiMap.cbegin(),
                           end = impl->m_VariableToPlotMultiMap.cend();
                      it != end; it = impl->m_VariableToPlotMultiMap.upper_bound(it->first)) {
                     // 'Remove variable' action
                     graphMenu.addAction(tr("Remove variable %1").arg(it->first->name()),
                                         [ this, var = it->first ]() { removeVariable(var); });
                 }
                 if (!graphMenu.isEmpty()) {
                     graphMenu.exec(mapToGlobal(pos));
                 }
             }
             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;
-                    qCInfo(LOG_VisualizationGraphWidget())
-                        << tr("TORM: VisualizationGraphWidget::onRangeChanged")
-                        << variable->dataSeries()->xAxisData()->size();
                     auto dateTime = SqpDateTime{t2.lower, t2.upper};
                     if (!variable->contains(dateTime)) {
                         auto variableDateTimeWithTolerance = dateTime;
                         if (variable->intersect(dateTime)) {
                             auto variableDateTime = variable->dateTime();
                             if (variableDateTime.m_TStart < dateTime.m_TStart) {
                                 auto diffEndToKeepDelta = dateTime.m_TEnd - variableDateTime.m_TEnd;
                                 dateTime.m_TStart = variableDateTime.m_TStart + diffEndToKeepDelta;
                                 // Tolerance have to be added to the right
                                 // add 10% tolerance for right (end) side
                                 auto tolerance = 0.1 * (dateTime.m_TEnd - dateTime.m_TStart);
                                 variableDateTimeWithTolerance.m_TEnd += tolerance;
                             }
                             if (variableDateTime.m_TEnd > dateTime.m_TEnd) {
                                 auto diffStartToKeepDelta = variableDateTime.m_TStart - dateTime.m_TStart;
                                 dateTime.m_TEnd = variableDateTime.m_TEnd - diffStartToKeepDelta;
                                 // Tolerance have to be added to the left
                                 // add 10% tolerance for left (start) side
                                 auto tolerance = 0.1 * (dateTime.m_TEnd - dateTime.m_TStart);
                                 variableDateTimeWithTolerance.m_TStart -= tolerance;
                             }
                         }
                         else {
                             // add 10% tolerance for each side
                             auto tolerance = 0.1 * (dateTime.m_TEnd - dateTime.m_TStart);
                             variableDateTimeWithTolerance.m_TStart -= tolerance;
                             variableDateTimeWithTolerance.m_TEnd += tolerance;
                         }
                         variable->setDateTime(dateTime);
                         // CHangement detected, we need to ask controller to request data loading
-                        sqpApp->variableController().requestDataLoading(variable,
+                        emit requestDataLoading(variable, variableDateTimeWithTolerance);
-                                                                        variableDateTimeWithTolerance);
                     }
                 }
             }
             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;
                     VisualizationGraphHelper::updateData(QVector<QCPAbstractPlottable *>{} << it->second,
                                                          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);
                 }
                 VisualizationGraphHelper::updateData(abstractPlotableVect, variable->dataSeries(),
                                                      variable->dateTime());
             }

plugins/mockplugin/src/CosinusProvider.cpp +9 -6

             #include "CosinusProvider.h"
             #include <Data/DataProviderParameters.h>
             #include <Data/ScalarSeries.h>
             #include <cmath>
+            #include <QDateTime>
             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
                 for (const auto &dateTime : dateTimeList) {
                     auto scalarSeries = this->retrieveDataSeries(dateTime);
                     emit dataProvided(scalarSeries, dateTime);
                 }
             }
             std::shared_ptr<IDataSeries> CosinusProvider::retrieveDataSeries(const SqpDateTime &dateTime)
             {
+                auto dataIndex = 0;
                 // Gets the timerange from the parameters
-                auto start = dateTime.m_TStart;
+                double freq = 100.0;
-                auto end = dateTime.m_TEnd;
+                double start = dateTime.m_TStart * freq; // 100 htz
+                double end = dateTime.m_TEnd * freq;     // 100 htz
                 // 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));
+                    const auto timeOnFreq = time / freq;
+                    scalarSeries->setData(dataIndex, timeOnFreq, std::cos(timeOnFreq));
                 }
                 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