HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r1350:09a8c8a01145

Ported Mock plugin to new IDataProvider interface compatible with...

jeandet -

r1350:09a8c8a01145

parent child

Context file:

r1350:09a8c8a01145

core +1 -1

		@@ -1,1 +1,1
1		Subproject commit de55e7be90966d1efbd34a10df9a3231c50e245b
	1	Subproject commit c08d1b8ad2976824def52cf0fca26a72b1069356

gui/src/DragAndDrop/DragDropGuiController.cpp +1 -1

                  if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
                      auto variables = sqpApp->variableController().variables(
-                         mimeData->data(MIME_TYPE_VARIABLE_LIST));
+                         Variable::variablesIDs(mimeData->data(MIME_TYPE_VARIABLE_LIST)));
                      if (variables.size() == 1) {

gui/src/SqpApplication.cpp +6 -7

              public:
                  SqpApplicationPrivate()
                          : m_VariableController{std::make_shared<VariableController2>()},
-                           m_VariableModel{m_VariableController},
                            m_PlotInterractionMode(SqpApplication::PlotsInteractionMode::None),
                            m_PlotCursorMode(SqpApplication::PlotsCursorMode::NoCursor)
                  {
                      // VariableController <-> DataSourceController
                      connect(&m_DataSourceController,
-                             SIGNAL(variableCreationRequested(const QString &, const QVariantHash &,
-                                                              std::shared_ptr<IDataProvider>)),
-                             m_VariableController.get(),
-                             SLOT(createVariable(const QString &, const QVariantHash &,
-                                                 std::shared_ptr<IDataProvider>)));
+                             &DataSourceController::createVariable,[](const QString &variableName,
+                             const QVariantHash &variableMetadata,
+                             std::shared_ptr<IDataProvider> variableProvider)
+                     {
+                         sqpApp->variableController().createVariable(variableName,variableMetadata,variableProvider,sqpApp->timeController().dateTime());
+                     });
              //        connect(m_VariableController->variableModel(), &VariableModel::requestVariable,
              //                m_DataSourceController.get(), &DataSourceController::requestVariable);
                  NetworkController m_NetworkController;
                  VisualizationController m_VisualizationController;
                  CatalogueController m_CatalogueController;
-                 VariableModel2 m_VariableModel;
                  QThread m_DataSourceControllerThread;
                  QThread m_NetworkControllerThread;

gui/src/Variable/VariableInspectorWidget.cpp +13 -3

              #include <Variable/VariableInspectorWidget.h>
              #include <Variable/VariableMenuHeaderWidget.h>
              #include <Variable/VariableModel2.h>
+             #include <DataSource/DataSourceController.h>
              #include <ui_VariableInspectorWidget.h>
                  //    auto sortFilterModel = new QSortFilterProxyModel{this};
                  //    sortFilterModel->setSourceModel(sqpApp->variableController().variableModel());
-                 m_model = new VariableModel2(sqpApp->variableControllerOwner());
+                 m_model = new VariableModel2();
                  ui->tableView->setModel(m_model);
+                 connect(m_model, &VariableModel2::createVariable,
+                         [](const QVariantHash &productData)
+                 {
+                     sqpApp->dataSourceController().requestVariable(productData);
+                 });
+                 auto vc = &(sqpApp->variableController());
+                 connect(vc, &VariableController2::variableAdded, m_model, &VariableModel2::variableAdded);
+                 connect(vc, &VariableController2::variableDeleted, m_model, &VariableModel2::variableDeleted);
+                 connect(m_model, &VariableModel2::asyncChangeRange, vc, &VariableController2::asyncChangeRange);
                  // Adds extra signal/slot between view and model, so the view can be updated instantly when
                  // there is a change of data in the model
-                 connect(m_model, SIGNAL(dataChanged(const QModelIndex &, const QModelIndex &)), this,
-                         SLOT(refresh()));
+                 //connect(m_model, SIGNAL(dataChanged(const QModelIndex &, const QModelIndex &)), this,
+                 //        SLOT(refresh()));
                  //ui->tableView->setSelectionModel(sqpApp->variableController().variableSelectionModel());
                  ui->tableView->setItemDelegateForColumn(0, m_ProgressBarItemDelegate);

gui/src/Visualization/VisualizationTabWidget.cpp +1 -1

                  }
                  else if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
                      auto variables = sqpApp->variableController().variables(
-                         mimeData->data(MIME_TYPE_VARIABLE_LIST));
+                         Variable::variablesIDs(mimeData->data(MIME_TYPE_VARIABLE_LIST)));
                      impl->dropVariables(variables, index, this);
                  }
                  else if (mimeData->hasFormat(MIME_TYPE_PRODUCT_LIST)) {

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

                      if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
                          auto variables = sqpApp->variableController().variables(
-                             mimeData->data(MIME_TYPE_VARIABLE_LIST));
+                             Variable::variablesIDs(mimeData->data(MIME_TYPE_VARIABLE_LIST)));
                          if (variables.size() != 1) {
                              return false;
                  }
                  else if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
                      auto variables = sqpApp->variableController().variables(
-                         mimeData->data(MIME_TYPE_VARIABLE_LIST));
+                         Variable::variablesIDs(mimeData->data(MIME_TYPE_VARIABLE_LIST)));
                      impl->dropVariables(variables, index, this);
                  }
                  else if (mimeData->hasFormat(MIME_TYPE_PRODUCT_LIST)) {
                  if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
                      auto variables = sqpApp->variableController().variables(
-                         mimeData->data(MIME_TYPE_VARIABLE_LIST));
+                         Variable::variablesIDs(mimeData->data(MIME_TYPE_VARIABLE_LIST)));
                      for (const auto &var : variables) {
                          graphWidget->addVariable(var, graphWidget->graphRange());
                      }

