HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/SciQLOPCore Commit - r21:5a50815a763f

Quick variable model copied from existing one...

jeandet -

r21:5a50815a763f

parent child

Context file:

r21:5a50815a763f

include/Variable/VariableModel2.h created 644 +62 0

@@ -0,0 +1,62
	1	#ifndef SCIQLOP_VARIABLEMODEL2_H
	2	#define SCIQLOP_VARIABLEMODEL2_H
	3
	4	#include "CoreGlobal.h"
	5
	6	#include <Data/DateTimeRange.h>
	7
	8	#include <QAbstractTableModel>
	9	#include <QLoggingCategory>
	10
	11	#include <Common/MetaTypes.h>
	12	#include <Common/spimpl.h>
	13
	14
	15
	16	class IDataSeries;
	17	class Variable;
	18	class VariableController2;
	19
	20	/**
	21	* @brief The VariableModel class aims to hold the variables that have been created in SciQlop
	22	*/
	23	class SCIQLOP_CORE_EXPORT VariableModel2 : public QAbstractTableModel {
	24	enum VariableRoles { ProgressRole = Qt::UserRole };
	25	Q_OBJECT
	26	std::shared_ptr<VariableController2> _variableController;
	27	public:
	28	explicit VariableModel2(const std::shared_ptr<VariableController2>& variableController, QObject *parent = nullptr);
	29
	30	// /////////////////////////// //
	31	// QAbstractTableModel methods //
	32	// /////////////////////////// //
	33
	34	virtual int columnCount(const QModelIndex &parent = QModelIndex{}) const override;
	35	virtual int rowCount(const QModelIndex &parent = QModelIndex{}) const override;
	36	virtual QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
	37	virtual QVariant headerData(int section, Qt::Orientation orientation,
	38	int role = Qt::DisplayRole) const override;
	39	virtual Qt::ItemFlags flags(const QModelIndex &index) const override;
	40
	41	// ///////////////// //
	42	// Drag&Drop methods //
	43	// ///////////////// //
	44
	45	virtual Qt::DropActions supportedDropActions() const override;
	46	virtual Qt::DropActions supportedDragActions() const override;
	47	virtual QStringList mimeTypes() const override;
	48	virtual QMimeData *mimeData(const QModelIndexList &indexes) const override;
	49	virtual bool canDropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column,
	50	const QModelIndex &parent) const override;
	51	virtual bool dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column,
	52	const QModelIndex &parent) override;
	53
	54
	55	signals:
	56
	57	private slots:
	58	/// Slot called when data of a variable has been updated
	59	void variableUpdated() noexcept;
	60	};
	61
	62	#endif // SCIQLOP_VARIABLEMODEL2_H

src/Variable/VariableModel2.cpp created 644 +250 0

