GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r384:be36d883265c

Merge pull request from SCIQLOP-Initialisation develop...

perrinel -

r384:be36d883265c

parent child

Context file:

r384:be36d883265c

core/include/Network/NetworkController.h created 644 +30 0

@@ -0,0 +1,30
	1	#ifndef SCIQLOP_NETWORKCONTROLLER_H
	2	#define SCIQLOP_NETWORKCONTROLLER_H
	3
	4	#include <QLoggingCategory>
	5	#include <QObject>
	6
	7	#include <Common/spimpl.h>
	8
	9	Q_DECLARE_LOGGING_CATEGORY(LOG_NetworkController)
	10
	11	/**
	12	* @brief The NetworkController class aims to handle all network connection of SciQlop.
	13	*/
	14	class NetworkController : public QObject {
	15	Q_OBJECT
	16	public:
	17	explicit NetworkController(QObject *parent = 0);
	18
	19
	20	void initialize();
	21	void finalize();
	22
	23	private:
	24	void waitForFinish();
	25
	26	class NetworkControllerPrivate;
	27	spimpl::unique_impl_ptr<NetworkControllerPrivate> impl;
	28	};
	29
	30	#endif // SCIQLOP_NETWORKCONTROLLER_H

core/src/Network/NetworkController.cpp created 644 +33 0

@@ -0,0 +1,33
	1	#include "Network/NetworkController.h"
	2
	3	#include <QMutex>
	4	#include <QThread>
	5
	6	Q_LOGGING_CATEGORY(LOG_NetworkController, "NetworkController")
	7
	8	struct NetworkController::NetworkControllerPrivate {
	9	explicit NetworkControllerPrivate(NetworkController *parent) : m_WorkingMutex{} {}
	10	QMutex m_WorkingMutex;
	11	};
	12
	13	NetworkController::NetworkController(QObject *parent)
	14	: QObject(parent), impl{spimpl::make_unique_impl<NetworkControllerPrivate>(this)}
	15	{
	16	}
	17
	18	void NetworkController::initialize()
	19	{
	20	qCDebug(LOG_NetworkController()) << tr("NetworkController init") << QThread::currentThread();
	21	impl->m_WorkingMutex.lock();
	22	qCDebug(LOG_NetworkController()) << tr("NetworkController init END");
	23	}
	24
	25	void NetworkController::finalize()
	26	{
	27	impl->m_WorkingMutex.unlock();
	28	}
	29
	30	void NetworkController::waitForFinish()
	31	{
	32	QMutexLocker locker{&impl->m_WorkingMutex};
	33	}

plugins/amda/include/AmdaProvider.h created 644 +36 0

@@ -0,0 +1,36
	1	#ifndef SCIQLOP_AMDAPROVIDER_H
	2	#define SCIQLOP_AMDAPROVIDER_H
	3
	4	#include "AmdaGlobal.h"
	5
	6	#include <Common/spimpl.h>
	7
	8	#include <Data/IDataProvider.h>
	9
	10	#include <QLoggingCategory>
	11
	12
	13	Q_DECLARE_LOGGING_CATEGORY(LOG_AmdaProvider)
	14
	15	/**
	16	* @brief The AmdaProvider class is an example of how a data provider can generate data
	17	*/
	18	class SCIQLOP_AMDA_EXPORT AmdaProvider : public IDataProvider {
	19	public:
	20	explicit AmdaProvider();
	21
	22	void requestDataLoading(QUuid token, const QVector<SqpDateTime> &dateTimeList) override;
	23
	24	private:
	25	void retrieveData(QUuid token, const DataProviderParameters &parameters) const;
	26
	27	class AmdaProviderPrivate;
	28	spimpl::unique_impl_ptr<AmdaProviderPrivate> impl;
	29
	30	private slots:
	31	void httpFinished() noexcept;
	32	void httpDownloadFinished() noexcept;
	33	void httpDownloadReadyRead() noexcept;
	34	};
	35
	36	#endif // SCIQLOP_AMDAPROVIDER_H

plugins/amda/include/AmdaResultParser.h created 644 +19 0

@@ -0,0 +1,19
	1	#ifndef SCIQLOP_AMDARESULTPARSER_H
	2	#define SCIQLOP_AMDARESULTPARSER_H
	3
	4	#include "AmdaGlobal.h"
	5
	6	#include <QLoggingCategory>
	7
	8	#include <memory>
	9
	10	class IDataSeries;
	11
	12	Q_DECLARE_LOGGING_CATEGORY(LOG_AmdaResultParser)
	13
	14	struct SCIQLOP_AMDA_EXPORT AmdaResultParser {
	15
	16	static std::shared_ptr<IDataSeries> readTxt(const QString &filePath) noexcept;
	17	};
	18
	19	#endif // SCIQLOP_AMDARESULTPARSER_H

plugins/amda/src/AmdaProvider.cpp created 644 +134 0

