HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r1275:73d2a50d0c6d

Merge branch 'feature/AcqFixes' into develop

Alexandre Leroux -

r1275:73d2a50d0c6d

parent child

Context file:

r1275:73d2a50d0c6d

Collapse all files

core/src/Variable/VariableController.cpp +52 -19

@@ -136,6 +136,9 struct VariableController::VariableControllerPrivate {
136	void cancelVariableRequest(QUuid varRequestId);	136	void cancelVariableRequest(QUuid varRequestId);
137	void executeVarRequest(std::shared_ptr<Variable> var, VariableRequest &varRequest);	137	void executeVarRequest(std::shared_ptr<Variable> var, VariableRequest &varRequest);
138		138
		139	template <typename VariableIterator>
		140	void desynchronize(VariableIterator variableIt, const QUuid &syncGroupId);
		141
139	QMutex m_WorkingMutex;	142	QMutex m_WorkingMutex;
140	/// Variable model. The VariableController has the ownership	143	/// Variable model. The VariableController has the ownership
141	VariableModel *m_VariableModel;	144	VariableModel *m_VariableModel;
@@ -258,8 +261,22 void VariableController::deleteVariable(std::shared_ptr<Variable> variable) noex
258	// make some treatments before the deletion	261	// make some treatments before the deletion
259	emit variableAboutToBeDeleted(variable);	262	emit variableAboutToBeDeleted(variable);
260		263
		264	auto variableIt = impl->m_VariableToIdentifierMap.find(variable);
		265	Q_ASSERT(variableIt != impl->m_VariableToIdentifierMap.cend());
		266
		267	auto variableId = variableIt->second;
		268
		269	// Removes variable's handler
		270	impl->m_VarIdToVarRequestHandler.erase(variableId);
		271
		272	// Desynchronizes variable (if the variable is in a sync group)
		273	auto syncGroupIt = impl->m_VariableIdGroupIdMap.find(variableId);
		274	if (syncGroupIt != impl->m_VariableIdGroupIdMap.cend()) {
		275	impl->desynchronize(variableIt, syncGroupIt->second);
		276	}
		277
261	// Deletes identifier	278	// Deletes identifier
262	impl->m_VariableToIdentifierMap.erase(variable);	279	impl->m_VariableToIdentifierMap.erase(variableIt);
263		280
264	// Deletes provider	281	// Deletes provider
265	auto nbProvidersDeleted = impl->m_VariableToProviderMap.erase(variable);	282	auto nbProvidersDeleted = impl->m_VariableToProviderMap.erase(variable);
@@ -545,23 +562,7 void VariableController::desynchronize(std::shared_ptr<Variable> variable,
545	return;	562	return;
546	}	563	}
547		564
548	// Gets synchronization group	565	impl->desynchronize(variableIt, synchronizationGroupId);
549	auto groupIt = impl->m_GroupIdToVariableSynchronizationGroupMap.find(synchronizationGroupId);
550	if (groupIt == impl->m_GroupIdToVariableSynchronizationGroupMap.cend()) {
551	qCCritical(LOG_VariableController())
552	<< tr("Can't desynchronize variable %1: unknown synchronization group")
553	.arg(variable->name());
554	return;
555	}
556
557	auto variableId = variableIt->second;
558
559	// Removes variable from synchronization group
560	auto synchronizationGroup = groupIt->second;
561	synchronizationGroup->removeVariableId(variableId);
562
563	// Removes link between variable and synchronization group
564	impl->m_VariableIdGroupIdMap.erase(variableId);
565	}	566	}
566		567
567	void VariableController::onRequestDataLoading(QVector<std::shared_ptr<Variable> > variables,	568	void VariableController::onRequestDataLoading(QVector<std::shared_ptr<Variable> > variables,
@@ -933,6 +934,7 void VariableController::VariableControllerPrivate::updateVariableRequest(QUuid
933	varHandler->m_PendingVarRequest = VariableRequest{};	934	varHandler->m_PendingVarRequest = VariableRequest{};
934	auto var = findVariable(itVarHandler->first);	935	auto var = findVariable(itVarHandler->first);
935	executeVarRequest(var, varHandler->m_RunningVarRequest);	936	executeVarRequest(var, varHandler->m_RunningVarRequest);
		937	updateVariables(varHandler->m_RunningVarRequest.m_VariableGroupId);
936	break;	938	break;
937	}	939	}
938	default:	940	default:
@@ -1032,7 +1034,14 void VariableController::VariableControllerPrivate::executeVarRequest(std::share
1032	{	1034	{
1033	qCDebug(LOG_VariableController()) << tr("TORM: executeVarRequest");	1035	qCDebug(LOG_VariableController()) << tr("TORM: executeVarRequest");
1034		1036
1035	auto varId = m_VariableToIdentifierMap.at(var);	1037	auto varIdIt = m_VariableToIdentifierMap.find(var);
		1038	if (varIdIt == m_VariableToIdentifierMap.cend()) {
		1039	qCWarning(LOG_VariableController()) << tr(
		1040	"Can't execute request of a variable that is not registered (may has been deleted)");
		1041	return;
		1042	}
		1043
		1044	auto varId = varIdIt->second;
1036		1045
1037	auto varCacheRange = var->cacheRange();	1046	auto varCacheRange = var->cacheRange();
1038	auto varCacheRangeRequested = varRequest.m_CacheRangeRequested;	1047	auto varCacheRangeRequested = varRequest.m_CacheRangeRequested;
@@ -1067,3 +1076,27 void VariableController::VariableControllerPrivate::executeVarRequest(std::share
1067	var->dataSeries()->subDataSeries(varRequest.m_CacheRangeRequested));	1076	var->dataSeries()->subDataSeries(varRequest.m_CacheRangeRequested));
1068	}	1077	}
1069	}	1078	}
		1079
		1080	template <typename VariableIterator>
		1081	void VariableController::VariableControllerPrivate::desynchronize(VariableIterator variableIt,
		1082	const QUuid &syncGroupId)
		1083	{
		1084	const auto &variable = variableIt->first;
		1085	const auto &variableId = variableIt->second;
		1086
		1087	// Gets synchronization group
		1088	auto groupIt = m_GroupIdToVariableSynchronizationGroupMap.find(syncGroupId);
		1089	if (groupIt == m_GroupIdToVariableSynchronizationGroupMap.cend()) {
		1090	qCCritical(LOG_VariableController())
		1091	<< tr("Can't desynchronize variable %1: unknown synchronization group")
		1092	.arg(variable->name());
		1093	return;
		1094	}
		1095
		1096	// Removes variable from synchronization group
		1097	auto synchronizationGroup = groupIt->second;
		1098	synchronizationGroup->removeVariableId(variableId);
		1099
		1100	// Removes link between variable and synchronization group
		1101	m_VariableIdGroupIdMap.erase(variableId);
		1102	}