@@ -0,0 +1,250
	1	#include <Variable/Variable.h>
	2	#include <Variable/VariableController2.h>
	3	#include <Variable/VariableModel2.h>
	4
	5	#include <Common/DateUtils.h>
	6	#include <Common/MimeTypesDef.h>
	7	#include <Common/StringUtils.h>
	8
	9	#include <Data/IDataSeries.h>
	10
	11	#include <DataSource/DataSourceController.h>
	12	#include <Time/TimeController.h>
	13
	14	#include <QMimeData>
	15	#include <QSize>
	16	#include <QTimer>
	17	#include <unordered_map>
	18
	19	namespace {
	20
	21	// Column indexes
	22	const auto NAME_COLUMN = 0;
	23	const auto TSTART_COLUMN = 1;
	24	const auto TEND_COLUMN = 2;
	25	const auto NBPOINTS_COLUMN = 3;
	26	const auto UNIT_COLUMN = 4;
	27	const auto MISSION_COLUMN = 5;
	28	const auto PLUGIN_COLUMN = 6;
	29	const auto NB_COLUMNS = 7;
	30
	31	// Column properties
	32	const auto DEFAULT_HEIGHT = 25;
	33	const auto DEFAULT_WIDTH = 100;
	34
	35	struct ColumnProperties {
	36	ColumnProperties(const QString &name = {}, int width = DEFAULT_WIDTH,
	37	int height = DEFAULT_HEIGHT)
	38	: m_Name{name}, m_Width{width}, m_Height{height}
	39	{
	40	}
	41
	42	QString m_Name;
	43	int m_Width;
	44	int m_Height;
	45	};
	46
	47	const auto COLUMN_PROPERTIES = QHash<int, ColumnProperties>{
	48	{NAME_COLUMN, {QObject::tr("Name")}}, {TSTART_COLUMN, {QObject::tr("tStart"), 180}},
	49	{TEND_COLUMN, {QObject::tr("tEnd"), 180}}, {NBPOINTS_COLUMN, {QObject::tr("Nb points")}},
	50	{UNIT_COLUMN, {QObject::tr("Unit")}}, {MISSION_COLUMN, {QObject::tr("Mission")}},
	51	{PLUGIN_COLUMN, {QObject::tr("Plugin")}}};
	52
	53	QString uniqueName(const QString &defaultName,
	54	const std::vector<std::shared_ptr<Variable> > &variables)
	55	{
	56	auto forbiddenNames = std::vector<QString>(variables.size());
	57	std::transform(variables.cbegin(), variables.cend(), forbiddenNames.begin(),
	58	[](const auto &variable) { return variable->name(); });
	59	auto uniqueName = StringUtils::uniqueName(defaultName, forbiddenNames);
	60	Q_ASSERT(!uniqueName.isEmpty());
	61
	62	return uniqueName;
	63	}
	64
	65	} // namespace
	66
	67
	68
	69	VariableModel2::VariableModel2(const std::shared_ptr<VariableController2> &variableController, QObject *parent)
	70	: QAbstractTableModel{parent}, _variableController{variableController}
	71	{
	72	}
	73
	74
	75	int VariableModel2::columnCount(const QModelIndex &parent) const
	76	{
	77	Q_UNUSED(parent);
	78
	79	return NB_COLUMNS;
	80	}
	81
	82	int VariableModel2::rowCount(const QModelIndex &parent) const
	83	{
	84	Q_UNUSED(parent);
	85	return static_cast<int>(_variableController->variables().size());
	86	}
	87
	88	QVariant VariableModel2::data(const QModelIndex &index, int role) const
	89	{
	90	if (!index.isValid()) {
	91	return QVariant{};
	92	}
	93
	94	if (index.row() < 0 \|\| index.row() >= rowCount()) {
	95	return QVariant{};
	96	}
	97
	98	if (role == Qt::DisplayRole) {
	99	if (auto variable = _variableController->variables()[index.row()]) {
	100	switch (index.column()) {
	101	case NAME_COLUMN:
	102	return variable->name();
	103	case TSTART_COLUMN: {
	104	if(auto range = variable->realRange(); range.has_value())
	105	return DateUtils::dateTime(range.value().m_TStart).toString(DATETIME_FORMAT);
	106	return QVariant{};
	107	}
	108	case TEND_COLUMN: {
	109	if(auto range = variable->realRange(); range.has_value())
	110	return DateUtils::dateTime(range.value().m_TEnd).toString(DATETIME_FORMAT);
	111	return QVariant{};
	112	}
	113	case NBPOINTS_COLUMN:
	114	return variable->nbPoints();
	115	case UNIT_COLUMN:
	116	return variable->metadata().value(QStringLiteral("units"));
	117	case MISSION_COLUMN:
	118	return variable->metadata().value(QStringLiteral("mission"));
	119	case PLUGIN_COLUMN:
	120	return variable->metadata().value(QStringLiteral("plugin"));
	121	default:
	122	// No action
	123	break;
	124	}
	125	}
	126	}
	127	else if (role == VariableRoles::ProgressRole) {
	128	return QVariant{};
	129	}
	130
	131	return QVariant{};
	132	}
	133
	134	QVariant VariableModel2::headerData(int section, Qt::Orientation orientation, int role) const
	135	{
	136	if (role != Qt::DisplayRole && role != Qt::SizeHintRole) {
	137	return QVariant{};
	138	}
	139
	140	if (orientation == Qt::Horizontal) {
	141	auto propertiesIt = COLUMN_PROPERTIES.find(section);
	142	if (propertiesIt != COLUMN_PROPERTIES.cend()) {
	143	// Role is either DisplayRole or SizeHintRole
	144	return (role == Qt::DisplayRole)
	145	? QVariant{propertiesIt->m_Name}
	146	: QVariant{QSize{propertiesIt->m_Width, propertiesIt->m_Height}};
	147	}
	148	else {
	149	qWarning(LOG_VariableModel())
	150	<< tr("Can't get header data (unknown column %1)").arg(section);
	151	}
	152	}
	153
	154	return QVariant{};
	155	}
	156
	157	Qt::ItemFlags VariableModel2::flags(const QModelIndex &index) const
	158	{
	159	return QAbstractTableModel::flags(index) \| Qt::ItemIsDragEnabled \| Qt::ItemIsDropEnabled;
	160	}
	161
	162	Qt::DropActions VariableModel2::supportedDropActions() const
	163	{
	164	return Qt::CopyAction \| Qt::MoveAction;
	165	}
	166
	167	Qt::DropActions VariableModel2::supportedDragActions() const
	168	{
	169	return Qt::CopyAction \| Qt::MoveAction;
	170	}
	171
	172	QStringList VariableModel2::mimeTypes() const
	173	{
	174	return {MIME_TYPE_VARIABLE_LIST, MIME_TYPE_TIME_RANGE};
	175	}
	176
	177	QMimeData *VariableModel2::mimeData(const QModelIndexList &indexes) const
	178	{
	179	auto mimeData = new QMimeData;
	180	std::vector<std::shared_ptr<Variable> > variables;
	181
	182	DateTimeRange firstTimeRange;
	183	for (const auto &index : indexes) {
	184	if (index.column() == 0) { // only the first column
	185	auto variable = _variableController->variables()[index.row()];
	186	if (variable.get() && index.isValid()) {
	187
	188	if (variables.size()==0) {
	189	// Gets the range of the first variable
	190	firstTimeRange = std::move(variable->range());
	191	}
	192	variables.push_back(variable);
	193	}
	194	}
	195	}
	196
	197	auto variablesEncodedData = _variableController->mimeData(variables);
	198	mimeData->setData(MIME_TYPE_VARIABLE_LIST, variablesEncodedData);
	199
	200	if (variables.size() == 1) {
	201	// No time range MIME data if multiple variables are dragged
	202	auto timeEncodedData = TimeController::mimeDataForTimeRange(firstTimeRange);
	203	mimeData->setData(MIME_TYPE_TIME_RANGE, timeEncodedData);
	204	}
	205
	206	return mimeData;
	207	}
	208
	209	bool VariableModel2::canDropMimeData(const QMimeData *data, Qt::DropAction action, int row,
	210	int column, const QModelIndex &parent) const
	211	{
	212	// drop of a product
	213	return data->hasFormat(MIME_TYPE_PRODUCT_LIST)
	214	\|\| (data->hasFormat(MIME_TYPE_TIME_RANGE) && parent.isValid()
	215	&& !data->hasFormat(MIME_TYPE_VARIABLE_LIST));
	216	}
	217
	218	bool VariableModel2::dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column,
	219	const QModelIndex &parent)
	220	{
	221	auto dropDone = false;
	222
	223	if (data->hasFormat(MIME_TYPE_PRODUCT_LIST)) {
	224	auto productList
	225	= DataSourceController::productsDataForMimeData(data->data(MIME_TYPE_PRODUCT_LIST));
	226
	227	for (auto metaData : productList) {
	228	//emit requestVariable(metaData.toHash());
	229	//@TODO No idea what this does
	230	}
	231
	232	dropDone = true;
	233	}
	234	else if (data->hasFormat(MIME_TYPE_TIME_RANGE) && parent.isValid()) {
	235	auto variable = _variableController->variables()[parent.row()];
	236	auto range = TimeController::timeRangeForMimeData(data->data(MIME_TYPE_TIME_RANGE));
	237
	238	_variableController->asyncChangeRange(variable, range);
	239
	240	dropDone = true;
	241	}
	242
	243	return dropDone;
	244	}
	245
	246	void VariableModel2::variableUpdated() noexcept
	247	{
	248
	249	}
	250

