GIT_REPOSITORIES/LPP/Users/mperrinel/SCIQLOP-Initialisation Commit - r212:8e4faeed90b4

A variable is now created with its dateTime too....

perrinel -

r212:8e4faeed90b4

parent child

Context file:

r212:8e4faeed90b4

core/include/Data/SqpDateTime.h +5 0

             #ifndef SCIQLOP_SQPDATETIME_H
             #define SCIQLOP_SQPDATETIME_H
             /**
              * @brief The SqpDateTime struct holds the information of time parameters
              */
             struct SqpDateTime {
                 /// Start time
                 double m_TStart;
                 /// End time
                 double m_TEnd;
+                bool contains(const SqpDateTime &dateTime)
+                {
+                    return (m_TStart <= dateTime.m_TStart && m_TEnd >= dateTime.m_TEnd);
+                }
             };
             #endif // SCIQLOP_SQPDATETIME_H

core/include/Variable/Variable.h +2 -1

             #ifndef SCIQLOP_VARIABLE_H
             #define SCIQLOP_VARIABLE_H
             #include <Data/SqpDateTime.h>
             #include <QLoggingCategory>
             #include <QObject>
             #include <Common/spimpl.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_Variable)
             class IDataSeries;
             class QString;
             /**
              * @brief The Variable class represents a variable in SciQlop.
              */
             class Variable {
             public:
-                explicit Variable(const QString &name, const QString &unit, const QString &mission);
+                explicit Variable(const QString &name, const QString &unit, const QString &mission,
+                                  const SqpDateTime &dateTime);
                 QString name() const noexcept;
                 QString mission() const noexcept;
                 QString unit() const noexcept;
                 void addDataSeries(std::unique_ptr<IDataSeries> dataSeries) noexcept;
                 /// @return the data of the variable, nullptr if there is no data
                 IDataSeries *dataSeries() const noexcept;
             public slots:
                 void onXRangeChanged(SqpDateTime dateTime);
             private:
                 class VariablePrivate;
                 spimpl::unique_impl_ptr<VariablePrivate> impl;
             };
             // Required for using shared_ptr in signals/slots
             Q_DECLARE_METATYPE(std::shared_ptr<Variable>)
             #endif // SCIQLOP_VARIABLE_H

core/include/Variable/VariableModel.h +7 -2

             #ifndef SCIQLOP_VARIABLEMODEL_H
             #define SCIQLOP_VARIABLEMODEL_H
-            #include <Common/spimpl.h>
+            #include <Data/SqpDateTime.h>
             #include <QAbstractTableModel>
             #include <QLoggingCategory>
+            #include <Common/spimpl.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_VariableModel)
             class IDataSeries;
             class Variable;
             /**
              * @brief The VariableModel class aims to hold the variables that have been created in SciQlop
              */
             class VariableModel : public QAbstractTableModel {
             public:
                 explicit VariableModel(QObject *parent = nullptr);
                 /**
                  * Creates a new variable in the model
                  * @param name the name of the new variable
+                 * @param dateTime the dateTime of the new variable
                  * @param defaultDataSeries the default data of the new variable
                  * @return the pointer to the new variable
                  */
                 std::shared_ptr<Variable>
-                createVariable(const QString &name, std::unique_ptr<IDataSeries> defaultDataSeries) noexcept;
+                createVariable(const QString &name, const SqpDateTime &dateTime,
+                               std::unique_ptr<IDataSeries> defaultDataSeries) noexcept;
                 // /////////////////////////// //
                 // 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;
             private:
                 class VariableModelPrivate;
                 spimpl::unique_impl_ptr<VariableModelPrivate> impl;
             };
             #endif // SCIQLOP_VARIABLEMODEL_H

core/src/Variable/Variable.cpp +20 -4

             #include "Variable/Variable.h"
             #include <Data/IDataSeries.h>
             #include <Data/SqpDateTime.h>
             Q_LOGGING_CATEGORY(LOG_Variable, "Variable")
             struct Variable::VariablePrivate {
-                explicit VariablePrivate(const QString &name, const QString &unit, const QString &mission)
+                explicit VariablePrivate(const QString &name, const QString &unit, const QString &mission,
-                        : m_Name{name}, m_Unit{unit}, m_Mission{mission}, m_DataSeries{nullptr}
+                                         const SqpDateTime &dateTime)
+                        : m_Name{name},
+                          m_Unit{unit},
+                          m_Mission{mission},
+                          m_DateTime{dateTime},
+                          m_DataSeries{nullptr}
                 {
                 }
                 QString m_Name;
                 QString m_Unit;
                 QString m_Mission;
                 SqpDateTime m_DateTime; // The dateTime available in the view and loaded. not the cache.
                 std::unique_ptr<IDataSeries> m_DataSeries;
             };
