HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r1346:d8cb4bff8c14

Renamed SqpRange to DateTimeRange, introduced VariableController2 to...

jeandet -

r1346:d8cb4bff8c14

parent child

Context file:

r1346:d8cb4bff8c14

core/include/Common/Numeric.h created 644 +18 0

@@ -0,0 +1,18
	1	#include <cmath>
	2	#include <limits>
	3	#include <type_traits>
	4	#include <algorithm>
	5
	6	/*
	7	taken from here https://en.cppreference.com/w/cpp/types/numeric_limits/epsilon
	8	*/
	9	template<class T>
	10	typename std::enable_if<!std::numeric_limits<T>::is_integer, bool>::type
	11	almost_equal(T x, T y, int ulp)
	12	{
	13	// the machine epsilon has to be scaled to the magnitude of the values used
	14	// and multiplied by the desired precision in ULPs (units in the last place)
	15	return std::abs(x-y) <= std::numeric_limits<T>::epsilon() * std::abs(x+y) * ulp
	16	// unless the result is subnormal
	17	\|\| std::abs(x-y) < std::numeric_limits<T>::min();
	18	}

core/include/Variable/VariableController2.h created 644 +32 0

@@ -0,0 +1,32
	1	#include <memory>
	2	#include <vector>
	3	#include <QHash>
	4	#include <Variable/Variable.h>
	5	#include <Variable/VariableSynchronizationGroup.h>
	6	#include "Data/SqpRange.h"
	7	#include <QMutexLocker>
	8	#include <QUuid>
	9
	10	class VariableController2
	11	{
	12
	13	QHash<QUuid, std::shared_ptr<Variable>> _variables;
	14	QMutex _variables_lock;
	15
	16	std::vector<std::unique_ptr<VariableSynchronizationGroup>> _groups;
	17	QMutex _variables_groups_lock;
	18	public:
	19
	20	QUuid addVariable(std::shared_ptr<Variable> variable)
	21	{
	22	QMutexLocker lock(&_variables_lock);
	23	QMutexLocker glock(&_variables_groups_lock);
	24
	25	QUuid uuid = QUuid::createUuid();
	26	this->_variables[uuid] = variable;
	27	this->_groups.push_back(std::make_unique<VariableSynchronizationGroup>(uuid));
	28	return uuid;
	29	}
	30	void changeRange(int variable, DateTimeRange r);
	31	void asyncChangeRange(int variable, DateTimeRange r);
	32	};

core/src/Variable/VariableController2.cpp created 644 +1 0

	@@ -0,0 +1,1
				1	#include "Variable/VariableController2.h"

core/tests/Variable/TestVariableController2.cpp created 644 +30 0

@@ -0,0 +1,30
	1	#include <QtTest>
	2	#include <QObject>
	3
	4
	5	class TestVariableController2 : public QObject
	6
	7	{
	8	Q_OBJECT
	9	public:
	10	explicit TestVariableController2(QObject *parent = nullptr) : QObject(parent){}
	11	signals:
	12
	13	private slots:
	14	void initTestCase(){}
	15	void cleanupTestCase(){}
	16
	17	void test1()
	18	{
	19	QCOMPARE(1+1, 2);
	20	}
	21
	22	private:
	23
	24	};
	25
	26
	27	QTEST_MAIN(TestVariableController2)
	28
	29	#include "TestVariableController2.moc"
	30

plugins/amda/tests/PyTestAmdaWrapper.h created 644 +38 0

@@ -0,0 +1,38
	1	/*------------------------------------------------------------------------------
	2	-- This file is a part of the SciQLOP Software
	3	-- Copyright (C) 2018, Plasma Physics Laboratory - CNRS
	4	--
	5	-- This program is free software; you can redistribute it and/or modify
	6	-- it under the terms of the GNU General Public License as published by
	7	-- the Free Software Foundation; either version 2 of the License, or
	8	-- (at your option) any later version.
	9	--
	10	-- This program is distributed in the hope that it will be useful,
	11	-- but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	-- GNU General Public License for more details.
	14	--
	15	-- You should have received a copy of the GNU General Public License
	16	-- along with this program; if not, write to the Free Software
	17	-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	18	-------------------------------------------------------------------------------*/
	19	/*-- Author : Alexis Jeandet
	20	-- Mail : alexis.jeandet@member.fsf.org
	21	----------------------------------------------------------------------------*/
	22	#include <string>
	23
	24	#include <pybind11/pybind11.h>
	25	#include <pybind11/embed.h>
	26
	27	namespace py = pybind11;
	28
	29
	30	int pytestamda_test(const char* testScriptPath )
	31	{
	32	py::scoped_interpreter guard{};
	33	py::globals()["__file__"] = py::str(testScriptPath);
	34	py::eval_file(testScriptPath);
	35	return 0;
	36	}
	37
	38

.gitignore +3 0

 rdparty/
             subprojects/CatalogueAPI/
             subprojects/QxOrm/
+            documentation/*
+            .idea/*
+            **/__pycache__/*

app/src/MainWindow.cpp +6 -6

                 // /////////// //
                 // Controllers / controllers connections
-                connect(&sqpApp->timeController(), SIGNAL(timeUpdated(SqpRange)), &sqpApp->variableController(),
+                connect(&sqpApp->timeController(), SIGNAL(timeUpdated(DateTimeRange)), &sqpApp->variableController(),
-                        SLOT(onDateTimeOnSelection(SqpRange)));
+                        SLOT(onDateTimeOnSelection(DateTimeRange)));
                 // Widgets / controllers connections
                         m_Ui->dataSourceWidget, SLOT(addDataSource(DataSourceItem *)));
                 // Time
-                connect(timeWidget, SIGNAL(timeUpdated(SqpRange)), &sqpApp->timeController(),
+                connect(timeWidget, SIGNAL(timeUpdated(DateTimeRange)), &sqpApp->timeController(),
-                        SLOT(onTimeToUpdate(SqpRange)));
+                        SLOT(onTimeToUpdate(DateTimeRange)));
                 // Visualization
                 connect(&sqpApp->visualizationController(),
                         SLOT(onVariableAboutToBeDeleted(std::shared_ptr<Variable>)));
                 connect(&sqpApp->visualizationController(),
-                        SIGNAL(rangeChanged(std::shared_ptr<Variable>, const SqpRange &)), m_Ui->view,
+                        SIGNAL(rangeChanged(std::shared_ptr<Variable>, const DateTimeRange &)), m_Ui->view,
-                        SLOT(onRangeChanged(std::shared_ptr<Variable>, const SqpRange &)));
+                        SLOT(onRangeChanged(std::shared_ptr<Variable>, const DateTimeRange &)));
                 // Widgets / widgets connections

core/CMakeLists.txt +4 0

                 ./include/Common/StringUtils.h
                 ./include/Common/SignalWaiter.h
                 ./include/Common/DateUtils.h
+                ./include/Common/Numeric.h
                 ./include/Plugin/IPlugin.h
                 ./include/Data/ArrayDataIterator.h
                 ./include/Data/VariableRequest.h
                 ./include/Data/IDataProvider.h
                 ./include/Data/IDataSeries.h
                 ./include/Network/NetworkController.h
+                ./include/Network/Downloader.h
                 ./include/Version.h
                 ./include/CoreGlobal.h
                 ./include/Catalogue/CatalogueController.h
                 ./include/Variable/Variable.h
                 ./include/Variable/VariableCacheController.h
                 ./include/Variable/VariableController.h
+                ./include/Variable/VariableController2.h
                 ./include/Time/TimeController.h
                 ./include/Settings/ISqpSettingsBindable.h
                 ./include/Settings/SqpSettingsDefs.h
                 ./src/Visualization/VisualizationController.cpp
                 ./src/PluginManager/PluginManager.cpp
                 ./src/Variable/VariableController.cpp
+                ./src/Variable/VariableController2.cpp
                 ./src/Variable/VariableModel.cpp
                 ./src/Variable/VariableCacheController.cpp
                 ./src/Variable/VariableSynchronizationGroup.cpp

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

              */
             struct AcquisitionDataPacket {
                 std::shared_ptr<IDataSeries> m_DateSeries;
-                SqpRange m_Range;
+                DateTimeRange m_Range;
             };
             SCIQLOP_REGISTER_META_TYPE(ACQUISITIONDATAPACKET_REGISTRY, AcquisitionDataPacket)

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

                 QUuid m_AcqIdentifier;
                 QUuid m_vIdentifier;
                 DataProviderParameters m_DataProviderParameters;
-                SqpRange m_RangeRequested;
+                DateTimeRange m_RangeRequested;
-                SqpRange m_CacheRangeRequested;
+                DateTimeRange m_CacheRangeRequested;
                 int m_Size;
                 int m_Progression;
                 std::shared_ptr<IDataProvider> m_Provider;

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

              */
             struct DataProviderParameters {
                 /// Times for which retrieve data
-                QVector<SqpRange> m_Times;
+                QVector<DateTimeRange> m_Times;
                 /// Extra data that can be used by the provider to retrieve data
                 QVariantHash m_Data;
             };

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

                  * identified by acqIdentifier
                  */
                 void dataProvided(QUuid acqIdentifier, std::shared_ptr<IDataSeries> dateSeriesAcquired,
-                                  const SqpRange &dataRangeAcquired);
+                                  const DateTimeRange &dataRangeAcquired);
                 /**
                  * @brief dataProvidedProgress notify the progression of the data identifier by acqIdentifier

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

                 virtual void purge(double min, double max) = 0;
                 /// @todo Review the name and signature of this method
-                virtual std::shared_ptr<IDataSeries> subDataSeries(const SqpRange &range) = 0;
+                virtual std::shared_ptr<IDataSeries> subDataSeries(const DateTimeRange &range) = 0;
                 virtual std::unique_ptr<IDataSeries> clone() const = 0;

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

                 std::unique_ptr<IDataSeries> clone() const override;
-                std::shared_ptr<IDataSeries> subDataSeries(const SqpRange &range) override;
+                std::shared_ptr<IDataSeries> subDataSeries(const DateTimeRange &range) override;
             };
             #endif // SCIQLOP_SCALARSERIES_H

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

                 std::unique_ptr<IDataSeries> clone() const override;
                 /// @sa DataSeries::subDataSeries()
-                std::shared_ptr<IDataSeries> subDataSeries(const SqpRange &range) override;
+                std::shared_ptr<IDataSeries> subDataSeries(const DateTimeRange &range) override;
                 inline double xResolution() const noexcept { return m_XResolution; }

core/include/Data/SqpRange.h +11 -9

             /**
              * @brief The SqpRange struct holds the information of time parameters
              */
