HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r1423:31110df2feb2

Ported MockPlugin to new Variable2 impl and added dummy python plugin...

jeandet -

r1423:31110df2feb2

parent child

Context file:

r1423:31110df2feb2

plugins/python_providers/CMakeLists.txt created 644 +26 0

@@ -0,0 +1,26
	1	include_directories(include)
	2	FILE (GLOB_RECURSE python_providers
	3	include/*.h
	4	src/*.cpp
	5	resources/*.qrc
	6	)
	7
	8	add_definitions(-DQT_PLUGIN)
	9	add_definitions(-DSCIQLOP_PLUGIN_JSON_FILE_PATH="${CMAKE_CURRENT_SOURCE_DIR}/resources/python_providers.json")
	10	if(NOT BUILD_SHARED_LIBS)
	11	add_definitions(-DQT_STATICPLUGIN)
	12	endif()
	13
	14	add_library(python_providers ${python_providers})
	15	SET_TARGET_PROPERTIES(python_providers PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS TRUE)
	16
	17	target_link_libraries(python_providers PUBLIC sciqlopgui)
	18	target_link_libraries(python_providers PRIVATE pybind11::embed)
	19	ADD_DEFINITIONS(-DQT_NO_KEYWORDS)
	20	install(TARGETS python_providers
	21	ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}/SciQlop
	22	LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}/SciQlop
	23	RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
	24
	25	include(sciqlop_tests)
	26

plugins/python_providers/include/python_providers.h created 644 +25 0

@@ -0,0 +1,25
	1	#ifndef PYTHON_PROVIDERS_H
	2	#define PYTHON_PROVIDERS_H
	3
	4	#include <Plugin/IPlugin.h>
	5
	6
	7	#include <memory>
	8
	9	#ifndef SCIQLOP_PLUGIN_JSON_FILE_PATH
	10	#define SCIQLOP_PLUGIN_JSON_FILE_PATH "python_providers.json"
	11	#endif
	12
	13	class DataSourceItem;
	14
	15	class PythonProviders : public QObject, public IPlugin
	16	{
	17	Q_OBJECT
	18	Q_INTERFACES(IPlugin)
	19	Q_PLUGIN_METADATA(IID "sciqlop.plugin.IPlugin" FILE SCIQLOP_PLUGIN_JSON_FILE_PATH)
	20	public:
	21	/// @sa IPlugin::initialize()
	22	void initialize() override;
	23	};
	24
	25	#endif // PYTHON_PROVIDERS_H

plugins/python_providers/resources/python_providers.json created 644 +3 0

@@ -0,0 +1,3
	1	{
	2	"name" : "python_providers"
	3	}

plugins/python_providers/src/python_providers.cpp created 644 +9 0

@@ -0,0 +1,9
	1	#include "python_providers.h"
	2	#include <pybind11/embed.h>
	3	namespace py = pybind11;
	4
	5	void PythonProviders::initialize()
	6	{
	7	py::scoped_interpreter guard {};
	8	py::print("Hello, World!");
	9	}

app/CMakeLists.txt +2 -1

             include_directories(include)
             FILE (GLOB_RECURSE app_SRCS
                     include/*.h
                     src/*.cpp
                     resources/*.qrc
                     )
             QT5_WRAP_UI(UiGenerated_SRCS
                 ui/MainWindow.ui
             )
             add_executable(sciqlopapp WIN32 ${app_SRCS} ${UiGenerated_SRCS})
             if(NOT BUILD_SHARED_LIBS)
                 add_definitions(-DQT_STATICPLUGIN)
                 if(BUILD_PLUGINS)
                     target_link_libraries(sciqlopapp mockplugin)
-                    target_link_libraries(sciqlopapp amdaplugin)
+                    #target_link_libraries(sciqlopapp amdaplugin)
+                    target_link_libraries(sciqlopapp python_providers)
                 endif()
             endif()
             if(NOT BUILD_PLUGINS)
                 add_definitions(-DSQP_NO_PLUGINS)
             endif()
             target_link_libraries(sciqlopapp
               Qt5::Core
               Qt5::Widgets
               Qt5::Network
               Qt5::PrintSupport
               Qt5::Svg
               sciqlopgui
               sciqlopcore
             )
             install(TARGETS sciqlopapp DESTINATION ${CMAKE_INSTALL_BINDIR})
             install(FILES resources/SciQLOP.desktop DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/applications/)
             install(FILES resources/SciQLOP.appdata.xml DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/metainfo/)
             install(FILES resources/sciqlopLOGO.svg DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/SciQLOP/icons/)

app/src/Main.cpp +3 -2

             /*------------------------------------------------------------------------------
             -- This file is a part of the QLop Software
             -- Copyright (C) 2015, 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 <QProcessEnvironment>
             #include <QThread>
             #include <SqpApplication.h>
             #include <qglobal.h>
             #include <PluginManager/PluginManager.h>
             #include <QDir>
             #include <QtPlugin>
             #include <QLoggingCategory>
             Q_LOGGING_CATEGORY(LOG_Main, "Main")
             namespace
             {
             const auto PLUGIN_DIRECTORY_NAME = QStringLiteral("plugins");
             } // namespace
             int main(int argc, char* argv[])
             {
             #ifdef QT_STATICPLUGIN
             #ifndef SQP_NO_PLUGINS
                 Q_IMPORT_PLUGIN(MockPlugin)
-                Q_IMPORT_PLUGIN(AmdaPlugin)
+                Q_IMPORT_PLUGIN(PythonProviders)
-                Q_INIT_RESOURCE(amdaresources);
+                // Q_IMPORT_PLUGIN(AmdaPlugin)
+                // Q_INIT_RESOURCE(amdaresources);
             #endif
             #endif
                 Q_INIT_RESOURCE(sqpguiresources);
                 SqpApplication::setOrganizationName("LPP");
                 SqpApplication::setOrganizationDomain("lpp.fr");
                 SqpApplication::setApplicationName("SciQLop");
                 QGuiApplication::setAttribute(Qt::AA_EnableHighDpiScaling);
                 SqpApplication a { argc, argv };
                 MainWindow w;
                 w.show();
                 // Loads plugins
                 auto pluginDir = QDir { a.applicationDirPath() };
                 auto pluginLookupPath = {
             #if _WIN32 || _WIN64
                     a.applicationDirPath() + "/SciQLop"
             #else
                     a.applicationDirPath() + "/../lib64/SciQLop",
                     a.applicationDirPath() + "/../lib64/sciqlop",
                     a.applicationDirPath() + "/../lib/SciQLop",
                     a.applicationDirPath() + "/../lib/sciqlop",
             #endif
                 };
             #if _WIN32 || _WIN64
                 pluginDir.mkdir(PLUGIN_DIRECTORY_NAME);
                 pluginDir.cd(PLUGIN_DIRECTORY_NAME);
             #endif
                 PluginManager pluginManager {};
                 for (auto&& path : pluginLookupPath)
                 {
                     QDir directory { path };
                     if (directory.exists())
                     {
                         qCDebug(LOG_Main())
                             << QObject::tr("Plugin directory: %1").arg(directory.absolutePath());
                         pluginManager.loadPlugins(directory);
                     }
                 }
                 pluginManager.loadStaticPlugins();
                 return a.exec();
             }

app/src/MainWindow.cpp +4 -4

             /*------------------------------------------------------------------------------
             -- 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 <Catalogue/CatalogueController.h>
             //#include <Catalogue/CatalogueExplorer.h>
             #include <DataSource/DataSourceController.h>
             #include <DataSource/DataSourceWidget.h>
             #include <Settings/SqpSettingsDialog.h>
             #include <Settings/SqpSettingsGeneralWidget.h>
             #include <SidePane/SqpSidePane.h>
             #include <SqpApplication.h>
             #include <Time/TimeController.h>
             #include <TimeWidget/TimeWidget.h>
             #include <Visualization/VisualizationController.h>
             #include <QAction>
             #include <QCloseEvent>
             #include <QDate>
             #include <QDir>
             #include <QFileDialog>
             #include <QMessageBox>
             #include <QToolBar>
             #include <QToolButton>
             #include <memory.h>
             #include "iostream"
             Q_LOGGING_CATEGORY(LOG_MainWindow, "MainWindow")
             namespace
             {
             const auto LEFTMAININSPECTORWIDGETSPLITTERINDEX = 0;
             const auto LEFTINSPECTORSIDEPANESPLITTERINDEX = 1;
             const auto VIEWPLITTERINDEX = 2;
             const auto RIGHTINSPECTORSIDEPANESPLITTERINDEX = 3;
             const auto RIGHTMAININSPECTORWIDGETSPLITTERINDEX = 4;
             }
             class MainWindow::MainWindowPrivate
             {
             public:
                 explicit MainWindowPrivate(MainWindow* mainWindow)
                         : m_LastOpenLeftInspectorSize {}
                         , m_LastOpenRightInspectorSize {}
                         , m_GeneralSettingsWidget { new SqpSettingsGeneralWidget { mainWindow } }
                         , m_SettingsDialog { new SqpSettingsDialog { mainWindow } }
                 //, m_CatalogExplorer { new CatalogueExplorer { mainWindow } }
                 {
                 }
                 QSize m_LastOpenLeftInspectorSize;
                 QSize m_LastOpenRightInspectorSize;
                 /// General settings widget. MainWindow has the ownership
                 SqpSettingsGeneralWidget* m_GeneralSettingsWidget;
                 /// Settings dialog. MainWindow has the ownership
                 SqpSettingsDialog* m_SettingsDialog;
                 /// Catalogue dialog. MainWindow has the ownership
                 // CatalogueExplorer* m_CatalogExplorer;
                 bool checkDataToSave(QWidget* parentWidget);
             };
             MainWindow::MainWindow(QWidget* parent)
                     : QMainWindow { parent }
                     , m_Ui { new Ui::MainWindow }
                     , impl { spimpl::make_unique_impl<MainWindowPrivate>(this) }
             {
                 m_Ui->setupUi(this);
                 m_Ui->splitter->setCollapsible(LEFTINSPECTORSIDEPANESPLITTERINDEX, false);
                 m_Ui->splitter->setCollapsible(RIGHTINSPECTORSIDEPANESPLITTERINDEX, false);
                 // impl->m_CatalogExplorer->setVisualizationWidget(m_Ui->view);
                 auto spacerLeftTop = new QWidget {};
                 spacerLeftTop->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                 auto spacerLeftBottom = new QWidget {};
                 spacerLeftBottom->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                 auto spacerRightTop = new QWidget {};
                 spacerRightTop->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                 auto spacerRightBottom = new QWidget {};
                 spacerRightBottom->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                 auto openInspector = [this](bool checked, bool right, auto action) {
                     action->setIcon(
                         QIcon { (checked ^ right) ? ":/icones/next.png" : ":/icones/previous.png" });
                     auto& lastInspectorSize
                         = right ? impl->m_LastOpenRightInspectorSize : impl->m_LastOpenLeftInspectorSize;
                     auto nextInspectorSize = right ? m_Ui->rightMainInspectorWidget->size()
                                                    : m_Ui->leftMainInspectorWidget->size();
                     // Update of the last opened geometry
                     if (checked)
                     {
                         lastInspectorSize = nextInspectorSize;
                     }
                     auto startSize = lastInspectorSize;
                     auto endSize = startSize;
                     endSize.setWidth(0);
                     auto splitterInspectorIndex
                         = right ? RIGHTMAININSPECTORWIDGETSPLITTERINDEX : LEFTMAININSPECTORWIDGETSPLITTERINDEX;
                     auto currentSizes = m_Ui->splitter->sizes();
                     if (checked)
                     {
                         // adjust sizes individually here, e.g.
                         currentSizes[splitterInspectorIndex] -= lastInspectorSize.width();
                         currentSizes[VIEWPLITTERINDEX] += lastInspectorSize.width();
                         m_Ui->splitter->setSizes(currentSizes);
                     }
                     else
                     {
                         // adjust sizes individually here, e.g.
                         currentSizes[splitterInspectorIndex] += lastInspectorSize.width();
                         currentSizes[VIEWPLITTERINDEX] -= lastInspectorSize.width();
                         m_Ui->splitter->setSizes(currentSizes);
                     }
                 };
                 // //////////////// //
                 // Menu and Toolbar //
                 // //////////////// //
                 this->menuBar()->addAction(tr("File"));
                 auto toolsMenu = this->menuBar()->addMenu(tr("Tools"));
                 toolsMenu->addAction(tr("Settings..."), [this]() {
                     // Loads settings
                     impl->m_SettingsDialog->loadSettings();
                     // Open settings dialog and save settings if the dialog is accepted
                     if (impl->m_SettingsDialog->exec() == QDialog::Accepted)
                     {
                         impl->m_SettingsDialog->saveSettings();
                     }
                 });
                 auto mainToolBar = this->addToolBar(QStringLiteral("MainToolBar"));
                 auto timeWidget = new TimeWidget {};
                 mainToolBar->addWidget(timeWidget);
                 // Interaction modes
                 auto actionPointerMode = new QAction { QIcon(":/icones/pointer.png"), "Move", this };
                 actionPointerMode->setCheckable(true);
                 actionPointerMode->setChecked(
                     sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::None);
                 connect(actionPointerMode, &QAction::triggered,
                     []() { sqpApp->setPlotsInteractionMode(SqpApplication::PlotsInteractionMode::None); });
                 auto actionZoomMode = new QAction { QIcon(":/icones/zoom.png"), "Zoom", this };
                 actionZoomMode->setCheckable(true);
                 actionZoomMode->setChecked(
                     sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::ZoomBox);
                 connect(actionZoomMode, &QAction::triggered,
                     []() { sqpApp->setPlotsInteractionMode(SqpApplication::PlotsInteractionMode::ZoomBox); });
                 auto actionOrganisationMode = new QAction { QIcon(":/icones/drag.png"), "Organize", this };
                 actionOrganisationMode->setCheckable(true);
                 actionOrganisationMode->setChecked(
                     sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::DragAndDrop);
                 connect(actionOrganisationMode, &QAction::triggered, []() {
                     sqpApp->setPlotsInteractionMode(SqpApplication::PlotsInteractionMode::DragAndDrop);
                 });
                 auto actionZonesMode = new QAction { QIcon(":/icones/rectangle.png"), "Zones", this };
                 actionZonesMode->setCheckable(true);
                 actionZonesMode->setChecked(
                     sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::SelectionZones);
                 connect(actionZonesMode, &QAction::triggered, []() {
                     sqpApp->setPlotsInteractionMode(SqpApplication::PlotsInteractionMode::SelectionZones);
                 });
                 auto modeActionGroup = new QActionGroup { this };
                 modeActionGroup->addAction(actionZoomMode);
                 modeActionGroup->addAction(actionZonesMode);
                 modeActionGroup->addAction(actionOrganisationMode);
                 modeActionGroup->addAction(actionPointerMode);
                 modeActionGroup->setExclusive(true);
                 mainToolBar->addSeparator();
                 mainToolBar->addAction(actionPointerMode);
                 mainToolBar->addAction(actionZoomMode);
                 mainToolBar->addAction(actionOrganisationMode);
                 mainToolBar->addAction(actionZonesMode);
                 mainToolBar->addSeparator();
                 // Cursors
                 auto btnCursor = new QToolButton { this };
                 btnCursor->setIcon(QIcon(":/icones/cursor.png"));
                 btnCursor->setText("Cursor");
                 btnCursor->setToolTip("Cursor");
                 btnCursor->setPopupMode(QToolButton::InstantPopup);
                 auto cursorMenu = new QMenu("CursorMenu", this);
                 btnCursor->setMenu(cursorMenu);
                 auto noCursorAction = cursorMenu->addAction("No Cursor");
                 noCursorAction->setCheckable(true);
                 noCursorAction->setChecked(
                     sqpApp->plotsCursorMode() == SqpApplication::PlotsCursorMode::NoCursor);
                 connect(noCursorAction, &QAction::triggered,
                     []() { sqpApp->setPlotsCursorMode(SqpApplication::PlotsCursorMode::NoCursor); });
                 cursorMenu->addSeparator();
                 auto verticalCursorAction = cursorMenu->addAction("Vertical Cursor");
                 verticalCursorAction->setCheckable(true);
                 verticalCursorAction->setChecked(
                     sqpApp->plotsCursorMode() == SqpApplication::PlotsCursorMode::Vertical);
                 connect(verticalCursorAction, &QAction::triggered,
                     []() { sqpApp->setPlotsCursorMode(SqpApplication::PlotsCursorMode::Vertical); });
                 auto temporalCursorAction = cursorMenu->addAction("Temporal Cursor");
                 temporalCursorAction->setCheckable(true);
                 temporalCursorAction->setChecked(
                     sqpApp->plotsCursorMode() == SqpApplication::PlotsCursorMode::Temporal);
                 connect(temporalCursorAction, &QAction::triggered,
                     []() { sqpApp->setPlotsCursorMode(SqpApplication::PlotsCursorMode::Temporal); });
                 auto horizontalCursorAction = cursorMenu->addAction("Horizontal Cursor");
                 horizontalCursorAction->setCheckable(true);
                 horizontalCursorAction->setChecked(
                     sqpApp->plotsCursorMode() == SqpApplication::PlotsCursorMode::Horizontal);
                 connect(horizontalCursorAction, &QAction::triggered,
                     []() { sqpApp->setPlotsCursorMode(SqpApplication::PlotsCursorMode::Horizontal); });
                 auto crossCursorAction = cursorMenu->addAction("Cross Cursor");
                 crossCursorAction->setCheckable(true);
                 crossCursorAction->setChecked(
                     sqpApp->plotsCursorMode() == SqpApplication::PlotsCursorMode::Cross);
                 connect(crossCursorAction, &QAction::triggered,
                     []() { sqpApp->setPlotsCursorMode(SqpApplication::PlotsCursorMode::Cross); });
                 mainToolBar->addWidget(btnCursor);
                 auto cursorModeActionGroup = new QActionGroup { this };
                 cursorModeActionGroup->setExclusive(true);
                 cursorModeActionGroup->addAction(noCursorAction);
                 cursorModeActionGroup->addAction(verticalCursorAction);
                 cursorModeActionGroup->addAction(temporalCursorAction);
                 cursorModeActionGroup->addAction(horizontalCursorAction);
                 cursorModeActionGroup->addAction(crossCursorAction);
                 // Catalog
                 mainToolBar->addSeparator();
                 //    mainToolBar->addAction(QIcon(":/icones/catalogue.png"), "Catalogues",
                 //        [this]() { impl->m_CatalogExplorer->show(); });
                 // //////// //
                 // Settings //
                 // //////// //
                 // Registers "general settings" widget to the settings dialog
                 impl->m_SettingsDialog->registerWidget(
                     QStringLiteral("General"), impl->m_GeneralSettingsWidget);
                 // /////////// //
                 // Connections //
                 // /////////// //
                 // Controllers / controllers connections
                 //    connect(&sqpApp->timeController(), SIGNAL(timeUpdated(DateTimeRange)),
                 //    &sqpApp->variableController(),
                 //            SLOT(onDateTimeOnSelection(DateTimeRange)));
                 // Widgets / controllers connections
                 // DataSource
                 connect(&sqpApp->dataSourceController(), SIGNAL(dataSourceItemSet(DataSourceItem*)),
                     m_Ui->dataSourceWidget, SLOT(addDataSource(DataSourceItem*)));
                 // Time
                 connect(timeWidget, SIGNAL(timeUpdated(DateTimeRange)), &sqpApp->timeController(),
                     SLOT(onTimeToUpdate(DateTimeRange)));
                 // Visualization
                 connect(&sqpApp->visualizationController(),
-                    SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)), m_Ui->view,
+                    SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable2>)), m_Ui->view,
-                    SLOT(onVariableAboutToBeDeleted(std::shared_ptr<Variable>)));
+                    SLOT(onVariableAboutToBeDeleted(std::shared_ptr<Variable2>)));
                 connect(&sqpApp->visualizationController(),
-                    SIGNAL(rangeChanged(std::shared_ptr<Variable>, const DateTimeRange&)), m_Ui->view,
+                    SIGNAL(rangeChanged(std::shared_ptr<Variable2>, const DateTimeRange&)), m_Ui->view,
-                    SLOT(onRangeChanged(std::shared_ptr<Variable>, const DateTimeRange&)));
+                    SLOT(onRangeChanged(std::shared_ptr<Variable2>, const DateTimeRange&)));
                 // Widgets / widgets connections
                 // For the following connections, we use DirectConnection to allow each widget that can
                 // potentially attach a menu to the variable's menu to do so before this menu is displayed.
                 // The order of connections is also important, since it determines the order in which each
                 // widget will attach its menu
                 connect(m_Ui->variableInspectorWidget,
                     SIGNAL(tableMenuAboutToBeDisplayed(QMenu*, const QVector<std::shared_ptr<Variable>>&)),
                     m_Ui->view, SLOT(attachVariableMenu(QMenu*, const QVector<std::shared_ptr<Variable>>&)),
                     Qt::DirectConnection);
             }
             MainWindow::~MainWindow() {}
             void MainWindow::changeEvent(QEvent* e)
             {
                 QMainWindow::changeEvent(e);
                 switch (e->type())
                 {
                     case QEvent::LanguageChange:
                         m_Ui->retranslateUi(this);
                         break;
                     default:
                         break;
                 }
             }
             void MainWindow::closeEvent(QCloseEvent* event)
             {
                 if (!impl->checkDataToSave(this))
                 {
                     event->ignore();
                 }
                 else
                 {
                     event->accept();
                 }
             }
             void MainWindow::keyPressEvent(QKeyEvent* event)
             {
                 switch (event->key())
                 {
                     case Qt::Key_F11:
                         if (this->isFullScreen())
                         {
                             this->showNormal();
                         }
                         else
                         {
                             this->showFullScreen();
                         }
                         break;
                     default:
                         break;
                 }
             }
             bool MainWindow::MainWindowPrivate::checkDataToSave(QWidget* parentWidget)
             {
                 //    auto hasChanges = sqpApp->catalogueController().hasChanges();
                 //    if (hasChanges)
                 //    {
                 //        // There are some unsaved changes
                 //        switch (QMessageBox::question(parentWidget, tr("Save changes"),
                 //            tr("The catalogue controller has unsaved changes.\nDo you want to save them ?"),
                 //            QMessageBox::SaveAll | QMessageBox::Discard | QMessageBox::Cancel,
                 //            QMessageBox::SaveAll))
                 //        {
                 //            case QMessageBox::SaveAll:
                 //                sqpApp->catalogueController().saveAll();
                 //                break;
                 //            case QMessageBox::Discard:
                 //                break;
                 //            case QMessageBox::Cancel:
                 //            default:
                 //                return false;
                 //        }
                 //    }
                 return true;
             }

core +1 -1

	@@ -1,1 +1,1
	1	Subproject commit cc26524fb5d10feca3820e6921c9cd3cfb1a3591		1	Subproject commit 00ce7df31d3e11df8a418988c601247f6dc64d13

gui/include/Visualization/VisualizationTabWidget.h +1 -1

             #ifndef SCIQLOP_VISUALIZATIONTABWIDGET_H
             #define SCIQLOP_VISUALIZATIONTABWIDGET_H
             #include "Visualization/IVisualizationWidget.h"
             #include <Common/spimpl.h>
             #include <QLoggingCategory>
             #include <QMimeData>
             #include <QWidget>
             Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationTabWidget)
-            class Variable;
+            class Variable2;
             class VisualizationZoneWidget;
             namespace Ui
             {
             class VisualizationTabWidget;
             } // namespace Ui
             class VisualizationTabWidget : public QWidget, public IVisualizationWidget
             {
                 Q_OBJECT
             public:
                 explicit VisualizationTabWidget(const QString& name = {}, QWidget* parent = 0);
                 virtual ~VisualizationTabWidget();
                 /// Adds a zone widget
                 void addZone(VisualizationZoneWidget* zoneWidget);
                 /// Inserts a zone widget at the specified position
                 void insertZone(int index, VisualizationZoneWidget* zoneWidget);
                 /// Returns the list of zone widget names in the order they are displayed
                 QStringList availableZoneWidgets() const;
                 /// Returns the zone with the specified name.
                 /// If multiple zone with the same name exist, the first one is returned.
                 VisualizationZoneWidget* getZoneWithName(const QString& zoneName);
                 /**
                  * Creates a zone using a variable. The variable will be displayed in a new graph of the new
                  * zone. The zone is added at the end.
                  * @param variable the variable for which to create the zone
                  * @return the pointer to the created zone
                  */
                 VisualizationZoneWidget* createZone(std::shared_ptr<Variable2> variable);
                 /**
                  * Creates a zone using a list of variables. The variables will be displayed in a new graph of
                  * the new zone. The zone is inserted at the specified index.
                  * @param variables the variables for which to create the zone
                  * @param index The index where the zone should be inserted in the layout
                  * @return the pointer to the created zone
                  */
                 VisualizationZoneWidget* createZone(
                     const std::vector<std::shared_ptr<Variable2>>& variables, int index);
                 /**
                  * Creates a zone which is empty (no variables). The zone is inserted at the specified index.
                  * @param index The index where the zone should be inserted in the layout
                  * @return the pointer to the created zone
                  */
                 VisualizationZoneWidget* createEmptyZone(int index);
                 // IVisualizationWidget interface
                 void accept(IVisualizationWidgetVisitor* visitor) override;
                 bool canDrop(Variable2& variable) const override;
                 bool contains(Variable2& variable) const override;
                 QString name() const override;
             protected:
                 void closeEvent(QCloseEvent* event) override;
             private:
                 /// @return the layout of tab in which zones are added
                 QLayout& tabLayout() const noexcept;
                 Ui::VisualizationTabWidget* ui;
                 class VisualizationTabWidgetPrivate;
                 spimpl::unique_impl_ptr<VisualizationTabWidgetPrivate> impl;
             private slots:
                 void dropMimeData(int index, const QMimeData* mimeData);
             };
             #endif // SCIQLOP_VISUALIZATIONTABWIDGET_H

