From db2b1901cd02e7c63968dea3014d2b0485041625 2017-06-26 07:33:57
From: Alexandre Leroux <aleroux@itlink.fr>
Date: 2017-06-26 07:33:57
Subject: [PATCH] Merge branch 'feature/VariableCache' into develop

---

diff --git a/core/include/Data/ArrayData.h b/core/include/Data/ArrayData.h
index b08f0c2..5be205f 100644
--- a/core/include/Data/ArrayData.h
+++ b/core/include/Data/ArrayData.h
@@ -49,6 +49,32 @@ public:
         return m_Data.at(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)
+    {
+        if (!m_Data.empty()) {
+            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;
 };
diff --git a/core/include/Data/DataSeries.h b/core/include/Data/DataSeries.h
index f9de7dc..6232a63 100644
--- a/core/include/Data/DataSeries.h
+++ b/core/include/Data/DataSeries.h
@@ -29,6 +29,15 @@ public:
     /// @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());
+        }
+    }
+
 protected:
     /// Protected ctor (DataSeries is abstract)
     explicit DataSeries(std::shared_ptr<ArrayData<1> > xAxisData, const Unit &xAxisUnit,
diff --git a/core/include/Data/IDataProvider.h b/core/include/Data/IDataProvider.h
index 628d123..5d025cf 100644
--- a/core/include/Data/IDataProvider.h
+++ b/core/include/Data/IDataProvider.h
@@ -5,6 +5,8 @@
 
 #include <QObject>
 
+#include <Data/SqpDateTime.h>
+
 class DataProviderParameters;
 class IDataSeries;
 
@@ -16,14 +18,21 @@ class IDataSeries;
  *
  * @sa IDataSeries
  */
-class IDataProvider {
+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);
+};
 // Required for using shared_ptr in signals/slots
 Q_DECLARE_METATYPE(std::shared_ptr<IDataProvider>)
 
diff --git a/core/include/Data/IDataSeries.h b/core/include/Data/IDataSeries.h
index 26a80a1..bbea31f 100644
--- a/core/include/Data/IDataSeries.h
+++ b/core/include/Data/IDataSeries.h
@@ -1,10 +1,12 @@
 #ifndef SCIQLOP_IDATASERIES_H
 #define SCIQLOP_IDATASERIES_H
 
-#include <QString>
 
 #include <memory>
 
+#include <QObject>
+#include <QString>
+
 template <int Dim>
 class ArrayData;
 
@@ -42,6 +44,11 @@ public:
     virtual Unit xAxisUnit() const = 0;
 
     virtual Unit valuesUnit() const = 0;
+
+    virtual void merge(IDataSeries *dataSeries) = 0;
 };
 
+// Required for using shared_ptr in signals/slots
+Q_DECLARE_METATYPE(std::shared_ptr<IDataSeries>)
+
 #endif // SCIQLOP_IDATASERIES_H
diff --git a/core/include/Data/SqpDateTime.h b/core/include/Data/SqpDateTime.h
index a6d1aa4..7ecec9f 100644
--- a/core/include/Data/SqpDateTime.h
+++ b/core/include/Data/SqpDateTime.h
@@ -1,6 +1,7 @@
 #ifndef SCIQLOP_SQPDATETIME_H
 #define SCIQLOP_SQPDATETIME_H
 
+#include <QObject>
 /**
  * @brief The SqpDateTime struct holds the information of time parameters
  */
@@ -9,6 +10,14 @@ struct SqpDateTime {
     double m_TStart;
     /// End time
     double m_TEnd;
+
+    bool contains(const SqpDateTime &dateTime)
+    {
+        return (m_TStart <= dateTime.m_TStart && m_TEnd >= dateTime.m_TEnd);
+    }
 };
 
+// Required for using shared_ptr in signals/slots
+Q_DECLARE_METATYPE(SqpDateTime)
+
 #endif // SCIQLOP_SQPDATETIME_H
diff --git a/core/include/Variable/Variable.h b/core/include/Variable/Variable.h
index 228202c..c233bde 100644
--- a/core/include/Variable/Variable.h
+++ b/core/include/Variable/Variable.h
@@ -1,29 +1,48 @@
 #ifndef SCIQLOP_VARIABLE_H
 #define SCIQLOP_VARIABLE_H
 