CMakeLists.txt +2 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/DateTimeRangeHelper.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/VariableModel2.h
                 ./include/Variable/VariableAcquisitionWorker.h
                 ./include/Variable/VariableCacheStrategy.h
                 ./include/Variable/VariableSynchronizationGroup.h
                 ./include/Variable/VariableSynchronizationGroup2.h
                 ./include/Variable/ProportionalCacheStrategy.h
                 ./include/Variable/SingleThresholdCacheStrategy.h
                 ./include/Variable/VariableCacheStrategyFactory.h
                 ./include/Variable/Variable.h
                 ./include/Variable/VariableCacheController.h
                 ./include/Variable/VariableController.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/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/VariableModel2.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_definitions(-DSCIQLOP_CRASH_ON_ERROR)
             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/Variable/VariableController2.h +3 -1

             #include <memory>
             #include <vector>
             #include <set>
             #include <QHash>
             #include <QObject>
             #include <QMutexLocker>
             #include <QUuid>
+            #include <QByteArray>
             #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"
             class VariableController2: public QObject
             {
                 class VariableController2Private;
                 Q_OBJECT
                 spimpl::unique_impl_ptr<VariableController2Private> impl;
             public:
                 explicit VariableController2();
                 std::shared_ptr<Variable> createVariable(const QString &name, const QVariantHash &metadata,
                                                          const std::shared_ptr<IDataProvider>& provider,
                                                          const DateTimeRange &range);
                 std::shared_ptr<Variable> cloneVariable(const std::shared_ptr<Variable>& variable);
                 void deleteVariable(const std::shared_ptr<Variable>& variable);
                 void changeRange(const std::shared_ptr<Variable>& variable, const DateTimeRange& r);
                 void asyncChangeRange(const std::shared_ptr<Variable>& variable, const DateTimeRange& r);
-                const std::set<std::shared_ptr<Variable>> variables();
+                const std::vector<std::shared_ptr<Variable>> variables();
                 bool isReady(const std::shared_ptr<Variable>& variable);
                 void synchronize(const std::shared_ptr<Variable>& var, const std::shared_ptr<Variable>& with);
+                QByteArray mimeData(const std::vector<std::shared_ptr<Variable>> &variables) const;
             signals:
                 void variableAdded(const std::shared_ptr<Variable>&);
                 void variableDeleted(const std::shared_ptr<Variable>&);
             };

