HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/SciQLOPCore Commit - r69:cc26524fb5d1

Removed old Variable impl...

jeandet -

r69:cc26524fb5d1

parent child

Context file:

r69:cc26524fb5d1

CMakeLists.txt 0 -27

             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 (PyWrappers "Enables Python 3 wrappers" ON)
             OPTION (Catalog "builds catalog API" ON)
             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 Concurrent Network PrintSupport Svg Test REQUIRED)
             if(PyWrappers)
                 find_package(pybind11 CONFIG QUIET)
                 if (NOT pybind11_FOUND)
                     if(NOT EXISTS ${CMAKE_CURRENT_LIST_DIR}/external/pybind11/CMakeLists.txt)
                         message("Init submodule pybind11")
                         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})
                     endif()
                     add_subdirectory(external/pybind11)
                 endif()
             endif()
             find_package(catalogicpp CONFIG QUIET)
             if (NOT catalogicpp_FOUND)
                 if(NOT EXISTS ${CMAKE_CURRENT_LIST_DIR}/external/catalogicpp/CMakeLists.txt)
                     message("Init submodule catalogicpp")
                     execute_process(COMMAND git submodule init external/catalogicpp WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
                     execute_process(COMMAND git submodule update external/catalogicpp WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
                 endif()
                 add_subdirectory(external/catalogicpp)
             endif()
             find_package(TimeSeries CONFIG QUIET)
             if (NOT TimeSeries_FOUND)
                 if(NOT EXISTS ${CMAKE_CURRENT_LIST_DIR}/external/TimeSeries/CMakeLists.txt)
                     message("Init submodule TimeSeries")
                     execute_process(COMMAND git submodule init external/TimeSeries WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
                     execute_process(COMMAND git submodule update external/TimeSeries WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
                 endif()
                 add_subdirectory(external/TimeSeries)
             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/Common/cpp_utils.h
-                ./include/Common/variant_with_base.h
                 ./include/Plugin/IPlugin.h
-                ./include/Data/ArrayDataIterator.h
-                ./include/Data/VectorSeries.h
                 ./include/Data/VectorTimeSerie.h
                 ./include/Data/DateTimeRange.h
                 ./include/Data/DateTimeRangeHelper.h
-                ./include/Data/ScalarSeries.h
                 ./include/Data/ScalarTimeSerie.h
-                ./include/Data/DataSeriesMergeHelper.h
-                ./include/Data/DataSeries.h
                 ./include/Data/DataSeriesType.h
                 ./include/Data/SqpIterator.h
-                ./include/Data/ArrayData.h
-                ./include/Data/DataSeriesIterator.h
-                ./include/Data/DataSeriesUtils.h
-                ./include/Data/SpectrogramSeries.h
                 ./include/Data/SpectrogramTimeSerie.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/VariableModel2.h
-                ./include/Variable/VariableCacheStrategy.h
                 ./include/Variable/VariableSynchronizationGroup2.h
-                ./include/Variable/ProportionalCacheStrategy.h
-                ./include/Variable/SingleThresholdCacheStrategy.h
-                ./include/Variable/VariableCacheStrategyFactory.h
-                ./include/Variable/Variable.h
                 ./include/Variable/Variable2.h
                 ./include/Variable/VariableController2.h
                 ./include/Variable/private/VCTransaction.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/ScalarTimeSerie.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/Data/VectorTimeSerie.cpp
                 ./src/Network/NetworkController.cpp
                 ./src/Network/Downloader.cpp
                 ./src/Visualization/VisualizationController.cpp
                 ./src/PluginManager/PluginManager.cpp
                 ./src/Variable/VariableController2.cpp
                 ./src/Variable/VariableModel2.cpp
                 ./src/Variable/VariableSynchronizationGroup2.cpp
                 ./src/Variable/Variable.cpp
                 ./src/Variable/Variable2.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_definitions(-DSCIQLOP_CRASH_ON_ERROR)
             add_library(sciqlopcore ${core_SRCS} ${core_catalog_SRCS})
             SET_TARGET_PROPERTIES(sciqlopcore PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS TRUE)
             add_definitions(-DCORE_LIB)
             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
               TimeSeries
             )
             if(Catalog)
                 target_link_libraries(sciqlopcore PUBLIC
                   CatalogiCpp
                 )
             endif()
             if(PyWrappers)
                 if(MINGW)
                     add_definitions(-D_hypot=hypot)
                 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)
                 pybind11_add_module(pysciqlopcatalogs src/pybind11_wrappers/CatalogWrappers.cpp)
                 target_link_libraries(pysciqlopcatalogs 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>
                 )
             endif()
             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/Variable/Variable2.h 0 -1

             #ifndef SCIQLOP_VARIABLE2_H
             #define SCIQLOP_VARIABLE2_H
             #include "CoreGlobal.h"
             #include <Common/MetaTypes.h>
             #include <Common/deprecate.h>
             #include <Common/spimpl.h>
-            #include <Common/variant_with_base.h>
             #include <Data/DataSeriesType.h>
             #include <Data/DateTimeRange.h>
             #include <Data/ScalarTimeSerie.h>
             #include <Data/SpectrogramTimeSerie.h>
             #include <Data/VectorTimeSerie.h>
             #include <QDataStream>
             #include <QObject>
             #include <QReadWriteLock>
             #include <QUuid>
             #include <TimeSeries.h>
             #include <optional>
             class SCIQLOP_CORE_EXPORT Variable2 : public QObject
             {
               Q_OBJECT
             public:
               explicit Variable2(const QString& name, const QVariantHash& metadata = {});
               /// Copy ctor
               explicit Variable2(const Variable2& other);
               std::shared_ptr<Variable2> clone() const;
               QString name();
               void setName(const QString& name);
               DateTimeRange range();
               void setRange(const DateTimeRange& range);
               std::optional<DateTimeRange> realRange();
               std::size_t nbPoints();
               /// @return the data of the variable, nullptr if there is no data
               std::shared_ptr<TimeSeries::ITimeSerie> data();
               /// @return the type of data that the variable holds
               DataSeriesType type();
               QVariantHash metadata() const noexcept;
               //  void setData(const std::vector<AnyTimeSerie*>& dataSeries,
               //               const DateTimeRange& range, bool notify = true);
               void setData(const std::vector<TimeSeries::ITimeSerie*>& dataSeries,
                            const DateTimeRange& range, bool notify = true);
               static QByteArray
               mimeData(const std::vector<std::shared_ptr<Variable2>>& variables)
               {
                 auto encodedData = QByteArray{};
                 QDataStream stream{&encodedData, QIODevice::WriteOnly};
                 for(auto& var : variables)
                 {
                   stream << var->ID().toByteArray();
                 }
                 return encodedData;
               }
               static std::vector<QUuid> IDs(QByteArray mimeData)
               {
                 std::vector<QUuid> variables;
                 QDataStream stream{mimeData};
                 QVariantList ids;
                 stream >> ids;
                 std::transform(std::cbegin(ids), std::cend(ids),
                                std::back_inserter(variables),
                                [](const auto& id) { return id.toByteArray(); });
                 return variables;
               }
               operator QUuid() { return _uuid; }
               QUuid ID() { return _uuid; }
             signals:
               void updated(QUuid ID);
             private:
               struct VariablePrivate;
               spimpl::unique_impl_ptr<VariablePrivate> impl;
               QUuid _uuid;
               QReadWriteLock m_lock;
             };
             // Required for using shared_ptr in signals/slots
             // SCIQLOP_REGISTER_META_TYPE(VARIABLE_PTR_REGISTRY, std::shared_ptr<Variable2>)
             // SCIQLOP_REGISTER_META_TYPE(VARIABLE_PTR_VECTOR_REGISTRY,
             //                           QVector<std::shared_ptr<Variable2>>)
             #endif // SCIQLOP_VARIABLE2_H

src/Variable/VariableController2.cpp 0 -4

             #include "Variable/VariableController2.h"
             #include "Variable/VariableSynchronizationGroup2.h"
             #include <Common/containers.h>
             #include <Common/debug.h>
             #include <Data/DataProviderParameters.h>
             #include <Data/DateTimeRange.h>
             #include <Data/DateTimeRangeHelper.h>
             #include <QCoreApplication>
             #include <QDataStream>
             #include <QObject>
             #include <QQueue>
             #include <QRunnable>
             #include <QThreadPool>
-            #include <Variable/VariableCacheStrategyFactory.h>
             #include <Variable/private/VCTransaction.h>
             class VariableController2::VariableController2Private
             {
               struct threadSafeVaraiblesMaps
               {
                 inline void
                 addVariable(const std::shared_ptr<Variable2>& variable,
                             const std::shared_ptr<IDataProvider>& provider,
                             const std::shared_ptr<VariableSynchronizationGroup2>&
                                 synchronizationGroup)
                 {
                   QWriteLocker lock{&_lock};
                   _variables[*variable]             = variable;
                   _providers[*variable]             = provider;
                   _synchronizationGroups[*variable] = synchronizationGroup;
                 }
                 inline void removeVariable(const std::shared_ptr<Variable2>& variable)
                 {
                   QWriteLocker lock{&_lock};
                   _variables.erase(*variable);
                   _providers.remove(*variable);
                   _synchronizationGroups.remove(*variable);
                 }
                 inline void
                 synchronize(const std::shared_ptr<Variable2>& variable,
                             const std::optional<std::shared_ptr<Variable2>>& with)
                 {
                   QWriteLocker lock{&_lock};
                   if(with.has_value())
                   {
                     auto newGroup = _synchronizationGroups[*with.value()];
                     newGroup->addVariable(*variable);
                     _synchronizationGroups[*variable] = newGroup;
                   }
                   else
                   {
                     _synchronizationGroups[*variable] =
                         std::make_shared<VariableSynchronizationGroup2>(*variable);
                   }
                 }
                 inline std::shared_ptr<Variable2> variable(QUuid variable)
                 {
                   QReadLocker lock{&_lock};
                   auto it = _variables.find(variable);
             #if __cplusplus > 201703L
                   [[unlikely]]
             #endif
                   if(it == _variables.end())
                       SCIQLOP_ERROR(threadSafeVaraiblesMaps, "Unknown Variable");
                   return (*it).second;
                 }
                 inline std::shared_ptr<Variable2> variable(int index)
                 {
                   QReadLocker lock{&_lock};
             #if __cplusplus > 201703L
                   [[unlikely]]
             #endif
                   if(!_variables.size() > index)
                       SCIQLOP_ERROR(threadSafeVaraiblesMaps, "Index is out of bounds");
                   auto it = _variables.cbegin();
                   while(index != 0)
                   {
                     index -= 1;
                     it++;
                   }
                   return (*(it)).second;
                 }
                 inline const std::vector<std::shared_ptr<Variable2>> variables()
                 {
                   std::vector<std::shared_ptr<Variable2>> vars;
                   QReadLocker lock{&_lock};
                   for(const auto& [id, var] : _variables)
                   {
                     vars.push_back(var);
                   }
                   return vars;
                 }
                 inline std::shared_ptr<IDataProvider> provider(QUuid variable)
                 {
                   QReadLocker lock{&_lock};
             #if __cplusplus > 201703L
                   [[unlikely]]
             #endif
                   if(!_providers.contains(variable))
                       SCIQLOP_ERROR(threadSafeVaraiblesMaps, "Unknown Variable");
                   return _providers[variable];
                 }
                 inline std::shared_ptr<VariableSynchronizationGroup2> group(QUuid variable)
                 {
                   QReadLocker lock{&_lock};
             #if __cplusplus > 201703L
                   [[unlikely]]
             #endif
                   if(!_synchronizationGroups.contains(variable))
                       SCIQLOP_ERROR(threadSafeVaraiblesMaps, "Unknown Variable");
                   return _synchronizationGroups[variable];
                 }
                 inline bool has(const std::shared_ptr<Variable2>& variable)
                 {
                   QReadLocker lock{&_lock};
                   return _variables.find(*variable) == _variables.end();
                 }
               private:
                 std::map<QUuid, std::shared_ptr<Variable2>> _variables;
                 QMap<QUuid, std::shared_ptr<IDataProvider>> _providers;
                 QMap<QUuid, std::shared_ptr<VariableSynchronizationGroup2>>
                     _synchronizationGroups;
                 QReadWriteLock _lock{QReadWriteLock::Recursive};
               } _maps;
               std::vector<QUuid> _variablesToRemove;
               QThreadPool* _ThreadPool;
               VCTransactionsQueues _transactions;
-              std::unique_ptr<VariableCacheStrategy> _cacheStrategy;
               void _transactionComplete(QUuid group,
                                         std::shared_ptr<VCTransaction> transaction)
               {
                 if(transaction->done()) { _transactions.complete(group); }
                 this->_processTransactions();
               }
               void _cleanupVariables()
               {
                 for(auto id : _variablesToRemove)
                 {
                   auto v = this->variable(id);
                   if(!hasPendingTransactions(v))
                   {
                     _variablesToRemove.erase(std::remove(_variablesToRemove.begin(),
                                                          _variablesToRemove.end(), id),
                                              _variablesToRemove.end());
                     this->deleteVariable(v);
                   }
                 }
               }
               void _processTransactions(bool fragmented = false)
               {
                 auto nextTransactions    = _transactions.nextTransactions();
                 auto pendingTransactions = _transactions.pendingTransactions();
                 for(auto [groupID, newTransaction] : nextTransactions)
                 {
                   if(newTransaction.has_value() &&
                      !pendingTransactions[groupID].has_value())
                   {
                     _transactions.start(groupID);
                     auto refVar = _maps.variable(newTransaction.value()->refVar);
                     auto ranges =
                         _computeAllRangesInGroup(refVar, newTransaction.value()->range);
                     for(auto const& [ID, range] : ranges)
                     {
                       auto provider = _maps.provider(ID);
                       auto variable = _maps.variable(ID);
                       if(fragmented)
                       {
                         auto missingRanges = _computeMissingRanges(variable, range);
                         auto exe =
                             new TransactionExe(variable, provider, missingRanges, range);
                         QObject::connect(
                             exe, &TransactionExe::transactionComplete,
                             [groupID = groupID, transaction = newTransaction.value(),
                              this]() { this->_transactionComplete(groupID, transaction); });
                         _ThreadPool->start(exe);
                       }
                       else
                       {
                         auto exe = new TransactionExe(variable, provider, {range}, range);
                         QObject::connect(
                             exe, &TransactionExe::transactionComplete,
                             [groupID = groupID, transaction = newTransaction.value(),
                              this]() { this->_transactionComplete(groupID, transaction); });
                         _ThreadPool->start(exe);
                       }
                     }
                   }
                 }
                 // after each transaction update we get a new distribution of idle and
                 // working variables so we can delete variables which are waiting to be
                 // deleted if they are now idle
                 _cleanupVariables();
               }
               std::map<QUuid, DateTimeRange>
               _computeAllRangesInGroup(const std::shared_ptr<Variable2>& refVar,
                                        DateTimeRange r)
               {
                 std::map<QUuid, DateTimeRange> ranges;
                 if(!DateTimeRangeHelper::hasnan(r))
                 {
                   auto group = _maps.group(*refVar);
                   if(auto transformation =
                          DateTimeRangeHelper::computeTransformation(refVar->range(), r);
                      transformation.has_value())
                   {
                     for(auto varId : group->variables())
                     {
                       auto var      = _maps.variable(varId);
                       auto newRange = var->range().transform(transformation.value());
                       ranges[varId] = newRange;
                     }
                   }
                   else // force new range to all variables -> may be weird if more than one
                        // var in the group
                        // @TODO ensure that there is no side effects
                   {
                     for(auto varId : group->variables())
                     {
                       auto var      = _maps.variable(varId);
                       ranges[varId] = r;
                     }
                   }
                 }
                 else
                 {
                   SCIQLOP_ERROR(VariableController2Private, "Invalid range containing NaN");
                 }
                 return ranges;
               }
               std::vector<DateTimeRange>
               _computeMissingRanges(const std::shared_ptr<Variable2>& var, DateTimeRange r)
               {
                 return r - var->range();
               }
               void _changeRange(QUuid id, DateTimeRange r)
               {
                 _changeRange(_maps.variable(id), r);
               }
               void _changeRange(const std::shared_ptr<Variable2>& var, DateTimeRange r)
               {
                 auto provider      = _maps.provider(*var);
                 auto missingRanges = _computeMissingRanges(var, r);
                 std::vector<TimeSeries::ITimeSerie*> data;
                 for(auto range : missingRanges)
                 {
                   data.push_back(
                       provider->getData(DataProviderParameters{{range}, var->metadata()}));
                 }
                 data.push_back(var->data().get()); // might be smarter
                 var->setData(data, r, true);
               }
             public:
               VariableController2Private(QObject* parent = Q_NULLPTR)
-                  : _cacheStrategy(VariableCacheStrategyFactory::createCacheStrategy(
-                        CacheStrategy::SingleThreshold))
               {
                 Q_UNUSED(parent);
                 this->_ThreadPool = new QThreadPool();
                 this->_ThreadPool->setMaxThreadCount(32);
               }
               /*
                * This dtor has to like this even if this is ugly, because default dtor would
                * rely on declaration order to destruct members and that would always lead to
                * regressions when modifying class members
                */
               ~VariableController2Private() { delete this->_ThreadPool; }
               std::shared_ptr<Variable2>
               createVariable(const QString& name, const QVariantHash& metadata,
                              std::shared_ptr<IDataProvider> provider)
               {
                 auto newVar = std::make_shared<Variable2>(name, metadata);
                 auto group  = std::make_shared<VariableSynchronizationGroup2>(newVar->ID());
                 _maps.addVariable(newVar, std::move(provider), group);
                 this->_transactions.addEntry(*group);
                 return newVar;
               }
               std::shared_ptr<Variable2> variable(QUuid ID) { return _maps.variable(ID); }
               std::shared_ptr<Variable2> variable(int index)
               {
                 return _maps.variable(index);
               }
               std::shared_ptr<Variable2>
               cloneVariable(const std::shared_ptr<Variable2>& variable)
               {
                 auto newVar = variable->clone();
                 _maps.synchronize(newVar, std::nullopt);
                 _maps.addVariable(newVar, _maps.provider(*variable), _maps.group(*newVar));
                 this->_transactions.addEntry(*_maps.group(*newVar));
                 return newVar;
               }
               bool hasPendingTransactions(const std::shared_ptr<Variable2>& variable)
               {
                 return _transactions.active(*_maps.group(*variable));
               }
               bool hasPendingTransactions()
               {
                 bool has = false;
                 for(const auto& var : _maps.variables())
                 {
                   has |= _transactions.active(*_maps.group(*var));
                 }
                 return has;
               }
               void deleteVariable(const std::shared_ptr<Variable2>& variable)
               {
                 if(!hasPendingTransactions(variable))
                   _maps.removeVariable(variable);
                 else
                   _variablesToRemove.push_back(variable->ID());
               }
               void asyncChangeRange(const std::shared_ptr<Variable2>& variable,
                                     const DateTimeRange& r)
               {
                 if(!DateTimeRangeHelper::hasnan(r))
                 {
                   auto group = _maps.group(*variable);
                   // Just overwrite next transaction
                   {
                     _transactions.enqueue(*group,
                                           std::make_shared<VCTransaction>(
                                               variable->ID(), r,
                                               static_cast<int>(group->variables().size())));
                   }
                   _processTransactions();
                 }
                 else
                 {
                   SCIQLOP_ERROR(VariableController2Private, "Invalid range containing NaN");
                 }
               }
               void changeRange(const std::shared_ptr<Variable2>& variable, DateTimeRange r)
               {
                 asyncChangeRange(variable, r);
                 while(hasPendingTransactions(variable))
                 {
                   QCoreApplication::processEvents();
                 }
               }
               inline void synchronize(const std::shared_ptr<Variable2>& var,
                                       const std::shared_ptr<Variable2>& with)
               {
                 _maps.synchronize(var, with);
               }
               inline const std::vector<std::shared_ptr<Variable2>> variables()
               {
                 return _maps.variables();
               }
             };
             VariableController2::VariableController2()
                 : impl{spimpl::make_unique_impl<VariableController2Private>()}
             {}
             std::shared_ptr<Variable2> VariableController2::createVariable(
                 const QString& name, const QVariantHash& metadata,
                 const std::shared_ptr<IDataProvider>& provider, const DateTimeRange& range)
             {
               auto var = impl->createVariable(name, metadata, provider);
               var->setRange(range); // even with no data this is it's range
               if(!DateTimeRangeHelper::hasnan(range))
                 impl->asyncChangeRange(var, range);
               else
                 SCIQLOP_ERROR(VariableController2, "Creating a variable with default "
                                                    "constructed DateTimeRange is an error");
               emit variableAdded(var);
               return var;
             }
             std::shared_ptr<Variable2>
             VariableController2::cloneVariable(const std::shared_ptr<Variable2>& variable)
             {
               return impl->cloneVariable(variable);
             }
             void VariableController2::deleteVariable(
                 const std::shared_ptr<Variable2>& variable)
             {
               impl->deleteVariable(variable);
               emit variableDeleted(variable);
             }
             void VariableController2::changeRange(
                 const std::shared_ptr<Variable2>& variable, const DateTimeRange& r)
             {
               impl->changeRange(variable, r);
             }
             void VariableController2::asyncChangeRange(
                 const std::shared_ptr<Variable2>& variable, const DateTimeRange& r)
             {
               impl->asyncChangeRange(variable, r);
             }
             const std::vector<std::shared_ptr<Variable2>> VariableController2::variables()
             {
               return impl->variables();
             }
             bool VariableController2::isReady(const std::shared_ptr<Variable2>& variable)
             {
               return !impl->hasPendingTransactions(variable);
             }
             bool VariableController2::isReady() { return !impl->hasPendingTransactions(); }
             void VariableController2::synchronize(const std::shared_ptr<Variable2>& var,
                                                   const std::shared_ptr<Variable2>& with)
             {
               impl->synchronize(var, with);
             }
             const std::vector<std::shared_ptr<Variable2>>
             VariableController2::variables(const std::vector<QUuid>& ids)
             {
               std::vector<std::shared_ptr<Variable2>> variables;
               std::transform(std::cbegin(ids), std::cend(ids),
                              std::back_inserter(variables),
                              [this](const auto& id) { return impl->variable(id); });
               return variables;
             }

src/Variable/VariableModel2.cpp 0 -1

             #include <Common/DateUtils.h>
             #include <Common/MimeTypesDef.h>
             #include <Common/StringUtils.h>
             #include <Common/containers.h>
-            #include <Data/IDataSeries.h>
             #include <DataSource/DataSourceController.h>
             #include <QMimeData>
             #include <QSize>
             #include <QTimer>
             #include <Time/TimeController.h>
             #include <Variable/Variable2.h>
             #include <Variable/VariableController2.h>
             #include <Variable/VariableModel2.h>
             #include <unordered_map>
             namespace
             {
               // Column indexes
               const auto NAME_COLUMN     = 0;
               const auto TSTART_COLUMN   = 1;
               const auto TEND_COLUMN     = 2;
               const auto NBPOINTS_COLUMN = 3;
               const auto UNIT_COLUMN     = 4;
               const auto MISSION_COLUMN  = 5;
               const auto PLUGIN_COLUMN   = 6;
               const auto NB_COLUMNS      = 7;
               // Column properties
               const auto DEFAULT_HEIGHT = 25;
               const auto DEFAULT_WIDTH  = 100;
               struct ColumnProperties
               {
                 ColumnProperties(const QString& name = {}, int width = DEFAULT_WIDTH,
                                  int height = DEFAULT_HEIGHT)
                     : m_Name{name}, m_Width{width}, m_Height{height}
                 {}
                 QString m_Name;
                 int m_Width;
                 int m_Height;
               };
               const auto COLUMN_PROPERTIES = QHash<int, ColumnProperties>{
                   {NAME_COLUMN, {QObject::tr("Name")}},
                   {TSTART_COLUMN, {QObject::tr("tStart"), 180}},
                   {TEND_COLUMN, {QObject::tr("tEnd"), 180}},
                   {NBPOINTS_COLUMN, {QObject::tr("Nb points")}},
                   {UNIT_COLUMN, {QObject::tr("Unit")}},
                   {MISSION_COLUMN, {QObject::tr("Mission")}},
                   {PLUGIN_COLUMN, {QObject::tr("Plugin")}}};
               QString uniqueName(const QString& defaultName,
                                  const std::vector<std::shared_ptr<Variable2>>& variables)
               {
                 auto forbiddenNames = std::vector<QString>(variables.size());
                 std::transform(variables.cbegin(), variables.cend(), forbiddenNames.begin(),
                                [](const auto& variable) { return variable->name(); });
                 auto uniqueName = StringUtils::uniqueName(defaultName, forbiddenNames);
                 Q_ASSERT(!uniqueName.isEmpty());
                 return uniqueName;
               }
             } // namespace
             VariableModel2::VariableModel2(QObject* parent) : QAbstractTableModel{parent} {}
             int VariableModel2::columnCount(const QModelIndex& parent) const
             {
               Q_UNUSED(parent);
               return NB_COLUMNS;
             }
             int VariableModel2::rowCount(const QModelIndex& parent) const
             {
               Q_UNUSED(parent);
               return _variables.size();
             }
             QVariant VariableModel2::data(const QModelIndex& index, int role) const
             {
               if(!index.isValid()) { return QVariant{}; }
               if(index.row() < 0 || index.row() >= rowCount()) { return QVariant{}; }
               if(role == Qt::DisplayRole)
               {
                 if(auto variable = _variables[index.row()])
                 {
                   switch(index.column())
                   {
                     case NAME_COLUMN: return variable->name();
                     case TSTART_COLUMN:
                     {
                       if(auto range = variable->realRange(); range.has_value())
                         return DateUtils::dateTime(range.value().m_TStart)
                             .toString(DATETIME_FORMAT);
                       return QVariant{};
                     }
                     case TEND_COLUMN:
                     {
                       if(auto range = variable->realRange(); range.has_value())
                         return DateUtils::dateTime(range.value().m_TEnd)
                             .toString(DATETIME_FORMAT);
                       return QVariant{};
                     }
                     case NBPOINTS_COLUMN: return int(variable->nbPoints());
                     case UNIT_COLUMN:
                       return variable->metadata().value(QStringLiteral("units"));
                     case MISSION_COLUMN:
                       return variable->metadata().value(QStringLiteral("mission"));
                     case PLUGIN_COLUMN:
                       return variable->metadata().value(QStringLiteral("plugin"));
                     default:
                       // No action
                       break;
                   }
                 }
               }
               else if(role == VariableRoles::ProgressRole)
               {
                 return QVariant{};
               }
               return QVariant{};
             }
             QVariant VariableModel2::headerData(int section, Qt::Orientation orientation,
                                                 int role) const
             {
               if(role != Qt::DisplayRole && role != Qt::SizeHintRole) { return QVariant{}; }
               if(orientation == Qt::Horizontal)
               {
                 auto propertiesIt = COLUMN_PROPERTIES.find(section);
                 if(propertiesIt != COLUMN_PROPERTIES.cend())
                 {
                   // Role is either DisplayRole or SizeHintRole
                   return (role == Qt::DisplayRole)
                              ? QVariant{propertiesIt->m_Name}
                              : QVariant{
                                    QSize{propertiesIt->m_Width, propertiesIt->m_Height}};
                 }
               }
               return QVariant{};
             }
             Qt::ItemFlags VariableModel2::flags(const QModelIndex& index) const
             {
               return QAbstractTableModel::flags(index) | Qt::ItemIsDragEnabled |
                      Qt::ItemIsDropEnabled;
             }
             Qt::DropActions VariableModel2::supportedDropActions() const
             {
               return Qt::CopyAction | Qt::MoveAction;
             }
             Qt::DropActions VariableModel2::supportedDragActions() const
             {
               return Qt::CopyAction | Qt::MoveAction;
             }
             QStringList VariableModel2::mimeTypes() const
             {
               return {MIME_TYPE_VARIABLE_LIST, MIME_TYPE_TIME_RANGE};
             }
             QMimeData* VariableModel2::mimeData(const QModelIndexList& indexes) const
             {
               auto mimeData = new QMimeData;
               std::vector<std::shared_ptr<Variable2>> variables;
               DateTimeRange firstTimeRange;
               for(const auto& index : indexes)
               {
                 if(index.column() == 0)
                 { // only the first column
                   auto variable = _variables[index.row()];
                   if(variable.get() && index.isValid())
                   {
                     if(variables.size() == 0)
                     {
                       // Gets the range of the first variable
                       firstTimeRange = variable->range();
                     }
                     variables.push_back(variable);
                   }
                 }
               }
               auto variablesEncodedData = Variable2::mimeData(variables);
               mimeData->setData(MIME_TYPE_VARIABLE_LIST, variablesEncodedData);
               if(variables.size() == 1)
               {
                 // No time range MIME data if multiple variables are dragged
                 auto timeEncodedData = TimeController::mimeDataForTimeRange(firstTimeRange);
                 mimeData->setData(MIME_TYPE_TIME_RANGE, timeEncodedData);
               }
               return mimeData;
             }
             bool VariableModel2::canDropMimeData(const QMimeData* data,
                                                  Qt::DropAction action, int row, int column,
                                                  const QModelIndex& parent) const
             {
               Q_UNUSED(column);
               // drop of a product
               return data->hasFormat(MIME_TYPE_PRODUCT_LIST) ||
                      (data->hasFormat(MIME_TYPE_TIME_RANGE) && parent.isValid() &&
                       !data->hasFormat(MIME_TYPE_VARIABLE_LIST));
             }
             bool VariableModel2::dropMimeData(const QMimeData* data, Qt::DropAction action,
                                               int row, int column,
                                               const QModelIndex& parent)
             {
               auto dropDone = false;
               if(data->hasFormat(MIME_TYPE_PRODUCT_LIST))
               {
                 auto productList = DataSourceController::productsDataForMimeData(
                     data->data(MIME_TYPE_PRODUCT_LIST));
                 for(auto metaData : productList)
                 {
                   emit createVariable(metaData.toHash());
                 }
                 dropDone = true;
               }
               else if(data->hasFormat(MIME_TYPE_TIME_RANGE) && parent.isValid())
               {
                 auto variable = _variables[parent.row()];
                 auto range =
                     TimeController::timeRangeForMimeData(data->data(MIME_TYPE_TIME_RANGE));
                 emit asyncChangeRange(variable, range);
                 dropDone = true;
               }
               return dropDone;
             }
             void VariableModel2::variableUpdated(QUuid id) noexcept
             {
               emit dataChanged(QModelIndex(), QModelIndex());
             }
             void VariableModel2::variableAdded(const std::shared_ptr<Variable2>& variable)
             {
               if(!SciQLop::containers::contains(_variables, variable))
               {
                 beginInsertRows(QModelIndex(), this->_variables.size(),
                                 this->_variables.size());
                 this->_variables.push_back(variable);
                 endInsertRows();
                 connect(variable.get(), &Variable2::updated, this,
                         &VariableModel2::variableUpdated);
               }
             }
             void VariableModel2::variableDeleted(const std::shared_ptr<Variable2>& variable)
             {
               auto it = std::find(_variables.begin(), _variables.end(), variable);
               if(it != _variables.end())
               {
                 auto index = std::distance(_variables.begin(), it);
                 beginRemoveRows(QModelIndex(), index, index);
                 _variables.erase(it);
                 endRemoveRows();
               }
             }

src/Visualization/VisualizationController.cpp +20 -25

-            #include <Visualization/VisualizationController.h>
-            #include <Variable/Variable.h>
-            #include <QMutex>
-            #include <QThread>
             #include <QDir>
+            #include <QMutex>
             #include <QStandardPaths>
+            #include <QThread>
+            #include <Visualization/VisualizationController.h>
             Q_LOGGING_CATEGORY(LOG_VisualizationController, "VisualizationController")
-            class VisualizationController::VisualizationControllerPrivate {
+            class VisualizationController::VisualizationControllerPrivate
+            {
             public:
-                QMutex m_WorkingMutex;
+              QMutex m_WorkingMutex;
             };
-            VisualizationController::VisualizationController(QObject *parent)
+            VisualizationController::VisualizationController(QObject* parent)
-                    : impl{spimpl::make_unique_impl<VisualizationControllerPrivate>()}
+                : impl{spimpl::make_unique_impl<VisualizationControllerPrivate>()}
             {
-                qCDebug(LOG_VisualizationController()) << tr("VisualizationController construction")
+              qCDebug(LOG_VisualizationController())
-                                                       << QThread::currentThread();
+                  << tr("VisualizationController construction") << QThread::currentThread();
             }
             VisualizationController::~VisualizationController()
             {
-                qCDebug(LOG_VisualizationController()) << tr("VisualizationController destruction")
+              qCDebug(LOG_VisualizationController())
-                                                       << QThread::currentThread();
+                  << tr("VisualizationController destruction") << QThread::currentThread();
-                this->waitForFinish();
+              this->waitForFinish();
             }
             void VisualizationController::initialize()
             {
-                qCDebug(LOG_VisualizationController()) << tr("VisualizationController init")
+              qCDebug(LOG_VisualizationController())
-                                                       << QThread::currentThread();
+                  << tr("VisualizationController init") << QThread::currentThread();
-                impl->m_WorkingMutex.lock();
+              impl->m_WorkingMutex.lock();
-                qCDebug(LOG_VisualizationController()) << tr("VisualizationController init END");
+              qCDebug(LOG_VisualizationController())
+                  << tr("VisualizationController init END");
             }
-            void VisualizationController::finalize()
+            void VisualizationController::finalize() { impl->m_WorkingMutex.unlock(); }
-                impl->m_WorkingMutex.unlock();
             void VisualizationController::waitForFinish()
             {
-                QMutexLocker locker{&impl->m_WorkingMutex};
+              QMutexLocker locker{&impl->m_WorkingMutex};
             }

src/pybind11_wrappers/CoreWrappers.cpp 0 -110

             #include "CoreWrappers.h"
             #include "pywrappers_common.h"
             #include <Data/DataSeriesType.h>
             #include <Data/IDataProvider.h>
-            #include <Data/OptionalAxis.h>
-            #include <Data/ScalarSeries.h>
-            #include <Data/SpectrogramSeries.h>
-            #include <Data/Unit.h>
-            #include <Data/VectorSeries.h>
             #include <Network/Downloader.h>
             #include <Time/TimeController.h>
             #include <Variable/Variable2.h>
             #include <Variable/VariableController2.h>
             #include <pybind11/chrono.h>
             #include <pybind11/embed.h>
             #include <pybind11/functional.h>
             #include <pybind11/numpy.h>
             #include <pybind11/operators.h>
             #include <pybind11/pybind11.h>
             #include <pybind11/stl.h>
             #include <pybind11/stl_bind.h>
             #include <sstream>
             #include <string>
             namespace py = pybind11;
             using namespace std::chrono;
             template<typename T, typename U, bool row_major = true>
             void copy_vector(py::array_t<double>& t, py::array_t<double>& values, T& dest_t,
                              U& dest_values)
             {
               auto t_view      = t.unchecked<1>();
               auto values_view = values.unchecked<2>();
               if constexpr(row_major)
               {
                 for(std::size_t i = 0; i < t.size(); i++)
                 {
                   dest_t[i]      = t_view[i];
                   dest_values[i] = {values_view(i, 0), values_view(i, 1),
                                     values_view(i, 2)};
                 }
               }
               else
               {
                 for(std::size_t i = 0; i < t.size(); i++)
                 {
                   dest_t[i]      = t_view[i];
                   dest_values[i] = {values_view(0, i), values_view(1, i),
                                     values_view(2, i)};
                 }
               }
             }
             template<typename T, typename U>
             void copy_scalar(py::array_t<double>& t, py::array_t<double>& values, T& dest_t,
                              U& dest_values)
             {
               auto t_view      = t.unchecked<1>();
               auto values_view = values.unchecked<1>();
               for(std::size_t i = 0; i < t.size(); i++)
               {
                 dest_t[i]      = t_view[i];
                 dest_values[i] = values_view[i];
               }
             }
             template<typename T, typename U>
             void copy_spectro(py::array_t<double>& t, py::array_t<double>& values,
                               T& dest_t, U& dest_values)
             {
               auto t_view      = t.unchecked<1>();
               auto values_view = values.unchecked<2>();
               const auto width = values.shape(0);
               for(std::size_t i = 0; i < t.size(); i++)
               {
                 dest_t[i] = t_view[i];
                 for(int j = 0; j < width; j++)
                 {
                   dest_values[i * width + j] = values_view(j, i);
                 }
               }
             }
             PYBIND11_MODULE(pysciqlopcore, m)
             {
               pybind11::bind_vector<std::vector<double>>(m, "VectorDouble");
               py::enum_<DataSeriesType>(m, "DataSeriesType")
                   .value("SCALAR", DataSeriesType::SCALAR)
                   .value("SPECTROGRAM", DataSeriesType::SPECTROGRAM)
                   .value("VECTOR", DataSeriesType::VECTOR)
                   .value("NONE", DataSeriesType::NONE)
                   .export_values();
-              py::class_<Unit>(m, "Unit")
-                  .def_readwrite("name", &Unit::m_Name)
-                  .def_readwrite("time_unit", &Unit::m_TimeUnit)
-                  .def(py::self == py::self)
-                  .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_<ArrayDataIteratorValue>(m, "ArrayDataIteratorValue")
-                  .def_property_readonly("value", &ArrayDataIteratorValue::first);
-              py::class_<OptionalAxis>(m, "OptionalAxis")
-                  .def("__len__", &OptionalAxis::size)
-                  .def_property_readonly("size", &OptionalAxis::size)
-                  .def("__getitem__",
-                       [](OptionalAxis& ax, int key) {
-                         return (*(ax.begin() + key)).first();
-                       },
-                       py::is_operator())
-                  .def("__iter__",
-                       [](OptionalAxis& ax) {
-                         return py::make_iterator(ax.begin(), ax.end());
-                       },
-                       py::keep_alive<0, 1>());
-              py::class_<DataSeriesIteratorValue>(m, "DataSeriesIteratorValue")
-                  .def_property_readonly("x", &DataSeriesIteratorValue::x)
-                  .def_property_readonly("y", &DataSeriesIteratorValue::y)
-                  .def("value",
-                       py::overload_cast<>(&DataSeriesIteratorValue::value, py::const_))
-                  .def("value",
-                       py::overload_cast<int>(&DataSeriesIteratorValue::value, py::const_))
-                  .def("values", &DataSeriesIteratorValue::values);
-              py::class_<IDataSeries, std::shared_ptr<IDataSeries>>(m, "IDataSeries")
-                  .def("nbPoints", &IDataSeries::nbPoints)
-                  .def_property_readonly("xAxisUnit", &IDataSeries::xAxisUnit)
-                  .def_property_readonly("yAxisUnit", &IDataSeries::yAxisUnit)
-                  .def_property_readonly("valuesUnit", &IDataSeries::valuesUnit)
-                  .def("__getitem__",
-                       [](IDataSeries& serie, int key) { return *(serie.begin() + key); },
-                       py::is_operator())
-                  .def("__len__", &IDataSeries::nbPoints)
-                  .def("__iter__",
-                       [](IDataSeries& serie) {
-                         return py::make_iterator(serie.begin(), serie.end());
-                       },
-                       py::keep_alive<0, 1>())
-                  .def("__repr__", __repr__<IDataSeries>);
-              py::class_<ArrayData<1>, std::shared_ptr<ArrayData<1>>>(m, "ArrayData1d")
-                  .def("cdata", [](ArrayData<1>& array) { return array.cdata(); });
-              py::class_<ScalarSeries, std::shared_ptr<ScalarSeries>, IDataSeries>(
-                  m, "ScalarSeries")
-                  .def("nbPoints", &ScalarSeries::nbPoints);
-              py::class_<VectorSeries, std::shared_ptr<VectorSeries>, IDataSeries>(
-                  m, "VectorSeries")
-                  .def("nbPoints", &VectorSeries::nbPoints);
-              py::class_<DataSeries<2>, std::shared_ptr<DataSeries<2>>, IDataSeries>(
-                  m, "DataSeries2d")
-                  .def_property_readonly(
-                      "xAxis", py::overload_cast<>(&DataSeries<2>::xAxisData, py::const_))
-                  .def_property_readonly(
-                      "yAxis", py::overload_cast<>(&DataSeries<2>::yAxis, py::const_));
-              py::class_<SpectrogramSeries, std::shared_ptr<SpectrogramSeries>,
-                         DataSeries<2>>(m, "SpectrogramSeries")
-                  .def("nbPoints", &SpectrogramSeries::nbPoints)
-                  .def("xRes", &SpectrogramSeries::xResolution);
               py::class_<IDataProvider, std::shared_ptr<IDataProvider>>(m, "IDataProvider");
-              py::class_<Variable, std::shared_ptr<Variable>>(m, "Variable")
-                  .def(py::init<const QString&>())
-                  .def_property("name", &Variable::name, &Variable::setName)
-                  .def_property("range", &Variable::range, &Variable::setRange)
-                  .def_property("cacheRange", &Variable::cacheRange,
-                                &Variable::setCacheRange)
-                  .def_property_readonly("nbPoints", &Variable::nbPoints)
-                  .def_property_readonly("dataSeries", &Variable::dataSeries)
-                  .def("__len__",
-                       [](Variable& variable) {
-                         auto rng = variable.dataSeries()->xAxisRange(
-                             variable.range().m_TStart, variable.range().m_TEnd);
-                         return std::distance(rng.first, rng.second);
-                       })
-                  .def("__iter__",
-                       [](Variable& variable) {
-                         auto rng = variable.dataSeries()->xAxisRange(
-                             variable.range().m_TStart, variable.range().m_TEnd);
-                         return py::make_iterator(rng.first, rng.second);
-                       },
-                       py::keep_alive<0, 1>())
-                  .def("__getitem__",
-                       [](Variable& variable, int key) {
-                         // insane and slow!
-                         auto rng = variable.dataSeries()->xAxisRange(
-                             variable.range().m_TStart, variable.range().m_TEnd);
-                         if(key < 0)
-                           return *(rng.second + key);
-                         else
-                           return *(rng.first + key);
-                       })
-                  .def("__repr__", __repr__<Variable>);
               py::class_<TimeSeries::ITimeSerie, std::shared_ptr<TimeSeries::ITimeSerie>>(
                   m, "ITimeSerie")
                   .def_property_readonly(
                       "size", [](const TimeSeries::ITimeSerie& ts) { return ts.size(); })
                   .def("__len__",
                        [](const TimeSeries::ITimeSerie& ts) { return ts.size(); })
                   .def_property_readonly(
                       "shape", [](const TimeSeries::ITimeSerie& ts) { return ts.shape(); })
                   .def_property_readonly(
                       "t",
                       [](TimeSeries::ITimeSerie& ts) -> decltype(ts.axis(0))& {
                         return ts.axis(0);
                       },
                       py::return_value_policy::reference);
               py::class_<ScalarTimeSerie, TimeSeries::ITimeSerie>(m, "ScalarTimeSerie")
                   .def(py::init<>())
                   .def(py::init<std::size_t>())
                   .def(py::init([](py::array_t<double> t, py::array_t<double> values) {
                     assert(t.size() == values.size());
                     ScalarTimeSerie::axis_t _t(t.size());
                     ScalarTimeSerie::axis_t _values(t.size());
                     copy_scalar(t, values, _t, _values);
                     return ScalarTimeSerie(_t, _values);
                   }))
                   .def("__getitem__",
                        [](ScalarTimeSerie& ts, std::size_t key) { return ts[key]; })
                   .def("__setitem__", [](ScalarTimeSerie& ts, std::size_t key,
                                          double value) { *(ts.begin() + key) = value; });
               py::class_<VectorTimeSerie::raw_value_type>(m, "vector")
                   .def(py::init<>())
                   .def(py::init<double, double, double>())
                   .def("__repr__", __repr__<VectorTimeSerie::raw_value_type>)
                   .def_readwrite("x", &VectorTimeSerie::raw_value_type::x)
                   .def_readwrite("y", &VectorTimeSerie::raw_value_type::y)
                   .def_readwrite("z", &VectorTimeSerie::raw_value_type::z);
               py::class_<VectorTimeSerie, TimeSeries::ITimeSerie>(m, "VectorTimeSerie")
                   .def(py::init<>())
                   .def(py::init<std::size_t>())
                   .def(py::init([](py::array_t<double> t, py::array_t<double> values) {
                     assert(t.size() * 3 == values.size());
                     VectorTimeSerie::axis_t _t(t.size());
                     VectorTimeSerie::container_type<VectorTimeSerie::raw_value_type>
                         _values(t.size());
                     if(values.shape()[0] == 3 && values.shape(1) != 3)
                     {
                       copy_vector<decltype(_t), decltype(_values), false>(t, values, _t,
                                                                           _values);
                     }
                     else
                     {
                       copy_vector(t, values, _t, _values);
                     }
                     return VectorTimeSerie(_t, _values);
                   }))
                   .def("__getitem__",
                        [](VectorTimeSerie& ts, std::size_t key)
                            -> VectorTimeSerie::raw_value_type& { return ts[key]; },
                        py::return_value_policy::reference)
                   .def("__setitem__", [](VectorTimeSerie& ts, std::size_t key,
                                          VectorTimeSerie::raw_value_type value) {
                     *(ts.begin() + key) = value;
                   });
               py::class_<SpectrogramTimeSerie::iterator_t>(m, "SpectrogramTimeSerieItem")
                   .def("__getitem__", [](SpectrogramTimeSerie::iterator_t& self,
                                          std::size_t key) { return (*self)[key]; })
                   .def("__setitem__",
                        [](SpectrogramTimeSerie::iterator_t& self, std::size_t key,
                           double value) { (*self)[key] = value; });
               py::class_<SpectrogramTimeSerie, TimeSeries::ITimeSerie>(
                   m, "SpectrogramTimeSerie")
                   .def(py::init<>())
                   .def(py::init<const std::vector<std::size_t>>())
                   .def(py::init([](py::array_t<double> t, py::array_t<double> values) {
                     assert(t.size() < values.size()); // TODO check geometry
                     SpectrogramTimeSerie::axis_t _t(t.size());
                     SpectrogramTimeSerie::container_type<
                         SpectrogramTimeSerie::raw_value_type>
                         _values(values.size());
                     copy_spectro(t, values, _t, _values);
                     std::vector<std::size_t> shape;
                     shape.push_back(values.shape(1));
                     shape.push_back(values.shape(0));
                     return SpectrogramTimeSerie(_t, _values, shape);
                   }))
                   .def("__getitem__",
                        [](SpectrogramTimeSerie& ts,
                           std::size_t key) -> SpectrogramTimeSerie::iterator_t {
                          return ts.begin() + key;
                        });
               py::class_<Variable2, std::shared_ptr<Variable2>>(m, "Variable2")
                   .def(py::init<const QString&>())
                   .def_property("name", &Variable2::name, &Variable2::setName)
                   .def_property_readonly("range", &Variable2::range)
                   .def_property_readonly("nbPoints", &Variable2::nbPoints)
                   .def_property_readonly(
                       "data",
                       [](Variable2& var) -> std::shared_ptr<TimeSeries::ITimeSerie> {
                         return var.data();
                       })
                   .def("set_data",
                        [](Variable2& var, std::vector<TimeSeries::ITimeSerie*> ts_list,
                           const DateTimeRange& range) { var.setData(ts_list, range); })
                   .def("__len__", &Variable2::nbPoints)
                   .def("__repr__", __repr__<Variable2>);
               py::class_<DateTimeRange>(m, "SqpRange")
                   //.def("fromDateTime", &DateTimeRange::fromDateTime,
                   // py::return_value_policy::move)
                   .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_ =
 .001 *
                             duration_cast<milliseconds>(start.time_since_epoch()).count();
                         double stop_ =
 .001 *
                             duration_cast<milliseconds>(stop.time_since_epoch()).count();
                         return DateTimeRange{start_, stop_};
                       }))
                   .def_property_readonly("start",
                                          [](const DateTimeRange& range) {
                                            return system_clock::from_time_t(range.m_TStart);
                                          })
                   .def_property_readonly("stop",
                                          [](const DateTimeRange& range) {
                                            return system_clock::from_time_t(range.m_TEnd);
                                          })
                   .def("__repr__", __repr__<DateTimeRange>);
             }

