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
-                 = QRegularExpression{QStringLiteral("\\s*PARAMETER_UNITS\\s*:\\s*(.*)")};
+             const QRegularExpression SPECTROGRAM_VALUES_UNIT_REGEX = PARAMETER_UNITS_REGEX;

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);
-                 if (match.hasMatch()) {
+                 // Searches for a match among all possible regexes
+                 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

	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