@@ -0,0 +1,134
	1	#include "AmdaProvider.h"
	2	#include "AmdaResultParser.h"
	3
	4	#include <Data/DataProviderParameters.h>
	5
	6	#include <QNetworkAccessManager>
	7	#include <QNetworkReply>
	8	#include <QTemporaryFile>
	9
	10	Q_LOGGING_CATEGORY(LOG_AmdaProvider, "AmdaProvider")
	11
	12	namespace {
	13
	14	/// URL format for a request on AMDA server. The parameters are as follows:
	15	/// - %1: start date
	16	/// - %2: end date
	17	/// - %3: parameter id
	18	const auto AMDA_URL_FORMAT = QStringLiteral(
	19	"http://amda.irap.omp.eu/php/rest/"
	20	"getParameter.php?startTime=%1&stopTime=%2&parameterID=%3&sampling=60&outputFormat=ASCII&"
	21	"timeFormat=ISO8601&gzip=0");
	22
	23	/// Dates format passed in the URL (e.g 2013-09-23T09:00)
	24	const auto AMDA_TIME_FORMAT = QStringLiteral("yyyy-MM-ddThh:ss");
	25
	26	/// Formats a time to a date that can be passed in URL
	27	QString dateFormat(double sqpDateTime) noexcept
	28	{
	29	auto dateTime = QDateTime::fromMSecsSinceEpoch(sqpDateTime * 1000.);
	30	return dateTime.toString(AMDA_TIME_FORMAT);
	31	}
	32
	33	} // namespace
	34
	35	struct AmdaProvider::AmdaProviderPrivate {
	36	DataProviderParameters m_Params{};
	37	std::unique_ptr<QNetworkAccessManager> m_AccessManager{nullptr};
	38	QNetworkReply *m_Reply{nullptr};
	39	std::unique_ptr<QTemporaryFile> m_File{nullptr};
	40	QUuid m_Token;
	41	};
	42
	43	AmdaProvider::AmdaProvider() : impl{spimpl::make_unique_impl<AmdaProviderPrivate>()}
	44	{
	45	}
	46
	47	void AmdaProvider::requestDataLoading(QUuid token, const QVector<SqpDateTime> &dateTimeList)
	48	{
	49	// NOTE: Try to use multithread if possible
	50	for (const auto &dateTime : dateTimeList) {
	51	retrieveData(token, DataProviderParameters{dateTime});
	52	}
	53	}
	54
	55	void AmdaProvider::retrieveData(QUuid token, const DataProviderParameters &parameters) const
	56	{
	57	// /////////// //
	58	// Creates URL //
	59	// /////////// //
	60
	61	auto startDate = dateFormat(parameters.m_Time.m_TStart);
	62	auto endDate = dateFormat(parameters.m_Time.m_TEnd);
	63	auto productId = QStringLiteral("imf(0)");
	64
	65	auto url = QUrl{QString{AMDA_URL_FORMAT}.arg(startDate, endDate, productId)};
	66
	67	// //////////////// //
	68	// Executes request //
	69	// //////////////// //
	70
	71	impl->m_Token = token;
	72	impl->m_Params = parameters;
	73	impl->m_AccessManager = std::make_unique<QNetworkAccessManager>();
	74	impl->m_Reply = impl->m_AccessManager->get(QNetworkRequest{url});
	75	connect(impl->m_Reply, &QNetworkReply::finished, this, &AmdaProvider::httpFinished);
	76	}
	77
	78	void AmdaProvider::httpFinished() noexcept
	79	{
	80	// ////////////////////// //
	81	// Gets download file url //
	82	// ////////////////////// //
	83
	84	auto downloadFileUrl = QUrl{QString{impl->m_Reply->readAll()}};
	85
	86	// ///////////////////////////////////// //
	87	// Executes request for downloading file //
	88	// ///////////////////////////////////// //
	89
	90	// Deletes old reply
	91	impl->m_Reply->deleteLater();
	92	impl->m_Reply = nullptr;
	93
	94	// Creates destination file
	95	impl->m_File = std::make_unique<QTemporaryFile>();
	96	if (impl->m_File->open()) {
	97	qCDebug(LOG_AmdaProvider()) << "Temp file: " << impl->m_File->fileName();
	98
	99	// Executes request
	100	impl->m_AccessManager = std::make_unique<QNetworkAccessManager>();
	101	impl->m_Reply = impl->m_AccessManager->get(QNetworkRequest{downloadFileUrl});
	102	connect(impl->m_Reply, &QNetworkReply::finished, this,
	103	&AmdaProvider::httpDownloadReadyRead);
	104	connect(impl->m_Reply, &QNetworkReply::finished, this, &AmdaProvider::httpDownloadFinished);
	105	}
	106	}
	107
	108	void AmdaProvider::httpDownloadFinished() noexcept
	109	{
	110	if (impl->m_File) {
	111	impl->m_File->close();
	112
	113	// Parse results file
	114	if (auto dataSeries = AmdaResultParser::readTxt(impl->m_File->fileName())) {
	115	emit dataProvided(impl->m_Token, dataSeries, impl->m_Params.m_Time);
	116	}
	117	else {
	118	/// @todo ALX : debug
	119	}
	120
	121	impl->m_File = nullptr;
	122	}
	123
	124	// Deletes reply
	125	impl->m_Reply->deleteLater();
	126	impl->m_Reply = nullptr;
	127	}
	128
	129	void AmdaProvider::httpDownloadReadyRead() noexcept
	130	{
	131	if (impl->m_File) {
	132	impl->m_File->write(impl->m_Reply->readAll());
	133	}
	134	}

plugins/amda/src/AmdaResultParser.cpp created 644 +70 0

@@ -0,0 +1,70
	1	#include "AmdaResultParser.h"
	2
	3	#include <Data/ScalarSeries.h>
	4
	5	#include <QDateTime>
	6	#include <QFile>
	7
	8	Q_LOGGING_CATEGORY(LOG_AmdaResultParser, "AmdaResultParser")
	9
	10	namespace {
	11
	12	/// Format for dates in result files
	13	const auto DATE_FORMAT = QStringLiteral("yyyy-MM-ddThh:mm:ss.zzz");
	14
	15	/// @todo ALX
	16	double doubleDate(const QString &stringDate) noexcept
	17	{
	18	auto dateTime = QDateTime::fromString(stringDate, DATE_FORMAT);
	19	return dateTime.toMSecsSinceEpoch() / 1000.;
	20	}
	21
	22	} // namespace
	23
	24	std::shared_ptr<IDataSeries> AmdaResultParser::readTxt(const QString &filePath) noexcept
	25	{
	26	QFile file{filePath};
	27
	28	if (!file.open(QFile::ReadOnly \| QIODevice::Text)) {
	29	qCCritical(LOG_AmdaResultParser())
	30	<< QObject::tr("Can't retrieve AMDA data from file %1: %2")
	31	.arg(filePath, file.errorString());
	32	return nullptr;
	33	}
	34
	35	auto xData = QVector<double>{};
	36	auto valuesData = QVector<double>{};
	37
	38	QTextStream stream{&file};
	39
	40	// Ignore comment lines (3 lines)
	41	stream.readLine();
	42	stream.readLine();
	43	stream.readLine();
	44
	45	QString line{};
	46	auto lineRegex = QRegExp{QStringLiteral("\\s+")};
	47	while (stream.readLineInto(&line)) {
	48	auto lineData = line.split(lineRegex, QString::SkipEmptyParts);
	49	if (lineData.size() == 2) {
	50	// X : the data is converted from date to double (in secs)
	51	xData.push_back(doubleDate(lineData.at(0)));
	52
	53	// Value
	54	valuesData.push_back(lineData.at(1).toDouble());
	55	}
	56	else {
	57	/// @todo ALX : log
	58	}
	59	}
	60
	61	/// @todo ALX : handle units
	62	auto scalarSeries = std::make_shared<ScalarSeries>(xData.size(), Unit{"nT", true}, Unit{});
	63
	64	const auto count = xData.size();
	65	for (auto i = 0; i < count; ++i) {
	66	scalarSeries->setData(i, xData.at(i), valuesData.at(i));
	67	}
	68
	69	return scalarSeries;
	70	}

