HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/SciQLOPCore Commit - r27:c08d1b8ad297

Removed bad dependency between VC and VariableModel, moved mime stuff...

jeandet -

r27:c08d1b8ad297

parent child

Context file:

r27:c08d1b8ad297

include/DataSource/DataSourceController.h +1 -1

                   * @param variableProvider the provider that will be used to retrieve the data of the variable
                   * (can be null)
                   */
-                 void variableCreationRequested(const QString &variableName,
+                 void createVariable(const QString &variableName,
                                                 const QVariantHash &variableMetadata,
                                                 std::shared_ptr<IDataProvider> variableProvider);

include/Variable/Variable.h +25 0

              #include <QObject>
              #include <QUuid>
              #include <QReadWriteLock>
+             #include <QDataStream>
              #include "CoreGlobal.h"
              #include <Data/DataSeriesIterator.h>
                                  const DateTimeRange& newRange, const DateTimeRange& newCacheRange,
                                  bool notify=true);
+                 static QByteArray mimeData(const std::vector<std::shared_ptr<Variable> > &variables)
+                 {
+                     auto encodedData = QByteArray{};
+                     QDataStream stream{&encodedData, QIODevice::WriteOnly};
+                     for (auto &var : variables) {
+                         stream << var->ID().toByteArray();
+                     }
+                     return encodedData;
+                 }
+                 static std::vector<QUuid> variablesIDs(QByteArray mimeData)
+                 {
+                     std::vector<QUuid> variables;
+                     QDataStream stream{mimeData};
+                     QVariantList ids;
+                     stream >> ids;
+                     for (const auto& id : ids) {
+                         variables.emplace_back (id.toByteArray());
+                     }
+                     return variables;
+                 }
              DEPRECATE(
                  bool contains(const DateTimeRange &range) const noexcept;

include/Variable/VariableController2.h +1 -3

                  void synchronize(const std::shared_ptr<Variable>& var, const std::shared_ptr<Variable>& with);
-                 //This should be somewhere else VC has nothing to do with MIMEData
-                 QByteArray mimeData(const std::vector<std::shared_ptr<Variable>> &variables) const;
-                 const std::vector<std::shared_ptr<Variable>> variables(QByteArray mimeData);
+                 const std::vector<std::shared_ptr<Variable>> variables(const std::vector<QUuid>& ids);
                  const std::shared_ptr<Variable>& operator[] (int index) const;
                  std::shared_ptr<Variable> operator[] (int index);

include/Variable/VariableModel2.h +8 -5

               */
              class SCIQLOP_CORE_EXPORT VariableModel2 : public QAbstractTableModel {
                  Q_OBJECT
-                 std::shared_ptr<VariableController2> _variableController;
+                 // read only mirror of VariableController2 content
+                 std::vector<std::shared_ptr<Variable>> _variables;
              public:
-                 explicit VariableModel2(const std::shared_ptr<VariableController2>& variableController, QObject *parent = nullptr);
+                 explicit VariableModel2(QObject *parent = nullptr);
                  // /////////////////////////// //
                  // QAbstractTableModel methods //
                  virtual bool dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column,
                                            const QModelIndex &parent) override;
              signals:
-             private slots:
+                 void createVariable(const QVariantHash &productData);
+                 void asyncChangeRange(const std::shared_ptr<Variable>& variable, const DateTimeRange& r);
+             public slots:
                  /// Slot called when data of a variable has been updated
                  void variableUpdated() noexcept;
+                 void variableAdded(const std::shared_ptr<Variable>&);
+                 void variableDeleted(const std::shared_ptr<Variable>&);
              };
              #endif // SCIQLOP_VARIABLEMODEL2_H

src/DataSource/DataSourceController.cpp +1 -1

                      auto it = impl->m_DataProviders.find(dataSourceUid);
                      auto dataProvider = (it != impl->m_DataProviders.end()) ? it->second : nullptr;
