HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/SciQLOPCore Commit - r32:6b6270b07547

Variable update signal forwards variable ID...

jeandet -

r32:6b6270b07547

parent child

Context file:

r32:6b6270b07547

include/Variable/Variable.h +2 -1

             #ifndef SCIQLOP_VARIABLE_H
             #define SCIQLOP_VARIABLE_H
             #include <optional>
             #include <QLoggingCategory>
             #include <QObject>
             #include <QUuid>
             #include <QReadWriteLock>
             #include <QDataStream>
             #include "CoreGlobal.h"
             #include <Data/DataSeriesIterator.h>
             #include <Data/DataSeriesType.h>
             #include <Data/DateTimeRange.h>
             #include <Common/deprecate.h>
             #include <Common/MetaTypes.h>
             #include <Common/spimpl.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_Variable)
             class IDataSeries;
             class QString;
             /**
              * @brief The Variable class represents a variable in SciQlop.
              */
             class SCIQLOP_CORE_EXPORT Variable : public QObject {
                 Q_OBJECT
             public:
                 explicit Variable(const QString &name, const QVariantHash &metadata = {});
                 /// Copy ctor
                 explicit Variable(const Variable &other);
                 std::shared_ptr<Variable> clone() const;
                 QString name() const noexcept;
                 void setName(const QString &name) noexcept;
                 DateTimeRange range() const noexcept;
                 void setRange(const DateTimeRange &range, bool notify=false) noexcept;
                 DateTimeRange cacheRange() const noexcept;
                 void setCacheRange(const DateTimeRange &cacheRange) noexcept;
                 /// @return the number of points hold by the variable. The number of points is updated each time
                 /// the data series changes
                 unsigned int nbPoints() const noexcept;
                 /// Returns the real range of the variable, i.e. the min and max x-axis values of the data
                 /// series between the range of the variable. The real range is updated each time the variable
                 /// range or the data series changed
                 /// @return the real range, invalid range if the data series is null or empty
                 /// @sa setDataSeries()
                 /// @sa setRange()
                 std::optional<DateTimeRange> realRange() const noexcept;
                 /// @return the data of the variable, nullptr if there is no data
                 std::shared_ptr<IDataSeries> dataSeries() const noexcept;
                 /// @return the type of data that the variable holds
                 DataSeriesType type() const noexcept;
                 QVariantHash metadata() const noexcept;
                 void updateData(const std::vector<IDataSeries*>& dataSeries,
                                 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;
                 }
                 operator QUuid() {return _uuid;}
                 QUuid ID(){return _uuid;}
             signals:
-                void updated();
+                void updated(QUuid ID);
             private:
                 class VariablePrivate;
                 spimpl::unique_impl_ptr<VariablePrivate> impl;
                 QUuid _uuid;
                 QReadWriteLock m_lock;
             };
             // Required for using shared_ptr in signals/slots
             SCIQLOP_REGISTER_META_TYPE(VARIABLE_PTR_REGISTRY, std::shared_ptr<Variable>)
             SCIQLOP_REGISTER_META_TYPE(VARIABLE_PTR_VECTOR_REGISTRY, QVector<std::shared_ptr<Variable> >)
             #endif // SCIQLOP_VARIABLE_H

