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

                  void cancelVariableRequest(QUuid varRequestId);
                  void executeVarRequest(std::shared_ptr<Variable> var, VariableRequest &varRequest);
+                 template <typename VariableIterator>
+                 void desynchronize(VariableIterator variableIt, const QUuid &syncGroupId);
                  QMutex m_WorkingMutex;
                  /// Variable model. The VariableController has the ownership
                  VariableModel *m_VariableModel;
                  // make some treatments before the deletion
                  emit variableAboutToBeDeleted(variable);
+                 auto variableIt = impl->m_VariableToIdentifierMap.find(variable);
+                 Q_ASSERT(variableIt != impl->m_VariableToIdentifierMap.cend());
+                 auto variableId = variableIt->second;
+                 // Removes variable's handler
+                 impl->m_VarIdToVarRequestHandler.erase(variableId);
+                 // Desynchronizes variable (if the variable is in a sync group)
+                 auto syncGroupIt = impl->m_VariableIdGroupIdMap.find(variableId);
+                 if (syncGroupIt != impl->m_VariableIdGroupIdMap.cend()) {
+                     impl->desynchronize(variableIt, syncGroupIt->second);
+                 }
                  // Deletes identifier
-                 impl->m_VariableToIdentifierMap.erase(variable);
+                 impl->m_VariableToIdentifierMap.erase(variableIt);
                  // Deletes provider
                  auto nbProvidersDeleted = impl->m_VariableToProviderMap.erase(variable);
                      return;
                  }
-                 // Gets synchronization group
-                 auto groupIt = impl->m_GroupIdToVariableSynchronizationGroupMap.find(synchronizationGroupId);
-                 if (groupIt == impl->m_GroupIdToVariableSynchronizationGroupMap.cend()) {
-                     qCCritical(LOG_VariableController())
-                         << tr("Can't desynchronize variable %1: unknown synchronization group")
-                                .arg(variable->name());
-                     return;
+                 }
-                 auto variableId = variableIt->second;
-                 // Removes variable from synchronization group
-                 auto synchronizationGroup = groupIt->second;
-                 synchronizationGroup->removeVariableId(variableId);
-                 // Removes link between variable and synchronization group
-                 impl->m_VariableIdGroupIdMap.erase(variableId);
+                 impl->desynchronize(variableIt, synchronizationGroupId);
              }
              void VariableController::onRequestDataLoading(QVector<std::shared_ptr<Variable> > variables,
                                  varHandler->m_PendingVarRequest = VariableRequest{};
                                  auto var = findVariable(itVarHandler->first);
                                  executeVarRequest(var, varHandler->m_RunningVarRequest);
+                                 updateVariables(varHandler->m_RunningVarRequest.m_VariableGroupId);
                                  break;
                              }
                              default:
              {
                  qCDebug(LOG_VariableController()) << tr("TORM: executeVarRequest");
-                 auto varId = m_VariableToIdentifierMap.at(var);
+                 auto varIdIt = m_VariableToIdentifierMap.find(var);
+                 if (varIdIt == m_VariableToIdentifierMap.cend()) {
+                     qCWarning(LOG_VariableController()) << tr(
+                         "Can't execute request of a variable that is not registered (may has been deleted)");
+                     return;
+                 }
+                 auto varId = varIdIt->second;
                  auto varCacheRange = var->cacheRange();
                  auto varCacheRangeRequested = varRequest.m_CacheRangeRequested;
                                            var->dataSeries()->subDataSeries(varRequest.m_CacheRangeRequested));
                  }
              }
+             template <typename VariableIterator>
+             void VariableController::VariableControllerPrivate::desynchronize(VariableIterator variableIt,
+                                                                               const QUuid &syncGroupId)
+             {
+                 const auto &variable = variableIt->first;
+                 const auto &variableId = variableIt->second;
+                 // Gets synchronization group
+                 auto groupIt = m_GroupIdToVariableSynchronizationGroupMap.find(syncGroupId);
+                 if (groupIt == m_GroupIdToVariableSynchronizationGroupMap.cend()) {
+                     qCCritical(LOG_VariableController())
+                         << tr("Can't desynchronize variable %1: unknown synchronization group")
+                                .arg(variable->name());
+                     return;
+                 }
+                 // Removes variable from synchronization group
+                 auto synchronizationGroup = groupIt->second;
+                 synchronizationGroup->removeVariableId(variableId);
+                 // Removes link between variable and synchronization group
+                 m_VariableIdGroupIdMap.erase(variableId);
+             }

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
-                 void enableAcquisition(bool enable);
+                 /// Sets graph options
+                 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) {
-                         qCDebug(LOG_VisualizationGraphWidget())
-                             << tr("TORM: VisualizationGraphWidget::Synchronize notify !!")
-                             << QThread::currentThread()->objectName() << graphRange << oldGraphRange;
-                         emit synchronize(graphRange, oldGraphRange);
+                     }
+                 if (impl->m_Flags.testFlag(GraphFlag::EnableSynchronization) && !impl->m_IsCalibration) {
+                     qCDebug(LOG_VisualizationGraphWidget())
+                         << tr("TORM: VisualizationGraphWidget::Synchronize notify !!")
+                         << QThread::currentThread()->objectName() << 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);
-                             qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: Range before: ")
-                                                                    << graphChild->graphRange();
-                             qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: Range after : ")
-                                                                    << graphChildRange;
+                             graphChild->setFlags(GraphFlag::DisableAll);
+                             qCDebug(LOG_VisualizationZoneWidget())
+                                 << tr("TORM: Range before: ") << graphChild->graphRange();
+                             qCDebug(LOG_VisualizationZoneWidget())
+                                 << 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
-                 // the sync group range
+                 // Registers variable into sync group
                  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}
-                                                               : m_SyncGroupsPool.at(syncGroupId).m_Variables;
-                 // Sets new range
-                 for (const auto &variableId : variablesToUpdate) {
+                 if (syncGroupId.isNull()) {
                      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