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) {
+            //    if (!impl->m_TimeController) {
-                    qCCritical(LOG_VariableController())
+            //        qCCritical(LOG_VariableController())
-                        << tr("Impossible to create variable: The time controller is null");
+            //            << tr("Impossible to create variable: The time controller is null");
-                    return nullptr;
+            //        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>(0, initialRange), {{0, initialRange}}});
-                iterations.push_back({std::make_shared<Create>(1), {{0, initialRange}, {1, 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>(0, initialRange), {{0, initialRange}}});
-                iterations.push_back({std::make_shared<Create>(1), {{0, initialRange}, {1, 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){
+                                    std::shared_ptr<IDataProvider> provider, const SqpRange& range){
-                    return sqpApp->variableController().createVariable(name, {{"dataType", "vector"}, {"xml:id", "c1_b"}}, provider);
+                    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