-                     emit variableCreationRequested(productItem.name(), productItem.data(), dataProvider);
+                     emit createVariable(productItem.name(), productItem.data(), dataProvider);
                  }
                  else {
                      qCWarning(LOG_DataSourceController()) << tr("Can't load an item that is not a product");

src/Variable/VariableController2.cpp +15 -26

                      inline void removeVariable(const std::shared_ptr<Variable>& variable)
                      {
                          QWriteLocker lock{&_lock};
-                         _variables.remove(*variable);
+                         _variables.erase(*variable);
                          _providers.remove(*variable);
                          _synchronizationGroups.remove(*variable);
                      }
                      inline std::shared_ptr<Variable> variable(QUuid variable)
                      {
                          QReadLocker lock{&_lock};
+                         auto it = _variables.find(variable);
                          [[unlikely]]
-                         if(!_variables.contains(variable))
+                         if(it==_variables.end())
                              SCIQLOP_ERROR(threadSafeVaraiblesMaps,"Unknown Variable");
-                         return _variables[variable];
+                         return (*it).second;
                      }
                      inline std::shared_ptr<Variable> variable(int index)
                          [[unlikely]]
                          if(!_variables.size() > index)
                              SCIQLOP_ERROR(threadSafeVaraiblesMaps,"Index is out of bounds");
-                         return _variables.values()[index];
+                         auto it = _variables.cbegin();
+                         while (index!=0) {
+                             index-=1;
+                             it++;
+                         }
+                         return (*it).second;
                      }
                      inline const std::vector<std::shared_ptr<Variable>> variables()
                      {
                          std::vector<std::shared_ptr<Variable>> vars;
                          QReadLocker lock{&_lock};
-                         for(const auto  &var:_variables)
+                         for(const auto&[id, var]:_variables)
                          {
                              vars.push_back(var);
                          }
                      inline bool has(const std::shared_ptr<Variable>& variable)
                      {
                          QReadLocker lock{&_lock};
-                         return _variables.contains(*variable);
+                         return _variables.find(*variable)==_variables.end();
                      }
                  private:
-                     QMap<QUuid,std::shared_ptr<Variable>> _variables;
+                     std::map<QUuid,std::shared_ptr<Variable>> _variables;
                      QMap<QUuid,std::shared_ptr<IDataProvider>> _providers;
                      QMap<QUuid,std::shared_ptr<VariableSynchronizationGroup2>> _synchronizationGroups;
                      QReadWriteLock _lock{QReadWriteLock::Recursive};
                  impl->synchronize(var, with);
              }
-             QByteArray VariableController2::mimeData(const std::vector<std::shared_ptr<Variable> > &variables) const
+             {
-                 auto encodedData = QByteArray{};
-                 QDataStream stream{&encodedData, QIODevice::WriteOnly};
-                 for (auto &var : variables) {
-                     stream << var->ID().toByteArray();
+                 }
-                 return encodedData;
+             }
-             const std::vector<std::shared_ptr<Variable>> VariableController2::variables(QByteArray mimeData)
+             const std::vector<std::shared_ptr<Variable>> VariableController2::variables(const std::vector<QUuid> &ids)
              {
                  std::vector<std::shared_ptr<Variable>> variables;
-                 QDataStream stream{mimeData};
-                 QVariantList ids;
-                 stream >> ids;
                  for (const auto& id : ids) {
-                     auto uuid = QUuid{id.toByteArray()};
-                     variables.push_back (impl->variable(uuid));
+                     variables.push_back(impl->variable(id));
                  }
                  return variables;
              }

src/Variable/VariableModel2.cpp +40 -16

+             #include <QMimeData>
+             #include <QSize>
+             #include <QTimer>
+             #include <unordered_map>
              #include <Variable/Variable.h>
              #include <Variable/VariableController2.h>
              #include <Variable/VariableModel2.h>
              #include <Common/DateUtils.h>
              #include <Common/MimeTypesDef.h>
              #include <Common/StringUtils.h>
+             #include <Common/containers.h>
              #include <Data/IDataSeries.h>
              #include <DataSource/DataSourceController.h>
              #include <Time/TimeController.h>
