GIT_REPOSITORIES/LPP/Users/mperrinel/SCIQLOP-Initialisation Commit - r123:517990a8462b

Merge branch 'feature/DataProvider' into develop

Alexandre Leroux -

r123:517990a8462b

parent child

Context file:

r123:517990a8462b

Collapse all files

core/include/Data/ArrayData.h created 644 +56 0

@@ -0,0 +1,56
	1	#ifndef SCIQLOP_ARRAYDATA_H
	2	#define SCIQLOP_ARRAYDATA_H
	3
	4	#include <QVector>
	5
	6	/**
	7	* @brief The ArrayData class represents a dataset for a data series.
	8	*
	9	* A dataset can be unidimensional or two-dimensional. This property is determined by the Dim
	10	* template-parameter.
	11	*
	12	* @tparam Dim the dimension of the ArrayData (one or two)
	13	* @sa IDataSeries
	14	*/
	15	template <int Dim>
	16	class ArrayData {
	17	public:
	18	/**
	19	* Ctor for a unidimensional ArrayData
	20	* @param nbColumns the number of values the ArrayData will hold
	21	*/
	22	template <int D = Dim, typename = std::enable_if_t<D == 1> >
	23	explicit ArrayData(int nbColumns) : m_Data{1, QVector<double>{}}
	24	{
	25	m_Data[0].resize(nbColumns);
	26	}
	27
	28	/**
	29	* Sets a data at a specified index. The index has to be valid to be effective
	30	* @param index the index to which the data will be set
	31	* @param data the data to set
	32	* @remarks this method is only available for a unidimensional ArrayData
	33	*/
	34	template <int D = Dim, typename = std::enable_if_t<D == 1> >
	35	void setData(int index, double data) noexcept
	36	{
	37	if (index >= 0 && index < m_Data.at(0).size()) {
	38	m_Data[0].replace(index, data);
	39	}
	40	}
	41
	42	/**
	43	* @return the data as a vector
	44	* @remarks this method is only available for a unidimensional ArrayData
	45	*/
	46	template <int D = Dim, typename = std::enable_if_t<D == 1> >
	47	QVector<double> data() const noexcept
	48	{
	49	return m_Data.at(0);
	50	}
	51
	52	private:
	53	QVector<QVector<double> > m_Data;
	54	};
	55
	56	#endif // SCIQLOP_ARRAYDATA_H

core/include/Data/DataProviderParameters.h created 644 +16 0

@@ -0,0 +1,16
	1	#ifndef SCIQLOP_DATAPROVIDERPARAMETERS_H
	2	#define SCIQLOP_DATAPROVIDERPARAMETERS_H
	3
	4	/**
	5	* @brief The DataProviderParameters struct holds the information needed to retrieve data from a
	6	* data provider
	7	* @sa IDataProvider
	8	*/
	9	struct DataProviderParameters {
	10	/// Start time
	11	double m_TStart;
	12	/// End time
	13	double m_TEnd;
	14	};
	15
	16	#endif // SCIQLOP_DATAPROVIDERPARAMETERS_H

core/include/Data/DataSeries.h created 644 +50 0

@@ -0,0 +1,50
	1	#ifndef SCIQLOP_DATASERIES_H
	2	#define SCIQLOP_DATASERIES_H
	3
	4	#include <Data/ArrayData.h>
	5	#include <Data/IDataSeries.h>
	6
	7	#include <memory>
	8
	9	/**
	10	* @brief The DataSeries class is the base (abstract) implementation of IDataSeries.
	11	*
	12	* It proposes to set a dimension for the values data
	13	*
	14	* @tparam Dim The dimension of the values data
	15	*
	16	*/
	17	template <int Dim>
	18	class DataSeries : public IDataSeries {
	19	public:
	20	/// @sa IDataSeries::xAxisData()
	21	std::shared_ptr<ArrayData<1> > xAxisData() override { return m_XAxisData; }
	22
	23	/// @sa IDataSeries::xAxisUnit()
	24	QString xAxisUnit() const override { return m_XAxisUnit; }
	25
	26	/// @return the values dataset
	27	std::shared_ptr<ArrayData<Dim> > valuesData() const { return m_ValuesData; }
	28
	29	/// @sa IDataSeries::valuesUnit()
	30	QString valuesUnit() const override { return m_ValuesUnit; }
	31
	32	protected:
	33	/// Protected ctor (DataSeries is abstract)
	34	explicit DataSeries(std::shared_ptr<ArrayData<1> > xAxisData, const QString &xAxisUnit,
	35	std::shared_ptr<ArrayData<Dim> > valuesData, const QString &valuesUnit)
	36	: m_XAxisData{xAxisData},
	37	m_XAxisUnit{xAxisUnit},
	38	m_ValuesData{valuesData},
	39	m_ValuesUnit{valuesUnit}
	40	{
	41	}
	42
	43	private:
	44	std::shared_ptr<ArrayData<1> > m_XAxisData;
	45	QString m_XAxisUnit;
	46	std::shared_ptr<ArrayData<Dim> > m_ValuesData;
	47	QString m_ValuesUnit;
	48	};
	49
	50	#endif // SCIQLOP_DATASERIES_H

