GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r861:86289e199fbd

Windows s**t

trabillard -

r861:86289e199fbd

parent child

Context file:

r861:86289e199fbd

app/src/MainWindow.cpp +2 -4

             const auto VIEWPLITTERINDEX = 2;
             const auto RIGHTINSPECTORSIDEPANESPLITTERINDEX = 3;
             const auto RIGHTMAININSPECTORWIDGETSPLITTERINDEX = 4;
+            } // namespace
             class MainWindow::MainWindowPrivate {
             public:
                     Qt::DirectConnection);
             }
-            MainWindow::~MainWindow()
+            MainWindow::~MainWindow() {}
             void MainWindow::changeEvent(QEvent *e)
             {

core/include/Common/MetaTypes.h +23 -23

@@ -13,30 +13,30 struct MetaTypeRegistry {
13	};	13	};
14		14
15	/**	15	/**
16	* This macro can be used to :	16	* This macro can be used to :
17	* - declare a type as a Qt meta type	17	* - declare a type as a Qt meta type
18	* - and register it (through a static instance) at the launch of SciQlop, so it can be passed in	18	* - and register it (through a static instance) at the launch of SciQlop, so it can be passed in
19	* Qt signals/slots	19	* Qt signals/slots
20	*	20	*
21	* It can be used both in .h or in .cpp files	21	* It can be used both in .h or in .cpp files
22	*	22	*
23	* @param NAME name of the instance under which the type will be registered (in uppercase)	23	* @param NAME name of the instance under which the type will be registered (in uppercase)
24	* @param TYPE type to register	24	* @param TYPE type to register
25	*	25	*
26	* Example:	26	* Example:
27	* ~~~cpp	27	* ~~~cpp
28	* // The following macro :	28	* // The following macro :
29	* // - declares std::shared_ptr<Variable> as a Qt meta type	29	* // - declares std::shared_ptr<Variable> as a Qt meta type
30	* // - registers it through an instance named VAR_SHARED_PTR	30	* // - registers it through an instance named VAR_SHARED_PTR
31	* SCIQLOP_REGISTER_META_TYPE(VAR_SHARED_PTR, std::shared_ptr<Variable>)	31	* SCIQLOP_REGISTER_META_TYPE(VAR_SHARED_PTR, std::shared_ptr<Variable>)
32	*	32	*
33	* // The following macro :	33	* // The following macro :
34	* // - declares a raw pointer of Variable as a Qt meta type	34	* // - declares a raw pointer of Variable as a Qt meta type
35	* // - registers it through an instance named VAR_RAW_PTR	35	* // - registers it through an instance named VAR_RAW_PTR
36	* SCIQLOP_REGISTER_META_TYPE(VAR_RAW_PTR, Variable*)	36	* SCIQLOP_REGISTER_META_TYPE(VAR_RAW_PTR, Variable*)
37	* ~~~	37	* ~~~
38	*	38	*
39	*/	39	*/
40	// clang-format off	40	// clang-format off
41	#define SCIQLOP_REGISTER_META_TYPE(NAME, TYPE) \	41	#define SCIQLOP_REGISTER_META_TYPE(NAME, TYPE) \
42	Q_DECLARE_METATYPE(TYPE) \	42	Q_DECLARE_METATYPE(TYPE) \

core/include/Common/spimpl.h +13 -15

             template <class T, class D, class C>
             struct is_default_manageable
-                : public std::integral_constant<bool, std::is_same<D, default_deleter_t<T> >::value
+                    : public std::integral_constant<bool, std::is_same<D, default_deleter_t<T> >::value
-                                                          && std::is_same<C, default_copier_t<T> >::value> {
+                                                              && std::is_same<C, default_copier_t<T> >::value> {
             };
+            } // namespace details
             template <class T, class Deleter = details::default_deleter_t<T>,
                                                            && is_default_manageable::value,
                                                        dummy_t_>::type
                                = dummy_t_()) SPIMPL_NOEXCEPT
-                    : impl_ptr(u, &details::default_delete<T>, &details::default_copy<T>)
+                        : impl_ptr(u, &details::default_delete<T>, &details::default_copy<T>)
                 {
                 }
                                                                            && is_default_manageable::value,
                                                                        dummy_t_>::type
                                                = dummy_t_()) SPIMPL_NOEXCEPT
-                    : ptr_(u.release(), &details::default_delete<T>),
+                        : ptr_(u.release(), &details::default_delete<T>),
-                      copier_(&details::default_copy<T>)
+                          copier_(&details::default_copy<T>)
                 {
                 }
             #endif
                     return operator=(u.clone());
                 }
-            //
+                    //
             #ifdef SPIMPL_HAS_AUTO_PTR
                 template <class U>
-                typename std::enable_if<std::is_convertible<U *, pointer>::value
+                typename std::enable_if<
-                                            && is_default_manageable::value,
+                    std::is_convertible<U *, pointer>::value && is_default_manageable::value, impl_ptr &>::type
-                                        impl_ptr &>::type
                 operator=(std::auto_ptr<U> &&u) SPIMPL_NOEXCEPT
                 {
                     return operator=(impl_ptr(std::move(u)));
             #endif
                 template <class U>
-                typename std::enable_if<std::is_convertible<U *, pointer>::value
+                typename std::enable_if<
-                                            && is_default_manageable::value,
+                    std::is_convertible<U *, pointer>::value && is_default_manageable::value, impl_ptr &>::type
-                                        impl_ptr &>::type
                 operator=(std::unique_ptr<U> &&u) SPIMPL_NOEXCEPT
                 {
                     return operator=(impl_ptr(std::move(u)));
                 static_assert(!std::is_array<T>::value, "unique_impl_ptr does not support arrays");
                 return unique_impl_ptr<T>(new T(std::forward<Args>(args)...), &details::default_delete<T>);
             }
+            } // namespace spimpl
             namespace std {
             template <class T, class D, class C>
                     return hash<typename argument_type::pointer>()(p.get());
                 }
             };
+            } // namespace std
             #endif // SPIMPL_H_

core/src/Data/VectorSeries.cpp +4 -3

             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),
+                    : VectorSeries{
-                                                                 std::move(zValuesData)),
+                          std::move(xAxisData),
-                                   xAxisUnit, valuesUnit}
+                          flatten(std::move(xValuesData), std::move(yValuesData), std::move(zValuesData)),
+                          xAxisUnit, valuesUnit}
             {
             }

core/src/DataSource/DataSourceController.cpp +6 -6

             DataSourceController::DataSourceController(QObject *parent)
                     : impl{spimpl::make_unique_impl<DataSourceControllerPrivate>()}
             {
-                qCDebug(LOG_DataSourceController()) << tr("DataSourceController construction")
+                qCDebug(LOG_DataSourceController())
-                                                    << QThread::currentThread();
+                    << tr("DataSourceController construction") << QThread::currentThread();
             }
             DataSourceController::~DataSourceController()
             {
-                qCDebug(LOG_DataSourceController()) << tr("DataSourceController destruction")
+                qCDebug(LOG_DataSourceController())
-                                                    << QThread::currentThread();
+                    << tr("DataSourceController destruction") << QThread::currentThread();
                 this->waitForFinish();
             }
             void DataSourceController::initialize()
             {
-                qCDebug(LOG_DataSourceController()) << tr("DataSourceController init")
+                qCDebug(LOG_DataSourceController())
-                                                    << QThread::currentThread();
+                    << tr("DataSourceController init") << QThread::currentThread();
                 impl->m_WorkingMutex.lock();
                 qCDebug(LOG_DataSourceController()) << tr("DataSourceController init END");
             }

core/src/Network/NetworkController.cpp +11 -11

                         impl->unlock();
                     }