-#include <Common/spimpl.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 {
+class Variable : public QObject {
+
+    Q_OBJECT
+
 public:
-    explicit Variable(const QString &name, const QString &unit, const QString &mission);
+    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;
-
-    void addDataSeries(std::unique_ptr<IDataSeries> dataSeries) 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);
+    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;
diff --git a/core/include/Variable/VariableCacheController.h b/core/include/Variable/VariableCacheController.h
new file mode 100644
index 0000000..edcc65d
--- /dev/null
+++ b/core/include/Variable/VariableCacheController.h
@@ -0,0 +1,33 @@
+#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.
+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
diff --git a/core/include/Variable/VariableController.h b/core/include/Variable/VariableController.h
index 0945b53..603c1e9 100644
--- a/core/include/Variable/VariableController.h
+++ b/core/include/Variable/VariableController.h
@@ -1,11 +1,14 @@
 #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;
@@ -26,6 +29,10 @@ public:
 
     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);
diff --git a/core/include/Variable/VariableModel.h b/core/include/Variable/VariableModel.h
index 140a02a..490f43b 100644
--- a/core/include/Variable/VariableModel.h
+++ b/core/include/Variable/VariableModel.h
@@ -1,11 +1,14 @@
 #ifndef SCIQLOP_VARIABLEMODEL_H
 #define SCIQLOP_VARIABLEMODEL_H
 
-#include <Common/spimpl.h>
+
+#include <Data/SqpDateTime.h>
 
 #include <QAbstractTableModel>
 #include <QLoggingCategory>
 
+#include <Common/spimpl.h>
+
 Q_DECLARE_LOGGING_CATEGORY(LOG_VariableModel)
 
 class IDataSeries;
@@ -21,11 +24,13 @@ public:
     /**
      * Creates a new variable in the model
      * @param name the name of the new variable
+     * @param dateTime the dateTime of the new variable
      * @param defaultDataSeries the default data of the new variable
      * @return the pointer to the new variable
      */
     std::shared_ptr<Variable>
-    createVariable(const QString &name, std::unique_ptr<IDataSeries> defaultDataSeries) noexcept;
+    createVariable(const QString &name, const SqpDateTime &dateTime,
+                   std::unique_ptr<IDataSeries> defaultDataSeries) noexcept;
 
     // /////////////////////////// //
     // QAbstractTableModel methods //
diff --git a/core/src/Variable/Variable.cpp b/core/src/Variable/Variable.cpp
index 544d73d..43864d5 100644
--- a/core/src/Variable/Variable.cpp
+++ b/core/src/Variable/Variable.cpp
@@ -1,21 +1,32 @@
 #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)
-            : m_Name{name}, m_Unit{unit}, m_Mission{mission}, m_DataSeries{nullptr}
+    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)
-        : impl{spimpl::make_unique_impl<VariablePrivate>(name, unit, mission)}
+Variable::Variable(const QString &name, const QString &unit, const QString &mission,
+                   const SqpDateTime &dateTime)
+        : impl{spimpl::make_unique_impl<VariablePrivate>(name, unit, mission, dateTime)}
 {
 }
 
@@ -34,15 +45,45 @@ QString Variable::unit() const noexcept
     return impl->m_Unit;
 }
 
-void Variable::addDataSeries(std::unique_ptr<IDataSeries> dataSeries) noexcept
+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);
     }
-    /// @todo : else, merge the two data series (if possible)
+}
+
+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)
+{
+    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;
+}
diff --git a/core/src/Variable/VariableCacheController.cpp b/core/src/Variable/VariableCacheController.cpp
new file mode 100644
index 0000000..63209ce
--- /dev/null
+++ b/core/src/Variable/VariableCacheController.cpp
@@ -0,0 +1,173 @@
+#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>()}
+{
+}
+
+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);
+    }
+    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);
+    }
+}
diff --git a/core/src/Variable/VariableController.cpp b/core/src/Variable/VariableController.cpp
index ccd7a5c..54124b6 100644
--- a/core/src/Variable/VariableController.cpp
+++ b/core/src/Variable/VariableController.cpp
@@ -1,3 +1,5 @@
+#include <Variable/Variable.h>
+#include <Variable/VariableCacheController.h>
 #include <Variable/VariableController.h>
 #include <Variable/VariableModel.h>
 
@@ -7,9 +9,12 @@
 #include <Time/TimeController.h>
 
 #include <QDateTime>
+#include <QElapsedTimer>
 #include <QMutex>
 #include <QThread>
 
