HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r512:d00d6fd96c10

Change SqpRange for SqpDateTime

perrinel -

r512:d00d6fd96c10

parent child

Context file:

r512:d00d6fd96c10

app/src/MainWindow.cpp +6 -6

              /*------------------------------------------------------------------------------
              -- This file is a part of the SciQLop Software
              -- Copyright (C) 2017, Plasma Physics Laboratory - CNRS
              --
              -- This program is free software; you can redistribute it and/or modify
              -- it under the terms of the GNU General Public License as published by
              -- the Free Software Foundation; either version 2 of the License, or
              -- (at your option) any later version.
              --
              -- This program is distributed in the hope that it will be useful,
              -- but WITHOUT ANY WARRANTY; without even the implied warranty of
              -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
              -- GNU General Public License for more details.
              --
              -- You should have received a copy of the GNU General Public License
              -- along with this program; if not, write to the Free Software
              -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
              -------------------------------------------------------------------------------*/
              /*-- Author : Alexis Jeandet
              -- Mail : alexis.jeandet@member.fsf.org
              ----------------------------------------------------------------------------*/
              #include "MainWindow.h"
              #include "ui_MainWindow.h"
              #include <DataSource/DataSourceController.h>
              #include <DataSource/DataSourceWidget.h>
              #include <Settings/SqpSettingsDialog.h>
              #include <Settings/SqpSettingsGeneralWidget.h>
              #include <SidePane/SqpSidePane.h>
              #include <SqpApplication.h>
              #include <Time/TimeController.h>
              #include <TimeWidget/TimeWidget.h>
              #include <Variable/Variable.h>
              #include <Variable/VariableController.h>
              #include <Visualization/VisualizationController.h>
              #include <QAction>
              #include <QDate>
              #include <QDir>
              #include <QFileDialog>
              #include <QToolBar>
              #include <QToolButton>
              #include <memory.h>
              #include "iostream"
              Q_LOGGING_CATEGORY(LOG_MainWindow, "MainWindow")
              namespace {
              const auto LEFTMAININSPECTORWIDGETSPLITTERINDEX = 0;
              const auto LEFTINSPECTORSIDEPANESPLITTERINDEX = 1;
              const auto VIEWPLITTERINDEX = 2;
              const auto RIGHTINSPECTORSIDEPANESPLITTERINDEX = 3;
              const auto RIGHTMAININSPECTORWIDGETSPLITTERINDEX = 4;
              }
              class MainWindow::MainWindowPrivate {
              public:
                  explicit MainWindowPrivate(MainWindow *mainWindow)
                          : m_LastOpenLeftInspectorSize{},
                            m_LastOpenRightInspectorSize{},
                            m_GeneralSettingsWidget{new SqpSettingsGeneralWidget{mainWindow}},
                            m_SettingsDialog{new SqpSettingsDialog{mainWindow}}
                  {
                  }
                  QSize m_LastOpenLeftInspectorSize;
                  QSize m_LastOpenRightInspectorSize;
                  /// General settings widget. MainWindow has the ownership
                  SqpSettingsGeneralWidget *m_GeneralSettingsWidget;
                  /// Settings dialog. MainWindow has the ownership
                  SqpSettingsDialog *m_SettingsDialog;
              };
              MainWindow::MainWindow(QWidget *parent)
                      : QMainWindow{parent},
                        m_Ui{new Ui::MainWindow},
                        impl{spimpl::make_unique_impl<MainWindowPrivate>(this)}
              {
                  m_Ui->setupUi(this);
                  m_Ui->splitter->setCollapsible(LEFTINSPECTORSIDEPANESPLITTERINDEX, false);
                  m_Ui->splitter->setCollapsible(RIGHTINSPECTORSIDEPANESPLITTERINDEX, false);
                  auto leftSidePane = m_Ui->leftInspectorSidePane->sidePane();
                  auto openLeftInspectorAction = new QAction{QIcon{
                                                                 ":/icones/previous.png",
                                                             },
                                                             tr("Show/hide the left inspector"), this};
                  auto spacerLeftTop = new QWidget{};
                  spacerLeftTop->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                  auto spacerLeftBottom = new QWidget{};
                  spacerLeftBottom->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                  leftSidePane->addWidget(spacerLeftTop);
                  leftSidePane->addAction(openLeftInspectorAction);
                  leftSidePane->addWidget(spacerLeftBottom);
                  auto rightSidePane = m_Ui->rightInspectorSidePane->sidePane();
                  auto openRightInspectorAction = new QAction{QIcon{
                                                                  ":/icones/next.png",
                                                              },
                                                              tr("Show/hide the right inspector"), this};
                  auto spacerRightTop = new QWidget{};
                  spacerRightTop->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                  auto spacerRightBottom = new QWidget{};
                  spacerRightBottom->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                  rightSidePane->addWidget(spacerRightTop);
                  rightSidePane->addAction(openRightInspectorAction);
                  rightSidePane->addWidget(spacerRightBottom);
                  openLeftInspectorAction->setCheckable(true);
                  openRightInspectorAction->setCheckable(true);
                  auto openInspector = [this](bool checked, bool right, auto action) {
                      action->setIcon(QIcon{(checked xor right) ? ":/icones/next.png" : ":/icones/previous.png"});
                      auto &lastInspectorSize
                          = right ? impl->m_LastOpenRightInspectorSize : impl->m_LastOpenLeftInspectorSize;
                      auto nextInspectorSize = right ? m_Ui->rightMainInspectorWidget->size()
                                                     : m_Ui->leftMainInspectorWidget->size();
                      // Update of the last opened geometry
                      if (checked) {
                          lastInspectorSize = nextInspectorSize;
                      }
                      auto startSize = lastInspectorSize;
                      auto endSize = startSize;
                      endSize.setWidth(0);
                      auto splitterInspectorIndex
                          = right ? RIGHTMAININSPECTORWIDGETSPLITTERINDEX : LEFTMAININSPECTORWIDGETSPLITTERINDEX;
                      auto currentSizes = m_Ui->splitter->sizes();
                      if (checked) {
                          // adjust sizes individually here, e.g.
                          currentSizes[splitterInspectorIndex] -= lastInspectorSize.width();
                          currentSizes[VIEWPLITTERINDEX] += lastInspectorSize.width();
                          m_Ui->splitter->setSizes(currentSizes);
                      }
                      else {
                          // adjust sizes individually here, e.g.
                          currentSizes[splitterInspectorIndex] += lastInspectorSize.width();
                          currentSizes[VIEWPLITTERINDEX] -= lastInspectorSize.width();
                          m_Ui->splitter->setSizes(currentSizes);
                      }
                  };
                  connect(openLeftInspectorAction, &QAction::triggered,
                          [openInspector, openLeftInspectorAction](bool checked) {
                              openInspector(checked, false, openLeftInspectorAction);
                          });
                  connect(openRightInspectorAction, &QAction::triggered,
                          [openInspector, openRightInspectorAction](bool checked) {
                              openInspector(checked, true, openRightInspectorAction);
                          });
                  // //// //
                  // Menu //
                  // //// //
                  this->menuBar()->addAction(tr("File"));
                  auto toolsMenu = this->menuBar()->addMenu(tr("Tools"));
                  toolsMenu->addAction(tr("Settings..."), [this]() {
                      // Loads settings
                      impl->m_SettingsDialog->loadSettings();
                      // Open settings dialog and save settings if the dialog is accepted
                      if (impl->m_SettingsDialog->exec() == QDialog::Accepted) {
                          impl->m_SettingsDialog->saveSettings();
                      }
                  });
                  auto mainToolBar = this->addToolBar(QStringLiteral("MainToolBar"));
                  auto timeWidget = new TimeWidget{};
                  mainToolBar->addWidget(timeWidget);
                  // //////// //
                  // Settings //
                  // //////// //
                  // Registers "general settings" widget to the settings dialog
                  impl->m_SettingsDialog->registerWidget(QStringLiteral("General"),
                                                         impl->m_GeneralSettingsWidget);
                  // /////////// //
                  // Connections //
                  // /////////// //
                  // Controllers / controllers connections
-                 connect(&sqpApp->timeController(), SIGNAL(timeUpdated(SqpDateTime)),
-                         &sqpApp->variableController(), SLOT(onDateTimeOnSelection(SqpDateTime)));
+                 connect(&sqpApp->timeController(), SIGNAL(timeUpdated(SqpRange)), &sqpApp->variableController(),
+                         SLOT(onDateTimeOnSelection(SqpRange)));
                  // Widgets / controllers connections
                  // DataSource
                  connect(&sqpApp->dataSourceController(), SIGNAL(dataSourceItemSet(DataSourceItem *)),
                          m_Ui->dataSourceWidget, SLOT(addDataSource(DataSourceItem *)));
                  // Time
-                 connect(timeWidget, SIGNAL(timeUpdated(SqpDateTime)), &sqpApp->timeController(),
-                         SLOT(onTimeToUpdate(SqpDateTime)));
+                 connect(timeWidget, SIGNAL(timeUpdated(SqpRange)), &sqpApp->timeController(),
+                         SLOT(onTimeToUpdate(SqpRange)));
                  // Visualization
                  connect(&sqpApp->visualizationController(),
                          SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)), m_Ui->view,
                          SLOT(onVariableAboutToBeDeleted(std::shared_ptr<Variable>)));
                  connect(&sqpApp->visualizationController(),
-                         SIGNAL(rangeChanged(std::shared_ptr<Variable>, const SqpDateTime &)), m_Ui->view,
-                         SLOT(onRangeChanged(std::shared_ptr<Variable>, const SqpDateTime &)));
+                         SIGNAL(rangeChanged(std::shared_ptr<Variable>, const SqpRange &)), m_Ui->view,
+                         SLOT(onRangeChanged(std::shared_ptr<Variable>, const SqpRange &)));
                  // Widgets / widgets connections
                  // For the following connections, we use DirectConnection to allow each widget that can
                  // potentially attach a menu to the variable's menu to do so before this menu is displayed.
                  // The order of connections is also important, since it determines the order in which each
                  // widget will attach its menu
                  connect(
                      m_Ui->variableInspectorWidget,
                      SIGNAL(tableMenuAboutToBeDisplayed(QMenu *, const QVector<std::shared_ptr<Variable> > &)),
                      m_Ui->view, SLOT(attachVariableMenu(QMenu *, const QVector<std::shared_ptr<Variable> > &)),
                      Qt::DirectConnection);
              }
              MainWindow::~MainWindow()
              {
              }
              void MainWindow::changeEvent(QEvent *e)
              {
                  QMainWindow::changeEvent(e);
                  switch (e->type()) {
                      case QEvent::LanguageChange:
                          m_Ui->retranslateUi(this);
                          break;
                      default:
                          break;
                  }
              }

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

              #ifndef SCIQLOP_DATAPROVIDERPARAMETERS_H
              #define SCIQLOP_DATAPROVIDERPARAMETERS_H
-             #include "SqpDateTime.h"
+             #include "SqpRange.h"
              /**
               * @brief The DataProviderParameters struct holds the information needed to retrieve data from a
               * data provider
               * @sa IDataProvider
               */
              struct DataProviderParameters {
                  /// Times for which retrieve data
-                 QVector<SqpDateTime> m_Times;
+                 QVector<SqpRange> m_Times;
                  /// Extra data that can be used by the provider to retrieve data
                  QVariantHash m_Data;
              };
              #endif // SCIQLOP_DATAPROVIDERPARAMETERS_H

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

              #ifndef SCIQLOP_IDATAPROVIDER_H
              #define SCIQLOP_IDATAPROVIDER_H
              #include "CoreGlobal.h"
              #include <memory>
              #include <QObject>
              #include <QUuid>
              #include <Common/MetaTypes.h>
-             #include <Data/SqpDateTime.h>
+             #include <Data/SqpRange.h>
              #include <functional>
              class DataProviderParameters;
              class IDataSeries;
              class QNetworkReply;
              class QNetworkRequest;
              /**
               * @brief The IDataProvider interface aims to declare a data provider.
               *
               * A data provider is an entity that generates data and returns it according to various parameters
               * (time interval, product to retrieve the data, etc.)
               *
               * @sa IDataSeries
               */
              class SCIQLOP_CORE_EXPORT IDataProvider : public QObject {
                  Q_OBJECT
              public:
                  virtual ~IDataProvider() noexcept = default;
                  /**
                   * @brief requestDataLoading provide datas for the data identified by identifier and parameters
                   */
                  virtual void requestDataLoading(QUuid identifier, const DataProviderParameters &parameters) = 0;
                  /**
                   * @brief requestDataAborting stop data loading of the data identified by identifier
                   */
                  virtual void requestDataAborting(QUuid identifier) = 0;
              signals:
                  /**
                   * @brief dataProvided send dataSeries under dateTime and that corresponds of the data
                   * identified by identifier
                   */
                  void dataProvided(QUuid identifier, std::shared_ptr<IDataSeries> dateSerie,
-                                   const SqpDateTime &dateTime);
+                                   const SqpRange &dateTime);
                  /**
                      * @brief dataProvided send dataSeries under dateTime and that corresponds of the data
                      * identified by identifier
                      */
                  void dataProvidedProgress(QUuid identifier, double progress);
                  /**
                   * @brief requestConstructed send a request for the data identified by identifier
                   * @callback is the methode call by the reply of the request when it is finished.
                   */
                  void requestConstructed(const QNetworkRequest &request, QUuid identifier,
                                          std::function<void(QNetworkReply *, QUuid)> callback);
              };
              // Required for using shared_ptr in signals/slots
              SCIQLOP_REGISTER_META_TYPE(IDATAPROVIDER_PTR_REGISTRY, std::shared_ptr<IDataProvider>)
              SCIQLOP_REGISTER_META_TYPE(IDATAPROVIDER_FUNCTION_REGISTRY,
                                         std::function<void(QNetworkReply *, QUuid)>)
              #endif // SCIQLOP_IDATAPROVIDER_H

core/include/Time/TimeController.h +4 -4

              #ifndef SCIQLOP_TIMECONTROLLER_H
              #define SCIQLOP_TIMECONTROLLER_H
              #include "CoreGlobal.h"
