HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/SciQLOPCore Commit - r2:c7f53bda4647

Basic serial variable creation and update...

jeandet -

r2:c7f53bda4647

parent child

Context file:

r2:c7f53bda4647

include/Common/debug.h created 644 +9 0

@@ -0,0 +1,9
	1	#ifndef DEBUG_H
	2	#define DEBUG_H
	3
	4	#ifdef SCIQLOP_CRASH_ON_ERROR
	5	#define SCIQLOP_ERROR(x) assert(false)
	6	#else
	7	#define SCIQLOP_ERROR(x)
	8	#endif
	9	#endif

CMakeLists.txt +1 0

             cmake_minimum_required(VERSION 3.6)
             project(SciQLOPCore CXX)
             OPTION (CPPCHECK "Analyzes the source code with cppcheck" OFF)
             OPTION (CLANG_TIDY "Analyzes the source code with Clang Tidy" OFF)
             OPTION (IWYU "Analyzes the source code with Include What You Use" OFF)
             OPTION (Catalog "builds catalog API" OFF)
             set(CMAKE_CXX_STANDARD 17)
             set(CMAKE_AUTOMOC ON)
             #https://gitlab.kitware.com/cmake/cmake/issues/15227
             #set(CMAKE_AUTOUIC ON)
             if(POLICY CMP0071)
                 cmake_policy(SET CMP0071 OLD)
             endif()
             set(CMAKE_AUTORCC ON)
             set(CMAKE_INCLUDE_CURRENT_DIR ON)
             find_package(Qt5 COMPONENTS Core Widgets Network PrintSupport Svg Test REQUIRED)
             find_package(pybind11 CONFIG QUIET)
             if (NOT pybind11_FOUND)
                 execute_process(COMMAND git submodule init external/pybind11 WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
                 execute_process(COMMAND git submodule update external/pybind11 WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
                 add_subdirectory(external/pybind11)
             endif()
             macro(declare_test testname testexe sources libraries)
                 add_executable(${testexe} ${sources})
                 target_link_libraries(${testexe} ${libraries})
                 add_test(NAME ${testname} COMMAND ${testexe})
             endmacro(declare_test)
             enable_testing()
             FILE (GLOB_RECURSE core_SRCS
                 ./include/DataSource/DataSourceItemMergeHelper.h
                 ./include/DataSource/DataSourceItemAction.h
                 ./include/DataSource/DataSourceItem.h
                 ./include/DataSource/DataSourceController.h
                 ./include/Common/SortUtils.h
                 ./include/Common/spimpl.h
                 ./include/Common/MimeTypesDef.h
                 ./include/Common/MetaTypes.h
                 ./include/Common/StringUtils.h
                 ./include/Common/SignalWaiter.h
                 ./include/Common/DateUtils.h
                 ./include/Common/Numeric.h
                 ./include/Common/deprecate.h
                 ./include/Common/containers.h
+                ./include/Common/debug.h
                 ./include/Plugin/IPlugin.h
                 ./include/Data/ArrayDataIterator.h
                 ./include/Data/VariableRequest.h
                 ./include/Data/VectorSeries.h
                 ./include/Data/DateTimeRange.h
                 ./include/Data/ScalarSeries.h
                 ./include/Data/DataSeriesMergeHelper.h
                 ./include/Data/DataSeries.h
                 ./include/Data/AcquisitionDataPacket.h
                 ./include/Data/DataSeriesType.h
                 ./include/Data/AcquisitionRequest.h
                 ./include/Data/SqpIterator.h
                 ./include/Data/ArrayData.h
                 ./include/Data/DataSeriesIterator.h
                 ./include/Data/DataSeriesUtils.h
                 ./include/Data/SpectrogramSeries.h
                 ./include/Data/Unit.h
                 ./include/Data/DataProviderParameters.h
                 ./include/Data/OptionalAxis.h
                 ./include/Data/IDataProvider.h
                 ./include/Data/IDataSeries.h
                 ./include/Network/NetworkController.h
                 ./include/Network/Downloader.h
                 ./include/Version.h
                 ./include/CoreGlobal.h
                 ./include/Visualization/VisualizationController.h
                 ./include/PluginManager/PluginManager.h
                 ./include/Variable/VariableModel.h
                 ./include/Variable/VariableAcquisitionWorker.h
                 ./include/Variable/VariableCacheStrategy.h
                 ./include/Variable/VariableSynchronizationGroup.h
                 ./include/Variable/VariableSynchronizationGroup2.h
                 ./include/Variable/VariableSingleThresholdCacheStrategy.h
                 ./include/Variable/VariableCacheStrategyFactory.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/DataSource/DataSourceItem.cpp
                 ./src/DataSource/DataSourceItemAction.cpp
                 ./src/DataSource/DataSourceItemMergeHelper.cpp
                 ./src/DataSource/DataSourceController.cpp
                 ./src/Common/DateUtils.cpp
                 ./src/Common/MimeTypesDef.cpp
                 ./src/Common/StringUtils.cpp
                 ./src/Common/SignalWaiter.cpp
                 ./src/Data/ScalarSeries.cpp
                 ./src/Data/DataSeriesIterator.cpp
                 ./src/Data/OptionalAxis.cpp
                 ./src/Data/ArrayDataIterator.cpp
                 ./src/Data/SpectrogramSeries.cpp
                 ./src/Data/DataSeriesUtils.cpp
                 ./src/Data/VectorSeries.cpp
                 ./src/Network/NetworkController.cpp
                 ./src/Network/Downloader.cpp
                 ./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
                 ./src/Variable/VariableSynchronizationGroup2.cpp
                 ./src/Variable/Variable.cpp
                 ./src/Variable/VariableAcquisitionWorker.cpp
                 ./src/Version.cpp
                 ./src/Time/TimeController.cpp
                 ./src/Settings/SqpSettingsDefs.cpp
                     )
             IF(Catalog)
                 FILE (GLOB_RECURSE core_catalog_SRCS
                     ./src/Catalogue/CatalogueController.cpp
                     ./include/Catalogue/CatalogueController.h
                     )
             ELSE()
             FILE (GLOB_RECURSE core_catalog_SRCS
                 )
             ENDIF(Catalog)
             add_definitions(-DCORE_STATIC)
             #add_definitions(-DHIDE_DEPRECATED)
             add_library(sciqlopcore ${core_SRCS} ${core_catalog_SRCS})
             SET_TARGET_PROPERTIES(sciqlopcore PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS TRUE)
             target_include_directories(sciqlopcore PUBLIC
                 $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
                 $<INSTALL_INTERFACE:include/SciQLOP>
             )
             target_link_libraries(sciqlopcore PUBLIC
               Qt5::Core
               Qt5::Network
             )
             if(Catalog)
                 target_link_libraries(sciqlopcore PUBLIC
                   catalogs
                 )
             endif()
             pybind11_add_module(sciqlopqt src/pybind11_wrappers/QtWrappers.cpp)
             target_link_libraries(sciqlopqt PUBLIC Qt5::Core)
             pybind11_add_module(pysciqlopcore src/pybind11_wrappers/CoreWrappers.cpp)
             target_link_libraries(pysciqlopcore PUBLIC sciqlopcore)
             add_library(pysciqlop src/pybind11_wrappers/pywrappers_common.h)
             target_link_libraries(pysciqlop PUBLIC Qt5::Core)
             target_include_directories(pysciqlop PUBLIC
                 $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src/pybind11_wrappers/>
                 $<INSTALL_INTERFACE:include/SciQLOP/py_wrappers>
             )
             SET_PROPERTY(GLOBAL PROPERTY CORE_PYTHON_PATH  ${CMAKE_CURRENT_BINARY_DIR})
             install(TARGETS sciqlopcore EXPORT SciQLOPCoreConfig
                 ARCHIVE  DESTINATION ${CMAKE_INSTALL_LIBDIR}
                 LIBRARY  DESTINATION ${CMAKE_INSTALL_LIBDIR}
                 RUNTIME  DESTINATION ${CMAKE_INSTALL_BINDIR})
             install(DIRECTORY include/ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/SciQLOP)
             install(EXPORT SciQLOPCoreConfig DESTINATION share/SciQLOPCore/cmake)
             export(TARGETS sciqlopcore FILE SciQLOPCoreConfig.cmake)
             add_subdirectory(tests)

include/Data/IDataProvider.h +7 -2

             #ifndef SCIQLOP_IDATAPROVIDER_H
             #define SCIQLOP_IDATAPROVIDER_H
             #include "CoreGlobal.h"
             #include <Common/deprecate.h>
             #include <memory>
             #include <QObject>
             #include <QUuid>
             #include <Common/MetaTypes.h>
             #include <Data/DateTimeRange.h>
             #include <functional>
             class DataProviderParameters;
             class IDataSeries;
             DEPRECATE(
                 class QNetworkReply;
                 class QNetworkRequest;
             )
             /**
              * @brief The IDataProvider interface aims to declare a data provider.
              *
              * A data provider is an entity that generates data and returns it according to various parameters
              * (time interval, product to retrieve the data, etc.)
              *
              * @sa IDataSeries
              */
             class SCIQLOP_CORE_EXPORT IDataProvider : public QObject {
                 Q_OBJECT
             public:
                 virtual ~IDataProvider() noexcept = default;
                 virtual std::shared_ptr<IDataProvider> clone() const = 0;
                 DEPRECATE(
                 /**
                  * @brief requestDataLoading provide datas for the data identified by acqIdentifier and
                  * parameters
                  */
                         virtual void requestDataLoading(QUuid acqIdentifier, const DataProviderParameters &parameters)
                           = 0;
                 )
-                virtual QUuid getData(const DataProviderParameters &parameters){return QUuid::createUuid();}
+                // Synchronous call -> asyncGetData may be written for asynchronous get
+                virtual IDataSeries* getData(const DataProviderParameters &parameters)
+                {
+                    Q_UNUSED(parameters);
+                    return nullptr;
+                }
                 DEPRECATE(
                 /**
                  * @brief requestDataAborting stop data loading of the data identified by acqIdentifier
                  */
                         virtual void requestDataAborting(QUuid acqIdentifier) = 0;
                 )
-                virtual void abort(QUuid requestID){}
+                virtual void abort(QUuid requestID){Q_UNUSED(requestID);}
             signals:
                 DEPRECATE(
                 /**
                  * @brief dataProvided send dataSeries under dateTime and that corresponds of the data
                  * identified by acqIdentifier
                  */
                         void dataProvided(QUuid acqIdentifier, std::shared_ptr<IDataSeries> dateSeriesAcquired,
                                           const DateTimeRange &dataRangeAcquired);
                 )
                 void finished(QUuid requestID, std::shared_ptr<IDataSeries> dataSerie,
                               const DateTimeRange &range);
                 DEPRECATE(
                 /**
                  * @brief dataProvidedProgress notify the progression of the data identifier by acqIdentifier
                  */
                         void dataProvidedProgress(QUuid acqIdentifier, double progress);
                 )
                 void progress(QUuid requestID, double progress);
                 DEPRECATE(
                 /**
                  * @brief dataProvidedFailed notify that data acquisition has failed
                  */
                         void dataProvidedFailed(QUuid acqIdentifier);
                 )
                 void failed(QUuid requestID);
                 /**
                  * @brief requestConstructed send a request for the data identified by acqIdentifier
                  * @callback is the methode call by the reply of the request when it is finished.
                  */
                 DEPRECATE(
                         void requestConstructed(std::shared_ptr<QNetworkRequest> request, QUuid acqIdentifier,
                                                   std::function<void(QNetworkReply *, QUuid)> callback);
                 )
             };
             // Required for using shared_ptr in signals/slots
             SCIQLOP_REGISTER_META_TYPE(IDATAPROVIDER_PTR_REGISTRY, std::shared_ptr<IDataProvider>)
             SCIQLOP_REGISTER_META_TYPE(IDATAPROVIDER_FUNCTION_REGISTRY,
                                        std::function<void(QNetworkReply *, QUuid)>)
             #endif // SCIQLOP_IDATAPROVIDER_H

include/Variable/Variable.h +7 0

             #ifndef SCIQLOP_VARIABLE_H
             #define SCIQLOP_VARIABLE_H
             #include "CoreGlobal.h"
             #include <Data/DataSeriesIterator.h>
             #include <Data/DataSeriesType.h>
             #include <Data/DateTimeRange.h>
             #include <QLoggingCategory>
             #include <QObject>
+            #include <QUuid>
+            #include <Common/deprecate.h>
             #include <Common/MetaTypes.h>
             #include <Common/spimpl.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_Variable)
             class IDataSeries;
             class QString;
             /**
              * @brief The Variable class represents a variable in SciQlop.
              */
             class SCIQLOP_CORE_EXPORT Variable : public QObject {
                 Q_OBJECT
             public:
                 explicit Variable(const QString &name, const QVariantHash &metadata = {});
                 /// Copy ctor
                 explicit Variable(const Variable &other);
                 std::shared_ptr<Variable> clone() const;
                 QString name() const noexcept;
                 void setName(const QString &name) noexcept;
                 DateTimeRange range() const noexcept;
                 void setRange(const DateTimeRange &range) noexcept;
                 DateTimeRange cacheRange() const 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
                 int nbPoints() const noexcept;
                 /// Returns the real range of the variable, i.e. the min and max x-axis values of the data
                 /// series between the range of the variable. The real range is updated each time the variable
                 /// range or the data series changed
                 /// @return the real range, invalid range if the data series is null or empty
                 /// @sa setDataSeries()
                 /// @sa setRange()
                 DateTimeRange realRange() const noexcept;
                 /// @return the data of the variable, nullptr if there is no data
                 std::shared_ptr<IDataSeries> dataSeries() const noexcept;
                 /// @return the type of data that the variable holds
                 DataSeriesType type() const noexcept;
                 QVariantHash metadata() const noexcept;
                 bool contains(const DateTimeRange &range) const noexcept;
                 bool intersect(const DateTimeRange &range) const noexcept;
                 bool isInside(const DateTimeRange &range) const noexcept;
                 bool cacheContains(const DateTimeRange &range) const noexcept;
                 bool cacheIntersect(const DateTimeRange &range) const noexcept;
                 bool cacheIsInside(const DateTimeRange &range) const noexcept;
                 QVector<DateTimeRange> provideNotInCacheRangeList(const DateTimeRange &range) const noexcept;
                 QVector<DateTimeRange> provideInCacheRangeList(const DateTimeRange &range) const noexcept;
+            DEPRECATE(
                 void mergeDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept;
+                )
+                void mergeDataSeries(IDataSeries* dataSeries) noexcept;
                 static QVector<DateTimeRange> provideNotInCacheRangeList(const DateTimeRange &oldRange,
                                                                     const DateTimeRange &nextRange);
                 static QVector<DateTimeRange> provideInCacheRangeList(const DateTimeRange &oldRange,
                                                                  const DateTimeRange &nextRange);
+                QUuid ID(){return _uuid;}
             signals:
                 void updated();
                 /// Signal emitted when when the data series of the variable is loaded for the first time
                 void dataInitialized();
             private:
                 class VariablePrivate;
                 spimpl::unique_impl_ptr<VariablePrivate> impl;
+                QUuid _uuid;
             };
             // Required for using shared_ptr in signals/slots
             SCIQLOP_REGISTER_META_TYPE(VARIABLE_PTR_REGISTRY, std::shared_ptr<Variable>)
             SCIQLOP_REGISTER_META_TYPE(VARIABLE_PTR_VECTOR_REGISTRY, QVector<std::shared_ptr<Variable> >)
             #endif // SCIQLOP_VARIABLE_H

include/Variable/VariableController2.h +18 -8

-            #include <Common/spimpl.h>
             #include <memory>
             #include <vector>
             #include <QHash>
+            #include <QObject>
+            #include <QMutexLocker>
+            #include <QUuid>
+            #include <QItemSelectionModel>
+            #include <Common/spimpl.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableSynchronizationGroup.h>
             #include <Variable/VariableModel.h>
             #include <Data/IDataProvider.h>
             #include "Data/DateTimeRange.h"
-            #include <QMutexLocker>
-            #include <QUuid>
-            #include <QItemSelectionModel>
-            class VariableController2Private;
+            class VariableController2: public QObject
-            class VariableController2
             {
+                class VariableController2Private;
+                Q_OBJECT
                 spimpl::unique_impl_ptr<VariableController2Private> impl;
             public:
                 explicit VariableController2();
                 std::shared_ptr<Variable> createVariable(const QString &name, const QVariantHash &metadata,
                                                          std::shared_ptr<IDataProvider> provider, const DateTimeRange &range);
-                void changeRange(QUuid variable, DateTimeRange r);
-                void asyncChangeRange(QUuid variable, DateTimeRange r);
+                void deleteVariable(std::shared_ptr<Variable> variable);
+                void changeRange(std::shared_ptr<Variable> variable, DateTimeRange r);
+                void asyncChangeRange(std::shared_ptr<Variable> variable, DateTimeRange r);
+                const std::set<std::shared_ptr<Variable> > &variables();
+            signals:
+                void variableAdded(std::shared_ptr<Variable>);
+                void variableDeleted(std::shared_ptr<Variable>);
             };

src/Variable/Variable.cpp +33 -2

             #include "Variable/Variable.h"
             #include <Data/IDataSeries.h>
             #include <Data/DateTimeRange.h>
             #include <QMutex>
             #include <QReadWriteLock>
             #include <QThread>
+            #include <Common/debug.h>
             Q_LOGGING_CATEGORY(LOG_Variable, "Variable")
             namespace {
             /**
              * Searches in metadata for a value that can be converted to DataSeriesType
              * @param metadata the metadata where to search
              * @return the value converted to a DataSeriesType if it was found, UNKNOWN type otherwise
              * @sa DataSeriesType
              */
             DataSeriesType findDataSeriesType(const QVariantHash &metadata)
             {
                 auto dataSeriesType = DataSeriesType::UNKNOWN;
                 // Go through the metadata and stop at the first value that could be converted to DataSeriesType
                 for (auto it = metadata.cbegin(), end = metadata.cend();
                      it != end && dataSeriesType == DataSeriesType::UNKNOWN; ++it) {
                     dataSeriesType = DataSeriesTypeUtils::fromString(it.value().toString());
                 }
                 return dataSeriesType;
             }
             } // namespace
             struct Variable::VariablePrivate {
                 explicit VariablePrivate(const QString &name, const QVariantHash &metadata)
                         : m_Name{name},
                           m_Range{INVALID_RANGE},
                           m_CacheRange{INVALID_RANGE},
                           m_Metadata{metadata},
                           m_DataSeries{nullptr},
                           m_RealRange{INVALID_RANGE},
                           m_NbPoints{0},
                           m_Type{findDataSeriesType(m_Metadata)}
                 {
                 }
                 VariablePrivate(const VariablePrivate &other)
                         : m_Name{other.m_Name},
                           m_Range{other.m_Range},
                           m_CacheRange{other.m_CacheRange},
                           m_Metadata{other.m_Metadata},
                           m_DataSeries{other.m_DataSeries != nullptr ? other.m_DataSeries->clone() : nullptr},
                           m_RealRange{other.m_RealRange},
                           m_NbPoints{other.m_NbPoints},
                           m_Type{findDataSeriesType(m_Metadata)}
                 {
                 }
                 void lockRead() { m_Lock.lockForRead(); }
                 void lockWrite() { m_Lock.lockForWrite(); }
                 void unlock() { m_Lock.unlock(); }
                 void purgeDataSeries()
                 {
                     if (m_DataSeries) {
                         m_DataSeries->purge(m_CacheRange.m_TStart, m_CacheRange.m_TEnd);
                     }
                     updateRealRange();
                     updateNbPoints();
                 }
                 void updateNbPoints() { m_NbPoints = m_DataSeries ? m_DataSeries->nbPoints() : 0; }
                 /// Updates real range according to current variable range and data series
                 void updateRealRange()
                 {
                     if (m_DataSeries) {
                         m_DataSeries->lockRead();
                         auto end = m_DataSeries->cend();
                         auto minXAxisIt = m_DataSeries->minXAxisData(m_Range.m_TStart);
                         auto maxXAxisIt = m_DataSeries->maxXAxisData(m_Range.m_TEnd);
                         m_RealRange
                             = (minXAxisIt != end && maxXAxisIt != end && minXAxisIt->x() <= maxXAxisIt->x())
                                   ? DateTimeRange{minXAxisIt->x(), maxXAxisIt->x()}
                                   : INVALID_RANGE;
                         m_DataSeries->unlock();
                     }
                     else {
                         m_RealRange = INVALID_RANGE;
                     }
                 }
                 QString m_Name;
                 DateTimeRange m_Range;
                 DateTimeRange m_CacheRange;
                 QVariantHash m_Metadata;
                 std::shared_ptr<IDataSeries> m_DataSeries;
                 DateTimeRange m_RealRange;
                 int m_NbPoints;
                 DataSeriesType m_Type;
                 QReadWriteLock m_Lock;
             };
             Variable::Variable(const QString &name, const QVariantHash &metadata)
-                    : impl{spimpl::make_unique_impl<VariablePrivate>(name, metadata)}
+                    : impl{spimpl::make_unique_impl<VariablePrivate>(name, metadata)},
+                      _uuid{QUuid::createUuid()}
             {
             }
             Variable::Variable(const Variable &other)
-                    : impl{spimpl::make_unique_impl<VariablePrivate>(*other.impl)}
+                    : impl{spimpl::make_unique_impl<VariablePrivate>(*other.impl)},
+                      _uuid{QUuid::createUuid()} //is a clone but must have a != uuid
             {
             }
             std::shared_ptr<Variable> Variable::clone() const
             {
                 return std::make_shared<Variable>(*this);
             }
             QString Variable::name() const noexcept
             {
                 impl->lockRead();
                 auto name = impl->m_Name;
                 impl->unlock();
                 return name;
             }
             void Variable::setName(const QString &name) noexcept
             {
                 impl->lockWrite();
                 impl->m_Name = name;
                 impl->unlock();
             }
             DateTimeRange Variable::range() const noexcept
             {
                 impl->lockRead();
                 auto range = impl->m_Range;
                 impl->unlock();
                 return range;
             }
             void Variable::setRange(const DateTimeRange &range) noexcept
             {
                 impl->lockWrite();
                 impl->m_Range = range;
                 impl->updateRealRange();
                 impl->unlock();
             }
             DateTimeRange Variable::cacheRange() const noexcept
             {
                 impl->lockRead();
                 auto cacheRange = impl->m_CacheRange;
                 impl->unlock();
                 return cacheRange;
             }
             void Variable::setCacheRange(const DateTimeRange &cacheRange) noexcept
             {
                 impl->lockWrite();
                 if (cacheRange != impl->m_CacheRange) {
                     impl->m_CacheRange = cacheRange;
                 }
                 impl->unlock();
             }
             int Variable::nbPoints() const noexcept
             {
                 return impl->m_NbPoints;
             }
             DateTimeRange Variable::realRange() const noexcept
             {
                 return impl->m_RealRange;
             }
             void Variable::mergeDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept
             {
                 qCDebug(LOG_Variable()) << "TORM Variable::mergeDataSeries"
                                         << QThread::currentThread()->objectName();
                 if (!dataSeries) {
                     /// @todo ALX : log
                     return;
                 }
                 auto dataInit = false;
                 // Add or merge the data
                 impl->lockWrite();
                 if (!impl->m_DataSeries) {
                     impl->m_DataSeries = dataSeries->clone();
                     dataInit = true;
                 }
                 else {
                     impl->m_DataSeries->merge(dataSeries.get());
                 }
                 impl->purgeDataSeries();
                 impl->unlock();
                 if (dataInit) {
                     emit dataInitialized();
                 }
             }
+            void Variable::mergeDataSeries(IDataSeries *dataSeries) noexcept
+            {
+                if (dataSeries==nullptr) {
+                    SCIQLOP_ERROR("Given IDataSeries is nullptr");
+                    return;
+                }
+                auto dataInit = false;
+                // @TODO move to impl to Pimpl this is what it stands for...
+                // Add or merge the data
+                impl->lockWrite();
+                if (!impl->m_DataSeries) {
+                    //@TODO find a better way
+                    impl->m_DataSeries = dataSeries->clone();
+                    dataInit = true;
+                    delete dataSeries;
+                }
+                else {
+                    impl->m_DataSeries->merge(dataSeries);
+                }
+                impl->purgeDataSeries();
+                impl->unlock();
+                if (dataInit) {
+                    emit dataInitialized();
+                }
+            }
             std::shared_ptr<IDataSeries> Variable::dataSeries() const noexcept
             {
                 impl->lockRead();
                 auto dataSeries = impl->m_DataSeries;
                 impl->unlock();
                 return dataSeries;
             }
             DataSeriesType Variable::type() const noexcept
             {
                 impl->lockRead();
                 auto type = impl->m_Type;
                 impl->unlock();
                 return type;
             }
             QVariantHash Variable::metadata() const noexcept
             {
                 impl->lockRead();
                 auto metadata = impl->m_Metadata;
                 impl->unlock();
                 return metadata;
             }
             bool Variable::contains(const DateTimeRange &range) const noexcept
             {
                 impl->lockRead();
                 auto res = impl->m_Range.contains(range);
                 impl->unlock();
                 return res;
             }
             bool Variable::intersect(const DateTimeRange &range) const noexcept
             {
                 impl->lockRead();
                 auto res = impl->m_Range.intersect(range);
                 impl->unlock();
                 return res;
             }
             bool Variable::isInside(const DateTimeRange &range) const noexcept
             {
                 impl->lockRead();
                 auto res = range.contains(DateTimeRange{impl->m_Range.m_TStart, impl->m_Range.m_TEnd});
                 impl->unlock();
                 return res;
             }
             bool Variable::cacheContains(const DateTimeRange &range) const noexcept
             {
                 impl->lockRead();
                 auto res = impl->m_CacheRange.contains(range);
                 impl->unlock();
                 return res;
             }
             bool Variable::cacheIntersect(const DateTimeRange &range) const noexcept
             {
                 impl->lockRead();
                 auto res = impl->m_CacheRange.intersect(range);
                 impl->unlock();
                 return res;
             }
             bool Variable::cacheIsInside(const DateTimeRange &range) const noexcept
             {
                 impl->lockRead();
                 auto res = range.contains(DateTimeRange{impl->m_CacheRange.m_TStart, impl->m_CacheRange.m_TEnd});
                 impl->unlock();
                 return res;
             }
             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<DateTimeRange>{};
                 if (impl->m_CacheRange != INVALID_RANGE) {
                     if (!this->cacheContains(range)) {
                         if (range.m_TEnd <= impl->m_CacheRange.m_TStart
                             || range.m_TStart >= impl->m_CacheRange.m_TEnd) {
                             notInCache << range;
                         }
                         else if (range.m_TStart < impl->m_CacheRange.m_TStart
                                  && range.m_TEnd <= impl->m_CacheRange.m_TEnd) {
                             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 << DateTimeRange{range.m_TStart, impl->m_CacheRange.m_TStart}
                                        << DateTimeRange{impl->m_CacheRange.m_TEnd, range.m_TEnd};
                         }
                         else if (range.m_TStart < impl->m_CacheRange.m_TEnd) {
                             notInCache << DateTimeRange{impl->m_CacheRange.m_TEnd, range.m_TEnd};
                         }
                         else {
                             qCCritical(LOG_Variable()) << tr("Detection of unknown case.")
                                                        << QThread::currentThread();
                         }
                     }
                 }
                 else {
                     notInCache << range;
                 }
                 return notInCache;
             }
             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<DateTimeRange>{};
                 if (impl->m_CacheRange != INVALID_RANGE) {
                     if (this->cacheIntersect(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 << DateTimeRange{impl->m_CacheRange.m_TStart, range.m_TEnd};
                         }
                         else if (range.m_TStart >= impl->m_CacheRange.m_TStart
                                  && range.m_TEnd <= impl->m_CacheRange.m_TEnd) {
                             inCache << range;
                         }
                         else if (range.m_TStart > impl->m_CacheRange.m_TStart
                                  && range.m_TEnd > 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) {
                             inCache << impl->m_CacheRange;
                         }
                         else {
                             qCCritical(LOG_Variable()) << tr("Detection of unknown case.")
                                                        << QThread::currentThread();
                         }
                     }
                 }
                 return inCache;
             }
             QVector<DateTimeRange> Variable::provideNotInCacheRangeList(const DateTimeRange &oldRange,
                                                                    const DateTimeRange &nextRange)
             {
                 // This code assume that cach in contigue. Can return 0, 1 or 2 SqpRange
                 auto notInCache = QVector<DateTimeRange>{};
                 if (oldRange != INVALID_RANGE) {
                     if (!oldRange.contains(nextRange)) {
                         if (nextRange.m_TEnd <= oldRange.m_TStart || nextRange.m_TStart >= oldRange.m_TEnd) {
                             notInCache << nextRange;
                         }
                         else if (nextRange.m_TStart < oldRange.m_TStart
                                  && nextRange.m_TEnd <= oldRange.m_TEnd) {
                             notInCache << DateTimeRange{nextRange.m_TStart, oldRange.m_TStart};
                         }
                         else if (nextRange.m_TStart < oldRange.m_TStart && nextRange.m_TEnd > oldRange.m_TEnd) {
                             notInCache << DateTimeRange{nextRange.m_TStart, oldRange.m_TStart}
                                        << DateTimeRange{oldRange.m_TEnd, nextRange.m_TEnd};
                         }
                         else if (nextRange.m_TStart < oldRange.m_TEnd) {
                             notInCache << DateTimeRange{oldRange.m_TEnd, nextRange.m_TEnd};
                         }
                         else {
                             qCCritical(LOG_Variable()) << tr("Detection of unknown case.")
                                                        << QThread::currentThread();
                         }
                     }
                 }
                 else {
                     notInCache << nextRange;
                 }
                 return notInCache;
             }
             QVector<DateTimeRange> Variable::provideInCacheRangeList(const DateTimeRange &oldRange,
                                                                 const DateTimeRange &nextRange)
             {
                 // This code assume that cach is contigue. Can return 0 or 1 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 << DateTimeRange{oldRange.m_TStart, nextRange.m_TEnd};
                         }
                         else if (nextRange.m_TStart >= oldRange.m_TStart
                                  && nextRange.m_TEnd <= oldRange.m_TEnd) {
                             inCache << nextRange;
                         }
                         else if (nextRange.m_TStart > oldRange.m_TStart && nextRange.m_TEnd > 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) {
                             inCache << oldRange;
                         }
                         else {
                             qCCritical(LOG_Variable()) << tr("Detection of unknown case.")
                                                        << QThread::currentThread();
                         }
                     }
                 }
                 return inCache;
             }