include/Variable/VariableModel2.h +1 -1

             #ifndef SCIQLOP_VARIABLEMODEL2_H
             #define SCIQLOP_VARIABLEMODEL2_H
             #include "CoreGlobal.h"
             #include <Data/DateTimeRange.h>
             #include <QAbstractTableModel>
             #include <QLoggingCategory>
             #include <Common/MetaTypes.h>
             #include <Common/spimpl.h>
             class IDataSeries;
             class Variable;
             class VariableController2;
             enum VariableRoles { ProgressRole = Qt::UserRole };
             /**
              * @brief The VariableModel class aims to hold the variables that have been created in SciQlop
              */
             class SCIQLOP_CORE_EXPORT VariableModel2 : public QAbstractTableModel {
                 Q_OBJECT
                 // read only mirror of VariableController2 content
                 std::vector<std::shared_ptr<Variable>> _variables;
             public:
                 explicit VariableModel2(QObject *parent = nullptr);
                 // /////////////////////////// //
                 // QAbstractTableModel methods //
                 // /////////////////////////// //
                 virtual int columnCount(const QModelIndex &parent = QModelIndex{}) const override;
                 virtual int rowCount(const QModelIndex &parent = QModelIndex{}) const override;
                 virtual QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
                 virtual QVariant headerData(int section, Qt::Orientation orientation,
                                             int role = Qt::DisplayRole) const override;
                 virtual Qt::ItemFlags flags(const QModelIndex &index) const override;
                 // ///////////////// //
                 // Drag&Drop methods //
                 // ///////////////// //
                 virtual Qt::DropActions supportedDropActions() const override;
                 virtual Qt::DropActions supportedDragActions() const override;
                 virtual QStringList mimeTypes() const override;
                 virtual QMimeData *mimeData(const QModelIndexList &indexes) const override;
                 virtual bool canDropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column,
                                              const QModelIndex &parent) const override;
                 virtual bool dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column,
                                           const QModelIndex &parent) override;
                 const std::vector<std::shared_ptr<Variable>>& variables() const
                 {return _variables;}
             signals:
                 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 variableUpdated(QUuid id) noexcept;
                 void variableAdded(const std::shared_ptr<Variable>&);
                 void variableDeleted(const std::shared_ptr<Variable>&);
             };
             #endif // SCIQLOP_VARIABLEMODEL2_H