app/ui/MainWindow.ui +2 -2

             <?xml version="1.0" encoding="UTF-8"?>
             <ui version="4.0">
              <class>MainWindow</class>
              <widget class="QMainWindow" name="MainWindow">
               <property name="geometry">
                <rect>
                 <x>0</x>
                 <y>0</y>
                 <width>800</width>
                 <height>600</height>
                </rect>
               </property>
               <property name="windowTitle">
-               <string>QLop</string>
+               <string>SciQlop v0.0.1</string>
               </property>
               <property name="dockNestingEnabled">
                <bool>true</bool>
               </property>
               <widget class="QWidget" name="centralWidget">
                <property name="enabled">
                 <bool>true</bool>
                </property>
                <property name="sizePolicy">
                 <sizepolicy hsizetype="Minimum" vsizetype="Minimum">
                  <horstretch>0</horstretch>
                  <verstretch>0</verstretch>
                 </sizepolicy>
                </property>
                <property name="maximumSize">
                 <size>
                  <width>16777215</width>
                  <height>16777215</height>
                 </size>
                </property>
                <layout class="QHBoxLayout" name="horizontalLayout">
                 <property name="spacing">
                  <number>0</number>
                 </property>
                 <property name="leftMargin">
                  <number>0</number>
                 </property>
                 <property name="topMargin">
                  <number>0</number>
                 </property>
                 <property name="rightMargin">
                  <number>0</number>
                 </property>
                 <property name="bottomMargin">
                  <number>0</number>
                 </property>
                 <item>
                  <widget class="QSplitter" name="splitter">
                   <property name="orientation">
                    <enum>Qt::Horizontal</enum>
                   </property>
                   <widget class="QWidget" name="leftMainInspectorWidget" native="true">
                    <layout class="QVBoxLayout" name="verticalLayout">
                     <property name="spacing">
                      <number>0</number>
                     </property>
                     <property name="leftMargin">
                      <number>0</number>
                     </property>
                     <property name="topMargin">
                      <number>0</number>
                     </property>
                     <property name="rightMargin">
                      <number>0</number>
                     </property>
                     <property name="bottomMargin">
                      <number>0</number>
                     </property>
                     <item>
                      <widget class="DataSourceWidget" name="dataSourceWidget" native="true"/>
                     </item>
                     <item>
                      <widget class="QWidget" name="dateTimeWidget" native="true"/>
                     </item>
                     <item>
                      <widget class="VariableInspectorWidget" name="variableInspectorWidget" native="true"/>
                     </item>
                    </layout>
                   </widget>
                   <widget class="SqpSidePane" name="leftInspectorSidePane" native="true"/>
                   <widget class="VisualizationWidget" name="view" native="true">
                    <property name="sizePolicy">
                     <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
                      <horstretch>0</horstretch>
                      <verstretch>0</verstretch>
                     </sizepolicy>
                    </property>
                   </widget>
                   <widget class="SqpSidePane" name="rightInspectorSidePane" native="true"/>
                   <widget class="QWidget" name="rightMainInspectorWidget" native="true">
                    <layout class="QVBoxLayout" name="verticalLayout_3">
                     <property name="spacing">
                      <number>0</number>
                     </property>
                     <property name="leftMargin">
                      <number>0</number>
                     </property>
                     <property name="topMargin">
                      <number>0</number>
                     </property>
                     <property name="rightMargin">
                      <number>0</number>
                     </property>
                     <property name="bottomMargin">
                      <number>0</number>
                     </property>
                     <item>
                      <widget class="QWidget" name="commonPropertyInspectorWidget" native="true"/>
                     </item>
                     <item>
                      <widget class="DataSourceWidget" name="catalogWidget" native="true"/>
                     </item>
                    </layout>
                   </widget>
                  </widget>
                 </item>
                </layout>
               </widget>
               <widget class="QMenuBar" name="menuBar">
                <property name="geometry">
                 <rect>
                  <x>0</x>
                  <y>0</y>
                  <width>800</width>
-                 <height>26</height>
+                 <height>28</height>
                 </rect>
                </property>
               </widget>
               <widget class="QStatusBar" name="statusBar"/>
              </widget>
              <layoutdefault spacing="6" margin="11"/>
              <customwidgets>
               <customwidget>
                <class>VisualizationWidget</class>
                <extends>QWidget</extends>
                <header location="global">Visualization/VisualizationWidget.h</header>
                <container>1</container>
               </customwidget>
               <customwidget>
                <class>SqpSidePane</class>
                <extends>QWidget</extends>
                <header location="global">SidePane/SqpSidePane.h</header>
                <container>1</container>
               </customwidget>
               <customwidget>
                <class>DataSourceWidget</class>
                <extends>QWidget</extends>
                <header location="global">DataSource/DataSourceWidget.h</header>
                <container>1</container>
               </customwidget>
               <customwidget>
                <class>VariableInspectorWidget</class>
                <extends>QWidget</extends>
                <header location="global">Variable/VariableInspectorWidget.h</header>
                <container>1</container>
               </customwidget>
              </customwidgets>
              <resources/>
              <connections/>
             </ui>

core/include/Data/IDataProvider.h +4 -6

             #ifndef SCIQLOP_IDATAPROVIDER_H
             #define SCIQLOP_IDATAPROVIDER_H
             #include <memory>
             #include <QObject>