src/pybind11_wrappers/CoreWrappers.h 0 -38

             #pragma once
             #include "QtWrappers.h"
             #include "pywrappers_common.h"
             #include <Data/DataSeriesType.h>
             #include <Data/DateTimeRange.h>
-            #include <Data/IDataSeries.h>
-            #include <Data/Unit.h>
-            #include <Variable/Variable.h>
             #include <Variable/Variable2.h>
             #include <pybind11/pybind11.h>
             #include <sstream>
             #include <string>
             PYBIND11_MAKE_OPAQUE(std::vector<double>);
-            std::ostream& operator<<(std::ostream& os, const Unit& u)
-              os << "=========================" << std::endl
-                 << "Unit:" << std::endl
-                 << " Name: " << u.m_Name << std::endl
-                 << " Is_TimeUnit: " << u.m_TimeUnit << std::endl;
-              return os;
-            std::ostream& operator<<(std::ostream& os, const IDataSeries& ds)
-              os << "=========================" << std::endl
-                 << "DataSerie:" << std::endl
-                 << " Number of points:" << ds.nbPoints() << std::endl
-                 << " X Axis Unit:" << std::endl
-                 << ds.xAxisUnit() << std::endl
-                 << " Y Axis Unit:" << std::endl
-                 << ds.yAxisUnit() << std::endl
-                 << " Values Axis Unit:" << std::endl
-                 << ds.valuesUnit() << std::endl;
-              return os;
             std::ostream& operator<<(std::ostream& os, const DateTimeRange& range)
             {
               os << "=========================" << std::endl
                  << "SqpRange:" << std::endl
                  << " Start date: " << DateUtils::dateTime(range.m_TStart).toString()
                  << std::endl
                  << " Stop date: " << DateUtils::dateTime(range.m_TEnd).toString()
                  << std::endl;
               return os;
             }
