GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r987:49134789d5f3

Parser refactoring (3)...

Alexandre Leroux -

r987:49134789d5f3

parent child

Context file:

r987:49134789d5f3

Collapse all files

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

@@ -0,0 +1,35
	1	#ifndef SCIQLOP_AMDARESULTPARSERDEFS_H
	2	#define SCIQLOP_AMDARESULTPARSERDEFS_H
	3
	4	#include <QtCore/QRegularExpression>
	5	#include <QtCore/QString>
	6	#include <QtCore/QVariantHash>
	7
	8	// ////////// //
	9	// Properties //
	10	// ////////// //
	11
	12	/// Alias to represent properties read in the header of AMDA file
	13	using Properties = QVariantHash;
	14
	15	extern const QString X_AXIS_UNIT_PROPERTY;
	16
	17	// /////////////////// //
	18	// Regular expressions //
	19	// /////////////////// //
	20
	21	// AMDA V2
	22	// /// ... PARAMETER_UNITS : nT ...
	23	// /// ... PARAMETER_UNITS:nT ...
	24	// /// ... PARAMETER_UNITS: m² ...
	25	// /// ... PARAMETER_UNITS : m/s ...
	26	// const auto UNIT_REGEX = QRegularExpression{QStringLiteral("\\sPARAMETER_UNITS\\s:\\s*(.+)")};
	27
	28	/// Regex to find x-axis unit in a line. Examples of valid lines:
	29	/// ... - Units : nT - ...
	30	/// ... -Units:nT- ...
	31	/// ... -Units: m²- ...
	32	/// ... - Units : m/s - ...
	33	extern const QRegularExpression DEFAULT_X_AXIS_UNIT_REGEX;
	34
	35	#endif // SCIQLOP_AMDARESULTPARSERDEFS_H

plugins/amda/src/AmdaResultParserDefs.cpp created 644 +6 0

@@ -0,0 +1,6
	1	#include "AmdaResultParserDefs.h"
	2
	3	const QString X_AXIS_UNIT_PROPERTY = QStringLiteral("xAxisUnit");
	4
	5	const QRegularExpression DEFAULT_X_AXIS_UNIT_REGEX
	6	= QRegularExpression{QStringLiteral("-\\sUnits\\s:\\s(.+?)\\s-")};

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

             #ifndef SCIQLOP_UNIT_H
             #define SCIQLOP_UNIT_H
+            #include <Common/MetaTypes.h>
             #include <QString>
             #include <tuple>
             struct Unit {
                 explicit Unit(const QString &name = {}, bool timeUnit = false)
                         : m_Name{name}, m_TimeUnit{timeUnit}
                 {
                 }
                 inline bool operator==(const Unit &other) const
                 {
                     return std::tie(m_Name, m_TimeUnit) == std::tie(other.m_Name, other.m_TimeUnit);
                 }
                 inline bool operator!=(const Unit &other) const { return !(*this == other); }
                 QString m_Name;  ///< Unit name
                 bool m_TimeUnit; ///< The unit is a unit of time (UTC)
             };
+            SCIQLOP_REGISTER_META_TYPE(UNIT_REGISTRY, Unit)
             #endif // SCIQLOP_UNIT_H

core/tests/Data/TestOptionalAxis.cpp 0 -1

             #include <Data/ArrayData.h>
             #include <Data/OptionalAxis.h>
             #include <QObject>
             #include <QtTest>
             Q_DECLARE_METATYPE(OptionalAxis)