+            #include <QUuid>
             #include <Common/MetaTypes.h>
             #include <Data/SqpDateTime.h>
             class DataProviderParameters;
             class IDataSeries;
             /**
              * @brief The IDataProvider interface aims to declare a data provider.
              *
              * A data provider is an entity that generates data and returns it according to various parameters
              * (time interval, product to retrieve the data, etc.)
              *
              * @sa IDataSeries
              */
             class IDataProvider : public QObject {
                 Q_OBJECT
             public:
                 virtual ~IDataProvider() noexcept = default;
-                virtual std::shared_ptr<IDataSeries>
+                virtual void requestDataLoading(QUuid token, const QVector<SqpDateTime> &dateTimeList) = 0;
-                retrieveData(const DataProviderParameters &parameters) const = 0;
-                virtual void requestDataLoading(const QVector<SqpDateTime> &dateTimeList) = 0;
             signals:
-                void dataProvided(std::shared_ptr<IDataSeries> dateSerie, const SqpDateTime &dateTime);
+                void dataProvided(QUuid token, std::shared_ptr<IDataSeries> dateSerie,
+                                  const SqpDateTime &dateTime);
             };
             // Required for using shared_ptr in signals/slots
             SCIQLOP_REGISTER_META_TYPE(IDATAPROVIDER_PTR_REGISTRY, std::shared_ptr<IDataProvider>)
             #endif // SCIQLOP_IDATAPROVIDER_H

core/src/Variable/VariableController.cpp +12 -18

             #include <Variable/Variable.h>
             #include <Variable/VariableCacheController.h>
             #include <Variable/VariableController.h>
             #include <Variable/VariableModel.h>
             #include <Data/DataProviderParameters.h>
             #include <Data/IDataProvider.h>
             #include <Data/IDataSeries.h>
             #include <Time/TimeController.h>
             #include <QDateTime>
             #include <QMutex>
             #include <QThread>
+            #include <QUuid>
             #include <QtCore/QItemSelectionModel>
             #include <unordered_map>
             Q_LOGGING_CATEGORY(LOG_VariableController, "VariableController")
-            namespace {
-            /// @todo Generates default dataseries, according to the provider passed in parameter. This method
-            /// will be deleted when the timerange is recovered from SciQlop
-            std::shared_ptr<IDataSeries> generateDefaultDataSeries(const IDataProvider &provider,
-                                                                   const SqpDateTime &dateTime) noexcept
-                auto parameters = DataProviderParameters{dateTime};
-                return provider.retrieveData(parameters);
-            } // namespace
             struct VariableController::VariableControllerPrivate {
                 explicit VariableControllerPrivate(VariableController *parent)
                         : m_WorkingMutex{},
                           m_VariableModel{new VariableModel{parent}},
                           m_VariableSelectionModel{new QItemSelectionModel{m_VariableModel, parent}},
                           m_VariableCacheController{std::make_unique<VariableCacheController>()}
                 {
                 }
                 QMutex m_WorkingMutex;
                 /// Variable model. The VariableController has the ownership
                 VariableModel *m_VariableModel;
                 QItemSelectionModel *m_VariableSelectionModel;
                 TimeController *m_TimeController{nullptr};
                 std::unique_ptr<VariableCacheController> m_VariableCacheController;
                 std::unordered_map<std::shared_ptr<Variable>, std::shared_ptr<IDataProvider> >
                     m_VariableToProviderMap;
+                std::unordered_map<std::shared_ptr<Variable>, QUuid> m_VariableToToken;
             };
             VariableController::VariableController(QObject *parent)
                     : QObject{parent}, impl{spimpl::make_unique_impl<VariableControllerPrivate>(this)}
             {
                 qCDebug(LOG_VariableController()) << tr("VariableController construction")
                                                   << QThread::currentThread();
             }
             VariableController::~VariableController()
             {
                 qCDebug(LOG_VariableController()) << tr("VariableController destruction")
                                                   << QThread::currentThread();
                 this->waitForFinish();
             }
             VariableModel *VariableController::variableModel() noexcept
             {
                 return impl->m_VariableModel;
             }
             QItemSelectionModel *VariableController::variableSelectionModel() noexcept
             {
                 return impl->m_VariableSelectionModel;
             }
             void VariableController::setTimeController(TimeController *timeController) noexcept
             {
                 impl->m_TimeController = timeController;
             }
             void VariableController::deleteVariable(std::shared_ptr<Variable> variable) noexcept
             {
                 if (!variable) {
                     qCCritical(LOG_VariableController()) << "Can't delete variable: variable is null";
                     return;
                 }
                 // Spreads in SciQlop that the variable will be deleted, so that potential receivers can
                 // make some treatments before the deletion
                 emit variableAboutToBeDeleted(variable);
                 // Deletes provider
                 auto nbProvidersDeleted = impl->m_VariableToProviderMap.erase(variable);
                 qCDebug(LOG_VariableController())
                     << tr("Number of providers deleted for variable %1: %2")
                            .arg(variable->name(), QString::number(nbProvidersDeleted));
                 // Clears cache
                 impl->m_VariableCacheController->clear(variable);
                 // Deletes from model
                 impl->m_VariableModel->deleteVariable(variable);
             }
             void VariableController::deleteVariables(
                 const QVector<std::shared_ptr<Variable> > &variables) noexcept
             {
                 for (auto variable : qAsConst(variables)) {
                     deleteVariable(variable);
                 }
             }
             void VariableController::createVariable(const QString &name,
                                                     std::shared_ptr<IDataProvider> provider) noexcept
             {
                 if (!impl->m_TimeController) {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to create variable: The time controller is null");
                     return;
                 }
                 /// @todo : for the moment :
                 /// - the provider is only used to retrieve data from the variable for its initialization, but
                 /// it will be retained later
                 /// - default data are generated for the variable, without taking into account the timerange set
                 /// in sciqlop
                 auto dateTime = impl->m_TimeController->dateTime();
                 if (auto newVariable = impl->m_VariableModel->createVariable(name, dateTime)) {
+                    auto token = QUuid::createUuid();
                     // store the provider
                     impl->m_VariableToProviderMap[newVariable] = provider;
+                    impl->m_VariableToToken[newVariable] = token;
                     auto addDateTimeAcquired = [ this, varW = std::weak_ptr<Variable>{newVariable} ](
-                        auto dataSeriesAcquired, auto dateTimeToPutInCache)
+                        QUuid token, auto dataSeriesAcquired, auto dateTimeToPutInCache)
                     {
                         if (auto variable = varW.lock()) {
-                            impl->m_VariableCacheController->addDateTime(variable, dateTimeToPutInCache);
+                            auto varToken = impl->m_VariableToToken.at(variable);
-                            variable->setDataSeries(dataSeriesAcquired);
+                            if (varToken == token) {
+                                impl->m_VariableCacheController->addDateTime(variable, dateTimeToPutInCache);
+                                variable->setDataSeries(dataSeriesAcquired);
+                            }
                         }
                     };
                     connect(provider.get(), &IDataProvider::dataProvided, addDateTimeAcquired);
                     this->onRequestDataLoading(newVariable, dateTime);
                 }
             }
             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)) {
                     if (auto selectedVariable = impl->m_VariableModel->variable(selectedRow.row())) {
                         selectedVariable->setDateTime(dateTime);
                         this->onRequestDataLoading(selectedVariable, dateTime);
                     }
                 }
             }
             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.
                 if (variable) {
                     auto dateTimeListNotInCache
                         = impl->m_VariableCacheController->provideNotInCacheDateTimeList(variable, dateTime);
                     if (!dateTimeListNotInCache.empty()) {
                         // Ask the provider for each data on the dateTimeListNotInCache
+                        auto token = impl->m_VariableToToken.at(variable);
                         impl->m_VariableToProviderMap.at(variable)->requestDataLoading(
-                            std::move(dateTimeListNotInCache));
+                            token, std::move(dateTimeListNotInCache));
                     }
                     else {
                         emit variable->updated();
                     }
                 }
                 else {
                     qCCritical(LOG_VariableController()) << tr("Impossible to load data of a variable null");
                 }
             }
             void VariableController::initialize()
             {
                 qCDebug(LOG_VariableController()) << tr("VariableController init") << QThread::currentThread();
                 impl->m_WorkingMutex.lock();
                 qCDebug(LOG_VariableController()) << tr("VariableController init END");
             }
             void VariableController::finalize()
             {
                 impl->m_WorkingMutex.unlock();
             }
             void VariableController::waitForFinish()
             {
                 QMutexLocker locker{&impl->m_WorkingMutex};
             }