gui/src/Visualization/VisualizationGraphHelper.cpp +5 -2

             #include "Visualization/VisualizationGraphHelper.h"
             #include "Visualization/qcustomplot.h"
             #include <Data/ScalarTimeSerie.h>
             #include <Data/SpectrogramTimeSerie.h>
             #include <Data/VectorTimeSerie.h>
             #include <Variable/Variable2.h>
             Q_LOGGING_CATEGORY(LOG_VisualizationGraphHelper, "VisualizationGraphHelper")
             namespace
             {
             class SqpDataContainer : public QCPGraphDataContainer
             {
             public:
                 void appendGraphData(const QCPGraphData& data) { mData.append(data); }
             };
             /**
              * Struct used to create plottables, depending on the type of the data series from which to create
              * them
              * @tparam T the data series' type
              * @remarks Default implementation can't create plottables
              */
             template <typename T, typename Enabled = void>
             struct PlottablesCreator
             {
                 static PlottablesMap createPlottables(QCustomPlot&) { return {}; }
             };
             PlottablesMap createGraphs(QCustomPlot& plot, int nbGraphs)
             {
                 PlottablesMap result {};
                 // Creates {nbGraphs} QCPGraph to add to the plot
                 for (auto i = 0; i < nbGraphs; ++i)
                 {
                     auto graph = plot.addGraph();
                     result.insert({ i, graph });
                 }
                 plot.replot();
                 return result;
             }
             /**
              * Specialization of PlottablesCreator for scalars
              * @sa ScalarSeries
              */
             template <typename T>
             struct PlottablesCreator<T, typename std::enable_if_t<std::is_base_of<ScalarTimeSerie, T>::value>>
             {
                 static PlottablesMap createPlottables(QCustomPlot& plot) { return createGraphs(plot, 1); }
             };
             /**
              * Specialization of PlottablesCreator for vectors
              * @sa VectorSeries
              */
             template <typename T>
             struct PlottablesCreator<T, typename std::enable_if_t<std::is_base_of<VectorTimeSerie, T>::value>>
             {
                 static PlottablesMap createPlottables(QCustomPlot& plot) { return createGraphs(plot, 3); }
             };
             /**
              * Specialization of PlottablesCreator for spectrograms
              * @sa SpectrogramSeries
              */
             template <typename T>
             struct PlottablesCreator<T,
                 typename std::enable_if_t<std::is_base_of<SpectrogramTimeSerie, T>::value>>
             {
                 static PlottablesMap createPlottables(QCustomPlot& plot)
                 {
                     PlottablesMap result {};
                     result.insert({ 0, new QCPColorMap { plot.xAxis, plot.yAxis } });
                     plot.replot();
                     return result;
                 }
             };
             /**
              * Struct used to update plottables, depending on the type of the data series from which to update
              * them
              * @tparam T the data series' type
              * @remarks Default implementation can't update plottables
              */
             template <typename T, typename Enabled = void>
             struct PlottablesUpdater
             {
                 static void setPlotYAxisRange(T&, const DateTimeRange&, QCustomPlot&)
                 {
                     qCCritical(LOG_VisualizationGraphHelper())
                         << QObject::tr("Can't set plot y-axis range: unmanaged data series type");
                 }
                 static void updatePlottables(T&, PlottablesMap&, const DateTimeRange&, bool)
                 {
                     qCCritical(LOG_VisualizationGraphHelper())
                         << QObject::tr("Can't update plottables: unmanaged data series type");
                 }
             };
             /**
              * Specialization of PlottablesUpdater for scalars and vectors
              * @sa ScalarSeries
              * @sa VectorSeries
              */
             template <typename T>
             struct PlottablesUpdater<T, typename std::enable_if_t<std::is_base_of<ScalarTimeSerie, T>::value>>
             {
                 static void setPlotYAxisRange(T& dataSeries, const DateTimeRange& xAxisRange, QCustomPlot& plot)
                 {
                     auto minValue = 0., maxValue = 0.;
                     if (auto serie = dynamic_cast<ScalarTimeSerie*>(&dataSeries))
                     {
-                        maxValue = (*std::max_element(std::begin(*serie), std::end(*serie))).v();
+                        if (serie->size())
-                        minValue = (*std::min_element(std::begin(*serie), std::end(*serie))).v();
+                            maxValue = (*std::max_element(std::begin(*serie), std::end(*serie))).v();
+                            minValue = (*std::min_element(std::begin(*serie), std::end(*serie))).v();
+                        }
                     }
                     plot.yAxis->setRange(QCPRange { minValue, maxValue });
                 }
                 static void updatePlottables(
                     T& dataSeries, PlottablesMap& plottables, const DateTimeRange& range, bool rescaleAxes)
                 {
                     // For each plottable to update, resets its data
                     for (const auto& plottable : plottables)
                     {
                         if (auto graph = dynamic_cast<QCPGraph*>(plottable.second))
                         {
                             auto dataContainer = QSharedPointer<SqpDataContainer>::create();
                             if (auto serie = dynamic_cast<ScalarTimeSerie*>(&dataSeries))
                             {
                                 std::for_each(
                                     std::begin(*serie), std::end(*serie), [&dataContainer](const auto& value) {
                                         dataContainer->appendGraphData(QCPGraphData(value.t(), value.v()));
                                     });
                             }
                             graph->setData(dataContainer);
                         }
                     }
                     if (!plottables.empty())
                     {
                         auto plot = plottables.begin()->second->parentPlot();
                         if (rescaleAxes)
                         {
                             plot->rescaleAxes();
                         }
                     }
                 }
             };
             template <typename T>
             struct PlottablesUpdater<T, typename std::enable_if_t<std::is_base_of<VectorTimeSerie, T>::value>>
             {
                 static void setPlotYAxisRange(T& dataSeries, const DateTimeRange& xAxisRange, QCustomPlot& plot)
                 {
                     double minValue = 0., maxValue = 0.;
                     if (auto serie = dynamic_cast<VectorTimeSerie*>(&dataSeries))
                     {
                         std::for_each(
                             std::begin(*serie), std::end(*serie), [&minValue, &maxValue](const auto& v) {
                                 minValue = std::min({ minValue, v.v().x, v.v().y, v.v().z });
                                 maxValue = std::max({ maxValue, v.v().x, v.v().y, v.v().z });
                             });
                     }
                     plot.yAxis->setRange(QCPRange { minValue, maxValue });
                 }
                 static void updatePlottables(
                     T& dataSeries, PlottablesMap& plottables, const DateTimeRange& range, bool rescaleAxes)
                 {
                     // For each plottable to update, resets its data
                     for (const auto& plottable : plottables)
                     {
                         if (auto graph = dynamic_cast<QCPGraph*>(plottable.second))
                         {
                             auto dataContainer = QSharedPointer<SqpDataContainer>::create();
                             if (auto serie = dynamic_cast<VectorTimeSerie*>(&dataSeries))
                             {
                                 switch (plottable.first)
                                 {
                                     case 0:
                                         std::for_each(std::begin(*serie), std::end(*serie),
                                             [&dataContainer](const auto& value) {
                                                 dataContainer->appendGraphData(
                                                     QCPGraphData(value.t(), value.v().x));
                                             });
                                         break;
                                     case 1:
                                         std::for_each(std::begin(*serie), std::end(*serie),
                                             [&dataContainer](const auto& value) {
                                                 dataContainer->appendGraphData(
                                                     QCPGraphData(value.t(), value.v().y));
                                             });
                                         break;
                                     case 2:
                                         std::for_each(std::begin(*serie), std::end(*serie),
                                             [&dataContainer](const auto& value) {
                                                 dataContainer->appendGraphData(
                                                     QCPGraphData(value.t(), value.v().z));
                                             });
                                         break;
                                     default:
                                         break;
                                 }
                             }
                             graph->setData(dataContainer);
                         }
                     }
                     if (!plottables.empty())
                     {
                         auto plot = plottables.begin()->second->parentPlot();
                         if (rescaleAxes)
                         {
                             plot->rescaleAxes();
                         }
                     }
                 }
             };
             /**
              * Specialization of PlottablesUpdater for spectrograms
              * @sa SpectrogramSeries
              */
             template <typename T>
             struct PlottablesUpdater<T,
                 typename std::enable_if_t<std::is_base_of<SpectrogramTimeSerie, T>::value>>
             {
                 static void setPlotYAxisRange(T& dataSeries, const DateTimeRange& xAxisRange, QCustomPlot& plot)
                 {
                     // TODO
                     //        double min, max;
                     //        std::tie(min, max) = dataSeries.yBounds();
                     //        if (!std::isnan(min) && !std::isnan(max))
                     //        {
                     //            plot.yAxis->setRange(QCPRange { min, max });
                     //        }
                 }
                 static void updatePlottables(
                     T& dataSeries, PlottablesMap& plottables, const DateTimeRange& range, bool rescaleAxes)
                 {
                     // TODO
                     //        if (plottables.empty())
                     //        {
                     //            qCDebug(LOG_VisualizationGraphHelper())
                     //                << QObject::tr("Can't update spectrogram: no colormap has been
                     //                associated");
                     //            return;
                     //        }
                     //        // Gets the colormap to update (normally there is only one colormap)
                     //        Q_ASSERT(plottables.size() == 1);
                     //        auto colormap = dynamic_cast<QCPColorMap*>(plottables.at(0));
                     //        Q_ASSERT(colormap != nullptr);
                     //        dataSeries.lockRead();
                     //        // Processing spectrogram data for display in QCustomPlot
                     //        auto its = dataSeries.xAxisRange(range.m_TStart, range.m_TEnd);
                     //        // Computes logarithmic y-axis resolution for the spectrogram
                     //        auto yData = its.first->y();
                     //        auto yResolution = DataSeriesUtils::resolution(yData.begin(), yData.end(), true);
                     //        // Generates mesh for colormap
                     //        auto mesh = DataSeriesUtils::regularMesh(its.first, its.second,
                     //            DataSeriesUtils::Resolution { dataSeries.xResolution() }, yResolution);
                     //        dataSeries.unlock();
                     //        colormap->data()->setSize(mesh.m_NbX, mesh.m_NbY);
                     //        if (!mesh.isEmpty())
                     //        {
                     //            colormap->data()->setRange(QCPRange { mesh.m_XMin, mesh.xMax() },
                     //                // y-axis range is converted to linear values
                     //                QCPRange { std::pow(10, mesh.m_YMin), std::pow(10, mesh.yMax()) });
                     //            // Sets values
                     //            auto index = 0;
                     //            for (auto it = mesh.m_Data.begin(), end = mesh.m_Data.end(); it != end; ++it,
                     //            ++index)
                     //            {
                     //                auto xIndex = index % mesh.m_NbX;
                     //                auto yIndex = index / mesh.m_NbX;
                     //                colormap->data()->setCell(xIndex, yIndex, *it);
                     //                // Makes the NaN values to be transparent in the colormap
                     //                if (std::isnan(*it))
                     //                {
                     //                    colormap->data()->setAlpha(xIndex, yIndex, 0);
                     //                }
                     //            }
                     //        }
                     //        // Rescales axes
                     //        auto plot = colormap->parentPlot();
                     //        if (rescaleAxes)
                     //        {
                     //            plot->rescaleAxes();
                     //        }
                 }
             };
             /**
              * Helper used to create/update plottables
              */
             struct IPlottablesHelper
             {
                 virtual ~IPlottablesHelper() noexcept = default;
                 virtual PlottablesMap create(QCustomPlot& plot) const = 0;
                 virtual void setYAxisRange(const DateTimeRange& xAxisRange, QCustomPlot& plot) const = 0;
                 virtual void update(
                     PlottablesMap& plottables, const DateTimeRange& range, bool rescaleAxes = false) const = 0;
             };
             /**
              * Default implementation of IPlottablesHelper, which takes data series to create/update plottables
              * @tparam T the data series' type
              */
             template <typename T>
             struct PlottablesHelper : public IPlottablesHelper
             {
                 explicit PlottablesHelper(std::shared_ptr<T> dataSeries) : m_DataSeries { dataSeries } {}
                 PlottablesMap create(QCustomPlot& plot) const override
                 {
                     return PlottablesCreator<T>::createPlottables(plot);
                 }
                 void update(
                     PlottablesMap& plottables, const DateTimeRange& range, bool rescaleAxes) const override
                 {
                     if (m_DataSeries)
                     {
                         PlottablesUpdater<T>::updatePlottables(*m_DataSeries, plottables, range, rescaleAxes);
                     }
                     else
                     {
                         qCCritical(LOG_VisualizationGraphHelper()) << "Can't update plottables: inconsistency "
                                                                       "between the type of data series and the "
                                                                       "type supposed";
                     }
                 }
                 void setYAxisRange(const DateTimeRange& xAxisRange, QCustomPlot& plot) const override
                 {
                     if (m_DataSeries)
                     {
                         PlottablesUpdater<T>::setPlotYAxisRange(*m_DataSeries, xAxisRange, plot);
                     }
                     else
                     {
                         qCCritical(LOG_VisualizationGraphHelper()) << "Can't update plottables: inconsistency "
                                                                       "between the type of data series and the "
                                                                       "type supposed";
                     }
                 }
                 std::shared_ptr<T> m_DataSeries;
             };
             /// Creates IPlottablesHelper according to the type of data series a variable holds
             std::unique_ptr<IPlottablesHelper> createHelper(std::shared_ptr<Variable2> variable) noexcept
             {
                 switch (variable->type())
                 {
                     case DataSeriesType::SCALAR:
                         return std::make_unique<PlottablesHelper<ScalarTimeSerie>>(
                             std::dynamic_pointer_cast<ScalarTimeSerie>(variable->data()));
                     case DataSeriesType::SPECTROGRAM:
                         return std::make_unique<PlottablesHelper<SpectrogramTimeSerie>>(
                             std::dynamic_pointer_cast<SpectrogramTimeSerie>(variable->data()));
                     case DataSeriesType::VECTOR:
                         return std::make_unique<PlottablesHelper<VectorTimeSerie>>(
                             std::dynamic_pointer_cast<VectorTimeSerie>(variable->data()));
                     default:
                         // Creates default helper
                         break;
                 }
                 return std::make_unique<PlottablesHelper<TimeSeries::ITimeSerie>>(nullptr);
             }
             } // namespace
             PlottablesMap VisualizationGraphHelper::create(
                 std::shared_ptr<Variable2> variable, QCustomPlot& plot) noexcept
             {
                 if (variable)
                 {
                     auto helper = createHelper(variable);
                     auto plottables = helper->create(plot);
                     return plottables;
                 }
                 else
                 {
                     qCDebug(LOG_VisualizationGraphHelper())
                         << QObject::tr("Can't create graph plottables : the variable is null");
                     return PlottablesMap {};
                 }
             }
             void VisualizationGraphHelper::setYAxisRange(
                 std::shared_ptr<Variable2> variable, QCustomPlot& plot) noexcept
             {
                 if (variable)
                 {
                     auto helper = createHelper(variable);
                     helper->setYAxisRange(variable->range(), plot);
                 }
                 else
                 {
                     qCDebug(LOG_VisualizationGraphHelper())
                         << QObject::tr("Can't set y-axis range of plot: the variable is null");
                 }
             }
             void VisualizationGraphHelper::updateData(
                 PlottablesMap& plottables, std::shared_ptr<Variable2> variable, const DateTimeRange& dateTime)
             {
                 auto helper = createHelper(variable);
                 helper->update(plottables, dateTime);
             }

