GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r391:4e032e665b92

Merge pull request from SCIQLOP-Initialisation develop...

leroux -

r391:4e032e665b92

parent child

Context file:

r391:4e032e665b92

Collapse all files

app/vera-exclusions/exclusions.txt +2 0

             # Ignore false positive relative to App macro
             \.h:\d+:.IPSIS_S04.*found: Ui
+            # Ignore false positive relative to macros
+            Main\.cpp:\d+:.*IPSIS_S04_VARIABLE.*found: (__ppc64__)
  No newline at end of file

core/CMakeLists.txt +2 -2

             ## core - CMakeLists.txt
             STRING(TOLOWER ${CMAKE_PROJECT_NAME} LIBRARY_PREFFIX)
             SET(SQPCORE_LIBRARY_NAME "${LIBRARY_PREFFIX}_core${DEBUG_SUFFIX}")
             SET(SOURCES_DIR "${CMAKE_CURRENT_SOURCE_DIR}/src/")
             SET(INCLUDES_DIR "${CMAKE_CURRENT_SOURCE_DIR}/include/")
             # Include core directory
             include_directories("${INCLUDES_DIR}")
             # Set a variable to display a warning in the version files.
             SET(SCIQLOP_CMAKE_GENERATION_WARNING "DON'T CHANGE THIS FILE. AUTOGENERATED BY CMAKE.")
             # Generate the version file from the cmake version variables. The version
             # variables are defined in the cmake/sciqlop_version.cmake file.
             CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/resources/Version.h.in"
                     "${INCLUDES_DIR}/Version.h")
             CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/resources/Version.cpp.in"
             	"${SOURCES_DIR}/Version.cpp")
             # Find dependent modules
             find_package(sciqlop-plugin)
             INCLUDE_DIRECTORIES(${SCIQLOP-PLUGIN_INCLUDE_DIR})
             #
             # Find Qt modules
             #