-            std::ostream& operator<<(std::ostream& os, const Variable& variable)
-              os << "=========================" << std::endl
-                 << "Variable:" << std::endl
-                 << " Name: " << variable.name() << std::endl
-                 << " range: " << std::endl
-                 << variable.range() << std::endl
-                 << " cache range: " << std::endl
-                 << variable.cacheRange() << std::endl;
-              return os;
             std::ostream& operator<<(std::ostream& os, Variable2& variable)
             {
               os << "=========================" << std::endl
                  << "Variable:" << std::endl
                  << " Name: " << variable.name() << std::endl
                  << " range: " << std::endl
                  << variable.range() << std::endl;
               return os;
             }
             std::ostream& operator<<(std::ostream& os,
                                      const VectorTimeSerie::raw_value_type& value)
             {
               os << "[" << value.x << ", " << value.y << ", " << value.z << "]"
                  << std::endl;
               return os;
             }

tests/CMakeLists.txt 0 -15

             add_definitions(-DCORE_TESTS_RESOURCES_DIR="${CMAKE_CURRENT_LIST_DIR}/../tests-resources")
             FILE (GLOB_RECURSE  TestUtilsSources
                 TestUtils/TestProviders.h
                 TestUtils/TestProviders.cpp
             )
             add_library(TestUtils ${TestUtilsSources})
             target_link_libraries(TestUtils sciqlopcore Qt5::Test)
             target_include_directories(TestUtils PUBLIC
                 $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>/TestUtils
             )
             declare_test(TestStringUtils TestStringUtils Common/TestStringUtils.cpp "sciqlopcore;Qt5::Test")
             declare_test(TestContainers TestContainers Common/TestContainers.cpp "sciqlopcore;Qt5::Test")
             declare_test(TestSyncGroup TestSyncGroup Variable/TestSyncGroup.cpp "sciqlopcore;Qt5::Test")
             declare_test(TestDateTimeRange TestDateTimeRange Data/TestDateTimeRange.cpp "sciqlopcore;Qt5::Test")