core/include/Data/IDataProvider.h created 644 +25 0

@@ -0,0 +1,25
	1	#ifndef SCIQLOP_IDATAPROVIDER_H
	2	#define SCIQLOP_IDATAPROVIDER_H
	3
	4	#include <memory>
	5
	6	class DataProviderParameters;
	7	class IDataSeries;
	8
	9	/**
	10	* @brief The IDataProvider interface aims to declare a data provider.
	11	*
	12	* A data provider is an entity that generates data and returns it according to various parameters
	13	* (time interval, product to retrieve the data, etc.)
	14	*
	15	* @sa IDataSeries
	16	*/
	17	class IDataProvider {
	18	public:
	19	virtual ~IDataProvider() noexcept = default;
	20
	21	virtual std::unique_ptr<IDataSeries>
	22	retrieveData(const DataProviderParameters &parameters) const = 0;
	23	};
	24
	25	#endif // SCIQLOP_IDATAPROVIDER_H

core/include/Data/IDataSeries.h created 644 +37 0

@@ -0,0 +1,37
	1	#ifndef SCIQLOP_IDATASERIES_H
	2	#define SCIQLOP_IDATASERIES_H
	3
	4	#include <QString>
	5
	6	#include <memory>
	7
	8	template <int Dim>
	9	class ArrayData;
	10
	11	/**
	12	* @brief The IDataSeries aims to declare a data series.
	13	*
	14	* A data series is an entity that contains at least :
	15	* - one dataset representing the x-axis
	16	* - one dataset representing the values
	17	*
	18	* Each dataset is represented by an ArrayData, and is associated with a unit.
	19	*
	20	* An ArrayData can be unidimensional or two-dimensional, depending on the implementation of the
	21	* IDataSeries. The x-axis dataset is always unidimensional.
	22	*
	23	* @sa ArrayData
	24	*/
	25	class IDataSeries {
	26	public:
	27	virtual ~IDataSeries() noexcept = default;
	28
	29	/// Returns the x-axis dataset
	30	virtual std::shared_ptr<ArrayData<1> > xAxisData() = 0;
	31
	32	virtual QString xAxisUnit() const = 0;
	33
	34	virtual QString valuesUnit() const = 0;
	35	};
	36
	37	#endif // SCIQLOP_IDATASERIES_H

core/include/Data/ScalarSeries.h created 644 +28 0

@@ -0,0 +1,28
	1	#ifndef SCIQLOP_SCALARSERIES_H
	2	#define SCIQLOP_SCALARSERIES_H
	3
	4	#include <Data/DataSeries.h>
	5
	6	/**
	7	* @brief The ScalarSeries class is the implementation for a data series representing a scalar.
	8	*/
	9	class ScalarSeries : public DataSeries<1> {
	10	public:
	11	/**
	12	* Ctor
	13	* @param size the number of data the series will hold
	14	* @param xAxisUnit x-axis unit
	15	* @param valuesUnit values unit
	16	*/
	17	explicit ScalarSeries(int size, const QString &xAxisUnit, const QString &valuesUnit);
	18
	19	/**
	20	* Sets data for a specific index. The index has to be valid to be effective
	21	* @param index the index to which the data will be set
	22	* @param x the x-axis data
	23	* @param value the value data
	24	*/
	25	void setData(int index, double x, double value) noexcept;
	26	};
	27
	28	#endif // SCIQLOP_SCALARSERIES_H

core/src/Data/ScalarSeries.cpp created 644 +13 0

@@ -0,0 +1,13
	1	#include <Data/ScalarSeries.h>
	2
	3	ScalarSeries::ScalarSeries(int size, const QString &xAxisUnit, const QString &valuesUnit)
	4	: DataSeries{std::make_shared<ArrayData<1> >(size), xAxisUnit,
	5	std::make_shared<ArrayData<1> >(size), valuesUnit}
	6	{
	7	}
	8
	9	void ScalarSeries::setData(int index, double x, double value) noexcept
	10	{
	11	xAxisData()->setData(index, x);
	12	valuesData()->setData(index, value);
	13	}