+#include <unordered_map>
+
 Q_LOGGING_CATEGORY(LOG_VariableController, "VariableController")
 
 namespace {
@@ -28,7 +33,9 @@ std::unique_ptr<IDataSeries> generateDefaultDataSeries(const IDataProvider &prov
 
 struct VariableController::VariableControllerPrivate {
     explicit VariableControllerPrivate(VariableController *parent)
-            : m_WorkingMutex{}, m_VariableModel{new VariableModel{parent}}
+            : m_WorkingMutex{},
+              m_VariableModel{new VariableModel{parent}},
+              m_VariableCacheController{std::make_unique<VariableCacheController>()}
     {
     }
 
@@ -36,7 +43,12 @@ struct VariableController::VariableControllerPrivate {
     /// 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)
@@ -66,13 +78,6 @@ void VariableController::setTimeController(TimeController *timeController) noexc
 void VariableController::createVariable(const QString &name,
                                         std::shared_ptr<IDataProvider> provider) noexcept
 {
-    // TORM
-    //    auto dateTime = SqpDateTime{
-    //        // Remarks : we don't use toSecsSinceEpoch() here (method is for Qt 5.8 or above)
-    //        static_cast<double>(QDateTime{QDate{2017, 01, 01}, QTime{12, 00}}.toMSecsSinceEpoch()
-    //                            / 1000.),
-    //        static_cast<double>(QDateTime{QDate{2017, 01, 01}, QTime{12, 01}}.toMSecsSinceEpoch())
-    //            / 1000.};
 
     if (!impl->m_TimeController) {
         qCCritical(LOG_VariableController())
@@ -86,12 +91,61 @@ void VariableController::createVariable(const QString &name,
     /// 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, generateDefaultDataSeries(*provider, impl->m_TimeController->dateTime()))) {
+            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()
+                                         << "milliseconds";
+        auto dateTimeListNotInCache
+            = impl->m_VariableCacheController->provideNotInCacheDateTimeList(variable, dateTime);
+        qCInfo(LOG_VariableController()) << "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()
+                                         << "milliseconds";
+
+        // store in cache
+        impl->m_VariableCacheController->addDateTime(variable, dateTime);
+        qCInfo(LOG_VariableController()) << "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();
diff --git a/core/src/Variable/VariableModel.cpp b/core/src/Variable/VariableModel.cpp
index 25edb92..601f3cb 100644
--- a/core/src/Variable/VariableModel.cpp
+++ b/core/src/Variable/VariableModel.cpp
@@ -26,16 +26,16 @@ VariableModel::VariableModel(QObject *parent)
 }
 
 std::shared_ptr<Variable>
-VariableModel::createVariable(const QString &name,
+VariableModel::createVariable(const QString &name, const SqpDateTime &dateTime,
                               std::unique_ptr<IDataSeries> defaultDataSeries) noexcept
 {
     auto insertIndex = rowCount();
     beginInsertRows({}, insertIndex, insertIndex);
 
     /// @todo For the moment, the other data of the variable is initialized with default values
-    auto variable
-        = std::make_shared<Variable>(name, QStringLiteral("unit"), QStringLiteral("mission"));
-    variable->addDataSeries(std::move(defaultDataSeries));
+    auto variable = std::make_shared<Variable>(name, QStringLiteral("unit"),
+                                               QStringLiteral("mission"), dateTime);
+    variable->setDataSeries(std::move(defaultDataSeries));
 
     impl->m_Variables.push_back(variable);
 
diff --git a/core/tests/Variable/TestVariableCacheController.cpp b/core/tests/Variable/TestVariableCacheController.cpp
new file mode 100644
index 0000000..ab5e726
--- /dev/null
+++ b/core/tests/Variable/TestVariableCacheController.cpp
@@ -0,0 +1,343 @@
+#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();
+    QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
+    QCOMPARE(notInCashSqp.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();
+    QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
+    QCOMPARE(notInCashSqp.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();
+    QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
+    QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(ts0.toMSecsSinceEpoch()));
+
+    notInCashSqp = notInCach.at(1);
+    QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(te0.toMSecsSinceEpoch()));
+    QCOMPARE(notInCashSqp.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();
+    QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
+    QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(ts0.toMSecsSinceEpoch()));
+
+    notInCashSqp = notInCach.at(1);
+    QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(te0.toMSecsSinceEpoch()));
+    QCOMPARE(notInCashSqp.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();
+    QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
+    QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(ts0.toMSecsSinceEpoch()));
+
+    notInCashSqp = notInCach.at(1);
+    QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(te0.toMSecsSinceEpoch()));
+    QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(ts1.toMSecsSinceEpoch()));
+
+    notInCashSqp = notInCach.at(2);
+    QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(te1.toMSecsSinceEpoch()));
+    QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(ts2.toMSecsSinceEpoch()));
+
+    notInCashSqp = notInCach.at(3);
+    QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(te2.toMSecsSinceEpoch()));
+    QCOMPARE(notInCashSqp.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();
+    QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
+    QCOMPARE(notInCashSqp.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();
+    QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(te0.toMSecsSinceEpoch()));
+    QCOMPARE(notInCashSqp.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();
+    QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(te0.toMSecsSinceEpoch()));
+    QCOMPARE(notInCashSqp.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();
+    QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(te0.toMSecsSinceEpoch()));
+    QCOMPARE(notInCashSqp.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();
+    QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
+    QCOMPARE(notInCashSqp.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();
+    QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
+    QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(ts1.toMSecsSinceEpoch()));
+
+    notInCashSqp = notInCach.at(1);
+    QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(te1.toMSecsSinceEpoch()));
+    QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(ts2.toMSecsSinceEpoch()));
+
+    notInCashSqp = notInCach.at(2);
+    QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(te2.toMSecsSinceEpoch()));
+    QCOMPARE(notInCashSqp.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();
+    QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
+    QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(ts1.toMSecsSinceEpoch()));
+
+    notInCashSqp = notInCach.at(1);
+    QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(te1.toMSecsSinceEpoch()));
+    QCOMPARE(notInCashSqp.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"
diff --git a/formatting/cmake/use_clangformat.cmake b/formatting/cmake/use_clangformat.cmake
index 7545eb7..8daefc7 100644
--- a/formatting/cmake/use_clangformat.cmake
+++ b/formatting/cmake/use_clangformat.cmake
@@ -63,6 +63,7 @@ FUNCTION(ADD_CLANGFORMAT_TARGETS)
         clangformat_incr(i)
     ENDWHILE()
     
+
     # Retrieve source files to format
     IF(recurse)
         FILE(GLOB_RECURSE srcs ${globs})
@@ -81,6 +82,16 @@ FUNCTION(ADD_CLANGFORMAT_TARGETS)
     # Create the directory where the touched files will be saved
     SET(formatDirectory "${CMAKE_CURRENT_BINARY_DIR}/format")
     FILE(MAKE_DIRECTORY ${formatDirectory})
+#    STRING(REPLACE "*.ui" "" srcs ${srcs})
+    FOREACH(item ${globs})
+      STRING(REGEX MATCH ".*\.ui$" item ${item})
+      IF(item)
+        LIST(APPEND UIS ${item})
+      ENDIF(item)
+    ENDFOREACH(item ${globs})
+
+    LIST(REMOVE_ITEM srcs ${UIS})
+    message("format lang: ${srcs}" )
     FOREACH (s ${srcs})
         SET(touchedFile ${formatDirectory}/format_touchedfile_${reportNb})
         IF(addToAll)
diff --git a/gui/include/DataSource/DataSourceWidget.h b/gui/include/DataSource/DataSourceWidget.h
index 4134f86..84e09dd 100644
--- a/gui/include/DataSource/DataSourceWidget.h
+++ b/gui/include/DataSource/DataSourceWidget.h
@@ -18,6 +18,7 @@ class DataSourceWidget : public QWidget {
 
 public:
     explicit DataSourceWidget(QWidget *parent = 0);
+    virtual ~DataSourceWidget() noexcept;
 
 public slots:
     /**
diff --git a/gui/include/Visualization/GraphPlottablesFactory.h b/gui/include/Visualization/GraphPlottablesFactory.h
index deaa485..35126e5 100644
--- a/gui/include/Visualization/GraphPlottablesFactory.h
+++ b/gui/include/Visualization/GraphPlottablesFactory.h
@@ -1,6 +1,8 @@
 #ifndef SCIQLOP_GRAPHPLOTTABLESFACTORY_H
 #define SCIQLOP_GRAPHPLOTTABLESFACTORY_H
 
+#include <Data/SqpDateTime.h>
+
 #include <QLoggingCategory>
 #include <QVector>
 
@@ -8,6 +10,7 @@
 
 Q_DECLARE_LOGGING_CATEGORY(LOG_GraphPlottablesFactory)
 
+class IDataSeries;
 class QCPAbstractPlottable;
 class QCustomPlot;
 class Variable;
@@ -27,6 +30,9 @@ struct GraphPlottablesFactory {
      */
     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
diff --git a/gui/include/Visualization/VisualizationGraphWidget.h b/gui/include/Visualization/VisualizationGraphWidget.h
index 33998b0..d23cbc5 100644
--- a/gui/include/Visualization/VisualizationGraphWidget.h
+++ b/gui/include/Visualization/VisualizationGraphWidget.h
@@ -12,6 +12,7 @@
 
 Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationGraphWidget)
 
+class QCPRange;
 class Variable;
 
 namespace Ui {
@@ -33,6 +34,9 @@ public:
     void close() override;
     QString name() const override;
 
+    void updateDisplay(std::shared_ptr<Variable> variable);
+
+
 private:
     Ui::VisualizationGraphWidget *ui;
 
@@ -40,8 +44,13 @@ private:
     spimpl::unique_impl_ptr<VisualizationGraphWidgetPrivate> impl;
 
 private slots:
+
+    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
diff --git a/gui/src/DataSource/DataSourceWidget.cpp b/gui/src/DataSource/DataSourceWidget.cpp
index 0209719..67bcf4a 100644
--- a/gui/src/DataSource/DataSourceWidget.cpp
+++ b/gui/src/DataSource/DataSourceWidget.cpp
@@ -49,6 +49,11 @@ DataSourceWidget::DataSourceWidget(QWidget *parent) : QWidget{parent}, ui{new Ui
             &DataSourceWidget::onTreeMenuRequested);
 }
 
+DataSourceWidget::~DataSourceWidget() noexcept
+{
+    delete ui;
+}
+
 void DataSourceWidget::addDataSource(DataSourceItem *dataSource) noexcept
 {
     // Creates the item associated to the source and adds it to the tree widget. The tree widget
diff --git a/gui/src/Visualization/GraphPlottablesFactory.cpp b/gui/src/Visualization/GraphPlottablesFactory.cpp
index ab384a9..3748d8f 100644
--- a/gui/src/Visualization/GraphPlottablesFactory.cpp
+++ b/gui/src/Visualization/GraphPlottablesFactory.cpp
@@ -5,6 +5,8 @@
 
 #include <Variable/Variable.h>
 
+#include <QElapsedTimer>
+
 Q_LOGGING_CATEGORY(LOG_GraphPlottablesFactory, "GraphPlottablesFactory")
 
 namespace {
@@ -28,15 +30,55 @@ QSharedPointer<QCPAxisTicker> axisTicker(bool isTimeAxis)
     }
 }
 
-QCPAbstractPlottable *createScalarSeriesComponent(ScalarSeries &scalarSeries, QCustomPlot &plot)
+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()
+                                              << "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()
+                                              << "milliseconds";
+    }
+    else {
+        /// @todo DEBUG
+    }
+}
+
+QCPAbstractPlottable *createScalarSeriesComponent(ScalarSeries &scalarSeries, QCustomPlot &plot,
+                                                  const SqpDateTime &dateTime)
 {
     auto component = plot.addGraph();
 
     if (component) {
-        // Graph data
+        //        // 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
@@ -75,7 +117,7 @@ QVector<QCPAbstractPlottable *> GraphPlottablesFactory::create(std::shared_ptr<V
         // 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));
+            result.append(createScalarSeriesComponent(*scalarSeries, plot, variable->dateTime()));
         }
         else {
             qCDebug(LOG_GraphPlottablesFactory())
@@ -89,3 +131,21 @@ QVector<QCPAbstractPlottable *> GraphPlottablesFactory::create(std::shared_ptr<V
 
     return result;
 }
+
+void GraphPlottablesFactory::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_GraphPlottablesFactory()) << QObject::tr(
+                "Can't update Data of a scalarSeries because there is not only one component "
+                "associated");
+        }
+    }
+    else {
+        /// @todo DEBUG
+    }
+}
diff --git a/gui/src/Visualization/VisualizationGraphWidget.cpp b/gui/src/Visualization/VisualizationGraphWidget.cpp
index ee02cb7..c60b0f4 100644
--- a/gui/src/Visualization/VisualizationGraphWidget.cpp
+++ b/gui/src/Visualization/VisualizationGraphWidget.cpp
@@ -3,7 +3,11 @@
 #include "Visualization/IVisualizationWidgetVisitor.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>
 