-            declare_test(TestDataSeriesUtils TestDataSeriesUtils Data/TestDataSeriesUtils.cpp "sciqlopcore;Qt5::Test")
-            declare_test(TestOptionalAxis TestOptionalAxis Data/TestOptionalAxis.cpp "sciqlopcore;Qt5::Test")
-            declare_test(TestSpectrogramSeries TestSpectrogramSeries
-                "Data/TestSpectrogramSeries.cpp;Data/DataSeriesBuilders.h;Data/DataSeriesBuilders.cpp;Data/DataSeriesTestsUtils.h;Data/DataSeriesTestsUtils.cpp"
-                "sciqlopcore;Qt5::Test")
-            declare_test(TestOneDimArrayData TestOneDimArrayData Data/TestOneDimArrayData.cpp "sciqlopcore;Qt5::Test")
-            declare_test(TestScalarSeries TestScalarSeries
-                "Data/TestScalarSeries.cpp;Data/DataSeriesBuilders.h;Data/DataSeriesBuilders.cpp;Data/DataSeriesTestsUtils.h;Data/DataSeriesTestsUtils.cpp"
-                "sciqlopcore;Qt5::Test")
-            declare_test(TestTwoDimArrayData TestTwoDimArrayData Data/TestTwoDimArrayData.cpp "sciqlopcore;Qt5::Test")
-            declare_test(TestVectorSeries TestVectorSeries
-                "Data/TestVectorSeries.cpp;Data/DataSeriesBuilders.h;Data/DataSeriesBuilders.cpp;Data/DataSeriesTestsUtils.h;Data/DataSeriesTestsUtils.cpp"
-                "sciqlopcore;Qt5::Test")
             declare_test(TestDataSourceController TestDataSourceController
                 "DataSource/TestDataSourceController.cpp;DataSource/DataSourceItemBuilder.cpp"
                 "sciqlopcore;Qt5::Test")
             declare_test(TestDataSourceItem TestDataSourceItem
                 "DataSource/TestDataSourceItem.cpp;DataSource/DataSourceItemBuilder.cpp"
                 "sciqlopcore;Qt5::Test")
             declare_test(TestVariable TestVariable Variable/TestVariable.cpp "sciqlopcore;Qt5::Test")
             declare_test(TestDownloader TestDownloader Network/TestDownloader.cpp "sciqlopcore;Qt5::Test;Qt5::Concurrent")
             declare_test(TestVariableController2 TestVariableController2 Variable/TestVariableController2.cpp "sciqlopcore;TestUtils;Qt5::Test")
             declare_test(TestVariableController2Async TestVariableController2Async Variable/TestVariableController2Async.cpp "sciqlopcore;TestUtils;Qt5::Test")
             declare_test(TestVariableController2WithSync TestVariableController2WithSync Variable/TestVariableController2WithSync.cpp "sciqlopcore;TestUtils;Qt5::Test")
             declare_test(TestCatalogueController TestCatalogueController CatalogueController/TestCatalogueController.cpp "sciqlopcore;TestUtils;Qt5::Test")
             add_executable(TestVariablesEmbed TestUtils/PyTestWrapperExe.cpp)
             target_link_libraries(TestVariablesEmbed PRIVATE pybind11::embed)
             add_test(NAME TestTestVariablesEmbed COMMAND TestVariablesEmbed)
             target_compile_definitions(TestVariablesEmbed PRIVATE -DPYTEST_SCRIPT="${CMAKE_CURRENT_LIST_DIR}/TestVariables.py")
             set_tests_properties(TestTestVariablesEmbed  PROPERTIES ENVIRONMENT PYTHONPATH=${CMAKE_CURRENT_BINARY_DIR}/../)
             find_package(PythonInterp 3 REQUIRED)
             add_test(NAME TestVariables
               COMMAND ${PYTHON_EXECUTABLE}
                 ${CMAKE_CURRENT_LIST_DIR}/TestVariables.py
                 TestVariables)
             set_tests_properties(TestVariables  PROPERTIES ENVIRONMENT PYTHONPATH=${CMAKE_CURRENT_BINARY_DIR}/../)

