GIT_REPOSITORIES/LPP/Users/mperrinel/SCIQLOP-Initialisation Commit - r455:a774a1678512

Merge branch 'feature/DateTimeUTC' into develop

Alexandre Leroux -

r455:a774a1678512

parent child

Context file:

r455:a774a1678512

Collapse all files

core/include/Common/DateUtils.h created 644 +19 0

@@ -0,0 +1,19
	1	#ifndef SCIQLOP_DATEUTILS_H
	2	#define SCIQLOP_DATEUTILS_H
	3
	4	#include "CoreGlobal.h"
	5
	6	#include <QDateTime>
	7
	8	/**
	9	* Utility class with methods for dates
	10	*/
	11	struct SCIQLOP_CORE_EXPORT DateUtils {
	12	/// Converts seconds (since epoch) to datetime. By default, the datetime is in UTC
	13	static QDateTime dateTime(double secs, Qt::TimeSpec timeSpec = Qt::UTC) noexcept;
	14
	15	/// Converts datetime to seconds since epoch
	16	static double secondsSinceEpoch(const QDateTime &dateTime) noexcept;
	17	};
	18
	19	#endif // SCIQLOP_DATEUTILS_H

core/src/Common/DateUtils.cpp created 644 +13 0

@@ -0,0 +1,13
	1	#include "Common/DateUtils.h"
	2
	3	QDateTime DateUtils::dateTime(double secs, Qt::TimeSpec timeSpec) noexcept
	4	{
	5	// Uses msecs to be Qt 4 compatible
	6	return QDateTime::fromMSecsSinceEpoch(secs * 1000., timeSpec);
	7	}
	8
	9	double DateUtils::secondsSinceEpoch(const QDateTime &dateTime) noexcept
	10	{
	11	// Uses msecs to be Qt 4 compatible
	12	return dateTime.toMSecsSinceEpoch() / 1000.;
	13	}

app/src/MainWindow.cpp 0 -1

             #include <QAction>
             #include <QDate>