@@ -22,7 +26,8 @@ const auto VERTICAL_ZOOM_MODIFIER = Qt::ControlModifier;
 struct VisualizationGraphWidget::VisualizationGraphWidgetPrivate {
 
     // 1 variable -> n qcpplot
-    std::unordered_map<std::shared_ptr<Variable>, QCPAbstractPlottable *> m_VariableToPlotMap;
+    std::unordered_multimap<std::shared_ptr<Variable>, QCPAbstractPlottable *>
+        m_VariableToPlotMultiMap;
 };
 
 VisualizationGraphWidget::VisualizationGraphWidget(const QString &name, QWidget *parent)
@@ -42,8 +47,12 @@ VisualizationGraphWidget::VisualizationGraphWidget(const QString &name, QWidget 
     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;
@@ -55,8 +64,10 @@ void VisualizationGraphWidget::addVariable(std::shared_ptr<Variable> variable)
     auto createdPlottables = GraphPlottablesFactory::create(variable, *ui->widget);
 
     for (auto createdPlottable : qAsConst(createdPlottables)) {
-        impl->m_VariableToPlotMap.insert({variable, createdPlottable});
+        impl->m_VariableToPlotMultiMap.insert({variable, createdPlottable});
     }
+
+    connect(variable.get(), SIGNAL(dataCacheUpdated()), this, SLOT(onDataCacheVariableUpdated()));
 }
 
 void VisualizationGraphWidget::accept(IVisualizationWidgetVisitor *visitor)