-             #include <Data/SqpDateTime.h>
+             #include <Data/SqpRange.h>
              #include <QLoggingCategory>
              #include <QObject>
              #include <Common/spimpl.h>
              Q_DECLARE_LOGGING_CATEGORY(LOG_TimeController)
              /**
               * @brief The TimeController class aims to handle the Time parameters notification in SciQlop.
               */
              class SCIQLOP_CORE_EXPORT TimeController : public QObject {
                  Q_OBJECT
              public:
                  explicit TimeController(QObject *parent = 0);
-                 SqpDateTime dateTime() const noexcept;
+                 SqpRange dateTime() const noexcept;
              signals:
                  /// Signal emitted to notify that time parameters has beed updated
-                 void timeUpdated(SqpDateTime time);
+                 void timeUpdated(SqpRange time);
              public slots:
                  /// Slot called when a new dateTime has been defined.
-                 void onTimeToUpdate(SqpDateTime dateTime);
+                 void onTimeToUpdate(SqpRange dateTime);
                  /// Slot called when the dateTime has to be notified. Call timeUpdated signal
                  void onTimeNotify();
              private:
                  class TimeControllerPrivate;
                  spimpl::unique_impl_ptr<TimeControllerPrivate> impl;
              };
              #endif // SCIQLOP_TIMECONTROLLER_H

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

              #ifndef SCIQLOP_VARIABLE_H
              #define SCIQLOP_VARIABLE_H
              #include "CoreGlobal.h"
-             #include <Data/SqpDateTime.h>
+             #include <Data/SqpRange.h>
              #include <QLoggingCategory>
              #include <QObject>
              #include <Common/MetaTypes.h>
              #include <Common/spimpl.h>
              Q_DECLARE_LOGGING_CATEGORY(LOG_Variable)
              class IDataSeries;
              class QString;
              /**
               * @brief The Variable class represents a variable in SciQlop.
               */
              class SCIQLOP_CORE_EXPORT Variable : public QObject {
                  Q_OBJECT
              public:
-                 explicit Variable(const QString &name, const SqpDateTime &dateTime,
+                 explicit Variable(const QString &name, const SqpRange &dateTime,
                                    const QVariantHash &metadata = {});
                  QString name() const noexcept;
-                 SqpDateTime dateTime() const noexcept;
-                 void setDateTime(const SqpDateTime &dateTime) noexcept;
+                 SqpRange dateTime() const noexcept;
+                 void setDateTime(const SqpRange &dateTime) noexcept;
                  /// @return the data of the variable, nullptr if there is no data
                  IDataSeries *dataSeries() const noexcept;
                  QVariantHash metadata() const noexcept;
-                 bool contains(const SqpDateTime &dateTime) const noexcept;
-                 bool intersect(const SqpDateTime &dateTime) const noexcept;
-                 bool isInside(const SqpDateTime &dateTime) const noexcept;
+                 bool contains(const SqpRange &dateTime) const noexcept;
+                 bool intersect(const SqpRange &dateTime) const noexcept;
+                 bool isInside(const SqpRange &dateTime) const noexcept;
              public slots:
                  void setDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept;
              signals:
                  void updated();
              private:
                  class VariablePrivate;
                  spimpl::unique_impl_ptr<VariablePrivate> impl;
              };
              // Required for using shared_ptr in signals/slots
              SCIQLOP_REGISTER_META_TYPE(VARIABLE_PTR_REGISTRY, std::shared_ptr<Variable>)
              #endif // SCIQLOP_VARIABLE_H

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

              #ifndef SCIQLOP_VARIABLECACHECONTROLLER_H
              #define SCIQLOP_VARIABLECACHECONTROLLER_H
              #include "CoreGlobal.h"
              #include <QLoggingCategory>
              #include <QObject>
-             #include <Data/SqpDateTime.h>
+             #include <Data/SqpRange.h>
              #include <QLoggingCategory>
              #include <Common/spimpl.h>
              Q_DECLARE_LOGGING_CATEGORY(LOG_VariableCacheController)
              class Variable;
              /// This class aims to store in the cache all of the dateTime already requested to the variable.
              class SCIQLOP_CORE_EXPORT VariableCacheController : public QObject {
                  Q_OBJECT
              public:
                  explicit VariableCacheController(QObject *parent = 0);
-                 void addDateTime(std::shared_ptr<Variable> variable, const SqpDateTime &dateTime);
+                 void addDateTime(std::shared_ptr<Variable> variable, const SqpRange &dateTime);
                  /// Clears cache concerning a variable
                  void clear(std::shared_ptr<Variable> variable) noexcept;
                  /// 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<SqpRange> provideNotInCacheDateTimeList(std::shared_ptr<Variable> variable,
+                                                                 const SqpRange &dateTime);
-                 QVector<SqpDateTime> dateCacheList(std::shared_ptr<Variable> variable) const noexcept;
+                 QVector<SqpRange> dateCacheList(std::shared_ptr<Variable> variable) const noexcept;
                  void displayCache(std::shared_ptr<Variable> variable) const;
              private:
                  class VariableCacheControllerPrivate;
                  spimpl::unique_impl_ptr<VariableCacheControllerPrivate> impl;
              };
              #endif // SCIQLOP_VARIABLECACHECONTROLLER_H

core/include/Variable/VariableController.h +4 -4

              #ifndef SCIQLOP_VARIABLECONTROLLER_H
              #define SCIQLOP_VARIABLECONTROLLER_H
              #include "CoreGlobal.h"
-             #include <Data/SqpDateTime.h>
+             #include <Data/SqpRange.h>
              #include <QLoggingCategory>
              #include <QObject>
              #include <Common/spimpl.h>
              class IDataProvider;
              class QItemSelectionModel;
              class TimeController;
              class Variable;
              class VariableModel;
              Q_DECLARE_LOGGING_CATEGORY(LOG_VariableController)
              /**
               * @brief The VariableController class aims to handle the variables in SciQlop.
               */
              class SCIQLOP_CORE_EXPORT VariableController : public QObject {
                  Q_OBJECT
              public:
                  explicit VariableController(QObject *parent = 0);
                  virtual ~VariableController();
                  VariableModel *variableModel() noexcept;
                  QItemSelectionModel *variableSelectionModel() noexcept;
                  void setTimeController(TimeController *timeController) noexcept;
                  /**
                   * Deletes from the controller the variable passed in parameter.
                   *
                   * Delete a variable includes:
                   * - the deletion of the various references to the variable in SciQlop
                   * - the deletion of the model variable
                   * - the deletion of the provider associated with the variable
                   * - removing the cache associated with the variable
                   *
                   * @param variable the variable to delete from the controller.
                   */
                  void deleteVariable(std::shared_ptr<Variable> variable) noexcept;
                  /**
                   * Deletes from the controller the variables passed in parameter.
                   * @param variables the variables to delete from the controller.
                   * @sa deleteVariable()
                   */
                  void deleteVariables(const QVector<std::shared_ptr<Variable> > &variables) noexcept;
                  /**
                   * @brief abort the variable retrieve data progression
                   */
                  void abortProgress(std::shared_ptr<Variable> variable);
              signals:
                  /// Signal emitted when a variable is about to be deleted from the controller
                  void variableAboutToBeDeleted(std::shared_ptr<Variable> variable);
                  /// Signal emitted when a data acquisition is requested on a range for a variable
-                 void rangeChanged(std::shared_ptr<Variable> variable, const SqpDateTime &range);
+                 void rangeChanged(std::shared_ptr<Variable> variable, const SqpRange &range);
              public slots:
                  /// Request the data loading of the variable whithin dateTime
-                 void onRequestDataLoading(std::shared_ptr<Variable> variable, const SqpDateTime &dateTime);
+                 void onRequestDataLoading(std::shared_ptr<Variable> variable, const SqpRange &dateTime);
                  /**
                   * Creates a new variable and adds it to the model
                   * @param name the name of the new variable
                   * @param metadata the metadata of the new variable
                   * @param provider the data provider for the new variable
                   */
                  void createVariable(const QString &name, const QVariantHash &metadata,
                                      std::shared_ptr<IDataProvider> provider) noexcept;
                  /// Update the temporal parameters of every selected variable to dateTime
-                 void onDateTimeOnSelection(const SqpDateTime &dateTime);
+                 void onDateTimeOnSelection(const SqpRange &dateTime);
                  void onVariableRetrieveDataInProgress(QUuid identifier, double progress);
                  void onAbortProgressRequested(std::shared_ptr<Variable> variable);
                  void initialize();
                  void finalize();
              private:
                  void waitForFinish();
                  class VariableControllerPrivate;
                  spimpl::unique_impl_ptr<VariableControllerPrivate> impl;
              };
              #endif // SCIQLOP_VARIABLECONTROLLER_H

core/include/Variable/VariableModel.h +2 -2

              #ifndef SCIQLOP_VARIABLEMODEL_H
              #define SCIQLOP_VARIABLEMODEL_H
              #include "CoreGlobal.h"
-             #include <Data/SqpDateTime.h>
+             #include <Data/SqpRange.h>
              #include <QAbstractTableModel>
              #include <QLoggingCategory>
              #include <Common/MetaTypes.h>
              #include <Common/spimpl.h>
              Q_DECLARE_LOGGING_CATEGORY(LOG_VariableModel)
              enum VariableRoles { ProgressRole = Qt::UserRole };
              class IDataSeries;
              class Variable;
              /**
               * @brief The VariableModel class aims to hold the variables that have been created in SciQlop
               */
              class SCIQLOP_CORE_EXPORT VariableModel : public QAbstractTableModel {
                  Q_OBJECT
              public:
                  explicit VariableModel(QObject *parent = nullptr);
                  /**
                   * Creates a new variable in the model
                   * @param name the name of the new variable
                   * @param dateTime the dateTime of the new variable
                   * @param metadata the metadata associated to the new variable
                   * @return the pointer to the new variable
                   */
-                 std::shared_ptr<Variable> createVariable(const QString &name, const SqpDateTime &dateTime,
+                 std::shared_ptr<Variable> createVariable(const QString &name, const SqpRange &dateTime,
                                                           const QVariantHash &metadata) noexcept;
                  /**
                   * Deletes a variable from the model, if it exists
                   * @param variable the variable to delete
                   */
                  void deleteVariable(std::shared_ptr<Variable> variable) noexcept;
                  std::shared_ptr<Variable> variable(int index) const;
                  void setDataProgress(std::shared_ptr<Variable> variable, double progress);
                  // /////////////////////////// //
                  // QAbstractTableModel methods //
                  // /////////////////////////// //
                  virtual int columnCount(const QModelIndex &parent = QModelIndex{}) const override;
                  virtual int rowCount(const QModelIndex &parent = QModelIndex{}) const override;
                  virtual QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
                  virtual QVariant headerData(int section, Qt::Orientation orientation,
                                              int role = Qt::DisplayRole) const override;
                  void abortProgress(const QModelIndex &index);
              signals:
                  void abortProgessRequested(std::shared_ptr<Variable> variable);
              private:
                  class VariableModelPrivate;
                  spimpl::unique_impl_ptr<VariableModelPrivate> impl;
              private slots:
                  /// Slot called when data of a variable has been updated
                  void onVariableUpdated() noexcept;
              };
              // Registers QVector<int> metatype so it can be used in VariableModel::dataChanged() signal
              SCIQLOP_REGISTER_META_TYPE(QVECTOR_INT_REGISTRY, QVector<int>)
              #endif // SCIQLOP_VARIABLEMODEL_H

core/include/Visualization/VisualizationController.h +2 -2

              #ifndef SCIQLOP_VISUALIZATIONCONTROLLER_H
              #define SCIQLOP_VISUALIZATIONCONTROLLER_H
              #include "CoreGlobal.h"
-             #include <Data/SqpDateTime.h>
+             #include <Data/SqpRange.h>
              #include <QLoggingCategory>
              #include <QObject>
              #include <QUuid>
              #include <Common/spimpl.h>
              Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationController)
              class DataSourceItem;
              class Variable;
              /**
               * @brief The VisualizationController class aims to make the link between SciQlop and its plugins.
               * This is the intermediate class that SciQlop has to use in the way to connect a data source.
               * Please first use register method to initialize a plugin specified by its metadata name (JSON
               * plugin source) then others specifics method will be able to access it. You can load a data source
               * driver plugin then create a data source.
               */
              class SCIQLOP_CORE_EXPORT VisualizationController : public QObject {
                  Q_OBJECT
              public:
                  explicit VisualizationController(QObject *parent = 0);
                  virtual ~VisualizationController();
              signals:
                  /// Signal emitted when a variable is about to be deleted from SciQlop
                  void variableAboutToBeDeleted(std::shared_ptr<Variable> variable);
                  /// Signal emitted when a data acquisition is requested on a range for a variable
-                 void rangeChanged(std::shared_ptr<Variable> variable, const SqpDateTime &range);
+                 void rangeChanged(std::shared_ptr<Variable> variable, const SqpRange &range);
              public slots:
                  /// Manage init/end of the controller
                  void initialize();
                  void finalize();
              private:
                  void waitForFinish();
                  class VisualizationControllerPrivate;
                  spimpl::unique_impl_ptr<VisualizationControllerPrivate> impl;
              };
              #endif // SCIQLOP_VISUALIZATIONCONTROLLER_H

core/src/Time/TimeController.cpp +3 -3

              #include "Time/TimeController.h"
              Q_LOGGING_CATEGORY(LOG_TimeController, "TimeController")
              struct TimeController::TimeControllerPrivate {
-                 SqpDateTime m_DateTime;
+                 SqpRange m_DateTime;
              };
              TimeController::TimeController(QObject *parent)
                      : QObject{parent}, impl{spimpl::make_unique_impl<TimeControllerPrivate>()}
              {
                  qCDebug(LOG_TimeController()) << tr("TimeController construction");
              }
-             SqpDateTime TimeController::dateTime() const noexcept
+             SqpRange TimeController::dateTime() const noexcept
              {
                  return impl->m_DateTime;
              }
-             void TimeController::onTimeToUpdate(SqpDateTime dateTime)
+             void TimeController::onTimeToUpdate(SqpRange dateTime)
              {
                  impl->m_DateTime = dateTime;
              }
              void TimeController::onTimeNotify()
              {
                  emit timeUpdated(impl->m_DateTime);
              }

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

              #include "Variable/Variable.h"
              #include <Data/IDataSeries.h>
