GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r960:72dc8e8c83d1

temp commit

Alexandre Leroux -

r960:72dc8e8c83d1

parent child

Context file:

r960:72dc8e8c83d1

Collapse all files

core/include/Common/spimpl.h +14 -12

             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<C, default_copier_t<T> >::value> {
+                                                std::is_same<D, default_deleter_t<T> >::value
+                                                    && std::is_same<C, default_copier_t<T> >::value> {
             };
             }
                 }
                 template <class U>
-                impl_ptr(U *u, typename std::enable_if<std::is_convertible<U *, pointer>::value
+                impl_ptr(U *u,
-                                                           && is_default_manageable::value,
+                         typename std::enable_if<std::is_convertible<U *, pointer>::value
-                                                       dummy_t_>::type
+                                                     && is_default_manageable::value,
-                               = dummy_t_()) SPIMPL_NOEXCEPT
+                                                 dummy_t_>::type
+                         = dummy_t_()) SPIMPL_NOEXCEPT
                     : impl_ptr(u, &details::default_delete<T>, &details::default_copy<T>)
                 {
                 }
             #ifdef SPIMPL_HAS_AUTO_PTR
                 template <class U>
-                impl_ptr(std::auto_ptr<U> &&u, typename std::enable_if<std::is_convertible<U *, pointer>::value
+                impl_ptr(std::auto_ptr<U> &&u,
-                                                                           && is_default_manageable::value,
+                         typename std::enable_if<std::is_convertible<U *, pointer>::value
-                                                                       dummy_t_>::type
+                                                     && is_default_manageable::value,
-                                               = dummy_t_()) SPIMPL_NOEXCEPT
+                                                 dummy_t_>::type
-                    : ptr_(u.release(), &details::default_delete<T>),
+                         = dummy_t_()) SPIMPL_NOEXCEPT : ptr_(u.release(), &details::default_delete<T>),
-                      copier_(&details::default_copy<T>)
+                                                         copier_(&details::default_copy<T>)
                 {
                 }
             #endif

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/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 +43 -43

             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/TestOptionalAxis.cpp +4 -4

                 QTest::newRow("data1") << axis({}) << 0;
                 QTest::newRow("data2") << axis({1, 2, 3}) << 3;
                 QTest::newRow("data3") << axis({1, 2, 3, 4}) << 4;
-                QTest::newRow("data4 (axis not defined)") << OptionalAxis{}
+                QTest::newRow("data4 (axis not defined)")
-                                                          << 0; // Expects 0 for undefined axis
+                    << OptionalAxis{} << 0; // Expects 0 for undefined axis
             }
             void TestOptionalAxis::testSize()
                 QTest::newRow("data1") << axis(Unit{"Hz"}) << Unit{"Hz"};
                 QTest::newRow("data2") << axis(Unit{"t", true}) << Unit{"t", true};
-                QTest::newRow("data3 (axis not defined)") << OptionalAxis{}
+                QTest::newRow("data3 (axis not defined)")
-                                                          << Unit{}; // Expects default unit for undefined axis
+                    << OptionalAxis{} << Unit{}; // Expects default unit for undefined axis
             }
             void TestOptionalAxis::testUnit()

core/tests/Data/TestScalarSeries.cpp +28 -28

             {
                 testMergeDifferentTypes_struct<VectorSeries, ScalarSeries>();
-                QTest::newRow("mergeVectorInScalar") << ScalarBuilder{}
+                QTest::newRow("mergeVectorInScalar")
-                                                            .setX({1., 2., 3., 4., 5.})
+                    << ScalarBuilder{}
-                                                            .setValues({100., 200., 300., 400., 500.})
+                           .setX({1., 2., 3., 4., 5.})
-                                                            .build()
+                           .setValues({100., 200., 300., 400., 500.})
-                                                     << VectorBuilder{}
+                           .build()
-                                                            .setX({6., 7., 8., 9., 10.})
+                    << VectorBuilder{}
-                                                            .setXValues({600., 700., 800., 900., 1000.})
+                           .setX({6., 7., 8., 9., 10.})
-                                                            .setYValues({610., 710., 810., 910., 1010.})
+                           .setXValues({600., 700., 800., 900., 1000.})
-                                                            .setZValues({620., 720., 820., 920., 1020.})
+                           .setYValues({610., 710., 810., 910., 1010.})
-                                                            .build()
+                           .setZValues({620., 720., 820., 920., 1020.})
-                                                     << DataContainer{1., 2., 3., 4., 5.}
+                           .build()
-                                                     << DataContainer{100., 200., 300., 400., 500.};
+                    << DataContainer{1., 2., 3., 4., 5.} << DataContainer{100., 200., 300., 400., 500.};
             }
             void TestScalarSeries::testMergeWithVector()
                                                     .build()
                                              << 2. << 4. << DataContainer{2., 3., 4.}
                                              << std::vector<DataContainer>{{200., 300., 400.}};