-            struct SqpRange {
+            struct DateTimeRange {
                 /// Creates SqpRange from dates and times
-                static SqpRange fromDateTime(const QDate &startDate, const QTime &startTime,
+                static DateTimeRange fromDateTime(const QDate &startDate, const QTime &startTime,
                                              const QDate &endDate, const QTime &endTime)
                 {
                     return {DateUtils::secondsSinceEpoch(QDateTime{startDate, startTime, Qt::UTC}),
                 /// End time (UTC)
                 double m_TEnd;
-                bool contains(const SqpRange &dateTime) const noexcept
+                double delta()const {return this->m_TEnd - this->m_TStart;}
+                bool contains(const DateTimeRange &dateTime) const noexcept
                 {
                     return (m_TStart <= dateTime.m_TStart && m_TEnd >= dateTime.m_TEnd);
                 }
-                bool intersect(const SqpRange &dateTime) const noexcept
+                bool intersect(const DateTimeRange &dateTime) const noexcept
                 {
                     return (m_TEnd >= dateTime.m_TStart && m_TStart <= dateTime.m_TEnd);
                 }
-                bool operator==(const SqpRange &other) const
+                bool operator==(const DateTimeRange &other) const
                 {
                     auto equals = [](const auto &v1, const auto &v2) {
                         return (std::isnan(v1) && std::isnan(v2)) || v1 == v2;
                     return equals(m_TStart, other.m_TStart) && equals(m_TEnd, other.m_TEnd);
                 }
-                bool operator!=(const SqpRange &other) const { return !(*this == other); }
+                bool operator!=(const DateTimeRange &other) const { return !(*this == other); }
             };
             const auto INVALID_RANGE
-                = SqpRange{std::numeric_limits<double>::quiet_NaN(), std::numeric_limits<double>::quiet_NaN()};
+                = DateTimeRange{std::numeric_limits<double>::quiet_NaN(), std::numeric_limits<double>::quiet_NaN()};
-            inline QDebug operator<<(QDebug d, SqpRange obj)
+            inline QDebug operator<<(QDebug d, DateTimeRange obj)
             {
                 auto tendDateTimeStart = DateUtils::dateTime(obj.m_TStart);
                 auto tendDateTimeEnd = DateUtils::dateTime(obj.m_TEnd);
             }
             // Required for using shared_ptr in signals/slots
-            SCIQLOP_REGISTER_META_TYPE(SQPRANGE_REGISTRY, SqpRange)
+            SCIQLOP_REGISTER_META_TYPE(SQPRANGE_REGISTRY, DateTimeRange)
             #endif // SCIQLOP_SQPRANGE_H

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

              */
             struct VariableRequest {
                 QUuid m_VariableGroupId;
-                SqpRange m_RangeRequested;
+                DateTimeRange m_RangeRequested;
-                SqpRange m_CacheRangeRequested;
+                DateTimeRange m_CacheRangeRequested;
                 std::shared_ptr<IDataSeries> m_DataSeries;
             };

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

                 std::unique_ptr<IDataSeries> clone() const;
-                std::shared_ptr<IDataSeries> subDataSeries(const SqpRange &range) override;
+                std::shared_ptr<IDataSeries> subDataSeries(const DateTimeRange &range) override;
             };
             #endif // SCIQLOP_VECTORSERIES_H

core/include/Network/Downloader.h +34 0

@@ -14,11 +14,45
14		14
15	/**	15	/**
16	* @brief The Downloader handles all data donwloads in SciQLOP.	16	* @brief The Downloader handles all data donwloads in SciQLOP.
		17	*
		18	* Simple synchronous GET example:
		19	* @code{.cpp}
		20	* auto response = Downloader::get("http://example.com")
		21	* std::cout << "Status code: " << response.status_code() << std::endl << "Data: " << response.data().toStdString() << std::endl;
		22	* @endcode
		23	*
		24	* @note
		25	* This is a quick and KISS implementation using QNetworkAccessManager isolating from Qt stuff (Signal/slots).
		26	* This could be impemented with a different backend in the future.
		27	*
		28	* @sa Response
17	*/	29	*/
18	class SCIQLOP_CORE_EXPORT Downloader{	30	class SCIQLOP_CORE_EXPORT Downloader{
19	public:	31	public:
		32	/**
		33	* @brief does a synchronous GET request on the given url
		34	* @param url
		35	* @param user
		36	* @param passwd
		37	* @return Response object containing request data and http status code
		38	* @sa Downloader::getAsync
		39	*/
20	static Response get(const QString& url, const QString& user="", const QString& passwd="");	40	static Response get(const QString& url, const QString& user="", const QString& passwd="");
		41	/**
		42	* @brief does an asynchronous GET request on the given url
		43	* @param url
		44	* @param callback
		45	* @param user
		46	* @param passwd
		47	* @return QUuid an unique identifier associated to this request
		48	* @sa Downloader::get, Downloader::downloadFinished
		49	*/
21	static QUuid getAsync(const QString& url, std::function<void (QUuid, Response)> callback, const QString& user="", const QString& passwd="");	50	static QUuid getAsync(const QString& url, std::function<void (QUuid, Response)> callback, const QString& user="", const QString& passwd="");
		51	/**
		52	* @brief downloadFinished
		53	* @param uuid
		54	* @return true if the request associated to this uuid is complete
		55	*/
22	static bool downloadFinished(QUuid uuid);	56	static bool downloadFinished(QUuid uuid);
23		57
24	static Downloader& instance()	58	static Downloader& instance()

core/include/Time/TimeController.h +5 -5

             public:
                 explicit TimeController(QObject *parent = 0);
-                SqpRange dateTime() const noexcept;
+                DateTimeRange dateTime() const noexcept;
                 /// Returns the MIME data associated to a time range
-                static QByteArray mimeDataForTimeRange(const SqpRange &timeRange);
+                static QByteArray mimeDataForTimeRange(const DateTimeRange &timeRange);
                 /// Returns the time range contained in a MIME data
-                static SqpRange timeRangeForMimeData(const QByteArray &mimeData);
+                static DateTimeRange timeRangeForMimeData(const QByteArray &mimeData);
             signals:
                 /// Signal emitted to notify that time parameters has beed updated
-                void timeUpdated(SqpRange time);
+                void timeUpdated(DateTimeRange time);
             public slots:
                 /// Slot called when a new dateTime has been defined.
-                void setDateTimeRange(SqpRange dateTime);
+                void setDateTimeRange(DateTimeRange dateTime);
                 /// Slot called when the dateTime has to be notified. Call timeUpdated signal
                 void onTimeNotify();

core/include/Variable/Variable.h +17 -17

                 QString name() const noexcept;
                 void setName(const QString &name) noexcept;
-                SqpRange range() const noexcept;
+                DateTimeRange range() const noexcept;
-                void setRange(const SqpRange &range) noexcept;
+                void setRange(const DateTimeRange &range) noexcept;
-                SqpRange cacheRange() const noexcept;
+                DateTimeRange cacheRange() const noexcept;
-                void setCacheRange(const SqpRange &cacheRange) noexcept;
+                void setCacheRange(const DateTimeRange &cacheRange) noexcept;
                 /// @return the number of points hold by the variable. The number of points is updated each time
                 /// the data series changes
                 /// @return the real range, invalid range if the data series is null or empty
                 /// @sa setDataSeries()
                 /// @sa setRange()
-                SqpRange realRange() const noexcept;
+                DateTimeRange realRange() const noexcept;
                 /// @return the data of the variable, nullptr if there is no data
                 std::shared_ptr<IDataSeries> dataSeries() const noexcept;
                 QVariantHash metadata() const noexcept;
-                bool contains(const SqpRange &range) const noexcept;
+                bool contains(const DateTimeRange &range) const noexcept;
-                bool intersect(const SqpRange &range) const noexcept;
+                bool intersect(const DateTimeRange &range) const noexcept;
-                bool isInside(const SqpRange &range) const noexcept;
+                bool isInside(const DateTimeRange &range) const noexcept;
-                bool cacheContains(const SqpRange &range) const noexcept;
+                bool cacheContains(const DateTimeRange &range) const noexcept;
-                bool cacheIntersect(const SqpRange &range) const noexcept;
+                bool cacheIntersect(const DateTimeRange &range) const noexcept;
-                bool cacheIsInside(const SqpRange &range) const noexcept;
+                bool cacheIsInside(const DateTimeRange &range) const noexcept;
-                QVector<SqpRange> provideNotInCacheRangeList(const SqpRange &range) const noexcept;
+                QVector<DateTimeRange> provideNotInCacheRangeList(const DateTimeRange &range) const noexcept;
-                QVector<SqpRange> provideInCacheRangeList(const SqpRange &range) const noexcept;
+                QVector<DateTimeRange> provideInCacheRangeList(const DateTimeRange &range) const noexcept;
                 void mergeDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept;
-                static QVector<SqpRange> provideNotInCacheRangeList(const SqpRange &oldRange,
+                static QVector<DateTimeRange> provideNotInCacheRangeList(const DateTimeRange &oldRange,
-                                                                    const SqpRange &nextRange);
+                                                                    const DateTimeRange &nextRange);
-                static QVector<SqpRange> provideInCacheRangeList(const SqpRange &oldRange,
+                static QVector<DateTimeRange> provideInCacheRangeList(const DateTimeRange &oldRange,
-                                                                 const SqpRange &nextRange);
+                                                                 const DateTimeRange &nextRange);
             signals:
                 void updated();

core/include/Variable/VariableAcquisitionWorker.h +5 -5

                 explicit VariableAcquisitionWorker(QObject *parent = 0);
                 virtual ~VariableAcquisitionWorker();
-                QUuid pushVariableRequest(QUuid varRequestId, QUuid vIdentifier, SqpRange rangeRequested,
+                QUuid pushVariableRequest(QUuid varRequestId, QUuid vIdentifier, DateTimeRange rangeRequested,
-                                          SqpRange cacheRangeRequested, DataProviderParameters parameters,
+                                          DateTimeRange cacheRangeRequested, DataProviderParameters parameters,
                                           std::shared_ptr<IDataProvider> provider);
                 void abortProgressRequested(QUuid vIdentifier);
                 void initialize();
                 void finalize();
             signals:
-                void dataProvided(QUuid vIdentifier, const SqpRange &rangeRequested,
+                void dataProvided(QUuid vIdentifier, const DateTimeRange &rangeRequested,
-                                  const SqpRange &cacheRangeRequested,
+                                  const DateTimeRange &cacheRangeRequested,
                                   QVector<AcquisitionDataPacket> dataAcquired);
                 void variableRequestInProgress(QUuid vIdentifier, double progress);
             public slots:
                 void onVariableDataAcquired(QUuid acqIdentifier, std::shared_ptr<IDataSeries> dataSeries,
-                                            SqpRange dataRangeAcquired);
+                                            DateTimeRange dataRangeAcquired);
                 void onVariableRetrieveDataInProgress(QUuid acqIdentifier, double progress);
                 void onVariableAcquisitionFailed(QUuid acqIdentifier);

core/include/Variable/VariableCacheController.h +4 -4

                 explicit VariableCacheController(QObject *parent = 0);
-                void addDateTime(std::shared_ptr<Variable> variable, const SqpRange &dateTime);
+                void addDateTime(std::shared_ptr<Variable> variable, const DateTimeRange &dateTime);
                 /// Clears cache concerning a variable
                 void clear(std::shared_ptr<Variable> variable) noexcept;
                 /// Return all of the SqpDataTime part of the dateTime whose are not in the cache
-                QVector<SqpRange> provideNotInCacheDateTimeList(std::shared_ptr<Variable> variable,
+                QVector<DateTimeRange> provideNotInCacheDateTimeList(std::shared_ptr<Variable> variable,
-                                                                const SqpRange &dateTime);
+                                                                const DateTimeRange &dateTime);
-                QVector<SqpRange> dateCacheList(std::shared_ptr<Variable> variable) const noexcept;
+                QVector<DateTimeRange> dateCacheList(std::shared_ptr<Variable> variable) const noexcept;
                 void displayCache(std::shared_ptr<Variable> variable) const;

core/include/Variable/VariableCacheStrategy.h +2 -2

             public:
                 virtual ~VariableCacheStrategy() noexcept = default;
-                virtual std::pair<SqpRange, SqpRange> computeRange(const SqpRange &vRange,
+                virtual std::pair<DateTimeRange, DateTimeRange> computeRange(const DateTimeRange &vRange,
-                                                                   const SqpRange &rangeRequested)
+                                                                   const DateTimeRange &rangeRequested)
                     = 0;
             };

core/include/Variable/VariableController.h +9 -9

                 /// Returns the list of variables contained in a MIME data
                 QList<std::shared_ptr<Variable> > variablesForMimeData(const QByteArray &mimeData) const;
-                static AcquisitionZoomType getZoomType(const SqpRange &range, const SqpRange &oldRange);
+                static AcquisitionZoomType getZoomType(const DateTimeRange &range, const DateTimeRange &oldRange);
                 /// Returns True if there are pending downloads
                 bool hasPendingDownloads();
                 void variableAboutToBeDeleted(std::shared_ptr<Variable> variable);
                 /// Signal emitted when a data acquisition is requested on a range for a variable
-                void rangeChanged(std::shared_ptr<Variable> variable, const SqpRange &range);
+                void rangeChanged(std::shared_ptr<Variable> variable, const DateTimeRange &range);
                 /// Signal emitted when a sub range of the cacheRange of the variable can be displayed
-                void updateVarDisplaying(std::shared_ptr<Variable> variable, const SqpRange &range);
+                void updateVarDisplaying(std::shared_ptr<Variable> variable, const DateTimeRange &range);
                 /// Signal emitted when all acquisitions related to the variables have been completed (whether
                 /// validated, canceled, or failed)
                 void deleteVariables(const QVector<std::shared_ptr<Variable> > &variables) noexcept;
                 /// Request the data loading of the variable whithin range
-                void onRequestDataLoading(QVector<std::shared_ptr<Variable> > variables, const SqpRange &range,
+                void onRequestDataLoading(QVector<std::shared_ptr<Variable> > variables, const DateTimeRange &range,
                                           bool synchronise);
                 /**
                  * Creates a new variable and adds it to the model
                  * @return the pointer to the new variable or nullptr if the creation failed
                  */
                 std::shared_ptr<Variable> createVariable(const QString &name, const QVariantHash &metadata,
-                                                         std::shared_ptr<IDataProvider> provider, const SqpRange &range) noexcept;
+                                                         std::shared_ptr<IDataProvider> provider, const DateTimeRange &range) noexcept;
                 /// Update the temporal parameters of every selected variable to dateTime
-                void onDateTimeOnSelection(const SqpRange &dateTime);
+                void onDateTimeOnSelection(const DateTimeRange &dateTime);
                 /// Update the temporal parameters of the specified variable
-                void onUpdateDateTime(std::shared_ptr<Variable> variable, const SqpRange &dateTime);
+                void onUpdateDateTime(std::shared_ptr<Variable> variable, const DateTimeRange &dateTime);
-                void onDataProvided(QUuid vIdentifier, const SqpRange &rangeRequested,
+                void onDataProvided(QUuid vIdentifier, const DateTimeRange &rangeRequested,
-                                    const SqpRange &cacheRangeRequested,
+                                    const DateTimeRange &cacheRangeRequested,
                                     QVector<AcquisitionDataPacket> dataAcquired);
                 void onVariableRetrieveDataInProgress(QUuid identifier, double progress);

core/include/Variable/VariableModel.h +1 -1

             signals:
                 void abortProgessRequested(std::shared_ptr<Variable> variable);
                 void requestVariable(const QVariantHash &productData);
-                void requestVariableRangeUpdate(std::shared_ptr<Variable> variable, const SqpRange &range);
+                void requestVariableRangeUpdate(std::shared_ptr<Variable> variable, const DateTimeRange &range);
             private:
                 class VariableModelPrivate;

core/include/Variable/VariableSingleThresholdCacheStrategy.h +4 -4

             public:
                 VariableSingleThresholdCacheStrategy() = default;
-                std::pair<SqpRange, SqpRange> computeRange(const SqpRange &vRange,
+                std::pair<DateTimeRange, DateTimeRange> computeRange(const DateTimeRange &vRange,
-                                                           const SqpRange &rangeRequested) override
+                                                           const DateTimeRange &rangeRequested) override
                 {
-                    auto varRanges = std::pair<SqpRange, SqpRange>{};
+                    auto varRanges = std::pair<DateTimeRange, DateTimeRange>{};
                     auto toleranceFactor = SqpSettings::toleranceValue(
                         GENERAL_TOLERANCE_AT_UPDATE_KEY, GENERAL_TOLERANCE_AT_UPDATE_DEFAULT_VALUE);
                     varRanges.first = rangeRequested;
                     varRanges.second
-                        = SqpRange{rangeRequested.m_TStart - tolerance, rangeRequested.m_TEnd + tolerance};
+                        = DateTimeRange{rangeRequested.m_TStart - tolerance, rangeRequested.m_TEnd + tolerance};
                     return varRanges;
                 }

core/include/Variable/VariableSynchronizationGroup.h +4 -3

             class SCIQLOP_CORE_EXPORT VariableSynchronizationGroup : public QObject {
                 Q_OBJECT
             public:
-                explicit VariableSynchronizationGroup(QObject *parent = 0);
+                explicit VariableSynchronizationGroup(QObject *parent = Q_NULLPTR);
+                explicit VariableSynchronizationGroup(QUuid variable, QObject *parent = Q_NULLPTR);
-                void addVariableId(QUuid vIdentifier);
+                void addVariable(QUuid vIdentifier);
-                void removeVariableId(QUuid vIdentifier);
+                void removeVariable(QUuid vIdentifier);
                 const std::set<QUuid> &getIds() const noexcept;

core/include/Visualization/VisualizationController.h +1 -1

                 void variableAboutToBeDeleted(std::shared_ptr<Variable> variable);
                 /// Signal emitted when a data acquisition is requested on a range for a variable
-                void rangeChanged(std::shared_ptr<Variable> variable, const SqpRange &range);
+                void rangeChanged(std::shared_ptr<Variable> variable, const DateTimeRange &range);
             public slots:
                 /// Manage init/end of the controller

core/src/Data/ScalarSeries.cpp +1 -1

                 return std::make_unique<ScalarSeries>(*this);
             }
-            std::shared_ptr<IDataSeries> ScalarSeries::subDataSeries(const SqpRange &range)
+            std::shared_ptr<IDataSeries> ScalarSeries::subDataSeries(const DateTimeRange &range)
             {
                 auto subXAxisData = std::vector<double>();
                 auto subValuesData = std::vector<double>();

core/src/Data/SpectrogramSeries.cpp +1 -1

                 return std::make_unique<SpectrogramSeries>(*this);
             }
-            std::shared_ptr<IDataSeries> SpectrogramSeries::subDataSeries(const SqpRange &range)
+            std::shared_ptr<IDataSeries> SpectrogramSeries::subDataSeries(const DateTimeRange &range)
             {
                 auto subXAxisData = std::vector<double>();
                 auto subValuesData = QVector<double>(); // Uses QVector to append easily values to it

core/src/Data/VectorSeries.cpp +1 -1

                 return std::make_unique<VectorSeries>(*this);
             }
-            std::shared_ptr<IDataSeries> VectorSeries::subDataSeries(const SqpRange &range)
+            std::shared_ptr<IDataSeries> VectorSeries::subDataSeries(const DateTimeRange &range)
             {
                 auto subXAxisData = std::vector<double>();
                 auto subValuesData = std::vector<double>();

core/src/Time/TimeController.cpp +6 -6

             struct TimeController::TimeControllerPrivate {
-                SqpRange m_DateTime;
+                DateTimeRange m_DateTime;
             };
             TimeController::TimeController(QObject *parent)
                 qCDebug(LOG_TimeController()) << tr("TimeController construction");
             }
-            SqpRange TimeController::dateTime() const noexcept
+            DateTimeRange TimeController::dateTime() const noexcept
             {
                 return impl->m_DateTime;
             }
-            QByteArray TimeController::mimeDataForTimeRange(const SqpRange &timeRange)
+            QByteArray TimeController::mimeDataForTimeRange(const DateTimeRange &timeRange)
             {
                 QByteArray encodedData;
                 QDataStream stream{&encodedData, QIODevice::WriteOnly};
                 return encodedData;
             }
-            SqpRange TimeController::timeRangeForMimeData(const QByteArray &mimeData)
+            DateTimeRange TimeController::timeRangeForMimeData(const QByteArray &mimeData)
             {
                 QDataStream stream{mimeData};
-                SqpRange timeRange;
+                DateTimeRange timeRange;
                 stream >> timeRange.m_TStart >> timeRange.m_TEnd;
                 return timeRange;
             }
-            void TimeController::setDateTimeRange(SqpRange dateTime)
+            void TimeController::setDateTimeRange(DateTimeRange dateTime)
             {
                 impl->m_DateTime = dateTime;
             }

core/src/Variable/Variable.cpp +39 -39

                         m_RealRange
                             = (minXAxisIt != end && maxXAxisIt != end && minXAxisIt->x() <= maxXAxisIt->x())
-                                  ? SqpRange{minXAxisIt->x(), maxXAxisIt->x()}
+                                  ? DateTimeRange{minXAxisIt->x(), maxXAxisIt->x()}
                                   : INVALID_RANGE;
                         m_DataSeries->unlock();
                     }
                 QString m_Name;
-                SqpRange m_Range;
+                DateTimeRange m_Range;
-                SqpRange m_CacheRange;
+                DateTimeRange m_CacheRange;
                 QVariantHash m_Metadata;
                 std::shared_ptr<IDataSeries> m_DataSeries;
-                SqpRange m_RealRange;
+                DateTimeRange m_RealRange;
                 int m_NbPoints;
                 DataSeriesType m_Type;
                 impl->unlock();
             }
-            SqpRange Variable::range() const noexcept
+            DateTimeRange Variable::range() const noexcept
             {
                 impl->lockRead();
                 auto range = impl->m_Range;
                 return range;
             }
-            void Variable::setRange(const SqpRange &range) noexcept
+            void Variable::setRange(const DateTimeRange &range) noexcept
             {
                 impl->lockWrite();
                 impl->m_Range = range;
                 impl->unlock();
             }
-            SqpRange Variable::cacheRange() const noexcept
+            DateTimeRange Variable::cacheRange() const noexcept
             {
                 impl->lockRead();
                 auto cacheRange = impl->m_CacheRange;
                 return cacheRange;
             }
-            void Variable::setCacheRange(const SqpRange &cacheRange) noexcept
+            void Variable::setCacheRange(const DateTimeRange &cacheRange) noexcept
             {
                 impl->lockWrite();
                 if (cacheRange != impl->m_CacheRange) {
                 return impl->m_NbPoints;
             }
-            SqpRange Variable::realRange() const noexcept
+            DateTimeRange Variable::realRange() const noexcept
             {
                 return impl->m_RealRange;
             }
                 return metadata;
             }
-            bool Variable::contains(const SqpRange &range) const noexcept
+            bool Variable::contains(const DateTimeRange &range) const noexcept
             {
                 impl->lockRead();
                 auto res = impl->m_Range.contains(range);
                 return res;
             }
-            bool Variable::intersect(const SqpRange &range) const noexcept
+            bool Variable::intersect(const DateTimeRange &range) const noexcept
             {
                 impl->lockRead();
                 return res;
             }
-            bool Variable::isInside(const SqpRange &range) const noexcept
+            bool Variable::isInside(const DateTimeRange &range) const noexcept
             {
                 impl->lockRead();
-                auto res = range.contains(SqpRange{impl->m_Range.m_TStart, impl->m_Range.m_TEnd});
+                auto res = range.contains(DateTimeRange{impl->m_Range.m_TStart, impl->m_Range.m_TEnd});
                 impl->unlock();
                 return res;
             }
-            bool Variable::cacheContains(const SqpRange &range) const noexcept
+            bool Variable::cacheContains(const DateTimeRange &range) const noexcept
             {
                 impl->lockRead();
                 auto res = impl->m_CacheRange.contains(range);
                 return res;
             }
-            bool Variable::cacheIntersect(const SqpRange &range) const noexcept
+            bool Variable::cacheIntersect(const DateTimeRange &range) const noexcept
             {
                 impl->lockRead();
                 auto res = impl->m_CacheRange.intersect(range);
                 return res;
             }
-            bool Variable::cacheIsInside(const SqpRange &range) const noexcept
+            bool Variable::cacheIsInside(const DateTimeRange &range) const noexcept
             {
                 impl->lockRead();
-                auto res = range.contains(SqpRange{impl->m_CacheRange.m_TStart, impl->m_CacheRange.m_TEnd});
+                auto res = range.contains(DateTimeRange{impl->m_CacheRange.m_TStart, impl->m_CacheRange.m_TEnd});
                 impl->unlock();
                 return res;
             }
-            QVector<SqpRange> Variable::provideNotInCacheRangeList(const SqpRange &range) const noexcept
+            QVector<DateTimeRange> Variable::provideNotInCacheRangeList(const DateTimeRange &range) const noexcept
             {
                 // This code assume that cach in contigue. Can return 0, 1 or 2 SqpRange
-                auto notInCache = QVector<SqpRange>{};
+                auto notInCache = QVector<DateTimeRange>{};
                 if (impl->m_CacheRange != INVALID_RANGE) {
                     if (!this->cacheContains(range)) {
                         }
                         else if (range.m_TStart < impl->m_CacheRange.m_TStart
                                  && range.m_TEnd <= impl->m_CacheRange.m_TEnd) {
-                            notInCache << SqpRange{range.m_TStart, impl->m_CacheRange.m_TStart};
+                            notInCache << DateTimeRange{range.m_TStart, impl->m_CacheRange.m_TStart};
                         }
                         else if (range.m_TStart < impl->m_CacheRange.m_TStart
                                  && range.m_TEnd > impl->m_CacheRange.m_TEnd) {
-                            notInCache << SqpRange{range.m_TStart, impl->m_CacheRange.m_TStart}
+                            notInCache << DateTimeRange{range.m_TStart, impl->m_CacheRange.m_TStart}
-                                       << SqpRange{impl->m_CacheRange.m_TEnd, range.m_TEnd};
+                                       << DateTimeRange{impl->m_CacheRange.m_TEnd, range.m_TEnd};
                         }
                         else if (range.m_TStart < impl->m_CacheRange.m_TEnd) {
-                            notInCache << SqpRange{impl->m_CacheRange.m_TEnd, range.m_TEnd};
+                            notInCache << DateTimeRange{impl->m_CacheRange.m_TEnd, range.m_TEnd};
                         }
                         else {
                             qCCritical(LOG_Variable()) << tr("Detection of unknown case.")
                 return notInCache;
             }
-            QVector<SqpRange> Variable::provideInCacheRangeList(const SqpRange &range) const noexcept
+            QVector<DateTimeRange> Variable::provideInCacheRangeList(const DateTimeRange &range) const noexcept
             {
                 // This code assume that cach in contigue. Can return 0 or 1 SqpRange
-                auto inCache = QVector<SqpRange>{};
+                auto inCache = QVector<DateTimeRange>{};
                 if (impl->m_CacheRange != INVALID_RANGE) {
                         if (range.m_TStart <= impl->m_CacheRange.m_TStart
                             && range.m_TEnd >= impl->m_CacheRange.m_TStart
                             && range.m_TEnd < impl->m_CacheRange.m_TEnd) {
-                            inCache << SqpRange{impl->m_CacheRange.m_TStart, range.m_TEnd};
+                            inCache << DateTimeRange{impl->m_CacheRange.m_TStart, range.m_TEnd};
                         }
                         else if (range.m_TStart >= impl->m_CacheRange.m_TStart
                         }
                         else if (range.m_TStart > impl->m_CacheRange.m_TStart
                                  && range.m_TEnd > impl->m_CacheRange.m_TEnd) {
-                            inCache << SqpRange{range.m_TStart, impl->m_CacheRange.m_TEnd};
+                            inCache << DateTimeRange{range.m_TStart, impl->m_CacheRange.m_TEnd};
                         }
                         else if (range.m_TStart <= impl->m_CacheRange.m_TStart
                                  && range.m_TEnd >= impl->m_CacheRange.m_TEnd) {
             }
-            QVector<SqpRange> Variable::provideNotInCacheRangeList(const SqpRange &oldRange,
+            QVector<DateTimeRange> Variable::provideNotInCacheRangeList(const DateTimeRange &oldRange,
-                                                                   const SqpRange &nextRange)
+                                                                   const DateTimeRange &nextRange)
             {
                 // This code assume that cach in contigue. Can return 0, 1 or 2 SqpRange
-                auto notInCache = QVector<SqpRange>{};
+                auto notInCache = QVector<DateTimeRange>{};
                 if (oldRange != INVALID_RANGE) {
                     if (!oldRange.contains(nextRange)) {
                         }
                         else if (nextRange.m_TStart < oldRange.m_TStart
                                  && nextRange.m_TEnd <= oldRange.m_TEnd) {
-                            notInCache << SqpRange{nextRange.m_TStart, oldRange.m_TStart};
+                            notInCache << DateTimeRange{nextRange.m_TStart, oldRange.m_TStart};
                         }
                         else if (nextRange.m_TStart < oldRange.m_TStart && nextRange.m_TEnd > oldRange.m_TEnd) {
-                            notInCache << SqpRange{nextRange.m_TStart, oldRange.m_TStart}
+                            notInCache << DateTimeRange{nextRange.m_TStart, oldRange.m_TStart}
-                                       << SqpRange{oldRange.m_TEnd, nextRange.m_TEnd};
+                                       << DateTimeRange{oldRange.m_TEnd, nextRange.m_TEnd};
                         }
                         else if (nextRange.m_TStart < oldRange.m_TEnd) {
-                            notInCache << SqpRange{oldRange.m_TEnd, nextRange.m_TEnd};
+                            notInCache << DateTimeRange{oldRange.m_TEnd, nextRange.m_TEnd};
                         }
                         else {
                             qCCritical(LOG_Variable()) << tr("Detection of unknown case.")
                 return notInCache;
             }
-            QVector<SqpRange> Variable::provideInCacheRangeList(const SqpRange &oldRange,
+            QVector<DateTimeRange> Variable::provideInCacheRangeList(const DateTimeRange &oldRange,
-                                                                const SqpRange &nextRange)
+                                                                const DateTimeRange &nextRange)
             {
                 // This code assume that cach is contigue. Can return 0 or 1 SqpRange
-                auto inCache = QVector<SqpRange>{};
+                auto inCache = QVector<DateTimeRange>{};
                 if (oldRange != INVALID_RANGE) {
                     if (oldRange.intersect(nextRange)) {
                         if (nextRange.m_TStart <= oldRange.m_TStart && nextRange.m_TEnd >= oldRange.m_TStart
                             && nextRange.m_TEnd < oldRange.m_TEnd) {
-                            inCache << SqpRange{oldRange.m_TStart, nextRange.m_TEnd};
+                            inCache << DateTimeRange{oldRange.m_TStart, nextRange.m_TEnd};
                         }
                         else if (nextRange.m_TStart >= oldRange.m_TStart
                             inCache << nextRange;
                         }
                         else if (nextRange.m_TStart > oldRange.m_TStart && nextRange.m_TEnd > oldRange.m_TEnd) {
-                            inCache << SqpRange{nextRange.m_TStart, oldRange.m_TEnd};
+                            inCache << DateTimeRange{nextRange.m_TStart, oldRange.m_TEnd};
                         }
                         else if (nextRange.m_TStart <= oldRange.m_TStart
                                  && nextRange.m_TEnd >= oldRange.m_TEnd) {

core/src/Variable/VariableAcquisitionWorker.cpp +3 -3

             QUuid VariableAcquisitionWorker::pushVariableRequest(QUuid varRequestId, QUuid vIdentifier,
-                                                                 SqpRange rangeRequested,
+                                                                 DateTimeRange rangeRequested,
-                                                                 SqpRange cacheRangeRequested,
+                                                                 DateTimeRange cacheRangeRequested,
                                                                  DataProviderParameters parameters,
                                                                  std::shared_ptr<IDataProvider> provider)
             {
             void VariableAcquisitionWorker::onVariableDataAcquired(QUuid acqIdentifier,
                                                                    std::shared_ptr<IDataSeries> dataSeries,
-                                                                   SqpRange dataRangeAcquired)
+                                                                   DateTimeRange dataRangeAcquired)
             {
                 qCDebug(LOG_VariableAcquisitionWorker()) << tr("TORM: onVariableDataAcquired on range ")
                                                          << acqIdentifier << dataRangeAcquired;

core/src/Variable/VariableCacheController.cpp +20 -20

             struct VariableCacheController::VariableCacheControllerPrivate {
-                std::unordered_map<std::shared_ptr<Variable>, QVector<SqpRange> > m_VariableToSqpRangeListMap;
+                std::unordered_map<std::shared_ptr<Variable>, QVector<DateTimeRange> > m_VariableToSqpRangeListMap;
-                void addInCacheDataByEnd(const SqpRange &dateTime, QVector<SqpRange> &dateTimeList,
+                void addInCacheDataByEnd(const DateTimeRange &dateTime, QVector<DateTimeRange> &dateTimeList,
-                                         QVector<SqpRange> &notInCache, int cacheIndex, double currentTStart);
+                                         QVector<DateTimeRange> &notInCache, int cacheIndex, double currentTStart);
-                void addInCacheDataByStart(const SqpRange &dateTime, QVector<SqpRange> &dateTimeList,
+                void addInCacheDataByStart(const DateTimeRange &dateTime, QVector<DateTimeRange> &dateTimeList,
-                                           QVector<SqpRange> &notInCache, int cacheIndex, double currentTStart);
+                                           QVector<DateTimeRange> &notInCache, int cacheIndex, double currentTStart);
-                void addDateTimeRecurse(const SqpRange &dateTime, QVector<SqpRange> &dateTimeList,
+                void addDateTimeRecurse(const DateTimeRange &dateTime, QVector<DateTimeRange> &dateTimeList,
                                         int cacheIndex);
             };
             }
             void VariableCacheController::addDateTime(std::shared_ptr<Variable> variable,
-                                                      const SqpRange &dateTime)
+                                                      const DateTimeRange &dateTime)
             {
                 qCDebug(LOG_VariableCacheController()) << "VariableCacheController::addDateTime"
                                                        << QThread::currentThread()->objectName();
                 qCDebug(LOG_VariableCacheController()) << clearCacheMessage;
             }
-            QVector<SqpRange>
+            QVector<DateTimeRange>
             VariableCacheController::provideNotInCacheDateTimeList(std::shared_ptr<Variable> variable,
-                                                                   const SqpRange &dateTime)
+                                                                   const DateTimeRange &dateTime)
             {
                 qCDebug(LOG_VariableCacheController())
                     << "VariableCacheController::provideNotInCacheDateTimeList"
                     << QThread::currentThread()->objectName();
-                auto notInCache = QVector<SqpRange>{};
+                auto notInCache = QVector<DateTimeRange>{};
                 // This algorithm is recursif. The idea is to localise the start time then the end time in the
                 // list of date time request associated to the variable
                 return notInCache;
             }
-            QVector<SqpRange>
+            QVector<DateTimeRange>
             VariableCacheController::dateCacheList(std::shared_ptr<Variable> variable) const noexcept
             {
                 qCDebug(LOG_VariableCacheController()) << "VariableCacheController::dateCacheList"
                 }
                 catch (const std::out_of_range &e) {
                     qCWarning(LOG_VariableCacheController()) << e.what();
-                    return QVector<SqpRange>{};
+                    return QVector<DateTimeRange>{};
                 }
             }
             void VariableCacheController::VariableCacheControllerPrivate::addDateTimeRecurse(
-                const SqpRange &dateTime, QVector<SqpRange> &dateTimeList, int cacheIndex)
+                const DateTimeRange &dateTime, QVector<DateTimeRange> &dateTimeList, int cacheIndex)
             {
                 const auto dateTimeListSize = dateTimeList.count();
                 if (cacheIndex >= dateTimeListSize) {
                     // rerun the algo from this index with the merged interval
                     auto mTStart = std::min(dateTime.m_TStart, currentDateTime.m_TStart);
                     auto mTEnd = std::max(dateTime.m_TEnd, currentDateTime.m_TEnd);
-                    auto mergeDateTime = SqpRange{mTStart, mTEnd};
+                    auto mergeDateTime = DateTimeRange{mTStart, mTEnd};
                     dateTimeList.remove(cacheIndex);
                     addDateTimeRecurse(mergeDateTime, dateTimeList, cacheIndex);
             void VariableCacheController::VariableCacheControllerPrivate::addInCacheDataByEnd(
-                const SqpRange &dateTime, QVector<SqpRange> &dateTimeList, QVector<SqpRange> &notInCache,
+                const DateTimeRange &dateTime, QVector<DateTimeRange> &dateTimeList, QVector<DateTimeRange> &notInCache,
                 int cacheIndex, double currentTStart)
             {
                 const auto dateTimeListSize = dateTimeList.count();
                     if (currentTStart < dateTime.m_TEnd) {
                         // te localised after all other interval: The last interval is [currentTsart, te]
-                        notInCache.push_back(SqpRange{currentTStart, dateTime.m_TEnd});
+                        notInCache.push_back(DateTimeRange{currentTStart, dateTime.m_TEnd});
                     }
                     return;
                 }
                 auto currentDateTimeJ = dateTimeList[cacheIndex];
                 if (dateTime.m_TEnd <= currentDateTimeJ.m_TStart) {
                     // te localised between to interval: The last interval is [currentTsart, te]
-                    notInCache.push_back(SqpRange{currentTStart, dateTime.m_TEnd});
+                    notInCache.push_back(DateTimeRange{currentTStart, dateTime.m_TEnd});
                 }
                 else {
-                    notInCache.push_back(SqpRange{currentTStart, currentDateTimeJ.m_TStart});
+                    notInCache.push_back(DateTimeRange{currentTStart, currentDateTimeJ.m_TStart});
                     if (dateTime.m_TEnd > currentDateTimeJ.m_TEnd) {
                         // te not localised before the current interval: we need to look at the next interval
                         addInCacheDataByEnd(dateTime, dateTimeList, notInCache, ++cacheIndex,
             }
             void VariableCacheController::VariableCacheControllerPrivate::addInCacheDataByStart(
-                const SqpRange &dateTime, QVector<SqpRange> &dateTimeList, QVector<SqpRange> &notInCache,
+                const DateTimeRange &dateTime, QVector<DateTimeRange> &dateTimeList, QVector<DateTimeRange> &notInCache,
                 int cacheIndex, double currentTStart)
             {
                 const auto dateTimeListSize = dateTimeList.count();
                 if (cacheIndex >= dateTimeListSize) {
                     // ts localised after all other interval: The last interval is [ts, te]
-                    notInCache.push_back(SqpRange{currentTStart, dateTime.m_TEnd});
+                    notInCache.push_back(DateTimeRange{currentTStart, dateTime.m_TEnd});
                     return;
                 }

core/src/Variable/VariableController.cpp +28 -33

             #include <Data/VariableRequest.h>
             #include <Time/TimeController.h>
+            #include <Common/Numeric.h>
             #include <QDataStream>
             #include <QMutex>
             #include <QThread>
             namespace {
-            SqpRange computeSynchroRangeRequested(const SqpRange &varRange, const SqpRange &graphRange,
+            DateTimeRange computeSynchroRangeRequested(const DateTimeRange &varRange, const DateTimeRange &graphRange,
-                                                  const SqpRange &oldGraphRange)
+                                                  const DateTimeRange &oldGraphRange)
             {
                 auto zoomType = VariableController::getZoomType(graphRange, oldGraphRange);
                 }
-                void processRequest(std::shared_ptr<Variable> var, const SqpRange &rangeRequested,
+                void processRequest(std::shared_ptr<Variable> var, const DateTimeRange &rangeRequested,
                                     QUuid varRequestId);
                 std::shared_ptr<Variable> findVariable(QUuid vIdentifier);
             std::shared_ptr<Variable>
             VariableController::createVariable(const QString &name, const QVariantHash &metadata,
-                                               std::shared_ptr<IDataProvider> provider, const SqpRange& range) noexcept
+                                               std::shared_ptr<IDataProvider> provider, const DateTimeRange& range) noexcept
             {
             //    if (!impl->m_TimeController) {
             //        qCCritical(LOG_VariableController())
                 return nullptr;
             }
-            void VariableController::onDateTimeOnSelection(const SqpRange &dateTime)
+            void VariableController::onDateTimeOnSelection(const DateTimeRange &dateTime)
             {
                 // NOTE: Even if acquisition request is aborting, the graphe range will be changed
                 qCDebug(LOG_VariableController()) << "VariableController::onDateTimeOnSelection"
             }
             void VariableController::onUpdateDateTime(std::shared_ptr<Variable> variable,
-                                                      const SqpRange &dateTime)
+                                                      const DateTimeRange &dateTime)
             {
                 auto itVar = impl->m_VariableToIdentifierMap.find(variable);
                 if (itVar == impl->m_VariableToIdentifierMap.cend()) {
                 this->onRequestDataLoading(QVector<std::shared_ptr<Variable> >{variable}, dateTime, synchro);
             }
-            void VariableController::onDataProvided(QUuid vIdentifier, const SqpRange &rangeRequested,
+            void VariableController::onDataProvided(QUuid vIdentifier, const DateTimeRange &rangeRequested,
-                                                    const SqpRange &cacheRangeRequested,
+                                                    const DateTimeRange &cacheRangeRequested,
                                                     QVector<AcquisitionDataPacket> dataAcquired)
             {
                 qCDebug(LOG_VariableController()) << tr("onDataProvided") << QThread::currentThread();
                     if (groupIdToVSGIt != impl->m_GroupIdToVariableSynchronizationGroupMap.cend()) {
                         impl->m_VariableIdGroupIdMap.insert(
                             std::make_pair(varToVarIdIt->second, synchronizationGroupId));
-                        groupIdToVSGIt->second->addVariableId(varToVarIdIt->second);
+                        groupIdToVSGIt->second->addVariable(varToVarIdIt->second);
                     }
                     else {
                         qCCritical(LOG_VariableController())
             }
             void VariableController::onRequestDataLoading(QVector<std::shared_ptr<Variable> > variables,
-                                                          const SqpRange &range, bool synchronise)
+                                                          const DateTimeRange &range, bool synchronise)
             {
                 // variables is assumed synchronized
                 // TODO: Asser variables synchronization
                 return impl->hasPendingDownloads();
             }
-            AcquisitionZoomType VariableController::getZoomType(const SqpRange &range, const SqpRange &oldRange)
+            AcquisitionZoomType VariableController::getZoomType(const DateTimeRange &range, const DateTimeRange &oldRange)
             {
-                // t1.m_TStart <= t2.m_TStart && t2.m_TEnd <= t1.m_TEnd
+                if (almost_equal(range.delta(), oldRange.delta(), 1)) // same delta -> must be a pan or nothing
-                auto zoomType = AcquisitionZoomType::Unknown;
-                if (range.m_TStart <= oldRange.m_TStart && oldRange.m_TEnd <= range.m_TEnd) {
+                    if(range.m_TStart > oldRange.m_TStart)
-                    qCDebug(LOG_VariableController()) << "zoomtype: ZoomOut";
+                        return AcquisitionZoomType::PanRight;
-                    zoomType = AcquisitionZoomType::ZoomOut;
+                    if(range.m_TStart < oldRange.m_TStart)
+                        return AcquisitionZoomType::PanLeft;
-                else if (range.m_TStart > oldRange.m_TStart && range.m_TEnd > oldRange.m_TEnd) {
-                    qCDebug(LOG_VariableController()) << "zoomtype: PanRight";
-                    zoomType = AcquisitionZoomType::PanRight;
-                else if (range.m_TStart < oldRange.m_TStart && range.m_TEnd < oldRange.m_TEnd) {
-                    qCDebug(LOG_VariableController()) << "zoomtype: PanLeft";
-                    zoomType = AcquisitionZoomType::PanLeft;
-                else if (range.m_TStart >= oldRange.m_TStart && oldRange.m_TEnd >= range.m_TEnd) {
-                    qCDebug(LOG_VariableController()) << "zoomtype: ZoomIn";
-                    zoomType = AcquisitionZoomType::ZoomIn;
                 }
-                else {
+                else // different delta -> must be a zoom
-                    qCDebug(LOG_VariableController()) << "getZoomType: Unknown type detected";
+                    if(range.m_TStart > oldRange.m_TStart)
+                        return AcquisitionZoomType::ZoomIn;
+                    if(range.m_TStart < oldRange.m_TStart)
+                        return AcquisitionZoomType::ZoomOut;
                 }
-                return zoomType;
+                return AcquisitionZoomType::Unknown;
             }
             void VariableController::VariableControllerPrivate::processRequest(std::shared_ptr<Variable> var,
-                                                                               const SqpRange &rangeRequested,
+                                                                               const DateTimeRange &rangeRequested,
                                                                                QUuid varRequestId)
             {
                 auto itVar = m_VariableToIdentifierMap.find(var);
                 // Removes variable from synchronization group
                 auto synchronizationGroup = groupIt->second;
-                synchronizationGroup->removeVariableId(variableId);
+                synchronizationGroup->removeVariable(variableId);
                 // Removes link between variable and synchronization group
                 m_VariableIdGroupIdMap.erase(variableId);

core/src/Variable/VariableModel.cpp +1 -1

                 QList<std::shared_ptr<Variable> > variableList;
-                SqpRange firstTimeRange;
+                DateTimeRange firstTimeRange;
                 for (const auto &index : indexes) {
                     if (index.column() == 0) { // only the first column
                         auto variable = impl->m_Variables.at(index.row());

core/src/Variable/VariableSynchronizationGroup.cpp +8 -2

             {
             }
-            void VariableSynchronizationGroup::addVariableId(QUuid vIdentifier)
+            VariableSynchronizationGroup::VariableSynchronizationGroup(QUuid variable, QObject *parent)
+                :QObject{parent}, impl{spimpl::make_unique_impl<VariableSynchronizationGroupPrivate>()}
+            {
+                this->addVariable(variable);
+            }
+            void VariableSynchronizationGroup::addVariable(QUuid vIdentifier)
             {
                 impl->m_VariableIdSet.insert(vIdentifier);
             }
-            void VariableSynchronizationGroup::removeVariableId(QUuid vIdentifier)
+            void VariableSynchronizationGroup::removeVariable(QUuid vIdentifier)
             {
                 impl->m_VariableIdSet.erase(vIdentifier);
             }

core/src/pybind11_wrappers/CoreWrappers.cpp +18 -7

             #include <pybind11/embed.h>
             #include <pybind11/numpy.h>
             #include <pybind11/chrono.h>
+            #include <pybind11/functional.h>
             #include <string>
             #include <sstream>
             #include <Time/TimeController.h>
+            #include <Network/Downloader.h>
             namespace py = pybind11;
                         .def(py::self != py::self)
                         .def("__repr__",__repr__<Unit>);
+                py::class_<Response>(m,"Response")
+                        .def("status_code", &Response::status_code);
+                py::class_<Downloader>(m,"Downloader")
+                        .def_static("get", Downloader::get)
+                        .def_static("getAsync", Downloader::getAsync)
+                        .def_static("downloadFinished", Downloader::downloadFinished);
                 py::class_<DataSeriesIteratorValue>(m,"DataSeriesIteratorValue")
                         .def_property_readonly("x", &DataSeriesIteratorValue::x)
                         .def("value", py::overload_cast<>(&DataSeriesIteratorValue::value, py::const_))
                         .def("__repr__",__repr__<Variable>);
-                py::class_<SqpRange>(m,"SqpRange")
+                py::class_<DateTimeRange>(m,"SqpRange")
-                        .def("fromDateTime", &SqpRange::fromDateTime, py::return_value_policy::move)
+                        .def("fromDateTime", &DateTimeRange::fromDateTime, py::return_value_policy::move)
-                        .def(py::init([](double start, double stop){return SqpRange{start, stop};}))
+                        .def(py::init([](double start, double stop){return DateTimeRange{start, stop};}))
                         .def(py::init([](system_clock::time_point start, system_clock::time_point stop)
                 {
                                  double start_ = 0.001 * duration_cast<milliseconds>(start.time_since_epoch()).count();
                                  double stop_ = 0.001 * duration_cast<milliseconds>(stop.time_since_epoch()).count();
-                                 return SqpRange{start_, stop_};
+                                 return DateTimeRange{start_, stop_};
                              }))
-                        .def_property_readonly("start", [](const SqpRange& range){
+                        .def_property_readonly("start", [](const DateTimeRange& range){
                     return  system_clock::from_time_t(range.m_TStart);
                 })
-                        .def_property_readonly("stop", [](const SqpRange& range){
+                        .def_property_readonly("stop", [](const DateTimeRange& range){
                     return  system_clock::from_time_t(range.m_TEnd);
                 })
-                        .def("__repr__", __repr__<SqpRange>);
+                        .def("__repr__", __repr__<DateTimeRange>);
             }

core/src/pybind11_wrappers/CoreWrappers.h +1 -1

                 return os;
             }
-            std::ostream &operator <<(std::ostream& os, const SqpRange& range)
+            std::ostream &operator <<(std::ostream& os, const DateTimeRange& range)
             {
                 os << "=========================" << std::endl
                    << "SqpRange:" << std::endl

core/tests/CMakeLists.txt +3 0

             declare_test(TestVariableSync TestVariableSync Variable/TestVariableSync.cpp "sciqlopcore;Qt5::Test")
             declare_test(TestDownloader TestDownloader Network/TestDownloader.cpp "sciqlopcore;Qt5::Test")
+            declare_test(TestVariableController2 TestVariableController2 Variable/TestVariableController2.cpp "sciqlopcore;Qt5::Test")

core/tests/Data/DataSeriesTestsUtils.h +2 -2

                 // Data series from which extract the subdata series
                 QTest::addColumn<std::shared_ptr<DataSeriesType> >("dataSeries");
                 // Range to extract
-                QTest::addColumn<SqpRange>("range");
+                QTest::addColumn<DateTimeRange>("range");
                 // Expected values for the subdata series
                 QTest::addColumn<DataContainer>("expectedXAxisData");
             template <typename DataSeriesType, typename ExpectedValuesType>
             void testSubDataSeries_t(){
                 QFETCH(std::shared_ptr<DataSeriesType>, dataSeries);
-                QFETCH(SqpRange, range);
+                QFETCH(DateTimeRange, range);
                 // Makes the operation
                 auto subDataSeries = std::dynamic_pointer_cast<DataSeriesType>(dataSeries->subDataSeries(range));

core/tests/Data/TestSpectrogramSeries.cpp +3 -3

                            .setY({1., 2.})
                            .setValues({10., 11., 20., 21., 30., 31})
                            .build()
-                    << SqpRange{0., 5.} << DataContainer{1., 2., 3.}
+                    << DateTimeRange{0., 5.} << DataContainer{1., 2., 3.}
                     << Components{{10., 20., 30.}, {11., 21., 31.}};
                 QTest::newRow("subDataSeries (the range includes no data)")
                            .setY({1., 2.})
                            .setValues({10., 11., 20., 21., 30., 31})
                            .build()
-                    << SqpRange{4., 5.} << DataContainer{} << Components{{}, {}};
+                    << DateTimeRange{4., 5.} << DataContainer{} << Components{{}, {}};
                 QTest::newRow("subDataSeries (the range includes some data)")
                     << SpectrogramBuilder{}
                            .setY({1., 2.})
                            .setValues({10., 11., 20., 21., 30., 31})
                            .build()
-                    << SqpRange{1.1, 3} << DataContainer{2., 3.} << Components{{20., 30.}, {21., 31.}};
+                    << DateTimeRange{1.1, 3} << DataContainer{2., 3.} << Components{{20., 30.}, {21., 31.}};
             }
             void TestSpectrogramSeries::testSubDataSeries()

core/tests/Variable/TestVariable.cpp +35 -35

             };
             /// Generates a series of test data for a range
-            std::shared_ptr<ScalarSeries> dataSeries(const SqpRange &range)
+            std::shared_ptr<ScalarSeries> dataSeries(const DateTimeRange &range)
             {
                 auto xAxisData = std::vector<double>{};
                 auto valuesData = std::vector<double>{};
                 QTest::addColumn<QString>("name");
                 QTest::addColumn<QVariantHash>("metadata");
-                QTest::addColumn<SqpRange>("range");
+                QTest::addColumn<DateTimeRange>("range");
-                QTest::addColumn<SqpRange>("cacheRange");
+                QTest::addColumn<DateTimeRange>("cacheRange");
                 QTest::addColumn<std::shared_ptr<ScalarSeries> >("dataSeries");
                 // ////////// //
                 // Test cases //
                 // ////////// //
-                auto cacheRange = SqpRange{date(2017, 1, 1, 12, 0, 0), date(2017, 1, 1, 13, 0, 0)};
+                auto cacheRange = DateTimeRange{date(2017, 1, 1, 12, 0, 0), date(2017, 1, 1, 13, 0, 0)};
                 QTest::newRow("clone1") << QStringLiteral("var1")
                                         << QVariantHash{{"data1", 1}, {"data2", "abc"}}
-                                        << SqpRange{date(2017, 1, 1, 12, 30, 0), (date(2017, 1, 1, 12, 45, 0))}
+                                        << DateTimeRange{date(2017, 1, 1, 12, 30, 0), (date(2017, 1, 1, 12, 45, 0))}
                                         << cacheRange << dataSeries(cacheRange);
             }
                 // Creates variable
                 QFETCH(QString, name);
                 QFETCH(QVariantHash, metadata);
-                QFETCH(SqpRange, range);
+                QFETCH(DateTimeRange, range);
-                QFETCH(SqpRange, cacheRange);
+                QFETCH(DateTimeRange, cacheRange);
                 QFETCH(std::shared_ptr<ScalarSeries>, dataSeries);
                 Variable variable{name, metadata};
                 auto varRS = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 20, 0}};
                 auto varRE = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 40, 0}};
-                auto sqpR = SqpRange{DateUtils::secondsSinceEpoch(varRS), DateUtils::secondsSinceEpoch(varRE)};
+                auto sqpR = DateTimeRange{DateUtils::secondsSinceEpoch(varRS), DateUtils::secondsSinceEpoch(varRE)};
                 auto varCRS = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 0, 0}};
                 auto varCRE = QDateTime{QDate{2017, 01, 01}, QTime{2, 4, 0, 0}};
                 auto sqpCR
-                    = SqpRange{DateUtils::secondsSinceEpoch(varCRS), DateUtils::secondsSinceEpoch(varCRE)};
+                    = DateTimeRange{DateUtils::secondsSinceEpoch(varCRS), DateUtils::secondsSinceEpoch(varCRE)};
                 Variable var{"Var test"};
                 var.setRange(sqpR);
                 // 1: [ts,te] < varTS
                 auto ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 0, 0, 0}};
                 auto te = QDateTime{QDate{2017, 01, 01}, QTime{2, 1, 0, 0}};
-                auto sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
+                auto sqp = DateTimeRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
                 auto notInCach = var.provideNotInCacheRangeList(sqp);
                 // 2: ts < varTS < te < varTE
                 ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 0, 0, 0}};
                 te = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 30, 0}};
-                sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
+                sqp = DateTimeRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
                 notInCach = var.provideNotInCacheRangeList(sqp);
                 QCOMPARE(notInCach.size(), 1);
                 notInCachRange = notInCach.first();
                 // 3: varTS < ts < te < varTE
                 ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 20, 0}};
                 te = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 30, 0}};
-                sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
+                sqp = DateTimeRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
                 notInCach = var.provideNotInCacheRangeList(sqp);
                 QCOMPARE(notInCach.size(), 0);
                 // 4: varTS < ts < varTE < te
                 ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 20, 0}};
                 te = QDateTime{QDate{2017, 01, 01}, QTime{2, 5, 0, 0}};
-                sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
+                sqp = DateTimeRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
                 notInCach = var.provideNotInCacheRangeList(sqp);
                 QCOMPARE(notInCach.size(), 1);
                 notInCachRange = notInCach.first();
                 // 5: varTS < varTE < ts < te
                 ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 4, 20, 0}};
                 te = QDateTime{QDate{2017, 01, 01}, QTime{2, 5, 0, 0}};
-                sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
+                sqp = DateTimeRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
                 notInCach = var.provideNotInCacheRangeList(sqp);
                 QCOMPARE(notInCach.size(), 1);
                 notInCachRange = notInCach.first();
                 // 6: ts <varTS < varTE < te
                 ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 1, 0, 0}};
                 te = QDateTime{QDate{2017, 01, 01}, QTime{2, 5, 0, 0}};
-                sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
+                sqp = DateTimeRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
                 notInCach = var.provideNotInCacheRangeList(sqp);
                 QCOMPARE(notInCach.size(), 2);
                 notInCachRange = notInCach.first();
                 auto varRS = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 20, 0}};
                 auto varRE = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 40, 0}};
-                auto sqpR = SqpRange{DateUtils::secondsSinceEpoch(varRS), DateUtils::secondsSinceEpoch(varRE)};
+                auto sqpR = DateTimeRange{DateUtils::secondsSinceEpoch(varRS), DateUtils::secondsSinceEpoch(varRE)};
                 auto varCRS = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 0, 0}};
                 auto varCRE = QDateTime{QDate{2017, 01, 01}, QTime{2, 4, 0, 0}};
                 auto sqpCR