@@ -93,6 +104,25 @@ QString VisualizationGraphWidget::name() const
     }
 }
 
+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>{};
@@ -109,3 +139,27 @@ void VisualizationGraphWidget::onMouseWheel(QWheelEvent *event) noexcept
 
     ui->widget->axisRect()->setRangeZoom(zoomOrientations);
 }
+
+void VisualizationGraphWidget::onDataCacheVariableUpdated()
+{
+    for (auto it = impl->m_VariableToPlotMultiMap.cbegin();
+         it != impl->m_VariableToPlotMultiMap.cend(); ++it) {
+        auto variable = it->first;
+        GraphPlottablesFactory::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);
+    }
+
+    GraphPlottablesFactory::updateData(abstractPlotableVect, variable->dataSeries(),
+                                       variable->dateTime());
+}
diff --git a/plugins/mockplugin/include/CosinusProvider.h b/plugins/mockplugin/include/CosinusProvider.h
index cc48a53..218623a 100644
--- a/plugins/mockplugin/include/CosinusProvider.h
+++ b/plugins/mockplugin/include/CosinusProvider.h
@@ -3,6 +3,10 @@
 
 #include <Data/IDataProvider.h>
 
+#include <QLoggingCategory>
+
+Q_DECLARE_LOGGING_CATEGORY(LOG_CosinusProvider)
+
 /**
  * @brief The CosinusProvider class is an example of how a data provider can generate data
  */