gui/include/Visualization/VisualizationGraphWidget.h +16 -2

             class VisualizationGraphWidget;
             } // namespace Ui
+            /// Defines options that can be associated with the graph
+            enum GraphFlag {
+                DisableAll = 0x0,        ///< Disables acquisition and synchronization
+                EnableAcquisition = 0x1, ///< When this flag is set, the change of the graph's range leads to
+                                         /// the acquisition of data
+                EnableSynchronization = 0x2, ///< When this flag is set, the change of the graph's range causes
+                                             /// the call to the synchronization of the graphs contained in the
+                /// same zone of this graph
+                EnableAll = ~DisableAll ///< Enables acquisition and synchronization
+            };
+            Q_DECLARE_FLAGS(GraphFlags, GraphFlag)
+            Q_DECLARE_OPERATORS_FOR_FLAGS(GraphFlags)
             class VisualizationGraphWidget : public VisualizationDragWidget, public IVisualizationWidget {
                 Q_OBJECT
                 /// Returns the main VisualizationWidget which contains the graph or nullptr
                 VisualizationWidget *parentVisualizationWidget() const;
-                /// If acquisition isn't enable, requestDataLoading signal cannot be emit
+                /// Sets graph options
-                void enableAcquisition(bool enable);
+                void setFlags(GraphFlags flags);
                 void addVariable(std::shared_ptr<Variable> variable, SqpRange range);

gui/src/Visualization/VisualizationGraphWidget.cpp +17 -16

                 explicit VisualizationGraphWidgetPrivate(const QString &name)
                         : m_Name{name},
-                          m_DoAcquisition{true},
+                          m_Flags{GraphFlag::EnableAll},
                           m_IsCalibration{false},
                           m_RenderingDelegate{nullptr}
                 {
                 QString m_Name;
                 // 1 variable -> n qcpplot
                 std::map<std::shared_ptr<Variable>, PlottablesMap> m_VariableToPlotMultiMap;
-                bool m_DoAcquisition;
+                GraphFlags m_Flags;
                 bool m_IsCalibration;
                 /// Delegate used to attach rendering features to the plot
                 std::unique_ptr<VisualizationGraphRenderingDelegate> m_RenderingDelegate;
                 return qobject_cast<VisualizationWidget *>(parent);
             }
-            void VisualizationGraphWidget::enableAcquisition(bool enable)
+            void VisualizationGraphWidget::setFlags(GraphFlags flags)
             {
-                impl->m_DoAcquisition = enable;
+                impl->m_Flags = std::move(flags);
             }
             void VisualizationGraphWidget::addVariable(std::shared_ptr<Variable> variable, SqpRange range)
                 connect(variable.get(), SIGNAL(updated()), this, SLOT(onDataCacheVariableUpdated()));
-                this->enableAcquisition(false);
+                this->setFlags(GraphFlag::DisableAll);
                 this->setGraphRange(range);
-                this->enableAcquisition(true);
+                this->setFlags(GraphFlag::EnableAll);
                 emit requestDataLoading(QVector<std::shared_ptr<Variable> >() << variable, range, false);
             {
                 qCDebug(LOG_VisualizationGraphWidget()) << tr("TORM: VisualizationGraphWidget::onRangeChanged")
                                                         << QThread::currentThread()->objectName() << "DoAcqui"
-                                                        << impl->m_DoAcquisition;
+                                                        << impl->m_Flags.testFlag(GraphFlag::EnableAcquisition);
                 auto graphRange = SqpRange{t1.lower, t1.upper};
                 auto oldGraphRange = SqpRange{t2.lower, t2.upper};
-                if (impl->m_DoAcquisition) {
+                if (impl->m_Flags.testFlag(GraphFlag::EnableAcquisition)) {
                     QVector<std::shared_ptr<Variable> > variableUnderGraphVector;
                     for (auto it = impl->m_VariableToPlotMultiMap.begin(),
                     }
                     emit requestDataLoading(std::move(variableUnderGraphVector), graphRange,
                                             !impl->m_IsCalibration);
+                }
-                    if (!impl->m_IsCalibration) {
+                if (impl->m_Flags.testFlag(GraphFlag::EnableSynchronization) && !impl->m_IsCalibration) {
-                        qCDebug(LOG_VisualizationGraphWidget())
+                    qCDebug(LOG_VisualizationGraphWidget())
-                            << tr("TORM: VisualizationGraphWidget::Synchronize notify !!")
+                        << tr("TORM: VisualizationGraphWidget::Synchronize notify !!")
-                            << QThread::currentThread()->objectName() << graphRange << oldGraphRange;
+                        << QThread::currentThread()->objectName() << graphRange << oldGraphRange;
-                        emit synchronize(graphRange, oldGraphRange);
+                    emit synchronize(graphRange, oldGraphRange);
                 }
                 auto pos = mapFromGlobal(QCursor::pos());
                 else {
                     qCWarning(LOG_VisualizationGraphWidget()) << "onMouseMove: No parent zone widget";
                 }
+                // Quits calibration
+                impl->m_IsCalibration = false;
             }
             void VisualizationGraphWidget::onMouseDoubleClick(QMouseEvent *event) noexcept
                 impl->endDrawingZone(this);
-                impl->m_IsCalibration = false;
                 // Selection / Deselection
                 auto isSelectionZoneMode
                     = sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::SelectionZones;

gui/src/Visualization/VisualizationZoneWidget.cpp +6 -6

                                     // No action
                                     break;
                             }
-                            graphChild->enableAcquisition(false);
+                            graphChild->setFlags(GraphFlag::DisableAll);
-                            qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: Range before: ")
+                            qCDebug(LOG_VisualizationZoneWidget())
-                                                                   << graphChild->graphRange();
+                                << tr("TORM: Range before: ") << graphChild->graphRange();
-                            qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: Range after : ")
+                            qCDebug(LOG_VisualizationZoneWidget())
-                                                                   << graphChildRange;
+                                << tr("TORM: Range after : ") << graphChildRange;
                             qCDebug(LOG_VisualizationZoneWidget())
                                 << tr("TORM: child dt") << graphChildRange.m_TEnd - graphChildRange.m_TStart;
                             graphChild->setGraphRange(graphChildRange);
-                            graphChild->enableAcquisition(true);
+                            graphChild->setFlags(GraphFlag::EnableAll);
                         }
                     }
                 };

