HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r654:aff19a50babf

Fixed untimely update of the range to be displayed in the variable widget

Alexandre Leroux -

r654:aff19a50babf

parent child

Context file:

r654:aff19a50babf

Collapse all files

core/include/Data/SqpRange.h +13 0

             #ifndef SCIQLOP_SQPRANGE_H
             #define SCIQLOP_SQPRANGE_H
             #include <QObject>
             #include <QDebug>
             #include <Common/DateUtils.h>
             #include <Common/MetaTypes.h>
             /**
              * @brief The SqpRange struct holds the information of time parameters
              */
             struct SqpRange {
                 /// Start time (UTC)
                 double m_TStart;
                 /// End time (UTC)
                 double m_TEnd;
                 bool contains(const SqpRange &dateTime) const noexcept
                 {
                     return (m_TStart <= dateTime.m_TStart && m_TEnd >= dateTime.m_TEnd);
                 }
                 bool intersect(const SqpRange &dateTime) const noexcept
                 {
                     return (m_TEnd >= dateTime.m_TStart && m_TStart <= dateTime.m_TEnd);
                 }
+                bool operator==(const SqpRange &other) const
+                {
+                    auto equals = [](const auto &v1, const auto &v2) {
+                        return (std::isnan(v1) && std::isnan(v2)) || v1 == v2;
+                    };
+                    return equals(m_TStart, other.m_TStart) && equals(m_TEnd, other.m_TEnd);
+                }
+                bool operator!=(const SqpRange &other) const { return !(*this == other); }
             };
+            const auto INVALID_RANGE
+                = SqpRange{std::numeric_limits<double>::quiet_NaN(), std::numeric_limits<double>::quiet_NaN()};
             inline QDebug operator<<(QDebug d, SqpRange obj)
             {
                 auto tendDateTimeStart = DateUtils::dateTime(obj.m_TStart);
                 auto tendDateTimeEnd = DateUtils::dateTime(obj.m_TEnd);
                 d << "ts: " << tendDateTimeStart << " te: " << tendDateTimeEnd;
                 return d;
             }
             // Required for using shared_ptr in signals/slots
             SCIQLOP_REGISTER_META_TYPE(SQPRANGE_REGISTRY, SqpRange)
             #endif // SCIQLOP_SQPRANGE_H

core/include/Variable/Variable.h +9 0

             #ifndef SCIQLOP_VARIABLE_H
             #define SCIQLOP_VARIABLE_H
             #include "CoreGlobal.h"
+            #include <Data/DataSeriesIterator.h>
             #include <Data/SqpRange.h>
             #include <QLoggingCategory>
             #include <QObject>
             #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 SqpRange &dateTime,
                                   const QVariantHash &metadata = {});
                 QString name() const noexcept;
                 SqpRange range() const noexcept;
                 void setRange(const SqpRange &range) noexcept;
                 SqpRange cacheRange() const noexcept;
                 void setCacheRange(const SqpRange &cacheRange) 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()
+                SqpRange realRange() const noexcept;
                 /// @return the data of the variable, nullptr if there is no data
                 std::shared_ptr<IDataSeries> dataSeries() const noexcept;
                 QVariantHash metadata() const noexcept;
                 bool contains(const SqpRange &range) const noexcept;
                 bool intersect(const SqpRange &range) const noexcept;
                 bool isInside(const SqpRange &range) const noexcept;
                 bool cacheContains(const SqpRange &range) const noexcept;
                 bool cacheIntersect(const SqpRange &range) const noexcept;
                 bool cacheIsInside(const SqpRange &range) const noexcept;
                 QVector<SqpRange> provideNotInCacheRangeList(const SqpRange &range) const noexcept;
                 QVector<SqpRange> provideInCacheRangeList(const SqpRange &range) const noexcept;
                 void setDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept;
                 void mergeDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept;
             signals:
                 void updated();
             private:
                 class VariablePrivate;
                 spimpl::unique_impl_ptr<VariablePrivate> impl;
             };
             // 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

