GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r1004:15899f42a907

Removes compilation warnings (with Meson)

Alexandre Leroux -

r1004:15899f42a907

parent child

Context file:

r1004:15899f42a907

Collapse all files

core/include/Common/SortUtils.h +1 -1

             #ifndef SCIQLOP_SORTUTILS_H
             #define SCIQLOP_SORTUTILS_H
             #include <algorithm>
             #include <cmath>
             #include <numeric>
             #include <vector>
             /**
              * Utility class with methods for sorting data
              */
             struct SortUtils {
                 /**
                  * Generates a vector representing the index of insertion of each data of a container if this
                  * one had to be sorted according to a comparison function.
                  *
                  * For example:
                  * If the container is a vector {1; 4; 2; 5; 3} and the comparison function is std::less, the
                  * result would be : {0; 3; 1; 4; 2}
                  *
                  * @tparam Container the type of the container.
                  * @tparam Compare the type of the comparison function
                  * @param container the container from which to generate the result. The container must have a
                  * at() method that returns a value associated to an index
                  * @param compare the comparison function
                  */
                 template <typename Container, typename Compare>
                 static std::vector<int> sortPermutation(const Container &container, const Compare &compare)
                 {
                     auto permutation = std::vector<int>{};
                     permutation.resize(container.size());
                     std::iota(permutation.begin(), permutation.end(), 0);
                     std::sort(permutation.begin(), permutation.end(),
                               [&](int i, int j) { return compare(container.at(i), container.at(j)); });
                     return permutation;
                 }
                 /**
                  * Sorts a container according to indices passed in parameter. The number of data in the
                  * container must be a multiple of the number of indices used to sort the container.
                  *
                  * Example 1:
                  * container: {1, 2, 3, 4, 5, 6}
                  * sortPermutation: {1, 0}
                  *
                  * Values will be sorted three by three, and the result will be:
                  * {4, 5, 6, 1, 2, 3}
                  *
                  * Example 2:
                  * container: {1, 2, 3, 4, 5, 6}
                  * sortPermutation: {2, 0, 1}
                  *
                  * Values will be sorted two by two, and the result will be:
                  * {5, 6, 1, 2, 3, 4}
                  *
                  * @param container the container sorted
                  * @param sortPermutation the indices used to sort the container
                  * @return the container sorted
                  * @warning no verification is made on validity of sortPermutation (i.e. the vector has unique
                  * indices and its range is [0 ; vector.size()[ )
                  */
                 template <typename Container>
                 static Container sort(const Container &container, int nbValues,
                                       const std::vector<int> &sortPermutation)
                 {
                     auto containerSize = container.size();
                     if (containerSize % nbValues != 0
                         || ((containerSize / nbValues) != sortPermutation.size())) {
                         return Container{};
                     }
                     // Inits result
                     auto sortedData = Container{};
                     sortedData.reserve(containerSize);
-                    for (auto i = 0, componentIndex = 0, permutationIndex = 0; i < containerSize;
+                    for (auto i = 0u, componentIndex = 0u, permutationIndex = 0u; i < containerSize;
                          ++i, componentIndex = i % nbValues, permutationIndex = i / nbValues) {
                         auto insertIndex = sortPermutation.at(permutationIndex) * nbValues + componentIndex;
                         sortedData.push_back(container.at(insertIndex));
                     }
                     return sortedData;
                 }
                 /**
                  * Compares two values that can be NaN. This method is intended to be used as a compare function
                  * for searching min value by excluding NaN values.
                  *
                  * Examples of use:
                  * - f({1, 3, 2, 4, 5}) will return 1
                  * - f({NaN, 3, 2, 4, 5}) will return 2 (NaN is excluded)
                  * - f({NaN, NaN, 3, NaN, NaN}) will return 3 (NaN are excluded)
                  * - f({NaN, NaN, NaN, NaN, NaN}) will return NaN (no existing value)
                  *
                  * @param v1 first value
                  * @param v2 second value
                  * @return true if v1 < v2, false otherwise
                  * @sa std::min_element
                  */
                 template <typename T>
                 static bool minCompareWithNaN(const T &v1, const T &v2)
                 {
                     // Table used with NaN values:
                     // NaN < v2 -> false
                     // v1 < NaN -> true
                     // NaN < NaN -> false
                     // v1 < v2 -> v1 < v2
                     return std::isnan(v1) ? false : std::isnan(v2) || (v1 < v2);
                 }
                 /**
                  * Compares two values that can be NaN. This method is intended to be used as a compare function
                  * for searching max value by excluding NaN values.
                  *
                  * Examples of use:
                  * - f({1, 3, 2, 4, 5}) will return 5
                  * - f({1, 3, 2, 4, NaN}) will return 4 (NaN is excluded)
                  * - f({NaN, NaN, 3, NaN, NaN}) will return 3 (NaN are excluded)
                  * - f({NaN, NaN, NaN, NaN, NaN}) will return NaN (no existing value)
                  *
                  * @param v1 first value
                  * @param v2 second value
                  * @return true if v1 < v2, false otherwise
                  * @sa std::max_element
                  */
                 template <typename T>
                 static bool maxCompareWithNaN(const T &v1, const T &v2)
                 {
                     // Table used with NaN values:
                     // NaN < v2 -> true
                     // v1 < NaN -> false
                     // NaN < NaN -> false
                     // v1 < v2 -> v1 < v2
                     return std::isnan(v1) ? true : !std::isnan(v2) && (v1 < v2);
                 }
             };
             #endif // SCIQLOP_SORTUTILS_H

core/include/Variable/VariableCacheStrategy.h +1 0

             #ifndef SCIQLOP_VARIABLECACHESTRATEGY_H
             #define SCIQLOP_VARIABLECACHESTRATEGY_H
             #include "CoreGlobal.h"
             #include <QLoggingCategory>
             #include <QObject>
             #include <Data/SqpRange.h>
             #include <QLoggingCategory>
             #include <Common/spimpl.h>
             #include <utility>
             Q_DECLARE_LOGGING_CATEGORY(LOG_VariableCacheStrategy)
             class Variable;
             /// This class aims to hande the cache strategy.
             class SCIQLOP_CORE_EXPORT VariableCacheStrategy {
             public:
+                virtual ~VariableCacheStrategy() noexcept = default;
                 virtual std::pair<SqpRange, SqpRange> computeRange(const SqpRange &vRange,
                                                                    const SqpRange &rangeRequested)
                     = 0;
             };
             #endif // SCIQLOP_VARIABLECACHESTRATEGY_H

core/include/Variable/VariableCacheStrategyFactory.h +2 0

             #ifndef SCIQLOP_VARIABLECACHESTRATEGYFACTORY_H
             #define SCIQLOP_VARIABLECACHESTRATEGYFACTORY_H
             #include <memory>
             #include <stdexcept>
             #include "VariableCacheStrategy.h"
             #include "VariableSingleThresholdCacheStrategy.h"
             #include <QLoggingCategory>
             #include <QString>
             Q_LOGGING_CATEGORY(LOG_VariableCacheStrategyFactory, "VariableCacheStrategyFactory")
             enum class CacheStrategy { SingleThreshold, TwoThreashold };
             class VariableCacheStrategyFactory {
                 using cacheStratPtr = std::unique_ptr<VariableCacheStrategy>;
             public:
                 static cacheStratPtr createCacheStrategy(CacheStrategy specificStrategy)
                 {
                     switch (specificStrategy) {
                         case CacheStrategy::SingleThreshold: {
                             return std::unique_ptr<VariableCacheStrategy>{
                                 new VariableSingleThresholdCacheStrategy{}};
                             break;
                         }
                         case CacheStrategy::TwoThreashold: {
                             qCCritical(LOG_VariableCacheStrategyFactory())
                                 << QObject::tr("cache strategy not implemented yet");
                             break;
                         }
                         default:
                             qCCritical(LOG_VariableCacheStrategyFactory())
                                 << QObject::tr("Unknown cache strategy");
                     }
+                    return nullptr;
                 }
             };
             #endif // VARIABLECACHESTRATEGYFACTORY_H

core/meson.build 0 -1

             core_moc_headers = [
               'include/Data/IDataProvider.h',
               'include/DataSource/DataSourceController.h',
               'include/DataSource/DataSourceItemAction.h',
               'include/Network/NetworkController.h',
               'include/Time/TimeController.h',
               'include/Variable/Variable.h',
               'include/Variable/VariableCacheController.h',
               'include/Variable/VariableController.h',
               'include/Variable/VariableAcquisitionWorker.h',
-              'include/Variable/VariableCacheStrategy.h',
               'include/Variable/VariableSynchronizationGroup.h',
               'include/Variable/VariableModel.h',
               'include/Visualization/VisualizationController.h'
             ]
             core_moc_files = qt5.preprocess(moc_headers : core_moc_headers)
             core_sources = [
               'src/Common/DateUtils.cpp',
               'src/Common/StringUtils.cpp',
               'src/Common/MimeTypesDef.cpp',
               'src/Data/ScalarSeries.cpp',
               'src/Data/SpectrogramSeries.cpp',
               'src/Data/DataSeriesIterator.cpp',
               'src/Data/ArrayDataIterator.cpp',
               'src/Data/VectorSeries.cpp',
               'src/Data/OptionalAxis.cpp',
               'src/DataSource/DataSourceController.cpp',
               'src/DataSource/DataSourceItem.cpp',
               'src/DataSource/DataSourceItemAction.cpp',
               'src/Network/NetworkController.cpp',
               'src/Plugin/PluginManager.cpp',
               'src/Settings/SqpSettingsDefs.cpp',
               'src/Time/TimeController.cpp',
               'src/Variable/Variable.cpp',
               'src/Variable/VariableCacheController.cpp',
               'src/Variable/VariableController.cpp',
               'src/Variable/VariableAcquisitionWorker.cpp',
               'src/Variable/VariableSynchronizationGroup.cpp',
               'src/Variable/VariableModel.cpp',
               'src/Visualization/VisualizationController.cpp'
             ]
             core_inc = include_directories(['include', '../plugin/include'])
             sciqlop_core_lib = library('sciqlopcore',
                                    core_sources,
                                    core_moc_files,
                                    cpp_args : '-DCORE_LIB',
                                    include_directories : core_inc,
                                    dependencies : [qt5core, qt5network],
                                    install : true
                                    )
             sciqlop_core = declare_dependency(link_with : sciqlop_core_lib,
                                             include_directories : core_inc,
                                             dependencies : [qt5core, qt5network])
             subdir('tests')

core/src/Data/OptionalAxis.cpp 0 -2

             #include <Data/OptionalAxis.h>
             #include "Data/ArrayData.h"
             OptionalAxis::OptionalAxis() : m_Defined{false}, m_Data{nullptr}, m_Unit{}
             {
             }
             OptionalAxis::OptionalAxis(std::shared_ptr<ArrayData<1> > data, Unit unit)
                     : m_Defined{true}, m_Data{data}, m_Unit{std::move(unit)}
             {
                 if (m_Data == nullptr) {
                     throw std::invalid_argument{"Data can't be null for a defined axis"};
                 }
             }
             OptionalAxis::OptionalAxis(const OptionalAxis &other)
                     : m_Defined{other.m_Defined},
                       m_Data{other.m_Data ? std::make_shared<ArrayData<1> >(*other.m_Data) : nullptr},
                       m_Unit{other.m_Unit}
             {
             }
             OptionalAxis &OptionalAxis::operator=(OptionalAxis other)
             {
                 std::swap(m_Defined, other.m_Defined);
                 std::swap(m_Data, other.m_Data);
                 std::swap(m_Unit, other.m_Unit);
                 return *this;
             }
             bool OptionalAxis::isDefined() const
             {
                 return m_Defined;
             }
             double OptionalAxis::at(int index) const
             {
                 if (m_Defined) {
                     return (index >= 0 && index < m_Data->size()) ? m_Data->at(index)
                                                                   : std::numeric_limits<double>::quiet_NaN();
                 }
                 else {
                     return std::numeric_limits<double>::quiet_NaN();
                 }
             }
             std::pair<double, double> OptionalAxis::bounds() const
             {
                 if (!m_Defined || m_Data->size() == 0) {
                     return std::make_pair(std::numeric_limits<double>::quiet_NaN(),
                                           std::numeric_limits<double>::quiet_NaN());
                 }
                 else {
                     auto minIt = std::min_element(
                         m_Data->cbegin(), m_Data->cend(), [](const auto &it1, const auto &it2) {
                             return SortUtils::minCompareWithNaN(it1.first(), it2.first());
                         });
                     // Gets the iterator on the max of all values data
                     auto maxIt = std::max_element(
                         m_Data->cbegin(), m_Data->cend(), [](const auto &it1, const auto &it2) {
                             return SortUtils::maxCompareWithNaN(it1.first(), it2.first());
                         });
-                    auto pair = std::make_pair(minIt->first(), maxIt->first());
                     return std::make_pair(minIt->first(), maxIt->first());
                 }
             }
             int OptionalAxis::size() const
             {
                 return m_Defined ? m_Data->size() : 0;
             }
             Unit OptionalAxis::unit() const
             {
                 return m_Defined ? m_Unit : Unit{};
             }
             bool OptionalAxis::operator==(const OptionalAxis &other)
             {
                 // Axis not defined
                 if (!m_Defined) {
                     return !other.m_Defined;
                 }
                 // Axis defined
                 return m_Unit == other.m_Unit
                        && std::equal(
                               m_Data->cbegin(), m_Data->cend(), other.m_Data->cbegin(), other.m_Data->cend(),
                               [](const auto &it1, const auto &it2) { return it1.values() == it2.values(); });
             }
             bool OptionalAxis::operator!=(const OptionalAxis &other)
             {
                 return !(*this == other);
             }

core/src/Data/VectorSeries.cpp +1 -1

             #include "Data/VectorSeries.h"
             namespace {
             /**
              * Flatten the three components of a vector to a single QVector that can be passed to an ArrayData
              *
              * Example:
              * xValues = {1, 2, 3}
              * yValues = {4, 5, 6}
              * zValues = {7, 8, 9}
              *
              * result = {1, 4, 7, 2, 5, 8, 3, 6, 9}
              *
              * @param xValues the x-component values of the vector
              * @param yValues the y-component values of the vector
              * @param zValues the z-component values of the vector
              * @return the single QVector
              * @remarks the three components are consumed
              * @sa ArrayData
              */
             std::vector<double> flatten(std::vector<double> xValues, std::vector<double> yValues,
                                         std::vector<double> zValues)
             {
                 if (xValues.size() != yValues.size() || xValues.size() != zValues.size()) {
                     /// @todo ALX : log
                     return {};
                 }
                 auto result = std::vector<double>();
                 result.reserve(xValues.size() * 3);
-                for (int i = 0; i < xValues.size(); i++) {
+                for (auto i = 0u; i < xValues.size(); ++i) {
                     result.push_back(xValues[i]);
                     result.push_back(yValues[i]);
                     result.push_back(zValues[i]);
                 }
                 return result;
             }
             } // namespace
             VectorSeries::VectorSeries(std::vector<double> xAxisData, std::vector<double> xValuesData,
                                        std::vector<double> yValuesData, std::vector<double> zValuesData,
                                        const Unit &xAxisUnit, const Unit &valuesUnit)
                     : VectorSeries{std::move(xAxisData), flatten(std::move(xValuesData), std::move(yValuesData),
                                                                  std::move(zValuesData)),
                                    xAxisUnit, valuesUnit}
             {
             }
             VectorSeries::VectorSeries(std::vector<double> xAxisData, std::vector<double> valuesData,
                                        const Unit &xAxisUnit, const Unit &valuesUnit)
                     : DataSeries{std::make_shared<ArrayData<1> >(std::move(xAxisData)), xAxisUnit,
                                  std::make_shared<ArrayData<2> >(std::move(valuesData), 3), valuesUnit}
             {
             }
             std::unique_ptr<IDataSeries> VectorSeries::clone() const
             {
                 return std::make_unique<VectorSeries>(*this);
             }
             std::shared_ptr<IDataSeries> VectorSeries::subDataSeries(const SqpRange &range)
             {
                 auto subXAxisData = std::vector<double>();
                 auto subValuesData = std::vector<double>();
                 this->lockRead();
                 {
                     auto bounds = xAxisRange(range.m_TStart, range.m_TEnd);
                     for (auto it = bounds.first; it != bounds.second; ++it) {
                         subXAxisData.push_back(it->x());
                         subValuesData.push_back(it->value(0));
                         subValuesData.push_back(it->value(1));
                         subValuesData.push_back(it->value(2));
                     }
                 }
                 this->unlock();
                 return std::make_shared<VectorSeries>(std::move(subXAxisData), std::move(subValuesData),
                                                       this->xAxisUnit(), this->valuesUnit());
             }

core/src/Variable/VariableController.cpp +3 0

             #include <Variable/Variable.h>
             #include <Variable/VariableAcquisitionWorker.h>
             #include <Variable/VariableCacheStrategy.h>
             #include <Variable/VariableCacheStrategyFactory.h>
             #include <Variable/VariableController.h>
             #include <Variable/VariableModel.h>
             #include <Variable/VariableSynchronizationGroup.h>
             #include <Data/DataProviderParameters.h>
             #include <Data/IDataProvider.h>
             #include <Data/IDataSeries.h>
             #include <Data/VariableRequest.h>
             #include <Time/TimeController.h>
             #include <QDataStream>
             #include <QMutex>
             #include <QThread>
             #include <QUuid>
             #include <QtCore/QItemSelectionModel>
             #include <deque>
             #include <set>
             #include <unordered_map>
             Q_LOGGING_CATEGORY(LOG_VariableController, "VariableController")
             namespace {
             SqpRange computeSynchroRangeRequested(const SqpRange &varRange, const SqpRange &graphRange,
                                                   const SqpRange &oldGraphRange)
             {
                 auto zoomType = VariableController::getZoomType(graphRange, oldGraphRange);
                 auto varRangeRequested = varRange;
                 switch (zoomType) {
                     case AcquisitionZoomType::ZoomIn: {
                         auto deltaLeft = graphRange.m_TStart - oldGraphRange.m_TStart;
                         auto deltaRight = oldGraphRange.m_TEnd - graphRange.m_TEnd;
                         varRangeRequested.m_TStart += deltaLeft;
                         varRangeRequested.m_TEnd -= deltaRight;
                         break;
                     }
                     case AcquisitionZoomType::ZoomOut: {
                         auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
                         auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
                         varRangeRequested.m_TStart -= deltaLeft;
                         varRangeRequested.m_TEnd += deltaRight;
                         break;
                     }
                     case AcquisitionZoomType::PanRight: {
                         auto deltaLeft = graphRange.m_TStart - oldGraphRange.m_TStart;
                         auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
                         varRangeRequested.m_TStart += deltaLeft;
                         varRangeRequested.m_TEnd += deltaRight;
                         break;
                     }
                     case AcquisitionZoomType::PanLeft: {
                         auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
                         auto deltaRight = oldGraphRange.m_TEnd - graphRange.m_TEnd;
                         varRangeRequested.m_TStart -= deltaLeft;
                         varRangeRequested.m_TEnd -= deltaRight;
                         break;
                     }
                     case AcquisitionZoomType::Unknown: {
                         qCCritical(LOG_VariableController())
                             << VariableController::tr("Impossible to synchronize: zoom type unknown");
                         break;
                     }
                     default:
                         qCCritical(LOG_VariableController()) << VariableController::tr(
                             "Impossible to synchronize: zoom type not take into account");
                         // No action
                         break;
                 }
                 return varRangeRequested;
             }
             }
             enum class VariableRequestHandlerState { OFF, RUNNING, PENDING };
             struct VariableRequestHandler {
                 VariableRequestHandler()
                 {
                     m_CanUpdate = false;
                     m_State = VariableRequestHandlerState::OFF;
                 }
                 QUuid m_VarId;
                 VariableRequest m_RunningVarRequest;
                 VariableRequest m_PendingVarRequest;
                 VariableRequestHandlerState m_State;
                 bool m_CanUpdate;
             };
             struct VariableController::VariableControllerPrivate {
                 explicit VariableControllerPrivate(VariableController *parent)
                         : m_WorkingMutex{},
                           m_VariableModel{new VariableModel{parent}},
                           m_VariableSelectionModel{new QItemSelectionModel{m_VariableModel, parent}},
                           // m_VariableCacheStrategy{std::make_unique<VariableCacheStrategy>()},
                           m_VariableCacheStrategy{VariableCacheStrategyFactory::createCacheStrategy(
                               CacheStrategy::SingleThreshold)},
                           m_VariableAcquisitionWorker{std::make_unique<VariableAcquisitionWorker>()},
                           q{parent}
                 {
                     m_VariableAcquisitionWorker->moveToThread(&m_VariableAcquisitionWorkerThread);
                     m_VariableAcquisitionWorkerThread.setObjectName("VariableAcquisitionWorkerThread");
                 }
                 virtual ~VariableControllerPrivate()
                 {
                     qCDebug(LOG_VariableController()) << tr("VariableControllerPrivate destruction");
                     m_VariableAcquisitionWorkerThread.quit();
                     m_VariableAcquisitionWorkerThread.wait();
                 }
                 void processRequest(std::shared_ptr<Variable> var, const SqpRange &rangeRequested,
                                     QUuid varRequestId);
                 std::shared_ptr<Variable> findVariable(QUuid vIdentifier);
                 std::shared_ptr<IDataSeries>
                 retrieveDataSeries(const QVector<AcquisitionDataPacket> acqDataPacketVector);
                 void registerProvider(std::shared_ptr<IDataProvider> provider);
                 void storeVariableRequest(QUuid varId, QUuid varRequestId, const VariableRequest &varRequest);
                 QUuid acceptVariableRequest(QUuid varId, std::shared_ptr<IDataSeries> dataSeries);
                 void updateVariables(QUuid varRequestId);
                 void updateVariableRequest(QUuid varRequestId);
                 void cancelVariableRequest(QUuid varRequestId);
                 void executeVarRequest(std::shared_ptr<Variable> var, VariableRequest &varRequest);
                 QMutex m_WorkingMutex;
                 /// Variable model. The VariableController has the ownership
                 VariableModel *m_VariableModel;
                 QItemSelectionModel *m_VariableSelectionModel;
                 TimeController *m_TimeController{nullptr};
                 std::unique_ptr<VariableCacheStrategy> m_VariableCacheStrategy;
                 std::unique_ptr<VariableAcquisitionWorker> m_VariableAcquisitionWorker;
                 QThread m_VariableAcquisitionWorkerThread;
                 std::unordered_map<std::shared_ptr<Variable>, std::shared_ptr<IDataProvider> >
                     m_VariableToProviderMap;
                 std::unordered_map<std::shared_ptr<Variable>, QUuid> m_VariableToIdentifierMap;
                 std::map<QUuid, std::shared_ptr<VariableSynchronizationGroup> >
                     m_GroupIdToVariableSynchronizationGroupMap;
                 std::map<QUuid, QUuid> m_VariableIdGroupIdMap;
                 std::set<std::shared_ptr<IDataProvider> > m_ProviderSet;
                 std::map<QUuid, std::list<QUuid> > m_VarGroupIdToVarIds;
                 std::map<QUuid, std::unique_ptr<VariableRequestHandler> > m_VarIdToVarRequestHandler;
                 VariableController *q;
             };
             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);
                 connect(impl->m_VariableAcquisitionWorker.get(),
                         &VariableAcquisitionWorker::variableCanceledRequested, this,
                         &VariableController::onAbortAcquisitionRequested);
                 connect(impl->m_VariableAcquisitionWorker.get(), &VariableAcquisitionWorker::dataProvided, this,
                         &VariableController::onDataProvided);
                 connect(impl->m_VariableAcquisitionWorker.get(),
                         &VariableAcquisitionWorker::variableRequestInProgress, this,
                         &VariableController::onVariableRetrieveDataInProgress);
                 connect(&impl->m_VariableAcquisitionWorkerThread, &QThread::started,
                         impl->m_VariableAcquisitionWorker.get(), &VariableAcquisitionWorker::initialize);
                 connect(&impl->m_VariableAcquisitionWorkerThread, &QThread::finished,
                         impl->m_VariableAcquisitionWorker.get(), &VariableAcquisitionWorker::finalize);
                 connect(impl->m_VariableModel, &VariableModel::requestVariableRangeUpdate, this,
                         &VariableController::onUpdateDateTime);
                 impl->m_VariableAcquisitionWorkerThread.start();
             }
             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;
             }
             std::shared_ptr<Variable>
             VariableController::cloneVariable(std::shared_ptr<Variable> variable) noexcept
             {
                 if (impl->m_VariableModel->containsVariable(variable)) {
                     // Clones variable
                     auto duplicate = variable->clone();
                     // Adds clone to model
                     impl->m_VariableModel->addVariable(duplicate);
                     // Generates clone identifier
                     impl->m_VariableToIdentifierMap[duplicate] = QUuid::createUuid();
                     // Registers provider
                     auto variableProvider = impl->m_VariableToProviderMap.at(variable);
                     auto duplicateProvider = variableProvider != nullptr ? variableProvider->clone() : nullptr;
                     impl->m_VariableToProviderMap[duplicate] = duplicateProvider;
                     if (duplicateProvider) {
                         impl->registerProvider(duplicateProvider);
                     }
                     return duplicate;
                 }
                 else {
                     qCCritical(LOG_VariableController())
                         << tr("Can't create duplicate of variable %1: variable not registered in the model")
                                .arg(variable->name());
                     return nullptr;
                 }
             }
             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));
                 // 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);
                 }
             }
             QByteArray
             VariableController::mimeDataForVariables(const QList<std::shared_ptr<Variable> > &variables) const
             {
                 auto encodedData = QByteArray{};
                 QVariantList ids;
                 for (auto &var : variables) {
                     auto itVar = impl->m_VariableToIdentifierMap.find(var);
                     if (itVar == impl->m_VariableToIdentifierMap.cend()) {
                         qCCritical(LOG_VariableController())
                             << tr("Impossible to find the data for an unknown variable.");
                     }
                     ids << itVar->second.toByteArray();
                 }
                 QDataStream stream{&encodedData, QIODevice::WriteOnly};
                 stream << ids;
                 return encodedData;
             }
             QList<std::shared_ptr<Variable> >
             VariableController::variablesForMimeData(const QByteArray &mimeData) const
             {
                 auto variables = QList<std::shared_ptr<Variable> >{};
                 QDataStream stream{mimeData};
                 QVariantList ids;
                 stream >> ids;
                 for (auto id : ids) {
                     auto uuid = QUuid{id.toByteArray()};
                     auto var = impl->findVariable(uuid);
                     variables << var;
                 }
                 return variables;
             }
             std::shared_ptr<Variable>
             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 nullptr;
                 }
                 auto range = impl->m_TimeController->dateTime();
                 if (auto newVariable = impl->m_VariableModel->createVariable(name, metadata)) {
                     auto varId = QUuid::createUuid();
                     // Create the handler
                     auto varRequestHandler = std::make_unique<VariableRequestHandler>();
                     varRequestHandler->m_VarId = varId;
                     impl->m_VarIdToVarRequestHandler.insert(
                         std::make_pair(varId, std::move(varRequestHandler)));
                     // store the provider
                     impl->registerProvider(provider);
                     // Associate the provider
                     impl->m_VariableToProviderMap[newVariable] = provider;
                     impl->m_VariableToIdentifierMap[newVariable] = varId;
                     this->onRequestDataLoading(QVector<std::shared_ptr<Variable> >{newVariable}, range, false);
                     //        auto varRequestId = QUuid::createUuid();
                     //        qCInfo(LOG_VariableController()) << "createVariable: " << varId << varRequestId;
                     //        impl->processRequest(newVariable, range, varRequestId);
                     //        impl->updateVariableRequest(varRequestId);
                     return newVariable;
                 }
