HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r310:9a5cb57f1573

Use std::shared_ptr in CosinusProvider

Alexandre Leroux -

r310:9a5cb57f1573

parent child

Context file:

r310:9a5cb57f1573

Collapse all files

core/include/Data/DataSeries.h +24 -1

             #ifndef SCIQLOP_DATASERIES_H
             #define SCIQLOP_DATASERIES_H
             #include <Data/ArrayData.h>
             #include <Data/IDataSeries.h>
             #include <QLoggingCategory>
             #include <memory>
             Q_DECLARE_LOGGING_CATEGORY(LOG_DataSeries)
             Q_LOGGING_CATEGORY(LOG_DataSeries, "DataSeries")
             /**
              * @brief The DataSeries class is the base (abstract) implementation of IDataSeries.
              *
              * It proposes to set a dimension for the values data
              *
              * @tparam Dim The dimension of the values data
              *
              */
             template <int Dim>
             class DataSeries : public IDataSeries {
             public:
                 /// @sa IDataSeries::xAxisData()
                 std::shared_ptr<ArrayData<1> > xAxisData() override { return m_XAxisData; }
+                const std::shared_ptr<ArrayData<1> > xAxisData() const { return m_XAxisData; }
                 /// @sa IDataSeries::xAxisUnit()
                 Unit xAxisUnit() const override { return m_XAxisUnit; }
                 /// @return the values dataset
-                std::shared_ptr<ArrayData<Dim> > valuesData() const { return m_ValuesData; }
+                std::shared_ptr<ArrayData<Dim> > valuesData() { return m_ValuesData; }
+                const std::shared_ptr<ArrayData<Dim> > valuesData() const { return m_ValuesData; }
                 /// @sa IDataSeries::valuesUnit()
                 Unit valuesUnit() const override { return m_ValuesUnit; }
                 /// @sa IDataSeries::merge()
                 void merge(IDataSeries *dataSeries) override
                 {
                     if (auto dimDataSeries = dynamic_cast<DataSeries<Dim> *>(dataSeries)) {
                         m_XAxisData->merge(*dimDataSeries->xAxisData());
                         m_ValuesData->merge(*dimDataSeries->valuesData());
                     }
                     else {
                         qCWarning(LOG_DataSeries())
                             << QObject::tr("Dection of a type of IDataSeries we cannot merge with !");
                     }
                 }
             protected:
                 /// Protected ctor (DataSeries is abstract)
                 explicit DataSeries(std::shared_ptr<ArrayData<1> > xAxisData, const Unit &xAxisUnit,
                                     std::shared_ptr<ArrayData<Dim> > valuesData, const Unit &valuesUnit)
                         : m_XAxisData{xAxisData},
                           m_XAxisUnit{xAxisUnit},
                           m_ValuesData{valuesData},
                           m_ValuesUnit{valuesUnit}
                 {
                 }
+                /// Copy ctor
+                explicit DataSeries(const DataSeries<Dim> &other)
+                        : m_XAxisData{std::make_shared<ArrayData<1> >(*other.m_XAxisData)},
+                          m_XAxisUnit{other.m_XAxisUnit},
+                          m_ValuesData{std::make_shared<ArrayData<Dim> >(*other.m_ValuesData)},
+                          m_ValuesUnit{other.m_ValuesUnit}
+                {
+                }
+                /// Assignment operator
+                template <int D>
+                DataSeries &operator=(DataSeries<D> other)
+                {
+                    std::swap(m_XAxisData, other.m_XAxisData);
+                    std::swap(m_XAxisUnit, other.m_XAxisUnit);
+                    std::swap(m_ValuesData, other.m_ValuesData);
+                    std::swap(m_ValuesUnit, other.m_ValuesUnit);
+                    return *this;
+                }
             private:
                 std::shared_ptr<ArrayData<1> > m_XAxisData;
                 Unit m_XAxisUnit;
                 std::shared_ptr<ArrayData<Dim> > m_ValuesData;
                 Unit m_ValuesUnit;
             };
             #endif // SCIQLOP_DATASERIES_H