@@ -11,6 +15,12 @@ public:
     /// @sa IDataProvider::retrieveData()
     std::unique_ptr<IDataSeries>
     retrieveData(const DataProviderParameters &parameters) const override;
+
+    void requestDataLoading(const QVector<SqpDateTime> &dateTimeList) override;
+
+
+private:
+    std::shared_ptr<IDataSeries> retrieveDataSeries(const SqpDateTime &dateTime);
 };
 
 #endif // SCIQLOP_COSINUSPROVIDER_H
diff --git a/plugins/mockplugin/src/CosinusProvider.cpp b/plugins/mockplugin/src/CosinusProvider.cpp
index 44e159c..d142c18 100644
--- a/plugins/mockplugin/src/CosinusProvider.cpp
+++ b/plugins/mockplugin/src/CosinusProvider.cpp
@@ -5,6 +5,8 @@
 
 #include <cmath>
 
+Q_LOGGING_CATEGORY(LOG_CosinusProvider, "CosinusProvider")
+
 std::unique_ptr<IDataSeries>
 CosinusProvider::retrieveData(const DataProviderParameters &parameters) const
 {
@@ -30,3 +32,40 @@ CosinusProvider::retrieveData(const DataProviderParameters &parameters) const
 
     return scalarSeries;
 }
+
+void CosinusProvider::requestDataLoading(const QVector<SqpDateTime> &dateTimeList)
+{
+    // NOTE: Try to use multithread if possible
+    foreach (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;
+}