plugins/CMakeLists.txt +3 -2

@@ -1,3 +1,4
1	add_subdirectory(mockplugin)	1	add_subdirectory(mockplugin)
2	add_subdirectory(~~amda~~)	2	add_subdirectory(python_providers)
3	add_subdirectory(~~generic_ws~~)	3	#add_subdirectory(amda)
		4	#add_subdirectory(generic_ws)

plugins/amda/include/AmdaProvider.h +3 -3

             #ifndef SCIQLOP_AMDAPROVIDER_H
             #define SCIQLOP_AMDAPROVIDER_H
             #include "AmdaGlobal.h"
             #include <Data/IDataProvider.h>
             #include <QLoggingCategory>
             #include <map>
             Q_DECLARE_LOGGING_CATEGORY(LOG_AmdaProvider)
             class QNetworkReply;
             class QNetworkRequest;
             /**
              * @brief The AmdaProvider class is an example of how a data provider can generate data
              */
-            class SCIQLOP_AMDA_EXPORT AmdaProvider : public IDataProvider {
+            class SCIQLOP_AMDA_EXPORT AmdaProvider : public IDataProvider
+            {
                 Q_OBJECT
             public:
                 explicit AmdaProvider();
                 std::shared_ptr<IDataProvider> clone() const override;
-                virtual IDataSeries *getData(const DataProviderParameters &parameters)override;
+                virtual TimeSeries::ITimeSerie* getData(const DataProviderParameters& parameters) override;
             };
             #endif // SCIQLOP_AMDAPROVIDER_H

plugins/amda/src/AmdaProvider.cpp +12 -15

             #include "AmdaProvider.h"
             #include "AmdaDefs.h"
             #include "AmdaResultParser.h"
             #include "AmdaServer.h"
             #include <Common/DateUtils.h>
             #include <Data/DataProviderParameters.h>
             #include <Network/NetworkController.h>
             #include <SqpApplication.h>
-            #include <Variable/Variable.h>
+            #include <Network/Downloader.h>
+            #include <QJsonDocument>
             #include <QNetworkAccessManager>
             #include <QNetworkReply>
             #include <QTemporaryFile>
             #include <QThread>
-            #include <QJsonDocument>
-            #include <Network/Downloader.h>
             Q_LOGGING_CATEGORY(LOG_AmdaProvider, "AmdaProvider")
-            namespace {
+            namespace
+            {
             /// URL format for a request on AMDA server. The parameters are as follows:
             /// - %1: server URL
             /// - %2: start date
             /// - %3: end date
             /// - %4: parameter id
             /// AMDA V2: http://amdatest.irap.omp.eu/php/rest/
             const auto AMDA_URL_FORMAT = QStringLiteral(
                 "http://%1/php/rest/"
                 "getParameter.php?startTime=%2&stopTime=%3&parameterID=%4&outputFormat=ASCII&"
                 "timeFormat=ISO8601&gzip=0");
             const auto AMDA_URL_FORMAT_WITH_TOKEN = QStringLiteral(
                 "http://%1/php/rest/"
                 "getParameter.php?startTime=%2&stopTime=%3&parameterID=%4&outputFormat=ASCII&"
                 "timeFormat=ISO8601&gzip=0&"
                 "token=%5");
             const auto AMDA_TOKEN_URL_FORMAT = QStringLiteral(
                 "http://%1/php/rest/"
                 "auth.php");
             /// Dates format passed in the URL (e.g 2013-09-23T09:00)
             const auto AMDA_TIME_FORMAT = QStringLiteral("yyyy-MM-ddThh:mm:ss");
             /// Formats a time to a date that can be passed in URL
             QString dateFormat(double sqpRange) noexcept
             {
                 auto dateTime = DateUtils::dateTime(sqpRange);
                 return dateTime.toString(AMDA_TIME_FORMAT);
             }
             } // namespace
-            AmdaProvider::AmdaProvider()
+            AmdaProvider::AmdaProvider() {}
             std::shared_ptr<IDataProvider> AmdaProvider::clone() const
             {
                 // No copy is made in the clone
                 return std::make_shared<AmdaProvider>();
             }
-            IDataSeries* AmdaProvider::getData(const DataProviderParameters &parameters)
+            TimeSeries::ITimeSerie* AmdaProvider::getData(const DataProviderParameters& parameters)
             {
                 auto range = parameters.m_Range;
                 auto metaData = parameters.m_Data;
                 auto productId = metaData.value(AMDA_XML_ID_KEY).toString();
                 auto productValueType
                     = DataSeriesTypeUtils::fromString(metaData.value(AMDA_DATA_TYPE_KEY).toString());
                 auto startDate = dateFormat(range.m_TStart);
                 auto endDate = dateFormat(range.m_TEnd);
-                QVariantHash urlProperties{{AMDA_SERVER_KEY, metaData.value(AMDA_SERVER_KEY)}};
+                QVariantHash urlProperties { { AMDA_SERVER_KEY, metaData.value(AMDA_SERVER_KEY) } };
-                auto token_url = QString{AMDA_TOKEN_URL_FORMAT}.arg(AmdaServer::instance().url(urlProperties));
+                auto token_url
+                    = QString { AMDA_TOKEN_URL_FORMAT }.arg(AmdaServer::instance().url(urlProperties));
                 auto response = Downloader::get(token_url);
-                auto url = QString{AMDA_URL_FORMAT_WITH_TOKEN}.arg(AmdaServer::instance().url(urlProperties),
+                auto url = QString { AMDA_URL_FORMAT_WITH_TOKEN }.arg(AmdaServer::instance().url(urlProperties),
-                                                             startDate, endDate, productId, QString(response.data()));
+                    startDate, endDate, productId, QString(response.data()));
                 response = Downloader::get(url);
                 auto test = QJsonDocument::fromJson(response.data());
                 url = test["dataFileURLs"].toString();
                 response = Downloader::get(url);
-                return AmdaResultParser::readTxt(QTextStream{response.data()},productValueType);
+                return nullptr; // AmdaResultParser::readTxt(QTextStream { response.data() }, productValueType);
             }

plugins/amda/src/AmdaResultParser.cpp 0 -1

             #include "AmdaResultParser.h"
             #include "AmdaResultParserHelper.h"
             #include <QFile>
-            #include <Data/IDataSeries.h>
             #include <cmath>
             Q_LOGGING_CATEGORY(LOG_AmdaResultParser, "AmdaResultParser")
             namespace
             {
             /// Message in result file when the file was not found on server
             const auto FILE_NOT_FOUND_MESSAGE = QStringLiteral("Not Found");
             /// Checks if a line is a comment line
             bool isCommentLine(const QString& line)
             {
                 return line.startsWith("#");
             }
             /**
              * Creates helper that will be used to read AMDA file, according to the type passed as parameter
              * @param valueType the type of values expected in the AMDA file (scalars, vectors, spectrograms...)
              * @return the helper created
              */
             std::unique_ptr<IAmdaResultParserHelper> createHelper(DataSeriesType valueType)
             {
                 switch (valueType)
                 {
                     case DataSeriesType::SCALAR:
                         return std::make_unique<ScalarParserHelper>();
                     case DataSeriesType::SPECTROGRAM:
                         return std::make_unique<SpectrogramParserHelper>();
                     case DataSeriesType::VECTOR:
                         return std::make_unique<VectorParserHelper>();
                     case DataSeriesType::NONE:
                         // Invalid case
                         break;
                 }
                 // Invalid cases
                 qCCritical(LOG_AmdaResultParser())
                     << QObject::tr("Can't create helper to read result file: unsupported type");
                 return nullptr;
             }
             /**
              * Reads properties of the stream passed as parameter
              * @param helper the helper used to read properties line by line
              * @param stream the stream to read
              */
             void readProperties(IAmdaResultParserHelper& helper, QTextStream& stream)
             {
                 // Searches properties in the comment lines (as long as the reading has not reached the data)
                 // AMDA V2: while (stream.readLineInto(&line) && !line.contains(DATA_HEADER_REGEX)) {
                 QString line {};
                 while (stream.readLineInto(&line) && isCommentLine(line))
                 {
                     helper.readPropertyLine(line);
                 }
             }
             /**
              * Reads results of the stream passed as parameter
              * @param helper the helper used to read results line by line
              * @param stream the stream to read
              */
             void readResults(IAmdaResultParserHelper& helper, QTextStream& stream)
             {
                 QString line {};
                 // Skip comment lines
                 while (stream.readLineInto(&line) && isCommentLine(line))
                 {
                 }
                 if (!stream.atEnd())
                 {
                     do
                     {
                         helper.readResultLine(line);
                     } while (stream.readLineInto(&line));
                 }
             }
             } // namespace
             std::shared_ptr<IDataSeries> AmdaResultParser::readTxt(
                 const QString& filePath, DataSeriesType type) noexcept
             {
                 if (type == DataSeriesType::NONE)
                 {
                     qCCritical(LOG_AmdaResultParser())
                         << QObject::tr("Can't retrieve AMDA data: the type of values to be read is unknown");
                     return nullptr;
                 }
                 QFile file { filePath };
                 if (!file.open(QFile::ReadOnly | QIODevice::Text))
                 {
                     qCCritical(LOG_AmdaResultParser())
                         << QObject::tr("Can't retrieve AMDA data from file %1: %2")
                                .arg(filePath, file.errorString());
                     return nullptr;
                 }
                 return std::shared_ptr<IDataSeries> { AmdaResultParser::readTxt(QTextStream { &file }, type) };
             }
             IDataSeries* AmdaResultParser::readTxt(QTextStream stream, DataSeriesType type) noexcept
             {
                 if (type == DataSeriesType::NONE)
                 {
                     return nullptr;
                 }
                 // Checks if the file was found on the server
                 auto firstLine = stream.readLine();
                 if (firstLine.compare(FILE_NOT_FOUND_MESSAGE) == 0)
                 {
                     return nullptr;
                 }
                 auto helper = createHelper(type);
                 Q_ASSERT(helper != nullptr);
                 // Reads header file to retrieve properties
                 stream.seek(0); // returns to the beginning of the file
                 readProperties(*helper, stream);
                 // Checks properties
                 if (helper->checkProperties())
                 {
                     // Reads results
                     // AMDA V2: remove line
                     stream.seek(0); // returns to the beginning of the file
                     readResults(*helper, stream);
                     // Creates data series
                     return helper->createSeries();
                 }
                 else
                 {
                     return nullptr;
                 }
             }

plugins/amda/tests/FuzzingDefs.h +15 -12

             #ifndef SCIQLOP_FUZZINGDEFS_H
             #define SCIQLOP_FUZZINGDEFS_H
             #include <Data/DateTimeRange.h>
             #include <QString>
             #include <QUuid>
             #include <QVariantHash>
             #include <memory>
             #include <set>
             // /////// //
             // Aliases //
             // /////// //
             using MetadataPool = std::vector<QVariantHash>;
             Q_DECLARE_METATYPE(MetadataPool)
             using Properties = QVariantHash;
             // ///////// //
             // Constants //
             // ///////// //
             /// Timeout set for data acquisition for an operation (in ms)
             extern const QString ACQUISITION_TIMEOUT_PROPERTY;
             /// Max number of operations to generate
             extern const QString NB_MAX_OPERATIONS_PROPERTY;
             /// Max number of sync groups to create through operations
             extern const QString NB_MAX_SYNC_GROUPS_PROPERTY;
             /// Max number of variables to manipulate through operations
             extern const QString NB_MAX_VARIABLES_PROPERTY;
             /// Set of operations available for the test
             extern const QString AVAILABLE_OPERATIONS_PROPERTY;
             /// Tolerance used for variable's cache (in ratio)
             extern const QString CACHE_TOLERANCE_PROPERTY;
             /// Range with which the timecontroller is initialized
             extern const QString INITIAL_RANGE_PROPERTY;
             /// Max range that an operation can reach
             extern const QString MAX_RANGE_PROPERTY;
             /// Set of metadata that can be associated to a variable
             extern const QString METADATA_POOL_PROPERTY;
             /// Provider used to retrieve data
             extern const QString PROVIDER_PROPERTY;
             /// Min/max times left for an operation to execute
             extern const QString OPERATION_DELAY_BOUNDS_PROPERTY;
             /// Validators used to validate an operation
             extern const QString VALIDATORS_PROPERTY;
             /// Min/max number of operations to execute before calling validation of the current test's state
             extern const QString VALIDATION_FREQUENCY_BOUNDS_PROPERTY;
             // /////// //
             // Structs //
             // /////// //
             class Variable;
-            struct VariableState {
+            struct VariableState
-                std::shared_ptr<Variable> m_Variable{nullptr};
-                DateTimeRange m_Range{INVALID_RANGE};
+                std::shared_ptr<Variable> m_Variable { nullptr };
+                DateTimeRange m_Range { INVALID_RANGE };
             };
             using VariableId = int;
             using VariablesPool = std::map<VariableId, VariableState>;
             /**
              * Defines a synchronization group for a fuzzing state. A group reports the variables synchronized
              * with each other, and the current range of the group (i.e. range of the last synchronized variable
              * that has been moved)
              */
-            struct SyncGroup {
+            struct SyncGroup
-                std::set<VariableId> m_Variables{};
-                DateTimeRange m_Range{INVALID_RANGE};
+                std::set<VariableId> m_Variables {};
+                DateTimeRange m_Range { INVALID_RANGE };
             };
             using SyncGroupId = QUuid;
             using SyncGroupsPool = std::map<SyncGroupId, SyncGroup>;
             /**
              * Defines a current state during a fuzzing state. It contains all the variables manipulated during
              * the test, as well as the synchronization status of these variables.
              */
-            struct FuzzingState {
+            struct FuzzingState
-                const SyncGroup &syncGroup(SyncGroupId id) const;
-                SyncGroup &syncGroup(SyncGroupId id);
+                const SyncGroup& syncGroup(SyncGroupId id) const;
+                SyncGroup& syncGroup(SyncGroupId id);
-                const VariableState &variableState(VariableId id) const;
+                const VariableState& variableState(VariableId id) const;
-                VariableState &variableState(VariableId id);
+                VariableState& variableState(VariableId id);
                 /// @return the identifier of the synchronization group in which the variable passed in
                 /// parameter is located. If the variable is not in any group, returns an invalid identifier
                 SyncGroupId syncGroupId(VariableId variableId) const;
                 /// @return the set of synchronization group identifiers
                 std::vector<SyncGroupId> syncGroupsIds() const;
                 /// Updates fuzzing state according to a variable synchronization
                 /// @param variableId the variable that is synchronized
                 /// @param syncGroupId the synchronization group
                 void synchronizeVariable(VariableId variableId, SyncGroupId syncGroupId);
                 /// Updates fuzzing state according to a variable desynchronization
                 /// @param variableId the variable that is desynchronized
                 /// @param syncGroupId the synchronization group from which to remove the variable
                 void desynchronizeVariable(VariableId variableId, SyncGroupId syncGroupId);
                 /// Updates the range of a variable and all variables to which it is synchronized
                 /// @param the variable for which to affect the range
                 /// @param the range to affect
-                void updateRanges(VariableId variableId, const DateTimeRange &newRange);
+                void updateRanges(VariableId variableId, const DateTimeRange& newRange);
                 VariablesPool m_VariablesPool;
                 SyncGroupsPool m_SyncGroupsPool;
             };
             #endif // SCIQLOP_FUZZINGDEFS_H

plugins/mockplugin/include/CosinusProvider.h +6 -5

             #ifndef SCIQLOP_COSINUSPROVIDER_H
             #define SCIQLOP_COSINUSPROVIDER_H
             #include "MockPluginGlobal.h"
             #include <Data/IDataProvider.h>
             #include <QLoggingCategory>
             #include <QUuid>
             #include <QHash>
             /**
              * @brief The CosinusProvider class is an example of how a data provider can generate data
              */
-            class SCIQLOP_MOCKPLUGIN_EXPORT CosinusProvider : public IDataProvider {
+            class SCIQLOP_MOCKPLUGIN_EXPORT CosinusProvider : public IDataProvider
+            {
             public:
                 std::shared_ptr<IDataProvider> clone() const override;
-                virtual IDataSeries* getData(const DataProviderParameters &parameters) override;
+                virtual TimeSeries::ITimeSerie* getData(const DataProviderParameters& parameters) override;
             private:
-                std::shared_ptr<IDataSeries>
+                std::shared_ptr<IDataSeries> retrieveData(
-                retrieveData(QUuid acqIdentifier, const DateTimeRange &dataRangeRequested, const QVariantHash &data);
+                    QUuid acqIdentifier, const DateTimeRange& dataRangeRequested, const QVariantHash& data);
-                IDataSeries* _generate(const DateTimeRange &range, const QVariantHash &metaData);
+                TimeSeries::ITimeSerie* _generate(const DateTimeRange& range, const QVariantHash& metaData);
                 QHash<QUuid, bool> m_VariableToEnableProvider;
             };
             #endif // SCIQLOP_COSINUSPROVIDER_H

plugins/mockplugin/src/CosinusProvider.cpp +40 -157

@@ -1,204 +1,87
1	#include "CosinusProvider.h"	1	#include "CosinusProvider.h"
2	#include "MockDefs.h"	2	#include "MockDefs.h"
3		3
4	#include <Data/DataProviderParameters.h>	4	#include <Data/DataProviderParameters.h>
5	#include <Data/ScalarSeries.h>	5	#include <Data/ScalarTimeSerie.h>
6	#include <Data/SpectrogramSeries.h>	6	#include <Data/SpectrogramTimeSerie.h>
7	#include <Data/VectorSeries.h>	7	#include <Data/VectorTimeSerie.h>
8		8
9	#include <cmath>	9	#include <cmath>
10	#include <set>	10	#include <set>
11		11
12	#include <QFuture>	12	#include <QFuture>
13	#include <QThread>	13	#include <QThread>
14	#include <QtConcurrent/QtConcurrent>	14	#include <QtConcurrent/QtConcurrent>
15		15
16		16
17	namespace {	17	namespace
		18	{
18		19
19	/// Number of bands generated for a spectrogram	20	/// Number of bands generated for a spectrogram
20	const auto SPECTROGRAM_NUMBER_BANDS = 30;	21	const auto SPECTROGRAM_NUMBER_BANDS = 30;
21		22
22	/// Bands for which to generate NaN values for a spectrogram	23	/// Bands for which to generate NaN values for a spectrogram
23	const auto SPECTROGRAM_NAN_BANDS = std::set<int>{1, 3, 10, 20};	24	const auto SPECTROGRAM_NAN_BANDS = std::set<int> { 1, 3, 10, 20 };
24		25
25	/// Bands for which to generate zeros for a spectrogram	26	/// Bands for which to generate zeros for a spectrogram
26	const auto SPECTROGRAM_ZERO_BANDS = std::set<int>{2, 15, 19, 29};	27	const auto SPECTROGRAM_ZERO_BANDS = std::set<int> { 2, 15, 19, 29 };
27
28	/// Abstract cosinus type
29	struct ICosinusType {
30	virtual ~ICosinusType() = default;
31	/// @return the number of components generated for the type
32	virtual std::size_t componentCount() const = 0;
33	/// @return the data series created for the type
34	virtual IDataSeries* createDataSeries(std::vector<double> xAxisData,
35	std::vector<double> valuesData) const = 0;
36	/// Generates values (one value per component)
37	/// @param x the x-axis data used to generate values
38	/// @param values the vector in which to insert the generated values
39	/// @param dataIndex the index of insertion of the generated values
40	///
41	virtual void generateValues(double x, std::vector<double> &values, int dataIndex) const = 0;
42	};
43
44	struct ScalarCosinus : public ICosinusType {
45	std::size_t componentCount() const override { return 1; }
46
47	IDataSeries* createDataSeries(std::vector<double> xAxisData,
48	std::vector<double> valuesData) const override
49	{
50	return new ScalarSeries(std::move(xAxisData), std::move(valuesData),
51	Unit{QStringLiteral("t"), true}, Unit{});
52	}
53
54	void generateValues(double x, std::vector<double> &values, int dataIndex) const override
55	{
56	values[dataIndex] = std::cos(x);
57	}
58	};
59
60	struct SpectrogramCosinus : public ICosinusType {
61	/// Ctor with y-axis
62	explicit SpectrogramCosinus(std::vector<double> yAxisData, Unit yAxisUnit, Unit valuesUnit)
63	: m_YAxisData{std::move(yAxisData)},
64	m_YAxisUnit{std::move(yAxisUnit)},
65	m_ValuesUnit{std::move(valuesUnit)}
66	{
67	}
68
69	std::size_t componentCount() const override { return m_YAxisData.size(); }
70
71	IDataSeries* createDataSeries(std::vector<double> xAxisData,
72	std::vector<double> valuesData) const override
73	{
74	return new SpectrogramSeries(
75	std::move(xAxisData), m_YAxisData, std::move(valuesData),
76	Unit{QStringLiteral("t"), true}, m_YAxisUnit, m_ValuesUnit);
77	}
78
79	void generateValues(double x, std::vector<double> &values, int dataIndex) const override
80	{
81	auto componentCount = this->componentCount();
82	for (int i = 0; i < componentCount; ++i) {
83	auto y = m_YAxisData[i];
84
85	double value;
86
87	// if (SPECTROGRAM_ZERO_BANDS.find(y) != SPECTROGRAM_ZERO_BANDS.end()) {
88	// value = 0.;
89	// }
90	// else if (SPECTROGRAM_NAN_BANDS.find(y) != SPECTROGRAM_NAN_BANDS.end()) {
91	// value = std::numeric_limits<double>::quiet_NaN();
92	// }
93	// else
94	{
95	// Generates value for non NaN/zero bands
96	//auto r = 3 * std::sqrt(x * x + y * y) + 1e-2;
97	//value = 2 * x * (std::cos(r + 2) / r - std::sin(r + 2) / r);
98	value = x + 10*y;
99	}
100
101	values[componentCount * dataIndex + i] = value;
102	}
103	}
104
105	std::vector<double> m_YAxisData;
106	Unit m_YAxisUnit;
107	Unit m_ValuesUnit;
108	};
109
110	struct VectorCosinus : public ICosinusType {
111	std::size_t componentCount() const override { return 3; }
112		28
113	IDataSeries* createDataSeries(std::vector<double> xAxisData,
114	std::vector<double> valuesData) const override
115	{
116	return new VectorSeries(std::move(xAxisData), std::move(valuesData),
117	Unit{QStringLiteral("t"), true}, Unit{});
118	}
119
120	void generateValues(double x, std::vector<double> &values, int dataIndex) const override
121	{
122	// Generates value for each component: cos(x), cos(x)/2, cos(x)/3
123	auto xValue = std::cos(x);
124	auto componentCount = this->componentCount();
125	for (auto i = 0; i < componentCount; ++i) {
126	values[componentCount * dataIndex + i] = xValue / (i + 1);
127	}
128	}
129	};
130
131	/// Converts string to cosinus type
132	/// @return the cosinus type if the string could be converted, nullptr otherwise
133	std::unique_ptr<ICosinusType> cosinusType(const QString &type) noexcept
134	{
135	if (type.compare(QStringLiteral("scalar"), Qt::CaseInsensitive) == 0) {
136	return std::make_unique<ScalarCosinus>();
137	}
138	else if (type.compare(QStringLiteral("spectrogram"), Qt::CaseInsensitive) == 0) {
139	// Generates default y-axis data for spectrogram [0., 1., 2., ...]
140	std::vector<double> yAxisData(SPECTROGRAM_NUMBER_BANDS);
141	std::iota(yAxisData.begin(), yAxisData.end(), 1.);
142	for (auto & v:yAxisData)
143	{
144	v = std::pow(2,v);
145	}
146	return std::make_unique<SpectrogramCosinus>(std::move(yAxisData), Unit{"eV"},
147	Unit{"eV/(cm^2-s-sr-eV)"});
148	}
149	else if (type.compare(QStringLiteral("vector"), Qt::CaseInsensitive) == 0) {
150	return std::make_unique<VectorCosinus>();
151	}
152	else {
153	return nullptr;
154	}
155	}
156		29
157	} // namespace	30	} // namespace
158		31
159	std::shared_ptr<IDataProvider> CosinusProvider::clone() const	32	std::shared_ptr<IDataProvider> CosinusProvider::clone() const
160	{	33	{
161	// No copy is made in clone	34	// No copy is made in clone
162	return std::make_shared<CosinusProvider>();	35	return std::make_shared<CosinusProvider>();
163	}	36	}
164		37
165	IDataSeries *CosinusProvider::_generate(const DateTimeRange &range, const QVariantHash &metaData)	38	TimeSeries::ITimeSerie* CosinusProvider::_generate(
		39	const DateTimeRange& range, const QVariantHash& metaData)
166	{	40	{
167	auto dataIndex = 0;
168
169	// Retrieves cosinus type	41	// Retrieves cosinus type
170	auto typeVariant = metaData.value(COSINUS_TYPE_KEY, COSINUS_TYPE_DEFAULT_VALUE);	42	auto typeVariant = metaData.value(COSINUS_TYPE_KEY, COSINUS_TYPE_DEFAULT_VALUE);
171	auto type = cosinusType(typeVariant.toString());
172	auto freqVariant = metaData.value(COSINUS_FREQUENCY_KEY, COSINUS_FREQUENCY_DEFAULT_VALUE);	43	auto freqVariant = metaData.value(COSINUS_FREQUENCY_KEY, COSINUS_FREQUENCY_DEFAULT_VALUE);
		44	const auto fs = 200.;
173	double freq = freqVariant.toDouble();	45	double freq = freqVariant.toDouble();
174	double start = std::ceil(range.m_TStart * freq);	46	double start = std::ceil(range.m_TStart * freq);
175	double end = std::floor(range.m_TEnd * freq);	47	double end = std::floor(range.m_TEnd * freq);
176	if (end < start) {	48	if (end < start)
		49	{
177	std::swap(start, end);	50	std::swap(start, end);
178	}	51	}
179	std::size_t dataCount = static_cast<std::size_t>(end - start + 1);	52	std::size_t dataCount = static_cast<std::size_t>(end - start + 1);
180	std::size_t componentCount = type->componentCount();	53	if (typeVariant.toString() == QStringLiteral("scalar"))
181
182	auto xAxisData = std::vector<double>{};
183	xAxisData.resize(dataCount);
184
185	auto valuesData = std::vector<double>{};
186	valuesData.resize(dataCount * componentCount);
187
188	int progress = 0;
189	auto progressEnd = dataCount;
190	for (auto time = start; time <= end; ++time, ++dataIndex)
191	{	54	{
192	const auto x = time / freq;	55	auto ts = new ScalarTimeSerie(dataCount);
193	xAxisData[dataIndex] = x;	56	std::generate(
194	// Generates values (depending on the type)	57	std::begin(ts), std::end(ts), [range, freq, fs, dt = 1. / freq, i = 0.]() mutable {
195	type->generateValues(x, valuesData, dataIndex);	58	auto t = range.m_TStart + i * dt;
		59	i++;
		60	return std::pair<double, double> { t, std::cos(2 * 3.14 * freq / fs * t) };
		61	});
		62	return ts;
196	}	63	}
197	return type->createDataSeries(std::move(xAxisData), std::move(valuesData));	64	if (typeVariant.toString() == QStringLiteral("vector"))
		65	{
		66	auto ts = new VectorTimeSerie(dataCount);
		67	std::generate(
		68	std::begin(ts), std::end(ts), [range, freq, fs, dt = 1. / freq, i = 0.]() mutable {
		69	auto t = range.m_TStart + i * dt;
		70	i++;
		71	return std::pair<double, VectorTimeSerie::raw_value_type> { t,
		72	{ std::cos(2 * 3.14 * freq / fs * t), std::sin(2 * 3.14 * freq / fs * t),
		73	std::cos(2 * 3.14 * freq / fs * t) * std::sin(2 * 3.14 * freq / fs * t) } };
		74	});
		75	return ts;
		76	}
		77	if (typeVariant.toString() == QStringLiteral("spectrogram"))
		78	{
		79	return nullptr;
		80	}
		81	return nullptr;
198	}	82	}
199		83
200	~~IDataSeries~~* CosinusProvider::getData(const DataProviderParameters &parameters)	84	TimeSeries::ITimeSerie* CosinusProvider::getData(const DataProviderParameters& parameters)
201	{	85	{
202	return _generate(parameters.m_Range, parameters.m_Data);	86	return _generate(parameters.m_Range, parameters.m_Data);
203	}	87	}
204

plugins/mockplugin/tests/PyTestMockPluginWrapper.cpp +29 -28

             /*------------------------------------------------------------------------------
             --  This file is a part of the SciQLOP Software
             --  Copyright (C) 2018, 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 <string>
-            #include <sstream>
             #include <memory>
+            #include <sstream>
+            #include <string>
-            #include <pybind11/pybind11.h>
+            #include <pybind11/chrono.h>
-            #include <pybind11/operators.h>
             #include <pybind11/embed.h>
             #include <pybind11/numpy.h>
-            #include <pybind11/chrono.h>
+            #include <pybind11/operators.h>
+            #include <pybind11/pybind11.h>
+            #include <Common/DateUtils.h>
+            #include <Data/DataSeriesType.h>
+            #include <Data/DateTimeRange.h>
             #include <SqpApplication.h>
-            #include <Variable/VariableController2.h>
             #include <Time/TimeController.h>
-            #include <Data/DateTimeRange.h>
+            #include <Variable/VariableController2.h>
-            #include <Data/DataSeriesType.h>
-            #include <Common/DateUtils.h>
-            #include <Variable/Variable.h>
-            #include <Data/ScalarSeries.h>
-            #include <Data/VectorSeries.h>
-            #include <MockPlugin.h>
             #include <CosinusProvider.h>
+            #include <MockPlugin.h>
             #include <QFile>
-            #include <pywrappers_common.h>
             #include <CoreWrappers.h>
+            #include <pywrappers_common.h>
             using namespace std::chrono;
             namespace py = pybind11;
+            PYBIND11_MODULE(pytestmockplugin, m)
-            PYBIND11_MODULE(pytestmockplugin, m){
                 int argc = 0;
-                char ** argv=nullptr;
+                char** argv = nullptr;
                 SqpApplication::setOrganizationName("LPP");
                 SqpApplication::setOrganizationDomain("lpp.fr");
                 SqpApplication::setApplicationName("SciQLop");
                 static SqpApplication app(argc, argv);
                 auto qtmod = py::module::import("sciqlopqt");
                 auto sciqlopmod = py::module::import("pysciqlopcore");
                 m.doc() = "";
-                py::class_<VariableController2>(m, "VariableController2").def_static("createVariable",[](const QString &name,
+                py::class_<VariableController2>(m, "VariableController2")
-                                    std::shared_ptr<IDataProvider> provider, const DateTimeRange& range){
+                    .def_static("createVariable",
-                    return sqpApp->variableController().createVariable(name, {{"cosinusType", "spectrogram"}, {"cosinusFrequency", "0.1"}}, provider, range);
+                        [](const QString& name, std::shared_ptr<IDataProvider> provider,
+                            const DateTimeRange& range) {
+                            return sqpApp->variableController().createVariable(name,
+                                { { "cosinusType", "spectrogram" }, { "cosinusFrequency", "0.1" } }, provider,
+                                range);
+                        });
+                py::class_<TimeController>(m, "TimeController").def_static("setTime", [](DateTimeRange range) {
+                    sqpApp->timeController().setDateTimeRange(range);
                 });
-                py::class_<TimeController>(m,"TimeController")
-                        .def_static("setTime", [](DateTimeRange range){sqpApp->timeController().setDateTimeRange(range);});
                 auto mock_provider = std::make_shared<CosinusProvider>();
-                m.def("mock_provider",[mock_provider](){return mock_provider;}, py::return_value_policy::copy);
+                m.def("mock_provider", [mock_provider]() { return mock_provider; },
+                    py::return_value_policy::copy);
-                py::class_<CosinusProvider, std::shared_ptr<CosinusProvider>, IDataProvider>(m, "CosinusProvider");
+                py::class_<CosinusProvider, std::shared_ptr<CosinusProvider>, IDataProvider>(
+                    m, "CosinusProvider");
             }

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