HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r92:afb77b3143a6

Change signal/slot signature for data source

Alexandre Leroux -

r92:afb77b3143a6

parent child

Context file:

r92:afb77b3143a6

Collapse all files

app/src/MainWindow.cpp +2 -2

             /*------------------------------------------------------------------------------
             -- This file is a part of the SciQLop Software
             -- Copyright (C) 2017, Plasma Physics Laboratory - CNRS
             --
             -- This program is free software; you can redistribute it and/or modify
             -- it under the terms of the GNU General Public License as published by
             -- the Free Software Foundation; either version 2 of the License, or
             -- (at your option) any later version.
             --
             -- This program is distributed in the hope that it will be useful,
             -- but WITHOUT ANY WARRANTY; without even the implied warranty of
             -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
             -- GNU General Public License for more details.
             --
             -- You should have received a copy of the GNU General Public License
             -- along with this program; if not, write to the Free Software
             -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
             -------------------------------------------------------------------------------*/
             /*-- Author : Alexis Jeandet
             -- Mail : alexis.jeandet@member.fsf.org
             ----------------------------------------------------------------------------*/
             #include "MainWindow.h"
             #include "ui_MainWindow.h"
             #include <DataSource/DataSourceController.h>
             #include <DataSource/DataSourceWidget.h>
             #include <SqpApplication.h>
             #include <QAction>
             #include <QDate>
             #include <QDateTime>
             #include <QDir>
             #include <QFileDialog>
             //#include <omp.h>
             //#include <network/filedownloader.h>
             //#include <qlopdatabase.h>
             //#include <qlopsettings.h>
             //#include <qlopgui.h>
             //#include <spacedata.h>
             //#include "qlopcore.h"
             //#include "qlopcodecmanager.h"
             //#include "cdfcodec.h"
             //#include "amdatxtcodec.h"
             //#include <qlopplotmanager.h>
             #include <QAction>
             #include <QToolBar>
             #include <memory.h>
             MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent), m_Ui(new Ui::MainWindow)
             {
                 m_Ui->setupUi(this);
                 auto leftSidePane = m_Ui->leftInspectorSidePane->sidePane();
                 leftSidePane->addAction("ACTION L1");
                 leftSidePane->addAction("ACTION L2");
                 leftSidePane->addAction("ACTION L3");
                 auto rightSidePane = m_Ui->rightInspectorSidePane->sidePane();
                 rightSidePane->addAction("ACTION R1");
                 rightSidePane->addAction("ACTION R2");
                 rightSidePane->addAction("ACTION R3");
                 this->menuBar()->addAction("File");
                 auto mainToolBar = this->addToolBar("MainToolBar");
                 mainToolBar->addAction("A1");
                 // Widgets / controllers connections
-                connect(&sqpApp->dataSourceController(), SIGNAL(dataSourceItemSet(DataSourceItem &)),
+                connect(&sqpApp->dataSourceController(), SIGNAL(dataSourceItemSet(DataSourceItem *)),
-                        m_Ui->dataSourceWidget, SLOT(addDataSource(DataSourceItem &)));
+                        m_Ui->dataSourceWidget, SLOT(addDataSource(DataSourceItem *)));
                 /*    QLopGUI::registerMenuBar(menuBar());
                     this->setWindowIcon(QIcon(":/sciqlopLOGO.svg"));
                     this->m_progressWidget = new QWidget();
                     this->m_progressLayout = new QVBoxLayout(this->m_progressWidget);
                     this->m_progressWidget->setLayout(this->m_progressLayout);
                     this->m_progressWidget->setWindowModality(Qt::WindowModal);
                     m_progressThreadIds = (int*) malloc(OMP_THREADS*sizeof(int));
                     for(int i=0;i<OMP_THREADS;i++)
                     {
                         this->m_progress.append(new QProgressBar(this->m_progressWidget));
                         this->m_progress.last()->setMinimum(0);
                         this->m_progress.last()->setMaximum(100);
                         this->m_progressLayout->addWidget(this->m_progress.last());
                         this->m_progressWidget->hide();
                         this->m_progressThreadIds[i] = -1;
                     }
                     this->m_progressWidget->setWindowTitle("Loading File");
                     const QList<QLopService*>ServicesToLoad=QList<QLopService*>()
                             << QLopCore::self()
                             << QLopPlotManager::self()
                             << QLopCodecManager::self()
                             << FileDownloader::self()
                             << QLopDataBase::self()
                             << SpaceData::self();
                     CDFCodec::registerToManager();
                     AMDATXTCodec::registerToManager();
                     for(int i=0;i<ServicesToLoad.count();i++)
                     {
                         qDebug()<<ServicesToLoad.at(i)->serviceName();
                         ServicesToLoad.at(i)->initialize(); //must be called before getGUI
                         QDockWidget* wdgt=ServicesToLoad.at(i)->getGUI();
                         if(wdgt)
                         {
                             wdgt->setAllowedAreas(Qt::AllDockWidgetAreas);
                             this->addDockWidget(Qt::TopDockWidgetArea,wdgt);
                         }
                         PythonQt::self()->getMainModule().addObject(ServicesToLoad.at(i)->serviceName(),(QObject*)ServicesToLoad.at(i));
                     }*/
             }
             MainWindow::~MainWindow()
             {
             }
             void MainWindow::changeEvent(QEvent *e)
             {
                 QMainWindow::changeEvent(e);
                 switch (e->type()) {
                     case QEvent::LanguageChange:
                         m_Ui->retranslateUi(this);
                         break;
                     default:
                         break;
                 }
             }