-                    = SqpRange{DateUtils::secondsSinceEpoch(varCRS), DateUtils::secondsSinceEpoch(varCRE)};
+                    = DateTimeRange{DateUtils::secondsSinceEpoch(varCRS), DateUtils::secondsSinceEpoch(varCRE)};
                 Variable var{"Var test"};
                 var.setRange(sqpR);
                 // 1: [ts,te] < varTS
                 auto ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 0, 0, 0}};
                 auto te = QDateTime{QDate{2017, 01, 01}, QTime{2, 1, 0, 0}};
-                auto sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
+                auto sqp = DateTimeRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
                 auto notInCach = var.provideInCacheRangeList(sqp);
                 // 2: ts < varTS < te < varTE
                 ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 0, 0, 0}};
                 te = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 30, 0}};
-                sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
+                sqp = DateTimeRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
                 notInCach = var.provideInCacheRangeList(sqp);
                 QCOMPARE(notInCach.size(), 1);
                 auto notInCachRange = notInCach.first();
                 // 3: varTS < ts < te < varTE
                 ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 20, 0}};
                 te = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 30, 0}};
-                sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
+                sqp = DateTimeRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
                 notInCach = var.provideInCacheRangeList(sqp);
                 QCOMPARE(notInCach.size(), 1);
                 notInCachRange = notInCach.first();
                 // 4: varTS < ts < varTE < te
                 ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 20, 0}};
                 te = QDateTime{QDate{2017, 01, 01}, QTime{2, 5, 0, 0}};
