HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r1345:ce477e992869

Some WIP refactoring, trying to remove TimeController object...

jeandet -

r1345:ce477e992869

parent child

Context file:

r1345:ce477e992869

core/include/Time/TimeController.h +1 -1

              public slots:
                  /// Slot called when a new dateTime has been defined.
-                 void onTimeToUpdate(SqpRange dateTime);
+                 void setDateTimeRange(SqpRange dateTime);
                  /// Slot called when the dateTime has to be notified. Call timeUpdated signal
                  void onTimeNotify();

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

                  VariableModel *variableModel() noexcept;
                  QItemSelectionModel *variableSelectionModel() noexcept;
-                 void setTimeController(TimeController *timeController) noexcept;
                  /**
                   * Clones the variable passed in parameter and adds the duplicate to the controller
                   * @return the pointer to the new variable or nullptr if the creation failed
                   */
                  std::shared_ptr<Variable> createVariable(const QString &name, const QVariantHash &metadata,
-                                                          std::shared_ptr<IDataProvider> provider) noexcept;
+                                                          std::shared_ptr<IDataProvider> provider, const SqpRange &range) noexcept;
                  /// Update the temporal parameters of every selected variable to dateTime
                  void onDateTimeOnSelection(const SqpRange &dateTime);

core/src/Time/TimeController.cpp +1 -1

                  return timeRange;
              }
-             void TimeController::onTimeToUpdate(SqpRange dateTime)
+             void TimeController::setDateTimeRange(SqpRange dateTime)
              {
                  impl->m_DateTime = dateTime;
              }

core/src/Variable/VariableController.cpp +7 -13

                  QItemSelectionModel *m_VariableSelectionModel;
-                 TimeController *m_TimeController{nullptr};
                  std::unique_ptr<VariableCacheStrategy> m_VariableCacheStrategy;
                  std::unique_ptr<VariableAcquisitionWorker> m_VariableAcquisitionWorker;
                  QThread m_VariableAcquisitionWorkerThread;
                  return impl->m_VariableSelectionModel;
              }