-             #include <Data/SqpDateTime.h>
+             #include <Data/SqpRange.h>
              #include <QReadWriteLock>
              #include <QThread>
              Q_LOGGING_CATEGORY(LOG_Variable, "Variable")
              struct Variable::VariablePrivate {
-                 explicit VariablePrivate(const QString &name, const SqpDateTime &dateTime,
+                 explicit VariablePrivate(const QString &name, const SqpRange &dateTime,
                                           const QVariantHash &metadata)
                          : m_Name{name}, m_DateTime{dateTime}, m_Metadata{metadata}, m_DataSeries{nullptr}
                  {
                  }
                  QString m_Name;
-                 SqpDateTime m_DateTime; // The dateTime available in the view and loaded. not the cache.
+                 SqpRange m_DateTime; // The dateTime available in the view and loaded. not the cache.
                  QVariantHash m_Metadata;
                  std::unique_ptr<IDataSeries> m_DataSeries;
              };
-             Variable::Variable(const QString &name, const SqpDateTime &dateTime, const QVariantHash &metadata)
+             Variable::Variable(const QString &name, const SqpRange &dateTime, const QVariantHash &metadata)
                      : impl{spimpl::make_unique_impl<VariablePrivate>(name, dateTime, metadata)}
              {
              }
              QString Variable::name() const noexcept
              {
                  return impl->m_Name;
              }
-             SqpDateTime Variable::dateTime() const noexcept
+             SqpRange Variable::dateTime() const noexcept
              {
                  return impl->m_DateTime;
              }
-             void Variable::setDateTime(const SqpDateTime &dateTime) noexcept
+             void Variable::setDateTime(const SqpRange &dateTime) noexcept
              {
                  impl->m_DateTime = dateTime;
              }
              void Variable::setDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept
              {
                  qCDebug(LOG_Variable()) << "Variable::setDataSeries" << QThread::currentThread()->objectName();
                  if (!dataSeries) {
                      /// @todo ALX : log
                      return;
                  }
                  // Inits the data series of the variable
                  if (!impl->m_DataSeries) {
                      impl->m_DataSeries = dataSeries->clone();
                  }
                  else {
                      impl->m_DataSeries->merge(dataSeries.get());
                      //  emit updated();
                  }
              }
              IDataSeries *Variable::dataSeries() const noexcept
              {
                  return impl->m_DataSeries.get();
              }
              QVariantHash Variable::metadata() const noexcept
              {
                  return impl->m_Metadata;
              }
-             bool Variable::contains(const SqpDateTime &dateTime) const noexcept
+             bool Variable::contains(const SqpRange &dateTime) const noexcept
              {
                  return impl->m_DateTime.contains(dateTime);
              }
-             bool Variable::intersect(const SqpDateTime &dateTime) const noexcept
+             bool Variable::intersect(const SqpRange &dateTime) const noexcept
              {
                  return impl->m_DateTime.intersect(dateTime);
              }
-             bool Variable::isInside(const SqpDateTime &dateTime) const noexcept
+             bool Variable::isInside(const SqpRange &dateTime) const noexcept
              {
-                 return dateTime.contains(SqpDateTime{impl->m_DateTime.m_TStart, impl->m_DateTime.m_TEnd});
+                 return dateTime.contains(SqpRange{impl->m_DateTime.m_TStart, impl->m_DateTime.m_TEnd});
              }

core/src/Variable/VariableCacheController.cpp +36 -39

              #include "Variable/VariableCacheController.h"
              #include "Variable/Variable.h"
              #include <unordered_map>
              #include <QThread>
              Q_LOGGING_CATEGORY(LOG_VariableCacheController, "VariableCacheController")
              struct VariableCacheController::VariableCacheControllerPrivate {
-                 std::unordered_map<std::shared_ptr<Variable>, QVector<SqpDateTime> >
-                     m_VariableToSqpDateTimeListMap;
+                 std::unordered_map<std::shared_ptr<Variable>, QVector<SqpRange> > m_VariableToSqpRangeListMap;
-                 void addInCacheDataByEnd(const SqpDateTime &dateTime, QVector<SqpDateTime> &dateTimeList,
-                                          QVector<SqpDateTime> &notInCache, int cacheIndex,
-                                          double currentTStart);
+                 void addInCacheDataByEnd(const SqpRange &dateTime, QVector<SqpRange> &dateTimeList,
+                                          QVector<SqpRange> &notInCache, int cacheIndex, double currentTStart);
-                 void addInCacheDataByStart(const SqpDateTime &dateTime, QVector<SqpDateTime> &dateTimeList,
-                                            QVector<SqpDateTime> &notInCache, int cacheIndex,
-                                            double currentTStart);
+                 void addInCacheDataByStart(const SqpRange &dateTime, QVector<SqpRange> &dateTimeList,
+                                            QVector<SqpRange> &notInCache, int cacheIndex, double currentTStart);
-                 void addDateTimeRecurse(const SqpDateTime &dateTime, QVector<SqpDateTime> &dateTimeList,
+                 void addDateTimeRecurse(const SqpRange &dateTime, QVector<SqpRange> &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)
+                                                       const SqpRange &dateTime)
              {
                  qCDebug(LOG_VariableCacheController()) << "VariableCacheController::addDateTime"
                                                         << QThread::currentThread()->objectName();
                  if (variable) {
-                     auto findVariableIte = impl->m_VariableToSqpDateTimeListMap.find(variable);
-                     if (findVariableIte == impl->m_VariableToSqpDateTimeListMap.end()) {
-                         impl->m_VariableToSqpDateTimeListMap[variable].push_back(dateTime);
+                     auto findVariableIte = impl->m_VariableToSqpRangeListMap.find(variable);
+                     if (findVariableIte == impl->m_VariableToSqpRangeListMap.end()) {
+                         impl->m_VariableToSqpRangeListMap[variable].push_back(dateTime);
                      }
                      else {
-                         // addDateTime modify the list<SqpDateTime> of the variable in a way to ensure
+                         // addDateTime modify the list<SqpRange> 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)
+                         // (with a & b of type SqpRange) 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
                          try {
-                             impl->addDateTimeRecurse(dateTime,
-                                                      impl->m_VariableToSqpDateTimeListMap.at(variable), 0);
+                             impl->addDateTimeRecurse(dateTime, impl->m_VariableToSqpRangeListMap.at(variable),
+);
                          }
                          catch (const std::out_of_range &e) {
                              qCWarning(LOG_VariableCacheController()) << "addDateTime" << e.what();
                          }
                      }
                  }
              }
              void VariableCacheController::clear(std::shared_ptr<Variable> variable) noexcept
              {
                  if (!variable) {
                      qCCritical(LOG_VariableCacheController()) << "Can't clear variable cache: variable is null";
                      return;
                  }
-                 auto nbEntries = impl->m_VariableToSqpDateTimeListMap.erase(variable);
+                 auto nbEntries = impl->m_VariableToSqpRangeListMap.erase(variable);
                  auto clearCacheMessage
                      = (nbEntries != 0)
                            ? tr("Variable cache cleared for variable %1").arg(variable->name())
                            : tr("No deletion of variable cache: no cache was associated with the variable");
                  qCDebug(LOG_VariableCacheController()) << clearCacheMessage;
              }
-             QVector<SqpDateTime>
+             QVector<SqpRange>
              VariableCacheController::provideNotInCacheDateTimeList(std::shared_ptr<Variable> variable,
-                                                                    const SqpDateTime &dateTime)
+                                                                    const SqpRange &dateTime)
              {
                  qCDebug(LOG_VariableCacheController())
                      << "VariableCacheController::provideNotInCacheDateTimeList"
                      << QThread::currentThread()->objectName();
-                 auto notInCache = QVector<SqpDateTime>{};
+                 auto notInCache = QVector<SqpRange>{};
                  // 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)
-                 auto it = impl->m_VariableToSqpDateTimeListMap.find(variable);
-                 if (it != impl->m_VariableToSqpDateTimeListMap.end()) {
+                 // (with a & b of type SqpRange) means ts(b) > te(a)
+                 auto it = impl->m_VariableToSqpRangeListMap.find(variable);
+                 if (it != impl->m_VariableToSqpRangeListMap.end()) {
                      impl->addInCacheDataByStart(dateTime, it->second, notInCache, 0, dateTime.m_TStart);
                  }
                  else {
                      notInCache << dateTime;
                  }
                  return notInCache;
              }
-             QVector<SqpDateTime>
+             QVector<SqpRange>
              VariableCacheController::dateCacheList(std::shared_ptr<Variable> variable) const noexcept
              {
                  qCDebug(LOG_VariableCacheController()) << "VariableCacheController::dateCacheList"
                                                         << QThread::currentThread()->objectName();
                  try {
-                     return impl->m_VariableToSqpDateTimeListMap.at(variable);
+                     return impl->m_VariableToSqpRangeListMap.at(variable);
                  }
                  catch (const std::out_of_range &e) {
                      qCWarning(LOG_VariableCacheController()) << e.what();
-                     return QVector<SqpDateTime>{};
+                     return QVector<SqpRange>{};
                  }
              }
              void VariableCacheController::VariableCacheControllerPrivate::addDateTimeRecurse(
-                 const SqpDateTime &dateTime, QVector<SqpDateTime> &dateTimeList, int cacheIndex)
+                 const SqpRange &dateTime, QVector<SqpRange> &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};
+                     auto mergeDateTime = SqpRange{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 SqpRange &dateTime, QVector<SqpRange> &dateTimeList, QVector<SqpRange> &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});
+                         notInCache.push_back(SqpRange{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});
+                     notInCache.push_back(SqpRange{currentTStart, dateTime.m_TEnd});
                  }
                  else {
-                     notInCache.push_back(SqpDateTime{currentTStart, currentDateTimeJ.m_TStart});
+                     notInCache.push_back(SqpRange{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 SqpRange &dateTime, QVector<SqpRange> &dateTimeList, QVector<SqpRange> &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});
+                     notInCache.push_back(SqpRange{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 (currentTStart < currentDateTimeI.m_TEnd) {
                      if (dateTime.m_TEnd > 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);
                  }
              }
              void VariableCacheController::displayCache(std::shared_ptr<Variable> variable) const
              {
-                 auto variableDateTimeList = impl->m_VariableToSqpDateTimeListMap.find(variable);
-                 if (variableDateTimeList != impl->m_VariableToSqpDateTimeListMap.end()) {
+                 auto variableDateTimeList = impl->m_VariableToSqpRangeListMap.find(variable);
+                 if (variableDateTimeList != impl->m_VariableToSqpRangeListMap.end()) {
                      qCInfo(LOG_VariableCacheController()) << tr("VariableCacheController::displayCache")
                                                            << variableDateTimeList->second;
                  }
                  else {
                      qCWarning(LOG_VariableCacheController())
                          << tr("Cannot display a variable that is not in the cache");
                  }
              }

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

              #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 <QMutex>
              #include <QThread>
              #include <QUuid>
              #include <QtCore/QItemSelectionModel>
              #include <unordered_map>
              Q_LOGGING_CATEGORY(LOG_VariableController, "VariableController")
              struct VariableController::VariableControllerPrivate {
                  explicit VariableControllerPrivate(VariableController *parent)
                          : m_WorkingMutex{},
                            m_VariableModel{new VariableModel{parent}},
                            m_VariableSelectionModel{new QItemSelectionModel{m_VariableModel, parent}},
                            m_VariableCacheController{std::make_unique<VariableCacheController>()}
                  {
                  }
                  QMutex m_WorkingMutex;
                  /// Variable model. The VariableController has the ownership
                  VariableModel *m_VariableModel;
                  QItemSelectionModel *m_VariableSelectionModel;
                  TimeController *m_TimeController{nullptr};
                  std::unique_ptr<VariableCacheController> m_VariableCacheController;
                  std::unordered_map<std::shared_ptr<Variable>, std::shared_ptr<IDataProvider> >
                      m_VariableToProviderMap;
                  std::unordered_map<std::shared_ptr<Variable>, QUuid> m_VariableToIdentifierMap;
              };
              VariableController::VariableController(QObject *parent)
                      : QObject{parent}, impl{spimpl::make_unique_impl<VariableControllerPrivate>(this)}
              {
                  qCDebug(LOG_VariableController()) << tr("VariableController construction")
                                                    << QThread::currentThread();
                  connect(impl->m_VariableModel, &VariableModel::abortProgessRequested, this,
                          &VariableController::onAbortProgressRequested);
              }
              VariableController::~VariableController()
              {
                  qCDebug(LOG_VariableController()) << tr("VariableController destruction")
                                                    << QThread::currentThread();
                  this->waitForFinish();
              }
              VariableModel *VariableController::variableModel() noexcept
              {
                  return impl->m_VariableModel;
              }
              QItemSelectionModel *VariableController::variableSelectionModel() noexcept
              {
                  return impl->m_VariableSelectionModel;
              }
              void VariableController::setTimeController(TimeController *timeController) noexcept
              {
                  impl->m_TimeController = timeController;
              }
              void VariableController::deleteVariable(std::shared_ptr<Variable> variable) noexcept
              {
                  if (!variable) {
                      qCCritical(LOG_VariableController()) << "Can't delete variable: variable is null";
                      return;
                  }
                  // Spreads in SciQlop that the variable will be deleted, so that potential receivers can
                  // make some treatments before the deletion
                  emit variableAboutToBeDeleted(variable);
                  // Deletes identifier
                  impl->m_VariableToIdentifierMap.erase(variable);
                  // Deletes provider
                  auto nbProvidersDeleted = impl->m_VariableToProviderMap.erase(variable);
                  qCDebug(LOG_VariableController())
                      << tr("Number of providers deleted for variable %1: %2")
                             .arg(variable->name(), QString::number(nbProvidersDeleted));
                  // Clears cache
                  impl->m_VariableCacheController->clear(variable);
                  // Deletes from model
                  impl->m_VariableModel->deleteVariable(variable);
              }
              void VariableController::deleteVariables(
                  const QVector<std::shared_ptr<Variable> > &variables) noexcept
              {
                  for (auto variable : qAsConst(variables)) {
                      deleteVariable(variable);
                  }
              }
              void VariableController::abortProgress(std::shared_ptr<Variable> variable)
              {
              }
              void VariableController::createVariable(const QString &name, const QVariantHash &metadata,
                                                      std::shared_ptr<IDataProvider> provider) noexcept
              {
                  if (!impl->m_TimeController) {
                      qCCritical(LOG_VariableController())
                          << tr("Impossible to create variable: The time controller is null");
                      return;
                  }
                  auto dateTime = impl->m_TimeController->dateTime();
                  if (auto newVariable = impl->m_VariableModel->createVariable(name, dateTime, metadata)) {
                      auto identifier = QUuid::createUuid();
                      // store the provider
                      impl->m_VariableToProviderMap[newVariable] = provider;
                      impl->m_VariableToIdentifierMap[newVariable] = identifier;
                      auto addDateTimeAcquired = [ this, varW = std::weak_ptr<Variable>{newVariable} ](
                          QUuid identifier, auto dataSeriesAcquired, auto dateTimeToPutInCache)
                      {
                          if (auto variable = varW.lock()) {
                              auto varIdentifier = impl->m_VariableToIdentifierMap.at(variable);
                              if (varIdentifier == identifier) {
                                  impl->m_VariableCacheController->addDateTime(variable, dateTimeToPutInCache);
                                  variable->setDataSeries(dataSeriesAcquired);
                                  emit variable->updated();
                              }
                          }
                      };
                      connect(provider.get(), &IDataProvider::dataProvided, addDateTimeAcquired);
                      connect(provider.get(), &IDataProvider::dataProvidedProgress, this,
                              &VariableController::onVariableRetrieveDataInProgress);
                      this->onRequestDataLoading(newVariable, dateTime);
                  }
              }
-             void VariableController::onDateTimeOnSelection(const SqpDateTime &dateTime)
+             void VariableController::onDateTimeOnSelection(const SqpRange &dateTime)
              {
                  qCDebug(LOG_VariableController()) << "VariableController::onDateTimeOnSelection"
                                                    << QThread::currentThread()->objectName();
                  auto selectedRows = impl->m_VariableSelectionModel->selectedRows();
                  for (const auto &selectedRow : qAsConst(selectedRows)) {
                      if (auto selectedVariable = impl->m_VariableModel->variable(selectedRow.row())) {
                          selectedVariable->setDateTime(dateTime);
                          this->onRequestDataLoading(selectedVariable, dateTime);
                          // notify that rescale operation has to be done
                          emit rangeChanged(selectedVariable, dateTime);
                      }
                  }
              }
              void VariableController::onVariableRetrieveDataInProgress(QUuid identifier, double progress)
              {
                  auto findReply = [identifier](const auto &entry) { return identifier == entry.second; };
                  auto end = impl->m_VariableToIdentifierMap.cend();
                  auto it = std::find_if(impl->m_VariableToIdentifierMap.cbegin(), end, findReply);
                  if (it != end) {
                      impl->m_VariableModel->setDataProgress(it->first, progress);
                  }
              }
              void VariableController::onAbortProgressRequested(std::shared_ptr<Variable> variable)
              {
                  qCDebug(LOG_VariableController()) << "TORM: VariableController::onAbortProgressRequested"
                                                    << QThread::currentThread()->objectName();
                  auto it = impl->m_VariableToIdentifierMap.find(variable);
                  if (it != impl->m_VariableToIdentifierMap.cend()) {
                      impl->m_VariableToProviderMap.at(variable)->requestDataAborting(it->second);
                  }
                  else {
                      qCWarning(LOG_VariableController())
                          << tr("Aborting progression of inexistant variable detected !!!")
                          << QThread::currentThread()->objectName();
                  }
              }
              void VariableController::onRequestDataLoading(std::shared_ptr<Variable> variable,
-                                                           const SqpDateTime &dateTime)
+                                                           const SqpRange &dateTime)
              {
                  qCDebug(LOG_VariableController()) << "VariableController::onRequestDataLoading"
                                                    << QThread::currentThread()->objectName();
                  // 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) {
                      auto dateTimeListNotInCache
                          = impl->m_VariableCacheController->provideNotInCacheDateTimeList(variable, dateTime);
                      if (!dateTimeListNotInCache.empty()) {
                          // Ask the provider for each data on the dateTimeListNotInCache
                          auto identifier = impl->m_VariableToIdentifierMap.at(variable);
                          impl->m_VariableToProviderMap.at(variable)->requestDataLoading(
                              identifier,
                              DataProviderParameters{std::move(dateTimeListNotInCache), variable->metadata()});
                      }
                      else {
                          emit variable->updated();
                      }
                  }
                  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/src/Variable/VariableModel.cpp +1 -1

              #include <Variable/Variable.h>
              #include <Variable/VariableModel.h>
              #include <Common/DateUtils.h>
              #include <Data/IDataSeries.h>
              #include <QSize>
              #include <unordered_map>
              Q_LOGGING_CATEGORY(LOG_VariableModel, "VariableModel")
              namespace {
              // Column indexes
              const auto NAME_COLUMN = 0;
              const auto TSTART_COLUMN = 1;
              const auto TEND_COLUMN = 2;
              const auto NB_COLUMNS = 3;
              // Column properties
              const auto DEFAULT_HEIGHT = 25;
              const auto DEFAULT_WIDTH = 100;
              struct ColumnProperties {
                  ColumnProperties(const QString &name = {}, int width = DEFAULT_WIDTH,
                                   int height = DEFAULT_HEIGHT)
                          : m_Name{name}, m_Width{width}, m_Height{height}
                  {
                  }
                  QString m_Name;
                  int m_Width;
                  int m_Height;
              };
              const auto COLUMN_PROPERTIES
                  = QHash<int, ColumnProperties>{{NAME_COLUMN, {QObject::tr("Name")}},
                                                 {TSTART_COLUMN, {QObject::tr("tStart"), 180}},
                                                 {TEND_COLUMN, {QObject::tr("tEnd"), 180}}};
              /// Format for datetimes
              const auto DATETIME_FORMAT = QStringLiteral("dd/MM/yyyy \nhh:mm:ss:zzz");
              } // namespace
              struct VariableModel::VariableModelPrivate {
                  /// Variables created in SciQlop
                  std::vector<std::shared_ptr<Variable> > m_Variables;
                  std::unordered_map<std::shared_ptr<Variable>, double> m_VariableToProgress;
                  /// Return the row index of the variable. -1 if it's not found
                  int indexOfVariable(Variable *variable) const noexcept;
              };
              VariableModel::VariableModel(QObject *parent)
                      : QAbstractTableModel{parent}, impl{spimpl::make_unique_impl<VariableModelPrivate>()}
              {
              }
              std::shared_ptr<Variable> VariableModel::createVariable(const QString &name,
-                                                                     const SqpDateTime &dateTime,
+                                                                     const SqpRange &dateTime,
                                                                      const QVariantHash &metadata) noexcept
              {
                  auto insertIndex = rowCount();
                  beginInsertRows({}, insertIndex, insertIndex);
                  auto variable = std::make_shared<Variable>(name, dateTime, metadata);
                  impl->m_Variables.push_back(variable);
                  connect(variable.get(), &Variable::updated, this, &VariableModel::onVariableUpdated);
                  endInsertRows();
                  return variable;
              }
              void VariableModel::deleteVariable(std::shared_ptr<Variable> variable) noexcept
              {
                  if (!variable) {
                      qCCritical(LOG_Variable()) << "Can't delete a null variable from the model";
                      return;
                  }
                  // Finds variable in the model
                  auto begin = impl->m_Variables.cbegin();
                  auto end = impl->m_Variables.cend();
                  auto it = std::find(begin, end, variable);
                  if (it != end) {
                      auto removeIndex = std::distance(begin, it);
                      // Deletes variable
                      beginRemoveRows({}, removeIndex, removeIndex);
                      impl->m_Variables.erase(it);
                      endRemoveRows();
                  }
                  else {
                      qCritical(LOG_VariableModel())
                          << tr("Can't delete variable %1 from the model: the variable is not in the model")
                                 .arg(variable->name());
                  }
                  // Removes variable from progress map
                  impl->m_VariableToProgress.erase(variable);
              }
              std::shared_ptr<Variable> VariableModel::variable(int index) const
              {
                  return (index >= 0 && index < impl->m_Variables.size()) ? impl->m_Variables[index] : nullptr;
              }
              void VariableModel::setDataProgress(std::shared_ptr<Variable> variable, double progress)
              {
                  if (progress > 0.0) {
                      impl->m_VariableToProgress[variable] = progress;
                  }
                  else {
                      impl->m_VariableToProgress.erase(variable);
                  }
                  auto modelIndex = createIndex(impl->indexOfVariable(variable.get()), NAME_COLUMN);
                  emit dataChanged(modelIndex, modelIndex);
              }
              int VariableModel::columnCount(const QModelIndex &parent) const
              {
                  Q_UNUSED(parent);
                  return NB_COLUMNS;
              }
              int VariableModel::rowCount(const QModelIndex &parent) const
              {
                  Q_UNUSED(parent);
                  return impl->m_Variables.size();
              }
              QVariant VariableModel::data(const QModelIndex &index, int role) const
              {
                  if (!index.isValid()) {
                      return QVariant{};
                  }
                  if (index.row() < 0 || index.row() >= rowCount()) {
                      return QVariant{};
                  }
                  if (role == Qt::DisplayRole) {
                      if (auto variable = impl->m_Variables.at(index.row()).get()) {
                          /// Lambda function that builds the variant to return for a time value
                          auto dateTimeVariant = [](double secs) {
                              auto dateTime = DateUtils::dateTime(secs);
                              return dateTime.toString(DATETIME_FORMAT);
                          };
                          switch (index.column()) {
                              case NAME_COLUMN:
                                  return variable->name();
                              case TSTART_COLUMN:
                                  return dateTimeVariant(variable->dateTime().m_TStart);
                              case TEND_COLUMN:
                                  return dateTimeVariant(variable->dateTime().m_TEnd);
                              default:
                                  // No action
                                  break;
                          }
                          qWarning(LOG_VariableModel())
                              << tr("Can't get data (unknown column %1)").arg(index.column());
                      }
                      else {
                          qWarning(LOG_VariableModel()) << tr("Can't get data (no variable)");
                      }
                  }
                  else if (role == VariableRoles::ProgressRole) {
                      if (auto variable = impl->m_Variables.at(index.row())) {
                          auto it = impl->m_VariableToProgress.find(variable);
                          if (it != impl->m_VariableToProgress.cend()) {
                              return it->second;
                          }
                      }
                  }
                  return QVariant{};
              }
              QVariant VariableModel::headerData(int section, Qt::Orientation orientation, int role) const
              {
                  if (role != Qt::DisplayRole && role != Qt::SizeHintRole) {
                      return QVariant{};
                  }
                  if (orientation == Qt::Horizontal) {
                      auto propertiesIt = COLUMN_PROPERTIES.find(section);
                      if (propertiesIt != COLUMN_PROPERTIES.cend()) {
                          // Role is either DisplayRole or SizeHintRole
                          return (role == Qt::DisplayRole)
                                     ? QVariant{propertiesIt->m_Name}
                                     : QVariant{QSize{propertiesIt->m_Width, propertiesIt->m_Height}};
                      }
                      else {
                          qWarning(LOG_VariableModel())
                              << tr("Can't get header data (unknown column %1)").arg(section);
                      }
                  }
                  return QVariant{};
              }
              void VariableModel::abortProgress(const QModelIndex &index)
              {
                  if (auto variable = impl->m_Variables.at(index.row())) {
                      emit abortProgessRequested(variable);
                  }
              }
              void VariableModel::onVariableUpdated() noexcept
              {
                  // Finds variable that has been updated in the model
                  if (auto updatedVariable = dynamic_cast<Variable *>(sender())) {
                      auto updatedVariableIndex = impl->indexOfVariable(updatedVariable);
                      if (updatedVariableIndex > -1) {
                          emit dataChanged(createIndex(updatedVariableIndex, 0),
                                           createIndex(updatedVariableIndex, columnCount() - 1));
                      }
                  }
              }
              int VariableModel::VariableModelPrivate::indexOfVariable(Variable *variable) const noexcept
              {
                  auto begin = std::cbegin(m_Variables);
                  auto end = std::cend(m_Variables);
                  auto it
                      = std::find_if(begin, end, [variable](const auto &var) { return var.get() == variable; });
                  if (it != end) {
                      // Gets the index of the variable in the model: we assume here that views have the same
                      // order as the model
                      return std::distance(begin, it);
                  }
                  else {
                      return -1;
                  }
              }

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

              #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()),
+                 auto sqp0 = SqpRange{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()),
+                 auto sqp1 = SqpRange{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()),
+                 auto sqp2 = SqpRange{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()),
+                 auto sqp = SqpRange{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()),
+                 sqp = SqpRange{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()),
+                 sqp = SqpRange{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()),
+                 sqp = SqpRange{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()),
+                 sqp = SqpRange{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()),
+                 sqp = SqpRange{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()),
+                 sqp = SqpRange{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()),
+                 sqp = SqpRange{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()),
+                 sqp = SqpRange{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()),
+                 sqp = SqpRange{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()),
+                 sqp = SqpRange{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()),
+                 sqp = SqpRange{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()),
+                 sqp = SqpRange{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()),
+                 auto sqp0 = SqpRange{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()),
+                 auto sqp1 = SqpRange{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()),
+                 auto sqp2 = SqpRange{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()),
+                 auto sqp01 = SqpRange{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()),
+                 auto sqp3 = SqpRange{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()),
+                 auto sqp03 = SqpRange{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/TimeWidget/TimeWidget.h +2 -2

              #ifndef SCIQLOP_TIMEWIDGET_H
              #define SCIQLOP_TIMEWIDGET_H
              #include <QWidget>
-             #include <Data/SqpDateTime.h>
+             #include <Data/SqpRange.h>
              namespace Ui {
              class TimeWidget;
              } // Ui
              class TimeWidget : public QWidget {
                  Q_OBJECT
              public:
                  explicit TimeWidget(QWidget *parent = 0);
                  virtual ~TimeWidget();
              signals:
                  /// Signal emitted when the time parameters has beed updated
-                 void timeUpdated(SqpDateTime time);
+                 void timeUpdated(SqpRange time);
              public slots:
                  /// slot called when time parameters update has ben requested
                  void onTimeUpdateRequested();
              private:
                  Ui::TimeWidget *ui;
              };
              #endif // SCIQLOP_ SQPSIDEPANE_H

gui/include/Visualization/VisualizationGraphHelper.h +2 -2

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

gui/include/Visualization/VisualizationGraphWidget.h +6 -6

              #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 SqpRange;
              class Variable;
              /**
               * Possible types of zoom operation
               */
              enum class VisualizationGraphWidgetZoomType { ZoomOut, ZoomIn, PanRight, PanLeft, Unknown };
              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 enableSynchronize(bool enable);
                  void addVariable(std::shared_ptr<Variable> variable);
                  void addVariableUsingGraph(std::shared_ptr<Variable> variable);
                  /// Removes a variable from the graph
                  void removeVariable(std::shared_ptr<Variable> variable) noexcept;
-                 void setRange(std::shared_ptr<Variable> variable, const SqpDateTime &range);
-                 SqpDateTime graphRange() const noexcept;
-                 void setGraphRange(const SqpDateTime &range);
+                 void setRange(std::shared_ptr<Variable> variable, const SqpRange &range);
+                 SqpRange graphRange() const noexcept;
+                 void setGraphRange(const SqpRange &range);
                  // IVisualizationWidget interface
                  void accept(IVisualizationWidgetVisitor *visitor) override;
                  bool canDrop(const Variable &variable) const override;
                  bool contains(const Variable &variable) const override;
                  QString name() const override;
              signals:
-                 void requestDataLoading(std::shared_ptr<Variable> variable, const SqpDateTime &dateTime);
-                 void synchronize(const SqpDateTime &dateTime, const SqpDateTime &oldDateTime,
+                 void requestDataLoading(std::shared_ptr<Variable> variable, const SqpRange &dateTime);
+                 void synchronize(const SqpRange &dateTime, const SqpRange &oldDateTime,
                                   VisualizationGraphWidgetZoomType zoomType);
              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;
                  /// Rescale the X axe to range parameter
                  void onRangeChanged(const QCPRange &t1, const QCPRange &t2);
                  /// Slot called when a mouse move was made
                  void onMouseMove(QMouseEvent *event) noexcept;
                  /// Slot called when a mouse wheel was made, to perform some processing before the zoom is done
                  void onMouseWheel(QWheelEvent *event) noexcept;
                  /// Slot called when a mouse press was made, to activate the calibration of a graph
                  void onMousePress(QMouseEvent *event) noexcept;
                  /// Slot called when a mouse release was made, to deactivate the calibration of a graph
                  void onMouseRelease(QMouseEvent *event) noexcept;
                  void onDataCacheVariableUpdated();
              };
              #endif // SCIQLOP_VISUALIZATIONGRAPHWIDGET_H

gui/include/Visualization/VisualizationWidget.h +2 -2

              #ifndef SCIQLOP_VISUALIZATIONWIDGET_H
              #define SCIQLOP_VISUALIZATIONWIDGET_H
              #include "Visualization/IVisualizationWidget.h"
-             #include <Data/SqpDateTime.h>
+             #include <Data/SqpRange.h>
              #include <QLoggingCategory>
              #include <QWidget>
              Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationWidget)
              class QMenu;
              class Variable;
              class VisualizationTabWidget;
              namespace Ui {
              class VisualizationWidget;
              } // namespace Ui
              class VisualizationWidget : public QWidget, public IVisualizationWidget {
                  Q_OBJECT
              public:
                  explicit VisualizationWidget(QWidget *parent = 0);
                  virtual ~VisualizationWidget();
                  // IVisualizationWidget interface
                  void accept(IVisualizationWidgetVisitor *visitor) override;
                  bool canDrop(const Variable &variable) const override;
                  bool contains(const Variable &variable) const override;
                  QString name() const override;
              public slots:
                  /**
                   * Attaches to a menu the menu relative to the visualization of variables
                   * @param menu the parent menu of the generated menu
                   * @param variables the variables for which to generate the menu
                   */
                  void attachVariableMenu(QMenu *menu,
                                          const QVector<std::shared_ptr<Variable> > &variables) noexcept;
                  /// Slot called when a variable is about to be deleted from SciQlop
                  void onVariableAboutToBeDeleted(std::shared_ptr<Variable> variable) noexcept;
-                 void onRangeChanged(std::shared_ptr<Variable> variable, const SqpDateTime &range) noexcept;
+                 void onRangeChanged(std::shared_ptr<Variable> variable, const SqpRange &range) noexcept;
              private:
                  Ui::VisualizationWidget *ui;
              };
              #endif // VISUALIZATIONWIDGET_H

gui/include/Visualization/operations/RescaleAxeOperation.h +2 -2

              #ifndef SCIQLOP_RESCALEAXEOPERATION_H
              #define SCIQLOP_RESCALEAXEOPERATION_H
              #include "Visualization/IVisualizationWidgetVisitor.h"
-             #include <Data/SqpDateTime.h>
+             #include <Data/SqpRange.h>
              #include <Common/spimpl.h>
              #include <QLoggingCategory>
              #include <memory>
              class Variable;
              Q_DECLARE_LOGGING_CATEGORY(LOG_RescaleAxeOperation)
              /**
               * @brief The RescaleAxeOperation class defines an operation that traverses all of visualization
               * widgets to remove a variable if they contain it
               */
              class RescaleAxeOperation : public IVisualizationWidgetVisitor {
              public:
                  /**
                   * Ctor
                   * @param variable the variable to remove from widgets
                   */
-                 explicit RescaleAxeOperation(std::shared_ptr<Variable> variable, const SqpDateTime &range);
+                 explicit RescaleAxeOperation(std::shared_ptr<Variable> variable, const SqpRange &range);
                  void visitEnter(VisualizationWidget *widget) override final;
                  void visitLeave(VisualizationWidget *widget) override final;
                  void visitEnter(VisualizationTabWidget *tabWidget) override final;
                  void visitLeave(VisualizationTabWidget *tabWidget) override final;
                  void visitEnter(VisualizationZoneWidget *zoneWidget) override final;
                  void visitLeave(VisualizationZoneWidget *zoneWidget) override final;
                  void visit(VisualizationGraphWidget *graphWidget) override final;
              private:
                  class RescaleAxeOperationPrivate;
                  spimpl::unique_impl_ptr<RescaleAxeOperationPrivate> impl;
              };
              #endif // SCIQLOP_RESCALEAXEOPERATION_H

gui/src/SqpApplication.cpp +2 -2

              #include "SqpApplication.h"
              #include <Data/IDataProvider.h>
              #include <DataSource/DataSourceController.h>
              #include <Network/NetworkController.h>
              #include <QThread>
              #include <Time/TimeController.h>
              #include <Variable/Variable.h>
              #include <Variable/VariableController.h>
              #include <Visualization/VisualizationController.h>
              Q_LOGGING_CATEGORY(LOG_SqpApplication, "SqpApplication")
              class SqpApplication::SqpApplicationPrivate {
              public:
                  SqpApplicationPrivate()
                          : m_DataSourceController{std::make_unique<DataSourceController>()},
                            m_NetworkController{std::make_unique<NetworkController>()},
                            m_TimeController{std::make_unique<TimeController>()},
                            m_VariableController{std::make_unique<VariableController>()},
                            m_VisualizationController{std::make_unique<VisualizationController>()}
                  {
                      // /////////////////////////////// //
                      // Connections between controllers //
                      // /////////////////////////////// //
                      // VariableController <-> DataSourceController
                      connect(m_DataSourceController.get(),
                              SIGNAL(variableCreationRequested(const QString &, const QVariantHash &,
                                                               std::shared_ptr<IDataProvider>)),
                              m_VariableController.get(),
                              SLOT(createVariable(const QString &, const QVariantHash &,
                                                  std::shared_ptr<IDataProvider>)));
                      // VariableController <-> VisualizationController
                      connect(m_VariableController.get(),
                              SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)),
                              m_VisualizationController.get(),
                              SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)), Qt::DirectConnection);
                      connect(m_VariableController.get(),
-                             SIGNAL(rangeChanged(std::shared_ptr<Variable>, const SqpDateTime &)),
+                             SIGNAL(rangeChanged(std::shared_ptr<Variable>, const SqpRange &)),
                              m_VisualizationController.get(),
-                             SIGNAL(rangeChanged(std::shared_ptr<Variable>, const SqpDateTime &)));
+                             SIGNAL(rangeChanged(std::shared_ptr<Variable>, const SqpRange &)));
                      m_DataSourceController->moveToThread(&m_DataSourceControllerThread);
                      m_DataSourceControllerThread.setObjectName("DataSourceControllerThread");
                      m_NetworkController->moveToThread(&m_NetworkControllerThread);
                      m_NetworkControllerThread.setObjectName("NetworkControllerThread");
                      m_VariableController->moveToThread(&m_VariableControllerThread);
                      m_VariableControllerThread.setObjectName("VariableControllerThread");
                      m_VisualizationController->moveToThread(&m_VisualizationControllerThread);
                      m_VisualizationControllerThread.setObjectName("VsualizationControllerThread");
                      // Additionnal init
                      m_VariableController->setTimeController(m_TimeController.get());
                  }
                  virtual ~SqpApplicationPrivate()
                  {
                      qCInfo(LOG_SqpApplication()) << tr("SqpApplicationPrivate destruction");
                      m_DataSourceControllerThread.quit();
                      m_DataSourceControllerThread.wait();
                      m_NetworkControllerThread.quit();
                      m_NetworkControllerThread.wait();
                      m_VariableControllerThread.quit();
                      m_VariableControllerThread.wait();
                      m_VisualizationControllerThread.quit();
                      m_VisualizationControllerThread.wait();
                  }
                  std::unique_ptr<DataSourceController> m_DataSourceController;
                  std::unique_ptr<VariableController> m_VariableController;
                  std::unique_ptr<TimeController> m_TimeController;
                  std::unique_ptr<NetworkController> m_NetworkController;
                  std::unique_ptr<VisualizationController> m_VisualizationController;
                  QThread m_DataSourceControllerThread;
                  QThread m_NetworkControllerThread;
                  QThread m_VariableControllerThread;
                  QThread m_VisualizationControllerThread;
              };
              SqpApplication::SqpApplication(int &argc, char **argv)
                      : QApplication{argc, argv}, impl{spimpl::make_unique_impl<SqpApplicationPrivate>()}
              {
                  qCDebug(LOG_SqpApplication()) << tr("SqpApplication construction") << QThread::currentThread();
                  connect(&impl->m_DataSourceControllerThread, &QThread::started,
                          impl->m_DataSourceController.get(), &DataSourceController::initialize);
                  connect(&impl->m_DataSourceControllerThread, &QThread::finished,
                          impl->m_DataSourceController.get(), &DataSourceController::finalize);
                  connect(&impl->m_NetworkControllerThread, &QThread::started, impl->m_NetworkController.get(),
                          &NetworkController::initialize);
                  connect(&impl->m_NetworkControllerThread, &QThread::finished, impl->m_NetworkController.get(),
                          &NetworkController::finalize);
                  connect(&impl->m_VariableControllerThread, &QThread::started, impl->m_VariableController.get(),
                          &VariableController::initialize);
                  connect(&impl->m_VariableControllerThread, &QThread::finished, impl->m_VariableController.get(),
                          &VariableController::finalize);
                  connect(&impl->m_VisualizationControllerThread, &QThread::started,
                          impl->m_VisualizationController.get(), &VisualizationController::initialize);
                  connect(&impl->m_VisualizationControllerThread, &QThread::finished,
                          impl->m_VisualizationController.get(), &VisualizationController::finalize);
                  impl->m_DataSourceControllerThread.start();
                  impl->m_NetworkControllerThread.start();
                  impl->m_VariableControllerThread.start();
                  impl->m_VisualizationControllerThread.start();
              }
              SqpApplication::~SqpApplication()
              {
              }
              void SqpApplication::initialize()
              {
              }
              DataSourceController &SqpApplication::dataSourceController() noexcept
              {
                  return *impl->m_DataSourceController;
              }
              NetworkController &SqpApplication::networkController() noexcept
              {
                  return *impl->m_NetworkController;
              }
              TimeController &SqpApplication::timeController() noexcept
              {
                  return *impl->m_TimeController;
              }
              VariableController &SqpApplication::variableController() noexcept
              {
                  return *impl->m_VariableController;
              }
              VisualizationController &SqpApplication::visualizationController() noexcept
              {
                  return *impl->m_VisualizationController;
              }