-                sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
+                sqp = DateTimeRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
                 notInCach = var.provideInCacheRangeList(sqp);
                 QCOMPARE(notInCach.size(), 1);
                 notInCachRange = notInCach.first();
                 // 5: varTS < varTE < ts < te
                 ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 4, 20, 0}};
                 te = QDateTime{QDate{2017, 01, 01}, QTime{2, 5, 0, 0}};
-                sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
+                sqp = DateTimeRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
                 notInCach = var.provideInCacheRangeList(sqp);
                 QCOMPARE(notInCach.size(), 0);
                 // 6: ts <varTS < varTE < te
                 ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 1, 0, 0}};
                 te = QDateTime{QDate{2017, 01, 01}, QTime{2, 5, 0, 0}};
-                sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
+                sqp = DateTimeRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
                 notInCach = var.provideInCacheRangeList(sqp);
                 QCOMPARE(notInCach.size(), 1);
                 notInCachRange = notInCach.first();
             /// Struct used to represent an operation for @sa TestVariable::testNbPoints()
             struct NbPointsOperation {
-                SqpRange m_CacheRange;                      /// Range to set for the variable
+                DateTimeRange m_CacheRange;                      /// Range to set for the variable
                 std::shared_ptr<ScalarSeries> m_DataSeries; /// Series to merge in the variable
                 int m_ExpectedNbPoints; /// Number of points in the variable expected after operation
             };
                 NbPointsOperations operations{};
                 // Sets cache range (expected nb points = values data)
-                auto cacheRange = SqpRange{date(2017, 1, 1, 12, 0, 0), date(2017, 1, 1, 12, 0, 9)};
+                auto cacheRange = DateTimeRange{date(2017, 1, 1, 12, 0, 0), date(2017, 1, 1, 12, 0, 9)};
                 operations.push_back({cacheRange, dataSeries(cacheRange), 10});
                 // Doubles cache but don't add data series (expected nb points don't change)
-                cacheRange = SqpRange{date(2017, 1, 1, 12, 0, 0), date(2017, 1, 1, 12, 0, 19)};
+                cacheRange = DateTimeRange{date(2017, 1, 1, 12, 0, 0), date(2017, 1, 1, 12, 0, 19)};
                 operations.push_back({cacheRange, dataSeries(INVALID_RANGE), 10});
                 // Doubles cache and data series (expected nb points change)
-                cacheRange = SqpRange{date(2017, 1, 1, 12, 0, 0), date(2017, 1, 1, 12, 0, 19)};
+                cacheRange = DateTimeRange{date(2017, 1, 1, 12, 0, 0), date(2017, 1, 1, 12, 0, 19)};
                 operations.push_back({cacheRange, dataSeries(cacheRange), 20});
                 // Decreases cache (expected nb points decreases as the series is purged)