src/Variable/Variable.cpp +3 -5

             #include <optional>
             #include <QMutex>
             #include <QReadWriteLock>
             #include <QThread>
             #include "Variable/Variable.h"
             #include <Data/IDataSeries.h>
             #include <Data/DateTimeRange.h>
             #include <Common/debug.h>
             Q_LOGGING_CATEGORY(LOG_Variable, "Variable")
             /**
              * Searches in metadata for a value that can be converted to DataSeriesType
              * @param metadata the metadata where to search
              * @return the value converted to a DataSeriesType if it was found, UNKNOWN type otherwise
              * @sa DataSeriesType
              */
             static DataSeriesType findDataSeriesType(const QVariantHash &metadata)
             {
                 auto dataSeriesType = DataSeriesType::UNKNOWN;
                 // Go through the metadata and stop at the first value that could be converted to DataSeriesType
                 for (auto it = metadata.cbegin(), end = metadata.cend();
                      it != end && dataSeriesType == DataSeriesType::UNKNOWN; ++it) {
                     dataSeriesType = DataSeriesTypeUtils::fromString(it.value().toString());
                 }
                 return dataSeriesType;
             }
             #define VP_PROPERTY(property,getter,setter,type) \
                 type getter() noexcept\
                 {\
                     QReadLocker lock{&m_Lock};\
                     return property;\
                 }\
                 void setter(const type& getter) noexcept\
                 {\
                     QWriteLocker lock{&m_Lock};\
                     property = getter;\
                 }\
                 type property;\
             #define V_FW_GETTER_SETTER(getter,setter, type)\
                 type Variable::getter() const noexcept \
                 {\
                     return impl->getter();\
                 }\
                 void Variable::setter(const type& getter) noexcept \
                 {\
                     impl->setter(getter);\
-                    emit updated();\
+                    emit updated(this->ID());\
                 }\
             struct Variable::VariablePrivate {
                 explicit VariablePrivate(const QString &name, const QVariantHash &metadata)
                         : m_Name{name},
                           m_Range{INVALID_RANGE},
                           m_CacheRange{INVALID_RANGE},
                           m_Metadata{metadata},
                           m_DataSeries{nullptr},
                           m_RealRange{INVALID_RANGE},
                           m_NbPoints{0},
                           m_Type{findDataSeriesType(m_Metadata)}
                 {
                 }
                 VariablePrivate(const VariablePrivate &other)
                         : m_Name{other.m_Name},
                           m_Range{other.m_Range},
                           m_CacheRange{other.m_CacheRange},
                           m_Metadata{other.m_Metadata},
                           m_DataSeries{other.m_DataSeries != nullptr ? other.m_DataSeries->clone() : nullptr},
                           m_RealRange{other.m_RealRange},
                           m_NbPoints{other.m_NbPoints},
                           m_Type{findDataSeriesType(m_Metadata)}
                 {
                 }
                 void lockRead() { m_Lock.lockForRead(); }
                 void lockWrite() { m_Lock.lockForWrite(); }
                 void unlock() { m_Lock.unlock(); }
                 void purgeDataSeries()
                 {
                     if (m_DataSeries) {
                         m_DataSeries->purge(m_CacheRange.m_TStart, m_CacheRange.m_TEnd);
                     }
                     updateRealRange();
                     updateNbPoints();
                 }
                 void mergeDataSeries(const std::vector<IDataSeries*>& dataseries)
                 {
                     QWriteLocker lock{&m_Lock};
                     for(auto ds:dataseries)
                     {
                         if(m_DataSeries)
                             m_DataSeries->merge(ds);
                         else
                             m_DataSeries = ds->clone();
                     }
                 }
                 void updateNbPoints() { m_NbPoints = m_DataSeries ? m_DataSeries->nbPoints() : 0; }
                 /// Updates real range according to current variable range and data series
                 void updateRealRange()
                 {
                     if (m_DataSeries) {
                         auto lock = m_DataSeries->getReadLock();
                         auto end = m_DataSeries->cend();
                         auto minXAxisIt = m_DataSeries->minXAxisData(m_Range.m_TStart);
                         auto maxXAxisIt = m_DataSeries->maxXAxisData(m_Range.m_TEnd);
                         if(minXAxisIt != end && maxXAxisIt != end && minXAxisIt->x() <= maxXAxisIt->x())
                             m_RealRange = DateTimeRange{minXAxisIt->x(), maxXAxisIt->x()};
                         else
                             m_RealRange = std::nullopt;
                     }
                     else {
                         m_RealRange = std::nullopt;
                     }
                 }
                 VP_PROPERTY(m_Name, name, setName, QString)
                 VP_PROPERTY(m_Range, range, setRange, DateTimeRange)
                 VP_PROPERTY(m_CacheRange, cacheRange, setCacheRange, DateTimeRange)
                 VP_PROPERTY(m_Metadata, metadata, setMetadata, QVariantHash)
                 VP_PROPERTY(m_DataSeries, dataSeries, setDataSeries, std::shared_ptr<IDataSeries>)
                 VP_PROPERTY(m_RealRange, realRange, setRealRange, std::optional<DateTimeRange>)
                 unsigned int m_NbPoints;
                 VP_PROPERTY(m_Type, type, setType, DataSeriesType)
                 QReadWriteLock m_Lock;
             };
             Variable::Variable(const QString &name, const QVariantHash &metadata)
                     : impl{spimpl::make_unique_impl<VariablePrivate>(name, metadata)},
                       _uuid{QUuid::createUuid()}
             {
             }
             Variable::Variable(const Variable &other)
                     : impl{spimpl::make_unique_impl<VariablePrivate>(*other.impl)},
                       _uuid{QUuid::createUuid()} //is a clone but must have a != uuid
             {
             }
             std::shared_ptr<Variable> Variable::clone() const
             {
                 return std::make_shared<Variable>(*this);
             }
             V_FW_GETTER_SETTER(name,setName,QString)
             DateTimeRange Variable::range() const noexcept
             {
                 return impl->range();
             }
             void Variable::setRange(const DateTimeRange &range, bool notify) noexcept
             {
                 impl->setRange(range);
                 impl->updateRealRange();
                 if(notify)
-                    emit this->updated();
+                    emit this->updated(this->ID());
             }
             V_FW_GETTER_SETTER(cacheRange, setCacheRange, DateTimeRange)
             unsigned int Variable::nbPoints() const noexcept
             {
                 return impl->m_NbPoints;
             }
             std::optional<DateTimeRange> Variable::realRange() const noexcept
             {
                 return impl->realRange();
             }
             void Variable::updateData(const std::vector<IDataSeries *> &dataSeries, const DateTimeRange &newRange, const DateTimeRange &newCacheRange, bool notify)
             {
                 {
                     QWriteLocker lock{&m_lock};
                     impl->mergeDataSeries(dataSeries);
                     impl->setRange(newRange);
                     impl->setCacheRange(newCacheRange);
                     impl->purgeDataSeries();
                 }
                 if(notify)
-                    emit updated();
+                    emit updated(this->ID());
             }
             std::shared_ptr<IDataSeries> Variable::dataSeries() const noexcept
             {
                 return impl->dataSeries();
             }
             DataSeriesType Variable::type() const noexcept
             {
                 return impl->type();
             }
             QVariantHash Variable::metadata() const noexcept
             {
                 impl->lockRead();
                 auto metadata = impl->m_Metadata;
                 impl->unlock();
                 return metadata;
             }