-            Q_DECLARE_METATYPE(Unit)
             class TestOptionalAxis : public QObject {
                 Q_OBJECT
             private slots:
                 /// Tests the creation of a undefined axis
                 void testNotDefinedAxisCtor();
                 /// Tests the creation of a undefined axis
                 void testDefinedAxisCtor_data();
                 void testDefinedAxisCtor();
                 /// Tests @sa OptionalAxis::at() method
                 void testAt_data();
                 void testAt();
                 /// Tests @sa OptionalAxis::size() method
                 void testSize_data();
                 void testSize();
                 /// Tests @sa OptionalAxis::unit() method
                 void testUnit_data();
                 void testUnit();
             };
             void TestOptionalAxis::testNotDefinedAxisCtor()
             {
                 OptionalAxis notDefinedAxis{};
                 QVERIFY(!notDefinedAxis.isDefined());
             }
             void TestOptionalAxis::testDefinedAxisCtor_data()
             {
                 QTest::addColumn<bool>("noData"); // If set to true, nullptr is passed as data of the axis
                 QTest::addColumn<std::vector<double> >(
                     "data"); // Values assigned to the axis when 'noData' flag is set to false
                 QTest::addColumn<Unit>("unit"); // Unit assigned to the axis
                 QTest::newRow("validData") << false << std::vector<double>{1, 2, 3} << Unit{"Hz"};
                 QTest::newRow("invalidData") << true << std::vector<double>{} << Unit{"Hz"};
             }
             void TestOptionalAxis::testDefinedAxisCtor()
             {
                 QFETCH(bool, noData);
                 QFETCH(Unit, unit);
                 // When there is no data, we expect that the constructor returns exception
                 if (noData) {
                     QVERIFY_EXCEPTION_THROWN(OptionalAxis(nullptr, unit), std::invalid_argument);
                 }
                 else {
                     QFETCH(std::vector<double>, data);
                     OptionalAxis axis{std::make_shared<ArrayData<1> >(data), unit};
                     QVERIFY(axis.isDefined());
                 }
             }
             void TestOptionalAxis::testAt_data()
             {
                 QTest::addColumn<OptionalAxis>("axis");    // Axis used for test case (defined or not)
                 QTest::addColumn<int>("index");            // Index to test in the axis
                 QTest::addColumn<double>("expectedValue"); // Expected axis value for the index
                 OptionalAxis definedAxis{std::make_shared<ArrayData<1> >(std::vector<double>{1, 2, 3}),
                                          Unit{"Hz"}};
                 QTest::newRow("data1") << definedAxis << 0 << 1.;
                 QTest::newRow("data2") << definedAxis << 1 << 2.;
                 QTest::newRow("data3") << definedAxis << 2 << 3.;
                 QTest::newRow("data4 (index out of bounds)")
                     << definedAxis << 3
                     << std::numeric_limits<double>::quiet_NaN(); // Expects NaN for out of bounds index
                 QTest::newRow("data5 (index out of bounds)")
                     << definedAxis << -1
                     << std::numeric_limits<double>::quiet_NaN(); // Expects NaN for out of bounds index
                 QTest::newRow("data6 (axis not defined)")
                     << OptionalAxis{} << 0
                     << std::numeric_limits<double>::quiet_NaN(); // Expects NaN for undefined axis
             }
             void TestOptionalAxis::testAt()
             {
                 QFETCH(OptionalAxis, axis);
                 QFETCH(int, index);
                 QFETCH(double, expectedValue);
                 auto value = axis.at(index);
                 QVERIFY((std::isnan(value) && std::isnan(expectedValue)) || value == expectedValue);
             }
             void TestOptionalAxis::testSize_data()
             {
                 QTest::addColumn<OptionalAxis>("axis"); // Axis used for test case (defined or not)
                 QTest::addColumn<int>("expectedSize");  // Expected number of data in the axis
                 // Lambda that creates default defined axis (with the values passed in parameter)
                 auto axis = [](std::vector<double> values) {
                     return OptionalAxis{std::make_shared<ArrayData<1> >(std::move(values)), Unit{"Hz"}};
                 };
                 QTest::newRow("data1") << axis({}) << 0;
                 QTest::newRow("data2") << axis({1, 2, 3}) << 3;
                 QTest::newRow("data3") << axis({1, 2, 3, 4}) << 4;
                 QTest::newRow("data4 (axis not defined)") << OptionalAxis{}
                                                           << 0; // Expects 0 for undefined axis
             }
             void TestOptionalAxis::testSize()
             {
                 QFETCH(OptionalAxis, axis);
                 QFETCH(int, expectedSize);
                 QCOMPARE(axis.size(), expectedSize);
             }
             void TestOptionalAxis::testUnit_data()
             {
                 QTest::addColumn<OptionalAxis>("axis"); // Axis used for test case (defined or not)
                 QTest::addColumn<Unit>("expectedUnit"); // Expected unit for the axis
                 // Lambda that creates default defined axis (with the unit passed in parameter)
                 auto axis = [](Unit unit) {
                     return OptionalAxis{std::make_shared<ArrayData<1> >(std::vector<double>{1, 2, 3}), unit};
                 };
                 QTest::newRow("data1") << axis(Unit{"Hz"}) << Unit{"Hz"};
                 QTest::newRow("data2") << axis(Unit{"t", true}) << Unit{"t", true};
                 QTest::newRow("data3 (axis not defined)") << OptionalAxis{}
                                                           << Unit{}; // Expects default unit for undefined axis
             }
             void TestOptionalAxis::testUnit()
             {
                 QFETCH(OptionalAxis, axis);
                 QFETCH(Unit, expectedUnit);
                 QCOMPARE(axis.unit(), expectedUnit);
             }
             QTEST_MAIN(TestOptionalAxis)
             #include "TestOptionalAxis.moc"