gui/src/Visualization/operations/RescaleAxeOperation.cpp +4 -2

                 if (graphWidget) {
                     // If the widget contains the variable, rescale it
                     if (impl->m_Variable && graphWidget->contains(*impl->m_Variable)) {
-                        graphWidget->enableAcquisition(false);
+                        // During rescale, acquisition for the graph is disabled but synchronization is still
+                        // enabled
+                        graphWidget->setFlags(GraphFlag::EnableSynchronization);
                         graphWidget->setGraphRange(impl->m_Range);
-                        graphWidget->enableAcquisition(true);
+                        graphWidget->setFlags(GraphFlag::EnableAll);
                     }
                 }
                 else {

plugins/amda/tests/FuzzingDefs.cpp +18 -9

                     return;
                 }
-                // Registers variable into sync group: if it's the first variable, sets the variable range as
+                // Registers variable into sync group
-                // the sync group range
                 auto &syncGroup = m_SyncGroupsPool.at(syncGroupId);
+                auto &variableState = m_VariablesPool.at(variableId);
                 syncGroup.m_Variables.insert(variableId);
                 if (syncGroup.m_Variables.size() == 1) {
-                    auto &variableState = m_VariablesPool.at(variableId);
+                    // If it's the first variable, sets the variable range as the sync group range
                     syncGroup.m_Range = variableState.m_Range;
                 }