gui/include/SqpApplication.h +2 0

             #ifndef SCIQLOP_SQPAPPLICATION_H
             #define SCIQLOP_SQPAPPLICATION_H
             #include "SqpApplication.h"
             #include <QApplication>
             #include <QLoggingCategory>
             #include <Common/spimpl.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_SqpApplication)
             #if defined(sqpApp)
             #undef sqpApp
             #endif
             #define sqpApp (static_cast<SqpApplication *>(QCoreApplication::instance()))
             class DataSourceController;
+            class NetworkController;
             class TimeController;
             class VariableController;
             class VisualizationController;
             /**
              * @brief The SqpApplication class aims to make the link between SciQlop
              * and its plugins. This is the intermediate class that SciQlop has to use
              * in the way to connect a data source. Please first use load method to initialize
              * a plugin specified by its metadata name (JSON plugin source) then others specifics
              * method will be able to access it.
              * You can load a data source driver plugin then create a data source.
              */
             class SqpApplication : public QApplication {
                 Q_OBJECT
             public:
                 explicit SqpApplication(int &argc, char **argv);
                 virtual ~SqpApplication();
                 void initialize();
                 /// Accessors for the differents sciqlop controllers
                 DataSourceController &dataSourceController() noexcept;
+                NetworkController &networkController() noexcept;
                 TimeController &timeController() noexcept;
                 VariableController &variableController() noexcept;
                 VisualizationController &visualizationController() noexcept;
             private:
                 class SqpApplicationPrivate;
                 spimpl::unique_impl_ptr<SqpApplicationPrivate> impl;
             };
             #endif // SCIQLOP_SQPAPPLICATION_H

gui/src/SqpApplication.cpp +24 -8

             #include "SqpApplication.h"
             #include <Data/IDataProvider.h>
             #include <DataSource/DataSourceController.h>
+            #include <Network/NetworkController.h>
             #include <QThread>
             #include <Time/TimeController.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <Visualization/VisualizationController.h>
             Q_LOGGING_CATEGORY(LOG_SqpApplication, "SqpApplication")
             class SqpApplication::SqpApplicationPrivate {
             public:
                 SqpApplicationPrivate()
                         : m_DataSourceController{std::make_unique<DataSourceController>()},
+                          m_NetworkController{std::make_unique<NetworkController>()},
                           m_TimeController{std::make_unique<TimeController>()},
                           m_VariableController{std::make_unique<VariableController>()},
                           m_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 //
                     // /////////////////////////////// //
                     // VariableController <-> DataSourceController
                     connect(m_DataSourceController.get(),
                             SIGNAL(variableCreationRequested(const QString &, std::shared_ptr<IDataProvider>)),
                             m_VariableController.get(),
                             SLOT(createVariable(const QString &, std::shared_ptr<IDataProvider>)));
                     // VariableController <-> VisualizationController
                     connect(m_VariableController.get(),
                             SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)),
                             m_VisualizationController.get(),
                             SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)), Qt::DirectConnection);
+                    m_DataSourceController->moveToThread(&m_DataSourceControllerThread);
+                    m_NetworkController->moveToThread(&m_NetworkControllerThread);
+                    m_VariableController->moveToThread(&m_VariableControllerThread);
+                    m_VisualizationController->moveToThread(&m_VisualizationControllerThread);
                     // Additionnal init
                     m_VariableController->setTimeController(m_TimeController.get());
                 }
                 virtual ~SqpApplicationPrivate()
                 {
                     qCInfo(LOG_SqpApplication()) << tr("SqpApplicationPrivate destruction");
                     m_DataSourceControllerThread.quit();
                     m_DataSourceControllerThread.wait();
+                    m_NetworkControllerThread.quit();
+                    m_NetworkControllerThread.wait();
                     m_VariableControllerThread.quit();
                     m_VariableControllerThread.wait();
                     m_VisualizationControllerThread.quit();
                     m_VisualizationControllerThread.wait();
                 }
                 std::unique_ptr<DataSourceController> m_DataSourceController;
                 std::unique_ptr<VariableController> m_VariableController;
                 std::unique_ptr<TimeController> m_TimeController;