-            #include <QDateTime>
             #include <QDir>
             #include <QFileDialog>
             #include <QToolBar>

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

                 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)
             };
             /**

core/include/Data/SqpDateTime.h +5 -6

             #include <QObject>
-            #include <QDateTime>
             #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
             inline QDebug operator<<(QDebug d, SqpDateTime obj)
             {
-                auto tendDateTimeStart = QDateTime::fromMSecsSinceEpoch(obj.m_TStart * 1000);
+                auto tendDateTimeStart = DateUtils::dateTime(obj.m_TStart);
-                auto tendDateTimeEnd = QDateTime::fromMSecsSinceEpoch(obj.m_TEnd * 1000);
+                auto tendDateTimeEnd = DateUtils::dateTime(obj.m_TEnd);
-                //        QDebug << "ts: " << tendDateTimeStart << " te: " << tendDateTimeEnd;
                 d << "ts: " << tendDateTimeStart << " te: " << tendDateTimeEnd;
                 return d;
             }

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

             #include <Data/IDataSeries.h>
             #include <Time/TimeController.h>
-            #include <QDateTime>
             #include <QMutex>
             #include <QThread>
             #include <QUuid>

core/src/Variable/VariableModel.cpp +4 -3

             #include <Variable/Variable.h>
             #include <Variable/VariableModel.h>
+            #include <Common/DateUtils.h>
             #include <Data/IDataSeries.h>
-            #include <QDateTime>
             #include <QSize>
             #include <unordered_map>
                 if (role == Qt::DisplayRole) {
                     if (auto variable = impl->m_Variables.at(index.row()).get()) {
                         /// Lambda function that builds the variant to return for a time value
-                        auto dateTimeVariant = [](double time) {
+                        auto dateTimeVariant = [](double secs) {
-                            auto dateTime = QDateTime::fromMSecsSinceEpoch(time * 1000.);
+                            auto dateTime = DateUtils::dateTime(secs);
                             return dateTime.toString(DATETIME_FORMAT);
                         };

gui/src/TimeWidget/TimeWidget.cpp +11 -9

             #include "TimeWidget/TimeWidget.h"
             #include "ui_TimeWidget.h"
+            #include <Common/DateUtils.h>
             #include <SqpApplication.h>
             #include <Time/TimeController.h>
                         &TimeController::onTimeNotify);
                 // Initialisation
-                ui->startDateTimeEdit->setDateTime(
+                auto endDateTime = QDateTime::currentDateTimeUtc();
-                    QDateTime::currentDateTime().addSecs(-3600)); // one hour berefore
+                auto startDateTime = endDateTime.addSecs(-3600); // one hour before
-                ui->endDateTimeEdit->setDateTime(QDateTime::currentDateTime());
+                ui->startDateTimeEdit->setDateTime(startDateTime);
+                ui->endDateTimeEdit->setDateTime(endDateTime);
+                auto dateTime = SqpDateTime{DateUtils::secondsSinceEpoch(startDateTime),
+                                            DateUtils::secondsSinceEpoch(endDateTime)};
-                auto dateTime
-                    = SqpDateTime{QDateTime::currentDateTime().addSecs(-3600).toMSecsSinceEpoch() / 1000.0,
-                                  QDateTime::currentDateTime().toMSecsSinceEpoch() / 1000.0};
                 sqpApp->timeController().onTimeToUpdate(dateTime);
             }
             void TimeWidget::onTimeUpdateRequested()
             {
-                auto dateTime = SqpDateTime{
+                auto dateTime = SqpDateTime{DateUtils::secondsSinceEpoch(ui->startDateTimeEdit->dateTime()),
-                    static_cast<double>(ui->startDateTimeEdit->dateTime().toMSecsSinceEpoch() / 1000.),
+                                            DateUtils::secondsSinceEpoch(ui->endDateTimeEdit->dateTime())};
-                    static_cast<double>(ui->endDateTimeEdit->dateTime().toMSecsSinceEpoch()) / 1000.};
                 emit timeUpdated(std::move(dateTime));
             }

gui/src/Visualization/VisualizationGraphHelper.cpp +1 0

                 if (isTimeAxis) {
                     auto dateTicker = QSharedPointer<QCPAxisTickerDateTime>::create();
                     dateTicker->setDateTimeFormat(DATETIME_TICKER_FORMAT);
+                    dateTicker->setDateTimeSpec(Qt::UTC);
                     return dateTicker;
                 }

gui/src/Visualization/VisualizationGraphRenderingDelegate.cpp +8 -3

             #include "Visualization/VisualizationGraphRenderingDelegate.h"
             #include "Visualization/qcustomplot.h"
+            #include <Common/DateUtils.h>
             namespace {
             const auto DATETIME_FORMAT = QStringLiteral("yyyy/MM/dd hh:mm:ss:zzz");
             QString formatValue(double value, const QCPAxis &axis)
             {
                 // If the axis is a time axis, formats the value as a date
-                return qSharedPointerDynamicCast<QCPAxisTickerDateTime>(axis.ticker())
+                if (auto axisTicker = qSharedPointerDynamicCast<QCPAxisTickerDateTime>(axis.ticker())) {
-                           ? QCPAxisTickerDateTime::keyToDateTime(value).toString(DATETIME_FORMAT)
+                    return DateUtils::dateTime(value, axisTicker->dateTimeSpec()).toString(DATETIME_FORMAT);
-                           : QString::number(value);
+                else {
+                    return QString::number(value);
+                }
             }
             void initPointTracerStyle(QCPItemTracer &tracer) noexcept

gui/ui/TimeWidget/TimeWidget.ui +6 0

                  <property name="calendarPopup">
                   <bool>true</bool>
                  </property>
+                 <property name="timeSpec">
+                  <enum>Qt::UTC</enum>
+                 </property>
                 </widget>
                </item>
                <item>
                  <property name="calendarPopup">
                   <bool>true</bool>
                  </property>
+                 <property name="timeSpec">
+                  <enum>Qt::UTC</enum>
+                 </property>
                 </widget>
                </item>
                <item>

plugins/amda/src/AmdaProvider.cpp +2 -1

             #include "AmdaDefs.h"
             #include "AmdaResultParser.h"
+            #include <Common/DateUtils.h>
             #include <Data/DataProviderParameters.h>
             #include <Network/NetworkController.h>
             #include <SqpApplication.h>
             /// Formats a time to a date that can be passed in URL
             QString dateFormat(double sqpDateTime) noexcept
             {
-                auto dateTime = QDateTime::fromMSecsSinceEpoch(sqpDateTime * 1000.);
+                auto dateTime = DateUtils::dateTime(sqpDateTime);
                 return dateTime.toString(AMDA_TIME_FORMAT);
             }

plugins/amda/src/AmdaResultParser.cpp +39 -32

             #include "AmdaResultParser.h"
+            #include <Common/DateUtils.h>
             #include <Data/ScalarSeries.h>
             #include <QDateTime>
             double doubleDate(const QString &stringDate) noexcept
             {
                 auto dateTime = QDateTime::fromString(stringDate, DATE_FORMAT);
-                return dateTime.isValid() ? (dateTime.toMSecsSinceEpoch() / 1000.)
+                dateTime.setTimeSpec(Qt::UTC);
+                return dateTime.isValid() ? DateUtils::secondsSinceEpoch(dateTime)
                                           : std::numeric_limits<double>::quiet_NaN();
             }
+            /// Checks if a line is a comment line
+            bool isCommentLine(const QString &line)
+            {
+                return line.startsWith("#");
+            }
             /**
              * Reads stream to retrieve x-axis unit
              * @param stream the stream to read
             {
                 QString line{};
-                if (stream.readLineInto(&line)) {
+                // Searches unit in the comment lines
+                while (stream.readLineInto(&line) && isCommentLine(line)) {
                     auto match = UNIT_REGEX.match(line);
                     if (match.hasMatch()) {
                         return Unit{match.captured(1), true};
                     }
-                    else {
-                        qCWarning(LOG_AmdaResultParser())
-                            << QObject::tr("Can't read unit: invalid line %1").arg(line);
-                else {
-                    qCWarning(LOG_AmdaResultParser()) << QObject::tr("Can't read unit: end of file");
                 }
+                qCWarning(LOG_AmdaResultParser()) << QObject::tr("The unit could not be found in the file");
                 // Error cases
                 return Unit{{}, true};
             }
                 auto valuesData = QVector<double>{};
                 QString line{};
                 while (stream.readLineInto(&line)) {
-                    auto lineData = line.split(RESULT_LINE_SEPARATOR, QString::SkipEmptyParts);
+                    // Ignore comment lines
-                    if (lineData.size() == 2) {
+                    if (!isCommentLine(line)) {
-                        // X : the data is converted from date to double (in secs)
+                        auto lineData = line.split(RESULT_LINE_SEPARATOR, QString::SkipEmptyParts);
-                        auto x = doubleDate(lineData.at(0));
+                        if (lineData.size() == 2) {
+                            // X : the data is converted from date to double (in secs)
-                        // Value
+                            auto x = doubleDate(lineData.at(0));
-                        bool valueOk;
-                        auto value = lineData.at(1).toDouble(&valueOk);
+                            // Value
+                            bool valueOk;
-                        // Adds result only if x and value are valid
+                            auto value = lineData.at(1).toDouble(&valueOk);
-                        if (!std::isnan(x) && !std::isnan(value) && valueOk) {
-                            xData.push_back(x);
+                            // Adds result only if x and value are valid
-                            valuesData.push_back(value);
+                            if (!std::isnan(x) && !std::isnan(value) && valueOk) {
+                                xData.push_back(x);
+                                valuesData.push_back(value);
+                            }
+                            else {
+                                qCWarning(LOG_AmdaResultParser())
+                                    << QObject::tr(
+                                           "Can't retrieve results from line %1: x and/or value are invalid")
+                                           .arg(line);
+                            }
                         }
                         else {
                             qCWarning(LOG_AmdaResultParser())
-                                << QObject::tr(
+                                << QObject::tr("Can't retrieve results from line %1: invalid line").arg(line);
-                                       "Can't retrieve results from line %1: x and/or value are invalid")
-                                       .arg(line);
                         }
                     }
-                    else {
-                        qCWarning(LOG_AmdaResultParser())
-                            << QObject::tr("Can't retrieve results from line %1: invalid line").arg(line);
                 }
                 return qMakePair(std::move(xData), std::move(valuesData));
                     return nullptr;
                 }
-                // Ignore comments lines
-                stream.readLine();
                 // Reads x-axis unit
+                stream.seek(0); // returns to the beginning of the file
                 auto xAxisUnit = readXAxisUnit(stream);
                 // Reads results
+                stream.seek(0); // returns to the beginning of the file
                 auto results = readResults(stream);
                 return std::make_shared<ScalarSeries>(std::move(results.first), std::move(results.second),

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

                 // ////////// //
                 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

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

             #include <cmath>
-            #include <QDateTime>
             #include <QFuture>
             #include <QThread>
             #include <QtConcurrent/QtConcurrent>

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