-                    qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyFinished END")
+                    qCDebug(LOG_NetworkController())
-                                                     << QThread::currentThread() << reply;
+                        << tr("NetworkController onReplyFinished END") << QThread::currentThread() << reply;
                 };
                 auto onReplyProgress = [reply, request, this](qint64 bytesRead, qint64 totalBytes) {
                     // NOTE: a totalbytes of 0 can happened when a request has been aborted
                     if (totalBytes > 0) {
                         double progress = (bytesRead * 100.0) / totalBytes;
-                        qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyProgress") << progress
+                        qCDebug(LOG_NetworkController())
-                                                         << QThread::currentThread() << request.get() << reply
+                            << tr("NetworkController onReplyProgress") << progress << QThread::currentThread()
-                                                         << bytesRead << totalBytes;
+                            << request.get() << reply << bytesRead << totalBytes;
                         impl->lockRead();
                         auto it = impl->m_NetworkReplyToId.find(reply);
                         if (it != impl->m_NetworkReplyToId.cend()) {
                             impl->unlock();
                         }
-                        qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyProgress END")
+                        qCDebug(LOG_NetworkController())
-                                                         << QThread::currentThread() << reply;
+                            << tr("NetworkController onReplyProgress END") << QThread::currentThread() << reply;
                     }
                 };
             void NetworkController::onReplyCanceled(QUuid identifier)
             {
                 auto findReply = [identifier](const auto &entry) { return identifier == entry.second; };
-                qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyCanceled")
+                qCDebug(LOG_NetworkController())
-                                                 << QThread::currentThread() << identifier;
+                    << tr("NetworkController onReplyCanceled") << QThread::currentThread() << identifier;
                 impl->lockRead();
                                                      << QThread::currentThread() << identifier;
                     it->first->abort();
                 }
-                qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyCanceled END")
+                qCDebug(LOG_NetworkController())
-                                                 << QThread::currentThread();
+                    << tr("NetworkController onReplyCanceled END") << QThread::currentThread();
             }
             void NetworkController::waitForFinish()

core/src/Plugin/PluginManager.cpp +1 -3

                 QHash<QString, QString> m_RegisteredPlugins;
             };
-            PluginManager::PluginManager() : impl{spimpl::make_unique_impl<PluginManagerPrivate>()}
+            PluginManager::PluginManager() : impl{spimpl::make_unique_impl<PluginManagerPrivate>()} {}
             void PluginManager::loadPlugins(const QDir &pluginDir)
             {

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

                             notInCache << SqpRange{impl->m_CacheRange.m_TEnd, range.m_TEnd};
                         }
                         else {
-                            qCCritical(LOG_Variable()) << tr("Detection of unknown case.")
+                            qCCritical(LOG_Variable())
-                                                       << QThread::currentThread();
+                                << tr("Detection of unknown case.") << QThread::currentThread();
                         }
                     }
                 }
                             inCache << impl->m_CacheRange;
                         }
                         else {
-                            qCCritical(LOG_Variable()) << tr("Detection of unknown case.")
+                            qCCritical(LOG_Variable())
-                                                       << QThread::currentThread();
+                                << tr("Detection of unknown case.") << QThread::currentThread();
                         }
                     }
                 }
                             notInCache << SqpRange{oldRange.m_TEnd, nextRange.m_TEnd};
                         }
                         else {
-                            qCCritical(LOG_Variable()) << tr("Detection of unknown case.")
+                            qCCritical(LOG_Variable())
-                                                       << QThread::currentThread();
+                                << tr("Detection of unknown case.") << QThread::currentThread();
                         }
                     }
                 }
                             inCache << oldRange;
                         }
                         else {
-                            qCCritical(LOG_Variable()) << tr("Detection of unknown case.")
+                            qCCritical(LOG_Variable())
-                                                       << QThread::currentThread();
+                                << tr("Detection of unknown case.") << QThread::currentThread();
                         }
                     }
                 }

core/src/Variable/VariableAcquisitionWorker.cpp +15 -15

             VariableAcquisitionWorker::~VariableAcquisitionWorker()
             {
-                qCInfo(LOG_VariableAcquisitionWorker()) << tr("VariableAcquisitionWorker destruction")
+                qCInfo(LOG_VariableAcquisitionWorker())
-                                                        << QThread::currentThread();
+                    << tr("VariableAcquisitionWorker destruction") << QThread::currentThread();
                 this->waitForFinish();
             }
                 // Request creation
                 auto acqRequest = AcquisitionRequest{};