-             void VariableController::setTimeController(TimeController *timeController) noexcept
+             {
-                 impl->m_TimeController = timeController;
+             }
              std::shared_ptr<Variable>
              VariableController::cloneVariable(std::shared_ptr<Variable> variable) noexcept
              {
              std::shared_ptr<Variable>
              VariableController::createVariable(const QString &name, const QVariantHash &metadata,
-                                                std::shared_ptr<IDataProvider> provider) noexcept
+                                                std::shared_ptr<IDataProvider> provider, const SqpRange& range) noexcept
              {
-                 if (!impl->m_TimeController) {
-                     qCCritical(LOG_VariableController())
-                         << tr("Impossible to create variable: The time controller is null");
-                     return nullptr;
+                 }
+             //    if (!impl->m_TimeController) {
+             //        qCCritical(LOG_VariableController())
+             //            << tr("Impossible to create variable: The time controller is null");
+             //        return nullptr;
+             //    }
-                 auto range = impl->m_TimeController->dateTime();
+             //    auto range = impl->m_TimeController->dateTime();
                  if (auto newVariable = impl->m_VariableModel->createVariable(name, metadata)) {
                      auto varId = QUuid::createUuid();

core/tests/Variable/TestVariableController.cpp +3 -3

                  QDateTime start{QDate{2017, 01, 01}, QTime{0, 0, 0, 0}};
                  QDateTime end{QDate{2017, 01, 02}, QTime{0, 0, 0, 0}};
-                 timeController->onTimeToUpdate(
+                 timeController->setDateTimeRange(
                      SqpRange{DateUtils::secondsSinceEpoch(start), DateUtils::secondsSinceEpoch(end)});
                  return timeController;
                  // Creates variable controller
                  auto timeController = defaultTimeController();
                  VariableController variableController{};
-                 variableController.setTimeController(timeController.get());
+                 //variableController.setTimeController(timeController.get());
                  // Creates a variable from the controller
                  auto variable
-                     = variableController.createVariable("variable", {}, std::make_shared<TestProvider>());
+                     = variableController.createVariable("variable", {}, std::make_shared<TestProvider>(), timeController->dateTime());
                  qDebug() << QString::number(variable.use_count());

core/tests/Variable/TestVariableSync.cpp +13 -13

               *Variable creation operation in the controller
               */
              struct Create : public IOperation {
-                 explicit Create(int index) : m_Index{index} {}
+                 explicit Create(int index, const SqpRange &range) : m_Index{index},m_range(range) {}
                  void exec(VariableController &variableController) const override
                  {
                      auto variable = variableController.createVariable(QString::number(m_Index), {},
-                                                                       std::make_unique<TestProvider>());
+                                                                       std::make_unique<TestProvider>(), m_range);
                  }
                  int m_Index; ///< The index of the variable to create in the controller
+                 SqpRange m_range;
              };
              /**
                  Iterations iterations{};
                  // Creates variables var0, var1 and var2
-                 iterations.push_back({std::make_shared<Create>(0), {{0, initialRange}}});
-                 iterations.push_back({std::make_shared<Create>(1), {{0, initialRange}, {1, initialRange}}});
+                 iterations.push_back({std::make_shared<Create>(0, initialRange), {{0, initialRange}}});
+                 iterations.push_back({std::make_shared<Create>(1, initialRange), {{0, initialRange}, {1, initialRange}}});
                  iterations.push_back(
-                     {std::make_shared<Create>(2), {{0, initialRange}, {1, initialRange}, {2, initialRange}}});
+                     {std::make_shared<Create>(2, initialRange), {{0, initialRange}, {1, initialRange}, {2, initialRange}}});
                  // Adds variables into the sync group (ranges don't need to be tested here)
                  iterations.push_back({std::make_shared<Synchronize>(0, syncId)});
                  Iterations iterations{};
                  // Creates variables var0 and var1
-                 iterations.push_back({std::make_shared<Create>(0), {{0, initialRange}}});
-                 iterations.push_back({std::make_shared<Create>(1), {{0, initialRange}, {1, initialRange}}});
+                 iterations.push_back({std::make_shared<Create>(0, initialRange), {{0, initialRange}}});
+                 iterations.push_back({std::make_shared<Create>(1, initialRange), {{0, initialRange}, {1, initialRange}}});
                  // Adds variables into the sync group (ranges don't need to be tested here)
                  iterations.push_back({std::make_shared<Synchronize>(0, syncId)});
                  Iterations creations{};
                  // Creates variables var0, var1 and var2
-                 creations.push_back({std::make_shared<Create>(0), {{0, initialRange}}});
+                 creations.push_back({std::make_shared<Create>(0, initialRange), {{0, initialRange}}});
                  Iterations synchronization{};
                  // Adds variables into the sync group (ranges don't need to be tested here)
                  // Inits controllers
                  TimeController timeController{};
                  VariableController variableController{};
-                 variableController.setTimeController(&timeController);
+                 //variableController.setTimeController(&timeController);
                  QFETCH(QUuid, syncId);
                  QFETCH(SqpRange, initialRange);
-                 timeController.onTimeToUpdate(initialRange);
+                 timeController.setDateTimeRange(initialRange);
                  // Synchronization group used
                  variableController.onAddSynchronizationGroupId(syncId);
                  // Inits controllers
                  TimeController timeController{};
                  VariableController variableController{};
-                 variableController.setTimeController(&timeController);
+                 //variableController.setTimeController(&timeController);
                  QFETCH(QUuid, syncId);
                  QFETCH(SqpRange, initialRange);
-                 timeController.onTimeToUpdate(initialRange);
+                 timeController.setDateTimeRange(initialRange);
                  // Synchronization group used
                  variableController.onAddSynchronizationGroupId(syncId);

gui/src/SqpApplication.cpp +1 -1

                      m_VisualizationControllerThread.setObjectName("VsualizationControllerThread");
                      // Additionnal init
-                     m_VariableController->setTimeController(m_TimeController.get());
+                     //m_VariableController->setTimeController(m_TimeController.get());
                  }
                  virtual ~SqpApplicationPrivate()

gui/src/TimeWidget/TimeWidget.cpp +1 -1

                  auto dateTime = SqpRange{DateUtils::secondsSinceEpoch(startDateTime),
                                           DateUtils::secondsSinceEpoch(endDateTime)};
-                 sqpApp->timeController().onTimeToUpdate(dateTime);
+                 sqpApp->timeController().setDateTimeRange(dateTime);
              }

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

                                                                << "(metadata:" << variableMetadata << ")...";
                      auto newVariable
-                         = variableController.createVariable(variableName, variableMetadata, variableProvider);
+                         = variableController.createVariable(variableName, variableMetadata, variableProvider, properties.value(INITIAL_RANGE_PROPERTY).value<SqpRange>());
                      // Updates variable's state
                      auto &variableState = fuzzingState.variableState(variableId);

plugins/amda/tests/PyTestAmdaWrapper.cpp +3 -3

                  py::class_<VariableController>(m, "VariableController")
                          .def_static("createVariable",[](const QString &name,
-                                     std::shared_ptr<IDataProvider> provider){
-                     return sqpApp->variableController().createVariable(name, {{"dataType", "vector"}, {"xml:id", "c1_b"}}, provider);
+                                     std::shared_ptr<IDataProvider> provider, const SqpRange& range){
+                     return sqpApp->variableController().createVariable(name, {{"dataType", "vector"}, {"xml:id", "c1_b"}}, provider, range);
                  })
                          .def_static("hasPendingDownloads",
                                      [](){return sqpApp->variableController().hasPendingDownloads();}
                  });
                  py::class_<TimeController>(m,"TimeController")
-                         .def_static("setTime", [](SqpRange range){sqpApp->timeController().onTimeToUpdate(range);});
+                         .def_static("setTime", [](SqpRange range){sqpApp->timeController().setDateTimeRange(range);});
                  auto amda_provider = std::make_shared<AmdaProvider>();

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

                  // Creates variable
                  QFETCH(SqpRange, initialRange);
-                 sqpApp->timeController().onTimeToUpdate(initialRange);
+                 sqpApp->timeController().setDateTimeRange(initialRange);
                  auto provider = std::make_shared<AmdaProvider>();
                  auto variable = sqpApp->variableController().createVariable(
-                     "bx_gse", {{"dataType", "scalar"}, {"xml:id", "imf(0)"}}, provider);
+                     "bx_gse", {{"dataType", "scalar"}, {"xml:id", "imf(0)"}}, provider, initialRange);
                  QTest::qWait(OPERATION_DELAY);
                  validateVariable(variable, initialRange);

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

                  // Sets initial range on time controller
                  SqpRange initialRange{initialRangeStart, initialRangeEnd};
                  qCInfo(LOG_TestAmdaFuzzing()).noquote() << "Setting initial range to" << initialRange << "...";
-                 timeController.onTimeToUpdate(initialRange);
+                 timeController.setDateTimeRange(initialRange);
                  properties.insert(INITIAL_RANGE_PROPERTY, QVariant::fromValue(initialRange));
                  FuzzingTest test{variableController, properties};

plugins/mockplugin/src/MockPlugin.cpp +4 -4

                  return std::make_unique<CosinusProvider>();
              }
-             std::unique_ptr<DataSourceItem> createProductItem(const QVariantHash &data,
+             std::unique_ptr<DataSourceItem> createProductItem(const QVariantHash &metaData,
                                                                const QUuid &dataSourceUid)
              {
-                 auto result = std::make_unique<DataSourceItem>(DataSourceItemType::PRODUCT, data);
+                 auto result = std::make_unique<DataSourceItem>(DataSourceItemType::PRODUCT, metaData);
                  // Adds plugin name to product metadata
                  result->setData(DataSourceItem::PLUGIN_DATA_KEY, DATA_SOURCE_NAME);
-                 result->setData(DataSourceItem::ID_DATA_KEY, data.value(DataSourceItem::NAME_DATA_KEY));
+                 result->setData(DataSourceItem::ID_DATA_KEY, metaData.value(DataSourceItem::NAME_DATA_KEY));
-                 auto productName = data.value(DataSourceItem::NAME_DATA_KEY).toString();
+                 auto productName = metaData.value(DataSourceItem::NAME_DATA_KEY).toString();
                  // Add action to load product from DataSourceController
                  result->addAction(std::make_unique<DataSourceItemAction>(

plugins/mockplugin/tests/TestCosinusAcquisition.cpp +2 -2

                  // Creates variable
                  QFETCH(SqpRange, initialRange);
-                 sqpApp->timeController().onTimeToUpdate(initialRange);
+                 sqpApp->timeController().setDateTimeRange(initialRange);
                  auto provider = std::make_shared<CosinusProvider>();
                  auto variable = sqpApp->variableController().createVariable(
-                     "MMS", {{COSINUS_TYPE_KEY, "scalar"}, {COSINUS_FREQUENCY_KEY, 10.}}, provider);
+                     "MMS", {{COSINUS_TYPE_KEY, "scalar"}, {COSINUS_FREQUENCY_KEY, 10.}}, provider, initialRange);
                  QFETCH(int, operationDelay);

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