src/Variable/VariableController2.cpp +64 -6

@@ -1,25 +1,83
1	#include "Variable/VariableController2.h"	1	#include "Variable/VariableController2.h"
		2	#include <Common/containers.h>
		3	#include <Common/debug.h>
		4	#include <Data/DataProviderParameters.h>
2		5
3		6	class VariableController2::VariableController2Private
4	class VariableController2Private
5	{	7	{
6		8	std::set<std::shared_ptr<Variable>> _variables;
		9	QMap<QUuid,std::shared_ptr<IDataProvider>> _providers;
7	public:	10	public:
8	VariableController2Private(QObject* parent=Q_NULLPTR)	11	VariableController2Private(QObject* parent=Q_NULLPTR)
9	{}	12	{
		13	Q_UNUSED(parent);
		14	}
		15
10	~VariableController2Private() = default;	16	~VariableController2Private() = default;
		17
11	std::shared_ptr<Variable> createVariable(const QString &name, const QVariantHash &metadata, std::shared_ptr<IDataProvider> provider, const DateTimeRange &range)	18	std::shared_ptr<Variable> createVariable(const QString &name, const QVariantHash &metadata, std::shared_ptr<IDataProvider> provider, const DateTimeRange &range)
12	{	19	{
13	~~return~~ std::make_shared<Variable>(name,metadata);	20	auto newVar = std::make_shared<Variable>(name,metadata);
		21	this->_variables.insert(newVar);
		22	this->_providers[newVar->ID()] = provider;
		23	return newVar;
		24	}
		25
		26	void deleteVariable(std::shared_ptr<Variable> variable)
		27	{
		28	if(this->_providers.contains(variable->ID()))
		29	this->_providers.remove(variable->ID());
		30	if(SciQLop::containers::contains(this->_variables, variable))
		31	this->_variables.erase(variable);
		32	}
		33
		34	void changeRange(std::shared_ptr<Variable> variable, DateTimeRange r)
		35	{
		36	if(_providers.contains(variable->ID()))
		37	{
		38	auto provider = _providers[variable->ID()];
		39	auto data = provider->getData(DataProviderParameters{{r},variable->metadata()});
		40	variable->mergeDataSeries(data);
		41	}
		42	else
		43	{
		44	SCIQLOP_ERROR("No provider found for given variable");
		45	}
		46	}
		47
		48
		49	const std::set<std::shared_ptr<Variable>>& variables()
		50	{
		51	return _variables;
14	}	52	}
		53
15	};	54	};
16		55
17	VariableController2::VariableController2()	56	VariableController2::VariableController2()
18	:impl{spimpl::make_unique_impl<VariableController2Private>()}	57	:impl{spimpl::make_unique_impl<VariableController2Private>()}
19	{}	58	{}
20		59
21	std::shared_ptr<Variable> VariableController2::createVariable(const QString &name, const QVariantHash &metadata, std::shared_ptr<IDataProvider> provider, const DateTimeRange &range)	60	std::shared_ptr<Variable> VariableController2::createVariable(const QString &name, const QVariantHash &metadata, std::shared_ptr<IDataProvider> provider, const DateTimeRange &range)
22	{	61	{
23	~~return~~ impl->createVariable(name, metadata, provider, range);	62	auto var = impl->createVariable(name, metadata, provider, range);
		63	emit variableAdded(var);
		64	impl->changeRange(var,range);
		65	return var;
		66	}
		67
		68	void VariableController2::deleteVariable(std::shared_ptr<Variable> variable)
		69	{
		70	impl->deleteVariable(variable);
		71	emit variableDeleted(variable);
		72	}
		73
		74	void VariableController2::changeRange(std::shared_ptr<Variable> variable, DateTimeRange r)
		75	{
		76	impl->changeRange(variable, r);
		77	}
		78
		79	const std::set<std::shared_ptr<Variable> > &VariableController2::variables()
		80	{
		81	return impl->variables();
24	}	82	}
25		83