-            SCIQLOP_FIND_QT(Core)
+            SCIQLOP_FIND_QT(Core Network)
             #
             # Compile the library library
             #
             FILE (GLOB_RECURSE MODULE_SOURCES
                     ${INCLUDES_DIR}/*.h
                     ${SOURCES_DIR}/*.c
                     ${SOURCES_DIR}/*.cpp
             	${SOURCES_DIR}/*.h)
             ADD_LIBRARY(${SQPCORE_LIBRARY_NAME} ${MODULE_SOURCES})
             set_property(TARGET ${SQPCORE_LIBRARY_NAME} PROPERTY CXX_STANDARD 14)
             set_property(TARGET ${SQPCORE_LIBRARY_NAME} PROPERTY CXX_STANDARD_REQUIRED ON)
             TARGET_LINK_LIBRARIES(${SQPCORE_LIBRARY_NAME})
-            qt5_use_modules(${SQPCORE_LIBRARY_NAME} Core)
+            qt5_use_modules(${SQPCORE_LIBRARY_NAME} Core Network)
             INSTALL(TARGETS ${SQPCORE_LIBRARY_NAME}
               RUNTIME DESTINATION ${INSTALL_BINARY_DIR}
               LIBRARY DESTINATION ${INSTALL_LIBRARY_DIR}
               ARCHIVE DESTINATION ${INSTALL_LIBRARY_DIR}
             )
             # 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(${SQPCORE_LIBRARY_NAME} PROPERTIES COMPILE_DEFINITIONS "SCIQLOP_EXPORT")
             ELSE()
                     TARGET_COMPILE_DEFINITIONS(${SQPCORE_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(SQPCORE_LIBRARY_NAME)
             # Copy extern shared libraries to the lib folder
             SCIQLOP_COPY_TO_TARGET(LIBRARY ${SQPCORE_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 ${SQPCORE_LIBRARY_NAME})
                     SET(TARGETS_COV)
             	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})
                             set(Coverage_NAME ${testName})
                             if(UNIX)
                                 SETUP_TARGET_FOR_COVERAGE(TARGET ${testName}_coverage OUTPUT ${testFile}-path NAME ${testFile} EXECUTABLE ${testName})
                                 LIST( APPEND TARGETS_COV ${testName}_coverage)
                             endif(UNIX)
                     ENDFOREACH( testFile )
                     add_custom_target(coverage)
                     FOREACH( target_cov ${TARGETS_COV} )
                         add_custom_command(TARGET coverage PRE_BUILD COMMAND make ${target_cov})
                     ENDFOREACH( target_cov )
             	LIST(APPEND testFilesToFormat ${TESTS_SOURCES})
             	LIST(APPEND testFilesToFormat ${TESTS_HEADERS})
             	LIST(APPEND FORMATTING_INPUT_FILES ${testFilesToFormat})
                     SCIQLOP_SET_TO_PARENT_SCOPE(FORMATTING_INPUT_FILES)
             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)

core/include/Data/IDataProvider.h +22 -2

             #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;
+            class QNetworkReply;
+            class QNetworkRequest;
             /**
              * @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 void requestDataLoading(QUuid token, const QVector<SqpDateTime> &dateTimeList) = 0;
+                /**
+                 * @brief requestDataLoading provide datas for the data identified by identifier for all
+                 * SqpDateTime of dateTimeList
+                 */
+                virtual void requestDataLoading(QUuid identifier, const QVector<SqpDateTime> &dateTimeList) = 0;
             signals:
-                void dataProvided(QUuid token, std::shared_ptr<IDataSeries> dateSerie,
+                /**
+                 * @brief dataProvided send dataSeries under dateTime and that corresponds of the data
+                 * identified by identifier
+                 */
+                void dataProvided(QUuid identifier, std::shared_ptr<IDataSeries> dateSerie,
                                   const SqpDateTime &dateTime);
+                /**
+                 * @brief requestConstructed send a request for the data identified by identifier
+                 * @callback is the methode call by the reply of the request when it is finished.
+                 */
+                void requestConstructed(const QNetworkRequest &request, QUuid identifier,
+                                        std::function<void(QNetworkReply *, QUuid)> callback);
             };
             // Required for using shared_ptr in signals/slots
             SCIQLOP_REGISTER_META_TYPE(IDATAPROVIDER_PTR_REGISTRY, std::shared_ptr<IDataProvider>)
+            SCIQLOP_REGISTER_META_TYPE(IDATAPROVIDER_FUNCTION_REGISTRY,
+                                       std::function<void(QNetworkReply *, QUuid)>)
             #endif // SCIQLOP_IDATAPROVIDER_H

core/include/Network/NetworkController.h +14 -1

             #ifndef SCIQLOP_NETWORKCONTROLLER_H
             #define SCIQLOP_NETWORKCONTROLLER_H
             #include <QLoggingCategory>
             #include <QObject>
+            #include <QUuid>
             #include <Common/spimpl.h>
+            #include <functional>
             Q_DECLARE_LOGGING_CATEGORY(LOG_NetworkController)
+            class QNetworkReply;
+            class QNetworkRequest;
             /**
              * @brief The NetworkController class aims to handle all network connection of SciQlop.
              */
             class NetworkController : public QObject {
                 Q_OBJECT
             public:
                 explicit NetworkController(QObject *parent = 0);
                 void initialize();
                 void finalize();
+            public slots:
+                void onProcessRequested(const QNetworkRequest &request, QUuid identifier,
+                                        std::function<void(QNetworkReply *, QUuid)> callback);
+                void onReplyCanceled(QUuid identifier);
+            signals:
+                void replyFinished(QNetworkReply *reply, QUuid identifier);
+                void replyDownloadProgress(QUuid identifier);
             private:
                 void waitForFinish();
                 class NetworkControllerPrivate;
                 spimpl::unique_impl_ptr<NetworkControllerPrivate> impl;
             };
             #endif // SCIQLOP_NETWORKCONTROLLER_H

core/src/Network/NetworkController.cpp +55 0

@@ -1,33 +1,88
1	#include "Network/NetworkController.h"	1	#include "Network/NetworkController.h"
2		2
3	#include <QMutex>	3	#include <QMutex>
		4	#include <QNetworkAccessManager>
		5	#include <QNetworkReply>
		6	#include <QNetworkRequest>
4	#include <QThread>	7	#include <QThread>
5		8
		9	#include <unordered_map>
		10
6	Q_LOGGING_CATEGORY(LOG_NetworkController, "NetworkController")	11	Q_LOGGING_CATEGORY(LOG_NetworkController, "NetworkController")
7		12
8	struct NetworkController::NetworkControllerPrivate {	13	struct NetworkController::NetworkControllerPrivate {
9	explicit NetworkControllerPrivate(NetworkController *parent) : m_WorkingMutex{} {}	14	explicit NetworkControllerPrivate(NetworkController *parent) : m_WorkingMutex{} {}
10	QMutex m_WorkingMutex;	15	QMutex m_WorkingMutex;
		16
		17	std::unordered_map<QNetworkReply *, QUuid> m_NetworkReplyToVariableId;
		18	std::unique_ptr<QNetworkAccessManager> m_AccessManager{nullptr};
11	};	19	};
12		20
13	NetworkController::NetworkController(QObject *parent)	21	NetworkController::NetworkController(QObject *parent)
14	: QObject(parent), impl{spimpl::make_unique_impl<NetworkControllerPrivate>(this)}	22	: QObject(parent), impl{spimpl::make_unique_impl<NetworkControllerPrivate>(this)}
15	{	23	{
16	}	24	}
17		25
		26	void NetworkController::onProcessRequested(const QNetworkRequest &request, QUuid identifier,
		27	std::function<void(QNetworkReply *, QUuid)> callback)
		28	{
		29	qCDebug(LOG_NetworkController()) << tr("NetworkController registered")
		30	<< QThread::currentThread();
		31	auto reply = impl->m_AccessManager->get(request);
		32
		33	// Store the couple reply id
		34	impl->m_NetworkReplyToVariableId[reply] = identifier;
		35
		36	auto onReplyFinished = [reply, this, identifier, callback]() {
		37
		38	qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyFinished")
		39	<< QThread::currentThread();
		40	auto it = impl->m_NetworkReplyToVariableId.find(reply);
		41	if (it != impl->m_NetworkReplyToVariableId.cend()) {
		42	callback(reply, identifier);
		43	}
		44	};
		45
		46	auto onReplyDownloadProgress = [reply, this]() {
		47
		48	qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyDownloadProgress")
		49	<< QThread::currentThread();
		50	auto it = impl->m_NetworkReplyToVariableId.find(reply);
		51	if (it != impl->m_NetworkReplyToVariableId.cend()) {
		52	emit this->replyDownloadProgress(it->second);
		53	}
		54	};
		55
		56
		57	connect(reply, &QNetworkReply::finished, this, onReplyFinished);
		58	connect(reply, &QNetworkReply::downloadProgress, this, onReplyDownloadProgress);
		59	}
		60
18	void NetworkController::initialize()	61	void NetworkController::initialize()
19	{	62	{
20	qCDebug(LOG_NetworkController()) << tr("NetworkController init") << QThread::currentThread();	63	qCDebug(LOG_NetworkController()) << tr("NetworkController init") << QThread::currentThread();
21	impl->m_WorkingMutex.lock();	64	impl->m_WorkingMutex.lock();
		65	impl->m_AccessManager = std::make_unique<QNetworkAccessManager>();
22	qCDebug(LOG_NetworkController()) << tr("NetworkController init END");	66	qCDebug(LOG_NetworkController()) << tr("NetworkController init END");
23	}	67	}
24		68
25	void NetworkController::finalize()	69	void NetworkController::finalize()
26	{	70	{
27	impl->m_WorkingMutex.unlock();	71	impl->m_WorkingMutex.unlock();
28	}	72	}
29		73
		74	void NetworkController::onReplyCanceled(QUuid identifier)
		75	{
		76	auto findReply = [identifier](const auto &entry) { return identifier == entry.second; };
		77
		78	auto end = impl->m_NetworkReplyToVariableId.cend();
		79	auto it = std::find_if(impl->m_NetworkReplyToVariableId.cbegin(), end, findReply);
		80	if (it != end) {
		81	it->first->abort();
		82	}
		83	}
		84
30	void NetworkController::waitForFinish()	85	void NetworkController::waitForFinish()
31	{	86	{
32	QMutexLocker locker{&impl->m_WorkingMutex};	87	QMutexLocker locker{&impl->m_WorkingMutex};
33	}	88	}

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

             #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")
             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;
+                std::unordered_map<std::shared_ptr<Variable>, QUuid> m_VariableToIdentifier;
             };
             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();
