GIT_REPOSITORIES/LPP/Users/mperrinel/SCIQLOP-Initialisation Commit - r336:d84300391f84

Add current progression for thread fix

perrinel -

r336:d84300391f84

parent child

Context file:

r336:d84300391f84

core/include/Data/ArrayData.h +30 -4

             #ifndef SCIQLOP_ARRAYDATA_H
             #define SCIQLOP_ARRAYDATA_H
+            #include <QReadLocker>
+            #include <QReadWriteLock>
             #include <QVector>
             /**
              * @brief The ArrayData class represents a dataset for a data series.
              *
                 template <int D = Dim, typename = std::enable_if_t<D == 1> >
                 explicit ArrayData(int nbColumns) : m_Data{1, QVector<double>{}}
                 {
+                    QWriteLocker locker(&m_Lock);
                     m_Data[0].resize(nbColumns);
                 }
                 /**
+                 * Ctor for a unidimensional ArrayData
+                 * @param nbColumns the number of values the ArrayData will hold
+                 */
+                explicit ArrayData(const ArrayData &other)
+                {
+                    QReadLocker otherLocker(&other.m_Lock);
+                    QWriteLocker locker(&m_Lock);
+                    m_Data = other.m_Data;
+                }
+                /**
                  * Sets a data at a specified index. The index has to be valid to be effective
                  * @param index the index to which the data will be set
                  * @param data the data to set
                 template <int D = Dim, typename = std::enable_if_t<D == 1> >
                 void setData(int index, double data) noexcept
                 {
+                    QWriteLocker locker(&m_Lock);
                     if (index >= 0 && index < m_Data.at(0).size()) {
                         m_Data[0].replace(index, data);
                     }
                  * @remarks this method is only available for a unidimensional ArrayData
                  */
                 template <int D = Dim, typename = std::enable_if_t<D == 1> >
-                const QVector<double> &data() const noexcept
+                QVector<double> data() const noexcept
                 {
+                    QReadLocker locker(&m_Lock);
                     return m_Data[0];
                 }
                  * @remarks this method is only available for a unidimensional ArrayData
                  */
                 template <int D = Dim, typename = std::enable_if_t<D == 1> >
-                const QVector<double> &data(double tStart, double tEnd) const noexcept
+                QVector<double> data(double tStart, double tEnd) const noexcept
                 {
+                    QReadLocker locker(&m_Lock);
                     return m_Data.at(tStart);
                 }
                 template <int D = Dim, typename = std::enable_if_t<D == 1> >
                 void merge(const ArrayData<1> &arrayData)
                 {
+                    QWriteLocker locker(&m_Lock);
                     if (!m_Data.empty()) {
+                        QReadLocker otherLocker(&arrayData.m_Lock);
                         m_Data[0] += arrayData.data();
                     }
                 }
                 template <int D = Dim, typename = std::enable_if_t<D == 1> >
-                int size()
+                int size() const
                 {
+                    QReadLocker locker(&m_Lock);
                     return m_Data[0].size();
                 }
+                void clear()
+                {
+                    QWriteLocker locker(&m_Lock);
+                    m_Data.clear();
+                }
             private:
                 QVector<QVector<double> > m_Data;
+                mutable QReadWriteLock m_Lock;
             };
             #endif // SCIQLOP_ARRAYDATA_H

core/include/Data/DataSeries.h +15 -1

             #include <QLoggingCategory>
+            #include <QReadLocker>
+            #include <QReadWriteLock>
             #include <memory>
             Q_DECLARE_LOGGING_CATEGORY(LOG_DataSeries)
             Q_LOGGING_CATEGORY(LOG_DataSeries, "DataSeries")
                 /// @sa IDataSeries::valuesUnit()
                 Unit valuesUnit() const override { return m_ValuesUnit; }
+                void clear()
+                {
+                    m_XAxisData->clear();
+                    m_ValuesData->clear();
+                }
                 /// @sa IDataSeries::merge()
                 void merge(IDataSeries *dataSeries) override
                 {
                     if (auto dimDataSeries = dynamic_cast<DataSeries<Dim> *>(dataSeries)) {
                         m_XAxisData->merge(*dimDataSeries->xAxisData());
                         m_ValuesData->merge(*dimDataSeries->valuesData());
+                        dimDataSeries->clear();
                     }
                     else {
                         qCWarning(LOG_DataSeries())
                     }
                 }