tests/Variable/TestVariableController2.cpp +81 -3

@@ -1,30 +1,108
		1	#include <cmath>
1	#include <QtTest>	2	#include <QtTest>
2	#include <QObject>	3	#include <QObject>
		4	#include <Variable/VariableController2.h>
		5	#include <Data/DateTimeRange.h>
		6	#include <Data/IDataProvider.h>
		7	#include <Data/ScalarSeries.h>
		8	#include <Data/DataProviderParameters.h>
		9	#include <Common/containers.h>
3		10
		11	class FakeProvider: public IDataProvider
		12	{
		13	public:
		14	FakeProvider() = default;
4		15
5	class TestVariableController2 : public QObject	16	std::shared_ptr<IDataProvider> clone() const override{ return std::make_shared<FakeProvider>(); }
		17
		18	IDataSeries* getData(const DataProviderParameters &parameters) override
		19	{
		20	auto tstart = parameters.m_Times[0].m_TStart;
		21	auto tend = parameters.m_Times[0].m_TEnd;
		22	std::vector<double> x;
		23	std::vector<double> y;
		24	for(auto i = tstart;i<tend;i+=1.) //1 seconde data resolution
		25	{
		26	x.push_back(i);
		27	y.push_back(i);
		28	}
		29	auto serie = new ScalarSeries(std::move(x),std::move(y),Unit("Secondes",true),Unit("Volts",false));
		30	return serie;
		31	}
		32
		33
		34
		35	void requestDataLoading(QUuid acqIdentifier, const DataProviderParameters &parameters) override
		36	{
		37	Q_UNUSED(acqIdentifier)
		38	Q_UNUSED(parameters)
		39	}
		40
		41	void requestDataAborting(QUuid acqIdentifier) override
		42	{
		43	Q_UNUSED(acqIdentifier)
		44	}
		45
		46	};