-                QTest::newRow("purgeScalar1 (min/max swap)") << ScalarBuilder{}
+                QTest::newRow("purgeScalar1 (min/max swap)")
-                                                                    .setX({1., 2., 3., 4., 5.})
+                    << ScalarBuilder{}
-                                                                    .setValues({100., 200., 300., 400., 500.})
+                           .setX({1., 2., 3., 4., 5.})
-                                                                    .build()
+                           .setValues({100., 200., 300., 400., 500.})
-                                                             << 4. << 2. << DataContainer{2., 3., 4.}
+                           .build()
-                                                             << std::vector<DataContainer>{{200., 300., 400.}};
+                    << 4. << 2. << DataContainer{2., 3., 4.} << std::vector<DataContainer>{{200., 300., 400.}};
                 QTest::newRow("purgeScalar2") << ScalarBuilder{}
                                                      .setX({1., 2., 3., 4., 5.})
                                                      .setValues({100., 200., 300., 400., 500.})
                                                    .build()
                                             << -1. << 3.2 << DataContainer{1., 2., 3.}
                                             << DataContainer{100., 200., 300.};
-                QTest::newRow("xAxisRange1 (min/max swap)") << ScalarBuilder{}
+                QTest::newRow("xAxisRange1 (min/max swap)")
-                                                                   .setX({1., 2., 3., 4., 5.})
+                    << ScalarBuilder{}
-                                                                   .setValues({100., 200., 300., 400., 500.})
+                           .setX({1., 2., 3., 4., 5.})
-                                                                   .build()
+                           .setValues({100., 200., 300., 400., 500.})
-                                                            << 3.2 << -1. << DataContainer{1., 2., 3.}
+                           .build()
-                                                            << DataContainer{100., 200., 300.};
+                    << 3.2 << -1. << DataContainer{1., 2., 3.} << DataContainer{100., 200., 300.};
                 QTest::newRow("xAxisRange2") << ScalarBuilder{}
                                                     .setX({1., 2., 3., 4., 5.})
                                                     .setValues({100., 200., 300., 400., 500.})
                                                       .setValues({100., 200., 300., 400., 500.})
                                                       .build()
                                                << 5.1 << 6. << false << nan << nan;
-                QTest::newRow("scalarBounds5") << ScalarBuilder{}.setX({1.}).setValues({100.}).build() << 0.
+                QTest::newRow("scalarBounds5")
-                                               << 2. << true << 100. << 100.;
+                    << ScalarBuilder{}.setX({1.}).setValues({100.}).build() << 0. << 2. << true << 100. << 100.;
-                QTest::newRow("scalarBounds6") << ScalarBuilder{}.setX({}).setValues({}).build() << 0. << 2.
+                QTest::newRow("scalarBounds6")
-                                               << false << nan << nan;
+                    << ScalarBuilder{}.setX({}).setValues({}).build() << 0. << 2. << false << nan << nan;
                 // Tests with NaN values: NaN values are not included in min/max search
                 QTest::newRow("scalarBounds7") << ScalarBuilder{}

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

                                             << 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}
+                QTest::newRow("invalidInput (invalid data size")
-                                                                 << false << Container{{}, {}, {}};
+                    << 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{{}, {}, {}};
             }

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

                 // 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);
             }
             }

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

             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 +23 -20

               \see initializeParentPlot
             */
-            void QCPLayerable::parentPlotInitialized(QCustomPlot *parentPlot)
+            void QCPLayerable::parentPlotInitialized(QCustomPlot *parentPlot){Q_UNUSED(parentPlot)}
-                Q_UNUSED(parentPlot)
             /*! \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);
                                         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();
                                     }
                 switch (phase) {
                     case upMargins: {
                         if (mType == QCPAxis::atBottom || mType == QCPAxis::atTop) {
-                            setMaximumSize(QWIDGETSIZE_MAX, mBarWidth + mAxisRect.data()->margins().top()
+                            setMaximumSize(QWIDGETSIZE_MAX,
-                                                                + mAxisRect.data()->margins().bottom()
+                                           mBarWidth + mAxisRect.data()->margins().top()
-                                                                + margins().top() + margins().bottom());
+                                               + mAxisRect.data()->margins().bottom() + margins().top()
-                            setMinimumSize(0, mBarWidth + mAxisRect.data()->margins().top()
+                                               + margins().bottom());
-                                                  + mAxisRect.data()->margins().bottom() + margins().top()
+                            setMinimumSize(0,
-                                                  + margins().bottom());
+                                           mBarWidth + mAxisRect.data()->margins().top()
+                                               + mAxisRect.data()->margins().bottom() + margins().top()
+                                               + margins().bottom());
                         }
                         else {
                             setMaximumSize(mBarWidth + mAxisRect.data()->margins().left()

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

                 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/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/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;

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