+                qCCritical(LOG_VariableController()) << tr("Impossible to create variable");
+                return nullptr;
             }
             void VariableController::onDateTimeOnSelection(const SqpRange &dateTime)
             {
                 // NOTE: Even if acquisition request is aborting, the graphe range will be changed
                 qCDebug(LOG_VariableController()) << "VariableController::onDateTimeOnSelection"
                                                   << QThread::currentThread()->objectName();
                 auto selectedRows = impl->m_VariableSelectionModel->selectedRows();
                 // NOTE we only permit the time modification for one variable
                 // DEPRECATED
                 // auto variables = QVector<std::shared_ptr<Variable> >{};
                 //        for (const auto &selectedRow : qAsConst(selectedRows)) {
                 //            if (auto selectedVariable =
                 //            impl->m_VariableModel->variable(selectedRow.row())) {
                 //                variables << selectedVariable;
                 //                // notify that rescale operation has to be done
                 //                emit rangeChanged(selectedVariable, dateTime);
                 //            }
                 //        }
                 //        if (!variables.isEmpty()) {
                 //            this->onRequestDataLoading(variables, dateTime, synchro);
                 //        }
                 if (selectedRows.size() == 1) {
                     if (auto selectedVariable
                         = impl->m_VariableModel->variable(qAsConst(selectedRows).first().row())) {
                         onUpdateDateTime(selectedVariable, dateTime);
                     }
                 }
                 else if (selectedRows.size() > 1) {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to set time for more than 1 variable in the same time");
                 }
                 else {
                     qCWarning(LOG_VariableController())
                         << tr("There is no variable selected to set the time one");
                 }
             }
             void VariableController::onUpdateDateTime(std::shared_ptr<Variable> variable,
                                                       const SqpRange &dateTime)
             {
                 auto itVar = impl->m_VariableToIdentifierMap.find(variable);
                 if (itVar == impl->m_VariableToIdentifierMap.cend()) {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to onDateTimeOnSelection request for unknown variable");
                     return;
                 }
                 // notify that rescale operation has to be done
                 emit rangeChanged(variable, dateTime);
                 auto synchro
                     = impl->m_VariableIdGroupIdMap.find(itVar->second) != impl->m_VariableIdGroupIdMap.cend();
                 this->onRequestDataLoading(QVector<std::shared_ptr<Variable> >{variable}, dateTime, synchro);
             }
             void VariableController::onDataProvided(QUuid vIdentifier, const SqpRange &rangeRequested,
                                                     const SqpRange &cacheRangeRequested,
                                                     QVector<AcquisitionDataPacket> dataAcquired)
             {
                 qCDebug(LOG_VariableController()) << tr("onDataProvided") << QThread::currentThread();
                 auto retrievedDataSeries = impl->retrieveDataSeries(dataAcquired);
                 auto varRequestId = impl->acceptVariableRequest(vIdentifier, retrievedDataSeries);
                 if (!varRequestId.isNull()) {
                     impl->updateVariables(varRequestId);
                 }
             }
             void VariableController::onVariableRetrieveDataInProgress(QUuid identifier, double progress)
             {
                 qCDebug(LOG_VariableController())
                     << "TORM: variableController::onVariableRetrieveDataInProgress"
                     << QThread::currentThread()->objectName() << progress;
                 if (auto var = impl->findVariable(identifier)) {
                     impl->m_VariableModel->setDataProgress(var, progress);
                 }
                 else {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to notify progression of a null variable");
                 }
             }
             void VariableController::onAbortProgressRequested(std::shared_ptr<Variable> variable)
             {
                 qCDebug(LOG_VariableController()) << "TORM: variableController::onAbortProgressRequested"
                                                   << QThread::currentThread()->objectName() << variable->name();
                 auto itVar = impl->m_VariableToIdentifierMap.find(variable);
                 if (itVar == impl->m_VariableToIdentifierMap.cend()) {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to onAbortProgressRequested request for unknown variable");
                     return;
                 }
                 auto varId = itVar->second;
                 auto itVarHandler = impl->m_VarIdToVarRequestHandler.find(varId);
                 if (itVarHandler == impl->m_VarIdToVarRequestHandler.cend()) {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to onAbortProgressRequested for variable with unknown handler");
                     return;
                 }
                 auto varHandler = itVarHandler->second.get();
                 // case where a variable has a running request
                 if (varHandler->m_State != VariableRequestHandlerState::OFF) {
                     impl->cancelVariableRequest(varHandler->m_RunningVarRequest.m_VariableGroupId);
                 }
             }
             void VariableController::onAbortAcquisitionRequested(QUuid vIdentifier)
             {
                 qCDebug(LOG_VariableController()) << "TORM: variableController::onAbortAcquisitionRequested"
                                                   << QThread::currentThread()->objectName() << vIdentifier;
                 if (auto var = impl->findVariable(vIdentifier)) {
                     this->onAbortProgressRequested(var);
                 }
                 else {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to abort Acquisition Requestof a null variable");
                 }
             }
             void VariableController::onAddSynchronizationGroupId(QUuid synchronizationGroupId)
             {
                 qCDebug(LOG_VariableController()) << "TORM: VariableController::onAddSynchronizationGroupId"
                                                   << QThread::currentThread()->objectName()
                                                   << synchronizationGroupId;
                 auto vSynchroGroup = std::make_shared<VariableSynchronizationGroup>();
                 impl->m_GroupIdToVariableSynchronizationGroupMap.insert(
                     std::make_pair(synchronizationGroupId, vSynchroGroup));
             }
             void VariableController::onRemoveSynchronizationGroupId(QUuid synchronizationGroupId)
             {
                 impl->m_GroupIdToVariableSynchronizationGroupMap.erase(synchronizationGroupId);
             }
             void VariableController::onAddSynchronized(std::shared_ptr<Variable> variable,
                                                        QUuid synchronizationGroupId)
             {
                 qCDebug(LOG_VariableController()) << "TORM: VariableController::onAddSynchronized"
                                                   << synchronizationGroupId;
                 auto varToVarIdIt = impl->m_VariableToIdentifierMap.find(variable);
                 if (varToVarIdIt != impl->m_VariableToIdentifierMap.cend()) {
                     auto groupIdToVSGIt
                         = impl->m_GroupIdToVariableSynchronizationGroupMap.find(synchronizationGroupId);
                     if (groupIdToVSGIt != impl->m_GroupIdToVariableSynchronizationGroupMap.cend()) {
                         impl->m_VariableIdGroupIdMap.insert(
                             std::make_pair(varToVarIdIt->second, synchronizationGroupId));
                         groupIdToVSGIt->second->addVariableId(varToVarIdIt->second);
                     }
                     else {
                         qCCritical(LOG_VariableController())
                             << tr("Impossible to synchronize a variable with an unknown sycnhronization group")
                             << variable->name();
                     }
                 }
                 else {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to synchronize a variable with no identifier") << variable->name();
                 }
             }
             void VariableController::desynchronize(std::shared_ptr<Variable> variable,
                                                    QUuid synchronizationGroupId)
             {
                 // Gets variable id
                 auto variableIt = impl->m_VariableToIdentifierMap.find(variable);
                 if (variableIt == impl->m_VariableToIdentifierMap.cend()) {
                     qCCritical(LOG_VariableController())
                         << tr("Can't desynchronize variable %1: variable identifier not found")
                                .arg(variable->name());
                     return;
                 }
                 // Gets synchronization group
                 auto groupIt = impl->m_GroupIdToVariableSynchronizationGroupMap.find(synchronizationGroupId);
                 if (groupIt == impl->m_GroupIdToVariableSynchronizationGroupMap.cend()) {
                     qCCritical(LOG_VariableController())
                         << tr("Can't desynchronize variable %1: unknown synchronization group")
                                .arg(variable->name());
                     return;
                 }
                 auto variableId = variableIt->second;
                 // Removes variable from synchronization group
                 auto synchronizationGroup = groupIt->second;
                 synchronizationGroup->removeVariableId(variableId);
                 // Removes link between variable and synchronization group
                 impl->m_VariableIdGroupIdMap.erase(variableId);
             }
             void VariableController::onRequestDataLoading(QVector<std::shared_ptr<Variable> > variables,
                                                           const SqpRange &range, bool synchronise)
             {
                 // variables is assumed synchronized
                 // TODO: Asser variables synchronization
                 // we want to load data of the variable for the dateTime.
                 if (variables.isEmpty()) {
                     return;
                 }
                 auto varRequestId = QUuid::createUuid();
                 qCDebug(LOG_VariableController()) << "VariableController::onRequestDataLoading"
                                                   << QThread::currentThread()->objectName() << varRequestId
                                                   << range << synchronise;
                 if (!synchronise) {
                     auto varIds = std::list<QUuid>{};
                     for (const auto &var : variables) {
                         auto vId = impl->m_VariableToIdentifierMap.at(var);
                         varIds.push_back(vId);
                     }
                     impl->m_VarGroupIdToVarIds.insert(std::make_pair(varRequestId, varIds));
                     for (const auto &var : variables) {
                         qCDebug(LOG_VariableController()) << "processRequest for" << var->name() << varRequestId
                                                           << varIds.size();
                         impl->processRequest(var, range, varRequestId);
                     }
                 }
                 else {
                     auto vId = impl->m_VariableToIdentifierMap.at(variables.first());
                     auto varIdToGroupIdIt = impl->m_VariableIdGroupIdMap.find(vId);
                     if (varIdToGroupIdIt != impl->m_VariableIdGroupIdMap.cend()) {
                         auto groupId = varIdToGroupIdIt->second;
                         auto vSynchronizationGroup
                             = impl->m_GroupIdToVariableSynchronizationGroupMap.at(groupId);
                         auto vSyncIds = vSynchronizationGroup->getIds();
                         auto varIds = std::list<QUuid>{};
                         for (auto vId : vSyncIds) {
                             varIds.push_back(vId);
                         }
                         impl->m_VarGroupIdToVarIds.insert(std::make_pair(varRequestId, varIds));
                         for (auto vId : vSyncIds) {
                             auto var = impl->findVariable(vId);
                             // Don't process already processed var
                             if (var != nullptr) {
                                 qCDebug(LOG_VariableController()) << "processRequest synchro for" << var->name()
                                                                   << varRequestId;
                                 auto vSyncRangeRequested
                                     = variables.contains(var)
                                           ? range
                                           : computeSynchroRangeRequested(var->range(), range,
                                                                          variables.first()->range());
                                 qCDebug(LOG_VariableController()) << "synchro RR" << vSyncRangeRequested;
                                 impl->processRequest(var, vSyncRangeRequested, varRequestId);
                             }
                             else {
                                 qCCritical(LOG_VariableController())
                                     << tr("Impossible to synchronize a null variable");
                             }
                         }
                     }
                 }
                 impl->updateVariables(varRequestId);
             }
             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};
             }
             AcquisitionZoomType VariableController::getZoomType(const SqpRange &range, const SqpRange &oldRange)
             {
                 // t1.m_TStart <= t2.m_TStart && t2.m_TEnd <= t1.m_TEnd
                 auto zoomType = AcquisitionZoomType::Unknown;
                 if (range.m_TStart <= oldRange.m_TStart && oldRange.m_TEnd <= range.m_TEnd) {
                     qCDebug(LOG_VariableController()) << "zoomtype: ZoomOut";
                     zoomType = AcquisitionZoomType::ZoomOut;
                 }
                 else if (range.m_TStart > oldRange.m_TStart && range.m_TEnd > oldRange.m_TEnd) {
                     qCDebug(LOG_VariableController()) << "zoomtype: PanRight";
                     zoomType = AcquisitionZoomType::PanRight;
                 }
                 else if (range.m_TStart < oldRange.m_TStart && range.m_TEnd < oldRange.m_TEnd) {
                     qCDebug(LOG_VariableController()) << "zoomtype: PanLeft";
                     zoomType = AcquisitionZoomType::PanLeft;
                 }
                 else if (range.m_TStart > oldRange.m_TStart && oldRange.m_TEnd > range.m_TEnd) {
                     qCDebug(LOG_VariableController()) << "zoomtype: ZoomIn";
                     zoomType = AcquisitionZoomType::ZoomIn;
                 }
                 else {
                     qCDebug(LOG_VariableController()) << "getZoomType: Unknown type detected";
                 }
                 return zoomType;
             }
             void VariableController::VariableControllerPrivate::processRequest(std::shared_ptr<Variable> var,
                                                                                const SqpRange &rangeRequested,
                                                                                QUuid varRequestId)
             {
                 auto itVar = m_VariableToIdentifierMap.find(var);
                 if (itVar == m_VariableToIdentifierMap.cend()) {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to process request for unknown variable");
                     return;
                 }
                 auto varId = itVar->second;
                 auto itVarHandler = m_VarIdToVarRequestHandler.find(varId);
                 if (itVarHandler == m_VarIdToVarRequestHandler.cend()) {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to process request for variable with unknown handler");
                     return;
                 }
                 auto oldRange = var->range();
                 auto varHandler = itVarHandler->second.get();
                 if (varHandler->m_State != VariableRequestHandlerState::OFF) {
                     oldRange = varHandler->m_RunningVarRequest.m_RangeRequested;
                 }
                 auto varRequest = VariableRequest{};
                 varRequest.m_VariableGroupId = varRequestId;
                 auto varStrategyRangesRequested
                     = m_VariableCacheStrategy->computeRange(oldRange, rangeRequested);
                 varRequest.m_RangeRequested = varStrategyRangesRequested.first;
                 varRequest.m_CacheRangeRequested = varStrategyRangesRequested.second;
                 switch (varHandler->m_State) {
                     case VariableRequestHandlerState::OFF: {
                         qCDebug(LOG_VariableController()) << tr("Process Request OFF")
                                                           << varRequest.m_RangeRequested
                                                           << varRequest.m_CacheRangeRequested;
                         varHandler->m_RunningVarRequest = varRequest;
                         varHandler->m_State = VariableRequestHandlerState::RUNNING;
                         executeVarRequest(var, varRequest);
                         break;
                     }
                     case VariableRequestHandlerState::RUNNING: {
                         qCDebug(LOG_VariableController()) << tr("Process Request RUNNING")
                                                           << varRequest.m_RangeRequested
                                                           << varRequest.m_CacheRangeRequested;
                         varHandler->m_State = VariableRequestHandlerState::PENDING;
                         varHandler->m_PendingVarRequest = varRequest;
                         break;
                     }
                     case VariableRequestHandlerState::PENDING: {
                         qCDebug(LOG_VariableController()) << tr("Process Request PENDING")
                                                           << varRequest.m_RangeRequested
                                                           << varRequest.m_CacheRangeRequested;
                         auto variableGroupIdToCancel = varHandler->m_PendingVarRequest.m_VariableGroupId;
                         cancelVariableRequest(variableGroupIdToCancel);
                         // Cancel variable can make state downgrade
                         varHandler->m_State = VariableRequestHandlerState::PENDING;
                         varHandler->m_PendingVarRequest = varRequest;
                         break;
                     }
                     default:
                         qCCritical(LOG_VariableController())
                             << QObject::tr("Unknown VariableRequestHandlerState");
                 }
             }
             std::shared_ptr<Variable>
             VariableController::VariableControllerPrivate::findVariable(QUuid vIdentifier)
             {
                 std::shared_ptr<Variable> var;
                 auto findReply = [vIdentifier](const auto &entry) { return vIdentifier == entry.second; };
                 auto end = m_VariableToIdentifierMap.cend();
                 auto it = std::find_if(m_VariableToIdentifierMap.cbegin(), end, findReply);
                 if (it != end) {
                     var = it->first;
                 }
                 else {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to find the variable with the identifier: ") << vIdentifier;
                 }
                 return var;
             }
             std::shared_ptr<IDataSeries> VariableController::VariableControllerPrivate::retrieveDataSeries(
                 const QVector<AcquisitionDataPacket> acqDataPacketVector)
             {
                 qCDebug(LOG_VariableController()) << tr("TORM: retrieveDataSeries acqDataPacketVector size")
                                                   << acqDataPacketVector.size();
                 std::shared_ptr<IDataSeries> dataSeries;
                 if (!acqDataPacketVector.isEmpty()) {
                     dataSeries = acqDataPacketVector[0].m_DateSeries;
                     for (int i = 1; i < acqDataPacketVector.size(); ++i) {
                         dataSeries->merge(acqDataPacketVector[i].m_DateSeries.get());
                     }
                 }
                 qCDebug(LOG_VariableController()) << tr("TORM: retrieveDataSeries acqDataPacketVector size END")
                                                   << acqDataPacketVector.size();
                 return dataSeries;
             }
             void VariableController::VariableControllerPrivate::registerProvider(
                 std::shared_ptr<IDataProvider> provider)
             {
                 if (m_ProviderSet.find(provider) == m_ProviderSet.end()) {
                     qCDebug(LOG_VariableController()) << tr("Registering of a new provider")
                                                       << provider->objectName();
                     m_ProviderSet.insert(provider);
                     connect(provider.get(), &IDataProvider::dataProvided, m_VariableAcquisitionWorker.get(),
                             &VariableAcquisitionWorker::onVariableDataAcquired);
                     connect(provider.get(), &IDataProvider::dataProvidedProgress,
                             m_VariableAcquisitionWorker.get(),
                             &VariableAcquisitionWorker::onVariableRetrieveDataInProgress);
                     connect(provider.get(), &IDataProvider::dataProvidedFailed,
                             m_VariableAcquisitionWorker.get(),
                             &VariableAcquisitionWorker::onVariableAcquisitionFailed);
                 }
                 else {
                     qCDebug(LOG_VariableController()) << tr("Cannot register provider, it already exists ");
                 }
             }
             QUuid VariableController::VariableControllerPrivate::acceptVariableRequest(
                 QUuid varId, std::shared_ptr<IDataSeries> dataSeries)
             {
                 auto itVarHandler = m_VarIdToVarRequestHandler.find(varId);
                 if (itVarHandler == m_VarIdToVarRequestHandler.cend()) {
                     return QUuid();
                 }
                 auto varHandler = itVarHandler->second.get();
                 if (varHandler->m_State == VariableRequestHandlerState::OFF) {
                     qCCritical(LOG_VariableController())
                         << tr("acceptVariableRequest impossible on a variable with OFF state");
                 }
                 varHandler->m_RunningVarRequest.m_DataSeries = dataSeries;
                 varHandler->m_CanUpdate = true;
                 // Element traité, on a déjà toutes les données necessaires
                 auto varGroupId = varHandler->m_RunningVarRequest.m_VariableGroupId;
                 qCDebug(LOG_VariableController()) << "Variable::acceptVariableRequest" << varGroupId
                                                   << m_VarGroupIdToVarIds.size();
                 return varHandler->m_RunningVarRequest.m_VariableGroupId;
             }
             void VariableController::VariableControllerPrivate::updateVariables(QUuid varRequestId)
             {
                 qCDebug(LOG_VariableController()) << "VariableControllerPrivate::updateVariables"
                                                   << QThread::currentThread()->objectName() << varRequestId;
                 auto varGroupIdToVarIdsIt = m_VarGroupIdToVarIds.find(varRequestId);
                 if (varGroupIdToVarIdsIt == m_VarGroupIdToVarIds.end()) {
                     qCWarning(LOG_VariableController())
                         << tr("Impossible to updateVariables of unknown variables") << varRequestId;
                     return;
                 }
                 auto &varIds = varGroupIdToVarIdsIt->second;
                 auto varIdsEnd = varIds.end();
                 bool processVariableUpdate = true;
                 qCDebug(LOG_VariableController()) << "VariableControllerPrivate::updateVariables"
                                                   << varRequestId << varIds.size();
                 for (auto varIdsIt = varIds.begin(); (varIdsIt != varIdsEnd) && processVariableUpdate;
                      ++varIdsIt) {
                     auto itVarHandler = m_VarIdToVarRequestHandler.find(*varIdsIt);
                     if (itVarHandler != m_VarIdToVarRequestHandler.cend()) {
                         processVariableUpdate &= itVarHandler->second->m_CanUpdate;
                     }
                 }
                 if (processVariableUpdate) {
                     qCDebug(LOG_VariableController()) << "Final update OK for the var request" << varIds.size();
                     for (auto varIdsIt = varIds.begin(); varIdsIt != varIdsEnd; ++varIdsIt) {
                         auto itVarHandler = m_VarIdToVarRequestHandler.find(*varIdsIt);
                         if (itVarHandler != m_VarIdToVarRequestHandler.cend()) {
                             if (auto var = findVariable(*varIdsIt)) {
                                 auto &varRequest = itVarHandler->second->m_RunningVarRequest;
                                 var->setRange(varRequest.m_RangeRequested);
                                 var->setCacheRange(varRequest.m_CacheRangeRequested);
                                 qCDebug(LOG_VariableController()) << tr("1: onDataProvided")
                                                                   << varRequest.m_RangeRequested
                                                                   << varRequest.m_CacheRangeRequested;
                                 qCDebug(LOG_VariableController()) << tr("2: onDataProvided var points before")
                                                                   << var->nbPoints()
                                                                   << varRequest.m_DataSeries->nbPoints();
                                 var->mergeDataSeries(varRequest.m_DataSeries);
                                 qCDebug(LOG_VariableController()) << tr("3: onDataProvided var points after")
                                                                   << var->nbPoints();
                                 emit var->updated();
                                 qCDebug(LOG_VariableController()) << tr("Update OK");
                             }
                             else {
                                 qCCritical(LOG_VariableController())
                                     << tr("Impossible to update data to a null variable");
                             }
                         }
                     }
                     updateVariableRequest(varRequestId);
                     // cleaning varRequestId
                     qCDebug(LOG_VariableController()) << tr("m_VarGroupIdToVarIds erase") << varRequestId;
                     m_VarGroupIdToVarIds.erase(varRequestId);
                 }
             }
             void VariableController::VariableControllerPrivate::updateVariableRequest(QUuid varRequestId)
             {
                 auto varGroupIdToVarIdsIt = m_VarGroupIdToVarIds.find(varRequestId);
                 if (varGroupIdToVarIdsIt == m_VarGroupIdToVarIds.end()) {
                     qCCritical(LOG_VariableController()) << QObject::tr(
                         "Impossible to updateVariableRequest since varGroupdId isn't here anymore");
                     return;
                 }
                 auto &varIds = varGroupIdToVarIdsIt->second;
                 auto varIdsEnd = varIds.end();
                 for (auto varIdsIt = varIds.begin(); (varIdsIt != varIdsEnd); ++varIdsIt) {
                     auto itVarHandler = m_VarIdToVarRequestHandler.find(*varIdsIt);
                     if (itVarHandler != m_VarIdToVarRequestHandler.cend()) {
                         auto varHandler = itVarHandler->second.get();
                         varHandler->m_CanUpdate = false;
                         switch (varHandler->m_State) {
                             case VariableRequestHandlerState::OFF: {
                                 qCCritical(LOG_VariableController())
                                     << QObject::tr("Impossible to update a variable with handler in OFF state");
                             } break;
                             case VariableRequestHandlerState::RUNNING: {
                                 varHandler->m_State = VariableRequestHandlerState::OFF;
                                 varHandler->m_RunningVarRequest = VariableRequest{};
                                 break;
                             }
                             case VariableRequestHandlerState::PENDING: {
                                 varHandler->m_State = VariableRequestHandlerState::RUNNING;
                                 varHandler->m_RunningVarRequest = varHandler->m_PendingVarRequest;
                                 varHandler->m_PendingVarRequest = VariableRequest{};
                                 auto var = findVariable(itVarHandler->first);
                                 executeVarRequest(var, varHandler->m_RunningVarRequest);
                                 break;
                             }
                             default:
                                 qCCritical(LOG_VariableController())
                                     << QObject::tr("Unknown VariableRequestHandlerState");
                         }
                     }
                 }
             }
             void VariableController::VariableControllerPrivate::cancelVariableRequest(QUuid varRequestId)
             {
                 qCDebug(LOG_VariableController()) << tr("cancelVariableRequest") << varRequestId;
                 auto varGroupIdToVarIdsIt = m_VarGroupIdToVarIds.find(varRequestId);
                 if (varGroupIdToVarIdsIt == m_VarGroupIdToVarIds.end()) {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to cancelVariableRequest for unknown varGroupdId") << varRequestId;
                     return;
                 }
                 auto &varIds = varGroupIdToVarIdsIt->second;
                 auto varIdsEnd = varIds.end();
                 for (auto varIdsIt = varIds.begin(); (varIdsIt != varIdsEnd); ++varIdsIt) {
                     auto itVarHandler = m_VarIdToVarRequestHandler.find(*varIdsIt);
                     if (itVarHandler != m_VarIdToVarRequestHandler.cend()) {
                         auto varHandler = itVarHandler->second.get();
                         varHandler->m_VarId = QUuid{};
                         switch (varHandler->m_State) {
                             case VariableRequestHandlerState::OFF: {
                                 qCWarning(LOG_VariableController())
                                     << QObject::tr("Impossible to cancel a variable with no running request");
                                 break;
                             }
                             case VariableRequestHandlerState::RUNNING: {
                                 if (varHandler->m_RunningVarRequest.m_VariableGroupId == varRequestId) {
                                     auto var = findVariable(itVarHandler->first);
                                     auto varProvider = m_VariableToProviderMap.at(var);
                                     if (varProvider != nullptr) {
                                         m_VariableAcquisitionWorker->abortProgressRequested(
                                             itVarHandler->first);
                                     }
                                     m_VariableModel->setDataProgress(var, 0.0);
                                     varHandler->m_CanUpdate = false;
                                     varHandler->m_State = VariableRequestHandlerState::OFF;
                                     varHandler->m_RunningVarRequest = VariableRequest{};
                                 }
                                 else {
                                     // TODO: log Impossible to cancel the running variable request beacause its
                                     // varRequestId isn't not the canceled one
                                 }
                                 break;
                             }
                             case VariableRequestHandlerState::PENDING: {
                                 if (varHandler->m_RunningVarRequest.m_VariableGroupId == varRequestId) {
                                     auto var = findVariable(itVarHandler->first);
                                     auto varProvider = m_VariableToProviderMap.at(var);
                                     if (varProvider != nullptr) {
                                         m_VariableAcquisitionWorker->abortProgressRequested(
                                             itVarHandler->first);
                                     }
                                     m_VariableModel->setDataProgress(var, 0.0);
                                     varHandler->m_CanUpdate = false;
                                     varHandler->m_State = VariableRequestHandlerState::RUNNING;
                                     varHandler->m_RunningVarRequest = varHandler->m_PendingVarRequest;
                                     varHandler->m_PendingVarRequest = VariableRequest{};
                                     executeVarRequest(var, varHandler->m_RunningVarRequest);
                                 }
                                 else if (varHandler->m_PendingVarRequest.m_VariableGroupId == varRequestId) {
                                     varHandler->m_State = VariableRequestHandlerState::RUNNING;
                                     varHandler->m_PendingVarRequest = VariableRequest{};
                                 }
                                 else {
                                     // TODO: log Impossible to cancel the variable request beacause its
                                     // varRequestId isn't not the canceled one
                                 }
                                 break;
                             }
                             default:
                                 qCCritical(LOG_VariableController())
                                     << QObject::tr("Unknown VariableRequestHandlerState");
                         }
                     }
                 }
                 qCDebug(LOG_VariableController()) << tr("cancelVariableRequest: erase") << varRequestId;
                 m_VarGroupIdToVarIds.erase(varRequestId);
             }
             void VariableController::VariableControllerPrivate::executeVarRequest(std::shared_ptr<Variable> var,
                                                                                   VariableRequest &varRequest)
             {
                 qCDebug(LOG_VariableController()) << tr("TORM: executeVarRequest");
                 auto varId = m_VariableToIdentifierMap.at(var);
                 auto varCacheRange = var->cacheRange();
                 auto varCacheRangeRequested = varRequest.m_CacheRangeRequested;
                 auto notInCacheRangeList
                     = Variable::provideNotInCacheRangeList(varCacheRange, varCacheRangeRequested);
                 auto inCacheRangeList
                     = Variable::provideInCacheRangeList(varCacheRange, varCacheRangeRequested);
                 if (!notInCacheRangeList.empty()) {
                     auto varProvider = m_VariableToProviderMap.at(var);
                     if (varProvider != nullptr) {
                         qCDebug(LOG_VariableController()) << "executeVarRequest " << varRequest.m_RangeRequested
                                                           << varRequest.m_CacheRangeRequested;
                         m_VariableAcquisitionWorker->pushVariableRequest(
                             varRequest.m_VariableGroupId, varId, varRequest.m_RangeRequested,
                             varRequest.m_CacheRangeRequested,
                             DataProviderParameters{std::move(notInCacheRangeList), var->metadata()},
                             varProvider);
                     }
                     else {
                         qCCritical(LOG_VariableController())
                             << "Impossible to provide data with a null provider";
                     }
                     if (!inCacheRangeList.empty()) {
                         emit q->updateVarDisplaying(var, inCacheRangeList.first());
                     }
                 }
                 else {
                     acceptVariableRequest(varId,
                                           var->dataSeries()->subDataSeries(varRequest.m_CacheRangeRequested));
                 }
             }

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

             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <Variable/VariableModel.h>
             #include <Common/DateUtils.h>
             #include <Common/MimeTypesDef.h>
             #include <Common/StringUtils.h>
             #include <Data/IDataSeries.h>
             #include <DataSource/DataSourceController.h>
             #include <Time/TimeController.h>
             #include <QMimeData>
             #include <QSize>
             #include <QTimer>
             #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 NBPOINTS_COLUMN = 3;
             const auto UNIT_COLUMN = 4;
             const auto MISSION_COLUMN = 5;
             const auto PLUGIN_COLUMN = 6;
             const auto NB_COLUMNS = 7;
             // 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}}, {NBPOINTS_COLUMN, {QObject::tr("Nb points")}},
                 {UNIT_COLUMN, {QObject::tr("Unit")}},      {MISSION_COLUMN, {QObject::tr("Mission")}},
                 {PLUGIN_COLUMN, {QObject::tr("Plugin")}}};
             /// Format for datetimes
             const auto DATETIME_FORMAT = QStringLiteral("dd/MM/yyyy \nhh:mm:ss:zzz");
             QString uniqueName(const QString &defaultName,
                                const std::vector<std::shared_ptr<Variable> > &variables)
             {
                 auto forbiddenNames = std::vector<QString>(variables.size());
                 std::transform(variables.cbegin(), variables.cend(), forbiddenNames.begin(),
                                [](const auto &variable) { return variable->name(); });
                 auto uniqueName = StringUtils::uniqueName(defaultName, forbiddenNames);
                 Q_ASSERT(!uniqueName.isEmpty());
                 return uniqueName;
             }
             } // 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;
                 VariableController *m_VariableController;
                 /// Return the row index of the variable. -1 if it's not found
                 int indexOfVariable(Variable *variable) const noexcept;
             };
             VariableModel::VariableModel(VariableController *parent)
                     : QAbstractTableModel{parent}, impl{spimpl::make_unique_impl<VariableModelPrivate>()}
             {
                 impl->m_VariableController = parent;
             }
             void VariableModel::addVariable(std::shared_ptr<Variable> variable) noexcept
             {
                 auto insertIndex = rowCount();
                 beginInsertRows({}, insertIndex, insertIndex);
                 // Generates unique name for the variable
                 variable->setName(uniqueName(variable->name(), impl->m_Variables));
                 impl->m_Variables.push_back(variable);
                 connect(variable.get(), &Variable::updated, this, &VariableModel::onVariableUpdated);
                 endInsertRows();
             }
             bool VariableModel::containsVariable(std::shared_ptr<Variable> variable) const noexcept
             {
                 auto end = impl->m_Variables.cend();
                 return std::find(impl->m_Variables.cbegin(), end, variable) != end;
             }
             std::shared_ptr<Variable> VariableModel::createVariable(const QString &name,
                                                                     const QVariantHash &metadata) noexcept
             {
                 auto variable = std::make_shared<Variable>(name, metadata);
                 addVariable(variable);
                 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;
+                return (index >= 0u && static_cast<size_t>(index) < impl->m_Variables.size())
+                           ? impl->m_Variables[index]
+                           : nullptr;
             }
             std::vector<std::shared_ptr<Variable> > VariableModel::variables() const
             {
                 return impl->m_Variables;
             }
             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()) {
                         switch (index.column()) {
                             case NAME_COLUMN:
                                 return variable->name();
                             case TSTART_COLUMN: {
                                 auto range = variable->realRange();
                                 return range != INVALID_RANGE
                                            ? DateUtils::dateTime(range.m_TStart).toString(DATETIME_FORMAT)
                                            : QVariant{};
                             }
                             case TEND_COLUMN: {
                                 auto range = variable->realRange();
                                 return range != INVALID_RANGE
                                            ? DateUtils::dateTime(range.m_TEnd).toString(DATETIME_FORMAT)
                                            : QVariant{};
                             }
                             case NBPOINTS_COLUMN:
                                 return variable->nbPoints();
                             case UNIT_COLUMN:
                                 return variable->metadata().value(QStringLiteral("units"));
                             case MISSION_COLUMN:
                                 return variable->metadata().value(QStringLiteral("mission"));
                             case PLUGIN_COLUMN:
                                 return variable->metadata().value(QStringLiteral("plugin"));
                             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{};
             }
             Qt::ItemFlags VariableModel::flags(const QModelIndex &index) const
             {
                 return QAbstractTableModel::flags(index) | Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled;
             }
             Qt::DropActions VariableModel::supportedDropActions() const
             {
                 return Qt::CopyAction | Qt::MoveAction;
             }
             Qt::DropActions VariableModel::supportedDragActions() const
             {
                 return Qt::CopyAction | Qt::MoveAction;
             }
             QStringList VariableModel::mimeTypes() const
             {
                 return {MIME_TYPE_VARIABLE_LIST, MIME_TYPE_TIME_RANGE};
             }
             QMimeData *VariableModel::mimeData(const QModelIndexList &indexes) const
             {
                 auto mimeData = new QMimeData;
                 QList<std::shared_ptr<Variable> > variableList;
                 SqpRange firstTimeRange;
                 for (const auto &index : indexes) {
                     if (index.column() == 0) { // only the first column
                         auto variable = impl->m_Variables.at(index.row());
                         if (variable.get() && index.isValid()) {
                             if (variableList.isEmpty()) {
                                 // Gets the range of the first variable
                                 firstTimeRange = std::move(variable->range());
                             }
                             variableList << variable;
                         }
                     }
                 }
                 auto variablesEncodedData = impl->m_VariableController->mimeDataForVariables(variableList);
                 mimeData->setData(MIME_TYPE_VARIABLE_LIST, variablesEncodedData);
                 if (variableList.count() == 1) {
                     // No time range MIME data if multiple variables are dragged
                     auto timeEncodedData = TimeController::mimeDataForTimeRange(firstTimeRange);
                     mimeData->setData(MIME_TYPE_TIME_RANGE, timeEncodedData);
                 }
                 return mimeData;
             }
             bool VariableModel::canDropMimeData(const QMimeData *data, Qt::DropAction action, int row,
                                                 int column, const QModelIndex &parent) const
             {
                 // drop of a product
                 return data->hasFormat(MIME_TYPE_PRODUCT_LIST)
                        || (data->hasFormat(MIME_TYPE_TIME_RANGE) && parent.isValid()
                            && !data->hasFormat(MIME_TYPE_VARIABLE_LIST));
             }
             bool VariableModel::dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column,
                                              const QModelIndex &parent)
             {
                 auto dropDone = false;
                 if (data->hasFormat(MIME_TYPE_PRODUCT_LIST)) {
                     auto productList
                         = DataSourceController::productsDataForMimeData(data->data(MIME_TYPE_PRODUCT_LIST));
                     for (auto metaData : productList) {
                         emit requestVariable(metaData.toHash());
                     }
                     dropDone = true;
                 }
                 else if (data->hasFormat(MIME_TYPE_TIME_RANGE) && parent.isValid()) {
                     auto variable = this->variable(parent.row());
                     auto range = TimeController::timeRangeForMimeData(data->data(MIME_TYPE_TIME_RANGE));
                     emit requestVariableRangeUpdate(variable, range);
                     dropDone = true;
                 }
                 return dropDone;
             }
             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/Data/DataSeriesUtils.cpp +1 -1

             #include "DataSeriesUtils.h"
             void validateRange(DataSeriesIterator first, DataSeriesIterator last, const DataContainer &xData,
                                const DataContainer &valuesData)
             {
                 QVERIFY(std::equal(first, last, xData.cbegin(), xData.cend(),
                                    [](const auto &it, const auto &expectedX) { return it.x() == expectedX; }));
                 QVERIFY(std::equal(
                     first, last, valuesData.cbegin(), valuesData.cend(),
                     [](const auto &it, const auto &expectedVal) { return it.value() == expectedVal; }));
             }
             void validateRange(DataSeriesIterator first, DataSeriesIterator last, const DataContainer &xData, const std::vector<DataContainer> &valuesData)
             {
                 QVERIFY(std::equal(first, last, xData.cbegin(), xData.cend(),
                                    [](const auto &it, const auto &expectedX) { return it.x() == expectedX; }));
-                for (auto i = 0; i < valuesData.size(); ++i) {
+                for (auto i = 0u; i < valuesData.size(); ++i) {
                     auto componentData = valuesData.at(i);
                     QVERIFY(std::equal(
                                 first, last, componentData.cbegin(), componentData.cend(),
                                 [i](const auto &it, const auto &expectedVal) { return it.value(i) == expectedVal; }));
                 }
             }

core/tests/Data/TestTwoDimArrayData.cpp +3 -3

             #include "Data/ArrayData.h"
             #include <QObject>
             #include <QtTest>
             using DataContainer = std::vector<double>;
             using Container = std::vector<DataContainer>;
             using InputData = QPair<DataContainer, int>;
             namespace {
             InputData flatten(const Container &container)
             {
                 if (container.empty()) {
                     return {};
                 }
                 // We assume here that each component of the container have the same size
                 auto containerSize = container.size();
                 auto componentSize = container.front().size();
                 auto result = DataContainer{};
                 result.reserve(componentSize * containerSize);
-                for (auto i = 0; i < componentSize; ++i) {
+                for (auto i = 0u; i < componentSize; ++i) {
-                    for (auto j = 0; j < containerSize; ++j) {
+                    for (auto j = 0u; j < containerSize; ++j) {
                         result.push_back(container.at(j).at(i));
                     }
                 }
                 return {result, static_cast<int>(containerSize)};
             }
             void verifyArrayData(const ArrayData<2> &arrayData, const Container &expectedData)
             {
                 auto verifyComponent = [&arrayData](const auto &componentData, const auto &equalFun) {
                     QVERIFY(std::equal(arrayData.cbegin(), arrayData.cend(), componentData.cbegin(),
                                        componentData.cend(),
                                        [&equalFun](const auto &dataSeriesIt, const auto &expectedValue) {
                                            return equalFun(dataSeriesIt, expectedValue);
                                        }));
                 };
-                for (auto i = 0; i < expectedData.size(); ++i) {
+                for (auto i = 0u; i < expectedData.size(); ++i) {
                     verifyComponent(expectedData.at(i), [i](const auto &seriesIt, const auto &value) {
                         return seriesIt.at(i) == value;
                     });
                 }
             }
             } // namespace
             class TestTwoDimArrayData : public QObject {
                 Q_OBJECT
             private slots:
                 /// Tests @sa ArrayData ctor
                 void testCtor_data();
                 void testCtor();
                 /// Tests @sa ArrayData::add()
                 void testAdd_data();
                 void testAdd();
                 /// Tests @sa ArrayData::clear()
                 void testClear_data();
                 void testClear();
                 /// Tests @sa ArrayData::size()
                 void testSize_data();
                 void testSize();
                 /// Tests @sa ArrayData::sort()
                 void testSort_data();
                 void testSort();
             };
             void TestTwoDimArrayData::testCtor_data()
             {
                 // Test structure
                 QTest::addColumn<InputData>("inputData");    // array data's input
                 QTest::addColumn<bool>("success");           // array data has been successfully constructed
                 QTest::addColumn<Container>("expectedData"); // expected array data (when success)
                 // Test cases
                 QTest::newRow("validInput") << flatten(Container{{1., 2., 3., 4., 5.},
                                                                  {6., 7., 8., 9., 10.},
                                                                  {11., 12., 13., 14., 15.}})
                                             << true << Container{{1., 2., 3., 4., 5.},
                                                                  {6., 7., 8., 9., 10.},
                                                                  {11., 12., 13., 14., 15.}};
                 QTest::newRow("invalidInput (invalid data size") << InputData{{1., 2., 3., 4., 5., 6., 7.}, 3}
                                                                  << false << Container{{}, {}, {}};
                 QTest::newRow("invalidInput (less than two components")
                     << flatten(Container{{1., 2., 3., 4., 5.}}) << false << Container{{}, {}, {}};
             }
             void TestTwoDimArrayData::testCtor()
             {
                 QFETCH(InputData, inputData);
                 QFETCH(bool, success);
                 if (success) {
                     QFETCH(Container, expectedData);
                     ArrayData<2> arrayData{inputData.first, inputData.second};
                     verifyArrayData(arrayData, expectedData);
                 }
                 else {
                     QVERIFY_EXCEPTION_THROWN(ArrayData<2>(inputData.first, inputData.second),
                                              std::invalid_argument);
                 }
             }
             void TestTwoDimArrayData::testAdd_data()
             {
                 // Test structure
                 QTest::addColumn<InputData>("inputData");    // array's data input
                 QTest::addColumn<InputData>("otherData");    // array data's input to merge with
                 QTest::addColumn<bool>("prepend");           // prepend or append merge
                 QTest::addColumn<Container>("expectedData"); // expected data after merge
                 // Test cases
                 auto inputData = flatten(
                     Container{{1., 2., 3., 4., 5.}, {11., 12., 13., 14., 15.}, {21., 22., 23., 24., 25.}});
                 auto vectorContainer = flatten(Container{{6., 7., 8.}, {16., 17., 18.}, {26., 27., 28}});
                 auto tensorContainer = flatten(Container{{6., 7., 8.},
                                                          {16., 17., 18.},
                                                          {26., 27., 28},
                                                          {36., 37., 38.},
                                                          {46., 47., 48.},
                                                          {56., 57., 58}});
                 QTest::newRow("appendMerge") << inputData << vectorContainer << false
                                              << Container{{1., 2., 3., 4., 5., 6., 7., 8.},
                                                           {11., 12., 13., 14., 15., 16., 17., 18.},
                                                           {21., 22., 23., 24., 25., 26., 27., 28}};
                 QTest::newRow("prependMerge") << inputData << vectorContainer << true
                                               << Container{{6., 7., 8., 1., 2., 3., 4., 5.},
                                                            {16., 17., 18., 11., 12., 13., 14., 15.},
                                                            {26., 27., 28, 21., 22., 23., 24., 25.}};
                 QTest::newRow("invalidMerge") << inputData << tensorContainer << false
                                               << Container{{1., 2., 3., 4., 5.},
                                                            {11., 12., 13., 14., 15.},
                                                            {21., 22., 23., 24., 25.}};
             }
             void TestTwoDimArrayData::testAdd()
             {
                 QFETCH(InputData, inputData);
                 QFETCH(InputData, otherData);
                 QFETCH(bool, prepend);
                 QFETCH(Container, expectedData);
                 ArrayData<2> arrayData{inputData.first, inputData.second};
                 ArrayData<2> other{otherData.first, otherData.second};
                 arrayData.add(other, prepend);
                 verifyArrayData(arrayData, expectedData);
             }
             void TestTwoDimArrayData::testClear_data()
             {
                 // Test structure
                 QTest::addColumn<InputData>("inputData"); // array data's input
                 // Test cases
                 QTest::newRow("data1") << flatten(
                     Container{{1., 2., 3., 4., 5.}, {6., 7., 8., 9., 10.}, {11., 12., 13., 14., 15.}});
             }
             void TestTwoDimArrayData::testClear()
             {
                 QFETCH(InputData, inputData);
                 ArrayData<2> arrayData{inputData.first, inputData.second};
                 arrayData.clear();
                 auto emptyData = Container(inputData.second, DataContainer{});
                 verifyArrayData(arrayData, emptyData);
             }
             void TestTwoDimArrayData::testSize_data()
             {
                 // Test structure
                 QTest::addColumn<InputData>("inputData"); // array data's input
                 QTest::addColumn<int>("expectedSize");    // expected array data size
                 // Test cases
                 QTest::newRow("data1") << flatten(Container{{1., 2., 3., 4., 5.}, {6., 7., 8., 9., 10.}}) << 5;
                 QTest::newRow("data2") << flatten(Container{{1., 2., 3., 4., 5.},
                                                             {6., 7., 8., 9., 10.},
                                                             {11., 12., 13., 14., 15.}})
                                        << 5;
             }
             void TestTwoDimArrayData::testSize()
             {
                 QFETCH(InputData, inputData);
                 QFETCH(int, expectedSize);
                 ArrayData<2> arrayData{inputData.first, inputData.second};
                 QVERIFY(arrayData.size() == expectedSize);
             }
             void TestTwoDimArrayData::testSort_data()
             {
                 // Test structure
                 QTest::addColumn<InputData>("inputData");               // array data's input
                 QTest::addColumn<std::vector<int> >("sortPermutation"); // permutation used to sort data
                 QTest::addColumn<Container>("expectedData");            // expected data after sorting
                 // Test cases
                 QTest::newRow("data1")
                     << flatten(
                            Container{{1., 2., 3., 4., 5.}, {6., 7., 8., 9., 10.}, {11., 12., 13., 14., 15.}})
                     << std::vector<int>{0, 2, 3, 1, 4}
                     << Container{{1., 3., 4., 2., 5.}, {6., 8., 9., 7., 10.}, {11., 13., 14., 12., 15.}};
                 QTest::newRow("data2")
                     << flatten(
                            Container{{1., 2., 3., 4., 5.}, {6., 7., 8., 9., 10.}, {11., 12., 13., 14., 15.}})
                     << std::vector<int>{2, 4, 3, 0, 1}
                     << Container{{3., 5., 4., 1., 2.}, {8., 10., 9., 6., 7.}, {13., 15., 14., 11., 12.}};
             }
             void TestTwoDimArrayData::testSort()
             {
                 QFETCH(InputData, inputData);
                 QFETCH(std::vector<int>, sortPermutation);
                 QFETCH(Container, expectedData);
                 ArrayData<2> arrayData{inputData.first, inputData.second};
                 auto sortedArrayData = arrayData.sort(sortPermutation);
                 QVERIFY(sortedArrayData != nullptr);
                 verifyArrayData(*sortedArrayData, expectedData);
             }
             QTEST_MAIN(TestTwoDimArrayData)
             #include "TestTwoDimArrayData.moc"

gui/meson.build 0 -3

             gui_moc_headers = [
               'include/DataSource/DataSourceWidget.h',
-              'include/DataSource/DataSourceTreeWidget.h',
               'include/Settings/SqpSettingsDialog.h',
               'include/Settings/SqpSettingsGeneralWidget.h',
               'include/SidePane/SqpSidePane.h',
               'include/SqpApplication.h',
-              'include/DragAndDrop/DragDropHelper.h',
               'include/DragAndDrop/DragDropScroller.h',
               'include/DragAndDrop/DragDropTabSwitcher.h',
               'include/TimeWidget/TimeWidget.h',
               'include/Variable/VariableInspectorWidget.h',
-              'include/Variable/VariableInspectorTableView.h',
               'include/Variable/RenameVariableDialog.h',
               'include/Visualization/qcustomplot.h',
               'include/Visualization/VisualizationGraphWidget.h',
               'include/Visualization/VisualizationTabWidget.h',
               'include/Visualization/VisualizationWidget.h',
               'include/Visualization/VisualizationZoneWidget.h',
               'include/Visualization/VisualizationDragDropContainer.h',
               'include/Visualization/VisualizationDragWidget.h'
             ]
             gui_ui_files = [
               'ui/DataSource/DataSourceWidget.ui',
               'ui/Settings/SqpSettingsDialog.ui',
               'ui/Settings/SqpSettingsGeneralWidget.ui',
               'ui/SidePane/SqpSidePane.ui',
               'ui/TimeWidget/TimeWidget.ui',
               'ui/Variable/VariableInspectorWidget.ui',
               'ui/Variable/RenameVariableDialog.ui',
               'ui/Variable/VariableMenuHeaderWidget.ui',
               'ui/Visualization/VisualizationGraphWidget.ui',
               'ui/Visualization/VisualizationTabWidget.ui',
               'ui/Visualization/VisualizationWidget.ui',
               'ui/Visualization/VisualizationZoneWidget.ui'
             ]
             gui_qresources = ['resources/sqpguiresources.qrc']
             gui_moc_files = qt5.preprocess(moc_headers : gui_moc_headers,
                                            ui_files : gui_ui_files,
                                            qresources : gui_qresources)
             gui_sources = [
               'src/SqpApplication.cpp',
               'src/DragAndDrop/DragDropHelper.cpp',
               'src/DragAndDrop/DragDropScroller.cpp',
               'src/DragAndDrop/DragDropTabSwitcher.cpp',
               'src/Common/ColorUtils.cpp',
               'src/Common/VisualizationDef.cpp',
               'src/DataSource/DataSourceTreeWidgetItem.cpp',
               'src/DataSource/DataSourceTreeWidgetHelper.cpp',
               'src/DataSource/DataSourceWidget.cpp',
               'src/DataSource/DataSourceTreeWidget.cpp',
               'src/Settings/SqpSettingsDialog.cpp',
               'src/Settings/SqpSettingsGeneralWidget.cpp',
               'src/SidePane/SqpSidePane.cpp',
               'src/TimeWidget/TimeWidget.cpp',
               'src/Variable/VariableInspectorWidget.cpp',
               'src/Variable/VariableInspectorTableView.cpp',
               'src/Variable/VariableMenuHeaderWidget.cpp',
               'src/Variable/RenameVariableDialog.cpp',
               'src/Visualization/VisualizationGraphHelper.cpp',
               'src/Visualization/VisualizationGraphRenderingDelegate.cpp',
               'src/Visualization/VisualizationGraphWidget.cpp',
               'src/Visualization/VisualizationTabWidget.cpp',
               'src/Visualization/VisualizationWidget.cpp',
               'src/Visualization/VisualizationZoneWidget.cpp',
               'src/Visualization/qcustomplot.cpp',
               'src/Visualization/QCustomPlotSynchronizer.cpp',
               'src/Visualization/operations/FindVariableOperation.cpp',
               'src/Visualization/operations/GenerateVariableMenuOperation.cpp',
               'src/Visualization/operations/MenuBuilder.cpp',
               'src/Visualization/operations/RemoveVariableOperation.cpp',
               'src/Visualization/operations/RescaleAxeOperation.cpp',
               'src/Visualization/VisualizationDragDropContainer.cpp',
               'src/Visualization/VisualizationDragWidget.cpp',
               'src/Visualization/AxisRenderingUtils.cpp',
               'src/Visualization/PlottablesRenderingUtils.cpp',
               'src/Visualization/MacScrollBarStyle.cpp'
             ]
             gui_inc = include_directories(['include'])
             sciqlop_gui_lib = library('sciqlopgui',
                                    gui_sources,
                                    gui_moc_files,
                                    include_directories : [gui_inc],
                                    dependencies : [ qt5printsupport, qt5gui, qt5widgets, qt5svg, sciqlop_core],
                                    install : true
                                    )
             sciqlop_gui = declare_dependency(link_with : sciqlop_gui_lib,
                                             include_directories : gui_inc,
                                             dependencies : [qt5printsupport, qt5gui, qt5widgets, qt5svg, sciqlop_core])

gui/src/SqpApplication.cpp +2 -2

             #include "SqpApplication.h"
             #include <Data/IDataProvider.h>
             #include <DataSource/DataSourceController.h>
             #include <DragAndDrop/DragDropHelper.h>
             #include <Network/NetworkController.h>
             #include <QThread>
             #include <Time/TimeController.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <Variable/VariableModel.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_TimeController{std::make_unique<TimeController>()},
+                          m_NetworkController{std::make_unique<NetworkController>()},
                           m_VisualizationController{std::make_unique<VisualizationController>()},
                           m_DragDropHelper{std::make_unique<DragDropHelper>()}
                 {
                     // /////////////////////////////// //
                     // 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>)));
                     connect(m_VariableController->variableModel(), &VariableModel::requestVariable,
                             m_DataSourceController.get(), &DataSourceController::requestVariable);
                     // 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 SqpRange &)),
                             m_VisualizationController.get(),
                             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()
                 {
                     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;
                 std::unique_ptr<DragDropHelper> m_DragDropHelper;
             };
             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;
             }
             DragDropHelper &SqpApplication::dragDropHelper() noexcept
             {
                 return *impl->m_DragDropHelper;
             }

gui/src/Visualization/operations/GenerateVariableMenuOperation.cpp +2 -2

             #include "Visualization/operations/GenerateVariableMenuOperation.h"
             #include "Visualization/operations/MenuBuilder.h"
             #include "Visualization/VisualizationGraphWidget.h"
             #include "Visualization/VisualizationTabWidget.h"
             #include "Visualization/VisualizationZoneWidget.h"
             #include <Variable/Variable.h>
             #include <QMenu>
             #include <QStack>
             Q_LOGGING_CATEGORY(LOG_GenerateVariableMenuOperation, "GenerateVariableMenuOperation")
             struct GenerateVariableMenuOperation::GenerateVariableMenuOperationPrivate {
                 explicit GenerateVariableMenuOperationPrivate(
                     QMenu *menu, std::shared_ptr<Variable> variable,
                     std::set<IVisualizationWidget *> variableContainers)
                         : m_Variable{variable},
+                          m_VariableContainers{std::move(variableContainers)},
                           m_PlotMenuBuilder{menu},
-                          m_UnplotMenuBuilder{menu},
+                          m_UnplotMenuBuilder{menu}
-                          m_VariableContainers{std::move(variableContainers)}
                 {
                 }
                 void visitRootEnter()
                 {
                     // Creates the root menu
                     if (auto plotMenu
                         = m_PlotMenuBuilder.addMenu(QObject::tr("Plot"), QIcon{":/icones/plot.png"})) {
                         plotMenu->setEnabled(m_Variable && m_Variable->dataSeries() != nullptr);
                     }
                     m_UnplotMenuBuilder.addMenu(QObject::tr("Unplot"), QIcon{":/icones/unplot.png"});
                 }
                 void visitRootLeave()
                 {
                     // Closes the root menu
                     m_PlotMenuBuilder.closeMenu();
                     m_UnplotMenuBuilder.closeMenu();
                 }
                 void visitNodeEnter(const IVisualizationWidget &container)
                 {
                     // Opens a new menu associated to the node
                     m_PlotMenuBuilder.addMenu(container.name());
                     m_UnplotMenuBuilder.addMenu(container.name());
                 }
                 template <typename ActionFun>
                 void visitNodeLeavePlot(const IVisualizationWidget &container, const QString &actionName,
                                         ActionFun actionFunction)
                 {
                     if (isValidContainer(container)) {
                         m_PlotMenuBuilder.addSeparator();
                         m_PlotMenuBuilder.addAction(actionName, actionFunction);
                     }
                     // Closes the menu associated to the node
                     m_PlotMenuBuilder.closeMenu();
                 }
                 void visitNodeLeaveUnplot()
                 {
                     // Closes the menu associated to the node
                     m_UnplotMenuBuilder.closeMenu();
                 }
                 template <typename ActionFun>
                 void visitLeafPlot(const IVisualizationWidget &container, const QString &actionName,
                                    ActionFun actionFunction)
                 {
                     if (isValidContainer(container)) {
                         m_PlotMenuBuilder.addAction(actionName, actionFunction);
                     }
                 }
                 template <typename ActionFun>
                 void visitLeafUnplot(IVisualizationWidget *container, const QString &actionName,
                                      ActionFun actionFunction)
                 {
                     // If the container contains the variable, we generate 'unplot' action
                     if (m_VariableContainers.count(container) == 1) {
                         m_UnplotMenuBuilder.addAction(actionName, actionFunction);
                     }
                 }
                 bool isValidContainer(const IVisualizationWidget &container) const noexcept
                 {
                     // A container is valid if it can contain the variable and if the variable is not already
                     // contained in another container
                     return m_Variable && m_VariableContainers.size() == 0 && container.canDrop(*m_Variable);
                 }
                 std::shared_ptr<Variable> m_Variable;
                 std::set<IVisualizationWidget *> m_VariableContainers;
                 MenuBuilder m_PlotMenuBuilder;   ///< Builder for the 'Plot' menu
                 MenuBuilder m_UnplotMenuBuilder; ///< Builder for the 'Unplot' menu
             };
             GenerateVariableMenuOperation::GenerateVariableMenuOperation(
                 QMenu *menu, std::shared_ptr<Variable> variable,
                 std::set<IVisualizationWidget *> variableContainers)
                     : impl{spimpl::make_unique_impl<GenerateVariableMenuOperationPrivate>(
                           menu, variable, std::move(variableContainers))}
             {
             }
             void GenerateVariableMenuOperation::visitEnter(VisualizationWidget *widget)
             {
                 // VisualizationWidget is not intended to accommodate a variable
                 Q_UNUSED(widget)
                 // 'Plot' and 'Unplot' menus
                 impl->visitRootEnter();
             }
             void GenerateVariableMenuOperation::visitLeave(VisualizationWidget *widget)
             {
                 // VisualizationWidget is not intended to accommodate a variable
                 Q_UNUSED(widget)
                 // 'Plot' and 'Unplot' menus
                 impl->visitRootLeave();
             }
             void GenerateVariableMenuOperation::visitEnter(VisualizationTabWidget *tabWidget)
             {
                 if (tabWidget) {
                     // 'Plot' and 'Unplot' menus
                     impl->visitNodeEnter(*tabWidget);
                 }
                 else {
                     qCCritical(LOG_GenerateVariableMenuOperation(),
                                "Can't visit enter VisualizationTabWidget : the widget is null");
                 }
             }
             void GenerateVariableMenuOperation::visitLeave(VisualizationTabWidget *tabWidget)
             {
                 if (tabWidget) {
                     // 'Plot' menu
                     impl->visitNodeLeavePlot(*tabWidget, QObject::tr("Open in a new zone"),
                                              [ varW = std::weak_ptr<Variable>{impl->m_Variable}, tabWidget ]() {
                                                  if (auto var = varW.lock()) {
                                                      tabWidget->createZone(var);
                                                  }
                                              });
                     // 'Unplot' menu
                     impl->visitNodeLeaveUnplot();
                 }
                 else {
                     qCCritical(LOG_GenerateVariableMenuOperation(),
                                "Can't visit leave VisualizationTabWidget : the widget is null");
                 }
             }
             void GenerateVariableMenuOperation::visitEnter(VisualizationZoneWidget *zoneWidget)
             {
                 if (zoneWidget) {
                     // 'Plot' and 'Unplot' menus
                     impl->visitNodeEnter(*zoneWidget);
                 }
                 else {
                     qCCritical(LOG_GenerateVariableMenuOperation(),
                                "Can't visit enter VisualizationZoneWidget : the widget is null");
                 }
             }
             void GenerateVariableMenuOperation::visitLeave(VisualizationZoneWidget *zoneWidget)
             {
                 if (zoneWidget) {
                     // 'Plot' menu
                     impl->visitNodeLeavePlot(
                         *zoneWidget, QObject::tr("Open in a new graph"),
                         [ varW = std::weak_ptr<Variable>{impl->m_Variable}, zoneWidget ]() {
                             if (auto var = varW.lock()) {
                                 zoneWidget->createGraph(var);
                             }
                         });
                     // 'Unplot' menu
                     impl->visitNodeLeaveUnplot();
                 }
                 else {
                     qCCritical(LOG_GenerateVariableMenuOperation(),
                                "Can't visit leave VisualizationZoneWidget : the widget is null");
                 }
             }
             void GenerateVariableMenuOperation::visit(VisualizationGraphWidget *graphWidget)
             {
                 if (graphWidget) {
                     // 'Plot' menu
                     impl->visitLeafPlot(*graphWidget, QObject::tr("Open in %1").arg(graphWidget->name()),
                                         [ varW = std::weak_ptr<Variable>{impl->m_Variable}, graphWidget ]() {
                                             if (auto var = varW.lock()) {
                                                 graphWidget->addVariable(var, graphWidget->graphRange());
                                             }
                                         });
                     // 'Unplot' menu
                     impl->visitLeafUnplot(graphWidget, QObject::tr("Remove from %1").arg(graphWidget->name()),
                                           [ varW = std::weak_ptr<Variable>{impl->m_Variable}, graphWidget ]() {
                                               if (auto var = varW.lock()) {
                                                   graphWidget->removeVariable(var);
                                               }
                                           });
                 }
                 else {
                     qCCritical(LOG_GenerateVariableMenuOperation(),
                                "Can't visit VisualizationGraphWidget : the widget is null");
                 }
             }

plugins/amda/src/AmdaResultParserHelper.cpp +1 -1

             #include "AmdaResultParserHelper.h"
             #include <Common/DateUtils.h>
             #include <Common/SortUtils.h>
             #include <Data/ScalarSeries.h>
             #include <Data/SpectrogramSeries.h>
             #include <Data/Unit.h>
             #include <Data/VectorSeries.h>
             #include <QtCore/QDateTime>
             #include <QtCore/QRegularExpression>
             #include <functional>
             Q_LOGGING_CATEGORY(LOG_AmdaResultParserHelper, "AmdaResultParserHelper")
             namespace {
             // ///////// //
             // Constants //
             // ///////// //
             /// Separator between values in a result line
             const auto RESULT_LINE_SEPARATOR = QRegularExpression{QStringLiteral("\\s+")};
             /// Format for dates in result files
             const auto DATE_FORMAT = QStringLiteral("yyyy-MM-ddThh:mm:ss.zzz");
             // /////// //
             // Methods //
             // /////// //
             /**
              * Checks that the properties contain a specific unit and that this unit is valid
              * @param properties the properties map in which to search unit
              * @param key the key to search for the unit in the properties
              * @param errorMessage the error message to log in case the unit is invalid
              * @return true if the unit is valid, false it it's invalid or was not found in the properties
              */
             bool checkUnit(const Properties &properties, const QString &key, const QString &errorMessage)
             {
                 auto unit = properties.value(key).value<Unit>();
                 if (unit.m_Name.isEmpty()) {
                     qCWarning(LOG_AmdaResultParserHelper()) << errorMessage;
                     return false;
                 }
                 return true;
             }
             QDateTime dateTimeFromString(const QString &stringDate) noexcept
             {
             #if QT_VERSION >= QT_VERSION_CHECK(5, 8, 0)
                 return QDateTime::fromString(stringDate, Qt::ISODateWithMs);
             #else
                 return QDateTime::fromString(stringDate, DATE_FORMAT);
             #endif
             }
             /// Converts a string date to a double date
             /// @return a double that represents the date in seconds, NaN if the string date can't be converted
             double doubleDate(const QString &stringDate) noexcept
             {
                 // Format: yyyy-MM-ddThh:mm:ss.zzz
                 auto dateTime = dateTimeFromString(stringDate);
                 dateTime.setTimeSpec(Qt::UTC);
                 return dateTime.isValid() ? DateUtils::secondsSinceEpoch(dateTime)
                                           : std::numeric_limits<double>::quiet_NaN();
             }
             /**
              * Reads a line from the AMDA file and tries to extract a x-axis data and value data from it
              * @param xAxisData the vector in which to store the x-axis data extracted
              * @param valuesData the vector in which to store the value extracted
              * @param line the line to read to extract the property
              * @param valuesIndexes indexes of insertion of read values. For example, if the line contains three
              * columns of values, and valuesIndexes are {2, 0, 1}, the value of the third column will be read
              * and inserted first, then the value of the first column, and finally the value of the second
              * column.
              * @param fillValue value that tags an invalid data. For example, if fillValue is -1 and a read
              * value is -1, then this value is considered as invalid and converted to NaN
              */
             void tryReadResult(std::vector<double> &xAxisData, std::vector<double> &valuesData,
                                const QString &line, const std::vector<int> &valuesIndexes,
                                double fillValue = std::numeric_limits<double>::quiet_NaN())
             {
                 auto lineData = line.split(RESULT_LINE_SEPARATOR, QString::SkipEmptyParts);
                 // Checks that the line contains expected number of values + x-axis value
-                if (lineData.size() == valuesIndexes.size() + 1) {
+                if (static_cast<size_t>(lineData.size()) == valuesIndexes.size() + 1) {
                     // X : the data is converted from date to double (in secs)
                     auto x = doubleDate(lineData.at(0));
                     // Adds result only if x is valid. Then, if value is invalid, it is set to NaN
                     if (!std::isnan(x)) {
                         xAxisData.push_back(x);
                         // Values
                         for (auto valueIndex : valuesIndexes) {
                             bool valueOk;
                             // we use valueIndex + 1 to skip column 0 (x-axis value)
                             auto value = lineData.at(valueIndex + 1).toDouble(&valueOk);
                             if (!valueOk) {
                                 qCWarning(LOG_AmdaResultParserHelper())
                                     << QObject::tr(
                                            "Value from (line %1, column %2) is invalid and will be "
                                            "converted to NaN")
                                            .arg(line, valueIndex);
                                 value = std::numeric_limits<double>::quiet_NaN();
                             }
                             // Handles fill value
                             if (!std::isnan(fillValue) && !std::isnan(value) && fillValue == value) {
                                 value = std::numeric_limits<double>::quiet_NaN();
                             }
                             valuesData.push_back(value);
                         }
                     }
                     else {
                         qCWarning(LOG_AmdaResultParserHelper())
                             << QObject::tr("Can't retrieve results from line %1: x is invalid").arg(line);
                     }
                 }
                 else {
                     qCWarning(LOG_AmdaResultParserHelper())
                         << QObject::tr("Can't retrieve results from line %1: invalid line").arg(line);
                 }
             }
             /**
              * Reads a line from the AMDA file and tries to extract a property from it
              * @param properties the properties map in which to put the property extracted from the line
              * @param key the key to which the property is added in the properties map
              * @param line the line to read to extract the property
              * @param regex the expected regex to extract the property. If the line matches this regex, the
              * property is generated
              * @param fun the function used to generate the property
              * @return true if the property could be generated, false if the line does not match the regex, or
              * if a property has already been generated for the key
              */
             template <typename GeneratePropertyFun>
             bool tryReadProperty(Properties &properties, const QString &key, const QString &line,
                                  const QRegularExpression &regex, GeneratePropertyFun fun)
             {
                 if (properties.contains(key)) {
                     return false;
                 }
                 auto match = regex.match(line);
                 if (match.hasMatch()) {
                     properties.insert(key, fun(match));
                 }
                 return match.hasMatch();
             }
             /**
              * Reads a line from the AMDA file and tries to extract a double from it
              * @sa tryReadProperty()
              */
             bool tryReadDouble(Properties &properties, const QString &key, const QString &line,
                                const QRegularExpression &regex)
             {
                 return tryReadProperty(properties, key, line, regex, [](const auto &match) {
                     bool ok;
                     // If the value can't be converted to double, it is set to NaN
                     auto doubleValue = match.captured(1).toDouble(&ok);
                     if (!ok) {
                         doubleValue = std::numeric_limits<double>::quiet_NaN();
                     }
                     return QVariant::fromValue(doubleValue);
                 });
             }
             /**
              * Reads a line from the AMDA file and tries to extract a vector of doubles from it
              * @param sep the separator of double values in the line
              * @sa tryReadProperty()
              */
             bool tryReadDoubles(Properties &properties, const QString &key, const QString &line,
                                 const QRegularExpression &regex, const QString &sep = QStringLiteral(","))
             {
                 return tryReadProperty(properties, key, line, regex, [sep](const auto &match) {
                     std::vector<double> doubleValues{};
                     // If the value can't be converted to double, it is set to NaN
                     auto values = match.captured(1).split(sep);
                     for (auto value : values) {
                         bool ok;
                         auto doubleValue = value.toDouble(&ok);
                         if (!ok) {
                             doubleValue = std::numeric_limits<double>::quiet_NaN();
                         }
                         doubleValues.push_back(doubleValue);
                     }
                     return QVariant::fromValue(doubleValues);
                 });
             }
             /**
              * Reads a line from the AMDA file and tries to extract a unit from it
              * @sa tryReadProperty()
              */
             bool tryReadUnit(Properties &properties, const QString &key, const QString &line,
                              const QRegularExpression &regex, bool timeUnit = false)
             {
                 return tryReadProperty(properties, key, line, regex, [timeUnit](const auto &match) {
                     return QVariant::fromValue(Unit{match.captured(1), timeUnit});
                 });
             }
             } // namespace
             // ////////////////// //
             // ScalarParserHelper //
             // ////////////////// //
             bool ScalarParserHelper::checkProperties()
             {
                 return checkUnit(m_Properties, X_AXIS_UNIT_PROPERTY,
                                  QObject::tr("The x-axis unit could not be found in the file"));
             }
             std::shared_ptr<IDataSeries> ScalarParserHelper::createSeries()
             {
                 return std::make_shared<ScalarSeries>(std::move(m_XAxisData), std::move(m_ValuesData),
                                                       m_Properties.value(X_AXIS_UNIT_PROPERTY).value<Unit>(),
                                                       m_Properties.value(VALUES_UNIT_PROPERTY).value<Unit>());
             }
             void ScalarParserHelper::readPropertyLine(const QString &line)
             {
                 tryReadUnit(m_Properties, X_AXIS_UNIT_PROPERTY, line, DEFAULT_X_AXIS_UNIT_REGEX, true);
             }
             void ScalarParserHelper::readResultLine(const QString &line)
             {
                 tryReadResult(m_XAxisData, m_ValuesData, line, valuesIndexes());
             }
             std::vector<int> ScalarParserHelper::valuesIndexes() const
             {
                 // Only one value to read
                 static auto result = std::vector<int>{0};
                 return result;
             }
             // /////////////////////// //
             // SpectrogramParserHelper //
             // /////////////////////// //
             bool SpectrogramParserHelper::checkProperties()
             {
                 // Generates y-axis data from bands extracted (take the middle of the intervals)
                 auto minBands = m_Properties.value(MIN_BANDS_PROPERTY).value<std::vector<double> >();
                 auto maxBands = m_Properties.value(MAX_BANDS_PROPERTY).value<std::vector<double> >();
                 if (minBands.size() != maxBands.size()) {
                     qCWarning(LOG_AmdaResultParserHelper()) << QObject::tr(
                         "Can't generate y-axis data from bands extracted: bands intervals are invalid");
                     return false;
                 }
                 std::transform(
                     minBands.begin(), minBands.end(), maxBands.begin(), std::back_inserter(m_YAxisData),
                     [](const auto &minValue, const auto &maxValue) { return (minValue + maxValue) / 2.; });
                 // Generates values indexes, i.e. the order in which each value will be retrieved (in ascending
                 // order of the associated bands)
                 m_ValuesIndexes = SortUtils::sortPermutation(m_YAxisData, std::less<double>());
                 // Sorts y-axis data accoding to the ascending order
                 m_YAxisData = SortUtils::sort(m_YAxisData, 1, m_ValuesIndexes);
                 // Sets fill value
                 m_FillValue = m_Properties.value(FILL_VALUE_PROPERTY).value<double>();
                 /// @todo: handle min/max samplings?
                 return true;
             }
             std::shared_ptr<IDataSeries> SpectrogramParserHelper::createSeries()
             {
                 return std::make_shared<SpectrogramSeries>(
                     std::move(m_XAxisData), std::move(m_YAxisData), std::move(m_ValuesData),
                     Unit{"t", true}, // x-axis unit is always a time unit
                     m_Properties.value(Y_AXIS_UNIT_PROPERTY).value<Unit>(),
                     m_Properties.value(VALUES_UNIT_PROPERTY).value<Unit>());
             }
             void SpectrogramParserHelper::readPropertyLine(const QString &line)
             {
                 // Set of functions to test on the line to generate a property. If a function is valid (i.e. a
                 // property has been generated for the line), the line is treated as processed and the other
                 // functions are not called
                 std::vector<std::function<bool()> > functions{
                     // values unit
                     [&] {
                         return tryReadUnit(m_Properties, VALUES_UNIT_PROPERTY, line,
                                            SPECTROGRAM_VALUES_UNIT_REGEX);
                     },
                     // y-axis unit
                     [&] {
                         return tryReadUnit(m_Properties, Y_AXIS_UNIT_PROPERTY, line,
                                            SPECTROGRAM_Y_AXIS_UNIT_REGEX);
                     },
                     // min sampling
                     [&] {
                         return tryReadDouble(m_Properties, MIN_SAMPLING_PROPERTY, line,
                                              SPECTROGRAM_MIN_SAMPLING_REGEX);
                     },
                     // max sampling
                     [&] {
                         return tryReadDouble(m_Properties, MAX_SAMPLING_PROPERTY, line,
                                              SPECTROGRAM_MAX_SAMPLING_REGEX);
                     },
                     // fill value
                     [&] {
                         return tryReadDouble(m_Properties, FILL_VALUE_PROPERTY, line,
                                              SPECTROGRAM_FILL_VALUE_REGEX);
                     },
                     // min bounds of each band
                     [&] {
                         return tryReadDoubles(m_Properties, MIN_BANDS_PROPERTY, line,
                                               SPECTROGRAM_MIN_BANDS_REGEX);
                     },
                     // max bounds of each band
                     [&] {
                         return tryReadDoubles(m_Properties, MAX_BANDS_PROPERTY, line,
                                               SPECTROGRAM_MAX_BANDS_REGEX);
                     }};
                 for (auto function : functions) {
                     // Stops at the first function that is valid
                     if (function()) {
                         return;
                     }
                 }
             }
             void SpectrogramParserHelper::readResultLine(const QString &line)
             {
                 tryReadResult(m_XAxisData, m_ValuesData, line, m_ValuesIndexes, m_FillValue);
             }
             // ////////////////// //
             // VectorParserHelper //
             // ////////////////// //
             bool VectorParserHelper::checkProperties()
             {
                 return checkUnit(m_Properties, X_AXIS_UNIT_PROPERTY,
                                  QObject::tr("The x-axis unit could not be found in the file"));
             }
             std::shared_ptr<IDataSeries> VectorParserHelper::createSeries()
             {
                 return std::make_shared<VectorSeries>(std::move(m_XAxisData), std::move(m_ValuesData),
                                                       m_Properties.value(X_AXIS_UNIT_PROPERTY).value<Unit>(),
                                                       m_Properties.value(VALUES_UNIT_PROPERTY).value<Unit>());
             }
             void VectorParserHelper::readPropertyLine(const QString &line)
             {
                 tryReadUnit(m_Properties, X_AXIS_UNIT_PROPERTY, line, DEFAULT_X_AXIS_UNIT_REGEX, true);
             }
             void VectorParserHelper::readResultLine(const QString &line)
             {
                 tryReadResult(m_XAxisData, m_ValuesData, line, valuesIndexes());
             }
             std::vector<int> VectorParserHelper::valuesIndexes() const
             {
                 // 3 values to read, in order in the file (x, y, z)
                 static auto result = std::vector<int>{0, 1, 2};
                 return result;
             }

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