gui/src/TimeWidget/TimeWidget.cpp +2 -2

              #include "TimeWidget/TimeWidget.h"
              #include "ui_TimeWidget.h"
              #include <Common/DateUtils.h>
              #include <SqpApplication.h>
              #include <Time/TimeController.h>
              TimeWidget::TimeWidget(QWidget *parent) : QWidget{parent}, ui{new Ui::TimeWidget}
              {
                  ui->setupUi(this);
                  ui->applyToolButton->setIcon(sqpApp->style()->standardIcon(QStyle::SP_DialogApplyButton));
                  // Connection
                  connect(ui->startDateTimeEdit, &QDateTimeEdit::dateTimeChanged, this,
                          &TimeWidget::onTimeUpdateRequested);
                  connect(ui->endDateTimeEdit, &QDateTimeEdit::dateTimeChanged, this,
                          &TimeWidget::onTimeUpdateRequested);
                  connect(ui->applyToolButton, &QToolButton::clicked, &sqpApp->timeController(),
                          &TimeController::onTimeNotify);
                  // Initialisation
                  auto endDateTime = QDateTime::currentDateTimeUtc();
                  auto startDateTime = endDateTime.addSecs(-3600); // one hour before
                  ui->startDateTimeEdit->setDateTime(startDateTime);
                  ui->endDateTimeEdit->setDateTime(endDateTime);
-                 auto dateTime = SqpDateTime{DateUtils::secondsSinceEpoch(startDateTime),
+                 auto dateTime = SqpRange{DateUtils::secondsSinceEpoch(startDateTime),
-                                             DateUtils::secondsSinceEpoch(endDateTime)};
                  sqpApp->timeController().onTimeToUpdate(dateTime);
              }
              TimeWidget::~TimeWidget()
              {
                  delete ui;
              }
              void TimeWidget::onTimeUpdateRequested()
              {
-                 auto dateTime = SqpDateTime{DateUtils::secondsSinceEpoch(ui->startDateTimeEdit->dateTime()),
+                 auto dateTime = SqpRange{DateUtils::secondsSinceEpoch(ui->startDateTimeEdit->dateTime()),
-                                             DateUtils::secondsSinceEpoch(ui->endDateTimeEdit->dateTime())};
                  emit timeUpdated(std::move(dateTime));
              }

gui/src/Visualization/VisualizationGraphHelper.cpp +3 -3

              #include "Visualization/VisualizationGraphHelper.h"
              #include "Visualization/qcustomplot.h"
              #include <Data/ScalarSeries.h>
              #include <Variable/Variable.h>
              Q_LOGGING_CATEGORY(LOG_VisualizationGraphHelper, "VisualizationGraphHelper")
              namespace {
              class SqpDataContainer : public QCPGraphDataContainer {
              public:
                  void appendGraphData(const QCPGraphData &data) { mData.append(data); }
              };
              /// 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);
                      dateTicker->setDateTimeSpec(Qt::UTC);
                      return dateTicker;
                  }
                  else {
                      // default ticker
                      return QSharedPointer<QCPAxisTicker>::create();
                  }
              }
              void updateScalarData(QCPAbstractPlottable *component, ScalarSeries &scalarSeries,
-                                   const SqpDateTime &dateTime)
+                                   const SqpRange &dateTime)
              {
                  qCDebug(LOG_VisualizationGraphHelper()) << "TORM: updateScalarData"
                                                          << QThread::currentThread()->objectName();
                  if (auto qcpGraph = dynamic_cast<QCPGraph *>(component)) {
                      scalarSeries.lockRead();
                      {
                          const auto &xData = scalarSeries.xAxisData()->cdata();
                          const auto &valuesData = scalarSeries.valuesData()->cdata();
                          auto xDataBegin = xData.cbegin();
                          auto xDataEnd = xData.cend();
                          qCInfo(LOG_VisualizationGraphHelper()) << "TORM: Current points in cache"
                                                                 << xData.count();
                          auto sqpDataContainer = QSharedPointer<SqpDataContainer>::create();
                          qcpGraph->setData(sqpDataContainer);
                          auto lowerIt = std::lower_bound(xDataBegin, xDataEnd, dateTime.m_TStart);
                          auto upperIt = std::upper_bound(xDataBegin, xDataEnd, dateTime.m_TEnd);
                          auto distance = std::distance(xDataBegin, lowerIt);
                          auto valuesDataIt = valuesData.cbegin() + distance;
                          for (auto xAxisDataIt = lowerIt; xAxisDataIt != upperIt;
                               ++xAxisDataIt, ++valuesDataIt) {
                              sqpDataContainer->appendGraphData(QCPGraphData(*xAxisDataIt, *valuesDataIt));
                          }
                          qCInfo(LOG_VisualizationGraphHelper()) << "TORM: Current points displayed"
                                                                 << sqpDataContainer->size();
                      }
                      scalarSeries.unlock();
                      // Display all data
                      component->parentPlot()->replot();
                  }
                  else {
                      /// @todo DEBUG
                  }
              }
              QCPAbstractPlottable *createScalarSeriesComponent(ScalarSeries &scalarSeries, QCustomPlot &plot,
-                                                               const SqpDateTime &dateTime)
+                                                               const SqpRange &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)
+                                                       IDataSeries *dataSeries, const SqpRange &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 +8 -9

              #include "Visualization/VisualizationGraphWidget.h"
              #include "Visualization/IVisualizationWidgetVisitor.h"
              #include "Visualization/VisualizationGraphHelper.h"
              #include "Visualization/VisualizationGraphRenderingDelegate.h"
              #include "ui_VisualizationGraphWidget.h"
              #include <Data/ArrayData.h>
              #include <Data/IDataSeries.h>
              #include <Settings/SqpSettingsDefs.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;
              /// Gets a tolerance value from application settings. If the setting can't be found, the default
              /// value passed in parameter is returned
              double toleranceValue(const QString &key, double defaultValue) noexcept
              {
                  return QSettings{}.value(key, defaultValue).toDouble();
              }
              } // namespace
              struct VisualizationGraphWidget::VisualizationGraphWidgetPrivate {
                  explicit VisualizationGraphWidgetPrivate()
                          : m_DoSynchronize{true}, m_IsCalibration{false}, m_RenderingDelegate{nullptr}
                  {
                  }
                  // Return the operation when range changed
                  VisualizationGraphWidgetZoomType getZoomType(const QCPRange &t1, const QCPRange &t2);
                  // 1 variable -> n qcpplot
                  std::multimap<std::shared_ptr<Variable>, QCPAbstractPlottable *> m_VariableToPlotMultiMap;
                  bool m_DoSynchronize;
                  bool m_IsCalibration;
                  QCPItemTracer *m_TextTracer;
                  /// Delegate used to attach rendering features to the plot
                  std::unique_ptr<VisualizationGraphRenderingDelegate> m_RenderingDelegate;
              };
              VisualizationGraphWidget::VisualizationGraphWidget(const QString &name, QWidget *parent)
                      : QWidget{parent},
                        ui{new Ui::VisualizationGraphWidget},
                        impl{spimpl::make_unique_impl<VisualizationGraphWidgetPrivate>()}
              {
                  ui->setupUi(this);
                  // The delegate must be initialized after the ui as it uses the plot
                  impl->m_RenderingDelegate = std::make_unique<VisualizationGraphRenderingDelegate>(*ui->widget);
                  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::mousePress, this, &VisualizationGraphWidget::onMousePress);
                  connect(ui->widget, &QCustomPlot::mouseRelease, this,
                          &VisualizationGraphWidget::onMouseRelease);
                  connect(ui->widget, &QCustomPlot::mouseMove, this, &VisualizationGraphWidget::onMouseMove);
                  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, Qt::DirectConnection);
                  // 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::enableSynchronize(bool enable)
              {
                  impl->m_DoSynchronize = enable;
              }
              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(updated()), this, SLOT(onDataCacheVariableUpdated()));
              }
              void VisualizationGraphWidget::addVariableUsingGraph(std::shared_ptr<Variable> variable)
              {
                  // when adding a variable, we need to set its time range to the current graph range
                  auto grapheRange = ui->widget->xAxis->range();
-                 auto dateTime = SqpDateTime{grapheRange.lower, grapheRange.upper};
+                 auto dateTime = SqpRange{grapheRange.lower, grapheRange.upper};
                  variable->setDateTime(dateTime);
                  auto variableDateTimeWithTolerance = dateTime;
                  // add tolerance for each side
                  auto toleranceFactor
                      = toleranceValue(GENERAL_TOLERANCE_AT_INIT_KEY, GENERAL_TOLERANCE_AT_INIT_DEFAULT_VALUE);
                  auto tolerance = toleranceFactor * (dateTime.m_TEnd - dateTime.m_TStart);
                  variableDateTimeWithTolerance.m_TStart -= tolerance;
                  variableDateTimeWithTolerance.m_TEnd += tolerance;
                  // 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(updated()), this, SLOT(onDataCacheVariableUpdated()));
                  // CHangement detected, we need to ask controller to request data loading
                  emit requestDataLoading(variable, variableDateTimeWithTolerance);
              }
              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::setRange(std::shared_ptr<Variable> variable,
-                                                     const SqpDateTime &range)
+             void VisualizationGraphWidget::setRange(std::shared_ptr<Variable> variable, const SqpRange &range)
              {
                  // Note: in case of different axes that depends on variable, we could start with a code like
                  // that:
                  //    auto componentsIt = impl->m_VariableToPlotMultiMap.equal_range(variable);
                  //    for (auto it = componentsIt.first; it != componentsIt.second;) {
                  //    }
                  ui->widget->xAxis->setRange(range.m_TStart, range.m_TEnd);
                  ui->widget->replot();
              }