core/include/DataSource/DataSourceController.h +1 -1

             #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;
             /**
              * @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;
             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);
+                void dataSourceItemSet(DataSourceItem *dataSourceItem);
             private:
                 void waitForFinish();
                 class DataSourceControllerPrivate;
                 spimpl::unique_impl_ptr<DataSourceControllerPrivate> impl;
             };
             #endif // SCIQLOP_DATASOURCECONTROLLER_H

core/src/DataSource/DataSourceController.cpp +1 -1

             #include <DataSource/DataSourceController.h>
             #include <DataSource/DataSourceItem.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;
             };
             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);
+                        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::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/tests/DataSource/TestDataSourceController.cpp +1 -1

             #include <DataSource/DataSourceController.h>
             #include <DataSource/DataSourceItem.h>
             #include <QObject>
             #include <QtTest>
             #include <memory>
             class TestDataSourceController : public QObject {
                 Q_OBJECT
             private slots:
                 void testRegisterDataSource();
                 void testSetDataSourceItem();
             };
             void TestDataSourceController::testRegisterDataSource()
             {
                 DataSourceController dataSourceController{};
                 auto uid = dataSourceController.registerDataSource(QStringLiteral("Source1"));
                 QVERIFY(!uid.isNull());
             }
             void TestDataSourceController::testSetDataSourceItem()
             {
                 DataSourceController dataSourceController{};
                 // Spy to test controllers' signals
-                QSignalSpy signalSpy{&dataSourceController, SIGNAL(dataSourceItemSet(const DataSourceItem &))};
+                QSignalSpy signalSpy{&dataSourceController, SIGNAL(dataSourceItemSet(DataSourceItem *))};
                 // Create a data source item
                 auto source1Name = QStringLiteral("Source1");
                 auto source1Values = QVector<QVariant>{source1Name};
                 auto source1Item
                     = std::make_unique<DataSourceItem>(DataSourceItemType::PRODUCT, std::move(source1Values));
                 // Add data source item to the controller and check that a signal has been emitted after setting
                 // data source item in the controller
                 auto source1Uid = dataSourceController.registerDataSource(source1Name);
                 dataSourceController.setDataSourceItem(source1Uid, std::move(source1Item));
                 QCOMPARE(signalSpy.count(), 1);
                 // Try to a data source item with an unregistered uid and check that no signal has been emitted
                 auto unregisteredUid = QUuid::createUuid();
                 dataSourceController.setDataSourceItem(
                     unregisteredUid, std::make_unique<DataSourceItem>(DataSourceItemType::PRODUCT));
                 QCOMPARE(signalSpy.count(), 1);
             }
             QTEST_MAIN(TestDataSourceController)
             #include "TestDataSourceController.moc"

gui/include/DataSource/DataSourceWidget.h +2 -2

             #ifndef SCIQLOP_DATASOURCEWIDGET_H
             #define SCIQLOP_DATASOURCEWIDGET_H
             #include <Common/spimpl.h>
             #include <QWidget>
             class DataSourceItem;
             /**
              * @brief The DataSourceWidget handles the graphical representation (as a tree) of the data sources
              * attached to SciQlop.
              */
             class DataSourceWidget : public QWidget {
                 Q_OBJECT
             public:
                 explicit DataSourceWidget(QWidget *parent = 0);
             public slots:
                 /**
                  * Adds a data source. An item associated to the data source is created and then added to the
                  * representation tree
-                 * @param dataSource the data source to add
+                 * @param dataSource the data source to add. The pointer has to be not null
                  */
-                void addDataSource(DataSourceItem &dataSource) noexcept;
+                void addDataSource(DataSourceItem *dataSource) noexcept;
             private:
                 class DataSourceWidgetPrivate;
                 spimpl::unique_impl_ptr<DataSourceWidgetPrivate> impl;
             };
             #endif // SCIQLOP_DATASOURCEWIDGET_H

