GIT_REPOSITORIES/LPP/Users/mperrinel/SCIQLOP-Initialisation Commit - r137:f61d116e8daa

Adds action in the mock plugin to load products

Alexandre Leroux -

r137:f61d116e8daa

parent child

Context file:

r137:f61d116e8daa

Collapse all files

core/include/DataSource/DataSourceController.h +6 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;
+                /**
+                 * Loads an item (product) as a variable in SciQlop
+                 * @param productItem the item to load
+                 */
+                void loadProductItem(const DataSourceItem &productItem) 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/include/DataSource/DataSourceItem.h +2 0

             #ifndef SCIQLOP_DATASOURCEITEM_H
             #define SCIQLOP_DATASOURCEITEM_H
             #include <Common/spimpl.h>
             #include <QVariant>
             #include <QVector>
             class DataSourceItemAction;
             /**
              * Possible types of an item
              */
             enum class DataSourceItemType { NODE, PRODUCT };
             /**
              * @brief The DataSourceItem class aims to represent a structure element of a data source.
              * A data source has a tree structure that is made up of a main DataSourceItem object (root)
              * containing other DataSourceItem objects (children).
              * For each DataSourceItem can be associated a set of data representing it.
              */
             class DataSourceItem {
             public:
                 explicit DataSourceItem(DataSourceItemType type, QVector<QVariant> data = {});
                 /// @return the actions of the item as a vector
                 QVector<DataSourceItemAction *> actions() const noexcept;
                 /**
                  * Adds an action to the item. The item takes ownership of the action, and the action is
                  * automatically associated to the item
                  * @param action the action to add
                  */
                 void addAction(std::unique_ptr<DataSourceItemAction> action) noexcept;
                 /**
                  * Adds a child to the item. The item takes ownership of the child.
                  * @param child the child to add
                  */
                 void appendChild(std::unique_ptr<DataSourceItem> child) noexcept;
                 /**
                  * Returns the item's child associated to an index
                  * @param childIndex the index to search
                  * @return a pointer to the child if index is valid, nullptr otherwise
                  */
                 DataSourceItem *child(int childIndex) const noexcept;
                 int childCount() const noexcept;
                 /**
                  * Get the data associated to an index
                  * @param dataIndex the index to search
                  * @return the data found if index is valid, default QVariant otherwise
                  */
                 QVariant data(int dataIndex) const noexcept;
+                QString name() const noexcept;
                 /**
                  * Get the item's parent
                  * @return a pointer to the parent if it exists, nullptr if the item is a root
                  */
                 DataSourceItem *parentItem() const noexcept;
                 DataSourceItemType type() const noexcept;
             private:
                 class DataSourceItemPrivate;
                 spimpl::unique_impl_ptr<DataSourceItemPrivate> impl;
             };
             #endif // SCIQLOP_DATASOURCEITEMMODEL_H

core/src/DataSource/DataSourceController.cpp +5 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::loadProductItem(const DataSourceItem &productItem) noexcept
+            {
+                /// @todo ALX
+            }
             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/src/DataSource/DataSourceItem.cpp +12 0

             #include <DataSource/DataSourceItem.h>
             #include <DataSource/DataSourceItemAction.h>
             #include <QVector>
+            namespace {
+            /// Index of the 'name' value in the item
+            const auto NAME_INDEX = 0;
+            } // namespace
             struct DataSourceItem::DataSourceItemPrivate {
                 explicit DataSourceItemPrivate(DataSourceItemType type, QVector<QVariant> data)
                         : m_Parent{nullptr}, m_Children{}, m_Type{type}, m_Data{std::move(data)}, m_Actions{}
                 {
                 }
                 DataSourceItem *m_Parent;
                 std::vector<std::unique_ptr<DataSourceItem> > m_Children;
                 DataSourceItemType m_Type;
                 QVector<QVariant> m_Data;
                 std::vector<std::unique_ptr<DataSourceItemAction> > m_Actions;
             };
             DataSourceItem::DataSourceItem(DataSourceItemType type, QVector<QVariant> data)
                     : impl{spimpl::make_unique_impl<DataSourceItemPrivate>(type, std::move(data))}
             {
             }
             QVector<DataSourceItemAction *> DataSourceItem::actions() const noexcept
             {
                 QVector<DataSourceItemAction *> result{};
                 std::transform(std::cbegin(impl->m_Actions), std::cend(impl->m_Actions),
                                std::back_inserter(result), [](const auto &action) { return action.get(); });
                 return result;
             }
             void DataSourceItem::addAction(std::unique_ptr<DataSourceItemAction> action) noexcept
             {
                 action->setDataSourceItem(this);
                 impl->m_Actions.push_back(std::move(action));
             }
             void DataSourceItem::appendChild(std::unique_ptr<DataSourceItem> child) noexcept
             {
                 child->impl->m_Parent = this;
                 impl->m_Children.push_back(std::move(child));
             }
             DataSourceItem *DataSourceItem::child(int childIndex) const noexcept
             {
                 if (childIndex < 0 || childIndex >= childCount()) {
                     return nullptr;
                 }
                 else {
                     return impl->m_Children.at(childIndex).get();
                 }
             }
             int DataSourceItem::childCount() const noexcept
             {
                 return impl->m_Children.size();
             }
             QVariant DataSourceItem::data(int dataIndex) const noexcept
             {
                 return impl->m_Data.value(dataIndex);
             }
+            QString DataSourceItem::name() const noexcept
+            {
+                return data(NAME_INDEX).toString();
+            }
             DataSourceItem *DataSourceItem::parentItem() const noexcept
             {
                 return impl->m_Parent;
             }
             DataSourceItemType DataSourceItem::type() const noexcept
             {
                 return impl->m_Type;
             }

plugins/mockplugin/src/MockPlugin.cpp +19 -7

             #include "MockPlugin.h"
             #include "CosinusProvider.h"
             #include <DataSource/DataSourceController.h>
             #include <DataSource/DataSourceItem.h>
+            #include <DataSource/DataSourceItemAction.h>
             #include <SqpApplication.h>
             Q_LOGGING_CATEGORY(LOG_MockPlugin, "MockPlugin")
             namespace {
             /// Name of the data source
             const auto DATA_SOURCE_NAME = QStringLiteral("MMS");
             /// Creates the data provider relative to the plugin
             std::unique_ptr<IDataProvider> createDataProvider() noexcept
             {
                 return std::make_unique<CosinusProvider>();
             }
+            std::unique_ptr<DataSourceItem> createProductItem(const QString &productName)
+            {
+                auto result = std::make_unique<DataSourceItem>(DataSourceItemType::PRODUCT,
+                                                               QVector<QVariant>{productName});
+                // Add action to load product from DataSourceController
+                result->addAction(std::make_unique<DataSourceItemAction>(
+                    QObject::tr("Load %1 product").arg(productName), [productName](DataSourceItem &item) {
+                        if (auto app = sqpApp) {
+                            app->dataSourceController().loadProductItem(item);
+                        }
+                    }));
+                return result;
+            }
             /// 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(createProductItem(QStringLiteral("FGM")));
-                magneticFieldFolder->appendChild(std::move(scProduct));
+                magneticFieldFolder->appendChild(createProductItem(QStringLiteral("SC")));
                 // 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 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