-             SqpDateTime VisualizationGraphWidget::graphRange() const noexcept
+             SqpRange VisualizationGraphWidget::graphRange() const noexcept
              {
                  auto grapheRange = ui->widget->xAxis->range();
-                 return SqpDateTime{grapheRange.lower, grapheRange.upper};
+                 return SqpRange{grapheRange.lower, grapheRange.upper};
              }
-             void VisualizationGraphWidget::setGraphRange(const SqpDateTime &range)
+             void VisualizationGraphWidget::setGraphRange(const SqpRange &range)
              {
                  qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::setGraphRange START");
                  ui->widget->xAxis->setRange(range.m_TStart, range.m_TEnd);
                  ui->widget->replot();
                  qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::setGraphRange END");
              }
              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;
              }
              bool VisualizationGraphWidget::contains(const Variable &variable) const
              {
                  // Finds the variable among the keys of the map
                  auto variablePtr = &variable;
                  auto findVariable
                      = [variablePtr](const auto &entry) { return variablePtr == entry.first.get(); };
                  auto end = impl->m_VariableToPlotMultiMap.cend();
                  auto it = std::find_if(impl->m_VariableToPlotMultiMap.cbegin(), end, findVariable);
                  return it != end;
              }
              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)
              {
                  qCInfo(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::onRangeChanged")
                                                         << QThread::currentThread()->objectName();
-                 auto dateTimeRange = SqpDateTime{t1.lower, t1.upper};
+                 auto dateTimeRange = SqpRange{t1.lower, t1.upper};
                  auto zoomType = impl->getZoomType(t1, t2);
                  for (auto it = impl->m_VariableToPlotMultiMap.cbegin();
                       it != impl->m_VariableToPlotMultiMap.cend(); ++it) {
                      auto variable = it->first;
                      auto currentDateTime = dateTimeRange;
                      auto toleranceFactor = toleranceValue(GENERAL_TOLERANCE_AT_UPDATE_KEY,
                                                            GENERAL_TOLERANCE_AT_UPDATE_DEFAULT_VALUE);
                      auto tolerance = toleranceFactor * (currentDateTime.m_TEnd - currentDateTime.m_TStart);
                      auto variableDateTimeWithTolerance = currentDateTime;
                      variableDateTimeWithTolerance.m_TStart -= tolerance;
                      variableDateTimeWithTolerance.m_TEnd += tolerance;
                      qCDebug(LOG_VisualizationGraphWidget()) << "r" << currentDateTime;
                      qCDebug(LOG_VisualizationGraphWidget()) << "t" << variableDateTimeWithTolerance;
                      qCDebug(LOG_VisualizationGraphWidget()) << "v" << variable->dateTime();
                      // If new range with tol is upper than variable datetime parameters. we need to request new
                      // data
                      if (!variable->contains(variableDateTimeWithTolerance)) {
                          auto variableDateTimeWithTolerance = currentDateTime;
                          if (!variable->isInside(currentDateTime)) {
                              auto variableDateTime = variable->dateTime();
                              if (variable->contains(variableDateTimeWithTolerance)) {
                                  qCDebug(LOG_VisualizationGraphWidget())
                                      << tr("TORM: Detection zoom in that need request:");
                                  // add tolerance for each side
                                  tolerance
                                      = toleranceFactor * (currentDateTime.m_TEnd - currentDateTime.m_TStart);
                                  variableDateTimeWithTolerance.m_TStart -= tolerance;
                                  variableDateTimeWithTolerance.m_TEnd += tolerance;
                              }
                              else if (variableDateTime.m_TStart < currentDateTime.m_TStart) {
                                  qCInfo(LOG_VisualizationGraphWidget()) << tr("TORM: Detection pan to right:");
                                  auto diffEndToKeepDelta = currentDateTime.m_TEnd - variableDateTime.m_TEnd;
                                  currentDateTime.m_TStart = variableDateTime.m_TStart + diffEndToKeepDelta;
                                  // Tolerance have to be added to the right
                                  // add tolerance for right (end) side
                                  tolerance
                                      = toleranceFactor * (currentDateTime.m_TEnd - currentDateTime.m_TStart);
                                  variableDateTimeWithTolerance.m_TEnd += tolerance;
                              }
                              else if (variableDateTime.m_TEnd > currentDateTime.m_TEnd) {
                                  qCDebug(LOG_VisualizationGraphWidget()) << tr("TORM: Detection pan to left: ");
                                  auto diffStartToKeepDelta
                                      = variableDateTime.m_TStart - currentDateTime.m_TStart;
                                  currentDateTime.m_TEnd = variableDateTime.m_TEnd - diffStartToKeepDelta;
                                  // Tolerance have to be added to the left
                                  // add tolerance for left (start) side
                                  tolerance
                                      = toleranceFactor * (currentDateTime.m_TEnd - currentDateTime.m_TStart);
                                  variableDateTimeWithTolerance.m_TStart -= tolerance;
                              }
                              else {
                                  qCCritical(LOG_VisualizationGraphWidget())
                                      << tr("Detection anormal zoom detection: ");
                              }
                          }
                          else {
                              qCDebug(LOG_VisualizationGraphWidget()) << tr("TORM: Detection zoom out: ");
                              // add tolerance for each side
                              tolerance = toleranceFactor * (currentDateTime.m_TEnd - currentDateTime.m_TStart);
                              variableDateTimeWithTolerance.m_TStart -= tolerance;
                              variableDateTimeWithTolerance.m_TEnd += tolerance;
                              zoomType = VisualizationGraphWidgetZoomType::ZoomOut;
                          }
                          if (!variable->contains(dateTimeRange)) {
                              qCDebug(LOG_VisualizationGraphWidget())
                                  << "TORM: Modif on variable datetime detected" << currentDateTime;
                              variable->setDateTime(currentDateTime);
                          }
                          qCDebug(LOG_VisualizationGraphWidget()) << tr("TORM: Request data detection: ");
                          // CHangement detected, we need to ask controller to request data loading
                          emit requestDataLoading(variable, variableDateTimeWithTolerance);
                      }
                      else {
                          qCInfo(LOG_VisualizationGraphWidget())
                              << tr("TORM: Detection zoom in that doesn't need request: ");
                          zoomType = VisualizationGraphWidgetZoomType::ZoomIn;
                      }
                  }
                  if (impl->m_DoSynchronize && !impl->m_IsCalibration) {
-                     auto oldDateTime = SqpDateTime{t2.lower, t2.upper};
+                     auto oldDateTime = SqpRange{t2.lower, t2.upper};
                      qCDebug(LOG_VisualizationGraphWidget())
                          << tr("TORM: VisualizationGraphWidget::Synchronize notify !!")
                          << QThread::currentThread()->objectName();
                      emit synchronize(dateTimeRange, oldDateTime, zoomType);
                  }
              }
              void VisualizationGraphWidget::onMouseMove(QMouseEvent *event) noexcept
              {
                  // Handles plot rendering when mouse is moving
                  impl->m_RenderingDelegate->onMouseMove(event);
              }
              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::onMousePress(QMouseEvent *event) noexcept
              {
                  impl->m_IsCalibration = event->modifiers().testFlag(Qt::ControlModifier);
              }
              void VisualizationGraphWidget::onMouseRelease(QMouseEvent *event) noexcept
              {
                  impl->m_IsCalibration = false;
              }
              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
                  auto grapheRange = ui->widget->xAxis->range();
-                 auto dateTime = SqpDateTime{grapheRange.lower, grapheRange.upper};
+                 auto dateTime = SqpRange{grapheRange.lower, grapheRange.upper};
                  for (auto it = impl->m_VariableToPlotMultiMap.cbegin();
                       it != impl->m_VariableToPlotMultiMap.cend(); ++it) {
                      auto variable = it->first;
                      qCDebug(LOG_VisualizationGraphWidget())
                          << "TORM: VisualizationGraphWidget::onDataCacheVariableUpdated S"
                          << variable->dateTime();
                      qCDebug(LOG_VisualizationGraphWidget())
                          << "TORM: VisualizationGraphWidget::onDataCacheVariableUpdated E" << dateTime;
                      if (dateTime.contains(variable->dateTime()) || dateTime.intersect(variable->dateTime())) {
                          VisualizationGraphHelper::updateData(QVector<QCPAbstractPlottable *>{} << it->second,
                                                               variable->dataSeries(), variable->dateTime());
                      }
                  }
              }
              VisualizationGraphWidgetZoomType
              VisualizationGraphWidget::VisualizationGraphWidgetPrivate::getZoomType(const QCPRange &t1,
                                                                                     const QCPRange &t2)
              {
                  // t1.lower <= t2.lower && t2.upper <= t1.upper
                  auto zoomType = VisualizationGraphWidgetZoomType::Unknown;
                  if (t1.lower <= t2.lower && t2.upper <= t1.upper) {
                      zoomType = VisualizationGraphWidgetZoomType::ZoomOut;
                  }
                  else if (t1.lower > t2.lower && t1.upper > t2.upper) {
                      zoomType = VisualizationGraphWidgetZoomType::PanRight;
                  }
                  else if (t1.lower < t2.lower && t1.upper < t2.upper) {
                      zoomType = VisualizationGraphWidgetZoomType::PanLeft;
                  }
                  else if (t1.lower > t2.lower && t2.upper > t1.upper) {
                      zoomType = VisualizationGraphWidgetZoomType::ZoomIn;
                  }
                  else {
                      qCCritical(LOG_VisualizationGraphWidget()) << "getZoomType: Unknown type detected";
                  }
                  return zoomType;
              }

