GIT_REPOSITORIES/LPP/Users/mperrinel/SCIQLOP-Initialisation Commit - r453:0877c365bd5c

Some fixes...

Alexandre Leroux -

r453:0877c365bd5c

parent child

Context file:

r453:0877c365bd5c

Collapse all files

app/src/MainWindow.cpp 0 -1

             /*------------------------------------------------------------------------------
             -- 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 <Settings/SqpSettingsDialog.h>
             #include <Settings/SqpSettingsGeneralWidget.h>
             #include <SidePane/SqpSidePane.h>
             #include <SqpApplication.h>
             #include <Time/TimeController.h>
             #include <TimeWidget/TimeWidget.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <Visualization/VisualizationController.h>
             #include <QAction>
             #include <QDate>
-            #include <QDateTime>
             #include <QDir>
             #include <QFileDialog>
             #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}}
                 {
                 }
                 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;
             };
             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);
                 auto leftSidePane = m_Ui->leftInspectorSidePane->sidePane();
                 auto openLeftInspectorAction = new QAction{QIcon{
                                                                ":/icones/previous.png",
                                                            },
                                                            tr("Show/hide the left inspector"), this};
                 auto spacerLeftTop = new QWidget{};
                 spacerLeftTop->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                 auto spacerLeftBottom = new QWidget{};
                 spacerLeftBottom->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                 leftSidePane->addWidget(spacerLeftTop);
                 leftSidePane->addAction(openLeftInspectorAction);
                 leftSidePane->addWidget(spacerLeftBottom);
                 auto rightSidePane = m_Ui->rightInspectorSidePane->sidePane();
                 auto openRightInspectorAction = new QAction{QIcon{
                                                                 ":/icones/next.png",
                                                             },
                                                             tr("Show/hide the right inspector"), this};
                 auto spacerRightTop = new QWidget{};
                 spacerRightTop->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                 auto spacerRightBottom = new QWidget{};
                 spacerRightBottom->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                 rightSidePane->addWidget(spacerRightTop);
                 rightSidePane->addAction(openRightInspectorAction);
                 rightSidePane->addWidget(spacerRightBottom);
                 openLeftInspectorAction->setCheckable(true);
                 openRightInspectorAction->setCheckable(true);
                 auto openInspector = [this](bool checked, bool right, auto action) {
                     action->setIcon(QIcon{(checked xor 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);
                     }
                 };
                 connect(openLeftInspectorAction, &QAction::triggered,
                         [openInspector, openLeftInspectorAction](bool checked) {
                             openInspector(checked, false, openLeftInspectorAction);
                         });
                 connect(openRightInspectorAction, &QAction::triggered,
                         [openInspector, openRightInspectorAction](bool checked) {
                             openInspector(checked, true, openRightInspectorAction);
                         });
                 // //// //
                 // Menu //
                 // //// //
                 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);
                 // //////// //
                 // 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(SqpDateTime)),
                         &sqpApp->variableController(), SLOT(onDateTimeOnSelection(SqpDateTime)));
                 // Widgets / controllers connections
                 // DataSource
                 connect(&sqpApp->dataSourceController(), SIGNAL(dataSourceItemSet(DataSourceItem *)),
                         m_Ui->dataSourceWidget, SLOT(addDataSource(DataSourceItem *)));
                 // Time
                 connect(timeWidget, SIGNAL(timeUpdated(SqpDateTime)), &sqpApp->timeController(),
                         SLOT(onTimeToUpdate(SqpDateTime)));
                 // Visualization
                 connect(&sqpApp->visualizationController(),
                         SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)), m_Ui->view,
                         SLOT(onVariableAboutToBeDeleted(std::shared_ptr<Variable>)));
                 connect(&sqpApp->visualizationController(),
                         SIGNAL(rangeChanged(std::shared_ptr<Variable>, const SqpDateTime &)), m_Ui->view,
                         SLOT(onRangeChanged(std::shared_ptr<Variable>, const SqpDateTime &)));
                 // 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;
                 }
             }

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

             #ifndef SCIQLOP_IDATASERIES_H
             #define SCIQLOP_IDATASERIES_H
             #include <Common/MetaTypes.h>
             #include <memory>
             #include <QString>
             template <int Dim>
             class ArrayData;
             struct Unit {
                 explicit Unit(const QString &name = {}, bool timeUnit = false)
                         : m_Name{name}, m_TimeUnit{timeUnit}
                 {
                 }
                 inline bool operator==(const Unit &other) const
                 {
                     return std::tie(m_Name, m_TimeUnit) == std::tie(other.m_Name, other.m_TimeUnit);
                 }
                 inline bool operator!=(const Unit &other) const { return !(*this == other); }
                 QString m_Name;  ///< Unit name
-                bool m_TimeUnit; ///< The unit is a unit of time
+                bool m_TimeUnit; ///< The unit is a unit of time (UTC)
             };
             /**
              * @brief The IDataSeries aims to declare a data series.
              *
              * A data series is an entity that contains at least :
              * - one dataset representing the x-axis
              * - one dataset representing the values
              *
              * Each dataset is represented by an ArrayData, and is associated with a unit.
              *
              * An ArrayData can be unidimensional or two-dimensional, depending on the implementation of the
              * IDataSeries. The x-axis dataset is always unidimensional.
              *
              * @sa ArrayData
              */
             class IDataSeries {
             public:
                 virtual ~IDataSeries() noexcept = default;
                 /// Returns the x-axis dataset
                 virtual std::shared_ptr<ArrayData<1> > xAxisData() = 0;
                 /// Returns the x-axis dataset (as const)
                 virtual const std::shared_ptr<ArrayData<1> > xAxisData() const = 0;
                 virtual Unit xAxisUnit() const = 0;
                 virtual Unit valuesUnit() const = 0;
                 virtual void merge(IDataSeries *dataSeries) = 0;
                 virtual std::unique_ptr<IDataSeries> clone() const = 0;
                 virtual void lockRead() = 0;
                 virtual void lockWrite() = 0;
                 virtual void unlock() = 0;
             };
             // Required for using shared_ptr in signals/slots
             SCIQLOP_REGISTER_META_TYPE(IDATASERIES_PTR_REGISTRY, std::shared_ptr<IDataSeries>)
             #endif // SCIQLOP_IDATASERIES_H

