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,
+                explicit Variable(const QString &name, const QVariantHash &metadata = {});
-                                  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,
+                explicit VariablePrivate(const QString &name, const QVariantHash &metadata)
-                                         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)
+            Variable::Variable(const QString &name, const QVariantHash &metadata)
-                    : impl{spimpl::make_unique_impl<VariablePrivate>(name, dateTime, 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