plugins/amda/include/AmdaResultParserHelper.h +8 0

             #ifndef SCIQLOP_AMDARESULTPARSERHELPER_H
             #define SCIQLOP_AMDARESULTPARSERHELPER_H
+            #include "AmdaResultParserDefs.h"
             #include <QtCore/QLoggingCategory>
             #include <QtCore/QString>
             #include <memory>
             class IDataSeries;
             Q_DECLARE_LOGGING_CATEGORY(LOG_AmdaResultParserHelper)
             /**
              * Helper used to interpret the data of an AMDA result file and generate the corresponding data
              * series.
              *
              * It proposes methods allowing to read line by line an AMDA file and to extract the properties
              * (from the header) and the values corresponding to the data series
              *
              * @sa DataSeries
              */
             struct IAmdaResultParserHelper {
                 virtual ~IAmdaResultParserHelper() noexcept = default;
                 /// Verifies that the extracted properties are well formed and possibly applies other treatments
                 /// on them
                 /// @return true if the properties are well formed, false otherwise
                 virtual bool checkProperties() = 0;
                 /// Creates the data series from the properties and values extracted from the AMDA file.
                 /// @warning as the data are moved in the data series, the helper shouldn't be used after
                 /// calling this method
                 /// @return the data series created
                 virtual std::shared_ptr<IDataSeries> createSeries() = 0;
                 /// Reads a line from the AMDA file to extract a property that will be used to generate the data
                 /// series
                 /// @param line tahe line to interpret
                 virtual void readPropertyLine(const QString &line) = 0;
                 /// Reads a line from the AMDA file to extract a value that will be set in the data series
                 /// @param line the line to interpret
                 virtual void readResultLine(const QString &line) = 0;
             };
             /**
              * Implementation of @sa IAmdaResultParserHelper for scalars
              */
             class ScalarParserHelper : public IAmdaResultParserHelper {
             public:
                 bool checkProperties() override;
                 std::shared_ptr<IDataSeries> createSeries() override;
                 void readPropertyLine(const QString &line) override;
                 void readResultLine(const QString &line) override;
+            private:
+                Properties m_Properties{};
             };
             /**
              * Implementation of @sa IAmdaResultParserHelper for vectors
              */
             class VectorParserHelper : public IAmdaResultParserHelper {
             public:
                 bool checkProperties() override;
                 std::shared_ptr<IDataSeries> createSeries() override;
                 void readPropertyLine(const QString &line) override;
                 void readResultLine(const QString &line) override;
+            private:
+                Properties m_Properties{};
             };
             #endif // SCIQLOP_AMDARESULTPARSERHELPER_H

plugins/amda/meson.build +1 0

             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'
             ]
             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"',
                              '-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/AmdaResultParserHelper.cpp +73 -4

@@ -1,51 +1,120
1	#include "AmdaResultParserHelper.h"	1	#include "AmdaResultParserHelper.h"
2		2
		3	#include <Data/Unit.h>
		4
