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 +61 -53

@@ -10,10 +10,10
10	Q_LOGGING_CATEGORY(LOG_Variable, "Variable")	10	Q_LOGGING_CATEGORY(LOG_Variable, "Variable")
11		11
12	struct Variable::VariablePrivate {	12	struct Variable::VariablePrivate {
13	explicit VariablePrivate(const QString &name, const ~~SqpRange~~ &~~dateTime~~,	13	explicit VariablePrivate(const QString &name, const QVariantHash &metadata)
14	const QVariantHash &metadata)
15	: m_Name{name},	14	: m_Name{name},
16	m_Range{~~dateTime~~},	15	m_Range{INVALID_RANGE},
		16	m_CacheRange{INVALID_RANGE},
17	m_Metadata{metadata},	17	m_Metadata{metadata},
18	m_DataSeries{nullptr},	18	m_DataSeries{nullptr},
19	m_RealRange{INVALID_RANGE},	19	m_RealRange{INVALID_RANGE},
@@ -24,6 +24,7 struct Variable::VariablePrivate {
24	VariablePrivate(const VariablePrivate &other)	24	VariablePrivate(const VariablePrivate &other)
25	: m_Name{other.m_Name},	25	: m_Name{other.m_Name},
26	m_Range{other.m_Range},	26	m_Range{other.m_Range},
		27	m_CacheRange{other.m_CacheRange},
27	m_Metadata{other.m_Metadata},	28	m_Metadata{other.m_Metadata},
28	m_DataSeries{other.m_DataSeries != nullptr ? other.m_DataSeries->clone() : nullptr},	29	m_DataSeries{other.m_DataSeries != nullptr ? other.m_DataSeries->clone() : nullptr},
29	m_RealRange{other.m_RealRange},	30	m_RealRange{other.m_RealRange},
@@ -55,9 +56,10 struct Variable::VariablePrivate {
55	auto minXAxisIt = m_DataSeries->minXAxisData(m_Range.m_TStart);	56	auto minXAxisIt = m_DataSeries->minXAxisData(m_Range.m_TStart);
56	auto maxXAxisIt = m_DataSeries->maxXAxisData(m_Range.m_TEnd);	57	auto maxXAxisIt = m_DataSeries->maxXAxisData(m_Range.m_TEnd);
57		58
58	m_RealRange = (minXAxisIt != end && maxXAxisIt != end)	59	m_RealRange
59	? ~~SqpRange~~{minXAxisIt->x(), maxXAxisIt->x()}	60	= (minXAxisIt != end && maxXAxisIt != end && minXAxisIt->x() <= maxXAxisIt->x())
60	: INVALID_RANGE;	61	? SqpRange{minXAxisIt->x(), maxXAxisIt->x()}
		62	: INVALID_RANGE;
61	m_DataSeries->unlock();	63	m_DataSeries->unlock();
62	}	64	}
63	else {	65	else {
@@ -77,8 +79,8 struct Variable::VariablePrivate {
77	QReadWriteLock m_Lock;	79	QReadWriteLock m_Lock;
78	};	80	};
79		81
80	Variable::Variable(const QString &name, const ~~SqpRange~~ &~~dateTime~~, ~~const~~ QVariantHash &metadata)	82	Variable::Variable(const QString &name, const QVariantHash &metadata)
81	: impl{spimpl::make_unique_impl<VariablePrivate>(name, ~~dateTime~~, metadata)}	83	: impl{spimpl::make_unique_impl<VariablePrivate>(name, metadata)}
82	{	84	{
83	}	85	}
84		86
@@ -242,31 +244,35 bool Variable::cacheIsInside(const SqpRange &range) const noexcept
242	QVector<SqpRange> Variable::provideNotInCacheRangeList(const SqpRange &range) const noexcept	244	QVector<SqpRange> Variable::provideNotInCacheRangeList(const SqpRange &range) const noexcept
243	{	245	{
244	// This code assume that cach in contigue. Can return 0, 1 or 2 SqpRange	246	// This code assume that cach in contigue. Can return 0, 1 or 2 SqpRange
245
246	auto notInCache = QVector<SqpRange>{};	247	auto notInCache = QVector<SqpRange>{};
247		248	if (impl->m_CacheRange != INVALID_RANGE) {
248	if (!this->cacheContains(range)) {	249
249	if (range.m_TEnd <= impl->m_CacheRange.m_TStart	250	if (!this->cacheContains(range)) {
250	\|\| range.m_T~~Start~~ >= impl->m_CacheRange.m_T~~End~~) {	251	if (range.m_TEnd <= impl->m_CacheRange.m_TStart
251	notInCache << range;	252	\|\| range.m_TStart >= impl->m_CacheRange.m_TEnd) {
252	}	253	notInCache << range;
253	else if (range.m_TStart < impl->m_CacheRange.m_TStart	254	}
254	&& range.m_T~~End~~ <= impl->m_CacheRange.m_T~~End~~) {	255	else if (range.m_TStart < impl->m_CacheRange.m_TStart
255	~~notInCache~~ << ~~SqpRange~~{~~range~~.~~m_TStart~~, impl->m_CacheRange.m_T~~Start~~};	256	&& range.m_TEnd <= impl->m_CacheRange.m_TEnd) {
256	}	257	notInCache << SqpRange{range.m_TStart, impl->m_CacheRange.m_TStart};
257	else if (range.m_TStart < impl->m_CacheRange.m_TStart	258	}
258	&& range.m_T~~End~~ > impl->m_CacheRange.m_T~~End~~) {	259	else if (range.m_TStart < impl->m_CacheRange.m_TStart
259	~~notInCache~~ << ~~SqpRange~~{range.m_T~~Start~~, impl->m_CacheRange.m_T~~Start~~}	260	&& range.m_TEnd > impl->m_CacheRange.m_TEnd) {
260	<< SqpRange{impl->m_CacheRange.m_T~~End~~, ~~range~~.~~m_TEnd~~};	261	notInCache << SqpRange{range.m_TStart, impl->m_CacheRange.m_TStart}
261	}	262	<< SqpRange{impl->m_CacheRange.m_TEnd, range.m_TEnd};
262	else if (range.m_TStart < impl->m_CacheRange.m_TEnd) {	263	}
263	~~notInCache~~ << ~~SqpRange~~{impl->m_CacheRange.m_TEnd, ~~range~~.~~m_TEnd~~};	264	else if (range.m_TStart < impl->m_CacheRange.m_TEnd) {
264	}	265	notInCache << SqpRange{impl->m_CacheRange.m_TEnd, range.m_TEnd};
265	~~else~~ {	266	}
266	qCCritical(LOG_Variable()) << tr("Detection of unknown case.")	267	else {
267	<< QThread::currentThread();	268	qCCritical(LOG_Variable()) << tr("Detection of unknown case.")
		269	<< QThread::currentThread();
		270	}
268	}	271	}
269	}	272	}
		273	else {
		274	notInCache << range;
		275	}
270		276
271	return notInCache;	277	return notInCache;
272	}	278	}
@@ -277,29 +283,31 QVector<SqpRange> Variable::provideInCacheRangeList(const SqpRange &range) const
277		283
278	auto inCache = QVector<SqpRange>{};	284	auto inCache = QVector<SqpRange>{};
279		285
280		286	if (impl->m_CacheRange != INVALID_RANGE) {
281	if (this->intersect(range)) {	287
282	if (range.m_TStart <= impl->m_CacheRange.m_TStart	288	if (this->intersect(range)) {
283	&& range.m_T~~End~~ >= impl->m_CacheRange.m_TStart	289	if (range.m_TStart <= impl->m_CacheRange.m_TStart
284	&& range.m_TEnd < impl->m_CacheRange.m_T~~End~~) {	290	&& range.m_TEnd >= impl->m_CacheRange.m_TStart
285	~~inCache~~ << ~~SqpRange~~{impl->m_CacheRange.m_T~~Start~~, ~~range~~.~~m_TEnd~~};	291	&& range.m_TEnd < impl->m_CacheRange.m_TEnd) {
286	}	292	inCache << SqpRange{impl->m_CacheRange.m_TStart, range.m_TEnd};
287		293	}
288	else if (range.m_TStart >= impl->m_CacheRange.m_TStart	294
289	&& range.m_T~~End~~ <= impl->m_CacheRange.m_T~~End~~) {	295	else if (range.m_TStart >= impl->m_CacheRange.m_TStart
290	inCache << range;	296	&& range.m_TEnd <= impl->m_CacheRange.m_TEnd) {
291	}	297	inCache << range;
292	else if (range.m_TStart > impl->m_CacheRange.m_TStart	298	}
293	&& range.m_T~~End~~ > impl->m_CacheRange.m_T~~End~~) {	299	else if (range.m_TStart > impl->m_CacheRange.m_TStart
294	~~inCache~~ << ~~SqpRange~~{range.m_T~~Start~~, impl->m_CacheRange.m_TEnd};	300	&& range.m_TEnd > impl->m_CacheRange.m_TEnd) {
295	}	301	inCache << SqpRange{range.m_TStart, impl->m_CacheRange.m_TEnd};
296	else if (range.m_TStart <= impl->m_CacheRange.m_TStart	302	}
297	&& range.m_T~~End~~ >= impl->m_CacheRange.m_T~~End~~) {	303	else if (range.m_TStart <= impl->m_CacheRange.m_TStart
298	~~inCache~~ << impl->m_CacheRange;	304	&& range.m_TEnd >= impl->m_CacheRange.m_TEnd) {
299	}	305	inCache << impl->m_CacheRange;
300	~~else~~ {	306	}
301	qCCritical(LOG_Variable()) << tr("Detection of unknown case.")	307	else {
302	<< QThread::currentThread();	308	qCCritical(LOG_Variable()) << tr("Detection of unknown case.")
		309	<< QThread::currentThread();
		310	}
303	}	311	}
304	}	312	}
305		313

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