core/src/Variable/Variable.cpp +32 -1

             #include "Variable/Variable.h"
             #include <Data/IDataSeries.h>
             #include <Data/SqpRange.h>
             #include <QMutex>
             #include <QReadWriteLock>
             #include <QThread>
             Q_LOGGING_CATEGORY(LOG_Variable, "Variable")
             struct Variable::VariablePrivate {
                 explicit VariablePrivate(const QString &name, const SqpRange &dateTime,
                                          const QVariantHash &metadata)
-                        : m_Name{name}, m_Range{dateTime}, m_Metadata{metadata}, m_DataSeries{nullptr}
+                        : m_Name{name},
+                          m_Range{dateTime},
+                          m_Metadata{metadata},
+                          m_DataSeries{nullptr},
+                          m_RealRange{INVALID_RANGE}
                 {
                 }
                 void lockRead() { m_Lock.lockForRead(); }
                 void lockWrite() { m_Lock.lockForWrite(); }
                 void unlock() { m_Lock.unlock(); }
+                /// Updates real range according to current variable range and data series
+                void updateRealRange()
+                {
+                    if (m_DataSeries) {
+                        m_DataSeries->lockRead();
+                        auto end = m_DataSeries->cend();
+                        auto minXAxisIt = m_DataSeries->minXAxisData(m_Range.m_TStart);
+                        auto maxXAxisIt = m_DataSeries->maxXAxisData(m_Range.m_TEnd);
+                        m_RealRange = (minXAxisIt != end && maxXAxisIt != end)
+                                          ? SqpRange{minXAxisIt->x(), maxXAxisIt->x()}
+                                          : INVALID_RANGE;
+                        m_DataSeries->unlock();
+                    }
+                    else {
+                        m_RealRange = INVALID_RANGE;
+                    }
+                }
                 QString m_Name;
                 SqpRange m_Range;
                 SqpRange m_CacheRange;
                 QVariantHash m_Metadata;
                 std::shared_ptr<IDataSeries> m_DataSeries;
+                SqpRange m_RealRange;
                 QReadWriteLock m_Lock;
             };
             Variable::Variable(const QString &name, const SqpRange &dateTime, const QVariantHash &metadata)
                     : impl{spimpl::make_unique_impl<VariablePrivate>(name, dateTime, metadata)}
             {
             }
             QString Variable::name() const noexcept
             {
                 impl->lockRead();
                 auto name = impl->m_Name;
                 impl->unlock();
                 return name;
             }
             SqpRange Variable::range() const noexcept
             {
                 impl->lockRead();
                 auto range = impl->m_Range;
                 impl->unlock();
                 return range;
             }
             void Variable::setRange(const SqpRange &range) noexcept
             {
                 impl->lockWrite();
                 impl->m_Range = range;
+                impl->updateRealRange();
                 impl->unlock();
             }
             SqpRange Variable::cacheRange() const noexcept
             {
                 impl->lockRead();
                 auto cacheRange = impl->m_CacheRange;
                 impl->unlock();
                 return cacheRange;
             }
             void Variable::setCacheRange(const SqpRange &cacheRange) noexcept
             {
                 impl->lockWrite();
                 impl->m_CacheRange = cacheRange;
                 impl->unlock();
             }