-            Variable::Variable(const QString &name, const QString &unit, const QString &mission)
+            Variable::Variable(const QString &name, const QString &unit, const QString &mission,
-                    : impl{spimpl::make_unique_impl<VariablePrivate>(name, unit, mission)}
+                               const SqpDateTime &dateTime)
+                    : impl{spimpl::make_unique_impl<VariablePrivate>(name, unit, mission, dateTime)}
             {
             }
             QString Variable::name() const noexcept
             {
                 return impl->m_Name;
             }
             QString Variable::mission() const noexcept
             {
                 return impl->m_Mission;
             }
             QString Variable::unit() const noexcept
             {
                 return impl->m_Unit;
             }
             void Variable::addDataSeries(std::unique_ptr<IDataSeries> dataSeries) noexcept
             {
                 if (!impl->m_DataSeries) {
                     impl->m_DataSeries = std::move(dataSeries);
                 }
                 /// @todo : else, merge the two data series (if possible)
             }
             IDataSeries *Variable::dataSeries() const noexcept
             {
                 return impl->m_DataSeries.get();
             }
             void Variable::onXRangeChanged(SqpDateTime dateTime)
             {
                 qCInfo(LOG_Variable()) << "onXRangeChanged detected";
+                if (!impl->m_DateTime.contains(dateTime)) {
+                    // The current variable dateTime isn't enough to display the dateTime requested.
+                    // We have to update it to the new dateTime requested.
+                    // the correspondant new data to display will be given by the cache if possible and the
+                    // provider if necessary.
+                    qCInfo(LOG_Variable()) << "NEW DATE NEEDED";
+                    impl->m_DateTime = dateTime;
+                }
             }

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

             #include <Variable/VariableCacheController.h>
             #include <Variable/VariableController.h>
             #include <Variable/VariableModel.h>
             #include <Data/DataProviderParameters.h>
             #include <Data/IDataProvider.h>
             #include <Data/IDataSeries.h>
             #include <Time/TimeController.h>
             #include <QDateTime>
             #include <QMutex>
             #include <QThread>
             #include <unordered_map>
             Q_LOGGING_CATEGORY(LOG_VariableController, "VariableController")
             namespace {
             /// @todo Generates default dataseries, according to the provider passed in parameter. This method
             /// will be deleted when the timerange is recovered from SciQlop
             std::unique_ptr<IDataSeries> generateDefaultDataSeries(const IDataProvider &provider,
                                                                    const SqpDateTime &dateTime) noexcept
             {
                 auto parameters = DataProviderParameters{dateTime};
                 return provider.retrieveData(parameters);
             }
             } // namespace
             struct VariableController::VariableControllerPrivate {
                 explicit VariableControllerPrivate(VariableController *parent)
                         : m_WorkingMutex{},
                           m_VariableModel{new VariableModel{parent}},
                           m_VariableCacheController{std::make_unique<VariableCacheController>()}
                 {
                 }
                 QMutex m_WorkingMutex;
                 /// Variable model. The VariableController has the ownership
                 VariableModel *m_VariableModel;
                 TimeController *m_TimeController{nullptr};
                 std::unique_ptr<VariableCacheController> m_VariableCacheController;
             };
             VariableController::VariableController(QObject *parent)
                     : QObject{parent}, impl{spimpl::make_unique_impl<VariableControllerPrivate>(this)}
             {
                 qCDebug(LOG_VariableController()) << tr("VariableController construction")
                                                   << QThread::currentThread();
             }
             VariableController::~VariableController()
             {
                 qCDebug(LOG_VariableController()) << tr("VariableController destruction")
                                                   << QThread::currentThread();
                 this->waitForFinish();
             }
             VariableModel *VariableController::variableModel() noexcept
             {
                 return impl->m_VariableModel;
             }
             void VariableController::setTimeController(TimeController *timeController) noexcept
             {
                 impl->m_TimeController = timeController;
             }
             void VariableController::createVariable(const QString &name,
                                                     std::shared_ptr<IDataProvider> provider) noexcept
             {
                 // TORM
                 //    auto dateTime = SqpDateTime{
                 //        // Remarks : we don't use toSecsSinceEpoch() here (method is for Qt 5.8 or above)
                 //        static_cast<double>(QDateTime{QDate{2017, 01, 01}, QTime{12, 00}}.toMSecsSinceEpoch()
                 //                            / 1000.),
                 //        static_cast<double>(QDateTime{QDate{2017, 01, 01}, QTime{12, 01}}.toMSecsSinceEpoch())
                 //            / 1000.};
                 if (!impl->m_TimeController) {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to create variable: The time controller is null");
                     return;
                 }
                 /// @todo : for the moment :
                 /// - the provider is only used to retrieve data from the variable for its initialization, but
                 /// it will be retained later
                 /// - default data are generated for the variable, without taking into account the timerange set
                 /// in sciqlop
                 auto dateTime = impl->m_TimeController->dateTime();
                 if (auto newVariable = impl->m_VariableModel->createVariable(
-                        name, generateDefaultDataSeries(*provider, dateTime))) {
+                        name, dateTime, generateDefaultDataSeries(*provider, dateTime))) {
                     // store in cache
                     impl->m_VariableCacheController->addDateTime(newVariable, dateTime);
                     // notify the creation
                     emit variableCreated(newVariable);
                 }
             }
             void VariableController::initialize()
             {
                 qCDebug(LOG_VariableController()) << tr("VariableController init") << QThread::currentThread();
                 impl->m_WorkingMutex.lock();
                 qCDebug(LOG_VariableController()) << tr("VariableController init END");
             }
             void VariableController::finalize()
             {
                 impl->m_WorkingMutex.unlock();
             }
             void VariableController::waitForFinish()
             {
                 QMutexLocker locker{&impl->m_WorkingMutex};
             }

