HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r1121:98220c931c83

Adds read compatibility for local AMDA server...

Alexandre Leroux -

r1121:98220c931c83

parent child

Context file:

r1121:98220c931c83

Collapse all files

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/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 +34 -25

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

	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