plugins/mockplugin/include/CosinusProvider.h created 644 +16 0

@@ -0,0 +1,16
	1	#ifndef SCIQLOP_COSINUSPROVIDER_H
	2	#define SCIQLOP_COSINUSPROVIDER_H
	3
	4	#include <Data/IDataProvider.h>
	5
	6	/**
	7	* @brief The CosinusProvider class is an example of how a data provider can generate data
	8	*/
	9	class CosinusProvider : public IDataProvider {
	10	public:
	11	/// @sa IDataProvider::retrieveData()
	12	std::unique_ptr<IDataSeries>
	13	retrieveData(const DataProviderParameters &parameters) const override;
	14	};
	15
	16	#endif // SCIQLOP_COSINUSPROVIDER_H

plugins/mockplugin/src/CosinusProvider.cpp created 644 +28 0

@@ -0,0 +1,28
	1	#include "CosinusProvider.h"
	2
	3	#include <Data/DataProviderParameters.h>
	4	#include <Data/ScalarSeries.h>
	5
	6	std::unique_ptr<IDataSeries>
	7	CosinusProvider::retrieveData(const DataProviderParameters &parameters) const
	8	{
	9	// Gets the timerange from the parameters
	10	auto start = parameters.m_TStart;
	11	auto end = parameters.m_TEnd;
	12
	13	// We assure that timerange is valid
	14	if (end < start) {
	15	std::swap(start, end);
	16	}
	17
	18	// Generates scalar series containing cosinus values (one value per second)
	19	auto scalarSeries
	20	= std::make_unique<ScalarSeries>(end - start, QStringLiteral("t"), QStringLiteral(""));
	21
	22	for (auto time = start; time < end; ++time) {
	23	auto dataIndex = time - start;
	24	scalarSeries->setData(dataIndex, time, std::cos(time));
	25	}
	26
	27	return scalarSeries;
	28	}

core/include/DataSource/DataSourceController.h +12 0

             #ifndef SCIQLOP_DATASOURCECONTROLLER_H
             #define SCIQLOP_DATASOURCECONTROLLER_H
             #include <QLoggingCategory>
             #include <QObject>
             #include <QUuid>
             #include <Common/spimpl.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_DataSourceController)
             class DataSourceItem;
+            class IDataProvider;
             /**
              * @brief The DataSourceController class aims to make the link between SciQlop and its plugins. This
              * is the intermediate class that SciQlop has to use in the way to connect a data source. Please
              * first use register method to initialize a plugin specified by its metadata name (JSON plugin
              * source) then others specifics method will be able to access it. You can load a data source driver
              * plugin then create a data source.
              */
             class DataSourceController : public QObject {
                 Q_OBJECT
             public:
                 explicit DataSourceController(QObject *parent = 0);
                 virtual ~DataSourceController();
                 /**
                  * Registers a data source. The method delivers a unique id that can be used afterwards to
                  * access to the data source properties (structure, connection parameters, data provider, etc.)
                  * @param dataSourceName the name of the data source
                  * @return the unique id with which the data source has been registered
                  */
                 QUuid registerDataSource(const QString &dataSourceName) noexcept;
                 /**
                  * Sets the structure of a data source. The controller takes ownership of the structure.
                  * @param dataSourceUid the unique id with which the data source has been registered into the
                  * controller. If it is invalid, the method has no effect.
                  * @param dataSourceItem the structure of the data source
                  * @sa registerDataSource()
                  */
                 void setDataSourceItem(const QUuid &dataSourceUid,
                                        std::unique_ptr<DataSourceItem> dataSourceItem) noexcept;
+                /**
+                 * Sets the data provider used to retrieve data from of a data source. The controller takes
+                 * ownership of the provider.
+                 * @param dataSourceUid the unique id with which the data source has been registered into the
+                 * controller. If it is invalid, the method has no effect.
+                 * @param dataProvider the provider of the data source
+                 * @sa registerDataSource()
+                 */
+                void setDataProvider(const QUuid &dataSourceUid,
+                                     std::unique_ptr<IDataProvider> dataProvider) noexcept;
             public slots:
                 /// Manage init/end of the controller
                 void initialize();
                 void finalize();
             signals:
                 /// Signal emitted when a structure has been set for a data source
                 void dataSourceItemSet(DataSourceItem *dataSourceItem);
             private:
                 void waitForFinish();
                 class DataSourceControllerPrivate;
                 spimpl::unique_impl_ptr<DataSourceControllerPrivate> impl;
             };
             #endif // SCIQLOP_DATASOURCECONTROLLER_H