core/include/Data/IDataProvider.h +1 -1

             #ifndef SCIQLOP_IDATAPROVIDER_H
             #define SCIQLOP_IDATAPROVIDER_H
             #include <memory>
             #include <QObject>
             #include <Common/MetaTypes.h>
             #include <Data/SqpDateTime.h>
             class DataProviderParameters;
             class IDataSeries;
             /**
              * @brief The IDataProvider interface aims to declare a data provider.
              *
              * A data provider is an entity that generates data and returns it according to various parameters
              * (time interval, product to retrieve the data, etc.)
              *
              * @sa IDataSeries
              */
             class IDataProvider : public QObject {
                 Q_OBJECT
             public:
                 virtual ~IDataProvider() noexcept = default;
-                virtual std::unique_ptr<IDataSeries>
+                virtual std::shared_ptr<IDataSeries>
                 retrieveData(const DataProviderParameters &parameters) const = 0;
                 virtual void requestDataLoading(const QVector<SqpDateTime> &dateTimeList) = 0;
             signals:
                 void dataProvided(std::shared_ptr<IDataSeries> dateSerie, const SqpDateTime &dateTime);
             };
             // Required for using shared_ptr in signals/slots
             SCIQLOP_REGISTER_META_TYPE(IDATAPROVIDER_PTR_REGISTRY, std::shared_ptr<IDataProvider>)
             #endif // SCIQLOP_IDATAPROVIDER_H

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

             #ifndef SCIQLOP_IDATASERIES_H
             #define SCIQLOP_IDATASERIES_H
             #include <Common/MetaTypes.h>
             #include <memory>
             #include <QString>
             template <int Dim>
             class ArrayData;
             struct Unit {
                 explicit Unit(const QString &name = {}, bool timeUnit = false)
                         : m_Name{name}, m_TimeUnit{timeUnit}
                 {
                 }
                 QString m_Name;  ///< Unit name
                 bool m_TimeUnit; ///< The unit is a unit of time
             };
             /**
              * @brief The IDataSeries aims to declare a data series.
              *
              * A data series is an entity that contains at least :
              * - one dataset representing the x-axis
              * - one dataset representing the values
              *
              * Each dataset is represented by an ArrayData, and is associated with a unit.
              *
              * An ArrayData can be unidimensional or two-dimensional, depending on the implementation of the
              * IDataSeries. The x-axis dataset is always unidimensional.
              *
              * @sa ArrayData
              */
             class IDataSeries {
             public:
                 virtual ~IDataSeries() noexcept = default;
                 /// Returns the x-axis dataset
                 virtual std::shared_ptr<ArrayData<1> > xAxisData() = 0;
+                /// Returns the x-axis dataset (as const)
+                virtual const std::shared_ptr<ArrayData<1> > xAxisData() const = 0;
                 virtual Unit xAxisUnit() const = 0;
                 virtual Unit valuesUnit() const = 0;
                 virtual void merge(IDataSeries *dataSeries) = 0;
+                virtual std::unique_ptr<IDataSeries> clone() const = 0;
             };
             // Required for using shared_ptr in signals/slots
             SCIQLOP_REGISTER_META_TYPE(IDATASERIES_PTR_REGISTRY, std::shared_ptr<IDataSeries>)
             #endif // SCIQLOP_IDATASERIES_H

core/include/Data/ScalarSeries.h +2 0

             #ifndef SCIQLOP_SCALARSERIES_H
             #define SCIQLOP_SCALARSERIES_H
             #include <Data/DataSeries.h>
             /**
              * @brief The ScalarSeries class is the implementation for a data series representing a scalar.
              */
             class ScalarSeries : public DataSeries<1> {
             public:
                 /**
                  * Ctor
                  * @param size the number of data the series will hold
                  * @param xAxisUnit x-axis unit
                  * @param valuesUnit values unit
                  */
                 explicit ScalarSeries(int size, const Unit &xAxisUnit, const Unit &valuesUnit);
                 /**
                  * Sets data for a specific index. The index has to be valid to be effective
                  * @param index the index to which the data will be set
                  * @param x the x-axis data
                  * @param value the value data
                  */
                 void setData(int index, double x, double value) noexcept;
+                std::unique_ptr<IDataSeries> clone() const;
             };
             #endif // SCIQLOP_SCALARSERIES_H

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

             #ifndef SCIQLOP_VARIABLE_H
             #define SCIQLOP_VARIABLE_H
             #include <Data/SqpDateTime.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 Variable : public QObject {
                 Q_OBJECT
             public:
                 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;
                 SqpDateTime dateTime() const noexcept;
                 void setDateTime(const SqpDateTime &dateTime) noexcept;
                 /// @return the data of the variable, nullptr if there is no data
                 IDataSeries *dataSeries() const noexcept;
                 bool contains(const SqpDateTime &dateTime);
                 bool intersect(const SqpDateTime &dateTime);
