HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r233:508df86e5db1

Add merge API and implement it for the DataSeries

perrinel -

r233:508df86e5db1

parent child

Context file:

r233:508df86e5db1

core/include/Data/ArrayData.h +26 0

             #ifndef SCIQLOP_ARRAYDATA_H
             #define SCIQLOP_ARRAYDATA_H
             #include <QVector>
             /**
              * @brief The ArrayData class represents a dataset for a data series.
              *
              * A dataset can be unidimensional or two-dimensional. This property is determined by the Dim
              * template-parameter.
              *
              * @tparam Dim the dimension of the ArrayData (one or two)
              * @sa IDataSeries
              */
             template <int Dim>
             class ArrayData {
             public:
                 /**
                  * Ctor for a unidimensional ArrayData
                  * @param nbColumns the number of values the ArrayData will hold
                  */
                 template <int D = Dim, typename = std::enable_if_t<D == 1> >
                 explicit ArrayData(int nbColumns) : m_Data{1, QVector<double>{}}
                 {
                     m_Data[0].resize(nbColumns);
                 }
                 /**
                  * Sets a data at a specified index. The index has to be valid to be effective
                  * @param index the index to which the data will be set
                  * @param data the data to set
                  * @remarks this method is only available for a unidimensional ArrayData
                  */
                 template <int D = Dim, typename = std::enable_if_t<D == 1> >
                 void setData(int index, double data) noexcept
                 {
                     if (index >= 0 && index < m_Data.at(0).size()) {
                         m_Data[0].replace(index, data);
                     }
                 }
                 /**
                  * @return the data as a vector
                  * @remarks this method is only available for a unidimensional ArrayData
                  */
                 template <int D = Dim, typename = std::enable_if_t<D == 1> >
                 QVector<double> data() const noexcept
                 {
                     return m_Data.at(0);
                 }
+                /**
+                 * @return the data as a vector
+                 * @remarks this method is only available for a unidimensional ArrayData
+                 */
+                template <int D = Dim, typename = std::enable_if_t<D == 1> >
+                const QVector<double> &data(double tStart, double tEnd) const noexcept
+                {
+                    return m_Data.at(tStart);
+                }
+                // TODO Comment
+                template <int D = Dim, typename = std::enable_if_t<D == 1> >
+                void merge(ArrayData<1> *arrayData)
+                {
+                    if (!m_Data.empty()) {
+                        m_Data[0] += arrayData->data();
+                    }
+                }
+                template <int D = Dim, typename = std::enable_if_t<D == 1> >
+                int size()
+                {
+                    return m_Data[0].size();
+                }
             private:
                 QVector<QVector<double> > m_Data;
             };
             #endif // SCIQLOP_ARRAYDATA_H

core/include/Data/DataSeries.h +9 0

             #ifndef SCIQLOP_DATASERIES_H
             #define SCIQLOP_DATASERIES_H
             #include <Data/ArrayData.h>
             #include <Data/IDataSeries.h>
             #include <memory>
             /**
              * @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; }
                 /// @sa IDataSeries::xAxisUnit()
                 Unit xAxisUnit() const override { return m_XAxisUnit; }
                 /// @return the values dataset
                 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().get());
+                        m_ValuesData->merge(dimDataSeries->valuesData().get());
+                    }
+                }
             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}
                 {
                 }
             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 +11 -2

             #ifndef SCIQLOP_IDATAPROVIDER_H
             #define SCIQLOP_IDATAPROVIDER_H
             #include <memory>
             #include <QObject>
+            #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 {
+            class IDataProvider : public QObject {
+                Q_OBJECT
             public:
                 virtual ~IDataProvider() noexcept = default;
                 virtual std::unique_ptr<IDataSeries>
                 retrieveData(const DataProviderParameters &parameters) const = 0;
-            };
+                virtual void requestDataLoading(const QVector<SqpDateTime> &dateTimeList) = 0;
+            signals:
+                void dataProvided(std::shared_ptr<IDataSeries> dateSerie, SqpDateTime dateTime);
+            };
             // Required for using shared_ptr in signals/slots
             Q_DECLARE_METATYPE(std::shared_ptr<IDataProvider>)
             #endif // SCIQLOP_IDATAPROVIDER_H

core/include/Data/IDataSeries.h +8 -1

             #ifndef SCIQLOP_IDATASERIES_H
             #define SCIQLOP_IDATASERIES_H
-            #include <QString>
             #include <memory>
+            #include <QObject>
+            #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;
                 virtual Unit xAxisUnit() const = 0;
                 virtual Unit valuesUnit() const = 0;
+                virtual void merge(IDataSeries *dataSeries) = 0;
             };
+            // Required for using shared_ptr in signals/slots
+            Q_DECLARE_METATYPE(std::shared_ptr<IDataSeries>)
             #endif // SCIQLOP_IDATASERIES_H

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

		ok
		ok

	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