tests/TestUtils/TestProviders.h 0 -2

             #ifndef TESTPROVIDER_H
             #define TESTPROVIDER_H
             #include <Data/DataProviderParameters.h>
-            #include <Data/DataSeries.h>
             #include <Data/IDataProvider.h>
-            #include <Data/ScalarSeries.h>
             #include <Data/ScalarTimeSerie.h>
             #include <QUuid>
             #include <QtGlobal>
             #include <QtTest>
             #include <TimeSeries.h>
             #include <Variable/Variable2.h>
             #include <algorithm>
             #include <cmath>
             #include <memory>
             #include <numeric>
             template<int slope> class SimpleRange : public IDataProvider
             {
             public:
               SimpleRange() = default;
               int callCounter = 0;
               std::shared_ptr<IDataProvider> clone() const override
               {
                 return std::make_shared<SimpleRange>();
               }
               TimeSeries::ITimeSerie*
               getData(const DataProviderParameters& parameters) override
               {
                 callCounter += 1;
                 std::size_t size =
                     static_cast<std::size_t>(floor(parameters.m_Range.m_TEnd) -
                                              ceil(parameters.m_Range.m_TStart) + 1.);
                 auto serie = new ScalarTimeSerie(size);
                 std::generate(std::begin(*serie), std::end(*serie),
                               [i = ceil(parameters.m_Range.m_TStart)]() mutable {
                                 return std::pair<double, double>{i, i++ * slope};
                               });
                 return serie;
               }
             };
             template<class T> auto sumdiff(T begin, T end)
             {
               std::vector<double> diff_vect(end - begin - 1);
               auto diff = [](auto next, auto item) { return next.value() - item.value(); };
               std::transform(begin + 1, end, begin, diff_vect.begin(), diff);
               return std::accumulate(diff_vect.cbegin(), diff_vect.cend(), 0);
             }
             template<int slope = 1> struct RangeType
             {
               static void check_properties(std::shared_ptr<Variable2> v, DateTimeRange r)
               {
                 // TODO
               }
             };
             template<class T>
             void check_variable_state(std::shared_ptr<Variable2> v, DateTimeRange r)
             {
               auto range = v->data()->axis_range(0);
               QVERIFY(range.first >= r.m_TStart);
               QVERIFY(range.second <= r.m_TEnd);
               T::check_properties(v, r);
             }
             #endif

