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

@@ -27,6 +27,15 IF(BUILD_PLUGINS)
27	set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${sciqlop-mockplugin_DIR}")	27	set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${sciqlop-mockplugin_DIR}")
28	ADD_SUBDIRECTORY("${CMAKE_SOURCE_DIR}/plugins/mockplugin")	28	ADD_SUBDIRECTORY("${CMAKE_SOURCE_DIR}/plugins/mockplugin")
29		29
		30	# Sets AMDA server that will be used during execution.
		31	# Available values are:
		32	# - "default": default AMDA server
		33	# - "amdatest": AMDA test server
		34	# - "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)
		35	# - "localhost": use local AMDA server
		36	# Any other value will lead to the use of the default server
		37	ADD_DEFINITIONS(-DSCIQLOP_AMDA_SERVER="hybrid")
		38
30	set(sciqlop-amda_DIR "${CMAKE_SOURCE_DIR}/plugins/amda/cmake")	39	set(sciqlop-amda_DIR "${CMAKE_SOURCE_DIR}/plugins/amda/cmake")
31	set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${sciqlop-amda_DIR}")	40	set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${sciqlop-amda_DIR}")
32	ADD_SUBDIRECTORY("${CMAKE_SOURCE_DIR}/plugins/amda")	41	ADD_SUBDIRECTORY("${CMAKE_SOURCE_DIR}/plugins/amda")

meson.build +9 0

@@ -22,6 +22,15 elif host_machine.system()=='windows'
22	meson.add_install_script('build_cfg/windows/install_script.sh')	22	meson.add_install_script('build_cfg/windows/install_script.sh')
23	endif	23	endif
24		24
		25	# Sets AMDA server that will be used during execution.
		26	# Available values are:
		27	# - "default": default AMDA server
		28	# - "amdatest": AMDA test server
		29	# - "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)
		30	# - "localhost": use local AMDA server
		31	# Any other value will lead to the use of the default server
		32	add_project_arguments('-DSCIQLOP_AMDA_SERVER="hybrid"', language : 'cpp')
		33
25	subdir('core')	34	subdir('core')
26	subdir('gui')	35	subdir('gui')
27	subdir('app')	36	subdir('app')

plugins/amda/CMakeLists.txt +1 -1

             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)
             #

plugins/amda/include/AmdaPlugin.h +3 -3

             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;

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

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

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

plugins/amda/meson.build +3 -2

               'src/AmdaProvider.cpp',
               'src/AmdaResultParser.cpp',
               'src/AmdaResultParserDefs.cpp',
-              'src/AmdaResultParserHelper.cpp'
+              'src/AmdaResultParserHelper.cpp',
+              'src/AmdaServer.cpp'
             ]
             amdaplugin_ui_files = []
             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@'])

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

             #include "AmdaDefs.h"
             #include "AmdaParser.h"
             #include "AmdaProvider.h"
+            #include "AmdaServer.h"
             #include <DataSource/DataSourceController.h>
             #include <DataSource/DataSourceItem.h>
             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");
                 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(
             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 {

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>
             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
                 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")) {
                 // 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>();

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

             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_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 +33 -24

              * @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
              */
             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;
+                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;
             }
             /**
              * @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)));
                 });
             }
              * @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
              * @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
              * @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});
                 });
             }
             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)
                     // 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) {
             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)

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