core/include/Data/SqpDateTime.h +2 -2

             #ifndef SCIQLOP_SQPDATETIME_H
             #define SCIQLOP_SQPDATETIME_H
             #include <QObject>
             #include <QDebug>
             #include <Common/DateUtils.h>
             #include <Common/MetaTypes.h>
             /**
              * @brief The SqpDateTime struct holds the information of time parameters
              */
             struct SqpDateTime {
-                /// Start time
+                /// Start time (UTC)
                 double m_TStart;
-                /// End time
+                /// End time (UTC)
                 double m_TEnd;
                 bool contains(const SqpDateTime &dateTime) const noexcept
                 {
                     return (m_TStart <= dateTime.m_TStart && m_TEnd >= dateTime.m_TEnd);
                 }
                 bool intersect(const SqpDateTime &dateTime) const noexcept
                 {
                     return (m_TEnd >= dateTime.m_TStart && m_TStart <= dateTime.m_TEnd);
                 }
             };
             inline QDebug operator<<(QDebug d, SqpDateTime obj)
             {
                 auto tendDateTimeStart = DateUtils::dateTime(obj.m_TStart);
                 auto tendDateTimeEnd = DateUtils::dateTime(obj.m_TEnd);
                 d << "ts: " << tendDateTimeStart << " te: " << tendDateTimeEnd;
                 return d;
             }
             // Required for using shared_ptr in signals/slots
             SCIQLOP_REGISTER_META_TYPE(SQPDATETIME_REGISTRY, SqpDateTime)
             #endif // SCIQLOP_SQPDATETIME_H

core/src/Variable/VariableController.cpp 0 -1

             #include <Variable/Variable.h>
             #include <Variable/VariableCacheController.h>
             #include <Variable/VariableController.h>
             #include <Variable/VariableModel.h>
             #include <Data/DataProviderParameters.h>
             #include <Data/IDataProvider.h>
             #include <Data/IDataSeries.h>
             #include <Time/TimeController.h>