-                void setDataSeries(std::unique_ptr<IDataSeries> dataSeries) noexcept;
             public slots:
-                void onAddDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept;
+                void setDataSeries(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>)
             #endif // SCIQLOP_VARIABLE_H

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

             #ifndef SCIQLOP_VARIABLEMODEL_H
             #define SCIQLOP_VARIABLEMODEL_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, const SqpDateTime &dateTime,
-                               std::unique_ptr<IDataSeries> defaultDataSeries) noexcept;
+                               std::shared_ptr<IDataSeries> defaultDataSeries) noexcept;
                 std::shared_ptr<Variable> variable(int index) const;
                 // /////////////////////////// //
                 // 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/Data/ScalarSeries.cpp +5 0

             #include <Data/ScalarSeries.h>
             ScalarSeries::ScalarSeries(int size, const Unit &xAxisUnit, const Unit &valuesUnit)
                     : DataSeries{std::make_shared<ArrayData<1> >(size), xAxisUnit,
                                  std::make_shared<ArrayData<1> >(size), valuesUnit}
             {
             }
             void ScalarSeries::setData(int index, double x, double value) noexcept
             {
                 xAxisData()->setData(index, x);
                 valuesData()->setData(index, value);
             }
+            std::unique_ptr<IDataSeries> ScalarSeries::clone() const
+            {
+                return std::make_unique<ScalarSeries>(*this);
+            }

core/src/Variable/Variable.cpp +9 -7

             #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,
                                          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,
                                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;
             }
             SqpDateTime Variable::dateTime() const noexcept
             {
                 return impl->m_DateTime;
             }
             void Variable::setDateTime(const SqpDateTime &dateTime) noexcept
             {
                 impl->m_DateTime = dateTime;
             }