-                cacheRange = SqpRange{date(2017, 1, 1, 12, 0, 5), date(2017, 1, 1, 12, 0, 9)};
+                cacheRange = DateTimeRange{date(2017, 1, 1, 12, 0, 5), date(2017, 1, 1, 12, 0, 9)};
                 operations.push_back({cacheRange, dataSeries(INVALID_RANGE), 5});
                 QTest::newRow("nbPoints1") << operations;
             /// Struct used to represent a range operation on a variable
             /// @sa TestVariable::testRealRange()
             struct RangeOperation {
-                SqpRange m_CacheRange;                      /// Range to set for the variable
+                DateTimeRange m_CacheRange;                      /// Range to set for the variable
                 std::shared_ptr<ScalarSeries> m_DataSeries; /// Series to merge in the variable
-                SqpRange m_ExpectedRealRange; /// Real Range expected after operation on the variable
+                DateTimeRange m_ExpectedRealRange; /// Real Range expected after operation on the variable
             };
             using RangeOperations = std::vector<RangeOperation>;
                 RangeOperations operations{};
                 // Inits cache range and data series (expected real range = cache range)
-                auto cacheRange = SqpRange{date(2017, 1, 1, 12, 0, 0), date(2017, 1, 1, 13, 0, 0)};
+                auto cacheRange = DateTimeRange{date(2017, 1, 1, 12, 0, 0), date(2017, 1, 1, 13, 0, 0)};
                 operations.push_back({cacheRange, dataSeries(cacheRange), cacheRange});
                 // Changes cache range and updates data series (expected real range = cache range)
-                cacheRange = SqpRange{date(2017, 1, 1, 14, 0, 0), date(2017, 1, 1, 15, 0, 0)};
+                cacheRange = DateTimeRange{date(2017, 1, 1, 14, 0, 0), date(2017, 1, 1, 15, 0, 0)};
                 operations.push_back({cacheRange, dataSeries(cacheRange), cacheRange});
                 // Changes cache range and update data series but with a lower range (expected real range =
                 // data series range)
-                cacheRange = SqpRange{date(2017, 1, 1, 12, 0, 0), date(2017, 1, 1, 16, 0, 0)};
+                cacheRange = DateTimeRange{date(2017, 1, 1, 12, 0, 0), date(2017, 1, 1, 16, 0, 0)};
-                auto dataSeriesRange = SqpRange{date(2017, 1, 1, 14, 0, 0), date(2017, 1, 1, 15, 0, 0)};
+                auto dataSeriesRange = DateTimeRange{date(2017, 1, 1, 14, 0, 0), date(2017, 1, 1, 15, 0, 0)};
                 operations.push_back({cacheRange, dataSeries(dataSeriesRange), dataSeriesRange});
                 // Changes cache range but DON'T update data series (expected real range = cache range
                 // before operation)
-                cacheRange = SqpRange{date(2017, 1, 1, 10, 0, 0), date(2017, 1, 1, 17, 0, 0)};
+                cacheRange = DateTimeRange{date(2017, 1, 1, 10, 0, 0), date(2017, 1, 1, 17, 0, 0)};
                 operations.push_back({cacheRange, nullptr, dataSeriesRange});
                 QTest::newRow("realRange1") << operations;

core/tests/Variable/TestVariableCacheController.cpp +22 -22

                 auto ts0 = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 0, 0}};
                 auto te0 = QDateTime{QDate{2017, 01, 01}, QTime{2, 4, 0, 0}};
-                auto sqp0 = SqpRange{DateUtils::secondsSinceEpoch(ts0), DateUtils::secondsSinceEpoch(te0)};
+                auto sqp0 = DateTimeRange{DateUtils::secondsSinceEpoch(ts0), DateUtils::secondsSinceEpoch(te0)};
                 auto ts1 = QDateTime{QDate{2017, 01, 01}, QTime{2, 6, 0, 0}};
                 auto te1 = QDateTime{QDate{2017, 01, 01}, QTime{2, 8, 0, 0}};
-                auto sqp1 = SqpRange{DateUtils::secondsSinceEpoch(ts1), DateUtils::secondsSinceEpoch(te1)};
+                auto sqp1 = DateTimeRange{DateUtils::secondsSinceEpoch(ts1), DateUtils::secondsSinceEpoch(te1)};
                 auto ts2 = QDateTime{QDate{2017, 01, 01}, QTime{2, 18, 0, 0}};
                 auto te2 = QDateTime{QDate{2017, 01, 01}, QTime{2, 20, 0, 0}};
-                auto sqp2 = SqpRange{DateUtils::secondsSinceEpoch(ts2), DateUtils::secondsSinceEpoch(te2)};
+                auto sqp2 = DateTimeRange{DateUtils::secondsSinceEpoch(ts2), DateUtils::secondsSinceEpoch(te2)};
                 auto var0 = std::make_shared<Variable>("");
                 var0->setRange(sqp0);
                 // first case [ts,te] < ts0
                 auto ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 0, 0, 0}};
                 auto te = QDateTime{QDate{2017, 01, 01}, QTime{2, 1, 0, 0}};
-                auto sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
+                auto sqp = DateTimeRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
                 auto notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
                 // second case ts < ts0 &&  ts0 < te <= te0
                 ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 0, 0, 0}};
                 te = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 30, 0}};
-                sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
+                sqp = DateTimeRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
                 notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
                 // 3th case ts < ts0 &&  te0 < te <= ts1
                 ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 0, 0, 0}};
                 te = QDateTime{QDate{2017, 01, 01}, QTime{2, 5, 0, 0}};
-                sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
+                sqp = DateTimeRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
                 notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
                 // 4th case ts < ts0 &&  ts1 < te <= te1
                 ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 0, 0, 0}};
                 te = QDateTime{QDate{2017, 01, 01}, QTime{2, 7, 0, 0}};
-                sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
+                sqp = DateTimeRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
                 notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
                 // 5th case ts < ts0 &&  te3 < te
                 ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 0, 0, 0}};
                 te = QDateTime{QDate{2017, 01, 01}, QTime{2, 22, 0, 0}};
-                sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
+                sqp = DateTimeRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
                 notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
                 // 6th case ts2 < ts
                 ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 45, 0, 0}};
                 te = QDateTime{QDate{2017, 01, 01}, QTime{2, 47, 0, 0}};
-                sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
+                sqp = DateTimeRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
                 notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
                 // 7th case ts = te0 && te < ts1
                 ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 4, 0, 0}};
                 te = QDateTime{QDate{2017, 01, 01}, QTime{2, 5, 0, 0}};
-                sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
+                sqp = DateTimeRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
                 notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
                 // 8th case ts0 < ts < te0 && te < ts1
                 ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 30, 0}};
                 te = QDateTime{QDate{2017, 01, 01}, QTime{2, 5, 0, 0}};
-                sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
+                sqp = DateTimeRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
                 notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
                 // 9th case ts0 < ts < te0 &&  ts1 < te < te1
                 ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 30, 0}};
                 te = QDateTime{QDate{2017, 01, 01}, QTime{2, 7, 0, 0}};
-                sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
+                sqp = DateTimeRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
                 notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
                 // 10th case te1 < ts < te < ts2
                 ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 9, 0, 0}};
                 te = QDateTime{QDate{2017, 01, 01}, QTime{2, 10, 0, 0}};
-                sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
+                sqp = DateTimeRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
                 notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
                 // 11th case te0 < ts < ts1 &&  te3 < te
                 ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 5, 0, 0}};
                 te = QDateTime{QDate{2017, 01, 01}, QTime{2, 47, 0, 0}};
-                sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
+                sqp = DateTimeRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
                 notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
                 // 12th case te0 < ts < ts1 &&  te3 < te
                 ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 5, 0, 0}};
                 te = QDateTime{QDate{2017, 01, 01}, QTime{2, 10, 0, 0}};
-                sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
+                sqp = DateTimeRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
                 notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
                 // 12th case ts0 < ts < te0
                 ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 10, 0}};
                 te = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 50, 0}};
-                sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
+                sqp = DateTimeRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
                 notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
                 QCOMPARE(notInCach.size(), 0);
                 auto ts0 = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 0, 0}};
                 auto te0 = QDateTime{QDate{2017, 01, 01}, QTime{2, 4, 0, 0}};
-                auto sqp0 = SqpRange{DateUtils::secondsSinceEpoch(ts0), DateUtils::secondsSinceEpoch(te0)};
+                auto sqp0 = DateTimeRange{DateUtils::secondsSinceEpoch(ts0), DateUtils::secondsSinceEpoch(te0)};
                 auto ts1 = QDateTime{QDate{2017, 01, 01}, QTime{2, 6, 0, 0}};
                 auto te1 = QDateTime{QDate{2017, 01, 01}, QTime{2, 8, 0, 0}};
-                auto sqp1 = SqpRange{DateUtils::secondsSinceEpoch(ts1), DateUtils::secondsSinceEpoch(te1)};
+                auto sqp1 = DateTimeRange{DateUtils::secondsSinceEpoch(ts1), DateUtils::secondsSinceEpoch(te1)};
                 auto ts2 = QDateTime{QDate{2017, 01, 01}, QTime{2, 18, 0, 0}};
                 auto te2 = QDateTime{QDate{2017, 01, 01}, QTime{2, 20, 0, 0}};
-                auto sqp2 = SqpRange{DateUtils::secondsSinceEpoch(ts2), DateUtils::secondsSinceEpoch(te2)};
+                auto sqp2 = DateTimeRange{DateUtils::secondsSinceEpoch(ts2), DateUtils::secondsSinceEpoch(te2)};
                 auto ts01 = QDateTime{QDate{2017, 01, 01}, QTime{2, 4, 0, 0}};
                 auto te01 = QDateTime{QDate{2017, 01, 01}, QTime{2, 6, 0, 0}};
-                auto sqp01 = SqpRange{DateUtils::secondsSinceEpoch(ts01), DateUtils::secondsSinceEpoch(te01)};
+                auto sqp01 = DateTimeRange{DateUtils::secondsSinceEpoch(ts01), DateUtils::secondsSinceEpoch(te01)};
                 auto ts3 = QDateTime{QDate{2017, 01, 01}, QTime{2, 14, 0, 0}};
                 auto te3 = QDateTime{QDate{2017, 01, 01}, QTime{2, 16, 0, 0}};
-                auto sqp3 = SqpRange{DateUtils::secondsSinceEpoch(ts3), DateUtils::secondsSinceEpoch(te3)};
+                auto sqp3 = DateTimeRange{DateUtils::secondsSinceEpoch(ts3), DateUtils::secondsSinceEpoch(te3)};
                 auto ts03 = QDateTime{QDate{2017, 01, 01}, QTime{2, 4, 0, 0}};
                 auto te03 = QDateTime{QDate{2017, 01, 01}, QTime{2, 22, 0, 0}};
-                auto sqp03 = SqpRange{DateUtils::secondsSinceEpoch(ts03), DateUtils::secondsSinceEpoch(te03)};
+                auto sqp03 = DateTimeRange{DateUtils::secondsSinceEpoch(ts03), DateUtils::secondsSinceEpoch(te03)};
                 auto var0 = std::make_shared<Variable>("");

core/tests/Variable/TestVariableController.cpp +1 -1

                 QDateTime start{QDate{2017, 01, 01}, QTime{0, 0, 0, 0}};
                 QDateTime end{QDate{2017, 01, 02}, QTime{0, 0, 0, 0}};
                 timeController->setDateTimeRange(
-                    SqpRange{DateUtils::secondsSinceEpoch(start), DateUtils::secondsSinceEpoch(end)});
+                    DateTimeRange{DateUtils::secondsSinceEpoch(start), DateUtils::secondsSinceEpoch(end)});
                 return timeController;
             }

core/tests/Variable/TestVariableSync.cpp +36 -36

              * Example: For a range between 00:00:10 and 00:00:20, the generated values are
              * {10,11,12,13,14,15,16,17,18,19,20}
              */
-            std::vector<double> values(const SqpRange &range)
+            std::vector<double> values(const DateTimeRange &range)
             {
                 QTime referenceTime{0, 0};
             }
             void validateRanges(VariableController &variableController,
-                                const std::map<int, SqpRange> &expectedRanges)
+                                const std::map<int, DateTimeRange> &expectedRanges)
             {
                 for (const auto &expectedRangeEntry : expectedRanges) {
                     auto variableIndex = expectedRangeEntry.first;
              *Variable creation operation in the controller
              */
             struct Create : public IOperation {
-                explicit Create(int index, const SqpRange &range) : m_Index{index},m_range(range) {}
+                explicit Create(int index, const DateTimeRange &range) : m_Index{index},m_range(range) {}
                 void exec(VariableController &variableController) const override
                 {
                                                                       std::make_unique<TestProvider>(), m_range);
                 }
                 int m_Index; ///< The index of the variable to create in the controller
-                SqpRange m_range;
+                DateTimeRange m_range;
             };
             /**
              * Variable move/shift operation in the controller
              */
             struct Move : public IOperation {
-                explicit Move(int index, const SqpRange &newRange, bool shift = false, int delayMS = 10)
+                explicit Move(int index, const DateTimeRange &newRange, bool shift = false, int delayMS = 10)
                         : m_Index{index}, m_NewRange{newRange}, m_Shift{shift}, m_DelayMs{delayMS}
                 {
                 }
                 }
                 int m_Index;         ///< The index of the variable to move
-                SqpRange m_NewRange; ///< The new range of the variable
+                DateTimeRange m_NewRange; ///< The new range of the variable
                 bool m_Shift;        ///< Performs a shift (
                 int m_DelayMs;       ///< wait the delay after running the request (
             };
              */
             struct Iteration {
                 std::shared_ptr<IOperation> m_Operation;  ///< Operation to perform
-                std::map<int, SqpRange> m_ExpectedRanges; ///< Expected ranges (by variable index)
+                std::map<int, DateTimeRange> m_ExpectedRanges; ///< Expected ranges (by variable index)
             };
             using Iterations = std::vector<Iteration>;
                 /// Generates a range according to a start time and a end time (the date is the same)
                 auto range = [](const QTime &startTime, const QTime &endTime) {
-                    return SqpRange{DateUtils::secondsSinceEpoch(QDateTime{{2017, 1, 1}, startTime, Qt::UTC}),
+                    return DateTimeRange{DateUtils::secondsSinceEpoch(QDateTime{{2017, 1, 1}, startTime, Qt::UTC}),
                                     DateUtils::secondsSinceEpoch(QDateTime{{2017, 1, 1}, endTime, Qt::UTC})};
                 };
                         QDateTime{{year, month, day}, QTime{hours, minutes, seconds}, Qt::UTC});
                 };
-                auto initialRange = SqpRange{dateTime(2017, 1, 1, 12, 0, 0), dateTime(2017, 1, 1, 13, 0, 0)};
+                auto initialRange = DateTimeRange{dateTime(2017, 1, 1, 12, 0, 0), dateTime(2017, 1, 1, 13, 0, 0)};
                 Iterations iterations{};
                 // Creates variables var0 and var1
                     iterations.push_back(
                         {std::make_shared<Move>(0, var0NewRange), {{0, var0NewRange}, {1, var0NewRange}}});
                 };
-                moveVar0(SqpRange{dateTime(2017, 1, 1, 12, 0, 0), dateTime(2017, 1, 1, 13, 0, 0)});
+                moveVar0(DateTimeRange{dateTime(2017, 1, 1, 12, 0, 0), dateTime(2017, 1, 1, 13, 0, 0)});
-                moveVar0(SqpRange{dateTime(2017, 1, 1, 14, 0, 0), dateTime(2017, 1, 1, 15, 0, 0)});
+                moveVar0(DateTimeRange{dateTime(2017, 1, 1, 14, 0, 0), dateTime(2017, 1, 1, 15, 0, 0)});
-                moveVar0(SqpRange{dateTime(2017, 1, 1, 8, 0, 0), dateTime(2017, 1, 1, 9, 0, 0)});
+                moveVar0(DateTimeRange{dateTime(2017, 1, 1, 8, 0, 0), dateTime(2017, 1, 1, 9, 0, 0)});
                 //    moveVar0(SqpRange{dateTime(2017, 1, 1, 7, 30, 0), dateTime(2017, 1, 1, 9, 30, 0)});