+                std::unique_ptr<NetworkController> m_NetworkController;
                 std::unique_ptr<VisualizationController> m_VisualizationController;
                 QThread m_DataSourceControllerThread;
+                QThread m_NetworkControllerThread;
                 QThread m_VariableControllerThread;
                 QThread m_VisualizationControllerThread;
             };
             SqpApplication::SqpApplication(int &argc, char **argv)
                     : QApplication{argc, argv}, impl{spimpl::make_unique_impl<SqpApplicationPrivate>()}
             {
                 qCInfo(LOG_SqpApplication()) << tr("SqpApplication construction");
                 connect(&impl->m_DataSourceControllerThread, &QThread::started,
                         impl->m_DataSourceController.get(), &DataSourceController::initialize);
                 connect(&impl->m_DataSourceControllerThread, &QThread::finished,
                         impl->m_DataSourceController.get(), &DataSourceController::finalize);
+                connect(&impl->m_NetworkControllerThread, &QThread::started, impl->m_NetworkController.get(),
+                        &NetworkController::initialize);
+                connect(&impl->m_NetworkControllerThread, &QThread::finished, impl->m_NetworkController.get(),
+                        &NetworkController::finalize);
                 connect(&impl->m_VariableControllerThread, &QThread::started, impl->m_VariableController.get(),
                         &VariableController::initialize);
                 connect(&impl->m_VariableControllerThread, &QThread::finished, impl->m_VariableController.get(),
                         &VariableController::finalize);
                 connect(&impl->m_VisualizationControllerThread, &QThread::started,
                         impl->m_VisualizationController.get(), &VisualizationController::initialize);
                 connect(&impl->m_VisualizationControllerThread, &QThread::finished,
                         impl->m_VisualizationController.get(), &VisualizationController::finalize);
                 impl->m_DataSourceControllerThread.start();
+                impl->m_NetworkControllerThread.start();
                 impl->m_VariableControllerThread.start();
                 impl->m_VisualizationControllerThread.start();
             }
             SqpApplication::~SqpApplication()
             {
             }
             void SqpApplication::initialize()
             {
             }
             DataSourceController &SqpApplication::dataSourceController() noexcept
             {
                 return *impl->m_DataSourceController;
             }
+            NetworkController &SqpApplication::networkController() noexcept
+            {
+                return *impl->m_NetworkController;
+            }
             TimeController &SqpApplication::timeController() noexcept
             {
                 return *impl->m_TimeController;
             }
             VariableController &SqpApplication::variableController() noexcept
             {
                 return *impl->m_VariableController;
             }
             VisualizationController &SqpApplication::visualizationController() noexcept
             {
                 return *impl->m_VisualizationController;
             }

plugins/amda/CMakeLists.txt +2 -2

             ## amda - CMakeLists.txt
             STRING(TOLOWER ${CMAKE_PROJECT_NAME} LIBRARY_PREFFIX)
             SET(SQPAMDA_LIBRARY_NAME "${LIBRARY_PREFFIX}_amda${DEBUG_SUFFIX}")
             SET(SOURCES_DIR "${CMAKE_CURRENT_SOURCE_DIR}/src")
             SET(INCLUDES_DIR "${CMAKE_CURRENT_SOURCE_DIR}/include")
             SET(RESOURCES_DIR "${CMAKE_CURRENT_SOURCE_DIR}/resources")
             SET(TESTS_RESOURCES_DIR "${CMAKE_CURRENT_SOURCE_DIR}/tests-resources")
             # Include amda directory
             INCLUDE_DIRECTORIES(${INCLUDES_DIR})
             INCLUDE_DIRECTORIES(${RESOURCES_DIR})
             #
             # Find Qt modules
             #