-            void Variable::setDataSeries(std::unique_ptr<IDataSeries> dataSeries) noexcept
+            void Variable::setDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept
             {
-                if (!impl->m_DataSeries) {
+                if (!dataSeries) {
-                    impl->m_DataSeries = std::move(dataSeries);
+                    /// @todo ALX : log
+                    return;
                 }
-            void Variable::onAddDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept
+                // Inits the data series of the variable
+                if (!impl->m_DataSeries) {
-                if (impl->m_DataSeries) {
+                    impl->m_DataSeries = dataSeries->clone();
+                }
+                else {
                     impl->m_DataSeries->merge(dataSeries.get());
                     emit updated();
                 }
             }
             IDataSeries *Variable::dataSeries() const noexcept
             {
                 return impl->m_DataSeries.get();
             }
             bool Variable::contains(const SqpDateTime &dateTime)
             {
                 return impl->m_DateTime.contains(dateTime);
             }
             bool Variable::intersect(const SqpDateTime &dateTime)
             {
                 return impl->m_DateTime.intersect(dateTime);
             }

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

             #include <Variable/Variable.h>
             #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 <QtCore/QItemSelectionModel>
             #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,
+            std::shared_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_VariableSelectionModel{new QItemSelectionModel{m_VariableModel, parent}},
                           m_VariableCacheController{std::make_unique<VariableCacheController>()}
                 {
                 }
                 QMutex m_WorkingMutex;
                 /// Variable model. The VariableController has the ownership
                 VariableModel *m_VariableModel;
                 QItemSelectionModel *m_VariableSelectionModel;
                 TimeController *m_TimeController{nullptr};
                 std::unique_ptr<VariableCacheController> m_VariableCacheController;
                 std::unordered_map<std::shared_ptr<Variable>, std::shared_ptr<IDataProvider> >
                     m_VariableToProviderMap;
             };
             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;
             }
             QItemSelectionModel *VariableController::variableSelectionModel() noexcept
             {
                 return impl->m_VariableSelectionModel;
             }
             void VariableController::setTimeController(TimeController *timeController) noexcept
             {
                 impl->m_TimeController = timeController;
             }
             void VariableController::createVariable(const QString &name,
                                                     std::shared_ptr<IDataProvider> provider) noexcept
             {
                 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, dateTime, generateDefaultDataSeries(*provider, dateTime))) {
                     // store the provider
                     impl->m_VariableToProviderMap[newVariable] = provider;
                     connect(provider.get(), &IDataProvider::dataProvided, newVariable.get(),
-                            &Variable::onAddDataSeries);
+                            &Variable::setDataSeries);
                     // store in cache
                     impl->m_VariableCacheController->addDateTime(newVariable, dateTime);
                     // notify the creation
                     emit variableCreated(newVariable);
                 }
             }
             void VariableController::onDateTimeOnSelection(const SqpDateTime &dateTime)
             {
                 auto selectedRows = impl->m_VariableSelectionModel->selectedRows();
                 for (const auto &selectedRow : qAsConst(selectedRows)) {
                     if (auto selectedVariable = impl->m_VariableModel->variable(selectedRow.row())) {
                         selectedVariable->setDateTime(dateTime);
                         this->onRequestDataLoading(selectedVariable, dateTime);
                     }
                 }
             }
             void VariableController::onRequestDataLoading(std::shared_ptr<Variable> variable,
                                                           const SqpDateTime &dateTime)
             {
                 // we want to load data of the variable for the dateTime.
                 // First we check if the cache contains some of them.
                 // For the other, we ask the provider to give them.
                 if (variable) {
                     auto dateTimeListNotInCache
                         = impl->m_VariableCacheController->provideNotInCacheDateTimeList(variable, dateTime);
                     if (!dateTimeListNotInCache.empty()) {
                         // Ask the provider for each data on the dateTimeListNotInCache
                         impl->m_VariableToProviderMap.at(variable)->requestDataLoading(
                             std::move(dateTimeListNotInCache));
                         // store in cache
                         impl->m_VariableCacheController->addDateTime(variable, dateTime);
                     }
                     else {
                         emit variable->updated();
                     }
                 }
                 else {
                     qCCritical(LOG_VariableController()) << tr("Impossible to load data of a variable null");
                 }
             }
             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 +1 -1

             #include <Variable/Variable.h>
             #include <Variable/VariableModel.h>
             #include <Data/IDataSeries.h>
             #include <QDateTime>
             #include <QSize>
             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 NB_COLUMNS = 3;
             // 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}}};
             /// 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;
             };
             VariableModel::VariableModel(QObject *parent)
                     : QAbstractTableModel{parent}, impl{spimpl::make_unique_impl<VariableModelPrivate>()}
             {
             }
             std::shared_ptr<Variable>
             VariableModel::createVariable(const QString &name, const SqpDateTime &dateTime,
-                                          std::unique_ptr<IDataSeries> defaultDataSeries) noexcept
+                                          std::shared_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 = std::make_shared<Variable>(name, QStringLiteral("unit"),
                                                            QStringLiteral("mission"), dateTime);
                 variable->setDataSeries(std::move(defaultDataSeries));
                 impl->m_Variables.push_back(variable);
                 endInsertRows();
                 return variable;
             }
             std::shared_ptr<Variable> VariableModel::variable(int index) const
             {
                 return (index >= 0 && index < impl->m_Variables.size()) ? impl->m_Variables[index] : nullptr;
             }
             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
                         auto dateTimeVariant = [](double time) {
                             auto dateTime = QDateTime::fromMSecsSinceEpoch(time * 1000.);
                             return dateTime.toString(DATETIME_FORMAT);
                         };
                         switch (index.column()) {
                             case NAME_COLUMN:
                                 return variable->name();
                             case TSTART_COLUMN:
                                 return dateTimeVariant(variable->dateTime().m_TStart);
                             case TEND_COLUMN:
                                 return dateTimeVariant(variable->dateTime().m_TEnd);
                             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 && 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{};
             }