core/src/DataSource/DataSourceController.cpp +17 0

             #include <DataSource/DataSourceController.h>
             #include <DataSource/DataSourceItem.h>
+            #include <Data/IDataProvider.h>
             #include <QMutex>
             #include <QThread>
             #include <QDir>
             #include <QStandardPaths>
             Q_LOGGING_CATEGORY(LOG_DataSourceController, "DataSourceController")
             class DataSourceController::DataSourceControllerPrivate {
             public:
                 QMutex m_WorkingMutex;
                 /// Data sources registered
                 QHash<QUuid, QString> m_DataSources;
                 /// Data sources structures
                 std::map<QUuid, std::unique_ptr<DataSourceItem> > m_DataSourceItems;
+                /// Data providers registered
+                std::map<QUuid, std::unique_ptr<IDataProvider> > m_DataProviders;
             };
             DataSourceController::DataSourceController(QObject *parent)
                     : impl{spimpl::make_unique_impl<DataSourceControllerPrivate>()}
             {
                 qCDebug(LOG_DataSourceController()) << tr("DataSourceController construction")
                                                     << QThread::currentThread();
             }
             DataSourceController::~DataSourceController()
             {
                 qCDebug(LOG_DataSourceController()) << tr("DataSourceController destruction")
                                                     << QThread::currentThread();
                 this->waitForFinish();
             }
             QUuid DataSourceController::registerDataSource(const QString &dataSourceName) noexcept
             {
                 auto dataSourceUid = QUuid::createUuid();
                 impl->m_DataSources.insert(dataSourceUid, dataSourceName);
                 return dataSourceUid;
             }
             void DataSourceController::setDataSourceItem(
                 const QUuid &dataSourceUid, std::unique_ptr<DataSourceItem> dataSourceItem) noexcept
             {
                 if (impl->m_DataSources.contains(dataSourceUid)) {
                     impl->m_DataSourceItems.insert(std::make_pair(dataSourceUid, std::move(dataSourceItem)));
                     // Retrieves the data source item to emit the signal with it
                     auto it = impl->m_DataSourceItems.find(dataSourceUid);
                     if (it != impl->m_DataSourceItems.end()) {
                         emit dataSourceItemSet(it->second.get());
                     }
                 }
                 else {
                     qCWarning(LOG_DataSourceController()) << tr("Can't set data source item for uid %1 : no "
                                                                 "data source has been registered with the uid")
                                                                  .arg(dataSourceUid.toString());
                 }
             }
+            void DataSourceController::setDataProvider(const QUuid &dataSourceUid,
+                                                       std::unique_ptr<IDataProvider> dataProvider) noexcept
+            {
+                if (impl->m_DataSources.contains(dataSourceUid)) {
+                    impl->m_DataProviders.insert(std::make_pair(dataSourceUid, std::move(dataProvider)));
+                }
+                else {
+                    qCWarning(LOG_DataSourceController()) << tr("Can't set data provider for uid %1 : no data "
+                                                                "source has been registered with the uid")
+                                                                 .arg(dataSourceUid.toString());
+                }
+            }
             void DataSourceController::initialize()
             {
                 qCDebug(LOG_DataSourceController()) << tr("DataSourceController init")
                                                     << QThread::currentThread();
                 impl->m_WorkingMutex.lock();
                 qCDebug(LOG_DataSourceController()) << tr("DataSourceController init END");
             }
             void DataSourceController::finalize()
             {
                 impl->m_WorkingMutex.unlock();
             }
             void DataSourceController::waitForFinish()
             {
                 QMutexLocker locker{&impl->m_WorkingMutex};
             }

core/vera-exclusions/exclusions.txt +4 0

             # On ignore toutes les règles vera++ pour le fichier spimpl
             Common/spimpl\.h:\d+:.*
             # Ignore false positive relative to two class definitions in a same file
             DataSourceItem\.h:\d+:.*IPSIS_S01.*
+            # Ignore false positive relative to a template class
+            ArrayData\.h:\d+:.*IPSIS_S04_VARIABLE.*found: (D)
+            ArrayData\.h:\d+:.*IPSIS_S06.*found: (D)
+            ArrayData\.h:\d+:.*IPSIS_S06.*found: (Dim)