+            SqpRange Variable::realRange() const noexcept
+            {
+                return impl->m_RealRange;
+            }
             void Variable::setDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept
             {
                 qCDebug(LOG_Variable()) << "TORM Variable::setDataSeries"
                                         << QThread::currentThread()->objectName();
                 if (!dataSeries) {
                     /// @todo ALX : log
                     return;
                 }
                 impl->lockWrite();
                 impl->m_DataSeries = dataSeries->clone();
+                impl->updateRealRange();
                 impl->unlock();
             }
             void Variable::mergeDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept
             {
                 qCDebug(LOG_Variable()) << "TORM Variable::mergeDataSeries"
                                         << QThread::currentThread()->objectName();
                 if (!dataSeries) {
                     /// @todo ALX : log
                     return;
                 }
                 // Add or merge the data
                 // Inits the data series of the variable
                 impl->lockWrite();
                 if (!impl->m_DataSeries) {
                     impl->m_DataSeries = dataSeries->clone();
                 }
                 else {
                     impl->m_DataSeries->merge(dataSeries.get());
                 }
                 impl->unlock();
                 // sub the data
                 auto subData = this->dataSeries()->subDataSeries(this->cacheRange());
                 qCDebug(LOG_Variable()) << "TORM: Variable::mergeDataSeries sub" << subData->range();
                 this->setDataSeries(subData);
                 qCDebug(LOG_Variable()) << "TORM: Variable::mergeDataSeries set" << this->dataSeries()->range();
             }
             std::shared_ptr<IDataSeries> Variable::dataSeries() const noexcept
             {
                 impl->lockRead();
                 auto dataSeries = impl->m_DataSeries;
                 impl->unlock();
                 return dataSeries;
             }
             QVariantHash Variable::metadata() const noexcept
             {
                 impl->lockRead();
                 auto metadata = impl->m_Metadata;
                 impl->unlock();
                 return metadata;
             }
             bool Variable::contains(const SqpRange &range) const noexcept
             {
                 impl->lockRead();
                 auto res = impl->m_Range.contains(range);
                 impl->unlock();
                 return res;
             }
             bool Variable::intersect(const SqpRange &range) const noexcept
             {
                 impl->lockRead();
                 auto res = impl->m_Range.intersect(range);
                 impl->unlock();
                 return res;
             }
             bool Variable::isInside(const SqpRange &range) const noexcept
             {
                 impl->lockRead();
                 auto res = range.contains(SqpRange{impl->m_Range.m_TStart, impl->m_Range.m_TEnd});
                 impl->unlock();
                 return res;
             }
             bool Variable::cacheContains(const SqpRange &range) const noexcept
             {
                 impl->lockRead();
                 auto res = impl->m_CacheRange.contains(range);
                 impl->unlock();
                 return res;
             }
             bool Variable::cacheIntersect(const SqpRange &range) const noexcept
             {
                 impl->lockRead();
                 auto res = impl->m_CacheRange.intersect(range);
                 impl->unlock();
                 return res;
             }
             bool Variable::cacheIsInside(const SqpRange &range) const noexcept
             {
                 impl->lockRead();
                 auto res = range.contains(SqpRange{impl->m_CacheRange.m_TStart, impl->m_CacheRange.m_TEnd});
                 impl->unlock();
                 return res;
             }
             QVector<SqpRange> Variable::provideNotInCacheRangeList(const SqpRange &range) const noexcept
             {
                 // This code assume that cach in contigue. Can return 0, 1 or 2 SqpRange
                 auto notInCache = QVector<SqpRange>{};
                 if (!this->cacheContains(range)) {
                     if (range.m_TEnd <= impl->m_CacheRange.m_TStart
                         || range.m_TStart >= impl->m_CacheRange.m_TEnd) {
                         notInCache << range;
                     }
                     else if (range.m_TStart < impl->m_CacheRange.m_TStart
                              && range.m_TEnd <= impl->m_CacheRange.m_TEnd) {
                         notInCache << SqpRange{range.m_TStart, impl->m_CacheRange.m_TStart};
                     }
                     else if (range.m_TStart < impl->m_CacheRange.m_TStart
                              && range.m_TEnd > impl->m_CacheRange.m_TEnd) {
                         notInCache << SqpRange{range.m_TStart, impl->m_CacheRange.m_TStart}
                                    << SqpRange{impl->m_CacheRange.m_TEnd, range.m_TEnd};
                     }
                     else if (range.m_TStart < impl->m_CacheRange.m_TEnd) {
                         notInCache << SqpRange{impl->m_CacheRange.m_TEnd, range.m_TEnd};
                     }
                     else {
                         qCCritical(LOG_Variable()) << tr("Detection of unknown case.")
                                                    << QThread::currentThread();
                     }
                 }
                 return notInCache;
             }
             QVector<SqpRange> Variable::provideInCacheRangeList(const SqpRange &range) const noexcept
             {
                 // This code assume that cach in contigue. Can return 0 or 1 SqpRange
                 auto inCache = QVector<SqpRange>{};
                 if (this->intersect(range)) {
                     if (range.m_TStart <= impl->m_CacheRange.m_TStart
                         && range.m_TEnd >= impl->m_CacheRange.m_TStart
                         && range.m_TEnd < impl->m_CacheRange.m_TEnd) {
                         inCache << SqpRange{impl->m_CacheRange.m_TStart, range.m_TEnd};
                     }
                     else if (range.m_TStart >= impl->m_CacheRange.m_TStart
                              && range.m_TEnd <= impl->m_CacheRange.m_TEnd) {
                         inCache << range;
                     }
                     else if (range.m_TStart > impl->m_CacheRange.m_TStart
                              && range.m_TEnd > impl->m_CacheRange.m_TEnd) {
                         inCache << SqpRange{range.m_TStart, impl->m_CacheRange.m_TEnd};
                     }
                     else if (range.m_TStart <= impl->m_CacheRange.m_TStart
                              && range.m_TEnd >= impl->m_CacheRange.m_TEnd) {
                         inCache << impl->m_CacheRange;
                     }
                     else {
                         qCCritical(LOG_Variable()) << tr("Detection of unknown case.")
                                                    << QThread::currentThread();
                     }
                 }
                 return inCache;
             }