-            SCIQLOP_FIND_QT(Core Widgets)
+            SCIQLOP_FIND_QT(Core Widgets Network)
             #
             # Find dependent libraries
             # ========================
             # sciqlop plugin
             find_package(sciqlop-plugin)
             INCLUDE_DIRECTORIES(${SCIQLOP-PLUGIN_INCLUDE_DIR})
             # sciqlop core
             find_package(sciqlop-core)
             INCLUDE_DIRECTORIES(${SCIQLOP-CORE_INCLUDE_DIR})
             list(APPEND LIBRARIES ${SCIQLOP-CORE_LIBRARIES})
             # sciqlop gui
             find_package(sciqlop-gui)
             INCLUDE_DIRECTORIES(${SCIQLOP-GUI_INCLUDE_DIR})
             list(APPEND LIBRARIES ${SCIQLOP-GUI_LIBRARIES})
             # Description file
             FILE (GLOB_RECURSE PLUGIN_FILE ${RESOURCES_DIR}/amda.json)
             # Resources files
             FILE (GLOB_RECURSE PROJECT_RESOURCES ${RESOURCES_DIR}/*.qrc)
             #
             # Compile the library
             #
             ADD_DEFINITIONS(-DAMDA_LIB)
             FILE (GLOB_RECURSE MODULE_SOURCES
                     ${INCLUDES_DIR}/*.h
                     ${SOURCES_DIR}/*.c
                     ${SOURCES_DIR}/*.cpp
                     ${SOURCES_DIR}/*.h
                     ${PLUGIN_FILE})
             QT5_ADD_RESOURCES(RCC_AMDA
                 ${PROJECT_RESOURCES}
             )
             ADD_LIBRARY(${SQPAMDA_LIBRARY_NAME} ${MODULE_SOURCES} ${RCC_AMDA})
             set_property(TARGET ${SQPAMDA_LIBRARY_NAME} PROPERTY CXX_STANDARD 14)
             set_property(TARGET ${SQPAMDA_LIBRARY_NAME} PROPERTY CXX_STANDARD_REQUIRED ON)
             INSTALL(TARGETS ${SQPAMDA_LIBRARY_NAME}
               RUNTIME DESTINATION ${INSTALL_BINARY_DIR}
               LIBRARY DESTINATION ${INSTALL_PLUGINS_LIBRARY_DIR}
               ARCHIVE DESTINATION ${INSTALL_PLUGINS_LIBRARY_DIR}
             )
             TARGET_LINK_LIBRARIES(${SQPAMDA_LIBRARY_NAME} ${LIBRARIES})
-            qt5_use_modules(${SQPAMDA_LIBRARY_NAME} Core Widgets)
+            qt5_use_modules(${SQPAMDA_LIBRARY_NAME} Core Widgets Network)
             add_dependencies(${SQPAMDA_LIBRARY_NAME} ${SQPPLUGIN_LIBRARY_NAME} ${SQPGUI_LIBRARY_NAME} ${SQPCORE_LIBRARY_NAME})
             # From cmake documentation: http://www.cmake.org/cmake/help/v3.0/manual/cmake-buildsystem.7.html
             # Entries in the COMPILE_DEFINITIONS are prefixed with -D or /D and added to the compile line in an unspecified order.
             # The DEFINE_SYMBOL target property is also added as a compile definition as a special convenience case for SHARED and MODULE library targets
             IF(BUILD_SHARED_LIBS)
                     SET_TARGET_PROPERTIES(${SQPAMDA_LIBRARY_NAME} PROPERTIES COMPILE_DEFINITIONS "SCIQLOP_EXPORT")
             ELSE()
                     TARGET_COMPILE_DEFINITIONS(${SQPAMDA_LIBRARY_NAME} PUBLIC "SCIQLOP_STATIC_LIBRARIES")
             ENDIF()
             # Set the variable to parent scope so that the other projects can copy the
             # dependent shared libraries
             SCIQLOP_SET_TO_PARENT_SCOPE(SQPAMDA_LIBRARY_NAME)
             # Copy extern shared libraries to the lib folder
             SCIQLOP_COPY_TO_TARGET(LIBRARY ${SQPAMDA_LIBRARY_NAME} ${EXTERN_SHARED_LIBRARIES})
             # Add the files to the list of files to be analyzed
             LIST(APPEND CHECKSTYLE_INPUT_FILES ${MODULE_SOURCES})
             SCIQLOP_SET_TO_PARENT_SCOPE(CHECKSTYLE_INPUT_FILES)
             # Vera++ exclusion files
             #LIST(APPEND CHECKSTYLE_EXCLUSION_FILES ${CMAKE_CURRENT_SOURCE_DIR}/vera-exclusions/exclusions.txt)
             SCIQLOP_SET_TO_PARENT_SCOPE(CHECKSTYLE_EXCLUSION_FILES)
             #
             # Compile the tests
             #
             IF(BUILD_TESTS)
                     INCLUDE_DIRECTORIES(${SOURCES_DIR})
                     FILE (GLOB_RECURSE TESTS_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/Test*.cpp)
                     FILE (GLOB_RECURSE TESTS_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/Test*.h)
                     SET( TEST_LIBRARIES ${SQPAMDA_LIBRARY_NAME})
                     FOREACH( testFile ${TESTS_SOURCES} )
                             GET_FILENAME_COMPONENT( testDirectory ${testFile} DIRECTORY )
                             GET_FILENAME_COMPONENT( testName ${testFile} NAME_WE )
                             # Add to the list of sources files all the sources in the same
                             # directory that aren't another test
                             FILE (GLOB currentTestSources
                                     ${testDirectory}/*.c
                                     ${testDirectory}/*.cpp
                                     ${testDirectory}/*.h)
                             LIST (REMOVE_ITEM currentTestSources ${TESTS_SOURCES})
                             # LIST (REMOVE_ITEM currentTestSources ${TESTS_HEADERS})
                             ADD_EXECUTABLE(${testName} ${testFile} ${currentTestSources})
                             set_property(TARGET ${testName} PROPERTY CXX_STANDARD 14)
                             set_property(TARGET ${testName} PROPERTY CXX_STANDARD_REQUIRED ON)
                             TARGET_LINK_LIBRARIES( ${testName} ${TEST_LIBRARIES} )
                             qt5_use_modules(${testName} Test)
                             ADD_TEST( NAME ${testName} COMMAND ${testName} )
                             SCIQLOP_COPY_TO_TARGET(RUNTIME ${testName} ${EXTERN_SHARED_LIBRARIES})
                     ENDFOREACH( testFile )
                     LIST(APPEND testFilesToFormat ${TESTS_SOURCES})
                     LIST(APPEND testFilesToFormat ${TESTS_HEADERS})
                     LIST(APPEND FORMATTING_INPUT_FILES ${testFilesToFormat})
                     SCIQLOP_SET_TO_PARENT_SCOPE(FORMATTING_INPUT_FILES)
                     ADD_DEFINITIONS(-DAMDA_TESTS_RESOURCES_DIR="${TESTS_RESOURCES_DIR}")
             ENDIF(BUILD_TESTS)
             #
             # Set the files that must be formatted by clang-format.
             #
             LIST (APPEND FORMATTING_INPUT_FILES ${MODULE_SOURCES})
             SCIQLOP_SET_TO_PARENT_SCOPE(FORMATTING_INPUT_FILES)
             #
             # Set the directories that doxygen must browse to generate the
             # documentation.
             #
             # Source directories:
             LIST (APPEND DOXYGEN_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/docs")
             LIST (APPEND DOXYGEN_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/src")
             SCIQLOP_SET_TO_PARENT_SCOPE(DOXYGEN_INPUT_DIRS)
             # Source directories to exclude from the documentation generation
             #LIST (APPEND DOXYGEN_EXCLUDE_PATTERNS "${CMAKE_CURRENT_SOURCE_DIR}/path/to/subdir/*")
             SCIQLOP_SET_TO_PARENT_SCOPE(DOXYGEN_EXCLUDE_PATTERNS)
             #
             # Set the directories with the sources to analyze and propagate the
             # modification to the parent scope
             #
             # Source directories to analyze:
             LIST (APPEND ANALYSIS_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/src")
             LIST (APPEND ANALYSIS_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/tests")
             SCIQLOP_SET_TO_PARENT_SCOPE(ANALYSIS_INPUT_DIRS)
             # Source directories to exclude from the analysis
             #LIST (APPEND ANALYSIS_EXCLUDE_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/path/to/subdir")
             SCIQLOP_SET_TO_PARENT_SCOPE(ANALYSIS_EXCLUDE_DIRS)

plugins/amda/src/AmdaPlugin.cpp +29 0

             #include "AmdaPlugin.h"
             #include "AmdaParser.h"
+            #include "AmdaProvider.h"
             #include <DataSource/DataSourceController.h>
             #include <DataSource/DataSourceItem.h>
+            #include <DataSource/DataSourceItemAction.h>
             #include <SqpApplication.h>
             Q_LOGGING_CATEGORY(LOG_AmdaPlugin, "AmdaPlugin")
             namespace {
             /// Name of the data source
             const auto DATA_SOURCE_NAME = QStringLiteral("AMDA");
             /// Path of the file used to generate the data source item for AMDA
             const auto JSON_FILE_PATH = QStringLiteral(":/samples/AmdaSample.json");
+            void associateActions(DataSourceItem &item, const QUuid &dataSourceUid)
+            {
+                if (item.type() == DataSourceItemType::PRODUCT) {
+                    auto itemName = item.name();
+                    item.addAction(std::make_unique<DataSourceItemAction>(
+                        QObject::tr("Load %1 product").arg(itemName),
+                        [itemName, dataSourceUid](DataSourceItem &item) {
+                            if (auto app = sqpApp) {
+                                app->dataSourceController().loadProductItem(dataSourceUid, item);
+                            }
+                        }));
+                }
+                auto count = item.childCount();
+                for (auto i = 0; i < count; ++i) {
+                    if (auto child = item.child(i)) {
+                        associateActions(*child, dataSourceUid);
+                    }
+                }
+            }
             } // namespace
             void AmdaPlugin::initialize()
             {
                 if (auto app = sqpApp) {
                     // Registers to the data source controller
                     auto &dataSourceController = app->dataSourceController();
                     auto dataSourceUid = dataSourceController.registerDataSource(DATA_SOURCE_NAME);
                     // Sets data source tree
                     if (auto dataSourceItem = AmdaParser::readJson(JSON_FILE_PATH)) {
+                        associateActions(*dataSourceItem, dataSourceUid);
                         dataSourceController.setDataSourceItem(dataSourceUid, std::move(dataSourceItem));
                     }
                     else {
                         qCCritical(LOG_AmdaPlugin()) << tr("No data source item could be generated for AMDA");
                     }
+                    // Sets data provider
+                    dataSourceController.setDataProvider(dataSourceUid, std::make_unique<AmdaProvider>());
                 }
                 else {
                     qCWarning(LOG_AmdaPlugin()) << tr("Can't access to SciQlop application");
                 }
             }

plugins/mockplugin/include/CosinusProvider.h +3 -5

             #ifndef SCIQLOP_COSINUSPROVIDER_H
             #define SCIQLOP_COSINUSPROVIDER_H
             #include "MockPluginGlobal.h"
             #include <Data/IDataProvider.h>
             #include <QLoggingCategory>
             Q_DECLARE_LOGGING_CATEGORY(LOG_CosinusProvider)
             /**
              * @brief The CosinusProvider class is an example of how a data provider can generate data
              */
             class SCIQLOP_MOCKPLUGIN_EXPORT CosinusProvider : public IDataProvider {
             public:
-                /// @sa IDataProvider::retrieveData()
+                void requestDataLoading(QUuid token, const QVector<SqpDateTime> &dateTimeList) override;
-                std::shared_ptr<IDataSeries>
-                retrieveData(const DataProviderParameters &parameters) const override;
-                void requestDataLoading(const QVector<SqpDateTime> &dateTimeList) override;
             private:
+                /// @sa IDataProvider::retrieveData()
+                std::shared_ptr<IDataSeries> retrieveData(const DataProviderParameters &parameters) const;
                 std::shared_ptr<IDataSeries> retrieveDataSeries(const SqpDateTime &dateTime);
             };
             #endif // SCIQLOP_COSINUSPROVIDER_H

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

             #include "CosinusProvider.h"
             #include <Data/DataProviderParameters.h>
             #include <Data/ScalarSeries.h>
             #include <cmath>
             #include <QDateTime>
             #include <QThread>
             Q_LOGGING_CATEGORY(LOG_CosinusProvider, "CosinusProvider")
             std::shared_ptr<IDataSeries>
             CosinusProvider::retrieveData(const DataProviderParameters &parameters) const
             {
                 auto dateTime = parameters.m_Time;
                 auto dataIndex = 0;
                 // Gets the timerange from the parameters
                 double freq = 100.0;
                 double start = dateTime.m_TStart * freq; // 100 htz
                 double end = dateTime.m_TEnd * freq;     // 100 htz
                 // We assure that timerange is valid
                 if (end < start) {
                     std::swap(start, end);
                 }
                 // Generates scalar series containing cosinus values (one value per second)
                 auto scalarSeries
                     = std::make_shared<ScalarSeries>(end - start, Unit{QStringLiteral("t"), true}, Unit{});
                 for (auto time = start; time < end; ++time, ++dataIndex) {
                     const auto timeOnFreq = time / freq;
                     scalarSeries->setData(dataIndex, timeOnFreq, std::cos(timeOnFreq));
                 }
                 return scalarSeries;
             }
-            void CosinusProvider::requestDataLoading(const QVector<SqpDateTime> &dateTimeList)
+            void CosinusProvider::requestDataLoading(QUuid token, const QVector<SqpDateTime> &dateTimeList)
             {
                 qCDebug(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});
-                    emit dataProvided(scalarSeries, dateTime);
+                    emit dataProvided(token, scalarSeries, 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