3	Q_LOGGING_CATEGORY(LOG_AmdaResultParserHelper, "AmdaResultParserHelper")	5	Q_LOGGING_CATEGORY(LOG_AmdaResultParserHelper, "AmdaResultParserHelper")
4		6
		7	namespace {
		8
		9	// /////// //
		10	// Methods //
		11	// /////// //
		12
		13	/**
		14	* Checks that the properties contain a specific unit and that this unit is valid
		15	* @param properties the properties map in which to search unit
		16	* @param key the key to search for the unit in the properties
		17	* @param errorMessage the error message to log in case the unit is invalid
		18	* @return true if the unit is valid, false it it's invalid or was not found in the properties
		19	*/
		20	bool checkUnit(const Properties &properties, const QString &key, const QString &errorMessage)
		21	{
		22	auto unit = properties.value(key).value<Unit>();
		23	if (unit.m_Name.isEmpty()) {
		24	qCWarning(LOG_AmdaResultParserHelper()) << errorMessage;
		25	return false;
		26	}
		27
		28	return true;
		29	}
		30
		31	/**
		32	* Reads a line from the AMDA file and tries to extract a property from it
		33	* @param properties the properties map in which to put the property extracted from the line
		34	* @param key the key to which the property is added in the properties map
		35	* @param line the line to read to extract the property
		36	* @param regex the expected regex to extract the property. If the line matches this regex, the
		37	* property is generated
		38	* @param fun the function used to generate the property
		39	* @return true if the property could be generated, false if the line does not match the regex, or
		40	* if a property has already been generated for the key
		41	*/
		42	template <typename GeneratePropertyFun>
		43	bool tryReadProperty(Properties &properties, const QString &key, const QString &line,
		44	const QRegularExpression &regex, GeneratePropertyFun fun)
		45	{
		46	if (properties.contains(key)) {
		47	return false;
		48	}
		49
		50	auto match = regex.match(line);
		51	if (match.hasMatch()) {
		52	properties.insert(key, fun(match));
		53	}
		54
		55	return match.hasMatch();
		56	}
		57
		58	/**
		59	* Reads a line from the AMDA file and tries to extract a unit from it
		60	* @sa tryReadProperty()
		61	*/
		62	bool tryReadUnit(Properties &properties, const QString &key, const QString &line,
		63	const QRegularExpression &regex, bool timeUnit = false)
		64	{
		65	return tryReadProperty(properties, key, line, regex, [timeUnit](const auto &match) {
		66	return QVariant::fromValue(Unit{match.captured(1), timeUnit});
		67	});
		68	}
		69
		70	} // namespace
		71
5	// ////////////////// //	72	// ////////////////// //
6	// ScalarParserHelper //	73	// ScalarParserHelper //
7	// ////////////////// //	74	// ////////////////// //
8		75
9	bool ScalarParserHelper::checkProperties()	76	bool ScalarParserHelper::checkProperties()
10	{	77	{
11	/// @todo ALX	78	return checkUnit(m_Properties, X_AXIS_UNIT_PROPERTY,
		79	QObject::tr("The x-axis unit could not be found in the file"));
12	}	80	}
13		81
14	std::shared_ptr<IDataSeries> ScalarParserHelper::createSeries()	82	std::shared_ptr<IDataSeries> ScalarParserHelper::createSeries()
15	{	83	{
16	/// @todo ALX	84	/// @todo ALX
17	}	85	}
18		86
19	void ScalarParserHelper::readPropertyLine(const QString &line)	87	void ScalarParserHelper::readPropertyLine(const QString &line)
20	{	88	{
21	/// @todo ALX	89	tryReadUnit(m_Properties, X_AXIS_UNIT_PROPERTY, line, DEFAULT_X_AXIS_UNIT_REGEX, true);
22	}	90	}
23		91
24	void ScalarParserHelper::readResultLine(const QString &line)	92	void ScalarParserHelper::readResultLine(const QString &line)
25	{	93	{
26	/// @todo ALX	94	/// @todo ALX
27	}	95	}
28		96
29	// ////////////////// //	97	// ////////////////// //
30	// VectorParserHelper //	98	// VectorParserHelper //
31	// ////////////////// //	99	// ////////////////// //
32		100
33	bool VectorParserHelper::checkProperties()	101	bool VectorParserHelper::checkProperties()
34	{	102	{
35	/// @todo ALX	103	return checkUnit(m_Properties, X_AXIS_UNIT_PROPERTY,
		104	QObject::tr("The x-axis unit could not be found in the file"));
36	}	105	}
37		106
38	std::shared_ptr<IDataSeries> VectorParserHelper::createSeries()	107	std::shared_ptr<IDataSeries> VectorParserHelper::createSeries()
39	{	108	{
40	/// @todo ALX	109	/// @todo ALX
41	}	110	}
42		111
43	void VectorParserHelper::readPropertyLine(const QString &line)	112	void VectorParserHelper::readPropertyLine(const QString &line)
44	{	113	{
45	/// @todo ALX	114	tryReadUnit(m_Properties, X_AXIS_UNIT_PROPERTY, line, DEFAULT_X_AXIS_UNIT_REGEX, true);
46	}	115	}
47		116
48	void VectorParserHelper::readResultLine(const QString &line)	117	void VectorParserHelper::readResultLine(const QString &line)
49	{	118	{
50	/// @todo ALX	119	/// @todo ALX
51	}	120	}

General Comments 0

Write
Preview

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

No TODOs yet

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

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