-            #include <QDateTime>
             #include <QMutex>
             #include <QThread>
             #include <QUuid>
             #include <QtCore/QItemSelectionModel>
             #include <unordered_map>
             Q_LOGGING_CATEGORY(LOG_VariableController, "VariableController")
             struct VariableController::VariableControllerPrivate {
                 explicit VariableControllerPrivate(VariableController *parent)
                         : m_WorkingMutex{},
                           m_VariableModel{new VariableModel{parent}},
                           m_VariableSelectionModel{new QItemSelectionModel{m_VariableModel, parent}},
                           m_VariableCacheController{std::make_unique<VariableCacheController>()}
                 {
                 }
                 QMutex m_WorkingMutex;
                 /// Variable model. The VariableController has the ownership
                 VariableModel *m_VariableModel;
                 QItemSelectionModel *m_VariableSelectionModel;
                 TimeController *m_TimeController{nullptr};
                 std::unique_ptr<VariableCacheController> m_VariableCacheController;
                 std::unordered_map<std::shared_ptr<Variable>, std::shared_ptr<IDataProvider> >
                     m_VariableToProviderMap;
                 std::unordered_map<std::shared_ptr<Variable>, QUuid> m_VariableToIdentifierMap;
             };
             VariableController::VariableController(QObject *parent)
                     : QObject{parent}, impl{spimpl::make_unique_impl<VariableControllerPrivate>(this)}
             {
                 qCDebug(LOG_VariableController()) << tr("VariableController construction")
                                                   << QThread::currentThread();
                 connect(impl->m_VariableModel, &VariableModel::abortProgessRequested, this,
                         &VariableController::onAbortProgressRequested);
             }
             VariableController::~VariableController()
             {
                 qCDebug(LOG_VariableController()) << tr("VariableController destruction")
                                                   << QThread::currentThread();
                 this->waitForFinish();
             }
             VariableModel *VariableController::variableModel() noexcept
             {
                 return impl->m_VariableModel;
             }
             QItemSelectionModel *VariableController::variableSelectionModel() noexcept
             {
                 return impl->m_VariableSelectionModel;
             }
             void VariableController::setTimeController(TimeController *timeController) noexcept
             {
                 impl->m_TimeController = timeController;
             }
             void VariableController::deleteVariable(std::shared_ptr<Variable> variable) noexcept
             {
                 if (!variable) {
                     qCCritical(LOG_VariableController()) << "Can't delete variable: variable is null";
                     return;
                 }
                 // Spreads in SciQlop that the variable will be deleted, so that potential receivers can
                 // make some treatments before the deletion
                 emit variableAboutToBeDeleted(variable);
                 // Deletes identifier
                 impl->m_VariableToIdentifierMap.erase(variable);
                 // Deletes provider
                 auto nbProvidersDeleted = impl->m_VariableToProviderMap.erase(variable);
                 qCDebug(LOG_VariableController())
                     << tr("Number of providers deleted for variable %1: %2")
                            .arg(variable->name(), QString::number(nbProvidersDeleted));
                 // Clears cache
                 impl->m_VariableCacheController->clear(variable);
                 // Deletes from model
                 impl->m_VariableModel->deleteVariable(variable);
             }
             void VariableController::deleteVariables(
                 const QVector<std::shared_ptr<Variable> > &variables) noexcept
             {
                 for (auto variable : qAsConst(variables)) {
                     deleteVariable(variable);
                 }
             }
             void VariableController::abortProgress(std::shared_ptr<Variable> variable)
             {
             }
             void VariableController::createVariable(const QString &name, const QVariantHash &metadata,
                                                     std::shared_ptr<IDataProvider> provider) noexcept
             {
                 if (!impl->m_TimeController) {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to create variable: The time controller is null");
                     return;
                 }
                 auto dateTime = impl->m_TimeController->dateTime();
                 if (auto newVariable = impl->m_VariableModel->createVariable(name, dateTime, metadata)) {
                     auto identifier = QUuid::createUuid();
                     // store the provider
                     impl->m_VariableToProviderMap[newVariable] = provider;
                     impl->m_VariableToIdentifierMap[newVariable] = identifier;
                     auto addDateTimeAcquired = [ this, varW = std::weak_ptr<Variable>{newVariable} ](
                         QUuid identifier, auto dataSeriesAcquired, auto dateTimeToPutInCache)
                     {
                         if (auto variable = varW.lock()) {
                             auto varIdentifier = impl->m_VariableToIdentifierMap.at(variable);
                             if (varIdentifier == identifier) {
                                 impl->m_VariableCacheController->addDateTime(variable, dateTimeToPutInCache);
                                 variable->setDataSeries(dataSeriesAcquired);
                                 emit variable->updated();
                             }
                         }
                     };
                     connect(provider.get(), &IDataProvider::dataProvided, addDateTimeAcquired);
                     connect(provider.get(), &IDataProvider::dataProvidedProgress, this,
                             &VariableController::onVariableRetrieveDataInProgress);
                     this->onRequestDataLoading(newVariable, dateTime);
                 }
             }
             void VariableController::onDateTimeOnSelection(const SqpDateTime &dateTime)
             {
                 qCDebug(LOG_VariableController()) << "VariableController::onDateTimeOnSelection"
                                                   << QThread::currentThread()->objectName();
                 auto selectedRows = impl->m_VariableSelectionModel->selectedRows();
                 for (const auto &selectedRow : qAsConst(selectedRows)) {
                     if (auto selectedVariable = impl->m_VariableModel->variable(selectedRow.row())) {
                         selectedVariable->setDateTime(dateTime);
                         this->onRequestDataLoading(selectedVariable, dateTime);
                         // notify that rescale operation has to be done
                         emit rangeChanged(selectedVariable, dateTime);
                     }
                 }
             }
             void VariableController::onVariableRetrieveDataInProgress(QUuid identifier, double progress)
             {
                 auto findReply = [identifier](const auto &entry) { return identifier == entry.second; };
                 auto end = impl->m_VariableToIdentifierMap.cend();
                 auto it = std::find_if(impl->m_VariableToIdentifierMap.cbegin(), end, findReply);
                 if (it != end) {
                     impl->m_VariableModel->setDataProgress(it->first, progress);
                 }
             }
             void VariableController::onAbortProgressRequested(std::shared_ptr<Variable> variable)
             {
                 qCDebug(LOG_VariableController()) << "TORM: VariableController::onAbortProgressRequested"
                                                   << QThread::currentThread()->objectName();
                 auto it = impl->m_VariableToIdentifierMap.find(variable);
                 if (it != impl->m_VariableToIdentifierMap.cend()) {
                     impl->m_VariableToProviderMap.at(variable)->requestDataAborting(it->second);
                 }
                 else {
                     qCWarning(LOG_VariableController())
                         << tr("Aborting progression of inexistant variable detected !!!")
                         << QThread::currentThread()->objectName();
                 }
             }
             void VariableController::onRequestDataLoading(std::shared_ptr<Variable> variable,
                                                           const SqpDateTime &dateTime)
             {
                 qCDebug(LOG_VariableController()) << "VariableController::onRequestDataLoading"
                                                   << QThread::currentThread()->objectName();
                 // we want to load data of the variable for the dateTime.
                 // First we check if the cache contains some of them.
                 // For the other, we ask the provider to give them.
                 if (variable) {
                     auto dateTimeListNotInCache
                         = impl->m_VariableCacheController->provideNotInCacheDateTimeList(variable, dateTime);
                     if (!dateTimeListNotInCache.empty()) {
                         // Ask the provider for each data on the dateTimeListNotInCache
                         auto identifier = impl->m_VariableToIdentifierMap.at(variable);
                         impl->m_VariableToProviderMap.at(variable)->requestDataLoading(
                             identifier,
                             DataProviderParameters{std::move(dateTimeListNotInCache), variable->metadata()});
                     }
                     else {
                         emit variable->updated();
                     }
                 }
                 else {
                     qCCritical(LOG_VariableController()) << tr("Impossible to load data of a variable null");
                 }
             }
             void VariableController::initialize()
             {
                 qCDebug(LOG_VariableController()) << tr("VariableController init") << QThread::currentThread();
                 impl->m_WorkingMutex.lock();
                 qCDebug(LOG_VariableController()) << tr("VariableController init END");
             }
             void VariableController::finalize()
             {
                 impl->m_WorkingMutex.unlock();
             }
             void VariableController::waitForFinish()
             {
                 QMutexLocker locker{&impl->m_WorkingMutex};
             }