tests/Variable/TestVariableController2.cpp 0 -1

             #include <Common/containers.h>
             #include <Data/DataProviderParameters.h>
             #include <Data/DateTimeRange.h>
             #include <Data/IDataProvider.h>
-            #include <Data/ScalarSeries.h>
             #include <QObject>
             #include <QtTest>
             #include <TestUtils/TestProviders.h>
             #include <Variable/VariableController2.h>
             #include <algorithm>
             #include <cmath>
             #include <numeric>
             #define TEST_VC2_FIXTURE(slope)                                                \
               VariableController2 vc;                                                      \
               auto provider = std::make_shared<SimpleRange<slope>>();
             #define TEST_VC2_CREATE_DEFAULT_VAR(name)                                      \
               auto range = DateTimeRange::fromDateTime(QDate(2018, 8, 7), QTime(14, 00),   \
                                                        QDate(2018, 8, 7), QTime(16, 00));  \
               auto name  = vc.createVariable("name", {}, provider, range);                 \
               while(!vc.isReady(name))                                                     \
                 QCoreApplication::processEvents();
             Q_DECLARE_METATYPE(DateTimeRangeTransformation);
             class TestVariableController2 : public QObject
             {
               Q_OBJECT
             public:
               explicit TestVariableController2(QObject* parent = nullptr) : QObject(parent)
               {}
             signals:
             private slots:
               void initTestCase() {}
               void cleanupTestCase() {}
               void testCreateVariable()
               {
                 TEST_VC2_FIXTURE(2);
                 auto range = DateTimeRange::fromDateTime(QDate(2018, 8, 7), QTime(14, 00),
                                                          QDate(2018, 8, 7), QTime(16, 00));
                 bool callbackCalled = false;
                 connect(&vc, &VariableController2::variableAdded,
                         [&callbackCalled](std::shared_ptr<Variable2>) {
                           callbackCalled = true;
                         });
                 QVERIFY(!callbackCalled);
                 auto var1 = vc.createVariable("var1", {}, provider, range);
                 QVERIFY(SciQLop::containers::contains(vc.variables(), var1));
                 QVERIFY(callbackCalled);
               }
               void testDeleteVariable()
               {
                 TEST_VC2_FIXTURE(1);
                 auto range = DateTimeRange::fromDateTime(QDate(2018, 8, 7), QTime(14, 00),
                                                          QDate(2018, 8, 7), QTime(16, 00));
                 bool callbackCalled = false;
                 connect(&vc, &VariableController2::variableDeleted,
                         [&callbackCalled](std::shared_ptr<Variable2>) {
                           callbackCalled = true;
                         });
                 auto var1 = vc.createVariable("var1", {}, provider, range);
                 while(!vc.isReady(var1))
                   QCoreApplication::processEvents();
                 QVERIFY(SciQLop::containers::contains(vc.variables(), var1));
                 QVERIFY(!callbackCalled);
                 vc.deleteVariable(var1);
                 QVERIFY(!SciQLop::containers::contains(vc.variables(), var1));
                 QVERIFY(callbackCalled);
               }
               void testGetData()
               {
                 TEST_VC2_FIXTURE(10);
                 TEST_VC2_CREATE_DEFAULT_VAR(var1);
                 check_variable_state<RangeType<10>>(var1, range);
               }
               void testZoom_data()
               {
                 QTest::addColumn<double>("zoom");
                 QTest::newRow("Zoom IN 10x") << .1;
                 QTest::newRow("Zoom OUT 10x") << 10.;
                 QTest::newRow("Zoom IN 1x") << 1.;
               }
               void testZoom()
               {
                 TEST_VC2_FIXTURE(100);
                 TEST_VC2_CREATE_DEFAULT_VAR(var1);
                 check_variable_state<RangeType<100>>(var1, range);
                 QFETCH(double, zoom);
                 range *= zoom;
                 vc.changeRange(var1, range);
                 check_variable_state<RangeType<100>>(var1, range);
               }
               void testPan_data()
               {
                 QTest::addColumn<double>("pan");
                 QTest::newRow("Right 1000 seconds") << 1000.;
                 QTest::newRow("Left 1000 seconds") << -1000.;
                 QTest::newRow("Right 0.1 seconds") << .1;
                 QTest::newRow("Left 0.1 seconds") << -.1;
               }
               void testPan()
               {
                 TEST_VC2_FIXTURE(10);
                 TEST_VC2_CREATE_DEFAULT_VAR(var1);
                 check_variable_state<RangeType<10>>(var1, range);
                 QFETCH(double, pan);
                 range += Seconds<double>{pan};
                 vc.changeRange(var1, range);
                 check_variable_state<RangeType<10>>(var1, range);
               }
               void testCache_data()
               {
                 QTest::addColumn<DateTimeRangeTransformation>("transformation");
                 QTest::addColumn<int>("expectedIncrement");
                 QTest::newRow("zoom in")
                     << DateTimeRangeTransformation{0.8, Seconds<double>(0.)} << 0;
                 QTest::newRow("tiny zoom out")
                     << DateTimeRangeTransformation{1.01, Seconds<double>(0.)} << 0;
                 QTest::newRow("just under cache zoom out")
                     << DateTimeRangeTransformation{2.0 / 1.1, Seconds<double>(0.)} << 0;
                 QTest::newRow("just over cache zoom out")
                     << DateTimeRangeTransformation{2.001 / 1.1, Seconds<double>(0.)} << 2;
                 QTest::newRow("tiny pan left")
                     << DateTimeRangeTransformation{1., Seconds<double>(-100.)} << 0;
                 QTest::newRow("tiny pan right")
                     << DateTimeRangeTransformation{1., Seconds<double>(100.)} << 0;
               }
               void testCache()
               {
                 QSKIP("The cache is disabled for now");
                 TEST_VC2_FIXTURE(10);
                 TEST_VC2_CREATE_DEFAULT_VAR(var1);
                 check_variable_state<RangeType<10>>(var1, range);
                 QFETCH(DateTimeRangeTransformation, transformation);
                 QFETCH(int, expectedIncrement);
                 auto initialCount = provider->callCounter;
                 range             = range.transform(transformation);
                 vc.changeRange(var1, range);
                 check_variable_state<RangeType<10>>(var1, range);
                 QCOMPARE(provider->callCounter - initialCount, expectedIncrement);
               }
             };
             QTEST_MAIN(TestVariableController2)
             #include "TestVariableController2.moc"