src/Variable/VariableModel2.cpp +1 -1

             #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>
             namespace {
             // Column indexes
             const auto NAME_COLUMN = 0;
             const auto TSTART_COLUMN = 1;
             const auto TEND_COLUMN = 2;
             const auto NBPOINTS_COLUMN = 3;
             const auto UNIT_COLUMN = 4;
             const auto MISSION_COLUMN = 5;
             const auto PLUGIN_COLUMN = 6;
             const auto NB_COLUMNS = 7;
             // Column properties
             const auto DEFAULT_HEIGHT = 25;
             const auto DEFAULT_WIDTH = 100;
             struct ColumnProperties {
                 ColumnProperties(const QString &name = {}, int width = DEFAULT_WIDTH,
                                  int height = DEFAULT_HEIGHT)
                         : m_Name{name}, m_Width{width}, m_Height{height}
                 {
                 }
                 QString m_Name;
                 int m_Width;
                 int m_Height;
             };
             const auto COLUMN_PROPERTIES = QHash<int, ColumnProperties>{
                 {NAME_COLUMN, {QObject::tr("Name")}},      {TSTART_COLUMN, {QObject::tr("tStart"), 180}},
                 {TEND_COLUMN, {QObject::tr("tEnd"), 180}}, {NBPOINTS_COLUMN, {QObject::tr("Nb points")}},
                 {UNIT_COLUMN, {QObject::tr("Unit")}},      {MISSION_COLUMN, {QObject::tr("Mission")}},
                 {PLUGIN_COLUMN, {QObject::tr("Plugin")}}};
             QString uniqueName(const QString &defaultName,
                                const std::vector<std::shared_ptr<Variable> > &variables)
             {
                 auto forbiddenNames = std::vector<QString>(variables.size());
                 std::transform(variables.cbegin(), variables.cend(), forbiddenNames.begin(),
                                [](const auto &variable) { return variable->name(); });
                 auto uniqueName = StringUtils::uniqueName(defaultName, forbiddenNames);
                 Q_ASSERT(!uniqueName.isEmpty());
                 return uniqueName;
             }
             } // namespace
             VariableModel2::VariableModel2(QObject *parent)
                 : QAbstractTableModel{parent}
             {
             }
             int VariableModel2::columnCount(const QModelIndex &parent) const
             {
                 Q_UNUSED(parent);
                 return NB_COLUMNS;
             }
             int VariableModel2::rowCount(const QModelIndex &parent) const
             {
                 Q_UNUSED(parent);
                 return _variables.size();
             }
             QVariant VariableModel2::data(const QModelIndex &index, int role) const
             {
                 if (!index.isValid()) {
                     return QVariant{};
                 }
                 if (index.row() < 0 || index.row() >= rowCount()) {
                     return QVariant{};
                 }
                 if (role == Qt::DisplayRole) {
                     if (auto variable = _variables[index.row()]) {
                         switch (index.column()) {
                             case NAME_COLUMN:
                                 return variable->name();
                             case TSTART_COLUMN: {
                                 if(auto range = variable->realRange(); range.has_value())
                                     return  DateUtils::dateTime(range.value().m_TStart).toString(DATETIME_FORMAT);
                                 return QVariant{};
                             }
                             case TEND_COLUMN: {
                                 if(auto range = variable->realRange(); range.has_value())
                                     return  DateUtils::dateTime(range.value().m_TEnd).toString(DATETIME_FORMAT);
                                 return QVariant{};
                             }
                             case NBPOINTS_COLUMN:
                                 return variable->nbPoints();
                             case UNIT_COLUMN:
                                 return variable->metadata().value(QStringLiteral("units"));
                             case MISSION_COLUMN:
                                 return variable->metadata().value(QStringLiteral("mission"));
                             case PLUGIN_COLUMN:
                                 return variable->metadata().value(QStringLiteral("plugin"));
                             default:
                                 // No action
                                 break;
                         }
                     }
                 }
                 else if (role == VariableRoles::ProgressRole) {
                     return QVariant{};
                 }
                 return QVariant{};
             }
             QVariant VariableModel2::headerData(int section, Qt::Orientation orientation, int role) const
             {
                 if (role != Qt::DisplayRole && role != Qt::SizeHintRole) {
                     return QVariant{};
                 }
                 if (orientation == Qt::Horizontal) {
                     auto propertiesIt = COLUMN_PROPERTIES.find(section);
                     if (propertiesIt != COLUMN_PROPERTIES.cend()) {
                         // Role is either DisplayRole or SizeHintRole
                         return (role == Qt::DisplayRole)
                                    ? QVariant{propertiesIt->m_Name}
                                    : QVariant{QSize{propertiesIt->m_Width, propertiesIt->m_Height}};
                     }
                 }
                 return QVariant{};
             }
             Qt::ItemFlags VariableModel2::flags(const QModelIndex &index) const
             {
                 return QAbstractTableModel::flags(index) | Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled;
             }
             Qt::DropActions VariableModel2::supportedDropActions() const
             {
                 return Qt::CopyAction | Qt::MoveAction;
             }
             Qt::DropActions VariableModel2::supportedDragActions() const
             {
                 return Qt::CopyAction | Qt::MoveAction;
             }
             QStringList VariableModel2::mimeTypes() const
             {
                 return {MIME_TYPE_VARIABLE_LIST, MIME_TYPE_TIME_RANGE};
             }
             QMimeData *VariableModel2::mimeData(const QModelIndexList &indexes) const
             {
                 auto mimeData = new QMimeData;
                 std::vector<std::shared_ptr<Variable> > variables;
                 DateTimeRange firstTimeRange;
                 for (const auto &index : indexes) {
                     if (index.column() == 0) { // only the first column
                         auto variable = _variables[index.row()];
                         if (variable.get() && index.isValid()) {
                             if (variables.size()==0) {
                                 // Gets the range of the first variable
                                 firstTimeRange = variable->range();
                             }
                             variables.push_back(variable);
                         }
                     }
                 }
                 auto variablesEncodedData = Variable::mimeData(variables);
                 mimeData->setData(MIME_TYPE_VARIABLE_LIST, variablesEncodedData);
                 if (variables.size() == 1) {
                     // No time range MIME data if multiple variables are dragged
                     auto timeEncodedData = TimeController::mimeDataForTimeRange(firstTimeRange);
                     mimeData->setData(MIME_TYPE_TIME_RANGE, timeEncodedData);
                 }
                 return mimeData;
             }
             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()
                            && !data->hasFormat(MIME_TYPE_VARIABLE_LIST));
             }
             bool VariableModel2::dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column,
                                              const QModelIndex &parent)
             {
                 auto dropDone = false;
                 if (data->hasFormat(MIME_TYPE_PRODUCT_LIST)) {
                     auto productList
                         = DataSourceController::productsDataForMimeData(data->data(MIME_TYPE_PRODUCT_LIST));
                     for (auto metaData : productList) {
                         emit createVariable(metaData.toHash());
                     }
                     dropDone = true;
                 }
                 else if (data->hasFormat(MIME_TYPE_TIME_RANGE) && parent.isValid()) {
                     auto variable = _variables[parent.row()];
                     auto range = TimeController::timeRangeForMimeData(data->data(MIME_TYPE_TIME_RANGE));
                     emit asyncChangeRange(variable, range);
                     dropDone = true;
                 }
                 return dropDone;
             }
-            void VariableModel2::variableUpdated() noexcept
+            void VariableModel2::variableUpdated(QUuid id) 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