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

Correction for pull request

perrinel -

r227:e94f13bbc48f

parent child

Context file:

r227:e94f13bbc48f

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

              #include <Data/ArrayData.h>
              #include <Data/IDataSeries.h>
+             #include <QLoggingCategory>
              #include <memory>
+             Q_DECLARE_LOGGING_CATEGORY(LOG_DataSeries)
+             Q_LOGGING_CATEGORY(LOG_DataSeries, "DataSeries")
              /**
               * @brief The DataSeries class is the base (abstract) implementation of IDataSeries.
               *
                          m_XAxisData->merge(dimDataSeries->xAxisData().get());
                          m_ValuesData->merge(dimDataSeries->valuesData().get());
                      }
+                     else {
+                         qCWarning(LOG_DataSeries())
+                             << QObject::tr("Dection of a type of IDataSeries we cannot merge with !");
+                     }
                  }
              protected:

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

                  virtual void requestDataLoading(const QVector<SqpDateTime> &dateTimeList) = 0;
              signals:
-                 void dataProvided(std::shared_ptr<IDataSeries> dateSerie, SqpDateTime dateTime);
+                 void dataProvided(std::shared_ptr<IDataSeries> dateSerie, const SqpDateTime &dateTime);
              };
              // Required for using shared_ptr in signals/slots
              Q_DECLARE_METATYPE(std::shared_ptr<IDataProvider>)

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

                  /// @return the data of the variable, nullptr if there is no data
                  IDataSeries *dataSeries() const noexcept;
-                 bool contains(SqpDateTime dateTime);
+                 bool contains(const SqpDateTime &dateTime);
                  void setDataSeries(std::unique_ptr<IDataSeries> dataSeries) noexcept;
              public slots:

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

              class Variable;
-             /// This class aims to store in the cash all of the dateTime already requested to the variable.
+             /// This class aims to store in the cache all of the dateTime already requested to the variable.
              class VariableCacheController : public QObject {
                  Q_OBJECT
              public:

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

                  return impl->m_DataSeries.get();
              }
-             bool Variable::contains(SqpDateTime dateTime)
+             bool Variable::contains(const SqpDateTime &dateTime)
              {
                  if (!impl->m_DateTime.contains(dateTime)) {
                      // The current variable dateTime isn't enough to display the dateTime requested.

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

              VariableCacheController::VariableCacheController(QObject *parent)
-                     : QObject(parent), impl{spimpl::make_unique_impl<VariableCacheControllerPrivate>()}
+                     : QObject{parent}, impl{spimpl::make_unique_impl<VariableCacheControllerPrivate>()}
              {
              }
                          //      will be compared to the next interval. The old one is remove from the list
                          //   C: if it is superior, we do the same with the next interval of the list
-                         int cacheIndex = 0;
                          impl->addDateTimeRecurse(dateTime, impl->m_VariableToSqpDateTimeListMap.at(variable),
-                                                  cacheIndex);
+);
                      }
                  }
              }
                      // 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);
                  }
                  auto currentDateTimeI = dateTimeList[cacheIndex];
-                 auto cacheIndexJ = cacheIndex;
                  if (currentTStart < currentDateTimeI.m_TStart) {
                      // ts localised between to interval: let's localized te
-                     addInCacheDataByEnd(dateTime, dateTimeList, notInCache, cacheIndexJ, currentTStart);
+                     addInCacheDataByEnd(dateTime, dateTimeList, notInCache, cacheIndex, currentTStart);
                  }
                  else if (dateTime.m_TStart < currentDateTimeI.m_TEnd) {
                      // ts not localised before the current interval: we need to look at the next interval

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

                      QElapsedTimer timer;
                      timer.start();
-                     qCInfo(LOG_VariableController()) << "The slow s0 operation took" << timer.elapsed()
+                     qCInfo(LOG_VariableController()) << "TORM: The slow s0 operation took" << timer.elapsed()
                                                       << "milliseconds";
                      auto dateTimeListNotInCache
                          = impl->m_VariableCacheController->provideNotInCacheDateTimeList(variable, dateTime);
-                     qCInfo(LOG_VariableController()) << "The slow s1 operation took" << timer.elapsed()
+                     qCInfo(LOG_VariableController()) << "TORM: The slow s1 operation took" << timer.elapsed()
                                                       << "milliseconds";
                      // Ask the provider for each data on the dateTimeListNotInCache
                      impl->m_VariableToProviderMap.at(variable)->requestDataLoading(dateTimeListNotInCache);
-                     qCInfo(LOG_VariableController()) << "The slow s2 operation took" << timer.elapsed()
+                     qCInfo(LOG_VariableController()) << "TORM: The slow s2 operation took" << timer.elapsed()
                                                       << "milliseconds";
                      // store in cache
                      impl->m_VariableCacheController->addDateTime(variable, dateTime);
-                     qCInfo(LOG_VariableController()) << "The slow s3 operation took" << timer.elapsed()
+                     qCInfo(LOG_VariableController()) << "TORM: The slow s3 operation took" << timer.elapsed()
                                                       << "milliseconds";
                  }
                  else {

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

                  auto notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
                  QCOMPARE(notInCach.size(), 1);
-                 auto notInCashSqp = notInCach.first();
-                 QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
-                 QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
+                 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
                  notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
                  QCOMPARE(notInCach.size(), 1);
-                 notInCashSqp = notInCach.first();
-                 QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
-                 QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(ts0.toMSecsSinceEpoch()));
+                 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}};
                  notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
                  QCOMPARE(notInCach.size(), 2);
-                 notInCashSqp = notInCach.first();
-                 QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
-                 QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(ts0.toMSecsSinceEpoch()));
+                 notInCacheSqp = notInCach.first();
+                 QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
+                 QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(ts0.toMSecsSinceEpoch()));
-                 notInCashSqp = notInCach.at(1);
-                 QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(te0.toMSecsSinceEpoch()));
-                 QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
+                 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}};
                  notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
                  QCOMPARE(notInCach.size(), 2);
-                 notInCashSqp = notInCach.first();
-                 QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
-                 QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(ts0.toMSecsSinceEpoch()));
+                 notInCacheSqp = notInCach.first();
+                 QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
+                 QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(ts0.toMSecsSinceEpoch()));
-                 notInCashSqp = notInCach.at(1);
-                 QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(te0.toMSecsSinceEpoch()));
-                 QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(ts1.toMSecsSinceEpoch()));
+                 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}};
                  notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
                  QCOMPARE(notInCach.size(), 4);
-                 notInCashSqp = notInCach.first();
-                 QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
-                 QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(ts0.toMSecsSinceEpoch()));
+                 notInCacheSqp = notInCach.first();
+                 QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
+                 QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(ts0.toMSecsSinceEpoch()));
-                 notInCashSqp = notInCach.at(1);
-                 QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(te0.toMSecsSinceEpoch()));
-                 QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(ts1.toMSecsSinceEpoch()));
+                 notInCacheSqp = notInCach.at(1);
+                 QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(te0.toMSecsSinceEpoch()));
+                 QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(ts1.toMSecsSinceEpoch()));
-                 notInCashSqp = notInCach.at(2);
-                 QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(te1.toMSecsSinceEpoch()));
-                 QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(ts2.toMSecsSinceEpoch()));
+                 notInCacheSqp = notInCach.at(2);
+                 QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(te1.toMSecsSinceEpoch()));
+                 QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(ts2.toMSecsSinceEpoch()));
-                 notInCashSqp = notInCach.at(3);
-                 QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(te2.toMSecsSinceEpoch()));
-                 QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
+                 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
                  notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
                  QCOMPARE(notInCach.size(), 1);
-                 notInCashSqp = notInCach.first();
-                 QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
-                 QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
+                 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}};
                  notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
                  QCOMPARE(notInCach.size(), 1);
-                 notInCashSqp = notInCach.first();
-                 QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(te0.toMSecsSinceEpoch()));
-                 QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
+                 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}};
                  notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
                  QCOMPARE(notInCach.size(), 1);
-                 notInCashSqp = notInCach.first();
-                 QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(te0.toMSecsSinceEpoch()));
-                 QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
+                 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}};
                  notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
                  QCOMPARE(notInCach.size(), 1);
-                 notInCashSqp = notInCach.first();
-                 QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(te0.toMSecsSinceEpoch()));
-                 QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(ts1.toMSecsSinceEpoch()));
+                 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}};
                  notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
                  QCOMPARE(notInCach.size(), 1);
-                 notInCashSqp = notInCach.first();
-                 QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
-                 QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
+                 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}};
                  notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
                  QCOMPARE(notInCach.size(), 3);
-                 notInCashSqp = notInCach.first();
-                 QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
-                 QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(ts1.toMSecsSinceEpoch()));
+                 notInCacheSqp = notInCach.first();
+                 QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
+                 QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(ts1.toMSecsSinceEpoch()));
-                 notInCashSqp = notInCach.at(1);
-                 QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(te1.toMSecsSinceEpoch()));
-                 QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(ts2.toMSecsSinceEpoch()));
+                 notInCacheSqp = notInCach.at(1);
+                 QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(te1.toMSecsSinceEpoch()));
+                 QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(ts2.toMSecsSinceEpoch()));
-                 notInCashSqp = notInCach.at(2);
-                 QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(te2.toMSecsSinceEpoch()));
-                 QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
+                 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}};
                  notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
                  QCOMPARE(notInCach.size(), 2);
-                 notInCashSqp = notInCach.first();
-                 QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
-                 QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(ts1.toMSecsSinceEpoch()));
+                 notInCacheSqp = notInCach.first();
+                 QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
+                 QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(ts1.toMSecsSinceEpoch()));
-                 notInCashSqp = notInCach.at(1);
-                 QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(te1.toMSecsSinceEpoch()));
-                 QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
+                 notInCacheSqp = notInCach.at(1);
+                 QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(te1.toMSecsSinceEpoch()));
+                 QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
              }

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

-             #ifndef SCIQLOP_GRAPHPLOTTABLESFACTORY_H
-             #define SCIQLOP_GRAPHPLOTTABLESFACTORY_H
+             #ifndef SCIQLOP_VISUALIZATIONGRAPHHELPER_H
+             #define SCIQLOP_VISUALIZATIONGRAPHHELPER_H
              #include <Data/SqpDateTime.h>
              #include <memory>
-             Q_DECLARE_LOGGING_CATEGORY(LOG_GraphPlottablesFactory)
+             Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationGraphHelper)
              class IDataSeries;
              class QCPAbstractPlottable;
              class Variable;
              /**
-              * @brief The GraphPlottablesFactory class aims to create the QCustomPlot components relative to a
+              * @brief The VisualizationGraphHelper class aims to create the QCustomPlot components relative to a
               * variable, depending on the data series of this variable
               */