6		47
		48	class TestVariableController2 : public QObject
7	{	49	{
8	Q_OBJECT	50	Q_OBJECT
9	public:	51	public:
10	explicit TestVariableController2(QObject *parent = nullptr) : QObject(parent){}	52	explicit TestVariableController2(QObject *parent = nullptr) : QObject(parent){}
11	signals:	53	signals:
12		54
13	private slots:	55	private slots:
14	void initTestCase(){}	56	void initTestCase(){}
15	void cleanupTestCase(){}	57	void cleanupTestCase(){}
16		58
17	void test1()	59	void testCreateVariable()
		60	{
		61	VariableController2 vc;
		62	bool callbackCalled = false;
		63	connect(&vc,&VariableController2::variableAdded, [&callbackCalled](std::shared_ptr<Variable>){callbackCalled=true;});
		64	auto provider = std::make_shared<FakeProvider>();
		65	QVERIFY(!callbackCalled);
		66	auto var1 = vc.createVariable("var1",{},provider,DateTimeRange());
		67	QVERIFY(SciQLop::containers::contains(vc.variables(), var1));
		68	QVERIFY(callbackCalled);
		69	}
		70
		71	void testDeleteVariable()
		72	{
		73	VariableController2 vc;
		74	bool callbackCalled = false;
		75	connect(&vc,&VariableController2::variableDeleted, [&callbackCalled](std::shared_ptr<Variable>){callbackCalled=true;});
		76	auto provider = std::make_shared<FakeProvider>();
		77	auto var1 = vc.createVariable("var1",{},provider,DateTimeRange());
		78	QVERIFY(SciQLop::containers::contains(vc.variables(), var1));
		79	QVERIFY(!callbackCalled);
		80	vc.deleteVariable(var1);
		81	QVERIFY(!SciQLop::containers::contains(vc.variables(), var1));
		82	QVERIFY(callbackCalled);
		83	}
		84
		85	void testGetData()
18	{	86	{
19	QCOMPARE(1+1, 2);	87	VariableController2 vc;
		88	auto provider = std::make_shared<FakeProvider>();
		89	auto range1 = DateTimeRange::fromDateTime(QDate(2018,8,7),QTime(14,00),
		90	QDate(2018,8,7),QTime(16,00));
		91	auto range2 = DateTimeRange::fromDateTime(QDate(2018,8,7),QTime(12,00),
		92	QDate(2018,8,7),QTime(18,00));
		93	auto var1 = vc.createVariable("var1", {}, provider, range1);
		94	QCOMPARE(var1->nbPoints(), int(range1.delta()));
		95	vc.changeRange(var1, range2);
		96	QCOMPARE(var1->nbPoints(), int(range2.delta()));
		97
20	}	98	}
21		99
22	private:	100	private:
23		101
24	};	102	};
25		103
26		104
27	QTEST_MAIN(TestVariableController2)	105	QTEST_MAIN(TestVariableController2)
28		106
29	#include "TestVariableController2.moc"	107	#include "TestVariableController2.moc"
30		108

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