gui/src/Visualization/VisualizationWidget.cpp +1 -1

              #include "Visualization/VisualizationWidget.h"
              #include "Visualization/IVisualizationWidgetVisitor.h"
              #include "Visualization/VisualizationGraphWidget.h"
              #include "Visualization/VisualizationTabWidget.h"
              #include "Visualization/VisualizationZoneWidget.h"
              #include "Visualization/operations/GenerateVariableMenuOperation.h"
              #include "Visualization/operations/RemoveVariableOperation.h"
              #include "Visualization/operations/RescaleAxeOperation.h"
              #include "Visualization/qcustomplot.h"
              #include "ui_VisualizationWidget.h"
              #include <QToolButton>
              Q_LOGGING_CATEGORY(LOG_VisualizationWidget, "VisualizationWidget")
              VisualizationWidget::VisualizationWidget(QWidget *parent)
                      : QWidget{parent}, ui{new Ui::VisualizationWidget}
              {
                  ui->setupUi(this);
                  auto addTabViewButton = new QToolButton{ui->tabWidget};
                  addTabViewButton->setText(tr("Add View"));
                  addTabViewButton->setCursor(Qt::ArrowCursor);
                  ui->tabWidget->setCornerWidget(addTabViewButton, Qt::TopRightCorner);
                  auto enableMinimumCornerWidgetSize = [this](bool enable) {
                      auto tabViewCornerWidget = ui->tabWidget->cornerWidget();
                      auto width = enable ? tabViewCornerWidget->width() : 0;
                      auto height = enable ? tabViewCornerWidget->height() : 0;
                      tabViewCornerWidget->setMinimumHeight(height);
                      tabViewCornerWidget->setMinimumWidth(width);
                      ui->tabWidget->setMinimumHeight(height);
                      ui->tabWidget->setMinimumWidth(width);
                  };
                  auto addTabView = [this, enableMinimumCornerWidgetSize]() {
                      auto widget = new VisualizationTabWidget{QString{"View %1"}.arg(ui->tabWidget->count() + 1),
                                                               ui->tabWidget};
                      auto index = ui->tabWidget->addTab(widget, widget->name());
                      if (ui->tabWidget->count() > 0) {
                          enableMinimumCornerWidgetSize(false);
                      }
                      qCInfo(LOG_VisualizationWidget()) << tr("add the tab of index %1").arg(index);
                  };
                  auto removeTabView = [this, enableMinimumCornerWidgetSize](int index) {
                      if (ui->tabWidget->count() == 1) {
                          enableMinimumCornerWidgetSize(true);
                      }
                      // Removes widget from tab and closes it
                      auto widget = ui->tabWidget->widget(index);
                      ui->tabWidget->removeTab(index);
                      if (widget) {
                          widget->close();
                      }
                      qCInfo(LOG_VisualizationWidget()) << tr("remove the tab of index %1").arg(index);
                  };
                  ui->tabWidget->setTabsClosable(true);
                  connect(addTabViewButton, &QToolButton::clicked, addTabView);
                  connect(ui->tabWidget, &QTabWidget::tabCloseRequested, removeTabView);
                  // Adds default tab
                  addTabView();
              }
              VisualizationWidget::~VisualizationWidget()
              {
                  delete ui;
              }
              void VisualizationWidget::accept(IVisualizationWidgetVisitor *visitor)
              {
                  if (visitor) {
                      visitor->visitEnter(this);
                      // Apply visitor for tab children
                      for (auto i = 0; i < ui->tabWidget->count(); ++i) {
                          // Widgets different from tabs are not visited (no action)
                          if (auto visualizationTabWidget
                              = dynamic_cast<VisualizationTabWidget *>(ui->tabWidget->widget(i))) {
                              visualizationTabWidget->accept(visitor);
                          }
                      }
                      visitor->visitLeave(this);
                  }
                  else {
                      qCCritical(LOG_VisualizationWidget()) << tr("Can't visit widget : the visitor is null");
                  }
              }
              bool VisualizationWidget::canDrop(const Variable &variable) const
              {
                  // The main widget can never accomodate a variable
                  Q_UNUSED(variable);
                  return false;
              }
              bool VisualizationWidget::contains(const Variable &variable) const
              {
                  Q_UNUSED(variable);
                  return false;
              }
              QString VisualizationWidget::name() const
              {
                  return QStringLiteral("MainView");
              }
              void VisualizationWidget::attachVariableMenu(
                  QMenu *menu, const QVector<std::shared_ptr<Variable> > &variables) noexcept
              {
                  // Menu is generated only if there is a single variable
                  if (variables.size() == 1) {
                      if (auto variable = variables.first()) {
                          // Generates the actions that make it possible to visualize the variable
                          auto generateVariableMenuOperation = GenerateVariableMenuOperation{menu, variable};
                          accept(&generateVariableMenuOperation);
                      }
                      else {
                          qCCritical(LOG_VisualizationWidget()) << tr(
                              "Can't generate the menu relative to the visualization: the variable is null");
                      }
                  }
                  else {
                      qCDebug(LOG_VisualizationWidget())
                          << tr("No generation of the menu related to the visualization: several variables are "
                                "selected");
                  }
              }
              void VisualizationWidget::onVariableAboutToBeDeleted(std::shared_ptr<Variable> variable) noexcept
              {
                  // Calls the operation of removing all references to the variable in the visualization
                  auto removeVariableOperation = RemoveVariableOperation{variable};
                  accept(&removeVariableOperation);
              }
              void VisualizationWidget::onRangeChanged(std::shared_ptr<Variable> variable,
-                                                      const SqpDateTime &range) noexcept
+                                                      const SqpRange &range) noexcept
              {
                  // Calls the operation of rescaling all graph that contrains variable in the visualization
                  auto rescaleVariableOperation = RescaleAxeOperation{variable, range};
                  accept(&rescaleVariableOperation);
              }