plugins/amda/tests/TestAmdaResultParser.cpp +1 -1

             #include "AmdaResultParser.h"
             #include <Data/ScalarSeries.h>
             #include <QObject>
             #include <QtTest>
             namespace {
             /// Path for the tests
             const auto TESTS_RESOURCES_PATH
                 = QFileInfo{QString{AMDA_TESTS_RESOURCES_DIR}, "TestAmdaResultParser"}.absoluteFilePath();
             QString inputFilePath(const QString &inputFileName)
             {
                 return QFileInfo{TESTS_RESOURCES_PATH, inputFileName}.absoluteFilePath();
             }
             struct ExpectedResults {
                 explicit ExpectedResults() = default;
                 /// Ctor with QVector<QDateTime> as x-axis data. Datetimes are converted to doubles
                 explicit ExpectedResults(Unit xAxisUnit, Unit valuesUnit, const QVector<QDateTime> &xAxisData,
                                          QVector<double> valuesData)
                         : m_ParsingOK{true},
                           m_XAxisUnit{xAxisUnit},
                           m_ValuesUnit{valuesUnit},
                           m_XAxisData{},
                           m_ValuesData{std::move(valuesData)}
                 {
                     // Converts QVector<QDateTime> to QVector<double>
                     std::transform(xAxisData.cbegin(), xAxisData.cend(), std::back_inserter(m_XAxisData),
                                    [](const auto &dateTime) { return dateTime.toMSecsSinceEpoch() / 1000.; });
                 }
                 /**
                  * Validates a DataSeries compared to the expected results
                  * @param results the DataSeries to validate
                  */
                 void validate(std::shared_ptr<IDataSeries> results)
                 {
                     if (m_ParsingOK) {
                         auto scalarSeries = dynamic_cast<ScalarSeries *>(results.get());
                         QVERIFY(scalarSeries != nullptr);
                         // Checks units
                         QVERIFY(scalarSeries->xAxisUnit() == m_XAxisUnit);
                         QVERIFY(scalarSeries->valuesUnit() == m_ValuesUnit);
                         // Checks values
                         QVERIFY(scalarSeries->xAxisData()->data() == m_XAxisData);
                         QVERIFY(scalarSeries->valuesData()->data() == m_ValuesData);
                     }
                     else {
                         QVERIFY(results == nullptr);
                     }
                 }
                 // Parsing was successfully completed
                 bool m_ParsingOK{false};
                 // Expected x-axis unit
                 Unit m_XAxisUnit{};
                 // Expected values unit
                 Unit m_ValuesUnit{};
                 // Expected x-axis data
                 QVector<double> m_XAxisData{};
                 // Expected values data
                 QVector<double> m_ValuesData{};
             };
             } // namespace
             Q_DECLARE_METATYPE(ExpectedResults)
             class TestAmdaResultParser : public QObject {
                 Q_OBJECT
             private slots:
                 /// Input test data
                 /// @sa testTxtJson()
                 void testReadTxt_data();
                 /// Tests parsing of a TXT file
                 void testReadTxt();
             };
             void TestAmdaResultParser::testReadTxt_data()
             {
                 // ////////////// //
                 // Test structure //
                 // ////////////// //
                 // Name of TXT file to read
                 QTest::addColumn<QString>("inputFileName");
                 // Expected results
                 QTest::addColumn<ExpectedResults>("expectedResults");
                 // ////////// //
                 // Test cases //
                 // ////////// //
                 auto dateTime = [](int year, int month, int day, int hours, int minutes, int seconds) {
-                    return QDateTime{{year, month, day}, {hours, minutes, seconds}};
+                    return QDateTime{{year, month, day}, {hours, minutes, seconds}, Qt::UTC};
                 };
                 // Valid file
                 QTest::newRow("Valid file")
                     << QStringLiteral("ValidScalar1.txt")
                     << ExpectedResults{
                            Unit{QStringLiteral("nT"), true}, Unit{},
                            QVector<QDateTime>{dateTime(2013, 9, 23, 9, 0, 30), dateTime(2013, 9, 23, 9, 1, 30),
                                               dateTime(2013, 9, 23, 9, 2, 30), dateTime(2013, 9, 23, 9, 3, 30),
                                               dateTime(2013, 9, 23, 9, 4, 30), dateTime(2013, 9, 23, 9, 5, 30),
                                               dateTime(2013, 9, 23, 9, 6, 30), dateTime(2013, 9, 23, 9, 7, 30),
                                               dateTime(2013, 9, 23, 9, 8, 30), dateTime(2013, 9, 23, 9, 9, 30)},
                            QVector<double>{-2.83950, -2.71850, -2.52150, -2.57633, -2.58050, -2.48325, -2.63025,
                                            -2.55800, -2.43250, -2.42200}};
                 // Valid files but with some invalid lines (wrong unit, wrong values, etc.)
                 QTest::newRow("No unit file") << QStringLiteral("NoUnit.txt")
                                               << ExpectedResults{Unit{QStringLiteral(""), true}, Unit{},
                                                                  QVector<QDateTime>{}, QVector<double>{}};
                 QTest::newRow("Wrong unit file")
                     << QStringLiteral("WrongUnit.txt")
                     << ExpectedResults{Unit{QStringLiteral(""), true}, Unit{},
                                        QVector<QDateTime>{dateTime(2013, 9, 23, 9, 0, 30),
                                                           dateTime(2013, 9, 23, 9, 1, 30),
                                                           dateTime(2013, 9, 23, 9, 2, 30)},
                                        QVector<double>{-2.83950, -2.71850, -2.52150}};
                 QTest::newRow("Wrong results file (date of first line is invalid")
                     << QStringLiteral("WrongDate.txt")
                     << ExpectedResults{
                            Unit{QStringLiteral("nT"), true}, Unit{},
                            QVector<QDateTime>{dateTime(2013, 9, 23, 9, 1, 30), dateTime(2013, 9, 23, 9, 2, 30)},
                            QVector<double>{-2.71850, -2.52150}};
                 QTest::newRow("Wrong results file (too many values for first line")
                     << QStringLiteral("TooManyValues.txt")
                     << ExpectedResults{
                            Unit{QStringLiteral("nT"), true}, Unit{},
                            QVector<QDateTime>{dateTime(2013, 9, 23, 9, 1, 30), dateTime(2013, 9, 23, 9, 2, 30)},
                            QVector<double>{-2.71850, -2.52150}};
                 QTest::newRow("Wrong results file (value of first line is invalid")
                     << QStringLiteral("WrongValue.txt")
                     << ExpectedResults{
                            Unit{QStringLiteral("nT"), true}, Unit{},
                            QVector<QDateTime>{dateTime(2013, 9, 23, 9, 1, 30), dateTime(2013, 9, 23, 9, 2, 30)},
                            QVector<double>{-2.71850, -2.52150}};
                 QTest::newRow("Wrong results file (value of first line is NaN")
                     << QStringLiteral("NaNValue.txt")
                     << ExpectedResults{
                            Unit{QStringLiteral("nT"), true}, Unit{},
                            QVector<QDateTime>{dateTime(2013, 9, 23, 9, 1, 30), dateTime(2013, 9, 23, 9, 2, 30)},
                            QVector<double>{-2.71850, -2.52150}};
                 // Invalid files
                 QTest::newRow("Invalid file (unexisting file)") << QStringLiteral("UnexistingFile.txt")
                                                                 << ExpectedResults{};
                 QTest::newRow("Invalid file (file not found on server)") << QStringLiteral("FileNotFound.txt")
                                                                          << ExpectedResults{};
             }
             void TestAmdaResultParser::testReadTxt()
             {
                 QFETCH(QString, inputFileName);
                 QFETCH(ExpectedResults, expectedResults);
                 // Parses file
                 auto filePath = inputFilePath(inputFileName);
                 auto results = AmdaResultParser::readTxt(filePath);
                 // ///////////////// //
                 // Validates results //
                 // ///////////////// //
                 expectedResults.validate(results);
             }
             QTEST_MAIN(TestAmdaResultParser)
             #include "TestAmdaResultParser.moc"