core/src/Variable/VariableModel.cpp +12 -26

             #include <Variable/Variable.h>
             #include <Variable/VariableModel.h>
             #include <Common/DateUtils.h>
             #include <Data/IDataSeries.h>
             #include <QSize>
             #include <unordered_map>
             Q_LOGGING_CATEGORY(LOG_VariableModel, "VariableModel")
             namespace {
             // Column indexes
             const auto NAME_COLUMN = 0;
             const auto TSTART_COLUMN = 1;
             const auto TEND_COLUMN = 2;
             const auto UNIT_COLUMN = 3;
             const auto MISSION_COLUMN = 4;
             const auto PLUGIN_COLUMN = 5;
             const auto NB_COLUMNS = 6;
             // 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}},  {UNIT_COLUMN, {QObject::tr("Unit")}},
                 {MISSION_COLUMN, {QObject::tr("Mission")}}, {PLUGIN_COLUMN, {QObject::tr("Plugin")}}};
             /// Format for datetimes
             const auto DATETIME_FORMAT = QStringLiteral("dd/MM/yyyy \nhh:mm:ss:zzz");
             } // namespace
             struct VariableModel::VariableModelPrivate {
                 /// Variables created in SciQlop
                 std::vector<std::shared_ptr<Variable> > m_Variables;
                 std::unordered_map<std::shared_ptr<Variable>, double> m_VariableToProgress;
                 /// Return the row index of the variable. -1 if it's not found
                 int indexOfVariable(Variable *variable) const noexcept;
             };
             VariableModel::VariableModel(QObject *parent)
                     : QAbstractTableModel{parent}, impl{spimpl::make_unique_impl<VariableModelPrivate>()}
             {
             }
             std::shared_ptr<Variable> VariableModel::createVariable(const QString &name,
                                                                     const SqpRange &dateTime,
                                                                     const QVariantHash &metadata) noexcept
             {
                 auto insertIndex = rowCount();
                 beginInsertRows({}, insertIndex, insertIndex);
                 auto variable = std::make_shared<Variable>(name, dateTime, metadata);
                 impl->m_Variables.push_back(variable);
                 connect(variable.get(), &Variable::updated, this, &VariableModel::onVariableUpdated);
                 endInsertRows();
                 return variable;
             }
             void VariableModel::deleteVariable(std::shared_ptr<Variable> variable) noexcept
             {
                 if (!variable) {
                     qCCritical(LOG_Variable()) << "Can't delete a null variable from the model";
                     return;
                 }
                 // Finds variable in the model
                 auto begin = impl->m_Variables.cbegin();
                 auto end = impl->m_Variables.cend();
                 auto it = std::find(begin, end, variable);
                 if (it != end) {
                     auto removeIndex = std::distance(begin, it);
                     // Deletes variable
                     beginRemoveRows({}, removeIndex, removeIndex);
                     impl->m_Variables.erase(it);
                     endRemoveRows();
                 }
                 else {
                     qCritical(LOG_VariableModel())
                         << tr("Can't delete variable %1 from the model: the variable is not in the model")
                                .arg(variable->name());
                 }
                 // Removes variable from progress map
                 impl->m_VariableToProgress.erase(variable);
             }
             std::shared_ptr<Variable> VariableModel::variable(int index) const
             {
                 return (index >= 0 && index < impl->m_Variables.size()) ? impl->m_Variables[index] : nullptr;
             }
             void VariableModel::setDataProgress(std::shared_ptr<Variable> variable, double progress)
             {
                 if (progress > 0.0) {
                     impl->m_VariableToProgress[variable] = progress;
                 }
                 else {
                     impl->m_VariableToProgress.erase(variable);
                 }
                 auto modelIndex = createIndex(impl->indexOfVariable(variable.get()), NAME_COLUMN);
                 emit dataChanged(modelIndex, modelIndex);
             }
             int VariableModel::columnCount(const QModelIndex &parent) const
             {
                 Q_UNUSED(parent);
                 return NB_COLUMNS;
             }
             int VariableModel::rowCount(const QModelIndex &parent) const
             {
                 Q_UNUSED(parent);
                 return impl->m_Variables.size();
             }
             QVariant VariableModel::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 = impl->m_Variables.at(index.row()).get()) {
-                        /// Lambda function that builds the variant to return for a time value
-                        /// @param getValueFun function used to get for a data series the iterator on the entry
-                        /// that contains the time value to display
-                        auto dateTimeVariant = [variable](const auto &getValueFun) {
-                            if (auto dataSeries = variable->dataSeries()) {
-                                dataSeries->lockRead();
-                                auto it = getValueFun(*dataSeries);
-                                auto resVariant = (it != dataSeries->cend())
-                                                      ? DateUtils::dateTime(it->x()).toString(DATETIME_FORMAT)
-                                                      : QVariant{};
-                                dataSeries->unlock();
-                                return resVariant;
-                            else {
-                                return QVariant{};
-                        };
                         switch (index.column()) {
                             case NAME_COLUMN:
                                 return variable->name();
-                            case TSTART_COLUMN:
+                            case TSTART_COLUMN: {
-                                // Shows the min value of the data series above the range tstart
+                                auto range = variable->realRange();
-                                return dateTimeVariant([min = variable->range().m_TStart](
+                                return range != INVALID_RANGE
-                                    const auto &dataSeries) { return dataSeries.minXAxisData(min); });
+                                           ? DateUtils::dateTime(range.m_TStart).toString(DATETIME_FORMAT)
-                            case TEND_COLUMN:
+                                           : QVariant{};
-                                // Shows the max value of the data series under the range tend
-                                return dateTimeVariant([max = variable->range().m_TEnd](
+                            case TEND_COLUMN: {
-                                    const auto &dataSeries) { return dataSeries.maxXAxisData(max); });
+                                auto range = variable->realRange();
+                                return range != INVALID_RANGE
+                                           ? DateUtils::dateTime(range.m_TEnd).toString(DATETIME_FORMAT)
+                                           : QVariant{};
+                            }
                             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;
                         }
                         qWarning(LOG_VariableModel())
                             << tr("Can't get data (unknown column %1)").arg(index.column());
                     }
                     else {
                         qWarning(LOG_VariableModel()) << tr("Can't get data (no variable)");
                     }
                 }
                 else if (role == VariableRoles::ProgressRole) {
                     if (auto variable = impl->m_Variables.at(index.row())) {
                         auto it = impl->m_VariableToProgress.find(variable);
                         if (it != impl->m_VariableToProgress.cend()) {
                             return it->second;
                         }
                     }
                 }
                 return QVariant{};
             }
             QVariant VariableModel::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}};
                     }
                     else {
                         qWarning(LOG_VariableModel())
                             << tr("Can't get header data (unknown column %1)").arg(section);
                     }
                 }
                 return QVariant{};
             }
             void VariableModel::abortProgress(const QModelIndex &index)
             {
                 if (auto variable = impl->m_Variables.at(index.row())) {
                     emit abortProgessRequested(variable);
                 }
             }
             void VariableModel::onVariableUpdated() noexcept
             {
                 // Finds variable that has been updated in the model
                 if (auto updatedVariable = dynamic_cast<Variable *>(sender())) {
                     auto updatedVariableIndex = impl->indexOfVariable(updatedVariable);
                     if (updatedVariableIndex > -1) {
                         emit dataChanged(createIndex(updatedVariableIndex, 0),
                                          createIndex(updatedVariableIndex, columnCount() - 1));
                     }
                 }
             }
             int VariableModel::VariableModelPrivate::indexOfVariable(Variable *variable) const noexcept
             {
                 auto begin = std::cbegin(m_Variables);
                 auto end = std::cend(m_Variables);
                 auto it
                     = std::find_if(begin, end, [variable](const auto &var) { return var.get() == variable; });
                 if (it != end) {
                     // Gets the index of the variable in the model: we assume here that views have the same
                     // order as the model
                     return std::distance(begin, it);
                 }
                 else {
                     return -1;
                 }
             }

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