-             #include <QMimeData>
-             #include <QSize>
-             #include <QTimer>
-             #include <unordered_map>
              namespace {
              // Column indexes
-             VariableModel2::VariableModel2(const std::shared_ptr<VariableController2> &variableController, QObject *parent)
-                 : QAbstractTableModel{parent}, _variableController{variableController}
+             VariableModel2::VariableModel2(QObject *parent)
+                 : QAbstractTableModel{parent}
              {
              }
              int VariableModel2::rowCount(const QModelIndex &parent) const
              {
                  Q_UNUSED(parent);
-                 return static_cast<int>(_variableController->variables().size());
+                 return _variables.size();
              }
              QVariant VariableModel2::data(const QModelIndex &index, int role) const
                  }
                  if (role == Qt::DisplayRole) {
-                     if (auto variable = _variableController->variables()[index.row()]) {
+                     if (auto variable = _variables[index.row()]) {
                          switch (index.column()) {
                              case NAME_COLUMN:
                                  return variable->name();
                  DateTimeRange firstTimeRange;
                  for (const auto &index : indexes) {
                      if (index.column() == 0) { // only the first column
-                         auto variable = _variableController->variables()[index.row()];
+                         auto variable = _variables[index.row()];
                          if (variable.get() && index.isValid()) {
                              if (variables.size()==0) {
                                  // Gets the range of the first variable
-                                 firstTimeRange = std::move(variable->range());
+                                 firstTimeRange = variable->range();
                              }
                              variables.push_back(variable);
                          }
                      }
                  }
-                 auto variablesEncodedData = _variableController->mimeData(variables);
+                 auto variablesEncodedData = Variable::mimeData(variables);
                  mimeData->setData(MIME_TYPE_VARIABLE_LIST, variablesEncodedData);
                  if (variables.size() == 1) {
              bool VariableModel2::canDropMimeData(const QMimeData *data, Qt::DropAction action, int row,
                                                  int column, const QModelIndex &parent) const
              {
+                 Q_UNUSED(column);
                  // drop of a product
                  return data->hasFormat(MIME_TYPE_PRODUCT_LIST)
                         || (data->hasFormat(MIME_TYPE_TIME_RANGE) && parent.isValid()
                          = DataSourceController::productsDataForMimeData(data->data(MIME_TYPE_PRODUCT_LIST));
                      for (auto metaData : productList) {
-                         //emit requestVariable(metaData.toHash());
-                         //@TODO No idea what this does
+                         emit createVariable(metaData.toHash());
                      }
                      dropDone = true;
                  }
                  else if (data->hasFormat(MIME_TYPE_TIME_RANGE) && parent.isValid()) {
-                     auto variable = _variableController->variables()[parent.row()];
+                     auto variable = _variables[parent.row()];
                      auto range = TimeController::timeRangeForMimeData(data->data(MIME_TYPE_TIME_RANGE));
-                     _variableController->asyncChangeRange(variable, range);
+                     emit asyncChangeRange(variable, range);
                      dropDone = true;
                  }
              void VariableModel2::variableUpdated() noexcept
              {
+                 emit dataChanged(QModelIndex(),QModelIndex());
+             }
+             void VariableModel2::variableAdded(const std::shared_ptr<Variable> & variable)
+             {
+                 if(!SciQLop::containers::contains(_variables,variable))
+                 {
+                     beginInsertRows(QModelIndex(), this->_variables.size(), this->_variables.size());
+                     this->_variables.push_back(variable);
+                     endInsertRows();
+                     connect(variable.get(),&Variable::updated,this,&VariableModel2::variableUpdated);
+                 }
+             }
+             void VariableModel2::variableDeleted(const std::shared_ptr<Variable> &variable)
+             {
+                 auto it = std::find(_variables.begin(), _variables.end(), variable);
+                 if (it != _variables.end())
+                 {
+                   auto index = std::distance(_variables.begin(), it);
+                   beginRemoveRows(QModelIndex(), index, index);
+                   _variables.erase(it);
+                   endRemoveRows();
+                 }
              }

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