-                qCDebug(LOG_VariableAcquisitionWorker()) << tr("PushVariableRequest ") << vIdentifier
+                qCDebug(LOG_VariableAcquisitionWorker())
-                                                         << varRequestId;
+                    << tr("PushVariableRequest ") << vIdentifier << varRequestId;
                 acqRequest.m_VarRequestId = varRequestId;
                 acqRequest.m_vIdentifier = vIdentifier;
                 acqRequest.m_DataProviderParameters = parameters;
             void VariableAcquisitionWorker::onVariableRetrieveDataInProgress(QUuid acqIdentifier,
                                                                              double progress)
             {
-                qCDebug(LOG_VariableAcquisitionWorker()) << tr("TORM: onVariableRetrieveDataInProgress ")
+                qCDebug(LOG_VariableAcquisitionWorker())
-                                                         << acqIdentifier << progress;
+                    << tr("TORM: onVariableRetrieveDataInProgress ") << acqIdentifier << progress;
                 impl->lockRead();
                 auto aIdToARit = impl->m_AcqIdentifierToAcqRequestMap.find(acqIdentifier);
                 if (aIdToARit != impl->m_AcqIdentifierToAcqRequestMap.cend()) {
             void VariableAcquisitionWorker::onVariableAcquisitionFailed(QUuid acqIdentifier)
             {
-                qCDebug(LOG_VariableAcquisitionWorker()) << tr("onVariableAcquisitionFailed")
+                qCDebug(LOG_VariableAcquisitionWorker())
-                                                         << QThread::currentThread();
+                    << tr("onVariableAcquisitionFailed") << QThread::currentThread();
                 impl->lockRead();
                 auto it = impl->m_AcqIdentifierToAcqRequestMap.find(acqIdentifier);
                 if (it != impl->m_AcqIdentifierToAcqRequestMap.cend()) {
                     auto request = it->second;
                     impl->unlock();
-                    qCDebug(LOG_VariableAcquisitionWorker()) << tr("onVariableAcquisitionFailed")
+                    qCDebug(LOG_VariableAcquisitionWorker())
-                                                             << acqIdentifier << request.m_vIdentifier
+                        << tr("onVariableAcquisitionFailed") << acqIdentifier << request.m_vIdentifier
-                                                             << QThread::currentThread();
+                        << QThread::currentThread();
                     emit variableCanceledRequested(request.m_vIdentifier);
                 }
                 else {
                                                                    std::shared_ptr<IDataSeries> dataSeries,
                                                                    SqpRange dataRangeAcquired)
             {
-                qCDebug(LOG_VariableAcquisitionWorker()) << tr("TORM: onVariableDataAcquired on range ")
+                qCDebug(LOG_VariableAcquisitionWorker())
-                                                         << acqIdentifier << dataRangeAcquired;
+                    << tr("TORM: onVariableDataAcquired on range ") << acqIdentifier << dataRangeAcquired;
                 impl->lockWrite();
                 auto aIdToARit = impl->m_AcqIdentifierToAcqRequestMap.find(acqIdentifier);
                 if (aIdToARit != impl->m_AcqIdentifierToAcqRequestMap.cend()) {
             void VariableAcquisitionWorker::initialize()
             {
-                qCDebug(LOG_VariableAcquisitionWorker()) << tr("VariableAcquisitionWorker init")
+                qCDebug(LOG_VariableAcquisitionWorker())
-                                                         << QThread::currentThread();
+                    << tr("VariableAcquisitionWorker init") << QThread::currentThread();
                 impl->m_WorkingMutex.lock();
                 qCDebug(LOG_VariableAcquisitionWorker()) << tr("VariableAcquisitionWorker init END");
             }

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

             void VariableCacheController::addDateTime(std::shared_ptr<Variable> variable,
                                                       const SqpRange &dateTime)
             {
-                qCDebug(LOG_VariableCacheController()) << "VariableCacheController::addDateTime"
+                qCDebug(LOG_VariableCacheController())
-                                                       << QThread::currentThread()->objectName();
+                    << "VariableCacheController::addDateTime" << QThread::currentThread()->objectName();
                 if (variable) {
                     auto findVariableIte = impl->m_VariableToSqpRangeListMap.find(variable);
                     if (findVariableIte == impl->m_VariableToSqpRangeListMap.end()) {
             QVector<SqpRange>
             VariableCacheController::dateCacheList(std::shared_ptr<Variable> variable) const noexcept
             {
-                qCDebug(LOG_VariableCacheController()) << "VariableCacheController::dateCacheList"
+                qCDebug(LOG_VariableCacheController())
-                                                       << QThread::currentThread()->objectName();
+                    << "VariableCacheController::dateCacheList" << QThread::currentThread()->objectName();
                 try {
                     return impl->m_VariableToSqpRangeListMap.at(variable);
                 }
             {
                 auto variableDateTimeList = impl->m_VariableToSqpRangeListMap.find(variable);
                 if (variableDateTimeList != impl->m_VariableToSqpRangeListMap.end()) {
-                    qCInfo(LOG_VariableCacheController()) << tr("VariableCacheController::displayCache")
+                    qCInfo(LOG_VariableCacheController())
-                                                          << variableDateTimeList->second;
+                        << tr("VariableCacheController::displayCache") << variableDateTimeList->second;
                 }
                 else {
                     qCWarning(LOG_VariableCacheController())

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

                 return varRangeRequested;
             }
+            } // namespace
             enum class VariableRequestHandlerState { OFF, RUNNING, PENDING };
             VariableController::VariableController(QObject *parent)
                     : QObject{parent}, impl{spimpl::make_unique_impl<VariableControllerPrivate>(this)}
             {
-                qCDebug(LOG_VariableController()) << tr("VariableController construction")
+                qCDebug(LOG_VariableController())
-                                                  << QThread::currentThread();
+                    << tr("VariableController construction") << QThread::currentThread();
                 connect(impl->m_VariableModel, &VariableModel::abortProgessRequested, this,
                         &VariableController::onAbortProgressRequested);
             VariableController::~VariableController()
             {
-                qCDebug(LOG_VariableController()) << tr("VariableController destruction")
+                qCDebug(LOG_VariableController())
-                                                  << QThread::currentThread();
+                    << tr("VariableController destruction") << QThread::currentThread();
                 this->waitForFinish();
             }
             void VariableController::onDateTimeOnSelection(const SqpRange &dateTime)
             {
                 // NOTE: Even if acquisition request is aborting, the graphe range will be changed
-                qCDebug(LOG_VariableController()) << "VariableController::onDateTimeOnSelection"
+                qCDebug(LOG_VariableController())
-                                                  << QThread::currentThread()->objectName();
+                    << "VariableController::onDateTimeOnSelection" << QThread::currentThread()->objectName();
                 auto selectedRows = impl->m_VariableSelectionModel->selectedRows();
                 // NOTE we only permit the time modification for one variable
             void VariableController::onAddSynchronizationGroupId(QUuid synchronizationGroupId)
             {
-                qCDebug(LOG_VariableController()) << "TORM: VariableController::onAddSynchronizationGroupId"
+                qCDebug(LOG_VariableController())
-                                                  << QThread::currentThread()->objectName()
+                    << "TORM: VariableController::onAddSynchronizationGroupId"
-                                                  << synchronizationGroupId;
+                    << QThread::currentThread()->objectName() << synchronizationGroupId;
                 auto vSynchroGroup = std::make_shared<VariableSynchronizationGroup>();
                 impl->m_GroupIdToVariableSynchronizationGroupMap.insert(
                     std::make_pair(synchronizationGroupId, vSynchroGroup));
                                                        QUuid synchronizationGroupId)
             {
-                qCDebug(LOG_VariableController()) << "TORM: VariableController::onAddSynchronized"
+                qCDebug(LOG_VariableController())
-                                                  << synchronizationGroupId;
+                    << "TORM: VariableController::onAddSynchronized" << synchronizationGroupId;
                 auto varToVarIdIt = impl->m_VariableToIdentifierMap.find(variable);
                 if (varToVarIdIt != impl->m_VariableToIdentifierMap.cend()) {
                     auto groupIdToVSGIt
                 }
                 auto varRequestId = QUuid::createUuid();
-                qCDebug(LOG_VariableController()) << "VariableController::onRequestDataLoading"
+                qCDebug(LOG_VariableController())
-                                                  << QThread::currentThread()->objectName() << varRequestId
+                    << "VariableController::onRequestDataLoading" << QThread::currentThread()->objectName()
-                                                  << range << synchronise;
+                    << varRequestId << range << synchronise;
                 if (!synchronise) {
                     auto varIds = std::list<QUuid>{};
                     }
                     impl->m_VarGroupIdToVarIds.insert(std::make_pair(varRequestId, varIds));
                     for (const auto &var : variables) {
-                        qCDebug(LOG_VariableController()) << "processRequest for" << var->name() << varRequestId
+                        qCDebug(LOG_VariableController())
-                                                          << varIds.size();
+                            << "processRequest for" << var->name() << varRequestId << varIds.size();
                         impl->processRequest(var, range, varRequestId);
                     }
                 }
                             // Don't process already processed var
                             if (var != nullptr) {
-                                qCDebug(LOG_VariableController()) << "processRequest synchro for" << var->name()
+                                qCDebug(LOG_VariableController())
-                                                                  << varRequestId;
+                                    << "processRequest synchro for" << var->name() << varRequestId;
                                 auto vSyncRangeRequested
                                     = variables.contains(var)
                                           ? range
                 switch (varHandler->m_State) {
                     case VariableRequestHandlerState::OFF: {
-                        qCDebug(LOG_VariableController()) << tr("Process Request OFF")
+                        qCDebug(LOG_VariableController())
-                                                          << varRequest.m_RangeRequested
+                            << tr("Process Request OFF") << varRequest.m_RangeRequested
-                                                          << varRequest.m_CacheRangeRequested;
+                            << 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")
+                        qCDebug(LOG_VariableController())
-                                                          << varRequest.m_RangeRequested
+                            << tr("Process Request RUNNING") << varRequest.m_RangeRequested
-                                                          << varRequest.m_CacheRangeRequested;
+                            << varRequest.m_CacheRangeRequested;
                         varHandler->m_State = VariableRequestHandlerState::PENDING;
                         varHandler->m_PendingVarRequest = varRequest;
                         break;
                     }
                     case VariableRequestHandlerState::PENDING: {
-                        qCDebug(LOG_VariableController()) << tr("Process Request PENDING")
+                        qCDebug(LOG_VariableController())
-                                                          << varRequest.m_RangeRequested
+                            << tr("Process Request PENDING") << varRequest.m_RangeRequested
-                                                          << varRequest.m_CacheRangeRequested;
+                            << varRequest.m_CacheRangeRequested;
                         auto variableGroupIdToCancel = varHandler->m_PendingVarRequest.m_VariableGroupId;
                         cancelVariableRequest(variableGroupIdToCancel);
                         // Cancel variable can make state downgrade
             std::shared_ptr<IDataSeries> VariableController::VariableControllerPrivate::retrieveDataSeries(
                 const QVector<AcquisitionDataPacket> acqDataPacketVector)
             {
-                qCDebug(LOG_VariableController()) << tr("TORM: retrieveDataSeries acqDataPacketVector size")
+                qCDebug(LOG_VariableController())
-                                                  << acqDataPacketVector.size();
+                    << tr("TORM: retrieveDataSeries acqDataPacketVector size") << acqDataPacketVector.size();
                 std::shared_ptr<IDataSeries> dataSeries;
                 if (!acqDataPacketVector.isEmpty()) {
                     dataSeries = acqDataPacketVector[0].m_DateSeries;
                 std::shared_ptr<IDataProvider> provider)
             {
                 if (m_ProviderSet.find(provider) == m_ProviderSet.end()) {
-                    qCDebug(LOG_VariableController()) << tr("Registering of a new provider")
+                    qCDebug(LOG_VariableController())
-                                                      << provider->objectName();
+                        << tr("Registering of a new provider") << provider->objectName();
                     m_ProviderSet.insert(provider);
                     connect(provider.get(), &IDataProvider::dataProvided, m_VariableAcquisitionWorker.get(),
                             &VariableAcquisitionWorker::onVariableDataAcquired);
                 // Element traité, on a déjà toutes les données necessaires
                 auto varGroupId = varHandler->m_RunningVarRequest.m_VariableGroupId;
-                qCDebug(LOG_VariableController()) << "Variable::acceptVariableRequest" << varGroupId
+                qCDebug(LOG_VariableController())
-                                                  << m_VarGroupIdToVarIds.size();
+                    << "Variable::acceptVariableRequest" << varGroupId << m_VarGroupIdToVarIds.size();
                 return varHandler->m_RunningVarRequest.m_VariableGroupId;
             }
                 auto &varIds = varGroupIdToVarIdsIt->second;
                 auto varIdsEnd = varIds.end();
                 bool processVariableUpdate = true;
-                qCDebug(LOG_VariableController()) << "VariableControllerPrivate::updateVariables"
+                qCDebug(LOG_VariableController())
-                                                  << varRequestId << varIds.size();
+                    << "VariableControllerPrivate::updateVariables" << varRequestId << varIds.size();
                 for (auto varIdsIt = varIds.begin(); (varIdsIt != varIdsEnd) && processVariableUpdate;
                      ++varIdsIt) {
                     auto itVarHandler = m_VarIdToVarRequestHandler.find(*varIdsIt);
                                 auto &varRequest = itVarHandler->second->m_RunningVarRequest;
                                 var->setRange(varRequest.m_RangeRequested);
                                 var->setCacheRange(varRequest.m_CacheRangeRequested);
-                                qCDebug(LOG_VariableController()) << tr("1: onDataProvided")
+                                qCDebug(LOG_VariableController())
-                                                                  << varRequest.m_RangeRequested
+                                    << tr("1: onDataProvided") << varRequest.m_RangeRequested
-                                                                  << varRequest.m_CacheRangeRequested;
+                                    << varRequest.m_CacheRangeRequested;
-                                qCDebug(LOG_VariableController()) << tr("2: onDataProvided var points before")
+                                qCDebug(LOG_VariableController())
-                                                                  << var->nbPoints()
+                                    << tr("2: onDataProvided var points before") << var->nbPoints()
-                                                                  << varRequest.m_DataSeries->nbPoints();
+                                    << varRequest.m_DataSeries->nbPoints();
                                 var->mergeDataSeries(varRequest.m_DataSeries);
-                                qCDebug(LOG_VariableController()) << tr("3: onDataProvided var points after")
+                                qCDebug(LOG_VariableController())
-                                                                  << var->nbPoints();
+                                    << tr("3: onDataProvided var points after") << var->nbPoints();
                                 emit var->updated();
                                 qCDebug(LOG_VariableController()) << tr("Update OK");

core/src/Visualization/VisualizationController.cpp +6 -6

             VisualizationController::VisualizationController(QObject *parent)
                     : impl{spimpl::make_unique_impl<VisualizationControllerPrivate>()}
             {
-                qCDebug(LOG_VisualizationController()) << tr("VisualizationController construction")
+                qCDebug(LOG_VisualizationController())
-                                                       << QThread::currentThread();
+                    << tr("VisualizationController construction") << QThread::currentThread();
             }
             VisualizationController::~VisualizationController()
             {
-                qCDebug(LOG_VisualizationController()) << tr("VisualizationController destruction")
+                qCDebug(LOG_VisualizationController())
-                                                       << QThread::currentThread();
+                    << tr("VisualizationController destruction") << QThread::currentThread();
                 this->waitForFinish();
             }
             void VisualizationController::initialize()
             {
-                qCDebug(LOG_VisualizationController()) << tr("VisualizationController init")
+                qCDebug(LOG_VisualizationController())
-                                                       << QThread::currentThread();
+                    << tr("VisualizationController init") << QThread::currentThread();
                 impl->m_WorkingMutex.lock();
                 qCDebug(LOG_VisualizationController()) << tr("VisualizationController init END");
             }

core/tests/Data/TestDataSeries.cpp +2 -2

                 QTest::newRow("scalarBounds4")
                     << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.}) << 5.1 << 6.
                     << false << nan << nan;
-                QTest::newRow("scalarBounds5") << createScalarSeries({1.}, {100.}) << 0. << 2. << true << 100.
+                QTest::newRow("scalarBounds5")
-                                               << 100.;
+                    << createScalarSeries({1.}, {100.}) << 0. << 2. << true << 100. << 100.;
                 QTest::newRow("scalarBounds6") << createScalarSeries({}, {}) << 0. << 2. << false << nan << nan;
                 // Tests with NaN values: NaN values are not included in min/max search

core/tests/Data/TestTwoDimArrayData.cpp +7 -8

                 QTest::addColumn<Container>("expectedData"); // expected array data (when success)
                 // Test cases
-                QTest::newRow("validInput") << flatten(Container{{1., 2., 3., 4., 5.},
+                QTest::newRow("validInput")
-                                                                 {6., 7., 8., 9., 10.},
+                    << flatten(
-                                                                 {11., 12., 13., 14., 15.}})
+                           Container{{1., 2., 3., 4., 5.}, {6., 7., 8., 9., 10.}, {11., 12., 13., 14., 15.}})
-                                            << true << Container{{1., 2., 3., 4., 5.},
+                    << true
-                                                                 {6., 7., 8., 9., 10.},
+                    << Container{{1., 2., 3., 4., 5.}, {6., 7., 8., 9., 10.}, {11., 12., 13., 14., 15.}};
-                                                                 {11., 12., 13., 14., 15.}};
+                QTest::newRow("invalidInput (invalid data size")
-                QTest::newRow("invalidInput (invalid data size") << InputData{{1., 2., 3., 4., 5., 6., 7.}, 3}
+                    << InputData{{1., 2., 3., 4., 5., 6., 7.}, 3} << false << Container{{}, {}, {}};
-                                                                 << false << Container{{}, {}, {}};
                 QTest::newRow("invalidInput (less than two components")
                     << flatten(Container{{1., 2., 3., 4., 5.}}) << false << Container{{}, {}, {}};
             }

core/tests/Variable/TestVariableSync.cpp +3 -3

                 // Go back to initial range
                 moveOp(initialRange, initialRange, 300);
-                QTest::newRow("syncOnVarCase1") << syncId << initialRange << std::move(creations)
+                QTest::newRow("syncOnVarCase1")
-                                                << std::move(iterations);
+                    << syncId << initialRange << std::move(creations) << std::move(iterations);
             }
+            } // namespace
             void TestVariableSync::testSync_data()
             {

gui/include/DataSource/DataSourceWidget.h +1 -1

             namespace Ui {
             class DataSourceWidget;
-            } // Ui
+            } // namespace Ui
             class DataSourceItem;

gui/include/Settings/SqpSettingsDialog.h +1 -1

             namespace Ui {
             class SqpSettingsDialog;
-            } // Ui
+            } // namespace Ui
             /**
              * @brief The SqpSettingsDialog class represents the dialog in which the parameters of SciQlop are

gui/include/Settings/SqpSettingsGeneralWidget.h +1 -1

             namespace Ui {
             class SqpSettingsGeneralWidget;
-            } // Ui
+            } // namespace Ui
             /**
              * @brief The SqpSettingsGeneralWidget class represents the general settings of SciQlop

gui/include/SidePane/SqpSidePane.h +1 -1

             namespace Ui {
             class SqpSidePane;
-            } // Ui
+            } // namespace Ui
             class QToolBar;

gui/include/TimeWidget/TimeWidget.h +1 -1

             namespace Ui {
             class TimeWidget;
-            } // Ui
+            } // namespace Ui
             class TimeWidget : public QWidget {
                 Q_OBJECT

gui/include/Variable/RenameVariableDialog.h +1 -1

             namespace Ui {
             class RenameVariableDialog;
-            } // Ui
+            } // namespace Ui
             /**
              * @brief The RenameVariableDialog class represents the dialog to rename a variable

gui/include/Variable/VariableInspectorWidget.h +1 -1

             namespace Ui {
             class VariableInspectorWidget;
-            } // Ui
+            } // namespace Ui
             /**
              * @brief The VariableInspectorWidget class representes represents the variable inspector, from

gui/include/Variable/VariableMenuHeaderWidget.h +1 -1

             namespace Ui {
             class VariableMenuHeaderWidget;
-            } // Ui
+            } // namespace Ui
             class Variable;

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

                 bool mGradientImageInvalidated;
                 // re-using some methods of QCPAxisRect to make them available to friend class QCPColorScale
                 using QCPAxisRect::calculateAutoMargin;
-                using QCPAxisRect::mousePressEvent;
                 using QCPAxisRect::mouseMoveEvent;
+                using QCPAxisRect::mousePressEvent;
                 using QCPAxisRect::mouseReleaseEvent;
-                using QCPAxisRect::wheelEvent;
                 using QCPAxisRect::update;
+                using QCPAxisRect::wheelEvent;
                 virtual void draw(QCPPainter *painter) Q_DECL_OVERRIDE;
                 void updateGradientImage();
                 Q_SLOT void axisSelectionChanged(QCPAxis::SelectableParts selectedParts);

gui/src/DragDropHelper.cpp +1 -3

             };
-            DragDropHelper::DragDropHelper() : impl{spimpl::make_unique_impl<DragDropHelperPrivate>()}
+            DragDropHelper::DragDropHelper() : impl{spimpl::make_unique_impl<DragDropHelperPrivate>()} {}
             DragDropHelper::~DragDropHelper()
             {

gui/src/SqpApplication.cpp +2 -6

                 impl->m_VisualizationControllerThread.start();
             }
-            SqpApplication::~SqpApplication()
+            SqpApplication::~SqpApplication() {}
-            void SqpApplication::initialize()
+            void SqpApplication::initialize() {}
             DataSourceController &SqpApplication::dataSourceController() noexcept
             {

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

                         &VisualizationGraphWidget::onMouseRelease);
                 connect(ui->widget, &QCustomPlot::mouseMove, this, &VisualizationGraphWidget::onMouseMove);
                 connect(ui->widget, &QCustomPlot::mouseWheel, this, &VisualizationGraphWidget::onMouseWheel);
-                connect(ui->widget->xAxis, static_cast<void (QCPAxis::*)(const QCPRange &, const QCPRange &)>(
+                connect(
-                                               &QCPAxis::rangeChanged),
+                    ui->widget->xAxis,
-                        this, &VisualizationGraphWidget::onRangeChanged, Qt::DirectConnection);
+                    static_cast<void (QCPAxis::*)(const QCPRange &, const QCPRange &)>(&QCPAxis::rangeChanged),
+                    this, &VisualizationGraphWidget::onRangeChanged, Qt::DirectConnection);
                 // Activates menu when right clicking on the graph
                 ui->widget->setContextMenuPolicy(Qt::CustomContextMenu);
             void VisualizationGraphWidget::onRangeChanged(const QCPRange &t1, const QCPRange &t2)
             {
-                qCDebug(LOG_VisualizationGraphWidget()) << tr("TORM: VisualizationGraphWidget::onRangeChanged")
+                qCDebug(LOG_VisualizationGraphWidget())
-                                                        << QThread::currentThread()->objectName() << "DoAcqui"
+                    << tr("TORM: VisualizationGraphWidget::onRangeChanged")
-                                                        << impl->m_DoAcquisition;
+                    << QThread::currentThread()->objectName() << "DoAcqui" << impl->m_DoAcquisition;
                 auto graphRange = SqpRange{t1.lower, t1.upper};
                 auto oldGraphRange = SqpRange{t2.lower, t2.upper};

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

                                     graphChildRange.m_TStart += deltaLeft;
                                     graphChildRange.m_TEnd -= deltaRight;
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: ZoomIn");
-                                    qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaLeft")
+                                    qCDebug(LOG_VisualizationZoneWidget())
-                                                                           << deltaLeft;
+                                        << tr("TORM: deltaLeft") << deltaLeft;
-                                    qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaRight")
+                                    qCDebug(LOG_VisualizationZoneWidget())
-                                                                           << deltaRight;
+                                        << tr("TORM: deltaRight") << deltaRight;
                                     qCDebug(LOG_VisualizationZoneWidget())
                                         << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: ZoomOut");
                                     auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
                                     auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
-                                    qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaLeft")
+                                    qCDebug(LOG_VisualizationZoneWidget())
-                                                                           << deltaLeft;
+                                        << tr("TORM: deltaLeft") << deltaLeft;
-                                    qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaRight")
+                                    qCDebug(LOG_VisualizationZoneWidget())
-                                                                           << deltaRight;
+                                        << tr("TORM: deltaRight") << deltaRight;
                                     qCDebug(LOG_VisualizationZoneWidget())
                                         << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
                                     graphChildRange.m_TStart -= deltaLeft;
                                     break;
                             }
                             graphChild->enableAcquisition(false);
-                            qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: Range before: ")
+                            qCDebug(LOG_VisualizationZoneWidget())
-                                                                   << graphChild->graphRange();
+                                << tr("TORM: Range before: ") << graphChild->graphRange();
-                            qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: Range after : ")
+                            qCDebug(LOG_VisualizationZoneWidget())
-                                                                   << graphChildRange;
+                                << tr("TORM: Range after : ") << graphChildRange;
                             qCDebug(LOG_VisualizationZoneWidget())
                                 << tr("TORM: child dt") << graphChildRange.m_TEnd - graphChildRange.m_TStart;
                             graphChild->setGraphRange(graphChildRange);

gui/src/Visualization/qcustomplot.cpp +86 -167

             /*!
               Creates a QCPVector2D object and initializes the x and y coordinates to 0.
             */
-            QCPVector2D::QCPVector2D() : mX(0), mY(0)
+            QCPVector2D::QCPVector2D() : mX(0), mY(0) {}
             /*!
               Creates a QCPVector2D object and initializes the \a x and \a y coordinates with the specified
               values.
             */
-            QCPVector2D::QCPVector2D(double x, double y) : mX(x), mY(y)
+            QCPVector2D::QCPVector2D(double x, double y) : mX(x), mY(y) {}
             /*!
               Creates a QCPVector2D object and initializes the x and y coordinates respective coordinates of
               the specified \a point.
             */
-            QCPVector2D::QCPVector2D(const QPoint &point) : mX(point.x()), mY(point.y())
+            QCPVector2D::QCPVector2D(const QPoint &point) : mX(point.x()), mY(point.y()) {}
             /*!
               Creates a QCPVector2D object and initializes the x and y coordinates respective coordinates of
               the specified \a point.
             */
-            QCPVector2D::QCPVector2D(const QPointF &point) : mX(point.x()), mY(point.y())
+            QCPVector2D::QCPVector2D(const QPointF &point) : mX(point.x()), mY(point.y()) {}
             /*!
               Normalizes this vector. After this operation, the length of the vector is equal to 1.
             {
             }
-            QCPAbstractPaintBuffer::~QCPAbstractPaintBuffer()
+            QCPAbstractPaintBuffer::~QCPAbstractPaintBuffer() {}
             /*!
               Sets the paint buffer size.
                 QCPPaintBufferPixmap::reallocateBuffer();
             }
-            QCPPaintBufferPixmap::~QCPPaintBufferPixmap()
+            QCPPaintBufferPixmap::~QCPPaintBufferPixmap() {}
             /* inherits documentation from base class */
             QCPPainter *QCPPaintBufferPixmap::startPainting()
                     mChildren.last()->setLayer(0); // removes itself from mChildren via removeChild()
                 if (mParentPlot->currentLayer() == this)
-                    qDebug() << Q_FUNC_INFO << "The parent plot's mCurrentLayer will be a dangling pointer. "
+                    qDebug() << Q_FUNC_INFO
-                                               "Should have been set to a valid layer or 0 beforehand.";
+                             << "The parent plot's mCurrentLayer will be a dangling pointer. "
+                                "Should have been set to a valid layer or 0 beforehand.";
             }
             /*!
               \see initializeParentPlot
             */
-            void QCPLayerable::parentPlotInitialized(QCustomPlot *parentPlot)
+            void QCPLayerable::parentPlotInitialized(QCustomPlot *parentPlot){Q_UNUSED(parentPlot)}
-                Q_UNUSED(parentPlot)
             /*! \internal
             /*!
               Constructs a range with \a lower and \a upper set to zero.
             */
-            QCPRange::QCPRange() : lower(0), upper(0)
+            QCPRange::QCPRange() : lower(0), upper(0) {}
             /*! \overload
             /*!
               Creates an empty QCPDataRange, with begin and end set to 0.
             */
-            QCPDataRange::QCPDataRange() : mBegin(0), mEnd(0)
+            QCPDataRange::QCPDataRange() : mBegin(0), mEnd(0) {}
             /*!
               Creates a QCPDataRange, initialized with the specified \a begin and \a end.
               No checks or corrections are made to ensure the resulting range is valid (\ref isValid).
             */
-            QCPDataRange::QCPDataRange(int begin, int end) : mBegin(begin), mEnd(end)
+            QCPDataRange::QCPDataRange(int begin, int end) : mBegin(begin), mEnd(end) {}
             /*!
               Returns a data range that matches this data range, except that parts exceeding \a other are
             /*!
               Creates an empty QCPDataSelection.
             */
-            QCPDataSelection::QCPDataSelection()
+            QCPDataSelection::QCPDataSelection() {}
             /*!
               Creates a QCPDataSelection containing the provided \a range.
               The default implementation does nothing.
             */
-            void QCPLayoutElement::layoutChanged()
+            void QCPLayoutElement::layoutChanged() {}
             ////////////////////////////////////////////////////////////////////////////////////////////////////
             //////////////////// QCPLayout
               Creates an instance of QCPLayout and sets default values. Note that since QCPLayout
               is an abstract base class, it can't be instantiated directly.
             */
-            QCPLayout::QCPLayout()
+            QCPLayout::QCPLayout() {}
             /*!
               If \a phase is \ref upLayout, calls \ref updateLayout, which subclasses may reimplement to
               Not all layouts need simplification. For example, QCPLayoutInset doesn't use explicit
               simplification while QCPLayoutGrid does.
             */
-            void QCPLayout::simplify()
+            void QCPLayout::simplify() {}
             /*!
               Removes and deletes the element at the provided \a index. Returns true on success. If \a index is
               \see update
             */
-            void QCPLayout::updateLayout()
+            void QCPLayout::updateLayout() {}
             /*! \internal
             /*!
               Creates an instance of QCPLayoutInset and sets default values.
             */
-            QCPLayoutInset::QCPLayoutInset()
+            QCPLayoutInset::QCPLayoutInset() {}
             QCPLayoutInset::~QCPLayoutInset()
             {
             /*!
               Creates a QCPLineEnding instance with default values (style \ref esNone).
             */
-            QCPLineEnding::QCPLineEnding() : mStyle(esNone), mWidth(8), mLength(10), mInverted(false)
+            QCPLineEnding::QCPLineEnding() : mStyle(esNone), mWidth(8), mLength(10), mInverted(false) {}
             /*!
               Creates a QCPLineEnding instance with the specified values.
               Constructs the ticker and sets reasonable default values. Axis tickers are commonly created
               managed by a QSharedPointer, which then can be passed to QCPAxis::setTicker.
             */
-            QCPAxisTicker::QCPAxisTicker() : mTickStepStrategy(tssReadability), mTickCount(5), mTickOrigin(0)
+            QCPAxisTicker::QCPAxisTicker() : mTickStepStrategy(tssReadability), mTickCount(5), mTickOrigin(0) {}
-            QCPAxisTicker::~QCPAxisTicker()
+            QCPAxisTicker::~QCPAxisTicker() {}
             /*!
               Sets which strategy the axis ticker follows when choosing the size of the tick step. For the
               Constructs the ticker and sets reasonable default values. Axis tickers are commonly created
               managed by a QSharedPointer, which then can be passed to QCPAxis::setTicker.
             */
-            QCPAxisTickerFixed::QCPAxisTickerFixed() : mTickStep(1.0), mScaleStrategy(ssNone)
+            QCPAxisTickerFixed::QCPAxisTickerFixed() : mTickStep(1.0), mScaleStrategy(ssNone) {}
             /*!
               Sets the fixed tick interval to \a step.
               Constructs the ticker and sets reasonable default values. Axis tickers are commonly created
               managed by a QSharedPointer, which then can be passed to QCPAxis::setTicker.
             */
-            QCPAxisTickerText::QCPAxisTickerText() : mSubTickCount(0)
+            QCPAxisTickerText::QCPAxisTickerText() : mSubTickCount(0) {}
             /*! \overload
                             mRange = newRange.sanitizedForLogScale();
                     }
                     else
-                        qDebug() << Q_FUNC_INFO << "Center of scaling operation doesn't lie in same "
+                        qDebug() << Q_FUNC_INFO
-                                                   "logarithmic sign domain as range:"
+                                 << "Center of scaling operation doesn't lie in same "
+                                    "logarithmic sign domain as range:"
                                  << center;
                 }
                 emit rangeChanged(mRange);
             {
             }
-            QCPAxisPainterPrivate::~QCPAxisPainterPrivate()
+            QCPAxisPainterPrivate::~QCPAxisPainterPrivate() {}
             /*! \internal
                 painter->setBrush(QBrush(basePen.color()));
                 QCPVector2D baseLineVector(baseLine.dx(), baseLine.dy());
                 if (lowerEnding.style() != QCPLineEnding::esNone)
-                    lowerEnding.draw(painter, QCPVector2D(baseLine.p1())
+                    lowerEnding.draw(painter,
-                                                  - baseLineVector.normalized() * lowerEnding.realLength()
+                                     QCPVector2D(baseLine.p1())
-                                                        * (lowerEnding.inverted() ? -1 : 1),
+                                         - baseLineVector.normalized() * lowerEnding.realLength()
+                                               * (lowerEnding.inverted() ? -1 : 1),
                                      -baseLineVector);
                 if (upperEnding.style() != QCPLineEnding::esNone)
-                    upperEnding.draw(painter, QCPVector2D(baseLine.p2())
+                    upperEnding.draw(painter,
-                                                  + baseLineVector.normalized() * upperEnding.realLength()
+                                     QCPVector2D(baseLine.p2())
-                                                        * (upperEnding.inverted() ? -1 : 1),
+                                         + baseLineVector.normalized() * upperEnding.realLength()
+                                               * (upperEnding.inverted() ? -1 : 1),
                                      baseLineVector);
                 painter->setAntialiasing(antialiasingBackup);
                     bool labelClippedByBorder = false;
                     if (tickLabelSide == QCPAxis::lsOutside) {
                         if (QCPAxis::orientation(type) == Qt::Horizontal)
-                            labelClippedByBorder = finalPosition.x() + (labelData.rotatedTotalBounds.width()
+                            labelClippedByBorder = finalPosition.x()
-                                                                        + labelData.rotatedTotalBounds.left())
+                                                           + (labelData.rotatedTotalBounds.width()
+                                                              + labelData.rotatedTotalBounds.left())
                                                        > viewportRect.right()
                                                    || finalPosition.x() + labelData.rotatedTotalBounds.left()
                                                           < viewportRect.left();
                         else
-                            labelClippedByBorder = finalPosition.y() + (labelData.rotatedTotalBounds.height()
+                            labelClippedByBorder = finalPosition.y()
-                                                                        + labelData.rotatedTotalBounds.top())
+                                                           + (labelData.rotatedTotalBounds.height()
+                                                              + labelData.rotatedTotalBounds.top())
                                                        > viewportRect.bottom()
                                                    || finalPosition.y() + labelData.rotatedTotalBounds.top()
                                                           < viewportRect.top();
             {
             }
-            QCPSelectionDecorator::~QCPSelectionDecorator()
+            QCPSelectionDecorator::~QCPSelectionDecorator() {}
             /*!
               Sets the pen that will be used by the parent plottable to draw selected data segments.
             */
             QPointF QCPAbstractItem::anchorPixelPosition(int anchorId) const
             {
-                qDebug() << Q_FUNC_INFO << "called on item which shouldn't have any anchors (this method not "
+                qDebug() << Q_FUNC_INFO
-                                           "reimplemented). anchorId"
+                         << "called on item which shouldn't have any anchors (this method not "
+                            "reimplemented). anchorId"
                          << anchorId;
                 return QPointF();
             }
                 setupPaintBuffers();
             #else
                 Q_UNUSED(enabled)
-                qDebug() << Q_FUNC_INFO << "QCustomPlot can't use OpenGL because QCUSTOMPLOT_USE_OPENGL was "
+                qDebug() << Q_FUNC_INFO
-                                           "not defined during compilation (add 'DEFINES += "
+                         << "QCustomPlot can't use OpenGL because QCUSTOMPLOT_USE_OPENGL was "
-                                           "QCUSTOMPLOT_USE_OPENGL' to your qmake .pro file)";
+                            "not defined during compilation (add 'DEFINES += "
+                            "QCUSTOMPLOT_USE_OPENGL' to your qmake .pro file)";
             #endif
             }
                 if (!valueAxis)
                     valueAxis = yAxis;
                 if (!keyAxis || !valueAxis) {
-                    qDebug() << Q_FUNC_INFO << "can't use default QCustomPlot xAxis or yAxis, because at least "
+                    qDebug() << Q_FUNC_INFO
-                                               "one is invalid (has been deleted)";
+                             << "can't use default QCustomPlot xAxis or yAxis, because at least "
+                                "one is invalid (has been deleted)";
                     return 0;
                 }
                 if (keyAxis->parentPlot() != this || valueAxis->parentPlot() != this) {
                     return new QCPPaintBufferGlPbuffer(viewport().size(), mBufferDevicePixelRatio,
                                                        mOpenGlMultisamples);
             #else
-                    qDebug() << Q_FUNC_INFO << "OpenGL enabled even though no support for it compiled in, this "
+                    qDebug() << Q_FUNC_INFO
-                                               "shouldn't have happened. Falling back to pixmap paint buffer.";
+                             << "OpenGL enabled even though no support for it compiled in, this "
+                                "shouldn't have happened. Falling back to pixmap paint buffer.";
                     return new QCPPaintBufferPixmap(viewport().size(), mBufferDevicePixelRatio);
             #endif
                 }
                                         hue -= 1.0;
                                     if (useAlpha) {
                                         const QRgb rgb
-                                            = QColor::fromHsvF(hue, (1 - t) * lowHsv.saturationF()
+                                            = QColor::fromHsvF(hue,
-                                                                        + t * highHsv.saturationF(),
+                                                               (1 - t) * lowHsv.saturationF()
+                                                                   + t * highHsv.saturationF(),
                                                                (1 - t) * lowHsv.valueF() + t * highHsv.valueF())
                                                   .rgb();
                                         const float alpha = (1 - t) * lowHsv.alphaF() + t * highHsv.alphaF();
                                     }
                                     else {
                                         mColorBuffer[i]
-                                            = QColor::fromHsvF(hue, (1 - t) * lowHsv.saturationF()
+                                            = QColor::fromHsvF(hue,
-                                                                        + t * highHsv.saturationF(),
+                                                               (1 - t) * lowHsv.saturationF()
+                                                                   + t * highHsv.saturationF(),
                                                                (1 - t) * lowHsv.valueF() + t * highHsv.valueF())
                                                   .rgb();
                                     }
             {
             }
-            QCPSelectionDecoratorBracket::~QCPSelectionDecoratorBracket()
+            QCPSelectionDecoratorBracket::~QCPSelectionDecoratorBracket() {}
             /*!
               Sets the pen that will be used to draw the brackets at the beginning and end of each selected
             }
             /*! \overload
-            */
+             */
             void QCPLegend::setIconSize(int width, int height)
             {
                 mIconSize.setWidth(width);
             /*!
               Constructs a data point with key and value set to zero.
             */
-            QCPGraphData::QCPGraphData() : key(0), value(0)
+            QCPGraphData::QCPGraphData() : key(0), value(0) {}
             /*!
               Constructs a data point with the specified \a key and \a value.
             */
-            QCPGraphData::QCPGraphData(double key, double value) : key(key), value(value)
+            QCPGraphData::QCPGraphData(double key, double value) : key(key), value(value) {}
             ////////////////////////////////////////////////////////////////////////////////////////////////////
                 setAdaptiveSampling(true);
             }
-            QCPGraph::~QCPGraph()
+            QCPGraph::~QCPGraph() {}
             /*! \overload
             /*!
               Constructs a curve data point with t, key and value set to zero.
             */
-            QCPCurveData::QCPCurveData() : t(0), key(0), value(0)
+            QCPCurveData::QCPCurveData() : t(0), key(0), value(0) {}
             /*!
               Constructs a curve data point with the specified \a t, \a key and \a value.
             */
-            QCPCurveData::QCPCurveData(double t, double key, double value) : t(t), key(key), value(value)
+            QCPCurveData::QCPCurveData(double t, double key, double value) : t(t), key(key), value(value) {}
             ////////////////////////////////////////////////////////////////////////////////////////////////////
                 setScatterSkip(0);
             }
-            QCPCurve::~QCPCurve()
+            QCPCurve::~QCPCurve() {}
             /*! \overload
             /*!
               Constructs a bar data point with key and value set to zero.
             */
-            QCPBarsData::QCPBarsData() : key(0), value(0)
+            QCPBarsData::QCPBarsData() : key(0), value(0) {}
             /*!
               Constructs a bar data point with the specified \a key and \a value.
             */
-            QCPBarsData::QCPBarsData(double key, double value) : key(key), value(value)
+            QCPBarsData::QCPBarsData(double key, double value) : key(key), value(value) {}
             ////////////////////////////////////////////////////////////////////////////////////////////////////
             /*!
               Constructs a data point with key and all values set to zero.
             */
-            QCPFinancialData::QCPFinancialData() : key(0), open(0), high(0), low(0), close(0)
+            QCPFinancialData::QCPFinancialData() : key(0), open(0), high(0), low(0), close(0) {}
             /*!
               Constructs a data point with the specified \a key and OHLC values.
                 mSelectionDecorator->setBrush(QBrush(QColor(160, 160, 255)));
             }
-            QCPFinancial::~QCPFinancial()
+            QCPFinancial::~QCPFinancial() {}
             /*! \overload
             /*!
               Constructs an error bar with errors set to zero.
             */
-            QCPErrorBarsData::QCPErrorBarsData() : errorMinus(0), errorPlus(0)
+            QCPErrorBarsData::QCPErrorBarsData() : errorMinus(0), errorPlus(0) {}
             /*!
               Constructs an error bar with equal \a error in both negative and positive direction.
             */
-            QCPErrorBarsData::QCPErrorBarsData(double error) : errorMinus(error), errorPlus(error)
+            QCPErrorBarsData::QCPErrorBarsData(double error) : errorMinus(error), errorPlus(error) {}
             /*!
               Constructs an error bar with negative and positive errors set to \a errorMinus and \a errorPlus,
                 setBrush(Qt::NoBrush);
             }
-            QCPErrorBars::~QCPErrorBars()
+            QCPErrorBars::~QCPErrorBars() {}
             /*! \overload
                 setSelectedPen(QPen(Qt::blue, 2));
             }
-            QCPItemStraightLine::~QCPItemStraightLine()
+            QCPItemStraightLine::~QCPItemStraightLine() {}
             /*!
               Sets the pen that will be used to draw the line
                 setSelectedPen(QPen(Qt::blue, 2));
             }
-            QCPItemLine::~QCPItemLine()
+            QCPItemLine::~QCPItemLine() {}
             /*!
               Sets the pen that will be used to draw the line
                 setSelectedPen(QPen(Qt::blue, 2));
             }
-            QCPItemCurve::~QCPItemCurve()
+            QCPItemCurve::~QCPItemCurve() {}
             /*!
               Sets the pen that will be used to draw the line
                 setSelectedBrush(Qt::NoBrush);
             }
-            QCPItemRect::~QCPItemRect()
+            QCPItemRect::~QCPItemRect() {}
             /*!
               Sets the pen that will be used to draw the line of the rectangle
                 setSelectedColor(Qt::blue);
             }
-            QCPItemText::~QCPItemText()
+            QCPItemText::~QCPItemText() {}
             /*!
               Sets the color of the text.
                 setSelectedBrush(Qt::NoBrush);
             }
-            QCPItemEllipse::~QCPItemEllipse()
+            QCPItemEllipse::~QCPItemEllipse() {}
             /*!
               Sets the pen that will be used to draw the line of the ellipse
                 setSelectedPen(QPen(Qt::blue));
             }
-            QCPItemPixmap::~QCPItemPixmap()
+            QCPItemPixmap::~QCPItemPixmap() {}
             /*!
               Sets the pixmap that will be displayed.
                 setSelectedPen(QPen(Qt::blue, 2));
             }
-            QCPItemTracer::~QCPItemTracer()
+            QCPItemTracer::~QCPItemTracer() {}
             /*!
               Sets the pen that will be used to draw the line of the tracer
                 setSelectedPen(QPen(Qt::blue, 2));
             }
-            QCPItemBracket::~QCPItemBracket()
+            QCPItemBracket::~QCPItemBracket() {}
             /*!
               Sets the pen that will be used to draw the bracket.

plugins/amda/src/AmdaProvider.cpp +5 -4

                 qCDebug(LOG_AmdaProvider()) << tr("AmdaProvider::AmdaProvider") << QThread::currentThread();
                 if (auto app = sqpApp) {
                     auto &networkController = app->networkController();
-                    connect(this, SIGNAL(requestConstructed(std::shared_ptr<QNetworkRequest>, QUuid,
+                    connect(this,
-                                                            std::function<void(QNetworkReply *, QUuid)>)),
+                            SIGNAL(requestConstructed(std::shared_ptr<QNetworkRequest>, QUuid,
+                                                      std::function<void(QNetworkReply *, QUuid)>)),
                             &networkController,
                             SLOT(onProcessRequested(std::shared_ptr<QNetworkRequest>, QUuid,
                                                     std::function<void(QNetworkReply *, QUuid)>)));
                 const auto times = parameters.m_Times;
                 const auto data = parameters.m_Data;
                 for (const auto &dateTime : qAsConst(times)) {
-                    qCDebug(LOG_AmdaProvider()) << tr("TORM AmdaProvider::requestDataLoading ") << acqIdentifier
+                    qCDebug(LOG_AmdaProvider())
-                                                << dateTime;
+                        << tr("TORM AmdaProvider::requestDataLoading ") << acqIdentifier << dateTime;
                     this->retrieveData(acqIdentifier, dateTime, data);

plugins/amda/tests/TestAmdaAcquisition.cpp +2 -2

                     return false;
                 }
             }
+            } // namespace
             class TestAmdaAcquisition : public QObject {
                 Q_OBJECT
                 return QTest::qExec(&tc, argc, argv);
             }
-            // QTEST_MAIN(TestAmdaAcquisition)
+                // QTEST_MAIN(TestAmdaAcquisition)
             #include "TestAmdaAcquisition.moc"

plugins/amda/tests/TestAmdaParser.cpp +8 -8

                 QTest::newRow("Valid file") << QStringLiteral("ValidFile1.json") << validResults1();
                 // Invalid files
-                QTest::newRow("Invalid file (unexisting file)") << QStringLiteral("UnexistingFile.json")
+                QTest::newRow("Invalid file (unexisting file)")
-                                                                << invalidResults();
+                    << QStringLiteral("UnexistingFile.json") << invalidResults();
-                QTest::newRow("Invalid file (two root objects)") << QStringLiteral("TwoRootsFile.json")
+                QTest::newRow("Invalid file (two root objects)")
-                                                                 << invalidResults();
+                    << QStringLiteral("TwoRootsFile.json") << invalidResults();
-                QTest::newRow("Invalid file (wrong root key)") << QStringLiteral("WrongRootKey.json")
+                QTest::newRow("Invalid file (wrong root key)")
-                                                               << invalidResults();
+                    << QStringLiteral("WrongRootKey.json") << invalidResults();
-                QTest::newRow("Invalid file (wrong root type)") << QStringLiteral("WrongRootType.json")
+                QTest::newRow("Invalid file (wrong root type)")
-                                                                << invalidResults();
+                    << QStringLiteral("WrongRootType.json") << invalidResults();
             }
             void TestAmdaParser::testReadJson()

plugins/amda/tests/TestAmdaResultParser.cpp +4 -4

                                                      QVector<QDateTime>{}, QVector<double>{}};
                 // Invalid files
-                QTest::newRow("Invalid file (unexisting file)") << QStringLiteral("UnexistingFile.txt")
+                QTest::newRow("Invalid file (unexisting file)")
-                                                                << ExpectedResults<ScalarSeries>{};
+                    << QStringLiteral("UnexistingFile.txt") << ExpectedResults<ScalarSeries>{};
-                QTest::newRow("Invalid file (file not found on server)") << QStringLiteral("FileNotFound.txt")
+                QTest::newRow("Invalid file (file not found on server)")
-                                                                         << ExpectedResults<ScalarSeries>{};
+                    << QStringLiteral("FileNotFound.txt") << ExpectedResults<ScalarSeries>{};
             }
             void TestAmdaResultParser::testReadScalarTxt()

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

                             progress = currentProgress;
                             emit dataProvidedProgress(acqIdentifier, progress);
-                            qCDebug(LOG_CosinusProvider()) << "TORM: CosinusProvider::retrieveData"
+                            qCDebug(LOG_CosinusProvider())
-                                                           << QThread::currentThread()->objectName()
+                                << "TORM: CosinusProvider::retrieveData"
-                                                           << progress;
+                                << QThread::currentThread()->objectName() << progress;
                             // NOTE: Try to use multithread if possible
                         }
                     }
             {
                 // TODO: Add Mutex
                 m_VariableToEnableProvider[acqIdentifier] = true;
-                qCDebug(LOG_CosinusProvider()) << "TORM: CosinusProvider::requestDataLoading"
+                qCDebug(LOG_CosinusProvider())
-                                               << QThread::currentThread()->objectName();
+                    << "TORM: CosinusProvider::requestDataLoading" << QThread::currentThread()->objectName();
                 // NOTE: Try to use multithread if possible
                 const auto times = parameters.m_Times;

plugins/mockplugin/tests/TestCosinusAcquisition.cpp +3 -3

             namespace {
             /// Path for the tests
-            const auto TESTS_RESOURCES_PATH = QFileInfo{
+            const auto TESTS_RESOURCES_PATH
-                QString{MOCKPLUGIN_TESTS_RESOURCES_DIR},
+                = QFileInfo{QString{MOCKPLUGIN_TESTS_RESOURCES_DIR}, "TestCosinusAcquisition"}
-                "TestCosinusAcquisition"}.absoluteFilePath();
+                      .absoluteFilePath();
             /// Format of dates in data files
             const auto DATETIME_FORMAT = QStringLiteral("yyyy/MM/dd hh:mm:ss:zzz");

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