include/Common/variant_with_base.h removed 0 -187

NO CONTENT: file was removed

include/Data/ArrayData.h removed 0 -373

NO CONTENT: file was removed

include/Data/ArrayDataIterator.h removed 0 -74

NO CONTENT: file was removed

include/Data/DataSeries.h removed 0 -510

	1	NO CONTENT: file was removed			NO CONTENT: file was removed
This diff has been collapsed as it changes many lines, (510 lines changed) Show them Hide them

include/Data/DataSeriesIterator.h removed 0 -81

NO CONTENT: file was removed

include/Data/DataSeriesMergeHelper.h removed 0 -83

NO CONTENT: file was removed

include/Data/DataSeriesUtils.h removed 0 -317

NO CONTENT: file was removed

include/Data/IDataSeries.h removed 0 -108

NO CONTENT: file was removed

include/Data/OptionalAxis.h removed 0 -66

NO CONTENT: file was removed

include/Data/ScalarSeries.h removed 0 -27

NO CONTENT: file was removed

include/Data/SpectrogramSeries.h removed 0 -59

NO CONTENT: file was removed

include/Data/Unit.h removed 0 -27

NO CONTENT: file was removed

include/Data/VectorSeries.h removed 0 -34

NO CONTENT: file was removed

include/Variable/ProportionalCacheStrategy.h removed 0 -24