+                    auto identifier = QUuid::createUuid();
                     // store the provider
                     impl->m_VariableToProviderMap[newVariable] = provider;
-                    impl->m_VariableToToken[newVariable] = token;
+                    impl->m_VariableToIdentifier[newVariable] = identifier;
                     auto addDateTimeAcquired = [ this, varW = std::weak_ptr<Variable>{newVariable} ](
-                        QUuid token, auto dataSeriesAcquired, auto dateTimeToPutInCache)
+                        QUuid identifier, auto dataSeriesAcquired, auto dateTimeToPutInCache)
                     {
                         if (auto variable = varW.lock()) {
-                            auto varToken = impl->m_VariableToToken.at(variable);
+                            auto varIdentifier = impl->m_VariableToIdentifier.at(variable);
-                            if (varToken == token) {
+                            if (varIdentifier == identifier) {
                                 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);
+                        auto identifier = impl->m_VariableToIdentifier.at(variable);
                         impl->m_VariableToProviderMap.at(variable)->requestDataLoading(
-                            token, std::move(dateTimeListNotInCache));
+                            identifier, 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};
             }

core/vera-exclusions/exclusions.txt +1 0

             # On ignore toutes les règles vera++ pour le fichier spimpl
             Common/spimpl\.h:\d+:.*
             # Ignore false positive relative to two class definitions in a same file
             DataSourceItem\.h:\d+:.*IPSIS_S01.*
             # Ignore false positive relative to a template class
             ArrayData\.h:\d+:.*IPSIS_S04_VARIABLE.*found: (D)
             ArrayData\.h:\d+:.*IPSIS_S06.*found: (D)
             ArrayData\.h:\d+:.*IPSIS_S06.*found: (Dim)
+            DataSeries\.h:\d+:.*IPSIS_S04_VARIABLE.*
             # Ignore false positive relative to an alias
             DataSourceItemAction\.h:\d+:.*IPSIS_S06.*found: (ExecuteFunction)
             # Ignore false positive relative to unnamed namespace
             VariableController\.cpp:\d+:.*IPSIS_F13.*

gui/src/SqpApplication.cpp +1 -1

             #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>()}
                 {
                     // /////////////////////////////// //
                     // 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");
+                qCDebug(LOG_SqpApplication()) << tr("SqpApplication construction") << QThread::currentThread();
                 connect(&impl->m_DataSourceControllerThread, &QThread::started,
                         impl->m_DataSourceController.get(), &DataSourceController::initialize);
                 connect(&impl->m_DataSourceControllerThread, &QThread::finished,
                         impl->m_DataSourceController.get(), &DataSourceController::finalize);
                 connect(&impl->m_NetworkControllerThread, &QThread::started, impl->m_NetworkController.get(),
                         &NetworkController::initialize);
                 connect(&impl->m_NetworkControllerThread, &QThread::finished, impl->m_NetworkController.get(),
                         &NetworkController::finalize);
                 connect(&impl->m_VariableControllerThread, &QThread::started, impl->m_VariableController.get(),
                         &VariableController::initialize);
                 connect(&impl->m_VariableControllerThread, &QThread::finished, impl->m_VariableController.get(),
                         &VariableController::finalize);
                 connect(&impl->m_VisualizationControllerThread, &QThread::started,
                         impl->m_VisualizationController.get(), &VisualizationController::initialize);
                 connect(&impl->m_VisualizationControllerThread, &QThread::finished,
                         impl->m_VisualizationController.get(), &VisualizationController::finalize);
                 impl->m_DataSourceControllerThread.start();
                 impl->m_NetworkControllerThread.start();
                 impl->m_VariableControllerThread.start();
                 impl->m_VisualizationControllerThread.start();
             }
             SqpApplication::~SqpApplication()
             {
             }
             void SqpApplication::initialize()
             {
             }
             DataSourceController &SqpApplication::dataSourceController() noexcept
             {
                 return *impl->m_DataSourceController;
             }
             NetworkController &SqpApplication::networkController() noexcept
             {
                 return *impl->m_NetworkController;
             }
             TimeController &SqpApplication::timeController() noexcept
             {
                 return *impl->m_TimeController;
             }
             VariableController &SqpApplication::variableController() noexcept
             {
                 return *impl->m_VariableController;
             }
             VisualizationController &SqpApplication::visualizationController() noexcept
             {
                 return *impl->m_VisualizationController;
             }

plugins/amda/include/AmdaProvider.h +7 -5

             #ifndef SCIQLOP_AMDAPROVIDER_H
             #define SCIQLOP_AMDAPROVIDER_H
             #include "AmdaGlobal.h"
             #include <Common/spimpl.h>
             #include <Data/IDataProvider.h>
             #include <QLoggingCategory>
             Q_DECLARE_LOGGING_CATEGORY(LOG_AmdaProvider)
+            class QNetworkReply;
             /**
              * @brief The AmdaProvider class is an example of how a data provider can generate data
              */
             class SCIQLOP_AMDA_EXPORT AmdaProvider : public IDataProvider {
             public:
                 explicit AmdaProvider();
                 void requestDataLoading(QUuid token, const QVector<SqpDateTime> &dateTimeList) override;
             private:
-                void retrieveData(QUuid token, const DataProviderParameters &parameters) const;
+                void retrieveData(QUuid token, const DataProviderParameters &parameters);
                 class AmdaProviderPrivate;
                 spimpl::unique_impl_ptr<AmdaProviderPrivate> impl;
-            private slots:
+                // private slots:
-                void httpFinished() noexcept;
+                //    void httpFinished(QNetworkReply *reply, QUuid dataId) noexcept;
-                void httpDownloadFinished() noexcept;
+                //    void httpDownloadFinished(QNetworkReply *reply, QUuid dataId) noexcept;
-                void httpDownloadReadyRead() noexcept;
+                //    void httpDownloadReadyRead(QNetworkReply *reply, QUuid dataId) noexcept;
             };
             #endif // SCIQLOP_AMDAPROVIDER_H

plugins/amda/src/AmdaProvider.cpp +55 -61

             #include "AmdaProvider.h"
             #include "AmdaResultParser.h"
             #include <Data/DataProviderParameters.h>
+            #include <Network/NetworkController.h>
+            #include <SqpApplication.h>
+            #include <Variable/Variable.h>
             #include <QNetworkAccessManager>
             #include <QNetworkReply>
             #include <QTemporaryFile>
+            #include <QThread>
             Q_LOGGING_CATEGORY(LOG_AmdaProvider, "AmdaProvider")
             namespace {
             /// URL format for a request on AMDA server. The parameters are as follows:
             /// - %1: start date
             /// - %2: end date
             /// - %3: parameter id
             const auto AMDA_URL_FORMAT = QStringLiteral(
                 "http://amda.irap.omp.eu/php/rest/"
                 "getParameter.php?startTime=%1&stopTime=%2&parameterID=%3&sampling=60&outputFormat=ASCII&"
                 "timeFormat=ISO8601&gzip=0");
             /// Dates format passed in the URL (e.g 2013-09-23T09:00)
             const auto AMDA_TIME_FORMAT = QStringLiteral("yyyy-MM-ddThh:ss");
             /// Formats a time to a date that can be passed in URL
             QString dateFormat(double sqpDateTime) noexcept
             {
                 auto dateTime = QDateTime::fromMSecsSinceEpoch(sqpDateTime * 1000.);
                 return dateTime.toString(AMDA_TIME_FORMAT);
             }
             } // namespace
             struct AmdaProvider::AmdaProviderPrivate {
                 DataProviderParameters m_Params{};
                 std::unique_ptr<QNetworkAccessManager> m_AccessManager{nullptr};
                 QNetworkReply *m_Reply{nullptr};
-                std::unique_ptr<QTemporaryFile> m_File{nullptr};
+                //    std::unique_ptr<QTemporaryFile> m_File{nullptr};
                 QUuid m_Token;
             };
             AmdaProvider::AmdaProvider() : impl{spimpl::make_unique_impl<AmdaProviderPrivate>()}
             {
+                qCDebug(LOG_NetworkController()) << tr("AmdaProvider::AmdaProvider")
+                                                 << QThread::currentThread();
+                if (auto app = sqpApp) {
+                    auto &networkController = app->networkController();
+                    connect(this, &AmdaProvider::requestConstructed, &networkController,
+                            &NetworkController::onProcessRequested);
+                }
             }
             void AmdaProvider::requestDataLoading(QUuid token, const QVector<SqpDateTime> &dateTimeList)
             {
                 // NOTE: Try to use multithread if possible
                 for (const auto &dateTime : dateTimeList) {
                     retrieveData(token, DataProviderParameters{dateTime});
                 }
             }
-            void AmdaProvider::retrieveData(QUuid token, const DataProviderParameters &parameters) const
+            void AmdaProvider::retrieveData(QUuid token, const DataProviderParameters &parameters)
             {
                 // /////////// //
                 // Creates URL //
                 // /////////// //
                 auto startDate = dateFormat(parameters.m_Time.m_TStart);
                 auto endDate = dateFormat(parameters.m_Time.m_TEnd);
                 auto productId = QStringLiteral("imf(0)");
                 auto url = QUrl{QString{AMDA_URL_FORMAT}.arg(startDate, endDate, productId)};
-                // //////////////// //
+                auto tempFile = std::make_shared<QTemporaryFile>();
-                // Executes request //
-                // //////////////// //
-                impl->m_Token = token;
-                impl->m_Params = parameters;
-                impl->m_AccessManager = std::make_unique<QNetworkAccessManager>();
-                impl->m_Reply = impl->m_AccessManager->get(QNetworkRequest{url});
-                connect(impl->m_Reply, &QNetworkReply::finished, this, &AmdaProvider::httpFinished);
-            void AmdaProvider::httpFinished() noexcept
+                // LAMBDA
+                auto httpDownloadFinished = [this, tempFile](QNetworkReply *reply, QUuid dataId) noexcept {
-                // ////////////////////// //
-                // Gets download file url //
-                // ////////////////////// //
-                auto downloadFileUrl = QUrl{QString{impl->m_Reply->readAll()}};
-                // ///////////////////////////////////// //
-                // Executes request for downloading file //
-                // ///////////////////////////////////// //
-                // Deletes old reply
-                impl->m_Reply->deleteLater();
-                impl->m_Reply = nullptr;
-                // Creates destination file
-                impl->m_File = std::make_unique<QTemporaryFile>();
-                if (impl->m_File->open()) {
-                    qCDebug(LOG_AmdaProvider()) << "Temp file: " << impl->m_File->fileName();
-                    // Executes request
-                    impl->m_AccessManager = std::make_unique<QNetworkAccessManager>();
-                    impl->m_Reply = impl->m_AccessManager->get(QNetworkRequest{downloadFileUrl});
-                    connect(impl->m_Reply, &QNetworkReply::finished, this,
-                            &AmdaProvider::httpDownloadReadyRead);
-                    connect(impl->m_Reply, &QNetworkReply::finished, this, &AmdaProvider::httpDownloadFinished);
-            void AmdaProvider::httpDownloadFinished() noexcept
+                    if (tempFile) {
+                        auto replyReadAll = reply->readAll();
-                if (impl->m_File) {
+                        if (!replyReadAll.isEmpty()) {
-                    impl->m_File->close();
+                            tempFile->write(replyReadAll);
+                        }
+                        tempFile->close();
-                    // Parse results file
+                        // Parse results file
-                    if (auto dataSeries = AmdaResultParser::readTxt(impl->m_File->fileName())) {
+                        if (auto dataSeries = AmdaResultParser::readTxt(tempFile->fileName())) {
-                        emit dataProvided(impl->m_Token, dataSeries, impl->m_Params.m_Time);
+                            emit dataProvided(impl->m_Token, dataSeries, impl->m_Params.m_Time);
+                        }
-                    else {
+                        else {
-                        /// @todo ALX : debug
+                            /// @todo ALX : debug
+                        }
                     }
-                    impl->m_File = nullptr;
+                    // Deletes reply
+                    reply->deleteLater();
+                    reply = nullptr;
+                };
+                auto httpFinishedLambda = [this, httpDownloadFinished, tempFile](QNetworkReply *reply,
+                                                                                 QUuid dataId) noexcept {
-                // Deletes reply
+                    auto downloadFileUrl = QUrl{QString{reply->readAll()}};
-                impl->m_Reply->deleteLater();
+                    // Deletes old reply
-                impl->m_Reply = nullptr;
+                    reply->deleteLater();
-            void AmdaProvider::httpDownloadReadyRead() noexcept
+                    // Executes request for downloading file //
-                if (impl->m_File) {
+                    // Creates destination file
-                    impl->m_File->write(impl->m_Reply->readAll());
+                    if (tempFile->open()) {
+                        // Executes request
+                        emit requestConstructed(QNetworkRequest{downloadFileUrl}, dataId, httpDownloadFinished);
+                    }
+                };
+                // //////////////// //
+                // Executes request //
+                // //////////////// //
+                impl->m_Token = token;
+                impl->m_Params = parameters;
+                emit requestConstructed(QNetworkRequest{url}, token, httpFinishedLambda);
             }

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