plugins/mockplugin/include/CosinusProvider.h +4 0

                  void requestDataLoading(QUuid acqIdentifier, const DataProviderParameters &parameters) override;
+                 virtual IDataSeries* getData(const DataProviderParameters &parameters) override;
                  /// @sa IDataProvider::requestDataAborting(). The current impl isn't thread safe.
                  void requestDataAborting(QUuid acqIdentifier) override;
                  std::shared_ptr<IDataSeries>
                  retrieveData(QUuid acqIdentifier, const DateTimeRange &dataRangeRequested, const QVariantHash &data);
+                 IDataSeries* _generate(const DateTimeRange &range, const QVariantHash &metaData);
                  QHash<QUuid, bool> m_VariableToEnableProvider;
              };

plugins/mockplugin/src/CosinusProvider.cpp +52 -11

              struct ICosinusType {
                  virtual ~ICosinusType() = default;
                  /// @return the number of components generated for the type
-                 virtual int componentCount() const = 0;
+                 virtual std::size_t componentCount() const = 0;
                  /// @return the data series created for the type
-                 virtual std::shared_ptr<IDataSeries> createDataSeries(std::vector<double> xAxisData,
+                 virtual IDataSeries* createDataSeries(std::vector<double> xAxisData,
                                                                        std::vector<double> valuesData) const = 0;
                  /// Generates values (one value per component)
                  /// @param x the x-axis data used to generate values
              };
              struct ScalarCosinus : public ICosinusType {
-                 int componentCount() const override { return 1; }
+                 std::size_t componentCount() const override { return 1; }
-                 std::shared_ptr<IDataSeries> createDataSeries(std::vector<double> xAxisData,
+                 IDataSeries* createDataSeries(std::vector<double> xAxisData,
                                                                std::vector<double> valuesData) const override
                  {
-                     return std::make_shared<ScalarSeries>(std::move(xAxisData), std::move(valuesData),
+                     return new ScalarSeries(std::move(xAxisData), std::move(valuesData),
                                                            Unit{QStringLiteral("t"), true}, Unit{});
                  }
                  {
                  }
-                 int componentCount() const override { return m_YAxisData.size(); }
+                 std::size_t componentCount() const override { return m_YAxisData.size(); }
-                 std::shared_ptr<IDataSeries> createDataSeries(std::vector<double> xAxisData,
+                 IDataSeries* createDataSeries(std::vector<double> xAxisData,
                                                                std::vector<double> valuesData) const override
                  {
-                     return std::make_shared<SpectrogramSeries>(
+                     return new SpectrogramSeries(
                          std::move(xAxisData), m_YAxisData, std::move(valuesData),
                          Unit{QStringLiteral("t"), true}, m_YAxisUnit, m_ValuesUnit);
                  }
              };
              struct VectorCosinus : public ICosinusType {
-                 int componentCount() const override { return 3; }
+                 std::size_t componentCount() const override { return 3; }
-                 std::shared_ptr<IDataSeries> createDataSeries(std::vector<double> xAxisData,
+                 IDataSeries* createDataSeries(std::vector<double> xAxisData,
                                                                std::vector<double> valuesData) const override
                  {
-                     return std::make_shared<VectorSeries>(std::move(xAxisData), std::move(valuesData),
+                     return new VectorSeries(std::move(xAxisData), std::move(valuesData),
                                                            Unit{QStringLiteral("t"), true}, Unit{});
                  }
                      // We can close progression beacause all data has been retrieved
                      emit dataProvidedProgress(acqIdentifier, 100);
                  }
+                 return std::shared_ptr<IDataSeries>(type->createDataSeries(std::move(xAxisData), std::move(valuesData)));
+             }
+             IDataSeries *CosinusProvider::_generate(const DateTimeRange &range, const QVariantHash &metaData)
+             {
+                 auto dataIndex = 0;
+                 // Retrieves cosinus type
+                 auto typeVariant = metaData.value(COSINUS_TYPE_KEY, COSINUS_TYPE_DEFAULT_VALUE);
+                 auto type = cosinusType(typeVariant.toString());
+                 auto freqVariant = metaData.value(COSINUS_FREQUENCY_KEY, COSINUS_FREQUENCY_DEFAULT_VALUE);
+                 double freq = freqVariant.toDouble();
+                 double start = std::ceil(range.m_TStart * freq);
+                 double end = std::floor(range.m_TEnd * freq);
+                 if (end < start) {
+                     std::swap(start, end);
+                 }
+                 std::size_t dataCount = static_cast<std::size_t>(end - start + 1);
+                 std::size_t componentCount = type->componentCount();
+                 auto xAxisData = std::vector<double>{};
+                 xAxisData.resize(dataCount);
+                 auto valuesData = std::vector<double>{};
+                 valuesData.resize(dataCount * componentCount);
+                 int progress = 0;
+                 auto progressEnd = dataCount;
+                 for (auto time = start; time <= end; ++time, ++dataIndex)
+                 {
+                         const auto x = time / freq;
+                         xAxisData[dataIndex] = x;
+                         // Generates values (depending on the type)
+                         type->generateValues(x, valuesData, dataIndex);
+                 }
                  return type->createDataSeries(std::move(xAxisData), std::move(valuesData));
              }
                  }
              }
+             IDataSeries* CosinusProvider::getData(const DataProviderParameters &parameters)
+             {
+                 return _generate(parameters.m_Times.front(),parameters.m_Data);
+             }
              void CosinusProvider::requestDataAborting(QUuid acqIdentifier)
              {
                  qCDebug(LOG_CosinusProvider()) << "CosinusProvider::requestDataAborting" << acqIdentifier

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