NO CONTENT: file was removed

include/Variable/SingleThresholdCacheStrategy.h removed 0 -22

NO CONTENT: file was removed

include/Variable/Variable.h removed 0 -119

NO CONTENT: file was removed

include/Variable/VariableCacheStrategy.h removed 0 -17

NO CONTENT: file was removed

include/Variable/VariableCacheStrategyFactory.h removed 0 -48

NO CONTENT: file was removed

src/Data/ArrayDataIterator.cpp removed 0 -77

NO CONTENT: file was removed

src/Data/DataSeriesIterator.cpp removed 0 -88

NO CONTENT: file was removed

src/Data/DataSeriesUtils.cpp removed 0 -194

NO CONTENT: file was removed

src/Data/OptionalAxis.cpp removed 0 -107

NO CONTENT: file was removed

src/Data/ScalarSeries.cpp removed 0 -31

NO CONTENT: file was removed

src/Data/ScalarTimeSerie.cpp removed 0 -1

NO CONTENT: file was removed

src/Data/SpectrogramSeries.cpp removed 0 -61

NO CONTENT: file was removed

src/Data/VectorSeries.cpp removed 0 -83

NO CONTENT: file was removed

src/Data/VectorTimeSerie.cpp removed 0 -1

NO CONTENT: file was removed

src/Variable/Variable.cpp removed 0 -211

NO CONTENT: file was removed

tests/Data/DataSeriesBuilders.cpp removed 0 -90

NO CONTENT: file was removed

tests/Data/DataSeriesBuilders.h removed 0 -74

NO CONTENT: file was removed

tests/Data/DataSeriesTestsUtils.cpp removed 0 -24

NO CONTENT: file was removed

tests/Data/DataSeriesTestsUtils.h removed 0 -373

NO CONTENT: file was removed

tests/Data/TestDataSeriesUtils.cpp removed 0 -206

NO CONTENT: file was removed

tests/Data/TestOneDimArrayData.cpp removed 0 -181

NO CONTENT: file was removed

tests/Data/TestOptionalAxis.cpp removed 0 -113

NO CONTENT: file was removed

tests/Data/TestScalarSeries.cpp removed 0 -426

NO CONTENT: file was removed

tests/Data/TestSpectrogramSeries.cpp removed 0 -198

NO CONTENT: file was removed

tests/Data/TestTwoDimArrayData.cpp removed 0 -240

NO CONTENT: file was removed

tests/Data/TestVectorSeries.cpp removed 0 -90

NO CONTENT: file was removed

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