GIT_REPOSITORIES/LPP/Users/mperrinel/SCIQLOP-Initialisation Commit - r699:a7f60f6512e6

Fix bug when creating two variables crash the app. ...

perrinel -

r699:a7f60f6512e6

parent child

Context file:

r699:a7f60f6512e6

core/include/Variable/Variable.h +1 -2

                  Q_OBJECT
              public:
-                 explicit Variable(const QString &name, const SqpRange &dateTime,
-                                   const QVariantHash &metadata = {});
+                 explicit Variable(const QString &name, const QVariantHash &metadata = {});
                  /// Copy ctor
                  explicit Variable(const Variable &other);

core/include/Variable/VariableModel.h +1 -2

                  /**
                   * Creates a new variable in the model
                   * @param name the name of the new variable
-                  * @param dateTime the dateTime of the new variable
                   * @param metadata the metadata associated to the new variable
                   * @return the pointer to the new variable
                   */
-                 std::shared_ptr<Variable> createVariable(const QString &name, const SqpRange &dateTime,
+                 std::shared_ptr<Variable> createVariable(const QString &name,
                                                           const QVariantHash &metadata) noexcept;
                  /**

core/src/Variable/Variable.cpp +15 -7

              Q_LOGGING_CATEGORY(LOG_Variable, "Variable")
              struct Variable::VariablePrivate {
-                 explicit VariablePrivate(const QString &name, const SqpRange &dateTime,
-                                          const QVariantHash &metadata)
+                 explicit VariablePrivate(const QString &name, const QVariantHash &metadata)
                          : m_Name{name},
-                           m_Range{dateTime},
+                           m_Range{INVALID_RANGE},
+                           m_CacheRange{INVALID_RANGE},
                            m_Metadata{metadata},
                            m_DataSeries{nullptr},
                            m_RealRange{INVALID_RANGE},
                  VariablePrivate(const VariablePrivate &other)
                          : m_Name{other.m_Name},
                            m_Range{other.m_Range},
+                           m_CacheRange{other.m_CacheRange},
                            m_Metadata{other.m_Metadata},
                            m_DataSeries{other.m_DataSeries != nullptr ? other.m_DataSeries->clone() : nullptr},
                            m_RealRange{other.m_RealRange},
                          auto minXAxisIt = m_DataSeries->minXAxisData(m_Range.m_TStart);
                          auto maxXAxisIt = m_DataSeries->maxXAxisData(m_Range.m_TEnd);
-                         m_RealRange = (minXAxisIt != end && maxXAxisIt != end)
+                         m_RealRange
+                             = (minXAxisIt != end && maxXAxisIt != end && minXAxisIt->x() <= maxXAxisIt->x())
-                                           ? SqpRange{minXAxisIt->x(), maxXAxisIt->x()}
-                                           : INVALID_RANGE;
                          m_DataSeries->unlock();
                  QReadWriteLock m_Lock;
              };
-             Variable::Variable(const QString &name, const SqpRange &dateTime, const QVariantHash &metadata)
-                     : impl{spimpl::make_unique_impl<VariablePrivate>(name, dateTime, metadata)}
+             Variable::Variable(const QString &name, const QVariantHash &metadata)
+                     : impl{spimpl::make_unique_impl<VariablePrivate>(name, metadata)}
              {
              }
              QVector<SqpRange> Variable::provideNotInCacheRangeList(const SqpRange &range) const noexcept
              {
                  // This code assume that cach in contigue. Can return 0, 1 or 2 SqpRange
                  auto notInCache = QVector<SqpRange>{};
+                 if (impl->m_CacheRange != INVALID_RANGE) {
                  if (!this->cacheContains(range)) {
                      if (range.m_TEnd <= impl->m_CacheRange.m_TStart
                                                     << QThread::currentThread();
                      }
                  }
+                 }
+                 else {
+                     notInCache << range;
+                 }
                  return notInCache;
              }
                  auto inCache = QVector<SqpRange>{};
+                 if (impl->m_CacheRange != INVALID_RANGE) {
                  if (this->intersect(range)) {
                      if (range.m_TStart <= impl->m_CacheRange.m_TStart
                                                     << QThread::currentThread();
                      }
                  }
+                 }
                  return inCache;
              }

core/src/Variable/VariableController.cpp +2 -3

                  auto range = impl->m_TimeController->dateTime();
-                 if (auto newVariable = impl->m_VariableModel->createVariable(name, range, metadata)) {
+                 if (auto newVariable = impl->m_VariableModel->createVariable(name, metadata)) {
                      auto identifier = QUuid::createUuid();
                      // store the provider
                              varProvider);
                          if (!varRequestIdCanceled.isNull()) {
-                             qCDebug(LOG_VariableAcquisitionWorker()) << tr("varRequestIdCanceled: ")
+                             qCDebug(LOG_VariableAcquisitionWorker()) << tr("vsarRequestIdCanceled: ")
                                                                       << varRequestIdCanceled;
                              cancelVariableRequest(varRequestIdCanceled);
                          }
                      }
                  }
                  else {
                      varRequest.m_RangeRequested = varStrategyRangesRequested.first;
                      varRequest.m_CacheRangeRequested = varStrategyRangesRequested.second;
                      // store VarRequest

core/src/Variable/VariableModel.cpp +1 -2

              }
              std::shared_ptr<Variable> VariableModel::createVariable(const QString &name,
-                                                                     const SqpRange &dateTime,
                                                                      const QVariantHash &metadata) noexcept
              {
-                 auto variable = std::make_shared<Variable>(name, dateTime, metadata);
+                 auto variable = std::make_shared<Variable>(name, metadata);
                  addVariable(variable);
                  return variable;

core/tests/Variable/TestVariable.cpp +5 -2

                  auto varCRS = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 0, 0}};
                  auto varCRE = QDateTime{QDate{2017, 01, 01}, QTime{2, 4, 0, 0}};
                  auto sqpCR
                      = SqpRange{DateUtils::secondsSinceEpoch(varCRS), DateUtils::secondsSinceEpoch(varCRE)};
-                 Variable var{"Var test", sqpR};
+                 Variable var{"Var test"};
+                 var.setRange(sqpR);
                  var.setCacheRange(sqpCR);
                  // 1: [ts,te] < varTS
                  auto sqpCR
                      = SqpRange{DateUtils::secondsSinceEpoch(varCRS), DateUtils::secondsSinceEpoch(varCRE)};
-                 Variable var{"Var test", sqpR};
+                 Variable var{"Var test"};
+                 var.setRange(sqpR);
                  var.setCacheRange(sqpCR);
                  // 1: [ts,te] < varTS

core/tests/Variable/TestVariableCacheController.cpp +4 -2

                  auto te2 = QDateTime{QDate{2017, 01, 01}, QTime{2, 20, 0, 0}};
                  auto sqp2 = SqpRange{DateUtils::secondsSinceEpoch(ts2), DateUtils::secondsSinceEpoch(te2)};
-                 auto var0 = std::make_shared<Variable>("", sqp0);
+                 auto var0 = std::make_shared<Variable>("");
+                 var0->setRange(sqp0);
                  variableCacheController.addDateTime(var0, sqp0);
                  variableCacheController.addDateTime(var0, sqp1);
                  auto sqp03 = SqpRange{DateUtils::secondsSinceEpoch(ts03), DateUtils::secondsSinceEpoch(te03)};
-                 auto var0 = std::make_shared<Variable>("", sqp0);
+                 auto var0 = std::make_shared<Variable>("");
+                 var0->setRange(sqp0);
                  // First case: add the first interval to the variable :sqp0

plugins/amda/src/AmdaProvider.cpp +1 -3

                  auto acqIdToRequestProgressMapIt = m_AcqIdToRequestProgressMap.find(acqIdentifier);
                  if (acqIdToRequestProgressMapIt != m_AcqIdToRequestProgressMap.end()) {
-                     qCDebug(LOG_AmdaProvider()) << tr("1 onReplyDownloadProgress found") << progress;
                      auto requestPtr = networkRequest;
                      auto findRequest = [requestPtr](const auto &entry) { return requestPtr == entry.first; };
                      qCCritical(LOG_AmdaProvider()) << tr("Can't retrieve data: unknown product id");
                      return;
                  }
-                 qCDebug(LOG_AmdaProvider()) << tr("AmdaProvider::retrieveData") << dateTime;
                  // Retrieves the data type that determines whether the expected format for the result file is
                  // scalar, vector...
                            if (reply->error() != QNetworkReply::OperationCanceledError) {
                                auto downloadFileUrl = QUrl{QString{reply->readAll()}};
-                               qCInfo(LOG_AmdaProvider())
+                               qCDebug(LOG_AmdaProvider())
                                    << tr("TORM AmdaProvider::retrieveData downloadFileUrl:") << downloadFileUrl;
                                // Executes request for downloading file //

plugins/amda/tests/TestAmdaAcquisition.cpp 0 -2

                  auto var = vc.createVariable("bx_gse", metaData, provider);
                  // 1 : Variable creation
-                 QCOMPARE(var->range().m_TStart, sqpR.m_TStart);
-                 QCOMPARE(var->range().m_TEnd, sqpR.m_TEnd);
                  qDebug() << " 1: TIMECONTROLLER" << timeController->dateTime();
                  qDebug() << " 1: RANGE     " << var->range();

General Comments 2

perrinel

|

Pull request updated. Auto status change to "Under Review"

Changed commits:
  * 2 added
  * 0 removed

Changed files:
  * A core/include/Variable/VariableAcquisitionWorker.h
  * M core/include/Data/IDataProvider.h
  * M core/include/Variable/VariableController.h
  * M core/src/Network/NetworkController.cpp
  * M core/src/Variable/VariableAcquisitionWorker.cpp
  * M core/src/Variable/VariableController.cpp
  * M plugins/amda/src/AmdaProvider.cpp

Write
Preview

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

	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