gui/src/Visualization/VisualizationZoneWidget.cpp +3 -3

              #include "Visualization/VisualizationZoneWidget.h"
-             #include "Data/SqpDateTime.h"
+             #include "Data/SqpRange.h"
              #include "Visualization/IVisualizationWidgetVisitor.h"
              #include "Visualization/VisualizationGraphWidget.h"
              #include "ui_VisualizationZoneWidget.h"
              #include <SqpApplication.h>
              Q_LOGGING_CATEGORY(LOG_VisualizationZoneWidget, "VisualizationZoneWidget")
              namespace {
              /// Minimum height for graph added in zones (in pixels)
              const auto GRAPH_MINIMUM_HEIGHT = 300;
              /// Generates a default name for a new graph, according to the number of graphs already displayed in
              /// the zone
              QString defaultGraphName(const QLayout &layout)
              {
                  auto count = 0;
                  for (auto i = 0; i < layout.count(); ++i) {
                      if (dynamic_cast<VisualizationGraphWidget *>(layout.itemAt(i)->widget())) {
                          count++;
                      }
                  }
                  return QObject::tr("Graph %1").arg(count + 1);
              }
              } // namespace
              VisualizationZoneWidget::VisualizationZoneWidget(const QString &name, QWidget *parent)
                      : QWidget{parent}, ui{new Ui::VisualizationZoneWidget}
              {
                  ui->setupUi(this);
                  ui->zoneNameLabel->setText(name);
                  // 'Close' options : widget is deleted when closed
                  setAttribute(Qt::WA_DeleteOnClose);
                  connect(ui->closeButton, &QToolButton::clicked, this, &VisualizationZoneWidget::close);
                  ui->closeButton->setIcon(sqpApp->style()->standardIcon(QStyle::SP_TitleBarCloseButton));
              }
              VisualizationZoneWidget::~VisualizationZoneWidget()
              {
                  delete ui;
              }
              void VisualizationZoneWidget::addGraph(VisualizationGraphWidget *graphWidget)
              {
                  ui->visualizationZoneFrame->layout()->addWidget(graphWidget);
              }
              VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<Variable> variable)
              {
                  auto graphWidget = new VisualizationGraphWidget{
                      defaultGraphName(*ui->visualizationZoneFrame->layout()), this};
                  // Set graph properties
                  graphWidget->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::MinimumExpanding);
                  graphWidget->setMinimumHeight(GRAPH_MINIMUM_HEIGHT);
                  this->addGraph(graphWidget);
                  graphWidget->addVariable(variable);
                  // Lambda to synchronize zone widget
-                 auto synchronizeZoneWidget = [this, graphWidget](const SqpDateTime &dateTime,
-                                                                  const SqpDateTime &oldDateTime,
+                 auto synchronizeZoneWidget = [this, graphWidget](const SqpRange &dateTime,
+                                                                  const SqpRange &oldDateTime,
                                                                   VisualizationGraphWidgetZoomType zoomType) {
                      auto frameLayout = ui->visualizationZoneFrame->layout();
                      for (auto i = 0; i < frameLayout->count(); ++i) {
                          auto graphChild
                              = dynamic_cast<VisualizationGraphWidget *>(frameLayout->itemAt(i)->widget());
                          if (graphChild && (graphChild != graphWidget)) {
                              auto graphChildRange = graphChild->graphRange();
                              switch (zoomType) {
                                  case VisualizationGraphWidgetZoomType::ZoomIn: {
                                      auto deltaLeft = dateTime.m_TStart - oldDateTime.m_TStart;
                                      auto deltaRight = oldDateTime.m_TEnd - dateTime.m_TEnd;
                                      graphChildRange.m_TStart += deltaLeft;
                                      graphChildRange.m_TEnd -= deltaRight;
                                      qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: ZoomIn");
                                      qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: deltaLeft")
                                                                                << deltaLeft;
                                      qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: deltaRight")
                                                                                << deltaRight;
                                      qCCritical(LOG_VisualizationZoneWidget())
                                          << tr("TORM: dt") << dateTime.m_TEnd - dateTime.m_TStart;
                                      break;
                                  }
                                  case VisualizationGraphWidgetZoomType::ZoomOut: {
                                      qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: ZoomOut");
                                      auto deltaLeft = oldDateTime.m_TStart - dateTime.m_TStart;
                                      auto deltaRight = dateTime.m_TEnd - oldDateTime.m_TEnd;
                                      qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: deltaLeft")
                                                                                << deltaLeft;
                                      qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: deltaRight")
                                                                                << deltaRight;
                                      qCCritical(LOG_VisualizationZoneWidget())
                                          << tr("TORM: dt") << dateTime.m_TEnd - dateTime.m_TStart;
                                      graphChildRange.m_TStart -= deltaLeft;
                                      graphChildRange.m_TEnd += deltaRight;
                                      break;
                                  }
                                  case VisualizationGraphWidgetZoomType::PanRight: {
                                      qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: PanRight");
                                      auto deltaRight = dateTime.m_TEnd - oldDateTime.m_TEnd;
                                      graphChildRange.m_TStart += deltaRight;
                                      graphChildRange.m_TEnd += deltaRight;
                                      qCCritical(LOG_VisualizationZoneWidget())
                                          << tr("TORM: dt") << dateTime.m_TEnd - dateTime.m_TStart;
                                      break;
                                  }
                                  case VisualizationGraphWidgetZoomType::PanLeft: {
                                      qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: PanLeft");
                                      auto deltaLeft = oldDateTime.m_TStart - dateTime.m_TStart;
                                      graphChildRange.m_TStart -= deltaLeft;
                                      graphChildRange.m_TEnd -= deltaLeft;
                                      break;
                                  }
                                  case VisualizationGraphWidgetZoomType::Unknown: {
                                      qCCritical(LOG_VisualizationZoneWidget())
                                          << tr("Impossible to synchronize: zoom type unknown");
                                      break;
                                  }
                                  default:
                                      qCCritical(LOG_VisualizationZoneWidget())
                                          << tr("Impossible to synchronize: zoom type not take into account");
                                      // No action
                                      break;
                              }
                              graphChild->enableSynchronize(false);
                              qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: Range before: ")
                                                                        << graphChild->graphRange();
                              qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: Range after : ")
                                                                        << graphChildRange;
                              qCCritical(LOG_VisualizationZoneWidget())
                                  << tr("TORM: child dt") << graphChildRange.m_TEnd - graphChildRange.m_TStart;
                              graphChild->setGraphRange(graphChildRange);
                              graphChild->enableSynchronize(true);
                          }
                      }
                  };
                  // connection for synchronization
                  connect(graphWidget, &VisualizationGraphWidget::synchronize, synchronizeZoneWidget);
                  return graphWidget;
              }
              void VisualizationZoneWidget::accept(IVisualizationWidgetVisitor *visitor)
              {
                  if (visitor) {
                      visitor->visitEnter(this);
                      // Apply visitor to graph children
                      auto layout = ui->visualizationZoneFrame->layout();
                      for (auto i = 0; i < layout->count(); ++i) {
                          if (auto item = layout->itemAt(i)) {
                              // Widgets different from graphs are not visited (no action)
                              if (auto visualizationGraphWidget
                                  = dynamic_cast<VisualizationGraphWidget *>(item->widget())) {
                                  visualizationGraphWidget->accept(visitor);
                              }
                          }
                      }
                      visitor->visitLeave(this);
                  }
                  else {
                      qCCritical(LOG_VisualizationZoneWidget()) << tr("Can't visit widget : the visitor is null");
                  }
              }
              bool VisualizationZoneWidget::canDrop(const Variable &variable) const
              {
                  // A tab can always accomodate a variable
                  Q_UNUSED(variable);
                  return true;
              }
              bool VisualizationZoneWidget::contains(const Variable &variable) const
              {
                  Q_UNUSED(variable);
                  return false;
              }
              QString VisualizationZoneWidget::name() const
              {
                  return ui->zoneNameLabel->text();
              }