gui/src/DataSource/DataSourceWidget.cpp +4 -2

             #include <DataSource/DataSourceWidget.h>
             #include <ui_DataSourceWidget.h>
             #include <DataSource/DataSourceItem.h>
             #include <DataSource/DataSourceTreeWidgetItem.h>
             namespace {
             /// Number of columns displayed in the tree
             const auto TREE_NB_COLUMNS = 1;
             /// Header labels for the tree
             const auto TREE_HEADER_LABELS = QStringList{QObject::tr("Name")};
             /**
              * Creates the item associated to a data source
              * @param dataSource the data source for which to create the item
              * @return the new item
              */
             DataSourceTreeWidgetItem *createTreeWidgetItem(DataSourceItem *dataSource)
             {
                 // Creates item for the data source
                 auto item = new DataSourceTreeWidgetItem{dataSource};
                 // Generates items for the children of the data source
                 for (auto i = 0; i < dataSource->childCount(); ++i) {
                     item->addChild(createTreeWidgetItem(dataSource->child(i)));
                 }
                 return item;
             }
             } // namespace
             class DataSourceWidget::DataSourceWidgetPrivate {
             public:
                 explicit DataSourceWidgetPrivate(DataSourceWidget &widget)
                         : m_Ui{std::make_unique<Ui::DataSourceWidget>()}
                 {
                     m_Ui->setupUi(&widget);
                     // Set tree properties
                     m_Ui->treeWidget->setColumnCount(TREE_NB_COLUMNS);
                     m_Ui->treeWidget->setHeaderLabels(TREE_HEADER_LABELS);
                 }
                 std::unique_ptr<Ui::DataSourceWidget> m_Ui;
             };
             DataSourceWidget::DataSourceWidget(QWidget *parent)
                     : QWidget{parent}, impl{spimpl::make_unique_impl<DataSourceWidgetPrivate>(*this)}
             {
             }
-            void DataSourceWidget::addDataSource(DataSourceItem &dataSource) noexcept
+            void DataSourceWidget::addDataSource(DataSourceItem *dataSource) noexcept
             {
                 // Creates the item associated to the source and adds it to the tree widget. The tree widget
                 // takes the ownership of the item
-                impl->m_Ui->treeWidget->addTopLevelItem(createTreeWidgetItem(&dataSource));
+                if (dataSource) {
+                    impl->m_Ui->treeWidget->addTopLevelItem(createTreeWidgetItem(dataSource));
+                }
             }

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