core/src/Variable/VariableModel.cpp +3 -3

             #include <Variable/Variable.h>
             #include <Variable/VariableModel.h>
             #include <Data/IDataSeries.h>
             Q_LOGGING_CATEGORY(LOG_VariableModel, "VariableModel")
             namespace {
             // Column indexes
             const auto NAME_COLUMN = 0;
             const auto UNIT_COLUMN = 1;
             const auto MISSION_COLUMN = 2;
             const auto NB_COLUMNS = 3;
             } // namespace
             struct VariableModel::VariableModelPrivate {
                 /// Variables created in SciQlop
                 std::vector<std::shared_ptr<Variable> > m_Variables;
             };
             VariableModel::VariableModel(QObject *parent)
                     : QAbstractTableModel{parent}, impl{spimpl::make_unique_impl<VariableModelPrivate>()}
             {
             }
             std::shared_ptr<Variable>
-            VariableModel::createVariable(const QString &name,
+            VariableModel::createVariable(const QString &name, const SqpDateTime &dateTime,
                                           std::unique_ptr<IDataSeries> defaultDataSeries) noexcept
             {
                 auto insertIndex = rowCount();
                 beginInsertRows({}, insertIndex, insertIndex);
                 /// @todo For the moment, the other data of the variable is initialized with default values
-                auto variable
+                auto variable = std::make_shared<Variable>(name, QStringLiteral("unit"),
-                    = std::make_shared<Variable>(name, QStringLiteral("unit"), QStringLiteral("mission"));
+                                                           QStringLiteral("mission"), dateTime);
                 variable->addDataSeries(std::move(defaultDataSeries));
                 impl->m_Variables.push_back(variable);
                 endInsertRows();
                 return variable;
             }
             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()) {
                         switch (index.column()) {
                             case NAME_COLUMN:
                                 return variable->name();
                             case UNIT_COLUMN:
                                 return variable->unit();
                             case MISSION_COLUMN:
                                 return variable->mission();
                             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)");
                     }
                 }
                 return QVariant{};
             }
             QVariant VariableModel::headerData(int section, Qt::Orientation orientation, int role) const
             {
                 if (role != Qt::DisplayRole) {
                     return QVariant{};
                 }
                 if (orientation == Qt::Horizontal) {
                     switch (section) {
                         case NAME_COLUMN:
                             return tr("Name");
                         case UNIT_COLUMN:
                             return tr("Unit");
                         case MISSION_COLUMN:
                             return tr("Mission");
                         default:
                             // No action
                             break;
                     }
                     qWarning(LOG_VariableModel())
                         << tr("Can't get header data (unknown column %1)").arg(section);
                 }
                 return QVariant{};
             }

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