+                else {
+                    // If a variable is added to an existing group, sets its range to the group's range
+                    variableState.m_Range = syncGroup.m_Range;
+                }
             }
             void FuzzingState::desynchronizeVariable(VariableId variableId, SyncGroupId syncGroupId)
                 auto syncGroupId = this->syncGroupId(variableId);
                 // Retrieves the variables to update:
-                // - if the variable is synchronized to others, updates all synchronized variables
+                // - if the variable is synchronized to others, updates the range of the group and of all
+                // synchronized variables
                 // - otherwise, updates only the variable
-                auto variablesToUpdate = syncGroupId.isNull() ? std::set<VariableId>{variableId}
+                if (syncGroupId.isNull()) {
-                                                              : m_SyncGroupsPool.at(syncGroupId).m_Variables;
-                // Sets new range
-                for (const auto &variableId : variablesToUpdate) {
                     m_VariablesPool.at(variableId).m_Range = newRange;
                 }
+                else {
+                    auto &syncGroup = m_SyncGroupsPool.at(syncGroupId);
+                    syncGroup.m_Range = newRange;
+                    for (const auto &variableId : syncGroup.m_Variables) {
+                        m_VariablesPool.at(variableId).m_Range = newRange;
+                    }
+                }
             }

plugins/amda/tests/FuzzingOperations.cpp +4 -1

                     // Updates state
                     fuzzingState.synchronizeVariable(variableId, syncGroupId);
+                    variableController.onRequestDataLoading({variableState.m_Variable}, variableState.m_Range,
+                                                            false);
                 }
             };
                     qCInfo(LOG_FuzzingOperations()).noquote() << "Removing" << variableState.m_Variable->name()
                                                               << "from synchronization group" << syncGroupId
                                                               << "...";
-                    variableController.onAddSynchronized(variableState.m_Variable, syncGroupId);
+                    variableController.desynchronize(variableState.m_Variable, syncGroupId);
                     // Updates state
                     fuzzingState.desynchronizeVariable(variableId, syncGroupId);

plugins/amda/tests/FuzzingValidators.cpp +1 -1

                     auto dataHoleIt = std::adjacent_find(
                         dataIts.first, dataIts.second, [](const auto &it1, const auto &it2) {
                             /// @todo: validate resolution
-                            return std::abs(it1.x() - it2.x()) > 2 * (LOCALHOST_SERVER_RESOLUTION - 1);
+                            return std::abs(it1.x() - it2.x()) > 2 * LOCALHOST_SERVER_RESOLUTION;
                         });
                     if (dataHoleIt != dataIts.second) {

plugins/amda/tests/TestAmdaFuzzing.cpp +4 0

             int main(int argc, char *argv[])
             {
+                // Increases the test function timeout (which is 5 minutes by default) to 12 hours
+                // https://stackoverflow.com/questions/42655932/setting-timeout-to-qt-test
+                qputenv("QTEST_FUNCTION_TIMEOUT", QByteArray::number(12*60*60*1000));
                 QLoggingCategory::setFilterRules(
                     "*.warning=false\n"
                     "*.info=false\n"

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