+                virtual void lockRead() { m_Lock.lockForRead(); }
+                virtual void lockWrite() { m_Lock.lockForWrite(); }
+                virtual void unlock() { m_Lock.unlock(); }
             protected:
                 /// Protected ctor (DataSeries is abstract)
                 explicit DataSeries(std::shared_ptr<ArrayData<1> > xAxisData, const Unit &xAxisUnit,
                 Unit m_XAxisUnit;
                 std::shared_ptr<ArrayData<Dim> > m_ValuesData;
                 Unit m_ValuesUnit;
+                QReadWriteLock m_Lock;
             };
             #endif // SCIQLOP_DATASERIES_H

core/include/Data/IDataSeries.h +4 0

                 virtual void merge(IDataSeries *dataSeries) = 0;
                 virtual std::unique_ptr<IDataSeries> clone() const = 0;
+                virtual void lockRead() = 0;
+                virtual void lockWrite() = 0;
+                virtual void unlock() = 0;
             };
             // Required for using shared_ptr in signals/slots

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/Variable/Variable.cpp +8 -1

             #include <Data/IDataSeries.h>
             #include <Data/SqpDateTime.h>
+            #include <QReadWriteLock>
+            #include <QThread>
             Q_LOGGING_CATEGORY(LOG_Variable, "Variable")
             struct Variable::VariablePrivate {
             void Variable::setDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept
             {
+                qCInfo(LOG_Variable()) << "Variable::setDataSeries" << QThread::currentThread()->objectName();
                 if (!dataSeries) {
                     /// @todo ALX : log
                     return;
                     impl->m_DataSeries = dataSeries->clone();
                 }
                 else {
+                    dataSeries->lockWrite();
+                    impl->m_DataSeries->lockWrite();
                     impl->m_DataSeries->merge(dataSeries.get());
+                    impl->m_DataSeries->unlock();
+                    dataSeries->unlock();
                     emit updated();
                 }
             }

core/src/Variable/VariableCacheController.cpp +10 -2

             #include "Variable/Variable.h"
             #include <unordered_map>
+            #include <QThread>
             Q_LOGGING_CATEGORY(LOG_VariableCacheController, "VariableCacheController")
             struct VariableCacheController::VariableCacheControllerPrivate {
             void VariableCacheController::addDateTime(std::shared_ptr<Variable> variable,
                                                       const SqpDateTime &dateTime)
             {
+                qCInfo(LOG_VariableCacheController())
+                    << "VariableCacheController::addDateTime" << QThread::currentThread()->objectName();
                 if (variable) {
                     auto findVariableIte = impl->m_VariableToSqpDateTimeListMap.find(variable);
                     if (findVariableIte == impl->m_VariableToSqpDateTimeListMap.end()) {
             VariableCacheController::provideNotInCacheDateTimeList(std::shared_ptr<Variable> variable,
                                                                    const SqpDateTime &dateTime)
             {
+                qCInfo(LOG_VariableCacheController())
+                    << "VariableCacheController::provideNotInCacheDateTimeList"
+                    << QThread::currentThread()->objectName();
                 auto notInCache = QVector<SqpDateTime>{};
                 // This algorithm is recursif. The idea is to localise the start time then the end time in the
             QVector<SqpDateTime>
             VariableCacheController::dateCacheList(std::shared_ptr<Variable> variable) const noexcept
             {
+                qCInfo(LOG_VariableCacheController())
+                    << "VariableCacheController::dateCacheList" << QThread::currentThread()->objectName();
                 try {
                     return impl->m_VariableToSqpDateTimeListMap.at(variable);
                 }
             {
                 auto variableDateTimeList = impl->m_VariableToSqpDateTimeListMap.find(variable);
                 if (variableDateTimeList != impl->m_VariableToSqpDateTimeListMap.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 +8 -4

             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();
             }
             VariableController::~VariableController()
             {
-                qCDebug(LOG_VariableController()) << tr("VariableController destruction")
+                qCDebug(LOG_VariableController())
-                                                  << QThread::currentThread();
+                    << tr("VariableController destruction") << QThread::currentThread();
                 this->waitForFinish();
             }
             void VariableController::onDateTimeOnSelection(const SqpDateTime &dateTime)
             {
+                qCDebug(LOG_VariableController())
+                    << "VariableController::onDateTimeOnSelection" << QThread::currentThread()->objectName();
                 auto selectedRows = impl->m_VariableSelectionModel->selectedRows();
                 for (const auto &selectedRow : qAsConst(selectedRows)) {
             void VariableController::onRequestDataLoading(std::shared_ptr<Variable> variable,
                                                           const SqpDateTime &dateTime)
             {
+                qCDebug(LOG_VariableController())
+                    << "VariableController::onRequestDataLoading" << QThread::currentThread()->objectName();
                 // we want to load data of the variable for the dateTime.
                 // First we check if the cache contains some of them.
                 // For the other, we ask the provider to give them.

gui/src/SqpApplication.cpp +8 -3

                           m_VariableController{std::make_unique<VariableController>()},
                           m_VisualizationController{std::make_unique<VisualizationController>()}
                 {
+                    QThread::currentThread()->setObjectName("MainThread");
+                    m_DataSourceController->moveToThread(&m_DataSourceControllerThread);
+                    m_DataSourceControllerThread.setObjectName("DataSourceControllerThread");
+                    m_VariableController->moveToThread(&m_VariableControllerThread);
+                    m_VariableControllerThread.setObjectName("VariableControllerThread");
+                    m_VisualizationController->moveToThread(&m_VisualizationControllerThread);
+                    m_VisualizationControllerThread.setObjectName("VisualizationControllerThread");
                     // /////////////////////////////// //
                     // Connections between controllers //
                     // /////////////////////////////// //
                             m_VisualizationController.get(),
                             SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)), Qt::DirectConnection);
-                    m_DataSourceController->moveToThread(&m_DataSourceControllerThread);
-                    m_VariableController->moveToThread(&m_VariableControllerThread);
-                    m_VisualizationController->moveToThread(&m_VisualizationControllerThread);
                     // Additionnal init
                     m_VariableController->setTimeController(m_TimeController.get());

gui/src/Visualization/VisualizationGraphHelper.cpp +30 -25

@@ -5,12 +5,16
5		5
6	#include <Variable/Variable.h>	6	#include <Variable/Variable.h>
7		7
8	#include <QElapsedTimer>
9
10	Q_LOGGING_CATEGORY(LOG_VisualizationGraphHelper, "VisualizationGraphHelper")	8	Q_LOGGING_CATEGORY(LOG_VisualizationGraphHelper, "VisualizationGraphHelper")
11		9
12	namespace {	10	namespace {
13		11
		12	class SqpDataContainer : public QCPGraphDataContainer {
		13	public:
		14	void sqpAdd(const QCPGraphData &data) { mData.append(data); }
		15	};
		16
		17
14	/// Format for datetimes on a axis	18	/// Format for datetimes on a axis
15	const auto DATETIME_TICKER_FORMAT = QStringLiteral("yyyy/MM/dd \nhh:mm:ss");	19	const auto DATETIME_TICKER_FORMAT = QStringLiteral("yyyy/MM/dd \nhh:mm:ss");
16		20
@@ -33,35 +37,36 QSharedPointer<QCPAxisTicker> axisTicker(bool isTimeAxis)
33	void updateScalarData(QCPAbstractPlottable *component, ScalarSeries &scalarSeries,	37	void updateScalarData(QCPAbstractPlottable *component, ScalarSeries &scalarSeries,
34	const SqpDateTime &dateTime)	38	const SqpDateTime &dateTime)
35	{	39	{
36	QElapsedTimer timer;	40	qCInfo(LOG_VisualizationGraphHelper())
37	timer.start();	41	<< "TORM: updateScalarData" << QThread::currentThread()->objectName();
38	if (auto qcpGraph = dynamic_cast<QCPGraph *>(component)) {	42	if (auto qcpGraph = dynamic_cast<QCPGraph *>(component)) {
39	// Clean the graph	43	// Clean the graph
40	// NAIVE approch	44	// NAIVE approch
41	const auto &xData = scalarSeries.xAxisData()->data();	45	scalarSeries.lockRead();
42	const auto &valuesData = scalarSeries.valuesData()->data();	46	{
43	const auto count = xData.count();	47	const auto xData = scalarSeries.xAxisData()->data();
44	qCInfo(LOG_VisualizationGraphHelper()) << "TORM: Current points in cache" << xData.count();	48	const auto valuesData = scalarSeries.valuesData()->data();
45	auto xValue = QVector<double>(count);	49	const auto count = xData.count();
46	auto vValue = QVector<double>(count);	50	qCInfo(LOG_VisualizationGraphHelper())
47		51	<< "TORM: Current points in cache" << xData.count();
48	int n = 0;	52
49	for (auto i = 0; i < count; ++i) {	53	auto dataContainer = qcpGraph->data();
50	const auto x = xData[i];	54	dataContainer->clear();
51	if (x >= dateTime.m_TStart && x <= dateTime.m_TEnd) {	55	auto sqpDataContainer = QSharedPointer<SqpDataContainer>::create();
52	xValue[n] = x;	56	qcpGraph->setData(sqpDataContainer);
53	vValue[n] = valuesData[i];	57
54	++n;	58	for (auto i = 0; i < count; ++i) {
		59	const auto x = xData[i];
		60	if (x >= dateTime.m_TStart && x <= dateTime.m_TEnd) {
		61	sqpDataContainer->sqpAdd(QCPGraphData(x, valuesData[i]));
		62	}
55	}	63	}
		64	sqpDataContainer->sort();
		65	qCInfo(LOG_VisualizationGraphHelper())
		66	<< "TORM: Current points displayed" << sqpDataContainer->size();
56	}	67	}
		68	scalarSeries.unlock();
57		69
58	xValue.resize(n);
59	vValue.resize(n);
60
61	qCInfo(LOG_VisualizationGraphHelper()) << "TORM: Current points displayed"
62	<< xValue.count();
63
64	qcpGraph->setData(xValue, vValue);
65		70
66	// Display all data	71	// Display all data
67	component->rescaleAxes();	72	component->rescaleAxes();

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

                 connect(variable.get(), SIGNAL(updated()), this, SLOT(onDataCacheVariableUpdated()));
             }
             void VisualizationGraphWidget::addVariableUsingGraph(std::shared_ptr<Variable> variable)
             {
             void VisualizationGraphWidget::onRangeChanged(const QCPRange &t1)
             {
-                qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::onRangeChanged");
+                qCDebug(LOG_VisualizationGraphWidget())
+                    << tr("VisualizationGraphWidget::onRangeChanged") << QThread::currentThread()->objectName();
                 for (auto it = impl->m_VariableToPlotMultiMap.cbegin();
                      it != impl->m_VariableToPlotMultiMap.cend(); ++it) {

gui/src/Visualization/qcustomplot.cpp +41 -32

                     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
                             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);
                 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();
             */
             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();
                                     }
             }
             /*! \overload
-            */
+             */
             void QCPLegend::setIconSize(int width, int height)
             {
                 mIconSize.setWidth(width);

plugins/mockplugin/src/CosinusProvider.cpp +3 0

             #include <cmath>
             #include <QDateTime>
+            #include <QThread>
             Q_LOGGING_CATEGORY(LOG_CosinusProvider, "CosinusProvider")
             void CosinusProvider::requestDataLoading(const QVector<SqpDateTime> &dateTimeList)
             {
+                qCInfo(LOG_CosinusProvider()) << "CosinusProvider::requestDataLoading"
+                                              << QThread::currentThread()->objectName();
                 // NOTE: Try to use multithread if possible
                 for (const auto &dateTime : dateTimeList) {
                     auto scalarSeries = this->retrieveData(DataProviderParameters{dateTime});

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages