GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r1155:2e3c32b33d04

Merge branch 'feature/CompilFlagServer' into develop

Alexandre Leroux -

r1155:2e3c32b33d04

parent child

Context file:

r1155:2e3c32b33d04

Collapse all files

plugins/amda/include/AmdaServer.h created 644 +35 0

@@ -0,0 +1,35
	1	#ifndef SCIQLOP_AMDASERVER_H
	2	#define SCIQLOP_AMDASERVER_H
	3
	4	#include <QLoggingCategory>
	5
	6	#include <memory>
	7
	8	Q_DECLARE_LOGGING_CATEGORY(LOG_AmdaServer)
	9
	10	// Directive used to determine the active AMDA server
	11	#ifndef SCIQLOP_AMDA_SERVER
	12	#define SCIQLOP_AMDA_SERVER "default"
	13	#endif
	14
	15	/**
	16	* @brief The AmdaServer class represents the server used to retrieve AMDA data (singleton).
	17	*
	18	* The server instance is initialized at compile time, as defined by the AMDA_SERVER value.
	19	*/
	20	class AmdaServer {
	21	public:
	22	/// @return the unique instance of the AMDA server
	23	static AmdaServer &instance();
	24
	25	virtual ~AmdaServer() noexcept = default;
	26
	27	/// @return the name of the server
	28	virtual QString name() const = 0;
	29
	30	/// @param properties used to generate url
	31	/// @return the url of the server (used to retrieve data)
	32	virtual QString url(const QVariantHash &properties = {}) const = 0;
	33	};
	34
	35	#endif // SCIQLOP_AMDASERVER_H

plugins/amda/src/AmdaServer.cpp created 644 +99 0

@@ -0,0 +1,99
	1	#include "AmdaServer.h"
	2
	3	#include "AmdaDefs.h"
	4
	5	Q_LOGGING_CATEGORY(LOG_AmdaServer, "AmdaServer")
	6
	7	namespace {
	8
	9	/// URL of the default AMDA server
	10	const auto AMDA_DEFAULT_SERVER_URL = QStringLiteral("amda.irap.omp.eu");
	11
	12	/// URL of the AMDA test server
	13	const auto AMDA_TEST_SERVER_URL = QStringLiteral("amdatest.irap.omp.eu");
	14
	15	/// Port used for local server
	16	const auto AMDA_LOCAL_SERVER_PORT = 6543;
	17
	18	/// URL of the local server
	19	const auto AMDA_LOCAL_SERVER_URL
	20	= QString{"localhost:%1"}.arg(QString::number(AMDA_LOCAL_SERVER_PORT));
	21
	22	/// Default AMDA server
	23	struct AmdaDefaultServer : public AmdaServer {
	24	public:
	25	QString name() const override { return QStringLiteral("AMDA (default)"); }
	26	QString url(const QVariantHash &properties) const override
	27	{
	28	Q_UNUSED(properties);
	29	return AMDA_DEFAULT_SERVER_URL;
	30	}
	31	};
	32
	33	/// Alternative AMDA server (tests)
	34	struct AmdaTestServer : public AmdaServer {
	35	public:
	36	QString name() const override { return QStringLiteral("AMDA (test)"); }
	37	QString url(const QVariantHash &properties) const override
	38	{
	39	Q_UNUSED(properties);
	40	return AMDA_TEST_SERVER_URL;
	41	}
	42	};
	43
	44	/// Hybrid AMDA server: use both of default and test server.
	45	/// The server used is relative to each product for which to retrieve url, according to its "server"
	46	/// property
	47	struct AmdaHybridServer : public AmdaServer {
	48	public:
	49	QString name() const override { return QStringLiteral("AMDA (hybrid)"); }
	50	QString url(const QVariantHash &properties) const override
	51	{
	52	// Reads "server" property to determine which server url to use
	53	auto server = properties.value(AMDA_SERVER_KEY).toString();
	54	return server == QString{"amdatest"} ? AMDA_TEST_SERVER_URL : AMDA_DEFAULT_SERVER_URL;
	55	}
	56	};
	57
	58	/// Local AMDA server: use local python server to simulate AMDA requests
	59	struct AmdaLocalServer : public AmdaServer {
	60	public:
	61	QString name() const override { return AMDA_LOCAL_SERVER_URL; }
	62	QString url(const QVariantHash &properties) const override
	63	{
	64	Q_UNUSED(properties);
	65	return AMDA_LOCAL_SERVER_URL;
	66	}
	67	};
	68
	69	/// @return an AMDA server instance created from the name of the server passed in parameter. If the
	70	/// name does not match any known server, a default server instance is created
	71	std::unique_ptr<AmdaServer> createInstance(const QString &server)
	72	{
	73	if (server == QString{"amdatest"}) {
	74	return std::make_unique<AmdaTestServer>();
	75	}
	76	else if (server == QString{"hybrid"}) {
	77	return std::make_unique<AmdaHybridServer>();
	78	}
	79	else if (server == QString{"localhost"}) {
	80	return std::make_unique<AmdaLocalServer>();
	81	}
	82	else {
	83	if (server != QString{"default"}) {
	84	qCWarning(LOG_AmdaServer())
	85	<< QObject::tr("Unknown server '%1': default AMDA server will be used").arg(server);
	86	}
	87
	88	return std::make_unique<AmdaDefaultServer>();
	89	}
	90	}
	91
	92	} // namespace
	93
	94	AmdaServer &AmdaServer::instance()
	95	{
	96	// Creates instance depending on the SCIQLOP_AMDA_SERVER value at compile time
	97	static auto instance = createInstance(SCIQLOP_AMDA_SERVER);
	98	return *instance;
	99	}

plugins/amda/vera-exclusions/exclusions.txt created 644 +5 0

@@ -0,0 +1,5
	1	AmdaResultParser\.h:\d+:.IPSIS_S01.
	2	AmdaResultParserHelper\.h:\d+:.IPSIS_S01.
	3
	4	AmdaProvider\.cpp:\d+:.IPSIS_S04_VARIABLE.found: QStringLiteral
	5	AmdaResultParserHelper\.cpp:\d+:.IPSIS_S04_VARIABLE.found: QT_VERSION_CHECK No newline at end of file

cmake/sciqlop_applications.cmake +9 0

             if(BUILD_TESTS)
                 INCLUDE ("cmake/sciqlop_code_coverage.cmake")
                 APPEND_COVERAGE_COMPILER_FLAGS()
             endif(BUILD_TESTS)
             #
             # Compile the diffents modules
             #
             set(sciqlop-plugin_DIR "${CMAKE_SOURCE_DIR}/plugin/cmake")
             set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${sciqlop-plugin_DIR}")
             ADD_SUBDIRECTORY("${CMAKE_SOURCE_DIR}/plugin")
             set(sciqlop-core_DIR "${CMAKE_SOURCE_DIR}/core/cmake")
             set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${sciqlop-core_DIR}")
             ADD_SUBDIRECTORY("${CMAKE_SOURCE_DIR}/core")
             set(sciqlop-gui_DIR "${CMAKE_SOURCE_DIR}/gui/cmake")
             set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${sciqlop-gui_DIR}")
             ADD_SUBDIRECTORY("${CMAKE_SOURCE_DIR}/gui")
             ADD_SUBDIRECTORY("${CMAKE_SOURCE_DIR}/app")
             OPTION (BUILD_PLUGINS "Build the plugins" OFF)
             IF(BUILD_PLUGINS)
                 set(sciqlop-mockplugin_DIR "${CMAKE_SOURCE_DIR}/plugins/mockplugin/cmake")
                 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${sciqlop-mockplugin_DIR}")
                 ADD_SUBDIRECTORY("${CMAKE_SOURCE_DIR}/plugins/mockplugin")
+                # Sets AMDA server that will be used during execution.
+                # Available values are:
+                # - "default": default AMDA server
+                # - "amdatest": AMDA test server
+                # - "hybrid": use both the default server and the test server (the server used is relative to each product, according to its "server" property in the JSON file)
+            	# - "localhost": use local AMDA server
+                # Any other value will lead to the use of the default server
+                ADD_DEFINITIONS(-DSCIQLOP_AMDA_SERVER="hybrid")
                 set(sciqlop-amda_DIR "${CMAKE_SOURCE_DIR}/plugins/amda/cmake")
                 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${sciqlop-amda_DIR}")
                 ADD_SUBDIRECTORY("${CMAKE_SOURCE_DIR}/plugins/amda")
                 # Temporary target to copy to plugins dir
                 find_package(sciqlop-mockplugin)
                 find_package(sciqlop-amda)
                 ADD_CUSTOM_TARGET(plugins
                     COMMAND ${CMAKE_COMMAND} -E copy ${SCIQLOP-MOCKPLUGIN_LIBRARIES} "${LIBRARY_OUTPUT_PATH}/plugins/${SCIQLOP-MOCKPLUGIN_LIBRARIES_NAME}"
                     COMMAND ${CMAKE_COMMAND} -E copy ${SCIQLOP-AMDA_LIBRARIES} "${LIBRARY_OUTPUT_PATH}/plugins/${SCIQLOP-AMDA_LIBRARIES_NAME}"
                 )
             ENDIF(BUILD_PLUGINS)
             # LOGGER
             set(QTLOGGING_INI_FILE "${CMAKE_SOURCE_DIR}/config/QtProject/qtlogging.ini")
             FILE(COPY ${QTLOGGING_INI_FILE} DESTINATION ${CONFIG_OUTPUT_PATH})
             #
             # Code formatting
             #
             # Vera++ exclusion files
             LIST(APPEND CHECKSTYLE_EXCLUSION_FILES ${CMAKE_CURRENT_SOURCE_DIR}/formatting/vera-exclusions/exclusions.txt)
             #SCIQLOP_SET_TO_PARENT_SCOPE(CHECKSTYLE_EXCLUSION_FILES)
             INCLUDE ("cmake/sciqlop_formatting.cmake")
             #
             # Documentation generation
             #
             INCLUDE ("cmake/sciqlop_doxygen.cmake")
             #
             # Source code analysis
             #
             INCLUDE ("cmake/sciqlop_code_analysis.cmake")
             INCLUDE ("cmake/sciqlop_code_cppcheck.cmake")

meson.build +9 0

             project('SciQLOP', 'cpp',default_options : ['cpp_std=c++14'])
             qt5 = import('qt5')
             qt5core = dependency('qt5', modules : 'Core')
             qt5widgets = dependency('qt5', modules : 'Widgets')
             qt5gui = dependency('qt5', modules : 'Gui')
             qt5svg = dependency('qt5', modules : 'Svg')
             qt5xml = dependency('qt5', modules : 'Xml')
             qt5network = dependency('qt5', modules : 'Network')
             qt5printsupport = dependency('qt5', modules : 'PrintSupport')
             qt5test = dependency('qt5', modules : 'Test')
             moc = find_program('moc-qt5','moc')
             rcc = find_program('rcc-qt5','rcc')
             if build_machine.system()=='darwin'
               add_global_link_arguments('-headerpad_max_install_names', language : 'cpp')
               install_data('build_cfg/mac/sciqlopLOGO.icns', install_dir : 'Contents/Resources')
               install_data('build_cfg/mac/Info.plist', install_dir : 'Contents')
               meson.add_install_script('build_cfg/mac/install_script.sh')
             elif host_machine.system()=='windows'
               meson.add_install_script('build_cfg/windows/install_script.sh')
             endif
+            # Sets AMDA server that will be used during execution.
+            # Available values are:
+            # - "default": default AMDA server
+            # - "amdatest": AMDA test server
+            # - "hybrid": use both the default server and the test server (the server used is relative to each product, according to its "server" property in the JSON file)
+            # - "localhost": use local AMDA server
+            # Any other value will lead to the use of the default server
+            add_project_arguments('-DSCIQLOP_AMDA_SERVER="hybrid"', language : 'cpp')
             subdir('core')
             subdir('gui')
             subdir('app')
             subdir('plugins')
             cppcheck = find_program('cppcheck', required : false)
             if cppcheck.found()
               run_target('cppcheck',
                           command : [cppcheck, '--enable=all',
                           '--project=' + join_paths(meson.build_root(), 'compile_commands.json')]
                           )
             endif

plugins/amda/CMakeLists.txt +1 -1

             ## 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 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 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)
+            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/include/AmdaPlugin.h +3 -3

             #ifndef SCIQLOP_AMDAPLUGIN_H
             #define SCIQLOP_AMDAPLUGIN_H
             #include "AmdaGlobal.h"
             #include <Plugin/IPlugin.h>
             #include <QLoggingCategory>
             #include <memory>
             Q_DECLARE_LOGGING_CATEGORY(LOG_AmdaPlugin)
-            #ifndef PLUGIN_JSON_FILE_PATH
+            #ifndef SCIQLOP_PLUGIN_JSON_FILE_PATH
-            #define PLUGIN_JSON_FILE_PATH "amda.json"
+            #define SCIQLOP_PLUGIN_JSON_FILE_PATH "amda.json"
             #endif
             class DataSourceItem;
             class SCIQLOP_AMDA_EXPORT AmdaPlugin : public QObject, public IPlugin {
                 Q_OBJECT
                 Q_INTERFACES(IPlugin)
-                Q_PLUGIN_METADATA(IID "sciqlop.plugin.IPlugin" FILE PLUGIN_JSON_FILE_PATH)
+                Q_PLUGIN_METADATA(IID "sciqlop.plugin.IPlugin" FILE SCIQLOP_PLUGIN_JSON_FILE_PATH)
             public:
                 /// @sa IPlugin::initialize()
                 void initialize() override;
             };
             #endif // SCIQLOP_AMDAPLUGIN_H

plugins/amda/include/AmdaProvider.h +4 -4

             #ifndef SCIQLOP_AMDAPROVIDER_H
             #define SCIQLOP_AMDAPROVIDER_H
             #include "AmdaGlobal.h"
             #include <Data/IDataProvider.h>
             #include <QLoggingCategory>
             #include <map>
             Q_DECLARE_LOGGING_CATEGORY(LOG_AmdaProvider)
             class QNetworkReply;
             class QNetworkRequest;
             /**
              * @brief The AmdaProvider class is an example of how a data provider can generate data
              */
             class SCIQLOP_AMDA_EXPORT AmdaProvider : public IDataProvider {
                 Q_OBJECT
             public:
                 explicit AmdaProvider();
                 std::shared_ptr<IDataProvider> clone() const override;
                 void requestDataLoading(QUuid acqIdentifier, const DataProviderParameters &parameters) override;
                 void requestDataAborting(QUuid acqIdentifier) override;
-            private slots:
-                void onReplyDownloadProgress(QUuid acqIdentifier,
-                                             std::shared_ptr<QNetworkRequest> networkRequest, double progress);
             private:
                 void retrieveData(QUuid token, const SqpRange &dateTime, const QVariantHash &data);
                 void updateRequestProgress(QUuid acqIdentifier, std::shared_ptr<QNetworkRequest> request,
                                            double progress);
                 std::map<QUuid, std::map<std::shared_ptr<QNetworkRequest>, double> >
                     m_AcqIdToRequestProgressMap;
+            private slots:
+                void onReplyDownloadProgress(QUuid acqIdentifier,
+                                             std::shared_ptr<QNetworkRequest> networkRequest, double progress);
             };
             #endif // SCIQLOP_AMDAPROVIDER_H

plugins/amda/include/AmdaResultParserDefs.h +3 0

             #ifndef SCIQLOP_AMDARESULTPARSERDEFS_H
             #define SCIQLOP_AMDARESULTPARSERDEFS_H
             #include <QtCore/QRegularExpression>
             #include <QtCore/QString>
             #include <QtCore/QVariantHash>
             // ////////// //
             // Properties //
             // ////////// //
             /// Alias to represent properties read in the header of AMDA file
             using Properties = QVariantHash;
             extern const QString END_TIME_PROPERTY;
             extern const QString FILL_VALUE_PROPERTY;
             extern const QString MAX_BANDS_PROPERTY;
             extern const QString MIN_BANDS_PROPERTY;
             extern const QString MAX_SAMPLING_PROPERTY;
             extern const QString MIN_SAMPLING_PROPERTY;
             extern const QString START_TIME_PROPERTY;
             extern const QString X_AXIS_UNIT_PROPERTY;
             extern const QString Y_AXIS_UNIT_PROPERTY;
             extern const QString VALUES_UNIT_PROPERTY;
             // /////////////////// //
             // Regular expressions //
             // /////////////////// //
             // AMDA V2
             // /// Regex to find the header of the data in the file. This header indicates the end of comments
             // in the file
             // const auto DATA_HEADER_REGEX = QRegularExpression{QStringLiteral("#\\s*DATA\\s*:")};
             // AMDA V2
             // /// ... PARAMETER_UNITS : nT ...
             // /// ... PARAMETER_UNITS:nT ...
             // /// ... PARAMETER_UNITS:   m² ...
             // /// ... PARAMETER_UNITS : m/s ...
             // const auto UNIT_REGEX = QRegularExpression{QStringLiteral("\\s*PARAMETER_UNITS\\s*:\\s*(.+)")};
             /// Regex to find x-axis unit in a line. Examples of valid lines:
             /// ... - Units : nT - ...
             /// ... -Units:nT- ...
             /// ... -Units:   m²- ...
             /// ... - Units : m/s - ...
             extern const QRegularExpression DEFAULT_X_AXIS_UNIT_REGEX;
+            /// Alternative regex to find x-axis unit in a line
+            extern const QRegularExpression ALTERNATIVE_X_AXIS_UNIT_REGEX;
             /// Regex to find end time of data in a line for a spectrogram
             extern const QRegularExpression SPECTROGRAM_END_TIME_REGEX;
             /// Regex to find fill value used in a line for a spectrogram
             extern const QRegularExpression SPECTROGRAM_FILL_VALUE_REGEX;
             /// Regex to find max bands in a line for a spectrogram
             extern const QRegularExpression SPECTROGRAM_MAX_BANDS_REGEX;
             /// Regex to find min bands in a line for a spectrogram
             extern const QRegularExpression SPECTROGRAM_MIN_BANDS_REGEX;
             /// Regex to find max x-axis sampling in a line for a spectrogram
             extern const QRegularExpression SPECTROGRAM_MAX_SAMPLING_REGEX;
             /// Regex to find min x-axis sampling in a line for a spectrogram
             extern const QRegularExpression SPECTROGRAM_MIN_SAMPLING_REGEX;
             /// Regex to find start time of data in a line for a spectrogram
             extern const QRegularExpression SPECTROGRAM_START_TIME_REGEX;
             /// Regex to find y-axis unit in a line for a spectrogram
             extern const QRegularExpression SPECTROGRAM_Y_AXIS_UNIT_REGEX;
             /// Regex to find values unit in a line for a spectrogram
             extern const QRegularExpression SPECTROGRAM_VALUES_UNIT_REGEX;
             #endif // SCIQLOP_AMDARESULTPARSERDEFS_H

plugins/amda/meson.build +3 -2

             amdaplugin_moc_headers = [
               'include/AmdaPlugin.h',
               'include/AmdaProvider.h'
             ]
             amdaplugin_sources = [
               'src/AmdaDefs.cpp',
               'src/AmdaParser.cpp',
               'src/AmdaPlugin.cpp',
               'src/AmdaProvider.cpp',
               'src/AmdaResultParser.cpp',
               'src/AmdaResultParserDefs.cpp',
-              'src/AmdaResultParserHelper.cpp'
+              'src/AmdaResultParserHelper.cpp',
+              'src/AmdaServer.cpp'
             ]
             amdaplugin_ui_files = []
             amdaplugin_resources_files = [
               'resources/amdaresources.qrc'
             ]
             amdaplugin_inc = include_directories(['include', '../../plugin/include'])
             moc_gen = generator(moc,
                             output  : 'moc_@BASENAME@.cpp',
                             arguments : ['@INPUT@',
-                             '-DPLUGIN_JSON_FILE_PATH="'+meson.source_root()+'/plugins/amda/resources/amda.json"',
+                             '-DSCIQLOP_PLUGIN_JSON_FILE_PATH="'+meson.source_root()+'/plugins/amda/resources/amda.json"',
                              '-I', meson.current_source_dir()+'/include',
                              '-I', meson.current_source_dir()+'/../../plugin/include',
                              '-o', '@OUTPUT@'])
             rcc_gen = generator(rcc,
                             output  : 'qrc_@BASENAME@.cpp',
                             arguments : ['--name=@BASENAME@"',
                              '--output',
                              '@OUTPUT@',
                              '@INPUT@'])
             amdaplugin_moc_plugin_files = moc_gen.process(amdaplugin_moc_headers)
             amdaplugin_rcc_plugin_files = rcc_gen.process(amdaplugin_resources_files)
             #amdaplugin_rcc_plugin_files = qt5.preprocess(
             #                               qresources : amdaplugin_resources_files)
             amdaplugin_moc_files = qt5.preprocess(
                                            ui_files : amdaplugin_ui_files)
             sciqlop_amdaplugin = library('amdaplugin',
                                    amdaplugin_sources,
                                    amdaplugin_moc_files,
                                    amdaplugin_rcc_plugin_files,
                                    amdaplugin_moc_plugin_files,
                                    cpp_args : ['-DAMDA_LIB','-DQT_PLUGIN'],
                                    include_directories : [amdaplugin_inc],
                                    dependencies : [sciqlop_core, sciqlop_gui],
                                    install : true
                                    )
             tests = [
               [['tests/TestAmdaParser.cpp'],'test_amda_parser','AMDA parser test'],
               [['tests/TestAmdaResultParser.cpp'],'test_amda_result_parser','AMDA result parser test'],
               [['tests/TestAmdaAcquisition.cpp'],'test_amda_acquisition','AMDA Acquisition test']
             ]
             foreach unit_test : tests
               test_moc_files = qt5.preprocess(moc_sources : unit_test[0])
               test_exe = executable(unit_test[1],unit_test[0] , test_moc_files,
                                       link_with : [sciqlop_amdaplugin],
                                       include_directories : [amdaplugin_inc],
                                       cpp_args : ['-DAMDA_TESTS_RESOURCES_DIR="'+meson.current_source_dir()+'/tests-resources"'],
                                       dependencies : [sciqlop_core, sciqlop_gui, qt5test])
               test(unit_test[2], test_exe, args: ['-teamcity', '-o', '@0@.teamcity.txt'.format(unit_test[1])], timeout: 3 * 60)
             endforeach

plugins/amda/src/AmdaPlugin.cpp +7 -6

             #include "AmdaPlugin.h"
             #include "AmdaDefs.h"
             #include "AmdaParser.h"
             #include "AmdaProvider.h"
+            #include "AmdaServer.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/AmdaSampleV3.json");
             void associateActions(DataSourceItem &item, const QUuid &dataSourceUid)
             {
                 auto addLoadAction = [&item, dataSourceUid](const QString &label) {
                     item.addAction(
                         std::make_unique<DataSourceItemAction>(label, [dataSourceUid](DataSourceItem &item) {
                             if (auto app = sqpApp) {
                                 app->dataSourceController().loadProductItem(dataSourceUid, item);
                             }
                         }));
                 };
                 const auto itemType = item.type();
                 if (itemType == DataSourceItemType::PRODUCT || itemType == DataSourceItemType::COMPONENT) {
                     // Adds plugin name to item metadata
-                    item.setData(DataSourceItem::PLUGIN_DATA_KEY, DATA_SOURCE_NAME);
+                    item.setData(DataSourceItem::PLUGIN_DATA_KEY, AmdaServer::instance().name());
                     // Adds load action
                     auto actionLabel = QObject::tr(
                         itemType == DataSourceItemType::PRODUCT ? "Load %1 product" : "Load %1 component");
                     addLoadAction(actionLabel.arg(item.name()));
                 }
                 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) {
+                    auto dataSourceName = AmdaServer::instance().name();
                     // Registers to the data source controller
                     auto &dataSourceController = app->dataSourceController();
-                    auto dataSourceUid = dataSourceController.registerDataSource(DATA_SOURCE_NAME);
+                    auto dataSourceUid = dataSourceController.registerDataSource(dataSourceName);
                     // Sets data source tree
                     if (auto dataSourceItem = AmdaParser::readJson(JSON_FILE_PATH)) {
-                        associateActions(*dataSourceItem, dataSourceUid);
+                        dataSourceItem->setData(DataSourceItem::NAME_DATA_KEY, dataSourceName);
+                        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/amda/src/AmdaProvider.cpp +4 -23

             #include "AmdaProvider.h"
             #include "AmdaDefs.h"
             #include "AmdaResultParser.h"
+            #include "AmdaServer.h"
             #include <Common/DateUtils.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 of the default AMDA server
-            const auto AMDA_SERVER_URL = QStringLiteral("amda.irap.omp.eu");
-            /// URL of the AMDA test server
-            const auto AMDA_TEST_SERVER_URL = QStringLiteral("amdatest.irap.omp.eu");
             /// URL format for a request on AMDA server. The parameters are as follows:
             /// - %1: server URL
             /// - %2: start date
             /// - %3: end date
             /// - %4: parameter id
             /// AMDA V2: http://amdatest.irap.omp.eu/php/rest/
             const auto AMDA_URL_FORMAT = QStringLiteral(
                 "http://%1/php/rest/"
                 "getParameter.php?startTime=%2&stopTime=%3&parameterID=%4&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:mm:ss");
             /// Formats a time to a date that can be passed in URL
             QString dateFormat(double sqpRange) noexcept
             {
                 auto dateTime = DateUtils::dateTime(sqpRange);
                 return dateTime.toString(AMDA_TIME_FORMAT);
             }
-            /// Returns the URL of the AMDA server queried for requests, depending on the type of server passed
-            /// as a parameter
-            QString serverURL(const QString &server)
-                if (server == QString{"amdatest"}) {
-                    return AMDA_TEST_SERVER_URL;
-                else {
-                    return AMDA_SERVER_URL;
             AmdaResultParser::ValueType valueType(const QString &valueType)
             {
                 if (valueType == QStringLiteral("scalar")) {
                     return AmdaResultParser::ValueType::SCALAR;
                 }
                 else if (valueType == QStringLiteral("spectrogram")) {
                     return AmdaResultParser::ValueType::SPECTROGRAM;
                 }
                 else if (valueType == QStringLiteral("vector")) {
                     return AmdaResultParser::ValueType::VECTOR;
                 }
                 else {
                     return AmdaResultParser::ValueType::UNKNOWN;
                 }
             }
             } // namespace
             AmdaProvider::AmdaProvider()
             {
                 qCDebug(LOG_AmdaProvider()) << tr("AmdaProvider::AmdaProvider") << QThread::currentThread();
                 if (auto app = sqpApp) {
                     auto &networkController = app->networkController();
                     connect(this, SIGNAL(requestConstructed(std::shared_ptr<QNetworkRequest>, QUuid,
                                                             std::function<void(QNetworkReply *, QUuid)>)),
                             &networkController,
                             SLOT(onProcessRequested(std::shared_ptr<QNetworkRequest>, QUuid,
                                                     std::function<void(QNetworkReply *, QUuid)>)));
                     connect(&sqpApp->networkController(),
                             SIGNAL(replyDownloadProgress(QUuid, std::shared_ptr<QNetworkRequest>, double)),
                             this,
                             SLOT(onReplyDownloadProgress(QUuid, std::shared_ptr<QNetworkRequest>, double)));
                 }
             }
             std::shared_ptr<IDataProvider> AmdaProvider::clone() const
             {
                 // No copy is made in the clone
                 return std::make_shared<AmdaProvider>();
             }
             void AmdaProvider::requestDataLoading(QUuid acqIdentifier, const DataProviderParameters &parameters)
             {
                 // NOTE: Try to use multithread if possible
                 const auto times = parameters.m_Times;
                 const auto data = parameters.m_Data;
                 for (const auto &dateTime : qAsConst(times)) {
                     qCDebug(LOG_AmdaProvider()) << tr("TORM AmdaProvider::requestDataLoading ") << acqIdentifier
                                                 << dateTime;
                     this->retrieveData(acqIdentifier, dateTime, data);
                     // TORM when AMDA will support quick asynchrone request
                     QThread::msleep(1000);
                 }
             }
             void AmdaProvider::requestDataAborting(QUuid acqIdentifier)
             {
                 if (auto app = sqpApp) {
                     auto &networkController = app->networkController();
                     networkController.onReplyCanceled(acqIdentifier);
                 }
             }
             void AmdaProvider::onReplyDownloadProgress(QUuid acqIdentifier,
                                                        std::shared_ptr<QNetworkRequest> networkRequest,
                                                        double progress)
             {
                 qCDebug(LOG_AmdaProvider()) << tr("onReplyDownloadProgress") << acqIdentifier
                                             << networkRequest.get() << progress;
                 auto acqIdToRequestProgressMapIt = m_AcqIdToRequestProgressMap.find(acqIdentifier);
                 if (acqIdToRequestProgressMapIt != m_AcqIdToRequestProgressMap.end()) {
                     // Update the progression for the current request
                     auto requestPtr = networkRequest;
                     auto findRequest = [requestPtr](const auto &entry) { return requestPtr == entry.first; };
                     auto &requestProgressMap = acqIdToRequestProgressMapIt->second;
                     auto requestProgressMapEnd = requestProgressMap.end();
                     auto requestProgressMapIt
                         = std::find_if(requestProgressMap.begin(), requestProgressMapEnd, findRequest);
                     if (requestProgressMapIt != requestProgressMapEnd) {
                         requestProgressMapIt->second = progress;
                     }
                     else {
                         // This case can happened when a progression is send after the request has been
                         // finished.
                         // Generaly the case when aborting a request
                         qCDebug(LOG_AmdaProvider()) << tr("Can't retrieve Request in progress") << acqIdentifier
                                                     << networkRequest.get() << progress;
                     }
                     // Compute the current final progress and notify it
                     double finalProgress = 0.0;
                     auto fraq = requestProgressMap.size();
                     for (auto requestProgress : requestProgressMap) {
                         finalProgress += requestProgress.second;
                         qCDebug(LOG_AmdaProvider()) << tr("Current final progress without fraq:")
                                                     << finalProgress << requestProgress.second;
                     }
                     if (fraq > 0) {
                         finalProgress = finalProgress / fraq;
                     }
                     qCDebug(LOG_AmdaProvider()) << tr("Current final progress: ") << fraq << finalProgress;
                     emit dataProvidedProgress(acqIdentifier, finalProgress);
                 }
                 else {
                     // This case can happened when a progression is send after the request has been finished.
                     // Generaly the case when aborting a request
                     emit dataProvidedProgress(acqIdentifier, 100.0);
                 }
             }
             void AmdaProvider::retrieveData(QUuid token, const SqpRange &dateTime, const QVariantHash &data)
             {
                 // Retrieves product ID from data: if the value is invalid, no request is made
                 auto productId = data.value(AMDA_XML_ID_KEY).toString();
                 if (productId.isNull()) {
                     qCCritical(LOG_AmdaProvider()) << tr("Can't retrieve data: unknown product id");
                     return;
                 }
                 // Retrieves the data type that determines whether the expected format for the result file is
                 // scalar, vector...
                 auto productValueType = valueType(data.value(AMDA_DATA_TYPE_KEY).toString());
-                // Gets the server being queried to retrieve the product. It's then used to set the server URL
-                auto productServer = data.value(AMDA_SERVER_KEY).toString();
                 // /////////// //
                 // Creates URL //
                 // /////////// //
                 auto startDate = dateFormat(dateTime.m_TStart);
                 auto endDate = dateFormat(dateTime.m_TEnd);
-                auto url = QUrl{
+                QVariantHash urlProperties{{AMDA_SERVER_KEY, data.value(AMDA_SERVER_KEY)}};
-                    QString{AMDA_URL_FORMAT}.arg(serverURL(productServer), startDate, endDate, productId)};
+                auto url = QUrl{QString{AMDA_URL_FORMAT}.arg(AmdaServer::instance().url(urlProperties),
+                                                             startDate, endDate, productId)};
                 qCInfo(LOG_AmdaProvider()) << tr("TORM AmdaProvider::retrieveData url:") << url;
                 auto tempFile = std::make_shared<QTemporaryFile>();
                 // LAMBDA
                 auto httpDownloadFinished = [this, dateTime, tempFile,
                                              productValueType](QNetworkReply *reply, QUuid dataId) noexcept {
                     // Don't do anything if the reply was abort
                     if (reply->error() == QNetworkReply::NoError) {
                         if (tempFile) {
                             auto replyReadAll = reply->readAll();
                             if (!replyReadAll.isEmpty()) {
                                 tempFile->write(replyReadAll);
                             }
                             tempFile->close();
                             // Parse results file
                             if (auto dataSeries
                                 = AmdaResultParser::readTxt(tempFile->fileName(), productValueType)) {
                                 emit dataProvided(dataId, dataSeries, dateTime);
                             }
                             else {
                                 /// @todo ALX : debug
                                 emit dataProvidedFailed(dataId);
                             }
                         }
                         m_AcqIdToRequestProgressMap.erase(dataId);
                     }
                     else {
                         qCCritical(LOG_AmdaProvider()) << tr("httpDownloadFinished ERROR");
                         emit dataProvidedFailed(dataId);
                     }
                 };
                 auto httpFinishedLambda
                     = [this, httpDownloadFinished, tempFile](QNetworkReply *reply, QUuid dataId) noexcept {
                           // Don't do anything if the reply was abort
                           if (reply->error() == QNetworkReply::NoError) {
                               auto downloadFileUrl = QUrl{QString{reply->readAll()}.trimmed()};
                               qCInfo(LOG_AmdaProvider())
                                   << tr("TORM AmdaProvider::retrieveData downloadFileUrl:") << downloadFileUrl;
                               // Executes request for downloading file //
                               // Creates destination file
                               if (tempFile->open()) {
                                   // Executes request and store the request for progression
                                   auto request = std::make_shared<QNetworkRequest>(downloadFileUrl);
                                   updateRequestProgress(dataId, request, 0.0);
                                   emit requestConstructed(request, dataId, httpDownloadFinished);
                               }
                               else {
                                   emit dataProvidedFailed(dataId);
                               }
                           }
                           else {
                               qCCritical(LOG_AmdaProvider()) << tr("httpFinishedLambda ERROR");
                               m_AcqIdToRequestProgressMap.erase(dataId);
                               emit dataProvidedFailed(dataId);
                           }
                       };
                 // //////////////// //
                 // Executes request //
                 // //////////////// //
                 auto request = std::make_shared<QNetworkRequest>(url);
                 qCDebug(LOG_AmdaProvider()) << tr("First Request creation") << request.get();
                 updateRequestProgress(token, request, 0.0);
                 emit requestConstructed(request, token, httpFinishedLambda);
             }
             void AmdaProvider::updateRequestProgress(QUuid acqIdentifier,
                                                      std::shared_ptr<QNetworkRequest> request, double progress)
             {
                 qCDebug(LOG_AmdaProvider()) << tr("updateRequestProgress request") << request.get();
                 auto acqIdToRequestProgressMapIt = m_AcqIdToRequestProgressMap.find(acqIdentifier);
                 if (acqIdToRequestProgressMapIt != m_AcqIdToRequestProgressMap.end()) {
                     auto &requestProgressMap = acqIdToRequestProgressMapIt->second;
                     auto requestProgressMapIt = requestProgressMap.find(request);
                     if (requestProgressMapIt != requestProgressMap.end()) {
                         requestProgressMapIt->second = progress;
                         qCDebug(LOG_AmdaProvider()) << tr("updateRequestProgress new progress for request")
                                                     << acqIdentifier << request.get() << progress;
                     }
                     else {
                         qCDebug(LOG_AmdaProvider()) << tr("updateRequestProgress new request") << acqIdentifier
                                                     << request.get() << progress;
                         acqIdToRequestProgressMapIt->second.insert(std::make_pair(request, progress));
                     }
                 }
                 else {
                     qCDebug(LOG_AmdaProvider()) << tr("updateRequestProgress new acqIdentifier")
                                                 << acqIdentifier << request.get() << progress;
                     auto requestProgressMap = std::map<std::shared_ptr<QNetworkRequest>, double>{};
                     requestProgressMap.insert(std::make_pair(request, progress));
                     m_AcqIdToRequestProgressMap.insert(
                         std::make_pair(acqIdentifier, std::move(requestProgressMap)));
                 }
             }

plugins/amda/src/AmdaResultParserDefs.cpp +9 -2

             #include "AmdaResultParserDefs.h"
             const QString END_TIME_PROPERTY = QStringLiteral("endTime");
             const QString FILL_VALUE_PROPERTY = QStringLiteral("fillValue");
             const QString MAX_BANDS_PROPERTY = QStringLiteral("maxBands");
             const QString MIN_BANDS_PROPERTY = QStringLiteral("minBands");
             const QString MAX_SAMPLING_PROPERTY = QStringLiteral("maxSampling");
             const QString MIN_SAMPLING_PROPERTY = QStringLiteral("minSampling");
             const QString START_TIME_PROPERTY = QStringLiteral("startTime");
             const QString X_AXIS_UNIT_PROPERTY = QStringLiteral("xAxisUnit");
             const QString Y_AXIS_UNIT_PROPERTY = QStringLiteral("yAxisUnit");
             const QString VALUES_UNIT_PROPERTY = QStringLiteral("valuesUnit");
+            namespace {
+            const auto PARAMETER_UNITS_REGEX
+                = QRegularExpression{QStringLiteral("\\s*PARAMETER_UNITS\\s*:\\s*(.*)")};
+            }
             const QRegularExpression DEFAULT_X_AXIS_UNIT_REGEX
                 = QRegularExpression{QStringLiteral("-\\s*Units\\s*:\\s*(.+?)\\s*-")};
+            const QRegularExpression ALTERNATIVE_X_AXIS_UNIT_REGEX = PARAMETER_UNITS_REGEX;
             const QRegularExpression SPECTROGRAM_END_TIME_REGEX
                 = QRegularExpression{QStringLiteral("\\s*INTERVAL_STOP\\s*:\\s*(.*)")};
             const QRegularExpression SPECTROGRAM_FILL_VALUE_REGEX
                 = QRegularExpression{QStringLiteral("\\s*PARAMETER_FILL_VALUE\\s*:\\s*(.*)")};
             const QRegularExpression SPECTROGRAM_MAX_BANDS_REGEX
                 = QRegularExpression{QStringLiteral("\\s*PARAMETER_TABLE_MAX_VALUES\\[0\\]\\s*:\\s*(.*)")};
             const QRegularExpression SPECTROGRAM_MIN_BANDS_REGEX
                 = QRegularExpression{QStringLiteral("\\s*PARAMETER_TABLE_MIN_VALUES\\[0\\]\\s*:\\s*(.*)")};
             const QRegularExpression SPECTROGRAM_MAX_SAMPLING_REGEX
                 = QRegularExpression{QStringLiteral("\\s*DATASET_MAX_SAMPLING\\s*:\\s*(.*)")};
             const QRegularExpression SPECTROGRAM_MIN_SAMPLING_REGEX
                 = QRegularExpression{QStringLiteral("\\s*DATASET_MIN_SAMPLING\\s*:\\s*(.*)")};
             const QRegularExpression SPECTROGRAM_START_TIME_REGEX
                 = QRegularExpression{QStringLiteral("\\s*INTERVAL_START\\s*:\\s*(.*)")};
             const QRegularExpression SPECTROGRAM_Y_AXIS_UNIT_REGEX
                 = QRegularExpression{QStringLiteral("\\s*PARAMETER_TABLE_UNITS\\[0\\]\\s*:\\s*(.*)")};
-            const QRegularExpression SPECTROGRAM_VALUES_UNIT_REGEX
+            const QRegularExpression SPECTROGRAM_VALUES_UNIT_REGEX = PARAMETER_UNITS_REGEX;
-                = QRegularExpression{QStringLiteral("\\s*PARAMETER_UNITS\\s*:\\s*(.*)")};

plugins/amda/src/AmdaResultParserHelper.cpp +34 -25

             #include "AmdaResultParserHelper.h"
             #include <Common/DateUtils.h>
             #include <Common/SortUtils.h>
             #include <Data/DataSeriesUtils.h>
             #include <Data/ScalarSeries.h>
             #include <Data/SpectrogramSeries.h>
             #include <Data/Unit.h>
             #include <Data/VectorSeries.h>
             #include <QtCore/QDateTime>
             #include <QtCore/QRegularExpression>
             #include <functional>
             Q_LOGGING_CATEGORY(LOG_AmdaResultParserHelper, "AmdaResultParserHelper")
             namespace {
             // ///////// //
             // Constants //
             // ///////// //
             /// Separator between values in a result line
             const auto RESULT_LINE_SEPARATOR = QRegularExpression{QStringLiteral("\\s+")};
             /// Format for dates in result files
             const auto DATE_FORMAT = QStringLiteral("yyyy-MM-ddThh:mm:ss.zzz");
             // /////// //
             // Methods //
             // /////// //
             /**
              * Checks that the properties contain a specific unit and that this unit is valid
              * @param properties the properties map in which to search unit
              * @param key the key to search for the unit in the properties
              * @param errorMessage the error message to log in case the unit is invalid
              * @return true if the unit is valid, false it it's invalid or was not found in the properties
              */
             bool checkUnit(const Properties &properties, const QString &key, const QString &errorMessage)
             {
                 auto unit = properties.value(key).value<Unit>();
                 if (unit.m_Name.isEmpty()) {
                     qCWarning(LOG_AmdaResultParserHelper()) << errorMessage;
                     return false;
                 }
                 return true;
             }
             QDateTime dateTimeFromString(const QString &stringDate) noexcept
             {
             #if QT_VERSION >= QT_VERSION_CHECK(5, 8, 0)
                 return QDateTime::fromString(stringDate, Qt::ISODateWithMs);
             #else
                 return QDateTime::fromString(stringDate, DATE_FORMAT);
             #endif
             }
             /// Converts a string date to a double date
             /// @return a double that represents the date in seconds, NaN if the string date can't be converted
             double doubleDate(const QString &stringDate) noexcept
             {
                 // Format: yyyy-MM-ddThh:mm:ss.zzz
                 auto dateTime = dateTimeFromString(stringDate);
                 dateTime.setTimeSpec(Qt::UTC);
                 return dateTime.isValid() ? DateUtils::secondsSinceEpoch(dateTime)
                                           : std::numeric_limits<double>::quiet_NaN();
             }
             /**
              * Reads a line from the AMDA file and tries to extract a x-axis data and value data from it
              * @param xAxisData the vector in which to store the x-axis data extracted
              * @param valuesData the vector in which to store the value extracted
              * @param line the line to read to extract the property
              * @param valuesIndexes indexes of insertion of read values. For example, if the line contains three
              * columns of values, and valuesIndexes are {2, 0, 1}, the value of the third column will be read
              * and inserted first, then the value of the first column, and finally the value of the second
              * column.
              * @param fillValue value that tags an invalid data. For example, if fillValue is -1 and a read
              * value is -1, then this value is considered as invalid and converted to NaN
              */
             void tryReadResult(std::vector<double> &xAxisData, std::vector<double> &valuesData,
                                const QString &line, const std::vector<int> &valuesIndexes,
                                double fillValue = std::numeric_limits<double>::quiet_NaN())
             {
                 auto lineData = line.split(RESULT_LINE_SEPARATOR, QString::SkipEmptyParts);
                 // Checks that the line contains expected number of values + x-axis value
                 if (static_cast<size_t>(lineData.size()) == valuesIndexes.size() + 1) {
                     // X : the data is converted from date to double (in secs)
                     auto x = doubleDate(lineData.at(0));
                     // Adds result only if x is valid. Then, if value is invalid, it is set to NaN
                     if (!std::isnan(x)) {
                         xAxisData.push_back(x);
                         // Values
                         for (auto valueIndex : valuesIndexes) {
                             bool valueOk;
                             // we use valueIndex + 1 to skip column 0 (x-axis value)
                             auto value = lineData.at(valueIndex + 1).toDouble(&valueOk);
                             if (!valueOk) {
                                 qCWarning(LOG_AmdaResultParserHelper())
                                     << QObject::tr(
                                            "Value from (line %1, column %2) is invalid and will be "
                                            "converted to NaN")
                                            .arg(line, valueIndex);
                                 value = std::numeric_limits<double>::quiet_NaN();
                             }
                             // Handles fill value
                             if (!std::isnan(fillValue) && !std::isnan(value) && fillValue == value) {
                                 value = std::numeric_limits<double>::quiet_NaN();
                             }
                             valuesData.push_back(value);
                         }
                     }
                     else {
                         qCWarning(LOG_AmdaResultParserHelper())
                             << QObject::tr("Can't retrieve results from line %1: x is invalid").arg(line);
                     }
                 }
                 else {
                     qCWarning(LOG_AmdaResultParserHelper())
                         << QObject::tr("Can't retrieve results from line %1: invalid line").arg(line);
                 }
             }
             /**
              * Reads a line from the AMDA file and tries to extract a property from it
              * @param properties the properties map in which to put the property extracted from the line
              * @param key the key to which the property is added in the properties map
              * @param line the line to read to extract the property
-             * @param regex the expected regex to extract the property. If the line matches this regex, the
+             * @param regexes the expected regexes to extract the property. If the line matches one regex, the
              * property is generated
              * @param fun the function used to generate the property
              * @return true if the property could be generated, false if the line does not match the regex, or
              * if a property has already been generated for the key
              */
             template <typename GeneratePropertyFun>
             bool tryReadProperty(Properties &properties, const QString &key, const QString &line,
-                                 const QRegularExpression &regex, GeneratePropertyFun fun)
+                                 const std::vector<QRegularExpression> &regexes, GeneratePropertyFun fun)
             {
                 if (properties.contains(key)) {
                     return false;
                 }
-                auto match = regex.match(line);
+                // Searches for a match among all possible regexes
-                if (match.hasMatch()) {
+                auto hasMatch = false;
-                    properties.insert(key, fun(match));
+                for (auto regexIt = regexes.cbegin(), end = regexes.cend(); regexIt != end && !hasMatch;
+                     ++regexIt) {
+                    auto match = regexIt->match(line);
+                    auto hasMatch = match.hasMatch();
+                    if (hasMatch) {
+                        properties.insert(key, fun(match));
+                    }
                 }
-                return match.hasMatch();
+                return hasMatch;
             }
             /**
              * Reads a line from the AMDA file and tries to extract a data from it. Date is converted to double
              * @sa tryReadProperty()
              */
             bool tryReadDate(Properties &properties, const QString &key, const QString &line,
-                             const QRegularExpression &regex, bool timeUnit = false)
+                             const std::vector<QRegularExpression> &regexes, bool timeUnit = false)
             {
-                return tryReadProperty(properties, key, line, regex, [timeUnit](const auto &match) {
+                return tryReadProperty(properties, key, line, regexes, [timeUnit](const auto &match) {
                     return QVariant::fromValue(doubleDate(match.captured(1)));
                 });
             }
             /**
              * Reads a line from the AMDA file and tries to extract a double from it
              * @sa tryReadProperty()
              */
             bool tryReadDouble(Properties &properties, const QString &key, const QString &line,
-                               const QRegularExpression &regex)
+                               const std::vector<QRegularExpression> &regexes)
             {
-                return tryReadProperty(properties, key, line, regex, [](const auto &match) {
+                return tryReadProperty(properties, key, line, regexes, [](const auto &match) {
                     bool ok;
                     // If the value can't be converted to double, it is set to NaN
                     auto doubleValue = match.captured(1).toDouble(&ok);
                     if (!ok) {
                         doubleValue = std::numeric_limits<double>::quiet_NaN();
                     }
                     return QVariant::fromValue(doubleValue);
                 });
             }
             /**
              * Reads a line from the AMDA file and tries to extract a vector of doubles from it
              * @param sep the separator of double values in the line
              * @sa tryReadProperty()
              */
             bool tryReadDoubles(Properties &properties, const QString &key, const QString &line,
-                                const QRegularExpression &regex, const QString &sep = QStringLiteral(","))
+                                const std::vector<QRegularExpression> &regexes,
+                                const QString &sep = QStringLiteral(","))
             {
-                return tryReadProperty(properties, key, line, regex, [sep](const auto &match) {
+                return tryReadProperty(properties, key, line, regexes, [sep](const auto &match) {
                     std::vector<double> doubleValues{};
                     // If the value can't be converted to double, it is set to NaN
                     auto values = match.captured(1).split(sep);
                     for (auto value : values) {
                         bool ok;
                         auto doubleValue = value.toDouble(&ok);
                         if (!ok) {
                             doubleValue = std::numeric_limits<double>::quiet_NaN();
                         }
                         doubleValues.push_back(doubleValue);
                     }
                     return QVariant::fromValue(doubleValues);
                 });
             }
             /**
              * Reads a line from the AMDA file and tries to extract a unit from it
              * @sa tryReadProperty()
              */
             bool tryReadUnit(Properties &properties, const QString &key, const QString &line,
-                             const QRegularExpression &regex, bool timeUnit = false)
+                             const std::vector<QRegularExpression> &regexes, bool timeUnit = false)
             {
-                return tryReadProperty(properties, key, line, regex, [timeUnit](const auto &match) {
+                return tryReadProperty(properties, key, line, regexes, [timeUnit](const auto &match) {
                     return QVariant::fromValue(Unit{match.captured(1), timeUnit});
                 });
             }
             } // namespace
             // ////////////////// //
             // ScalarParserHelper //
             // ////////////////// //
             bool ScalarParserHelper::checkProperties()
             {
                 return checkUnit(m_Properties, X_AXIS_UNIT_PROPERTY,
                                  QObject::tr("The x-axis unit could not be found in the file"));
             }
             std::shared_ptr<IDataSeries> ScalarParserHelper::createSeries()
             {
                 return std::make_shared<ScalarSeries>(std::move(m_XAxisData), std::move(m_ValuesData),
                                                       m_Properties.value(X_AXIS_UNIT_PROPERTY).value<Unit>(),
                                                       m_Properties.value(VALUES_UNIT_PROPERTY).value<Unit>());
             }
             void ScalarParserHelper::readPropertyLine(const QString &line)
             {
-                tryReadUnit(m_Properties, X_AXIS_UNIT_PROPERTY, line, DEFAULT_X_AXIS_UNIT_REGEX, true);
+                tryReadUnit(m_Properties, X_AXIS_UNIT_PROPERTY, line,
+                            {DEFAULT_X_AXIS_UNIT_REGEX, ALTERNATIVE_X_AXIS_UNIT_REGEX}, true);
             }
             void ScalarParserHelper::readResultLine(const QString &line)
             {
                 tryReadResult(m_XAxisData, m_ValuesData, line, valuesIndexes());
             }
             std::vector<int> ScalarParserHelper::valuesIndexes() const
             {
                 // Only one value to read
                 static auto result = std::vector<int>{0};
                 return result;
             }
             // /////////////////////// //
             // SpectrogramParserHelper //
             // /////////////////////// //
             bool SpectrogramParserHelper::checkProperties()
             {
                 // Generates y-axis data from bands extracted (take the middle of the intervals)
                 auto minBands = m_Properties.value(MIN_BANDS_PROPERTY).value<std::vector<double> >();
                 auto maxBands = m_Properties.value(MAX_BANDS_PROPERTY).value<std::vector<double> >();
                 if (minBands.size() < 2 || minBands.size() != maxBands.size()) {
                     qCWarning(LOG_AmdaResultParserHelper()) << QObject::tr(
                         "Can't generate y-axis data from bands extracted: bands intervals are invalid");
                     return false;
                 }
                 std::transform(
                     minBands.begin(), minBands.end(), maxBands.begin(), std::back_inserter(m_YAxisData),
                     [](const auto &minValue, const auto &maxValue) { return (minValue + maxValue) / 2.; });
                 // Generates values indexes, i.e. the order in which each value will be retrieved (in ascending
                 // order of the associated bands)
                 m_ValuesIndexes = SortUtils::sortPermutation(m_YAxisData, std::less<double>());
                 // Sorts y-axis data accoding to the ascending order
                 m_YAxisData = SortUtils::sort(m_YAxisData, 1, m_ValuesIndexes);
                 // Sets fill value
                 m_FillValue = m_Properties.value(FILL_VALUE_PROPERTY).value<double>();
                 return true;
             }
             std::shared_ptr<IDataSeries> SpectrogramParserHelper::createSeries()
             {
                 // Before creating the series, we handle its data holes
                 handleDataHoles();
                 return std::make_shared<SpectrogramSeries>(
                     std::move(m_XAxisData), std::move(m_YAxisData), std::move(m_ValuesData),
                     Unit{"t", true}, // x-axis unit is always a time unit
                     m_Properties.value(Y_AXIS_UNIT_PROPERTY).value<Unit>(),
                     m_Properties.value(VALUES_UNIT_PROPERTY).value<Unit>(),
                     m_Properties.value(MIN_SAMPLING_PROPERTY).value<double>());
             }
             void SpectrogramParserHelper::readPropertyLine(const QString &line)
             {
                 // Set of functions to test on the line to generate a property. If a function is valid (i.e. a
                 // property has been generated for the line), the line is treated as processed and the other
                 // functions are not called
                 std::vector<std::function<bool()> > functions{
                     // values unit
                     [&] {
                         return tryReadUnit(m_Properties, VALUES_UNIT_PROPERTY, line,
-                                           SPECTROGRAM_VALUES_UNIT_REGEX);
+                                           {SPECTROGRAM_VALUES_UNIT_REGEX});
                     },
                     // y-axis unit
                     [&] {
                         return tryReadUnit(m_Properties, Y_AXIS_UNIT_PROPERTY, line,
-                                           SPECTROGRAM_Y_AXIS_UNIT_REGEX);
+                                           {SPECTROGRAM_Y_AXIS_UNIT_REGEX});
                     },
                     // min sampling
                     [&] {
                         return tryReadDouble(m_Properties, MIN_SAMPLING_PROPERTY, line,
-                                             SPECTROGRAM_MIN_SAMPLING_REGEX);
+                                             {SPECTROGRAM_MIN_SAMPLING_REGEX});
                     },
                     // max sampling
                     [&] {
                         return tryReadDouble(m_Properties, MAX_SAMPLING_PROPERTY, line,
-                                             SPECTROGRAM_MAX_SAMPLING_REGEX);
+                                             {SPECTROGRAM_MAX_SAMPLING_REGEX});
                     },
                     // fill value
                     [&] {
                         return tryReadDouble(m_Properties, FILL_VALUE_PROPERTY, line,
-                                             SPECTROGRAM_FILL_VALUE_REGEX);
+                                             {SPECTROGRAM_FILL_VALUE_REGEX});
                     },
                     // min bounds of each band
                     [&] {
                         return tryReadDoubles(m_Properties, MIN_BANDS_PROPERTY, line,
-                                              SPECTROGRAM_MIN_BANDS_REGEX);
+                                              {SPECTROGRAM_MIN_BANDS_REGEX});
                     },
                     // max bounds of each band
                     [&] {
                         return tryReadDoubles(m_Properties, MAX_BANDS_PROPERTY, line,
-                                              SPECTROGRAM_MAX_BANDS_REGEX);
+                                              {SPECTROGRAM_MAX_BANDS_REGEX});
                     },
                     // start time of data
                     [&] {
                         return tryReadDate(m_Properties, START_TIME_PROPERTY, line,
-                                           SPECTROGRAM_START_TIME_REGEX);
+                                           {SPECTROGRAM_START_TIME_REGEX});
                     },
                     // end time of data
                     [&] {
-                        return tryReadDate(m_Properties, END_TIME_PROPERTY, line, SPECTROGRAM_END_TIME_REGEX);
+                        return tryReadDate(m_Properties, END_TIME_PROPERTY, line, {SPECTROGRAM_END_TIME_REGEX});
                     }};
                 for (auto function : functions) {
                     // Stops at the first function that is valid
                     if (function()) {
                         return;
                     }
                 }
             }
             void SpectrogramParserHelper::readResultLine(const QString &line)
             {
                 tryReadResult(m_XAxisData, m_ValuesData, line, m_ValuesIndexes, m_FillValue);
             }
             void SpectrogramParserHelper::handleDataHoles()
             {
                 // Fills data holes according to the max resolution found in the AMDA file
                 auto resolution = m_Properties.value(MAX_SAMPLING_PROPERTY).value<double>();
                 auto fillValue = m_Properties.value(FILL_VALUE_PROPERTY).value<double>();
                 auto minBound = m_Properties.value(START_TIME_PROPERTY).value<double>();
                 auto maxBound = m_Properties.value(END_TIME_PROPERTY).value<double>();
                 DataSeriesUtils::fillDataHoles(m_XAxisData, m_ValuesData, resolution, fillValue, minBound,
                                                maxBound);
             }
             // ////////////////// //
             // VectorParserHelper //
             // ////////////////// //
             bool VectorParserHelper::checkProperties()
             {
                 return checkUnit(m_Properties, X_AXIS_UNIT_PROPERTY,
                                  QObject::tr("The x-axis unit could not be found in the file"));
             }
             std::shared_ptr<IDataSeries> VectorParserHelper::createSeries()
             {
                 return std::make_shared<VectorSeries>(std::move(m_XAxisData), std::move(m_ValuesData),
                                                       m_Properties.value(X_AXIS_UNIT_PROPERTY).value<Unit>(),
                                                       m_Properties.value(VALUES_UNIT_PROPERTY).value<Unit>());
             }
             void VectorParserHelper::readPropertyLine(const QString &line)
             {
-                tryReadUnit(m_Properties, X_AXIS_UNIT_PROPERTY, line, DEFAULT_X_AXIS_UNIT_REGEX, true);
+                tryReadUnit(m_Properties, X_AXIS_UNIT_PROPERTY, line,
+                            {DEFAULT_X_AXIS_UNIT_REGEX, ALTERNATIVE_X_AXIS_UNIT_REGEX}, true);
             }
             void VectorParserHelper::readResultLine(const QString &line)
             {
                 tryReadResult(m_XAxisData, m_ValuesData, line, valuesIndexes());
             }
             std::vector<int> VectorParserHelper::valuesIndexes() const
             {
                 // 3 values to read, in order in the file (x, y, z)
                 static auto result = std::vector<int>{0, 1, 2};
                 return result;
             }

General Comments 0

Write
Preview

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

No TODOs yet

@@ -0,0 +1,5
	1	AmdaResultParser\.h:\d+:.IPSIS_S01.
	2	AmdaResultParserHelper\.h:\d+:.IPSIS_S01.
	3
	4	AmdaProvider\.cpp:\d+:.IPSIS_S04_VARIABLE.found: QStringLiteral
	5	AmdaResultParserHelper\.cpp:\d+:.IPSIS_S04_VARIABLE.found: QT_VERSION_CHECK No newline at end of file

	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