-             struct GraphPlottablesFactory {
+             struct VisualizationGraphHelper {
                  /**
                   * Creates (if possible) the QCustomPlot components relative to the variable passed in
                   * parameter, and adds these to the plot passed in parameter.
                                         const SqpDateTime &dateTime);
              };
-             #endif // SCIQLOP_GRAPHPLOTTABLESFACTORY_H
+             #endif // SCIQLOP_VISUALIZATIONGRAPHHELPER_H

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

-             #include "Visualization/GraphPlottablesFactory.h"
+             #include "Visualization/VisualizationGraphHelper.h"
              #include "Visualization/qcustomplot.h"
              #include <Data/ScalarSeries.h>
              #include <QElapsedTimer>
-             Q_LOGGING_CATEGORY(LOG_GraphPlottablesFactory, "GraphPlottablesFactory")
+             Q_LOGGING_CATEGORY(LOG_VisualizationGraphHelper, "VisualizationGraphHelper")
              namespace {
                  timer.start();
                  if (auto qcpGraph = dynamic_cast<QCPGraph *>(component)) {
                      // Clean the graph
-                     qCDebug(LOG_GraphPlottablesFactory()) << "The slow s1 operation took" << timer.elapsed()
-                                                           << "milliseconds";
+                     qCDebug(LOG_VisualizationGraphHelper()) << "The slow s1 operation took" << timer.elapsed()
+                                                             << "milliseconds";
                      // NAIVE approch
                      const auto &xData = scalarSeries.xAxisData()->data();
                      const auto &valuesData = scalarSeries.valuesData()->data();
                      qcpGraph->setData(xValue, vValue);
-                     qCDebug(LOG_GraphPlottablesFactory()) << "The slow s2 operation took" << timer.elapsed()
-                                                           << "milliseconds";
+                     qCDebug(LOG_VisualizationGraphHelper()) << "The slow s2 operation took" << timer.elapsed()
+                                                             << "milliseconds";
                  }
                  else {
                      /// @todo DEBUG
                      plot.replot();
                  }
                  else {
-                     qCDebug(LOG_GraphPlottablesFactory())
+                     qCDebug(LOG_VisualizationGraphHelper())
                          << QObject::tr("Can't create graph for the scalar series");
                  }
              } // namespace
-             QVector<QCPAbstractPlottable *> GraphPlottablesFactory::create(std::shared_ptr<Variable> variable,
-                                                                            QCustomPlot &plot) noexcept
+             QVector<QCPAbstractPlottable *> VisualizationGraphHelper::create(std::shared_ptr<Variable> variable,
+                                                                              QCustomPlot &plot) noexcept
              {
                  auto result = QVector<QCPAbstractPlottable *>{};
                          result.append(createScalarSeriesComponent(*scalarSeries, plot, variable->dateTime()));
                      }
                      else {
-                         qCDebug(LOG_GraphPlottablesFactory())
+                         qCDebug(LOG_VisualizationGraphHelper())
                              << QObject::tr("Can't create graph plottables : unmanaged data series type");
                      }
                  }
                  else {
-                     qCDebug(LOG_GraphPlottablesFactory())
+                     qCDebug(LOG_VisualizationGraphHelper())
                          << QObject::tr("Can't create graph plottables : the variable is null");
                  }
                  return result;
              }
-             void GraphPlottablesFactory::updateData(QVector<QCPAbstractPlottable *> plotableVect,
-                                                     IDataSeries *dataSeries, const SqpDateTime &dateTime)
+             void VisualizationGraphHelper::updateData(QVector<QCPAbstractPlottable *> plotableVect,
+                                                       IDataSeries *dataSeries, const SqpDateTime &dateTime)
              {
                  if (auto scalarSeries = dynamic_cast<ScalarSeries *>(dataSeries)) {
                      if (plotableVect.size() == 1) {
                          updateScalarData(plotableVect.at(0), *scalarSeries, dateTime);
                      }
                      else {
-                         qCCritical(LOG_GraphPlottablesFactory()) << QObject::tr(
+                         qCCritical(LOG_VisualizationGraphHelper()) << QObject::tr(
                              "Can't update Data of a scalarSeries because there is not only one component "
                              "associated");
                      }

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

              #include "Visualization/VisualizationGraphWidget.h"
-             #include "Visualization/GraphPlottablesFactory.h"
              #include "Visualization/IVisualizationWidgetVisitor.h"
+             #include "Visualization/VisualizationGraphHelper.h"
              #include "ui_VisualizationGraphWidget.h"
              #include <Data/ArrayData.h>
              void VisualizationGraphWidget::addVariable(std::shared_ptr<Variable> variable)
              {
                  // Uses delegate to create the qcpplot components according to the variable
-                 auto createdPlottables = GraphPlottablesFactory::create(variable, *ui->widget);
+                 auto createdPlottables = VisualizationGraphHelper::create(variable, *ui->widget);
                  for (auto createdPlottable : qAsConst(createdPlottables)) {
                      impl->m_VariableToPlotMultiMap.insert({variable, createdPlottable});
              void VisualizationGraphWidget::onDataCacheVariableUpdated()
              {
+                 // NOTE:
+                 //    We don't want to call the method for each component of a variable unitarily, but for all
+                 //    its components at once (eg its three components in the case of a vector).
+                 //    The unordered_multimap does not do this easily, so the question is whether to:
+                 //    - use an ordered_multimap and the algos of std to group the values by key
+                 //    - use a map (unique keys) and store as values directly the list of components
                  for (auto it = impl->m_VariableToPlotMultiMap.cbegin();
                       it != impl->m_VariableToPlotMultiMap.cend(); ++it) {
                      auto variable = it->first;
-                     GraphPlottablesFactory::updateData(QVector<QCPAbstractPlottable *>{} << it->second,
-                                                        variable->dataSeries(), variable->dateTime());
+                     VisualizationGraphHelper::updateData(QVector<QCPAbstractPlottable *>{} << it->second,
+                                                          variable->dataSeries(), variable->dateTime());
                  }
              }
                      abstractPlotableVect.push_back(it->second);
                  }
-                 GraphPlottablesFactory::updateData(abstractPlotableVect, variable->dataSeries(),
-                                                    variable->dateTime());
+                 VisualizationGraphHelper::updateData(abstractPlotableVect, variable->dataSeries(),
+                                                      variable->dateTime());
              }

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

              void CosinusProvider::requestDataLoading(const QVector<SqpDateTime> &dateTimeList)
              {
                  // NOTE: Try to use multithread if possible
-                 foreach (const auto &dateTime, dateTimeList) {
+                 for (const auto &dateTime : dateTimeList) {
                      auto scalarSeries = this->retrieveDataSeries(dateTime);

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