-                moveVar0(SqpRange{dateTime(2017, 1, 1, 2, 0, 0), dateTime(2017, 1, 1, 4, 0, 0)});
+                moveVar0(DateTimeRange{dateTime(2017, 1, 1, 2, 0, 0), dateTime(2017, 1, 1, 4, 0, 0)});
-                moveVar0(SqpRange{dateTime(2017, 1, 1, 6, 0, 0), dateTime(2017, 1, 1, 8, 0, 0)});
+                moveVar0(DateTimeRange{dateTime(2017, 1, 1, 6, 0, 0), dateTime(2017, 1, 1, 8, 0, 0)});
-                moveVar0(SqpRange{dateTime(2017, 1, 10, 6, 0, 0), dateTime(2017, 1, 15, 8, 0, 0)});
+                moveVar0(DateTimeRange{dateTime(2017, 1, 10, 6, 0, 0), dateTime(2017, 1, 15, 8, 0, 0)});
-                moveVar0(SqpRange{dateTime(2017, 1, 17, 6, 0, 0), dateTime(2017, 1, 25, 8, 0, 0)});
+                moveVar0(DateTimeRange{dateTime(2017, 1, 17, 6, 0, 0), dateTime(2017, 1, 25, 8, 0, 0)});
-                moveVar0(SqpRange{dateTime(2017, 1, 2, 6, 0, 0), dateTime(2017, 1, 8, 8, 0, 0)});
+                moveVar0(DateTimeRange{dateTime(2017, 1, 2, 6, 0, 0), dateTime(2017, 1, 8, 8, 0, 0)});
-                moveVar0(SqpRange{dateTime(2017, 4, 10, 6, 0, 0), dateTime(2017, 6, 15, 8, 0, 0)});
+                moveVar0(DateTimeRange{dateTime(2017, 4, 10, 6, 0, 0), dateTime(2017, 6, 15, 8, 0, 0)});
-                moveVar0(SqpRange{dateTime(2017, 1, 17, 6, 0, 0), dateTime(2017, 2, 25, 8, 0, 0)});
+                moveVar0(DateTimeRange{dateTime(2017, 1, 17, 6, 0, 0), dateTime(2017, 2, 25, 8, 0, 0)});
-                moveVar0(SqpRange{dateTime(2017, 7, 2, 6, 0, 0), dateTime(2017, 10, 8, 8, 0, 0)});
+                moveVar0(DateTimeRange{dateTime(2017, 7, 2, 6, 0, 0), dateTime(2017, 10, 8, 8, 0, 0)});
-                moveVar0(SqpRange{dateTime(2017, 4, 10, 6, 0, 0), dateTime(2017, 6, 15, 8, 0, 0)});
+                moveVar0(DateTimeRange{dateTime(2017, 4, 10, 6, 0, 0), dateTime(2017, 6, 15, 8, 0, 0)});
-                moveVar0(SqpRange{dateTime(2017, 1, 17, 6, 0, 0), dateTime(2017, 2, 25, 8, 0, 0)});
+                moveVar0(DateTimeRange{dateTime(2017, 1, 17, 6, 0, 0), dateTime(2017, 2, 25, 8, 0, 0)});
-                moveVar0(SqpRange{dateTime(2017, 7, 2, 6, 0, 0), dateTime(2017, 10, 8, 8, 0, 0)});
+                moveVar0(DateTimeRange{dateTime(2017, 7, 2, 6, 0, 0), dateTime(2017, 10, 8, 8, 0, 0)});
-                moveVar0(SqpRange{dateTime(2017, 4, 10, 6, 0, 0), dateTime(2017, 6, 15, 8, 0, 0)});
+                moveVar0(DateTimeRange{dateTime(2017, 4, 10, 6, 0, 0), dateTime(2017, 6, 15, 8, 0, 0)});
-                moveVar0(SqpRange{dateTime(2017, 1, 17, 6, 0, 0), dateTime(2017, 2, 25, 8, 0, 0)});
+                moveVar0(DateTimeRange{dateTime(2017, 1, 17, 6, 0, 0), dateTime(2017, 2, 25, 8, 0, 0)});
-                moveVar0(SqpRange{dateTime(2017, 7, 2, 6, 0, 0), dateTime(2017, 10, 8, 8, 0, 0)});
+                moveVar0(DateTimeRange{dateTime(2017, 7, 2, 6, 0, 0), dateTime(2017, 10, 8, 8, 0, 0)});
-                moveVar0(SqpRange{dateTime(2017, 4, 10, 6, 0, 0), dateTime(2017, 6, 15, 8, 0, 0)});
+                moveVar0(DateTimeRange{dateTime(2017, 4, 10, 6, 0, 0), dateTime(2017, 6, 15, 8, 0, 0)});
-                moveVar0(SqpRange{dateTime(2017, 1, 17, 6, 0, 0), dateTime(2017, 2, 25, 8, 0, 0)});
+                moveVar0(DateTimeRange{dateTime(2017, 1, 17, 6, 0, 0), dateTime(2017, 2, 25, 8, 0, 0)});
-                moveVar0(SqpRange{dateTime(2017, 7, 2, 6, 0, 0), dateTime(2017, 10, 8, 8, 0, 0)});
+                moveVar0(DateTimeRange{dateTime(2017, 7, 2, 6, 0, 0), dateTime(2017, 10, 8, 8, 0, 0)});
                 QTest::newRow("sync2") << syncId << initialRange << iterations << 4000;
                 /// Generates a range according to a start time and a end time (the date is the same)
                 auto range = [](const QTime &startTime, const QTime &endTime) {
-                    return SqpRange{DateUtils::secondsSinceEpoch(QDateTime{{2017, 1, 1}, startTime, Qt::UTC}),
+                    return DateTimeRange{DateUtils::secondsSinceEpoch(QDateTime{{2017, 1, 1}, startTime, Qt::UTC}),
                                     DateUtils::secondsSinceEpoch(QDateTime{{2017, 1, 1}, endTime, Qt::UTC})};
                 };
                 // ////////////// //
                 QTest::addColumn<QUuid>("syncId");
-                QTest::addColumn<SqpRange>("initialRange");
+                QTest::addColumn<DateTimeRange>("initialRange");
                 QTest::addColumn<Iterations>("iterations");
                 QTest::addColumn<int>("operationDelay");
                 // ////////////// //
                 QTest::addColumn<QUuid>("syncId");
-                QTest::addColumn<SqpRange>("initialRange");
+                QTest::addColumn<DateTimeRange>("initialRange");
                 QTest::addColumn<Iterations>("creations");
                 QTest::addColumn<Iterations>("iterations");
                 //variableController.setTimeController(&timeController);
                 QFETCH(QUuid, syncId);
-                QFETCH(SqpRange, initialRange);
+                QFETCH(DateTimeRange, initialRange);
                 timeController.setDateTimeRange(initialRange);
                 // Synchronization group used
                 //variableController.setTimeController(&timeController);
                 QFETCH(QUuid, syncId);
-                QFETCH(SqpRange, initialRange);
+                QFETCH(DateTimeRange, initialRange);
                 timeController.setDateTimeRange(initialRange);
                 // Synchronization group used

gui/include/TimeWidget/TimeWidget.h +3 -3

                 explicit TimeWidget(QWidget *parent = 0);
                 virtual ~TimeWidget();
-                void setTimeRange(SqpRange time);
+                void setTimeRange(DateTimeRange time);
-                SqpRange timeRange() const;
+                DateTimeRange timeRange() const;
             signals:
                 /// Signal emitted when the time parameters has beed updated
-                void timeUpdated(SqpRange time);
+                void timeUpdated(DateTimeRange time);
             public slots:
                 /// slot called when time parameters update has ben requested

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

                 static PlottablesMap create(std::shared_ptr<Variable> variable, QCustomPlot &plot) noexcept;
                 static void updateData(PlottablesMap &plottables, std::shared_ptr<Variable> variable,
-                                       const SqpRange &dateTime);
+                                       const DateTimeRange &dateTime);
                 static void setYAxisRange(std::shared_ptr<Variable> variable, QCustomPlot &plot) noexcept;
             };

gui/include/Visualization/VisualizationGraphWidget.h +10 -10

             class QCPRange;
             class QCustomPlot;
-            class SqpRange;
+            class DateTimeRange;
             class Variable;
             class VisualizationWidget;
             class VisualizationZoneWidget;
                 /// Sets graph options
                 void setFlags(GraphFlags flags);
-                void addVariable(std::shared_ptr<Variable> variable, SqpRange range);
+                void addVariable(std::shared_ptr<Variable> variable, DateTimeRange range);
                 /// Removes a variable from the graph
                 void removeVariable(std::shared_ptr<Variable> variable) noexcept;
                 /// Sets the y-axis range based on the data of a variable
                 void setYRange(std::shared_ptr<Variable> variable);
-                SqpRange graphRange() const noexcept;
+                DateTimeRange graphRange() const noexcept;
-                void setGraphRange(const SqpRange &range, bool calibration = false);
+                void setGraphRange(const DateTimeRange &range, bool calibration = false);
                 void setAutoRangeOnVariableInitialization(bool value);
                 // Zones
                 /// Returns the ranges of all the selection zones on the graph
-                QVector<SqpRange> selectionZoneRanges() const;
+                QVector<DateTimeRange> selectionZoneRanges() const;
                 /// Adds new selection zones in the graph
-                void addSelectionZones(const QVector<SqpRange> &ranges);
+                void addSelectionZones(const QVector<DateTimeRange> &ranges);
                 /// Adds a new selection zone in the graph
-                VisualizationSelectionZoneItem *addSelectionZone(const QString &name, const SqpRange &range);
+                VisualizationSelectionZoneItem *addSelectionZone(const QString &name, const DateTimeRange &range);
                 /// Removes the specified selection zone
                 void removeSelectionZone(VisualizationSelectionZoneItem *selectionZone);
                 void removeHorizontalCursor();
             signals:
-                void synchronize(const SqpRange &range, const SqpRange &oldRange);
+                void synchronize(const DateTimeRange &range, const DateTimeRange &oldRange);
-                void requestDataLoading(QVector<std::shared_ptr<Variable> > variable, const SqpRange &range,
+                void requestDataLoading(QVector<std::shared_ptr<Variable> > variable, const DateTimeRange &range,
                                         bool synchronise);
                 /// Signal emitted when the variable is about to be removed from the graph
                 void onDataCacheVariableUpdated();
-                void onUpdateVarDisplaying(std::shared_ptr<Variable> variable, const SqpRange &range);
+                void onUpdateVarDisplaying(std::shared_ptr<Variable> variable, const DateTimeRange &range);
             };
             #endif // SCIQLOP_VISUALIZATIONGRAPHWIDGET_H

gui/include/Visualization/VisualizationSelectionZoneItem.h +2 -2

             signals:
                 /// Signal emitted when the zone range is edited manually
-                void rangeEdited(const SqpRange &range);
+                void rangeEdited(const DateTimeRange &range);
             public:
                 VisualizationSelectionZoneItem(QCustomPlot *plot);
                 void setName(const QString &name);
                 QString name() const;
-                SqpRange range() const;
+                DateTimeRange range() const;
                 void setRange(double tstart, double tend);
                 void setStart(double tstart);
                 void setEnd(double tend);

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

                 /// Slot called when a variable is about to be deleted from SciQlop
                 void onVariableAboutToBeDeleted(std::shared_ptr<Variable> variable) noexcept;
-                void onRangeChanged(std::shared_ptr<Variable> variable, const SqpRange &range) noexcept;
+                void onRangeChanged(std::shared_ptr<Variable> variable, const DateTimeRange &range) noexcept;
             protected:
                 void closeEvent(QCloseEvent *event) override;

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

                 /// Sets the range of the zone, only works if there is at least one graph in the zone
                 /// Note: calibrations between graphs are lost.
-                void setZoneRange(const SqpRange &range);
+                void setZoneRange(const DateTimeRange &range);
                 /// Adds a graph widget
                 void addGraph(VisualizationGraphWidget *graphWidget);

gui/include/Visualization/operations/RescaleAxeOperation.h +1 -1

                  * Ctor
                  * @param variable the variable to remove from widgets
                  */
-                explicit RescaleAxeOperation(std::shared_ptr<Variable> variable, const SqpRange &range);
+                explicit RescaleAxeOperation(std::shared_ptr<Variable> variable, const DateTimeRange &range);
                 void visitEnter(VisualizationWidget *widget) override final;
                 void visitLeave(VisualizationWidget *widget) override final;

gui/src/Catalogue/CatalogueEventsModel.cpp +1 -1

                 QVector<std::shared_ptr<DBEvent> > eventList;
                 QVector<std::shared_ptr<DBEventProduct> > eventProductList;
-                SqpRange firstTimeRange;
+                DateTimeRange firstTimeRange;
                 for (const auto &index : indexes) {
                     if (index.column() == 0) { // only the first column

gui/src/Catalogue/CatalogueEventsWidget.cpp +7 -7

                                     for (auto zoneName : m_ZonesForTimeMode) {
                                         if (auto zone = tab->getZoneWithName(zoneName)) {
-                                            SqpRange eventRange;
+                                            DateTimeRange eventRange;
                                             eventRange.m_TStart = event->getTStart();
                                             eventRange.m_TEnd = event->getTEnd();
                                             zone->setZoneRange(eventRange);
                     }
                 }
-                QVector<SqpRange> getGraphRanges(const std::shared_ptr<DBEvent> &event)
+                QVector<DateTimeRange> getGraphRanges(const std::shared_ptr<DBEvent> &event)
                 {
                     // Retrieves the range of each product and the maximum size
-                    QVector<SqpRange> graphRanges;
+                    QVector<DateTimeRange> graphRanges;
                     double maxDt = 0;
                     for (auto eventProduct : event->getEventProducts()) {
-                        SqpRange eventRange;
+                        DateTimeRange eventRange;
                         eventRange.m_TStart = eventProduct.getTStart();
                         eventRange.m_TEnd = eventProduct.getTEnd();
                         graphRanges << eventRange;
                     maxDt *= (100.0 + EVENT_RANGE_MARGE) / 100.0;
                     // Corrects the graph ranges so that they all have the same size
-                    QVector<SqpRange> correctedGraphRanges;
+                    QVector<DateTimeRange> correctedGraphRanges;
                     for (auto range : graphRanges) {
                         auto dt = range.m_TEnd - range.m_TStart;
                         auto diff = qAbs((maxDt - dt) / 2.0);
-                        SqpRange correctedRange;
+                        DateTimeRange correctedRange;
                         correctedRange.m_TStart = range.m_TStart - diff;
                         correctedRange.m_TEnd = range.m_TEnd + diff;
                         auto range = *itRange;
                         ++itRange;
-                        SqpRange productRange;
+                        DateTimeRange productRange;
                         productRange.m_TStart = eventProduct.getTStart();
                         productRange.m_TEnd = eventProduct.getTEnd();

gui/src/Catalogue/CatalogueTreeItems/CatalogueTreeItem.cpp +1 0

                     impl->m_Catalogue->addEvent(event->getUniqId());
                     sqpApp->catalogueController().updateCatalogue(impl->m_Catalogue);
                 }
+                return true;
             }
             std::shared_ptr<DBCatalogue> CatalogueTreeItem::catalogue() const

gui/src/SqpApplication.cpp +2 -2

                             SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)), Qt::DirectConnection);
                     connect(m_VariableController.get(),
-                            SIGNAL(rangeChanged(std::shared_ptr<Variable>, const SqpRange &)),
+                            SIGNAL(rangeChanged(std::shared_ptr<Variable>, const DateTimeRange &)),
                             m_VisualizationController.get(),
-                            SIGNAL(rangeChanged(std::shared_ptr<Variable>, const SqpRange &)));
+                            SIGNAL(rangeChanged(std::shared_ptr<Variable>, const DateTimeRange &)));
                     m_DataSourceController->moveToThread(&m_DataSourceControllerThread);

gui/src/TimeWidget/TimeWidget.cpp +4 -4

                 ui->startDateTimeEdit->setDateTime(startDateTime);
                 ui->endDateTimeEdit->setDateTime(endDateTime);
-                auto dateTime = SqpRange{DateUtils::secondsSinceEpoch(startDateTime),
+                auto dateTime = DateTimeRange{DateUtils::secondsSinceEpoch(startDateTime),
                                          DateUtils::secondsSinceEpoch(endDateTime)};
                 sqpApp->timeController().setDateTimeRange(dateTime);
                 delete ui;
             }
-            void TimeWidget::setTimeRange(SqpRange time)
+            void TimeWidget::setTimeRange(DateTimeRange time)
             {
                 auto startDateTime = DateUtils::dateTime(time.m_TStart);
                 auto endDateTime = DateUtils::dateTime(time.m_TEnd);
                 ui->endDateTimeEdit->setDateTime(endDateTime);
             }