gui/src/Visualization/operations/RescaleAxeOperation.cpp +3 -5

              #include "Visualization/operations/RescaleAxeOperation.h"
              #include "Visualization/VisualizationGraphWidget.h"
              Q_LOGGING_CATEGORY(LOG_RescaleAxeOperation, "RescaleAxeOperation")
              struct RescaleAxeOperation::RescaleAxeOperationPrivate {
-                 explicit RescaleAxeOperationPrivate(std::shared_ptr<Variable> variable,
-                                                     const SqpDateTime &range)
+                 explicit RescaleAxeOperationPrivate(std::shared_ptr<Variable> variable, const SqpRange &range)
                          : m_Variable{variable}, m_Range{range}
                  {
                  }
                  std::shared_ptr<Variable> m_Variable;
-                 SqpDateTime m_Range;
+                 SqpRange m_Range;
              };
-             RescaleAxeOperation::RescaleAxeOperation(std::shared_ptr<Variable> variable,
-                                                      const SqpDateTime &range)
+             RescaleAxeOperation::RescaleAxeOperation(std::shared_ptr<Variable> variable, const SqpRange &range)
                      : impl{spimpl::make_unique_impl<RescaleAxeOperationPrivate>(variable, range)}
              {
              }
              void RescaleAxeOperation::visitEnter(VisualizationWidget *widget)
              {
                  // VisualizationWidget is not intended to contain a variable
                  Q_UNUSED(widget)
              }
              void RescaleAxeOperation::visitLeave(VisualizationWidget *widget)
              {
                  // VisualizationWidget is not intended to contain a variable
                  Q_UNUSED(widget)
              }
              void RescaleAxeOperation::visitEnter(VisualizationTabWidget *tabWidget)
              {
                  // VisualizationTabWidget is not intended to contain a variable
                  Q_UNUSED(tabWidget)
              }
              void RescaleAxeOperation::visitLeave(VisualizationTabWidget *tabWidget)
              {
                  // VisualizationTabWidget is not intended to contain a variable
                  Q_UNUSED(tabWidget)
              }
              void RescaleAxeOperation::visitEnter(VisualizationZoneWidget *zoneWidget)
              {
                  // VisualizationZoneWidget is not intended to contain a variable
                  Q_UNUSED(zoneWidget)
              }
              void RescaleAxeOperation::visitLeave(VisualizationZoneWidget *zoneWidget)
              {
                  // VisualizationZoneWidget is not intended to contain a variable
                  Q_UNUSED(zoneWidget)
              }
              void RescaleAxeOperation::visit(VisualizationGraphWidget *graphWidget)
              {
                  if (graphWidget) {
                      // If the widget contains the variable, rescale it
                      if (impl->m_Variable && graphWidget->contains(*impl->m_Variable)) {
                          graphWidget->setRange(impl->m_Variable, impl->m_Range);
                      }
                  }
                  else {
                      qCCritical(LOG_RescaleAxeOperation(),
                                 "Can't visit VisualizationGraphWidget : the widget is null");
                  }
              }

plugins/amda/include/AmdaProvider.h +1 -1

              #ifndef SCIQLOP_AMDAPROVIDER_H
              #define SCIQLOP_AMDAPROVIDER_H
              #include "AmdaGlobal.h"
              #include <Data/IDataProvider.h>
              #include <QLoggingCategory>
              Q_DECLARE_LOGGING_CATEGORY(LOG_AmdaProvider)
              class QNetworkReply;
              /**
               * @brief The AmdaProvider class is an example of how a data provider can generate data
               */
              class SCIQLOP_AMDA_EXPORT AmdaProvider : public IDataProvider {
              public:
                  explicit AmdaProvider();
                  void requestDataLoading(QUuid token, const DataProviderParameters &parameters) override;
                  void requestDataAborting(QUuid identifier) override;
              private:
-                 void retrieveData(QUuid token, const SqpDateTime &dateTime, const QVariantHash &data);
+                 void retrieveData(QUuid token, const SqpRange &dateTime, const QVariantHash &data);
              };
              #endif // SCIQLOP_AMDAPROVIDER_H

plugins/amda/src/AmdaProvider.cpp +3 -3

              #include "AmdaProvider.h"
              #include "AmdaDefs.h"
              #include "AmdaResultParser.h"
              #include <Common/DateUtils.h>
              #include <Data/DataProviderParameters.h>
              #include <Network/NetworkController.h>
              #include <SqpApplication.h>
              #include <Variable/Variable.h>
              #include <QNetworkAccessManager>
              #include <QNetworkReply>
              #include <QTemporaryFile>
              #include <QThread>
              Q_LOGGING_CATEGORY(LOG_AmdaProvider, "AmdaProvider")
              namespace {
              /// URL format for a request on AMDA server. The parameters are as follows:
              /// - %1: start date
              /// - %2: end date
              /// - %3: parameter id
              const auto AMDA_URL_FORMAT = QStringLiteral(
                  "http://amda.irap.omp.eu/php/rest/"
                  "getParameter.php?startTime=%1&stopTime=%2&parameterID=%3&outputFormat=ASCII&"
                  "timeFormat=ISO8601&gzip=0");
              /// Dates format passed in the URL (e.g 2013-09-23T09:00)
              const auto AMDA_TIME_FORMAT = QStringLiteral("yyyy-MM-ddThh:mm:ss");
              /// Formats a time to a date that can be passed in URL
-             QString dateFormat(double sqpDateTime) noexcept
+             QString dateFormat(double sqpRange) noexcept
              {
-                 auto dateTime = DateUtils::dateTime(sqpDateTime);
+                 auto dateTime = DateUtils::dateTime(sqpRange);
                  return dateTime.toString(AMDA_TIME_FORMAT);
              }
              } // namespace
              AmdaProvider::AmdaProvider()
              {
                  qCDebug(LOG_AmdaProvider()) << tr("AmdaProvider::AmdaProvider") << QThread::currentThread();
                  if (auto app = sqpApp) {
                      auto &networkController = app->networkController();
                      connect(this, SIGNAL(requestConstructed(QNetworkRequest, QUuid,
                                                              std::function<void(QNetworkReply *, QUuid)>)),
                              &networkController,
                              SLOT(onProcessRequested(QNetworkRequest, QUuid,
                                                      std::function<void(QNetworkReply *, QUuid)>)));
                      connect(&sqpApp->networkController(), SIGNAL(replyDownloadProgress(QUuid, double)), this,
                              SIGNAL(dataProvidedProgress(QUuid, double)));
                  }
              }
              void AmdaProvider::requestDataLoading(QUuid token, const DataProviderParameters &parameters)
              {
                  // NOTE: Try to use multithread if possible
                  const auto times = parameters.m_Times;
                  const auto data = parameters.m_Data;
                  for (const auto &dateTime : qAsConst(times)) {
                      retrieveData(token, dateTime, data);
                  }
              }
              void AmdaProvider::requestDataAborting(QUuid identifier)
              {
                  if (auto app = sqpApp) {
                      auto &networkController = app->networkController();
                      networkController.onReplyCanceled(identifier);
                  }
              }
-             void AmdaProvider::retrieveData(QUuid token, const SqpDateTime &dateTime, const QVariantHash &data)
+             void AmdaProvider::retrieveData(QUuid token, const SqpRange &dateTime, const QVariantHash &data)
              {
                  // Retrieves product ID from data: if the value is invalid, no request is made
                  auto productId = data.value(AMDA_XML_ID_KEY).toString();
                  if (productId.isNull()) {
                      qCCritical(LOG_AmdaProvider()) << tr("Can't retrieve data: unknown product id");
                      return;
                  }
                  qCInfo(LOG_AmdaProvider()) << tr("AmdaProvider::retrieveData") << dateTime;
                  // /////////// //
                  // Creates URL //
                  // /////////// //
                  auto startDate = dateFormat(dateTime.m_TStart);
                  auto endDate = dateFormat(dateTime.m_TEnd);
                  auto url = QUrl{QString{AMDA_URL_FORMAT}.arg(startDate, endDate, productId)};
                  qCInfo(LOG_AmdaProvider()) << tr("AmdaProvider::retrieveData url:") << url;
                  auto tempFile = std::make_shared<QTemporaryFile>();
                  // LAMBDA
                  auto httpDownloadFinished
                      = [this, dateTime, tempFile, token](QNetworkReply *reply, QUuid dataId) noexcept {
                            Q_UNUSED(dataId);
                            // Don't do anything if the reply was abort
                            if (reply->error() != QNetworkReply::OperationCanceledError) {
                                if (tempFile) {
                                    auto replyReadAll = reply->readAll();
                                    if (!replyReadAll.isEmpty()) {
                                        tempFile->write(replyReadAll);
                                    }
                                    tempFile->close();
                                    // Parse results file
                                    if (auto dataSeries = AmdaResultParser::readTxt(tempFile->fileName())) {
                                        emit dataProvided(token, dataSeries, dateTime);
                                    }
                                    else {
                                        /// @todo ALX : debug
                                    }
                                }
                            }
                        };
                  auto httpFinishedLambda
                      = [this, httpDownloadFinished, tempFile](QNetworkReply *reply, QUuid dataId) noexcept {
                            // Don't do anything if the reply was abort
                            if (reply->error() != QNetworkReply::OperationCanceledError) {
                                auto downloadFileUrl = QUrl{QString{reply->readAll()}};
                                qCInfo(LOG_AmdaProvider()) << tr("AmdaProvider::retrieveData downloadFileUrl:")
                                                           << downloadFileUrl;
                                // Executes request for downloading file //
                                // Creates destination file
                                if (tempFile->open()) {
                                    // Executes request
                                    emit requestConstructed(QNetworkRequest{downloadFileUrl}, dataId,
                                                            httpDownloadFinished);
                                }
                            }
                        };
                  // //////////////// //
                  // Executes request //
                  // //////////////// //
                  emit requestConstructed(QNetworkRequest{url}, token, httpFinishedLambda);
              }

plugins/mockplugin/include/CosinusProvider.h +1 -1

              #ifndef SCIQLOP_COSINUSPROVIDER_H
              #define SCIQLOP_COSINUSPROVIDER_H
              #include "MockPluginGlobal.h"
              #include <Data/IDataProvider.h>
              #include <QLoggingCategory>
              #include <QUuid>
              #include <QHash>
              Q_DECLARE_LOGGING_CATEGORY(LOG_CosinusProvider)
              /**
               * @brief The CosinusProvider class is an example of how a data provider can generate data
               */
              class SCIQLOP_MOCKPLUGIN_EXPORT CosinusProvider : public IDataProvider {
              public:
                  /// @sa IDataProvider::requestDataLoading(). The current impl isn't thread safe.
                  void requestDataLoading(QUuid token, const DataProviderParameters &parameters) override;
                  /// @sa IDataProvider::requestDataAborting(). The current impl isn't thread safe.
                  void requestDataAborting(QUuid identifier) override;
              private:
-                 std::shared_ptr<IDataSeries> retrieveData(QUuid token, const SqpDateTime &dateTime);
+                 std::shared_ptr<IDataSeries> retrieveData(QUuid token, const SqpRange &dateTime);
                  QHash<QUuid, bool> m_VariableToEnableProvider;
              };
              #endif // SCIQLOP_COSINUSPROVIDER_H

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

              #include "CosinusProvider.h"
              #include <Data/DataProviderParameters.h>
              #include <Data/ScalarSeries.h>
              #include <cmath>
              #include <QFuture>
              #include <QThread>
              #include <QtConcurrent/QtConcurrent>
              Q_LOGGING_CATEGORY(LOG_CosinusProvider, "CosinusProvider")
-             std::shared_ptr<IDataSeries> CosinusProvider::retrieveData(QUuid token, const SqpDateTime &dateTime)
+             std::shared_ptr<IDataSeries> CosinusProvider::retrieveData(QUuid token, const SqpRange &dateTime)
              {
                  // TODO: Add Mutex
                  auto dataIndex = 0;
                  // Gets the timerange from the parameters
                  double freq = 100.0;
                  double start = std::ceil(dateTime.m_TStart * freq); // 100 htz
                  double end = std::floor(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 dataCount = end - start;
                  auto xAxisData = QVector<double>{};
                  xAxisData.resize(dataCount);
                  auto valuesData = QVector<double>{};
                  valuesData.resize(dataCount);
                  int progress = 0;
                  auto progressEnd = dataCount;
                  for (auto time = start; time < end; ++time, ++dataIndex) {
                      auto it = m_VariableToEnableProvider.find(token);
                      if (it != m_VariableToEnableProvider.end() && it.value()) {
                          const auto timeOnFreq = time / freq;
                          xAxisData.replace(dataIndex, timeOnFreq);
                          valuesData.replace(dataIndex, std::cos(timeOnFreq));
                          // progression
                          int currentProgress = (time - start) * 100.0 / progressEnd;
                          if (currentProgress != progress) {
                              progress = currentProgress;
                              emit dataProvidedProgress(token, progress);
                          }
                      }
                      else {
                          if (!it.value()) {
                              qCDebug(LOG_CosinusProvider())
                                  << "CosinusProvider::retrieveData: ARRET De l'acquisition detecté"
                                  << end - time;
                          }
                      }
                  }
                  emit dataProvidedProgress(token, 0.0);
                  return std::make_shared<ScalarSeries>(std::move(xAxisData), std::move(valuesData),
                                                        Unit{QStringLiteral("t"), true}, Unit{});
              }
              void CosinusProvider::requestDataLoading(QUuid token, const DataProviderParameters &parameters)
              {
                  // TODO: Add Mutex
                  m_VariableToEnableProvider[token] = true;
                  qCDebug(LOG_CosinusProvider()) << "CosinusProvider::requestDataLoading"
                                                 << QThread::currentThread()->objectName();
                  // NOTE: Try to use multithread if possible
                  const auto times = parameters.m_Times;
                  for (const auto &dateTime : qAsConst(times)) {
                      if (m_VariableToEnableProvider[token]) {
                          auto scalarSeries = this->retrieveData(token, dateTime);
                          emit dataProvided(token, scalarSeries, dateTime);
                      }
                  }
              }
              void CosinusProvider::requestDataAborting(QUuid identifier)
              {
                  // TODO: Add Mutex
                  qCDebug(LOG_CosinusProvider()) << "CosinusProvider::requestDataAborting" << identifier
                                                 << QThread::currentThread()->objectName();
                  auto it = m_VariableToEnableProvider.find(identifier);
                  if (it != m_VariableToEnableProvider.end()) {
                      it.value() = false;
                  }
                  else {
                      qCWarning(LOG_CosinusProvider())
                          << tr("Aborting progression of inexistant identifier detected !!!");
                  }
              }

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