src/Variable/VariableController2.cpp +16 -5

             #include <QQueue>
             #include <QThreadPool>
             #include <QRunnable>
             #include <QObject>
+            #include <QDataStream>
             #include "Variable/VariableController2.h"
             #include "Variable/VariableSynchronizationGroup2.h"
             #include <Common/containers.h>
             #include <Common/debug.h>
             #include <Data/DataProviderParameters.h>
             #include <Data/DateTimeRangeHelper.h>
             #include <Data/DateTimeRange.h>
             #include <Variable/VariableCacheStrategyFactory.h>
             #include <Variable/private/VCTransaction.h>
             #include <QCoreApplication>
             class VariableController2::VariableController2Private
             {
                 struct threadSafeVaraiblesMaps
                 {
                     inline void addVariable(const std::shared_ptr<Variable>& 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<Variable>& variable)
                     {
                         QWriteLocker lock{&_lock};
                         _variables.remove(*variable);
                         _providers.remove(*variable);
                         _synchronizationGroups.remove(*variable);
                     }
                     inline void synchronize(const std::shared_ptr<Variable>& variable, const std::optional<std::shared_ptr<Variable>>& 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<Variable> variable(QUuid variable)
                     {
                         QReadLocker lock{&_lock};
                         [[unlikely]]
                         if(!_variables.contains(variable))
                             SCIQLOP_ERROR(threadSafeVaraiblesMaps,"Unknown Variable");
                         return _variables[variable];
                     }
-                    inline const std::set<std::shared_ptr<Variable>> variables()
+                    inline const std::vector<std::shared_ptr<Variable>> variables()
                     {
-                        std::set<std::shared_ptr<Variable>> vars;
+                        std::vector<std::shared_ptr<Variable>> vars;
                         QReadLocker lock{&_lock};
                         for(const auto  &var:_variables)
                         {
-                            vars.insert(var);
+                            vars.push_back(var);
                         }
                         return  vars;
                     }
                     inline std::shared_ptr<IDataProvider> provider(QUuid variable)
                     {
                         QReadLocker lock{&_lock};
                         [[unlikely]]
                         if(!_providers.contains(variable))
                             SCIQLOP_ERROR(threadSafeVaraiblesMaps,"Unknown Variable");
                         return _providers[variable];
                     }
                     inline std::shared_ptr<VariableSynchronizationGroup2> group(QUuid variable)
                     {
                         QReadLocker lock{&_lock};
                         [[unlikely]]
                         if(!_synchronizationGroups.contains(variable))
                             SCIQLOP_ERROR(threadSafeVaraiblesMaps,"Unknown Variable");
                         return _synchronizationGroups[variable];
                     }
                     inline bool has(const std::shared_ptr<Variable>& variable)
                     {
                         QReadLocker lock{&_lock};
                         return _variables.contains(*variable);
                     }
                 private:
                     QMap<QUuid,std::shared_ptr<Variable>> _variables;
                     QMap<QUuid,std::shared_ptr<IDataProvider>> _providers;
                     QMap<QUuid,std::shared_ptr<VariableSynchronizationGroup2>> _synchronizationGroups;
                     QReadWriteLock _lock{QReadWriteLock::Recursive};
                 }_maps;
                 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 _processTransactions()
                 {
                     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);
                                 auto [missingRanges, newCacheRange] = _computeMissingRanges(variable,range);
                                 auto exe = new TransactionExe(variable, provider, missingRanges, range, newCacheRange);
                                 QObject::connect(exe,
                                         &TransactionExe::transactionComplete,
                                         [groupID=groupID,transaction=newTransaction.value(),this]()
                                         {
                                             this->_transactionComplete(groupID, transaction);
                                         }
                                 );
                                 _ThreadPool.start(exe);
                             }
                         }
                     }
                 }
                 std::map<QUuid,DateTimeRange> _computeAllRangesInGroup(const std::shared_ptr<Variable>& 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::pair<std::vector<DateTimeRange>,DateTimeRange> _computeMissingRanges(const std::shared_ptr<Variable>& var, DateTimeRange r)
                 {
                     DateTimeRange newCacheRange;
                     std::vector<DateTimeRange> missingRanges;
                     if(DateTimeRangeHelper::hasnan(var->cacheRange()))
                     {
                         newCacheRange = _cacheStrategy->computeRange(r,r);
                         missingRanges = {newCacheRange};
                     }
                     else
                     {
                         newCacheRange = _cacheStrategy->computeRange(var->cacheRange(),r);
                         missingRanges = newCacheRange - var->cacheRange();
                     }
                     return {missingRanges,newCacheRange};
                 }
                 void _changeRange(QUuid id, DateTimeRange r)
                 {
                     _changeRange(_maps.variable(id) ,r);
                 }
                 void _changeRange(const std::shared_ptr<Variable>& var, DateTimeRange r)
                 {
                     auto provider = _maps.provider(*var);
                     auto [missingRanges, newCacheRange] = _computeMissingRanges(var,r);
                     std::vector<IDataSeries*> data;
                     for(auto range:missingRanges)
                     {
                         data.push_back(provider->getData(DataProviderParameters{{range}, var->metadata()}));
                     }
                     var->updateData(data, r, newCacheRange, true);
                 }
             public:
                 VariableController2Private(QObject* parent=Q_NULLPTR)
                     :_cacheStrategy(VariableCacheStrategyFactory::createCacheStrategy(CacheStrategy::SingleThreshold))
                 {
                     Q_UNUSED(parent);
                     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()
                 {
                     while (this->_ThreadPool.activeThreadCount())
                     {
                         this->_ThreadPool.waitForDone(100);
                     }
                 }
                 std::shared_ptr<Variable> createVariable(const QString &name, const QVariantHash &metadata, std::shared_ptr<IDataProvider> provider)
                 {
                     auto newVar = std::make_shared<Variable>(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<Variable> cloneVariable(const std::shared_ptr<Variable>& 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<Variable>& variable)
                 {
                     return _transactions.active(*_maps.group(*variable));
                 }
                 void deleteVariable(const std::shared_ptr<Variable>& variable)
                 {
                     _maps.removeVariable(variable);
                 }
                 void asyncChangeRange(const std::shared_ptr<Variable>& 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<Variable>& variable, DateTimeRange r)
                 {
                     asyncChangeRange(variable,r);
                     while (hasPendingTransactions(variable))
                     {
                         QCoreApplication::processEvents();
                     }
                 }
                 inline void synchronize(const std::shared_ptr<Variable>& var, const std::shared_ptr<Variable>& with)
                 {
                     _maps.synchronize(var, with);
                 }
-                inline const std::set<std::shared_ptr<Variable>> variables()
+                inline const std::vector<std::shared_ptr<Variable>> variables()
                 {
                     return _maps.variables();
                 }
             };
             VariableController2::VariableController2()
                 :impl{spimpl::make_unique_impl<VariableController2Private>()}
             {}
             std::shared_ptr<Variable> VariableController2::createVariable(const QString &name, const QVariantHash &metadata, const std::shared_ptr<IDataProvider>& provider, const DateTimeRange &range)
             {
                 auto var =  impl->createVariable(name, metadata, provider);
                 emit variableAdded(var);
                 if(!DateTimeRangeHelper::hasnan(range))
                     impl->changeRange(var,range);
                 else
                     SCIQLOP_ERROR(VariableController2, "Creating a variable with default constructed DateTimeRange is an error");
                 return var;
             }
             std::shared_ptr<Variable> VariableController2::cloneVariable(const std::shared_ptr<Variable> &variable)
             {
                 return impl->cloneVariable(variable);
             }
             void VariableController2::deleteVariable(const std::shared_ptr<Variable>& variable)
             {
                 impl->deleteVariable(variable);
                 emit variableDeleted(variable);
             }
             void VariableController2::changeRange(const std::shared_ptr<Variable>& variable, const DateTimeRange& r)
             {
                 impl->changeRange(variable, r);
             }
             void VariableController2::asyncChangeRange(const std::shared_ptr<Variable> &variable, const DateTimeRange &r)
             {
                 impl->asyncChangeRange(variable, r);
             }
-            const std::set<std::shared_ptr<Variable> > VariableController2::variables()
+            const std::vector<std::shared_ptr<Variable> > VariableController2::variables()
             {
                 return impl->variables();
             }
             bool VariableController2::isReady(const std::shared_ptr<Variable> &variable)
             {
                 return impl->hasPendingTransactions(variable);
             }
             void VariableController2::synchronize(const std::shared_ptr<Variable> &var, const std::shared_ptr<Variable> &with)
             {
                 impl->synchronize(var, with);
             }
+            QByteArray VariableController2::mimeData(const std::vector<std::shared_ptr<Variable> > &variables) const
+            {
+                auto encodedData = QByteArray{};
+                QDataStream stream{&encodedData, QIODevice::WriteOnly};
+                for (auto &var : variables) {
+                    stream << var->ID().toByteArray();
+                }
+                return encodedData;
+            }

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