plugins/mockplugin/include/MockPlugin.h 0 -4

             #ifndef SCIQLOP_MOCKPLUGIN_H
             #define SCIQLOP_MOCKPLUGIN_H
             #include <Plugin/IPlugin.h>
             #include <QLoggingCategory>
             #include <memory>
             Q_DECLARE_LOGGING_CATEGORY(LOG_MockPlugin)
             class DataSourceItem;
             class MockPlugin : public QObject, public IPlugin {
                 Q_OBJECT
                 Q_INTERFACES(IPlugin)
                 Q_PLUGIN_METADATA(IID "sciqlop.plugin.IPlugin" FILE "mockplugin.json")
             public:
                 /// @sa IPlugin::initialize()
                 void initialize() override;
-            private:
-                /// Creates the data source item relative to the plugin
-                std::unique_ptr<DataSourceItem> createDataSourceItem() const noexcept;
             };
             #endif // SCIQLOP_MOCKPLUGIN_H

plugins/mockplugin/src/MockPlugin.cpp +28 -16

-            #include <MockPlugin.h>
+            #include "MockPlugin.h"
+            #include "CosinusProvider.h"
             #include <DataSource/DataSourceController.h>
             #include <DataSource/DataSourceItem.h>
             #include <SqpApplication.h>
             Q_LOGGING_CATEGORY(LOG_MockPlugin, "MockPlugin")
             namespace {
             /// Name of the data source
             const auto DATA_SOURCE_NAME = QStringLiteral("MMS");
-            } // namespace
+            /// Creates the data provider relative to the plugin
+            std::unique_ptr<IDataProvider> createDataProvider() noexcept
-            void MockPlugin::initialize()
             {
-                if (auto app = sqpApp) {
+                return std::make_unique<CosinusProvider>();
-                    // Registers to the data source controller
-                    auto &dataSourceController = app->dataSourceController();
-                    auto dataSourceUid = dataSourceController.registerDataSource(DATA_SOURCE_NAME);
-                    dataSourceController.setDataSourceItem(dataSourceUid, createDataSourceItem());
-                else {
-                    qCWarning(LOG_MockPlugin()) << tr("Can't access to SciQlop application");
             }
-            std::unique_ptr<DataSourceItem> MockPlugin::createDataSourceItem() const noexcept
+            /// Creates the data source item relative to the plugin
+            std::unique_ptr<DataSourceItem> createDataSourceItem() noexcept
             {
                 // Magnetic field products
                 auto fgmProduct = std::make_unique<DataSourceItem>(DataSourceItemType::PRODUCT,
                                                                    QVector<QVariant>{QStringLiteral("FGM")});
                 auto scProduct = std::make_unique<DataSourceItem>(DataSourceItemType::PRODUCT,
                                                                   QVector<QVariant>{QStringLiteral("SC")});
                 auto magneticFieldFolder = std::make_unique<DataSourceItem>(
                     DataSourceItemType::NODE, QVector<QVariant>{QStringLiteral("Magnetic field")});
                 magneticFieldFolder->appendChild(std::move(fgmProduct));
                 magneticFieldFolder->appendChild(std::move(scProduct));
                 // Electric field products
                 auto electricFieldFolder = std::make_unique<DataSourceItem>(
                     DataSourceItemType::NODE, QVector<QVariant>{QStringLiteral("Electric field")});
                 // Root
                 auto root = std::make_unique<DataSourceItem>(DataSourceItemType::NODE,
                                                              QVector<QVariant>{DATA_SOURCE_NAME});
                 root->appendChild(std::move(magneticFieldFolder));
                 root->appendChild(std::move(electricFieldFolder));
-                return std::move(root);
+                return root;
+            }
+            } // namespace
+            void MockPlugin::initialize()
+            {
+                if (auto app = sqpApp) {
+                    // Registers to the data source controller
+                    auto &dataSourceController = app->dataSourceController();
+                    auto dataSourceUid = dataSourceController.registerDataSource(DATA_SOURCE_NAME);
+                    // Sets data source tree
+                    dataSourceController.setDataSourceItem(dataSourceUid, createDataSourceItem());
+                    // Sets data provider
+                    dataSourceController.setDataProvider(dataSourceUid, createDataProvider());
+                }
+                else {
+                    qCWarning(LOG_MockPlugin()) << tr("Can't access to SciQlop application");
+                }
             }

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