plugins/mockplugin/src/CosinusProvider.cpp 0 -1

             #include "CosinusProvider.h"
             #include <Data/DataProviderParameters.h>
             #include <Data/ScalarSeries.h>
             #include <cmath>
-            #include <QDateTime>
             #include <QFuture>
             #include <QThread>
             #include <QtConcurrent/QtConcurrent>
             Q_LOGGING_CATEGORY(LOG_CosinusProvider, "CosinusProvider")
             std::shared_ptr<IDataSeries> CosinusProvider::retrieveData(QUuid token, const SqpDateTime &dateTime)
             {
                 // TODO: Add Mutex
                 auto dataIndex = 0;
                 // Gets the timerange from the parameters
                 double freq = 100.0;
                 double start = std::ceil(dateTime.m_TStart * freq); // 100 htz
                 double end = std::floor(dateTime.m_TEnd * freq);    // 100 htz
                 // We assure that timerange is valid
                 if (end < start) {
                     std::swap(start, end);
                 }
                 // Generates scalar series containing cosinus values (one value per second)
                 auto dataCount = end - start;
                 auto xAxisData = QVector<double>{};
                 xAxisData.resize(dataCount);
                 auto valuesData = QVector<double>{};
                 valuesData.resize(dataCount);
                 int progress = 0;
                 auto progressEnd = dataCount;
                 for (auto time = start; time < end; ++time, ++dataIndex) {
                     auto it = m_VariableToEnableProvider.find(token);
                     if (it != m_VariableToEnableProvider.end() && it.value()) {
                         const auto timeOnFreq = time / freq;
                         xAxisData.replace(dataIndex, timeOnFreq);
                         valuesData.replace(dataIndex, std::cos(timeOnFreq));
                         // progression
                         int currentProgress = (time - start) * 100.0 / progressEnd;
                         if (currentProgress != progress) {
                             progress = currentProgress;
                             emit dataProvidedProgress(token, progress);
                         }
                     }
                     else {
                         if (!it.value()) {
                             qCDebug(LOG_CosinusProvider())
                                 << "CosinusProvider::retrieveData: ARRET De l'acquisition detecté"
                                 << end - time;
                         }
                     }
                 }
                 emit dataProvidedProgress(token, 0.0);
                 return std::make_shared<ScalarSeries>(std::move(xAxisData), std::move(valuesData),
                                                       Unit{QStringLiteral("t"), true}, Unit{});
             }
             void CosinusProvider::requestDataLoading(QUuid token, const DataProviderParameters &parameters)
             {
                 // TODO: Add Mutex
                 m_VariableToEnableProvider[token] = true;
                 qCDebug(LOG_CosinusProvider()) << "CosinusProvider::requestDataLoading"
                                                << QThread::currentThread()->objectName();
                 // NOTE: Try to use multithread if possible
                 const auto times = parameters.m_Times;
                 for (const auto &dateTime : qAsConst(times)) {
                     if (m_VariableToEnableProvider[token]) {
                         auto scalarSeries = this->retrieveData(token, dateTime);
                         emit dataProvided(token, scalarSeries, dateTime);
                     }
                 }
             }
             void CosinusProvider::requestDataAborting(QUuid identifier)
             {
                 // TODO: Add Mutex
                 qCDebug(LOG_CosinusProvider()) << "CosinusProvider::requestDataAborting" << identifier
                                                << QThread::currentThread()->objectName();
                 auto it = m_VariableToEnableProvider.find(identifier);
                 if (it != m_VariableToEnableProvider.end()) {
                     it.value() = false;
                 }
                 else {
                     qCWarning(LOG_CosinusProvider())
                         << tr("Aborting progression of inexistant identifier detected !!!");
                 }
             }

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