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();
+                auto notInCacheSqp = notInCach.first();
-                QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
-                QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
                 // second case ts < ts0 &&  ts0 < te <= te0
                 notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
                 QCOMPARE(notInCach.size(), 1);
-                notInCashSqp = notInCach.first();
+                notInCacheSqp = notInCach.first();
-                QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
-                QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(ts0.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(ts0.toMSecsSinceEpoch()));
                 // 3th case ts < ts0 &&  te0 < te <= ts1
                 ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 0, 0, 0}};
                 notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
                 QCOMPARE(notInCach.size(), 2);
-                notInCashSqp = notInCach.first();
+                notInCacheSqp = notInCach.first();
-                QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
-                QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(ts0.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(ts0.toMSecsSinceEpoch()));
-                notInCashSqp = notInCach.at(1);
+                notInCacheSqp = notInCach.at(1);
-                QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(te0.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(te0.toMSecsSinceEpoch()));
-                QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
                 // 4th case ts < ts0 &&  ts1 < te <= te1
                 ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 0, 0, 0}};
                 notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
                 QCOMPARE(notInCach.size(), 2);
-                notInCashSqp = notInCach.first();
+                notInCacheSqp = notInCach.first();
-                QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
-                QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(ts0.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(ts0.toMSecsSinceEpoch()));
-                notInCashSqp = notInCach.at(1);
+                notInCacheSqp = notInCach.at(1);
-                QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(te0.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(te0.toMSecsSinceEpoch()));
-                QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(ts1.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(ts1.toMSecsSinceEpoch()));
                 // 5th case ts < ts0 &&  te3 < te
                 ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 0, 0, 0}};
                 notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
                 QCOMPARE(notInCach.size(), 4);
-                notInCashSqp = notInCach.first();
+                notInCacheSqp = notInCach.first();
-                QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
-                QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(ts0.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(ts0.toMSecsSinceEpoch()));
-                notInCashSqp = notInCach.at(1);
+                notInCacheSqp = notInCach.at(1);
-                QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(te0.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(te0.toMSecsSinceEpoch()));
-                QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(ts1.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(ts1.toMSecsSinceEpoch()));
-                notInCashSqp = notInCach.at(2);
+                notInCacheSqp = notInCach.at(2);
-                QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(te1.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(te1.toMSecsSinceEpoch()));
-                QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(ts2.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(ts2.toMSecsSinceEpoch()));
-                notInCashSqp = notInCach.at(3);
+                notInCacheSqp = notInCach.at(3);
-                QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(te2.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(te2.toMSecsSinceEpoch()));
-                QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
                 // 6th case ts2 < ts
                 notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
                 QCOMPARE(notInCach.size(), 1);
-                notInCashSqp = notInCach.first();
+                notInCacheSqp = notInCach.first();
-                QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
-                QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
                 // 7th case ts = te0 && te < ts1
                 ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 4, 0, 0}};
                 notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
                 QCOMPARE(notInCach.size(), 1);
-                notInCashSqp = notInCach.first();
+                notInCacheSqp = notInCach.first();
-                QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(te0.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(te0.toMSecsSinceEpoch()));
-                QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
                 // 8th case ts0 < ts < te0 && te < ts1
                 ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 30, 0}};
                 notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
                 QCOMPARE(notInCach.size(), 1);
-                notInCashSqp = notInCach.first();
+                notInCacheSqp = notInCach.first();
-                QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(te0.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(te0.toMSecsSinceEpoch()));
-                QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
                 // 9th case ts0 < ts < te0 &&  ts1 < te < te1
                 ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 30, 0}};
                 notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
                 QCOMPARE(notInCach.size(), 1);
-                notInCashSqp = notInCach.first();
+                notInCacheSqp = notInCach.first();
-                QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(te0.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(te0.toMSecsSinceEpoch()));
-                QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(ts1.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(ts1.toMSecsSinceEpoch()));
                 // 10th case te1 < ts < te < ts2
                 ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 9, 0, 0}};
                 notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
                 QCOMPARE(notInCach.size(), 1);
-                notInCashSqp = notInCach.first();
+                notInCacheSqp = notInCach.first();
-                QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
-                QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
                 // 11th case te0 < ts < ts1 &&  te3 < te
                 ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 5, 0, 0}};
                 notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
                 QCOMPARE(notInCach.size(), 3);
-                notInCashSqp = notInCach.first();
+                notInCacheSqp = notInCach.first();
-                QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
-                QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(ts1.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(ts1.toMSecsSinceEpoch()));
-                notInCashSqp = notInCach.at(1);
+                notInCacheSqp = notInCach.at(1);
-                QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(te1.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(te1.toMSecsSinceEpoch()));
-                QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(ts2.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(ts2.toMSecsSinceEpoch()));
-                notInCashSqp = notInCach.at(2);
+                notInCacheSqp = notInCach.at(2);
-                QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(te2.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(te2.toMSecsSinceEpoch()));
-                QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
                 // 12th case te0 < ts < ts1 &&  te3 < te
                 ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 5, 0, 0}};
                 notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
                 QCOMPARE(notInCach.size(), 2);
-                notInCashSqp = notInCach.first();
+                notInCacheSqp = notInCach.first();
-                QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
-                QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(ts1.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(ts1.toMSecsSinceEpoch()));
-                notInCashSqp = notInCach.at(1);
+                notInCacheSqp = notInCach.at(1);
-                QCOMPARE(notInCashSqp.m_TStart, static_cast<double>(te1.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(te1.toMSecsSinceEpoch()));
-                QCOMPARE(notInCashSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
+                QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
             }

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

-            #ifndef SCIQLOP_GRAPHPLOTTABLESFACTORY_H
+            #ifndef SCIQLOP_VISUALIZATIONGRAPHHELPER_H
-            #define SCIQLOP_GRAPHPLOTTABLESFACTORY_H
+            #define SCIQLOP_VISUALIZATIONGRAPHHELPER_H
             #include <Data/SqpDateTime.h>
             #include <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 +10 -10

-            #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()
+                    qCDebug(LOG_VisualizationGraphHelper()) << "The slow s1 operation took" << timer.elapsed()
                                                             << "milliseconds";
                     // NAIVE approch
                     const auto &xData = scalarSeries.xAxisData()->data();
                     qcpGraph->setData(xValue, vValue);
-                    qCDebug(LOG_GraphPlottablesFactory()) << "The slow s2 operation took" << timer.elapsed()
+                    qCDebug(LOG_VisualizationGraphHelper()) << "The slow s2 operation took" << timer.elapsed()
                                                             << "milliseconds";
                 }
                 else {
                     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,
+            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,
+            void VisualizationGraphHelper::updateData(QVector<QCPAbstractPlottable *> plotableVect,
                                                       IDataSeries *dataSeries, const SqpDateTime &dateTime)
             {
                 if (auto scalarSeries = dynamic_cast<ScalarSeries *>(dataSeries)) {
                         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 +12 -4

             #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,
+                    VisualizationGraphHelper::updateData(QVector<QCPAbstractPlottable *>{} << it->second,
                                                          variable->dataSeries(), variable->dateTime());
                 }
             }
                     abstractPlotableVect.push_back(it->second);
                 }
-                GraphPlottablesFactory::updateData(abstractPlotableVect, variable->dataSeries(),
+                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