-            SqpRange TimeWidget::timeRange() const
+            DateTimeRange TimeWidget::timeRange() const
             {
-                return SqpRange{DateUtils::secondsSinceEpoch(ui->startDateTimeEdit->dateTime()),
+                return DateTimeRange{DateUtils::secondsSinceEpoch(ui->startDateTimeEdit->dateTime()),
                                 DateUtils::secondsSinceEpoch(ui->endDateTimeEdit->dateTime())};
             }

gui/src/Visualization/VisualizationGraphHelper.cpp +11 -11

              */
             template <typename T, typename Enabled = void>
             struct PlottablesUpdater {
-                static void setPlotYAxisRange(T &, const SqpRange &, QCustomPlot &)
+                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 SqpRange &, bool)
+                static void updatePlottables(T &, PlottablesMap &, const DateTimeRange &, bool)
                 {
                     qCCritical(LOG_VisualizationGraphHelper())
                         << QObject::tr("Can't update plottables: unmanaged data series type");
             struct PlottablesUpdater<T,
                                      typename std::enable_if_t<std::is_base_of<ScalarSeries, T>::value
                                                                or std::is_base_of<VectorSeries, T>::value> > {
-                static void setPlotYAxisRange(T &dataSeries, const SqpRange &xAxisRange, QCustomPlot &plot)
+                static void setPlotYAxisRange(T &dataSeries, const DateTimeRange &xAxisRange, QCustomPlot &plot)
                 {
                     auto minValue = 0., maxValue = 0.;
                     plot.yAxis->setRange(QCPRange{minValue, maxValue});
                 }
-                static void updatePlottables(T &dataSeries, PlottablesMap &plottables, const SqpRange &range,
+                static void updatePlottables(T &dataSeries, PlottablesMap &plottables, const DateTimeRange &range,
                                              bool rescaleAxes)
                 {
             template <typename T>
             struct PlottablesUpdater<T,
                                      typename std::enable_if_t<std::is_base_of<SpectrogramSeries, T>::value> > {
-                static void setPlotYAxisRange(T &dataSeries, const SqpRange &xAxisRange, QCustomPlot &plot)
+                static void setPlotYAxisRange(T &dataSeries, const DateTimeRange &xAxisRange, QCustomPlot &plot)
                 {
                     double min, max;
                     std::tie(min, max) = dataSeries.yBounds();
                     }
                 }
-                static void updatePlottables(T &dataSeries, PlottablesMap &plottables, const SqpRange &range,
+                static void updatePlottables(T &dataSeries, PlottablesMap &plottables, const DateTimeRange &range,
                                              bool rescaleAxes)
                 {
                     if (plottables.empty()) {
             struct IPlottablesHelper {
                 virtual ~IPlottablesHelper() noexcept = default;
                 virtual PlottablesMap create(QCustomPlot &plot) const = 0;
-                virtual void setYAxisRange(const SqpRange &xAxisRange, QCustomPlot &plot) const = 0;
+                virtual void setYAxisRange(const DateTimeRange &xAxisRange, QCustomPlot &plot) const = 0;
-                virtual void update(PlottablesMap &plottables, const SqpRange &range,
+                virtual void update(PlottablesMap &plottables, const DateTimeRange &range,
                                     bool rescaleAxes = false) const = 0;
             };
                     return PlottablesCreator<T>::createPlottables(plot);
                 }
-                void update(PlottablesMap &plottables, const SqpRange &range, bool rescaleAxes) const override
+                void update(PlottablesMap &plottables, const DateTimeRange &range, bool rescaleAxes) const override
                 {
                     if (m_DataSeries) {
                         PlottablesUpdater<T>::updatePlottables(*m_DataSeries, plottables, range, rescaleAxes);
                     }
                 }
-                void setYAxisRange(const SqpRange &xAxisRange, QCustomPlot &plot) const override
+                void setYAxisRange(const DateTimeRange &xAxisRange, QCustomPlot &plot) const override
                 {
                     if (m_DataSeries) {
                         PlottablesUpdater<T>::setPlotYAxisRange(*m_DataSeries, xAxisRange, plot);
             void VisualizationGraphHelper::updateData(PlottablesMap &plottables,
                                                       std::shared_ptr<Variable> variable,
-                                                      const SqpRange &dateTime)
+                                                      const DateTimeRange &dateTime)
             {
                 auto helper = createHelper(variable);
                 helper->update(plottables, dateTime);

gui/src/Visualization/VisualizationGraphWidget.cpp +14 -14

                 }
                 void updateData(PlottablesMap &plottables, std::shared_ptr<Variable> variable,
-                                const SqpRange &range)
+                                const DateTimeRange &range)
                 {
                     VisualizationGraphHelper::updateData(plottables, variable, range);
                 impl->m_Flags = std::move(flags);
             }
-            void VisualizationGraphWidget::addVariable(std::shared_ptr<Variable> variable, SqpRange range)
+            void VisualizationGraphWidget::addVariable(std::shared_ptr<Variable> variable, DateTimeRange range)
             {
                 /// Lambda used to set graph's units and range according to the variable passed in parameter
-                auto loadRange = [this](std::shared_ptr<Variable> variable, const SqpRange &range) {
+                auto loadRange = [this](std::shared_ptr<Variable> variable, const DateTimeRange &range) {
                     impl->m_RenderingDelegate->setAxesUnits(*variable);
                     this->setFlags(GraphFlag::DisableAll);
                 VisualizationGraphHelper::setYAxisRange(variable, *ui->widget);
             }
-            SqpRange VisualizationGraphWidget::graphRange() const noexcept
+            DateTimeRange VisualizationGraphWidget::graphRange() const noexcept
             {
                 auto graphRange = ui->widget->xAxis->range();
-                return SqpRange{graphRange.lower, graphRange.upper};
+                return DateTimeRange{graphRange.lower, graphRange.upper};
             }
-            void VisualizationGraphWidget::setGraphRange(const SqpRange &range, bool calibration)
+            void VisualizationGraphWidget::setGraphRange(const DateTimeRange &range, bool calibration)
             {
                 qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::setGraphRange START");
                 impl->m_VariableAutoRangeOnInit = value;
             }
-            QVector<SqpRange> VisualizationGraphWidget::selectionZoneRanges() const
+            QVector<DateTimeRange> VisualizationGraphWidget::selectionZoneRanges() const
             {
-                QVector<SqpRange> ranges;
+                QVector<DateTimeRange> ranges;
                 for (auto zone : impl->m_SelectionZones) {
                     ranges << zone->range();
                 }
                 return ranges;
             }
-            void VisualizationGraphWidget::addSelectionZones(const QVector<SqpRange> &ranges)
+            void VisualizationGraphWidget::addSelectionZones(const QVector<DateTimeRange> &ranges)
             {
                 for (const auto &range : ranges) {
                     // note: ownership is transfered to QCustomPlot
             }
             VisualizationSelectionZoneItem *VisualizationGraphWidget::addSelectionZone(const QString &name,
-                                                                                       const SqpRange &range)
+                                                                                       const DateTimeRange &range)
             {
                 // note: ownership is transfered to QCustomPlot
                 auto zone = new VisualizationSelectionZoneItem(&plot());
                                                         << QThread::currentThread()->objectName() << "DoAcqui"
                                                         << impl->m_Flags.testFlag(GraphFlag::EnableAcquisition);
-                auto graphRange = SqpRange{t1.lower, t1.upper};
+                auto graphRange = DateTimeRange{t1.lower, t1.upper};
-                auto oldGraphRange = SqpRange{t2.lower, t2.upper};
+                auto oldGraphRange = DateTimeRange{t2.lower, t2.upper};
                 if (impl->m_Flags.testFlag(GraphFlag::EnableAcquisition)) {
                     QVector<std::shared_ptr<Variable> > variableUnderGraphVector;
             void VisualizationGraphWidget::onDataCacheVariableUpdated()
             {
                 auto graphRange = ui->widget->xAxis->range();
-                auto dateTime = SqpRange{graphRange.lower, graphRange.upper};
+                auto dateTime = DateTimeRange{graphRange.lower, graphRange.upper};
                 for (auto &variableEntry : impl->m_VariableToPlotMultiMap) {
                     auto variable = variableEntry.first;
             }
             void VisualizationGraphWidget::onUpdateVarDisplaying(std::shared_ptr<Variable> variable,
-                                                                 const SqpRange &range)
+                                                                 const DateTimeRange &range)
             {
                 auto it = impl->m_VariableToPlotMultiMap.find(variable);
                 if (it != impl->m_VariableToPlotMultiMap.end()) {

gui/src/Visualization/VisualizationSelectionZoneItem.cpp +2 -2

                 return impl->m_NameLabelItem->text();
             }
-            SqpRange VisualizationSelectionZoneItem::range() const
+            DateTimeRange VisualizationSelectionZoneItem::range() const
             {
-                SqpRange range;
+                DateTimeRange range;
                 range.m_TStart = impl->m_T1 <= impl->m_T2 ? impl->m_T1 : impl->m_T2;
                 range.m_TEnd = impl->m_T1 > impl->m_T2 ? impl->m_T1 : impl->m_T2;
                 return range;

gui/src/Visualization/VisualizationWidget.cpp +1 -1

             }
             void VisualizationWidget::onRangeChanged(std::shared_ptr<Variable> variable,
-                                                     const SqpRange &range) noexcept
+                                                     const DateTimeRange &range) noexcept
             {
                 // Calls the operation of rescaling all graph that contrains variable in the visualization
                 auto rescaleVariableOperation = RescaleAxeOperation{variable, range};

gui/src/Visualization/VisualizationZoneWidget.cpp +4 -4

                 delete ui;
             }
-            void VisualizationZoneWidget::setZoneRange(const SqpRange &range)
+            void VisualizationZoneWidget::setZoneRange(const DateTimeRange &range)
             {
                 if (auto graph = firstGraph()) {
                     graph->setGraphRange(range);
                 // Lambda to synchronize zone widget
-                auto synchronizeZoneWidget = [this, graphWidget](const SqpRange &graphRange,
+                auto synchronizeZoneWidget = [this, graphWidget](const DateTimeRange &graphRange,
-                                                                 const SqpRange &oldGraphRange) {
+                                                                 const DateTimeRange &oldGraphRange) {
                     auto zoomType = VariableController::getZoomType(graphRange, oldGraphRange);
                     auto frameLayout = ui->dragDropContainer->layout();
                 connect(graphWidget, &VisualizationGraphWidget::variableAboutToBeRemoved, this,
                         &VisualizationZoneWidget::onVariableAboutToBeRemoved);
-                auto range = SqpRange{};
+                auto range = DateTimeRange{};
                 if (auto firstGraph = this->firstGraph()) {
                     // Case of a new graph in a existant zone
                     range = firstGraph->graphRange();

gui/src/Visualization/operations/RescaleAxeOperation.cpp +3 -3

             Q_LOGGING_CATEGORY(LOG_RescaleAxeOperation, "RescaleAxeOperation")
             struct RescaleAxeOperation::RescaleAxeOperationPrivate {
-                explicit RescaleAxeOperationPrivate(std::shared_ptr<Variable> variable, const SqpRange &range)
+                explicit RescaleAxeOperationPrivate(std::shared_ptr<Variable> variable, const DateTimeRange &range)
                         : m_Variable{variable}, m_Range{range}
                 {
                 }
                 std::shared_ptr<Variable> m_Variable;
-                SqpRange m_Range;
+                DateTimeRange m_Range;
             };
-            RescaleAxeOperation::RescaleAxeOperation(std::shared_ptr<Variable> variable, const SqpRange &range)
+            RescaleAxeOperation::RescaleAxeOperation(std::shared_ptr<Variable> variable, const DateTimeRange &range)
                     : impl{spimpl::make_unique_impl<RescaleAxeOperationPrivate>(variable, range)}
             {
             }

plugins/amda/CMakeLists.txt +3 -3

             GET_PROPERTY(CORE_PYTHON_PATH GLOBAL PROPERTY CORE_PYTHON_PATH)
-            declare_test(TestAmdaFileParserEmbed TestAmdaFileParserEmbed "tests/PyTestAmdaWrapperExe.cpp" "amdaplugin;pytestamdalib")
+            declare_test(TestAmdaFileParserEmbed TestAmdaFileParserEmbed "tests/PyTestAmdaWrapperExe.cpp" "pytestamdalib")
             target_compile_definitions(TestAmdaFileParserEmbed PRIVATE -DPYTESTAMDA_SCRIPT="${CMAKE_CURRENT_LIST_DIR}/tests/TestAmdaFileParser.py")
             set_tests_properties(TestAmdaFileParserEmbed  PROPERTIES ENVIRONMENT PYTHONPATH=${CMAKE_CURRENT_BINARY_DIR}:${CORE_PYTHON_PATH})
-            declare_test(TestAmdaDownloadEmbed TestAmdaDownloadEmbed "tests/PyTestAmdaWrapperExe.cpp" "amdaplugin;pytestamdalib")
+            declare_test(TestAmdaDownloadEmbed TestAmdaDownloadEmbed "tests/PyTestAmdaWrapperExe.cpp" "pytestamdalib")
             target_compile_definitions(TestAmdaDownloadEmbed PRIVATE -DPYTESTAMDA_SCRIPT="${CMAKE_CURRENT_LIST_DIR}/tests/TestAmdaDownload.py")
             set_tests_properties(TestAmdaDownloadEmbed  PROPERTIES ENVIRONMENT PYTHONPATH=${CMAKE_CURRENT_BINARY_DIR}:${CORE_PYTHON_PATH})
-            declare_test(TestAmdaMiniFuzzEmbed TestAmdaMiniFuzzEmbed "tests/PyTestAmdaWrapperExe.cpp" "amdaplugin;pytestamdalib")
+            declare_test(TestAmdaMiniFuzzEmbed TestAmdaMiniFuzzEmbed "tests/PyTestAmdaWrapperExe.cpp" "pytestamdalib")
             target_compile_definitions(TestAmdaMiniFuzzEmbed PRIVATE -DPYTESTAMDA_SCRIPT="${CMAKE_CURRENT_LIST_DIR}/tests/TestAmdaMiniFuzz.py")
             set_tests_properties(TestAmdaMiniFuzzEmbed  PROPERTIES ENVIRONMENT PYTHONPATH=${CMAKE_CURRENT_BINARY_DIR}:${CORE_PYTHON_PATH})

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

                 void requestDataAborting(QUuid acqIdentifier) override;
             private:
-                void retrieveData(QUuid token, const SqpRange &dateTime, const QVariantHash &data);
+                void retrieveData(QUuid token, const DateTimeRange &dateTime, const QVariantHash &data);
                 void updateRequestProgress(QUuid acqIdentifier, std::shared_ptr<QNetworkRequest> request,
                                            double progress);

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

                 }
             }
-            void AmdaProvider::retrieveData(QUuid token, const SqpRange &dateTime, const QVariantHash &data)
+            void AmdaProvider::retrieveData(QUuid token, const DateTimeRange &dateTime, const QVariantHash &data)
             {
                 // Retrieves product ID from data: if the value is invalid, no request is made
                 auto productId = data.value(AMDA_XML_ID_KEY).toString();

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

                 }
             }
-            void FuzzingState::updateRanges(VariableId variableId, const SqpRange &newRange)
+            void FuzzingState::updateRanges(VariableId variableId, const DateTimeRange &newRange)
             {
                 auto syncGroupId = this->syncGroupId(variableId);

plugins/amda/tests/FuzzingDefs.h +3 -3

             class Variable;
             struct VariableState {
                 std::shared_ptr<Variable> m_Variable{nullptr};
-                SqpRange m_Range{INVALID_RANGE};
+                DateTimeRange m_Range{INVALID_RANGE};
             };
             using VariableId = int;
              */
             struct SyncGroup {
                 std::set<VariableId> m_Variables{};
-                SqpRange m_Range{INVALID_RANGE};
+                DateTimeRange m_Range{INVALID_RANGE};
             };
             using SyncGroupId = QUuid;
                 /// 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 SqpRange &newRange);
+                void updateRanges(VariableId variableId, const DateTimeRange &newRange);
                 VariablesPool m_VariablesPool;
                 SyncGroupsPool m_SyncGroupsPool;

plugins/amda/tests/FuzzingOperations.cpp +9 -9

                                                               << "(metadata:" << variableMetadata << ")...";
                     auto newVariable
-                        = variableController.createVariable(variableName, variableMetadata, variableProvider, properties.value(INITIAL_RANGE_PROPERTY).value<SqpRange>());
+                        = variableController.createVariable(variableName, variableMetadata, variableProvider, properties.value(INITIAL_RANGE_PROPERTY).value<DateTimeRange>());
                     // Updates variable's state
                     auto &variableState = fuzzingState.variableState(variableId);
-                    variableState.m_Range = properties.value(INITIAL_RANGE_PROPERTY).value<SqpRange>();
+                    variableState.m_Range = properties.value(INITIAL_RANGE_PROPERTY).value<DateTimeRange>();
                     std::swap(variableState.m_Variable, newVariable);
                 }
             };
              */
             struct MoveOperation : public IFuzzingOperation {
                 using MoveFunction = std::function<double(double currentValue, double maxValue)>;
-                using MaxMoveFunction = std::function<double(const SqpRange &range, const SqpRange &maxRange)>;
+                using MaxMoveFunction = std::function<double(const DateTimeRange &range, const DateTimeRange &maxRange)>;
                 explicit MoveOperation(MoveFunction rangeStartMoveFun, MoveFunction rangeEndMoveFun,
                                        MaxMoveFunction maxMoveFun,
                     // Gets the max range defined
                     auto maxRange = properties.value(MAX_RANGE_PROPERTY, QVariant::fromValue(INVALID_RANGE))
-                                        .value<SqpRange>();
+                                        .value<DateTimeRange>();
                     auto variableRange = variableState.m_Range;
                     if (maxRange == INVALID_RANGE || variableRange.m_TStart < maxRange.m_TStart
                     // Moves variable to its new range
                     auto isSynchronized = !fuzzingState.syncGroupId(variableId).isNull();
-                    auto newVariableRange = SqpRange{m_RangeStartMoveFun(variableRange.m_TStart, delta),
+                    auto newVariableRange = DateTimeRange{m_RangeStartMoveFun(variableRange.m_TStart, delta),
                                                      m_RangeEndMoveFun(variableRange.m_TEnd, delta)};
                     qCInfo(LOG_FuzzingOperations()).noquote() << "Performing" << m_Label << "on"
                                                               << variable->name() << "(from" << variableRange
                     case FuzzingOperationType::PAN_LEFT:
                         return std::make_unique<MoveOperation>(
                             std::minus<double>(), std::minus<double>(),
-                            [](const SqpRange &range, const SqpRange &maxRange) {
+                            [](const DateTimeRange &range, const DateTimeRange &maxRange) {
                                 return range.m_TStart - maxRange.m_TStart;
                             },
                             QStringLiteral("Pan left operation"));
                     case FuzzingOperationType::PAN_RIGHT:
                         return std::make_unique<MoveOperation>(
                             std::plus<double>(), std::plus<double>(),
-                            [](const SqpRange &range, const SqpRange &maxRange) {
+                            [](const DateTimeRange &range, const DateTimeRange &maxRange) {
                                 return maxRange.m_TEnd - range.m_TEnd;
                             },
                             QStringLiteral("Pan right operation"));
                     case FuzzingOperationType::ZOOM_IN:
                         return std::make_unique<MoveOperation>(
                             std::plus<double>(), std::minus<double>(),
-                            [](const SqpRange &range, const SqpRange &maxRange) {
+                            [](const DateTimeRange &range, const DateTimeRange &maxRange) {
                                 Q_UNUSED(maxRange)
                                 return range.m_TEnd - (range.m_TStart + range.m_TEnd) / 2.;
                             },
                     case FuzzingOperationType::ZOOM_OUT:
                         return std::make_unique<MoveOperation>(
                             std::minus<double>(), std::plus<double>(),
-                            [](const SqpRange &range, const SqpRange &maxRange) {
+                            [](const DateTimeRange &range, const DateTimeRange &maxRange) {
                                 return std::min(range.m_TStart - maxRange.m_TStart,
                                                 maxRange.m_TEnd - range.m_TEnd);
                             },

plugins/amda/tests/FuzzingValidators.cpp +2 -2

              * @param getVariableRangeFun the function to retrieve the range from the variable
              * @remarks if the variable is null, checks that the expected range is the invalid range
              */
-            void validateRange(std::shared_ptr<Variable> variable, const SqpRange &expectedRange,
+            void validateRange(std::shared_ptr<Variable> variable, const DateTimeRange &expectedRange,
-                               std::function<SqpRange(const Variable &)> getVariableRangeFun)
+                               std::function<DateTimeRange(const Variable &)> getVariableRangeFun)
             {
                 auto compare = [](const auto &range, const auto &expectedRange, const auto &message) {
                     if (range == expectedRange) {

plugins/amda/tests/PyTestAmdaWrapper.cpp +5 -14

             #include <pywrappers_common.h>
             #include <CoreWrappers.h>
+            #include "PyTestAmdaWrapper.h"
             using namespace std::chrono;
-            namespace py = pybind11;
                 py::class_<VariableController>(m, "VariableController")
                         .def_static("createVariable",[](const QString &name,
-                                    std::shared_ptr<IDataProvider> provider, const SqpRange& range){
+                                    std::shared_ptr<IDataProvider> provider, const DateTimeRange& range){
                     return sqpApp->variableController().createVariable(name, {{"dataType", "vector"}, {"xml:id", "c1_b"}}, provider, range);
                 })
                         .def_static("hasPendingDownloads",
                                     [](std::shared_ptr<Variable> variable){
                     sqpApp->variableController().deleteVariable(variable);}
                                     )
-                        .def_static("update_range",[](std::shared_ptr<Variable> variable, const SqpRange &range, bool synchronise){
+                        .def_static("update_range",[](std::shared_ptr<Variable> variable, const DateTimeRange &range, bool synchronise){
                     sqpApp->variableController().onRequestDataLoading({variable}, range, synchronise);
                 })
                         .def_static("wait_for_downloads",[](){
                 });
                 py::class_<TimeController>(m,"TimeController")
-                        .def_static("setTime", [](SqpRange range){sqpApp->timeController().setDateTimeRange(range);});
+                        .def_static("setTime", [](DateTimeRange range){sqpApp->timeController().setDateTimeRange(range);});
                 auto amda_provider = std::make_shared<AmdaProvider>();
             }
-            int pytestamda_test(const char* testScriptPath )
-                py::scoped_interpreter guard{};
-                py::globals()["__file__"] = py::str(testScriptPath);
-                py::eval_file(testScriptPath);
-                return 0;

plugins/amda/tests/PyTestAmdaWrapperExe.cpp +2 -2

             --                     Mail : alexis.jeandet@member.fsf.org
             ----------------------------------------------------------------------------*/
             #include <QString>
-            extern int pytestamda_test(const char* testScriptPath );
+            #include "PyTestAmdaWrapper.h"
             int main(int argc, char** argv)
             {
-                pytestamda_test(PYTESTAMDA_SCRIPT);
+                int r = pytestamda_test(PYTESTAMDA_SCRIPT);
                 return 0;
             }

plugins/amda/tests/TestAmdaAcquisition.cpp +10 -10

             const auto OPERATION_DELAY = 10000;
             template <typename T>
-            bool compareDataSeries(std::shared_ptr<IDataSeries> candidate, SqpRange candidateCacheRange,
+            bool compareDataSeries(std::shared_ptr<IDataSeries> candidate, DateTimeRange candidateCacheRange,
                                    std::shared_ptr<IDataSeries> reference)
             {
                 auto compareLambda = [](const auto &it1, const auto &it2) {
                 // ////////////// //
                 QTest::addColumn<QString>("dataFilename");  // File containing expected data of acquisitions
-                QTest::addColumn<SqpRange>("initialRange"); // First acquisition
+                QTest::addColumn<DateTimeRange>("initialRange"); // First acquisition
-                QTest::addColumn<std::vector<SqpRange> >("operations"); // Acquisitions to make
+                QTest::addColumn<std::vector<DateTimeRange> >("operations"); // Acquisitions to make
                 // ////////// //
                 // Test cases //
                 QTest::newRow("amda")
                     << "AmdaData-2012-01-01-12-00-00_2012-01-03-12-00-00.txt"
-                    << SqpRange{dateTime(2012, 1, 2, 2, 3, 0), dateTime(2012, 1, 2, 2, 4, 0)}
+                    << DateTimeRange{dateTime(2012, 1, 2, 2, 3, 0), dateTime(2012, 1, 2, 2, 4, 0)}
-                    << std::vector<SqpRange>{
+                    << std::vector<DateTimeRange>{
                            // 2 : pan (jump) left for two min
-                           SqpRange{dateTime(2012, 1, 2, 2, 1, 0), dateTime(2012, 1, 2, 2, 2, 0)},
+                           DateTimeRange{dateTime(2012, 1, 2, 2, 1, 0), dateTime(2012, 1, 2, 2, 2, 0)},
                            // 3 : pan (jump) right for four min
-                           SqpRange{dateTime(2012, 1, 2, 2, 5, 0), dateTime(2012, 1, 2, 2, 6, 0)},
+                           DateTimeRange{dateTime(2012, 1, 2, 2, 5, 0), dateTime(2012, 1, 2, 2, 6, 0)},
                            // 4 : pan (overlay) right for 30 sec
                            /*SqpRange{dateTime(2012, 1, 2, 2, 5, 30), dateTime(2012, 1, 2, 2, 6, 30)},
                            // 5 : pan (overlay) left for 30 sec
                 auto results = AmdaResultParser::readTxt(filePath, DataSeriesType::SCALAR);
                 /// Lambda used to validate a variable at each step
-                auto validateVariable = [results](std::shared_ptr<Variable> variable, const SqpRange &range) {
+                auto validateVariable = [results](std::shared_ptr<Variable> variable, const DateTimeRange &range) {
                     // Checks that the variable's range has changed
                     qInfo() << tr("Compare var range vs range") << variable->range() << range;
                     QCOMPARE(variable->range(), range);
                 };
                 // Creates variable
-                QFETCH(SqpRange, initialRange);
+                QFETCH(DateTimeRange, initialRange);
                 sqpApp->timeController().setDateTimeRange(initialRange);
                 auto provider = std::make_shared<AmdaProvider>();
                 auto variable = sqpApp->variableController().createVariable(
                 validateVariable(variable, initialRange);
                 // Makes operations on the variable
-                QFETCH(std::vector<SqpRange>, operations);
+                QFETCH(std::vector<DateTimeRange>, operations);
                 for (const auto &operation : operations) {
                     // Asks request on the variable and waits during its execution
                     sqpApp->variableController().onRequestDataLoading({variable}, operation, false);

plugins/amda/tests/TestAmdaDownload.py +4 -1

                 sys.argv  = ['']
             current_script_path = os.path.dirname(os.path.realpath(__file__))
             sys.path.append(current_script_path)
             import pytestamda
             import pysciqlopcore
+            import sciqlopqt
             import amda
             import numpy as np
                     tstart = case[0]
                     tstop = case[1]
                     pytestamda.TimeController.setTime(pysciqlopcore.SqpRange(tstart, tstop))
-                    variable = pytestamda.VariableController.createVariable("bx_gse",pytestamda.amda_provider())
+                    variable = pytestamda.VariableController.createVariable("bx_gse",pytestamda.amda_provider(), pysciqlopcore.SqpRange(tstart, tstop))
                     pytestamda.VariableController.wait_for_downloads()
                     t_ref, x_ref, y_ref, z_ref = amda.generate_data(np.datetime64(tstart), np.datetime64(tstop), 4)
                     self.assertTrue( amda.compare_with_ref(variable,(t_ref, x_ref, y_ref, z_ref) ) )

plugins/amda/tests/TestAmdaFuzzing.cpp +3 -3

                 // Test cases //
                 // ////////// //
-                auto maxRange = SqpRange::fromDateTime({2017, 1, 1}, {0, 0}, {2017, 1, 5}, {0, 0});
+                auto maxRange = DateTimeRange::fromDateTime({2017, 1, 1}, {0, 0}, {2017, 1, 5}, {0, 0});
                 MetadataPool metadataPool{{{"dataType", "vector"}, {"xml:id", "imf"}}};
                 // Note: we don't use auto here as we want to pass std::shared_ptr<IDataProvider> as is in the
                 // Generates random initial range (bounded to max range)
                 auto maxRange = properties.value(MAX_RANGE_PROPERTY, QVariant::fromValue(INVALID_RANGE))
-                                    .value<SqpRange>();
+                                    .value<DateTimeRange>();
                 QVERIFY(maxRange != INVALID_RANGE);
                 }
                 // Sets initial range on time controller
-                SqpRange initialRange{initialRangeStart, initialRangeEnd};
+                DateTimeRange initialRange{initialRangeStart, initialRangeEnd};
                 qCInfo(LOG_TestAmdaFuzzing()).noquote() << "Setting initial range to" << initialRange << "...";
                 timeController.setDateTimeRange(initialRange);
                 properties.insert(INITIAL_RANGE_PROPERTY, QVariant::fromValue(initialRange));

plugins/mockplugin/include/CosinusProvider.h +2 -2

                 /// Provide data
-                std::shared_ptr<IDataSeries> provideDataSeries(const SqpRange &dataRangeRequested,
+                std::shared_ptr<IDataSeries> provideDataSeries(const DateTimeRange &dataRangeRequested,
                                                                const QVariantHash &data);
             private:
                 std::shared_ptr<IDataSeries>
-                retrieveData(QUuid acqIdentifier, const SqpRange &dataRangeRequested, const QVariantHash &data);
+                retrieveData(QUuid acqIdentifier, const DateTimeRange &dataRangeRequested, const QVariantHash &data);
                 QHash<QUuid, bool> m_VariableToEnableProvider;
             };

plugins/mockplugin/src/CosinusProvider.cpp +2 -2

             }
             std::shared_ptr<IDataSeries> CosinusProvider::retrieveData(QUuid acqIdentifier,
-                                                                       const SqpRange &dataRangeRequested,
+                                                                       const DateTimeRange &dataRangeRequested,
                                                                        const QVariantHash &data)
             {
                 // TODO: Add Mutex
                 }
             }
-            std::shared_ptr<IDataSeries> CosinusProvider::provideDataSeries(const SqpRange &dataRangeRequested,
+            std::shared_ptr<IDataSeries> CosinusProvider::provideDataSeries(const DateTimeRange &dataRangeRequested,
                                                                             const QVariantHash &data)
             {
                 auto uid = QUuid::createUuid();

plugins/mockplugin/tests/TestCosinusAcquisition.cpp +28 -28

              * @return true if the data of the candidate series and the reference series are identical in the
              * range, false otherwise
              */
-            bool checkDataSeries(std::shared_ptr<IDataSeries> candidate, const SqpRange &range,
+            bool checkDataSeries(std::shared_ptr<IDataSeries> candidate, const DateTimeRange &range,
                                  std::shared_ptr<IDataSeries> reference)
             {
                 if (candidate == nullptr || reference == nullptr) {
                 // Test structure //
                 // ////////////// //
-                QTest::addColumn<SqpRange>("referenceRange");           // Range for generating reference series
+                QTest::addColumn<DateTimeRange>("referenceRange");           // Range for generating reference series
-                QTest::addColumn<SqpRange>("initialRange");             // First acquisition
+                QTest::addColumn<DateTimeRange>("initialRange");             // First acquisition
                 QTest::addColumn<int>("operationDelay");                // Acquisitions to make
-                QTest::addColumn<std::vector<SqpRange> >("operations"); // Acquisitions to make
+                QTest::addColumn<std::vector<DateTimeRange> >("operations"); // Acquisitions to make
                 // ////////// //
                 // Test cases //
                 };
                 QTest::newRow("cosinus")
-                    << SqpRange{dateTime(2017, 1, 1, 12, 0, 0), dateTime(2017, 1, 1, 13, 0, 0)}
+                    << DateTimeRange{dateTime(2017, 1, 1, 12, 0, 0), dateTime(2017, 1, 1, 13, 0, 0)}
-                    << SqpRange{dateTime(2017, 1, 1, 12, 30, 0), dateTime(2017, 1, 1, 12, 35, 1)} << 250
+                    << DateTimeRange{dateTime(2017, 1, 1, 12, 30, 0), dateTime(2017, 1, 1, 12, 35, 1)} << 250
-                    << std::vector<SqpRange>{
+                    << std::vector<DateTimeRange>{
                            // Pan (jump) left
-                           SqpRange{dateTime(2017, 1, 1, 12, 45, 0), dateTime(2017, 1, 1, 12, 50, 0)},
+                           DateTimeRange{dateTime(2017, 1, 1, 12, 45, 0), dateTime(2017, 1, 1, 12, 50, 0)},
                            // Pan (jump) right
-                           SqpRange{dateTime(2017, 1, 1, 12, 15, 0), dateTime(2017, 1, 1, 12, 20, 0)},
+                           DateTimeRange{dateTime(2017, 1, 1, 12, 15, 0), dateTime(2017, 1, 1, 12, 20, 0)},
                            // Pan (overlay) right
-                           SqpRange{dateTime(2017, 1, 1, 12, 14, 0), dateTime(2017, 1, 1, 12, 19, 0)},
+                           DateTimeRange{dateTime(2017, 1, 1, 12, 14, 0), dateTime(2017, 1, 1, 12, 19, 0)},
                            // Pan (overlay) left
-                           SqpRange{dateTime(2017, 1, 1, 12, 15, 0), dateTime(2017, 1, 1, 12, 20, 0)},
+                           DateTimeRange{dateTime(2017, 1, 1, 12, 15, 0), dateTime(2017, 1, 1, 12, 20, 0)},
                            // Pan (overlay) left
-                           SqpRange{dateTime(2017, 1, 1, 12, 16, 0), dateTime(2017, 1, 1, 12, 21, 0)},
+                           DateTimeRange{dateTime(2017, 1, 1, 12, 16, 0), dateTime(2017, 1, 1, 12, 21, 0)},
                            // Zoom in
-                           SqpRange{dateTime(2017, 1, 1, 12, 17, 30), dateTime(2017, 1, 1, 12, 19, 30)},
+                           DateTimeRange{dateTime(2017, 1, 1, 12, 17, 30), dateTime(2017, 1, 1, 12, 19, 30)},
                            // Zoom out
-                           SqpRange{dateTime(2017, 1, 1, 12, 12, 30), dateTime(2017, 1, 1, 12, 24, 30)}};
+                           DateTimeRange{dateTime(2017, 1, 1, 12, 12, 30), dateTime(2017, 1, 1, 12, 24, 30)}};
                 QTest::newRow("cosinus_big")
-                    << SqpRange{dateTime(2017, 1, 1, 1, 0, 0), dateTime(2017, 1, 5, 13, 0, 0)}
+                    << DateTimeRange{dateTime(2017, 1, 1, 1, 0, 0), dateTime(2017, 1, 5, 13, 0, 0)}
-                    << SqpRange{dateTime(2017, 1, 2, 6, 30, 0), dateTime(2017, 1, 2, 18, 30, 0)} << 5000
+                    << DateTimeRange{dateTime(2017, 1, 2, 6, 30, 0), dateTime(2017, 1, 2, 18, 30, 0)} << 5000
-                    << std::vector<SqpRange>{
+                    << std::vector<DateTimeRange>{
                            // Pan (jump) left
-                           SqpRange{dateTime(2017, 1, 1, 13, 30, 0), dateTime(2017, 1, 1, 18, 30, 0)},
+                           DateTimeRange{dateTime(2017, 1, 1, 13, 30, 0), dateTime(2017, 1, 1, 18, 30, 0)},
                            // Pan (jump) right
-                           SqpRange{dateTime(2017, 1, 3, 4, 30, 0), dateTime(2017, 1, 3, 10, 30, 0)},
+                           DateTimeRange{dateTime(2017, 1, 3, 4, 30, 0), dateTime(2017, 1, 3, 10, 30, 0)},
                            // Pan (overlay) right
-                           SqpRange{dateTime(2017, 1, 3, 8, 30, 0), dateTime(2017, 1, 3, 12, 30, 0)},
+                           DateTimeRange{dateTime(2017, 1, 3, 8, 30, 0), dateTime(2017, 1, 3, 12, 30, 0)},
                            // Pan (overlay) left
-                           SqpRange{dateTime(2017, 1, 2, 8, 30, 0), dateTime(2017, 1, 3, 10, 30, 0)},
+                           DateTimeRange{dateTime(2017, 1, 2, 8, 30, 0), dateTime(2017, 1, 3, 10, 30, 0)},
                            // Pan (overlay) left
-                           SqpRange{dateTime(2017, 1, 1, 12, 30, 0), dateTime(2017, 1, 3, 5, 30, 0)},
+                           DateTimeRange{dateTime(2017, 1, 1, 12, 30, 0), dateTime(2017, 1, 3, 5, 30, 0)},
                            // Zoom in
-                           SqpRange{dateTime(2017, 1, 2, 2, 30, 0), dateTime(2017, 1, 2, 8, 30, 0)},
+                           DateTimeRange{dateTime(2017, 1, 2, 2, 30, 0), dateTime(2017, 1, 2, 8, 30, 0)},
                            // Zoom out
-                           SqpRange{dateTime(2017, 1, 1, 14, 30, 0), dateTime(2017, 1, 3, 12, 30, 0)}};
+                           DateTimeRange{dateTime(2017, 1, 1, 14, 30, 0), dateTime(2017, 1, 3, 12, 30, 0)}};
             }
             void TestCosinusAcquisition::testAcquisition()
             {
                 // Retrieves reference range
-                QFETCH(SqpRange, referenceRange);
+                QFETCH(DateTimeRange, referenceRange);
                 CosinusProvider referenceProvider{};
                 auto dataSeries = referenceProvider.provideDataSeries(
                     referenceRange, {{COSINUS_TYPE_KEY, "scalar"}, {COSINUS_FREQUENCY_KEY, 10.}});
                 /// Lambda used to validate a variable at each step
                 auto validateVariable
-                    = [dataSeries](std::shared_ptr<Variable> variable, const SqpRange &range) {
+                    = [dataSeries](std::shared_ptr<Variable> variable, const DateTimeRange &range) {
                           // Checks that the variable's range has changed
                           qInfo() << "range vs expected range" << variable->range() << range;
                           QCOMPARE(variable->range(), range);
                       };
                 // Creates variable
-                QFETCH(SqpRange, initialRange);
+                QFETCH(DateTimeRange, initialRange);
                 sqpApp->timeController().setDateTimeRange(initialRange);
                 auto provider = std::make_shared<CosinusProvider>();
                 auto variable = sqpApp->variableController().createVariable(
                 QTest::qWait(operationDelay);
                 // Makes operations on the variable
-                QFETCH(std::vector<SqpRange>, operations);
+                QFETCH(std::vector<DateTimeRange>, operations);
                 for (const auto &operation : operations) {
                     // Asks request on the variable and waits during its execution
                     sqpApp->variableController().onRequestDataLoading({variable}, operation, false);

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