plugins/mockplugin/include/CosinusProvider.h +1 -1

             #ifndef SCIQLOP_COSINUSPROVIDER_H
             #define SCIQLOP_COSINUSPROVIDER_H
             #include <Data/IDataProvider.h>
             #include <QLoggingCategory>
             Q_DECLARE_LOGGING_CATEGORY(LOG_CosinusProvider)
             /**
              * @brief The CosinusProvider class is an example of how a data provider can generate data
              */
             class CosinusProvider : public IDataProvider {
             public:
                 /// @sa IDataProvider::retrieveData()
-                std::unique_ptr<IDataSeries>
+                std::shared_ptr<IDataSeries>
                 retrieveData(const DataProviderParameters &parameters) const override;
                 void requestDataLoading(const QVector<SqpDateTime> &dateTimeList) override;
             private:
                 std::shared_ptr<IDataSeries> retrieveDataSeries(const SqpDateTime &dateTime);
             };
             #endif // SCIQLOP_COSINUSPROVIDER_H

plugins/mockplugin/src/CosinusProvider.cpp +10 -37

             #include "CosinusProvider.h"
             #include <Data/DataProviderParameters.h>
             #include <Data/ScalarSeries.h>
             #include <cmath>
             #include <QDateTime>
             Q_LOGGING_CATEGORY(LOG_CosinusProvider, "CosinusProvider")
-            std::unique_ptr<IDataSeries>
+            std::shared_ptr<IDataSeries>
             CosinusProvider::retrieveData(const DataProviderParameters &parameters) const
             {
                 auto dateTime = parameters.m_Time;
-                // Gets the timerange from the parameters
-                auto start = dateTime.m_TStart;
-                auto end = dateTime.m_TEnd;
-                // We assure that timerange is valid
-                if (end < start) {
-                    std::swap(start, end);
-                // Generates scalar series containing cosinus values (one value per second)
-                auto scalarSeries
-                    = std::make_unique<ScalarSeries>(end - start, Unit{QStringLiteral("t"), true}, Unit{});
-                auto dataIndex = 0;
-                for (auto time = start; time < end; ++time, ++dataIndex) {
-                    scalarSeries->setData(dataIndex, time, std::cos(time));
-                return scalarSeries;
-            void CosinusProvider::requestDataLoading(const QVector<SqpDateTime> &dateTimeList)
-                // NOTE: Try to use multithread if possible
-                for (const auto &dateTime : dateTimeList) {
-                    auto scalarSeries = this->retrieveDataSeries(dateTime);
-                    emit dataProvided(scalarSeries, dateTime);
-            std::shared_ptr<IDataSeries> CosinusProvider::retrieveDataSeries(const SqpDateTime &dateTime)
                 auto dataIndex = 0;
                 // Gets the timerange from the parameters
                 double freq = 100.0;
                 double start = dateTime.m_TStart * freq; // 100 htz
                 double end = dateTime.m_TEnd * freq;     // 100 htz
                 // We assure that timerange is valid
                 if (end < start) {
                     std::swap(start, end);
                 }
                 // Generates scalar series containing cosinus values (one value per second)
                 auto scalarSeries
                     = std::make_shared<ScalarSeries>(end - start, Unit{QStringLiteral("t"), true}, Unit{});
                 for (auto time = start; time < end; ++time, ++dataIndex) {
                     const auto timeOnFreq = time / freq;
                     scalarSeries->setData(dataIndex, timeOnFreq, std::cos(timeOnFreq));
                 }
                 return scalarSeries;
             }
+            void CosinusProvider::requestDataLoading(const QVector<SqpDateTime> &dateTimeList)
+            {
+                // NOTE: Try to use multithread if possible
+                for (const auto &dateTime : dateTimeList) {
+                    auto scalarSeries = this->retrieveData(DataProviderParameters{dateTime});
+                    emit dataProvided(scalarSeries, dateTime);
+                }
+            }

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