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

@@ -7,6 +7,7
7	#include <QObject>	7	#include <QObject>
8	#include <QUuid>	8	#include <QUuid>
9	#include <QReadWriteLock>	9	#include <QReadWriteLock>
		10	#include <QDataStream>
10		11
11	#include "CoreGlobal.h"	12	#include "CoreGlobal.h"
12	#include <Data/DataSeriesIterator.h>	13	#include <Data/DataSeriesIterator.h>
@@ -69,6 +70,30 public:
69	const DateTimeRange& newRange, const DateTimeRange& newCacheRange,	70	const DateTimeRange& newRange, const DateTimeRange& newCacheRange,
70	bool notify=true);	71	bool notify=true);
71		72
		73	static QByteArray mimeData(const std::vector<std::shared_ptr<Variable> > &variables)
		74	{
		75	auto encodedData = QByteArray{};
		76	QDataStream stream{&encodedData, QIODevice::WriteOnly};
		77	for (auto &var : variables) {
		78	stream << var->ID().toByteArray();
		79	}
		80	return encodedData;
		81	}
		82
		83	static std::vector<QUuid> variablesIDs(QByteArray mimeData)
		84	{
		85	std::vector<QUuid> variables;
		86	QDataStream stream{mimeData};
		87
		88	QVariantList ids;
		89	stream >> ids;
		90
		91	for (const auto& id : ids) {
		92	variables.emplace_back (id.toByteArray());
		93	}
		94	return variables;
		95	}
		96
72	DEPRECATE(	97	DEPRECATE(
73		98
74	bool contains(const DateTimeRange &range) const noexcept;	99	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
+                const std::vector<std::shared_ptr<Variable>> variables(const std::vector<QUuid>& ids);
-                QByteArray mimeData(const std::vector<std::shared_ptr<Variable>> &variables) const;
-                const std::vector<std::shared_ptr<Variable>> variables(QByteArray mimeData);
                 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:
+                void createVariable(const QVariantHash &productData);
-            private slots:
+                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
+            const std::vector<std::shared_ptr<Variable>> VariableController2::variables(const std::vector<QUuid> &ids)
-                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)
             {
                 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(id));
-                    variables.push_back (impl->variable(uuid));
                 }
                 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)
+            VariableModel2::VariableModel2(QObject *parent)
-                : QAbstractTableModel{parent}, _variableController{variableController}
+                : 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());
+                        emit createVariable(metaData.toHash());
-                        //@TODO No idea what this does
                     }
                     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