GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r40:59a87dfdf45b

Merge branch 'feature/InitDataSource' into develop

Alexandre Leroux -

r40:59a87dfdf45b

parent child

Context file:

r40:59a87dfdf45b

Collapse all files

app/vera-exclusions/exclusions.txt created 644 +3 0

@@ -0,0 +1,3
	1	# Ignore false positive relative to sqpApp macro
	2	SqpApplication\.h:\d+:.IPSIS_S03.*found: sqpApp
	3	SqpApplication\.h:\d+:.IPSIS_S04_VARIABLE.*found: sqpApp

core/include/DataSource/DataSourceItem.h created 644 +52 0

@@ -0,0 +1,52
	1	#ifndef SCIQLOP_DATASOURCEITEM_H
	2	#define SCIQLOP_DATASOURCEITEM_H
	3
	4	#include <Common/spimpl.h>
	5
	6	#include <QVariant>
	7	#include <QVector>
	8
	9	/**
	10	* @brief The DataSourceItem class aims to represent a structure element of a data source.
	11	* A data source has a tree structure that is made up of a main DataSourceItem object (root)
	12	* containing other DataSourceItem objects (children).
	13	* For each DataSourceItem can be associated a set of data representing it.
	14	*/
	15	class DataSourceItem {
	16	public:
	17	explicit DataSourceItem(QVector<QVariant> data = {});
	18
	19	/**
	20	* Adds a child to the item. The item takes ownership of the child.
	21	* @param child the child to add
	22	*/
	23	void appendChild(std::unique_ptr<DataSourceItem> child) noexcept;
	24
	25	/**
	26	* Returns the item's child associated to an index
	27	* @param childIndex the index to search
	28	* @return a pointer to the child if index is valid, nullptr otherwise
	29	*/
	30	DataSourceItem *child(int childIndex) const noexcept;
	31
	32	int childCount() const noexcept;
	33
	34	/**
	35	* Get the data associated to an index
	36	* @param dataIndex the index to search
	37	* @return the data found if index is valid, default QVariant otherwise
	38	*/
	39	QVariant data(int dataIndex) const noexcept;
	40
	41	/**
	42	* Get the item's parent
	43	* @return a pointer to the parent if it exists, nullptr if the item is a root
	44	*/
	45	DataSourceItem *parentItem() const noexcept;
	46
	47	private:
	48	class DataSourceItemPrivate;
	49	spimpl::unique_impl_ptr<DataSourceItemPrivate> impl;
	50	};
	51
	52	#endif // SCIQLOP_DATASOURCEITEMMODEL_H

core/src/DataSource/DataSourceItem.cpp created 644 +50 0

@@ -0,0 +1,50
	1	#include <DataSource/DataSourceItem.h>
	2
	3	#include <QVector>
	4
	5	struct DataSourceItem::DataSourceItemPrivate {
	6	explicit DataSourceItemPrivate(QVector<QVariant> data)
	7	: m_Parent{nullptr}, m_Children{}, m_Data{std::move(data)}
	8	{
	9	}
	10
	11	DataSourceItem *m_Parent;
	12	std::vector<std::unique_ptr<DataSourceItem> > m_Children;
	13	QVector<QVariant> m_Data;
	14	};
	15
	16	DataSourceItem::DataSourceItem(QVector<QVariant> data)
	17	: impl{spimpl::make_unique_impl<DataSourceItemPrivate>(data)}
	18	{
	19	}
	20
	21	void DataSourceItem::appendChild(std::unique_ptr<DataSourceItem> child) noexcept
	22	{
	23	child->impl->m_Parent = this;
	24	impl->m_Children.push_back(std::move(child));
	25	}
	26
	27	DataSourceItem *DataSourceItem::child(int childIndex) const noexcept
	28	{
	29	if (childIndex < 0 \|\| childIndex >= childCount()) {
	30	return nullptr;
	31	}
	32	else {
	33	return impl->m_Children.at(childIndex).get();
	34	}
	35	}
	36
	37	int DataSourceItem::childCount() const noexcept
	38	{
	39	return impl->m_Children.size();
	40	}
	41
	42	QVariant DataSourceItem::data(int dataIndex) const noexcept
	43	{
	44	return impl->m_Data.value(dataIndex);
	45	}
	46
	47	DataSourceItem *DataSourceItem::parentItem() const noexcept
	48	{
	49	return impl->m_Parent;
	50	}

core/tests/DataSource/TestDataSourceController.cpp created 644 +49 0

@@ -0,0 +1,49
	1	#include <DataSource/DataSourceController.h>
	2	#include <DataSource/DataSourceItem.h>
	3
	4	#include <QObject>
	5	#include <QtTest>
	6
	7	#include <memory>
	8
	9	class TestDataSourceController : public QObject {
	10	Q_OBJECT
	11	private slots:
	12	void testRegisterDataSource();
	13	void testSetDataSourceItem();
	14	};
	15
	16	void TestDataSourceController::testRegisterDataSource()
	17	{
	18	DataSourceController dataSourceController{};
	19
	20	auto uid = dataSourceController.registerDataSource(QStringLiteral("Source1"));
	21	QVERIFY(!uid.isNull());
	22	}
	23
	24	void TestDataSourceController::testSetDataSourceItem()
	25	{
	26	DataSourceController dataSourceController{};
	27
	28	// Spy to test controllers' signals
	29	QSignalSpy signalSpy{&dataSourceController, SIGNAL(dataSourceItemSet(const DataSourceItem &))};
	30
	31	// Create a data source item
	32	auto source1Name = QStringLiteral("Source1");
	33	auto source1Values = QVector<QVariant>{source1Name};
	34	auto source1Item = std::make_unique<DataSourceItem>(std::move(source1Values));
	35
	36	// Add data source item to the controller and check that a signal has been emitted after setting
	37	// data source item in the controller
	38	auto source1Uid = dataSourceController.registerDataSource(source1Name);
	39	dataSourceController.setDataSourceItem(source1Uid, std::move(source1Item));
	40	QCOMPARE(signalSpy.count(), 1);
	41
	42	// Try to a data source item with an unregistered uid and check that no signal has been emitted
	43	auto unregisteredUid = QUuid::createUuid();
	44	dataSourceController.setDataSourceItem(unregisteredUid, std::make_unique<DataSourceItem>());
	45	QCOMPARE(signalSpy.count(), 1);
	46	}
	47
	48	QTEST_MAIN(TestDataSourceController)
	49	#include "TestDataSourceController.moc"

.gitignore +2 0

             build/
             CMakeLists.txt.user
             /.project
+            core/src/Version.cpp
+            core/include/Version.h

app/CMakeLists.txt +1 -1

             ## sciqlop - CMakeLists.txt
             SET(EXECUTABLE_NAME "sciqlop")
             SET(SOURCES_DIR ${CMAKE_CURRENT_SOURCE_DIR}/src/)
             SET(INCLUDE_FOLDER ${CMAKE_CURRENT_SOURCE_DIR}/include)
             SET(UI_FOLDER ${CMAKE_CURRENT_SOURCE_DIR}/src)
             SET(RES_FOLDER ${CMAKE_CURRENT_SOURCE_DIR}/resources)
             #
             # Find Qt modules
             #
             SCIQLOP_FIND_QT(Core Widgets)
             #
             # Find dependent libraries
             # ========================
             find_package(sciqlop-gui)
             SET(LIBRARIES ${SCIQLOP-GUI_LIBRARIES})
             SET(EXTERN_SHARED_LIBRARIES)
             INCLUDE_DIRECTORIES(${SCIQLOP-GUI_INCLUDE_DIR})
             # Add sqpcore to the list of libraries to use
             list(APPEND LIBRARIES ${SQPCORE_LIBRARY_NAME})
             # Include core directory
             include_directories("${CMAKE_CURRENT_SOURCE_DIR}/../core/include")
             # Add dependent shared libraries
             list(APPEND SHARED_LIBRARIES ${SQPCORE_SHARED_LIBRARIES})
             # Retrieve the location of the dynamic library to copy it to the output path
             #get_property(sqpcoreLocation TARGET ${SQPCORE_LIBRARY_NAME} PROPERTY LOCATION)
             list(APPEND SHARED_LIBRARIES_FROM_TARGETS ${sqpcoreLocation})
             #
             # Compile the application
             #
             FILE (GLOB_RECURSE APPLICATION_SOURCES
             	${SOURCES_DIR}/*.c
             	${SOURCES_DIR}/*.cpp
             	${SOURCES_DIR}/*.h)
             # Headers files (.h)
             FILE (GLOB_RECURSE PROJECT_HEADERS ${INCLUDE_FOLDER}/*.h)
             # Ui files
             FILE (GLOB_RECURSE PROJECT_FORMS ${UI_FOLDER}/*.ui)
             # Resources files
             FILE (GLOB_RECURSE PROJECT_RESOURCES ${RES_FOLDER}/*.qrc)
             # Retrieve resources files
             FILE (GLOB_RECURSE APPLICATION_RESOURCES ${RES_FOLDER}/*.qrc)
             QT5_ADD_RESOURCES(RCC_HDRS ${APPLICATION_RESOURCES} )
             QT5_WRAP_UI(UIS_HDRS
              ${PROJECT_FORMS}
             )
             ADD_EXECUTABLE(${EXECUTABLE_NAME} ${APPLICATION_SOURCES} ${RCC_HDRS} ${UIS_HDRS})
             set_property(TARGET ${EXECUTABLE_NAME} PROPERTY CXX_STANDARD 14)
             set_property(TARGET ${EXECUTABLE_NAME} PROPERTY CXX_STANDARD_REQUIRED ON)
             target_link_libraries(${EXECUTABLE_NAME}
                 ${LIBRARIES})
             # Link with Qt5 modules
             qt5_use_modules(${EXECUTABLE_NAME} Core Widgets)
             # Add the files to the list of files to be analyzed
             LIST(APPEND CHECKSTYLE_INPUT_FILES ${APPLICATION_SOURCES})
             SCIQLOP_SET_TO_PARENT_SCOPE(CHECKSTYLE_INPUT_FILES)
             # Vera++ exclusion files
-            #LIST(APPEND CHECKSTYLE_EXCLUSION_FILES ${CMAKE_CURRENT_SOURCE_DIR}/path/to/exclusionFiles.tcl)
+            LIST(APPEND CHECKSTYLE_EXCLUSION_FILES ${CMAKE_CURRENT_SOURCE_DIR}/vera-exclusions/exclusions.txt)
             SCIQLOP_SET_TO_PARENT_SCOPE(CHECKSTYLE_EXCLUSION_FILES)
             #
             # Compile the tests
             #
             IF(BUILD_TESTS)
             	INCLUDE_DIRECTORIES(${SOURCES_DIR})
             	FILE (GLOB_RECURSE TESTS_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/Test*.cpp)
             	FILE (GLOB_RECURSE TESTS_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/Test*.h)
                     SET( TEST_LIBRARIES ${LIBRARIES})
             	FOREACH( testFile ${TESTS_SOURCES} )
             		GET_FILENAME_COMPONENT( testDirectory ${testFile} DIRECTORY )
             		GET_FILENAME_COMPONENT( testName ${testFile} NAME_WE )
             		# Add to the list of sources files all the sources in the same
             		# directory that aren't another test
             		FILE (GLOB currentTestSources
             			${testDirectory}/*.c
             			${testDirectory}/*.cpp
             			${testDirectory}/*.h)
             		LIST (REMOVE_ITEM currentTestSources ${TESTS_SOURCES})
             		LIST (REMOVE_ITEM currentTestSources ${TESTS_HEADERS})
             		ADD_EXECUTABLE(${testName} ${testFile} ${currentTestSources})
             		TARGET_LINK_LIBRARIES( ${testName} ${TEST_LIBRARIES} )
             		qt5_use_modules(${testName} Test)
             		ADD_TEST( NAME ${testName} COMMAND ${testName} )
                             SCIQLOP_COPY_TO_TARGET(RUNTIME ${testName})
             	ENDFOREACH( testFile )
             	LIST(APPEND testFilesToFormat ${TESTS_SOURCES})
             	LIST(APPEND testFilesToFormat ${TESTS_HEADERS})
             	LIST(APPEND FORMATTING_INPUT_FILES ${testFilesToFormat})
                     SCIQLOP_SET_TO_PARENT_SCOPE(FORMATTING_INPUT_FILES)
             ENDIF(BUILD_TESTS)
             #
             # Set the files that must be formatted by clang-format.
             #
             LIST (APPEND FORMATTING_INPUT_FILES ${APPLICATION_SOURCES})
             SCIQLOP_SET_TO_PARENT_SCOPE(FORMATTING_INPUT_FILES)
             #
             # Set the directories that doxygen must browse to generate the
             # documentation.
             #
             # Source directories:
             LIST (APPEND DOXYGEN_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/docs")
             LIST (APPEND DOXYGEN_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/src")
             SCIQLOP_SET_TO_PARENT_SCOPE(DOXYGEN_INPUT_DIRS)
             # Source directories to exclude from the documentation generation
             #LIST (APPEND DOXYGEN_EXCLUDE_PATTERNS "${CMAKE_CURRENT_SOURCE_DIR}/path/to/subdir/*")
             SCIQLOP_SET_TO_PARENT_SCOPE(DOXYGEN_EXCLUDE_PATTERNS)
             #
             # Set the directories with the sources to analyze and propagate the
             # modification to the parent scope
             #
             # Source directories to analyze:
             LIST (APPEND ANALYSIS_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/src")
             LIST (APPEND ANALYSIS_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/tests")
             SCIQLOP_SET_TO_PARENT_SCOPE(ANALYSIS_INPUT_DIRS)
             # Source directories to exclude from the analysis
             #LIST (APPEND ANALYSIS_EXCLUDE_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/path/to/subdir")
             SCIQLOP_SET_TO_PARENT_SCOPE(ANALYSIS_EXCLUDE_DIRS)

app/src/main.cpp +1 -2

             /*------------------------------------------------------------------------------
             -- This file is a part of the QLop Software
             -- Copyright (C) 2015, Plasma Physics Laboratory - CNRS
             --
             -- This program is free software; you can redistribute it and/or modify
             -- it under the terms of the GNU General Public License as published by
             -- the Free Software Foundation; either version 2 of the License, or
             -- (at your option) any later version.
             --
             -- This program is distributed in the hope that it will be useful,
             -- but WITHOUT ANY WARRANTY; without even the implied warranty of
             -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
             -- GNU General Public License for more details.
             --
             -- You should have received a copy of the GNU General Public License
             -- along with this program; if not, write to the Free Software
             -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
             -------------------------------------------------------------------------------*/
             /*-- Author : Alexis Jeandet
             -- Mail : alexis.jeandet@member.fsf.org
             ----------------------------------------------------------------------------*/
             #include "mainwindow.h"
             #include <QProcessEnvironment>
             #include <QThread>
             #include <SqpApplication.h>
             #include <qglobal.h>
             int main(int argc, char *argv[])
             {
-                int ad;
+                SqpApplication a{argc, argv};
-                SqpApplication a(argc, argv);
                 SqpApplication::setOrganizationName("LPP");
                 SqpApplication::setOrganizationDomain("lpp.fr");
                 SqpApplication::setApplicationName("SciQLop");
                 MainWindow w;
                 w.show();
                 return a.exec();
             }

core/CMakeLists.txt +4 -2

             ## core - CMakeLists.txt
             STRING(TOLOWER ${CMAKE_PROJECT_NAME} LIBRARY_PREFFIX)
             SET(SQPCORE_LIBRARY_NAME "${LIBRARY_PREFFIX}_core${DEBUG_SUFFIX}")
             SET(SOURCES_DIR "${CMAKE_CURRENT_SOURCE_DIR}/src/")
             SET(INCLUDES_DIR "${CMAKE_CURRENT_SOURCE_DIR}/include/")
             # Include core directory
             include_directories("${INCLUDES_DIR}")
             # Set a variable to display a warning in the version files.
             SET(SCIQLOP_CMAKE_GENERATION_WARNING "DON'T CHANGE THIS FILE. AUTOGENERATED BY CMAKE.")
             # Generate the version file from the cmake version variables. The version
             # variables are defined in the cmake/sciqlop_version.cmake file.
             CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/resources/Version.h.in"
                     "${INCLUDES_DIR}/Version.h")
             CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/resources/Version.cpp.in"
             	"${SOURCES_DIR}/Version.cpp")
             #
             # Find Qt modules
             #
             SCIQLOP_FIND_QT(Core)
             #
             # Compile the library library
             #
             FILE (GLOB_RECURSE MODULE_SOURCES
                     ${INCLUDES_DIR}/*.h
                     ${SOURCES_DIR}/*.c
                     ${SOURCES_DIR}/*.cpp
             	${SOURCES_DIR}/*.h)
             ADD_LIBRARY(${SQPCORE_LIBRARY_NAME} ${MODULE_SOURCES})
             set_property(TARGET ${SQPCORE_LIBRARY_NAME} PROPERTY CXX_STANDARD 14)
             set_property(TARGET ${SQPCORE_LIBRARY_NAME} PROPERTY CXX_STANDARD_REQUIRED ON)
             TARGET_LINK_LIBRARIES(${SQPCORE_LIBRARY_NAME})
             qt5_use_modules(${SQPCORE_LIBRARY_NAME} Core)
             # From cmake documentation: http://www.cmake.org/cmake/help/v3.0/manual/cmake-buildsystem.7.html
             # Entries in the COMPILE_DEFINITIONS are prefixed with -D or /D and added to the compile line in an unspecified order.
             # The DEFINE_SYMBOL target property is also added as a compile definition as a special convenience case for SHARED and MODULE library targets
             IF(BUILD_SHARED_LIBS)
                     SET_TARGET_PROPERTIES(${SQPCORE_LIBRARY_NAME} PROPERTIES COMPILE_DEFINITIONS "SCIQLOP_EXPORT")
             ELSE()
                     TARGET_COMPILE_DEFINITIONS(${SQPCORE_LIBRARY_NAME} PUBLIC "SCIQLOP_STATIC_LIBRARIES")
             ENDIF()
             # Set the variable to parent scope so that the other projects can copy the
             # dependent shared libraries
             SCIQLOP_SET_TO_PARENT_SCOPE(SQPCORE_LIBRARY_NAME)
             # Copy extern shared libraries to the lib folder
             SCIQLOP_COPY_TO_TARGET(LIBRARY ${SQPCORE_LIBRARY_NAME} ${EXTERN_SHARED_LIBRARIES})
             # Add the files to the list of files to be analyzed
             LIST(APPEND CHECKSTYLE_INPUT_FILES ${MODULE_SOURCES})
             SCIQLOP_SET_TO_PARENT_SCOPE(CHECKSTYLE_INPUT_FILES)
             # Vera++ exclusion files
             LIST(APPEND CHECKSTYLE_EXCLUSION_FILES ${CMAKE_CURRENT_SOURCE_DIR}/vera-exclusions/exclusions.txt)
             SCIQLOP_SET_TO_PARENT_SCOPE(CHECKSTYLE_EXCLUSION_FILES)
             #
             # Compile the tests
             #
             IF(BUILD_TESTS)
             	INCLUDE_DIRECTORIES(${SOURCES_DIR})
             	FILE (GLOB_RECURSE TESTS_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/Test*.cpp)
             	FILE (GLOB_RECURSE TESTS_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/Test*.h)
                     SET( TEST_LIBRARIES ${SQPCORE_LIBRARY_NAME})
             	FOREACH( testFile ${TESTS_SOURCES} )
             		GET_FILENAME_COMPONENT( testDirectory ${testFile} DIRECTORY )
             		GET_FILENAME_COMPONENT( testName ${testFile} NAME_WE )
             		# Add to the list of sources files all the sources in the same
             		# directory that aren't another test
             		FILE (GLOB currentTestSources
             			${testDirectory}/*.c
             			${testDirectory}/*.cpp
             			${testDirectory}/*.h)
-            		LIST (REMOVE_ITEM currentTestSources ${TESTS_SOURCES})
+                    LIST (REMOVE_ITEM currentTestSources ${TESTS_SOURCES})
-            		LIST (REMOVE_ITEM currentTestSources ${TESTS_HEADERS})
+                    # LIST (REMOVE_ITEM currentTestSources ${TESTS_HEADERS})
             		ADD_EXECUTABLE(${testName} ${testFile} ${currentTestSources})
+                    set_property(TARGET ${testName} PROPERTY CXX_STANDARD 14)
+                    set_property(TARGET ${testName} PROPERTY CXX_STANDARD_REQUIRED ON)
             		TARGET_LINK_LIBRARIES( ${testName} ${TEST_LIBRARIES} )
             		qt5_use_modules(${testName} Test)
             		ADD_TEST( NAME ${testName} COMMAND ${testName} )
                             SCIQLOP_COPY_TO_TARGET(RUNTIME ${testName} ${EXTERN_SHARED_LIBRARIES})
             	ENDFOREACH( testFile )
             	LIST(APPEND testFilesToFormat ${TESTS_SOURCES})
             	LIST(APPEND testFilesToFormat ${TESTS_HEADERS})
             	LIST(APPEND FORMATTING_INPUT_FILES ${testFilesToFormat})
                     SCIQLOP_SET_TO_PARENT_SCOPE(FORMATTING_INPUT_FILES)
             ENDIF(BUILD_TESTS)
             #
             # Set the files that must be formatted by clang-format.
             #
             LIST (APPEND FORMATTING_INPUT_FILES ${MODULE_SOURCES})
             SCIQLOP_SET_TO_PARENT_SCOPE(FORMATTING_INPUT_FILES)
             #
             # Set the directories that doxygen must browse to generate the
             # documentation.
             #
             # Source directories:
             LIST (APPEND DOXYGEN_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/docs")
             LIST (APPEND DOXYGEN_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/src")
             SCIQLOP_SET_TO_PARENT_SCOPE(DOXYGEN_INPUT_DIRS)
             # Source directories to exclude from the documentation generation
             #LIST (APPEND DOXYGEN_EXCLUDE_PATTERNS "${CMAKE_CURRENT_SOURCE_DIR}/path/to/subdir/*")
             SCIQLOP_SET_TO_PARENT_SCOPE(DOXYGEN_EXCLUDE_PATTERNS)
             #
             # Set the directories with the sources to analyze and propagate the
             # modification to the parent scope
             #
             # Source directories to analyze:
             LIST (APPEND ANALYSIS_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/src")
             LIST (APPEND ANALYSIS_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/tests")
             SCIQLOP_SET_TO_PARENT_SCOPE(ANALYSIS_INPUT_DIRS)
             # Source directories to exclude from the analysis
             #LIST (APPEND ANALYSIS_EXCLUDE_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/path/to/subdir")
             SCIQLOP_SET_TO_PARENT_SCOPE(ANALYSIS_EXCLUDE_DIRS)

core/include/Common/spimpl.h +14 -12

             /*
                 ====================================================================
                 A Smart Pointer to IMPLementation (i.e. Smart PIMPL or just SPIMPL).
                 ====================================================================
                 Version: 1.1
                 Latest version:
                     https://github.com/oliora/samples/blob/master/spimpl.h
                 Rationale and description:
                     http://oliora.github.io/2015/12/29/pimpl-and-rule-of-zero.html
                 Copyright (c) 2015 Andrey Upadyshev (oliora@gmail.com)
                 Distributed under the Boost Software License, Version 1.0.
                 See http://www.boost.org/LICENSE_1_0.txt
                 Changes history
                 ---------------
                 v1.1:
                     - auto_ptr support is disabled by default for C++17 compatibility
                 v1.0:
                     - Released
              */
             #ifndef SPIMPL_H_
             #define SPIMPL_H_
             #include <cassert>
             #include <memory>
             #include <type_traits>
             #if defined _MSC_VER && _MSC_VER < 1900 // MS Visual Studio before VS2015
             #define SPIMPL_NO_CPP11_NOEXCEPT
             #define SPIMPL_NO_CPP11_CONSTEXPR
             #define SPIMPL_NO_CPP11_DEFAULT_MOVE_SPEC_FUNC
             #endif
             #if !defined SPIMPL_NO_CPP11_NOEXCEPT
             #define SPIMPL_NOEXCEPT noexcept
             #else
             #define SPIMPL_NOEXCEPT
             #endif
             #if !defined SPIMPL_NO_CPP11_CONSTEXPR
             #define SPIMPL_CONSTEXPR constexpr
             #else
             #define SPIMPL_CONSTEXPR
             #endif
             // define SPIMPL_HAS_AUTO_PTR to enable constructor and assignment operator that accept
             // std::auto_ptr
             // TODO: auto detect std::auto_ptr support
             namespace spimpl {
             namespace details {
             template <class T>
             T *default_copy(T *src)
             {
                 static_assert(sizeof(T) > 0, "default_copy cannot copy incomplete type");
                 static_assert(!std::is_void<T>::value, "default_copy cannot copy incomplete type");
                 return new T(*src);
             }
             template <class T>
             void default_delete(T *p) SPIMPL_NOEXCEPT
             {
                 static_assert(sizeof(T) > 0, "default_delete cannot delete incomplete type");
                 static_assert(!std::is_void<T>::value, "default_delete cannot delete incomplete type");
                 delete p;
             }
             template <class T>
             struct default_deleter {
                 using type = void (*)(T *);
             };
             template <class T>
             using default_deleter_t = typename default_deleter<T>::type;
             template <class T>
             struct default_copier {
                 using type = T *(*)(T *);
             };
             template <class T>
             using default_copier_t = typename default_copier<T>::type;
             template <class T, class D, class C>
             struct is_default_manageable
-                : public std::integral_constant<bool, std::is_same<D, default_deleter_t<T> >::value
+                : public std::integral_constant<bool,
-                                                          && std::is_same<C, default_copier_t<T> >::value> {
+                                                std::is_same<D, default_deleter_t<T> >::value
+                                                    && std::is_same<C, default_copier_t<T> >::value> {
             };
             }
             template <class T, class Deleter = details::default_deleter_t<T>,
                       class Copier = details::default_copier_t<T> >
             class impl_ptr {
             private:
                 static_assert(!std::is_array<T>::value,
                               "impl_ptr specialization for arrays is not implemented");
                 struct dummy_t_ {
                     int dummy__;
                 };
             public:
                 using pointer = T *;
                 using element_type = T;
                 using copier_type = typename std::decay<Copier>::type;
                 using deleter_type = typename std::decay<Deleter>::type;
                 using unique_ptr_type = std::unique_ptr<T, deleter_type>;
                 using is_default_manageable = details::is_default_manageable<T, deleter_type, copier_type>;
                 SPIMPL_CONSTEXPR impl_ptr() SPIMPL_NOEXCEPT : ptr_(nullptr, deleter_type{}),
                                                               copier_(copier_type{})
                 {
                 }
                 SPIMPL_CONSTEXPR impl_ptr(std::nullptr_t) SPIMPL_NOEXCEPT : impl_ptr() {}
                 template <class D, class C>
                 impl_ptr(pointer p, D &&d, C &&c,
                          typename std::enable_if<std::is_convertible<D, deleter_type>::value
                                                      && std::is_convertible<C, copier_type>::value,
                                                  dummy_t_>::type
                          = dummy_t_()) SPIMPL_NOEXCEPT : ptr_(std::move(p), std::forward<D>(d)),
                                                          copier_(std::forward<C>(c))
                 {
                 }
                 template <class U>
-                impl_ptr(U *u, typename std::enable_if<std::is_convertible<U *, pointer>::value
+                impl_ptr(U *u,
-                                                           && is_default_manageable::value,
+                         typename std::enable_if<std::is_convertible<U *, pointer>::value
-                                                       dummy_t_>::type
+                                                     && is_default_manageable::value,
-                               = dummy_t_()) SPIMPL_NOEXCEPT
+                                                 dummy_t_>::type
+                         = dummy_t_()) SPIMPL_NOEXCEPT
                     : impl_ptr(u, &details::default_delete<T>, &details::default_copy<T>)
                 {
                 }
                 impl_ptr(const impl_ptr &r) : impl_ptr(r.clone()) {}
             #ifndef SPIMPL_NO_CPP11_DEFAULT_MOVE_SPEC_FUNC
                 impl_ptr(impl_ptr &&r) SPIMPL_NOEXCEPT = default;
             #else
                 impl_ptr(impl_ptr &&r) SPIMPL_NOEXCEPT : ptr_(std::move(r.ptr_)), copier_(std::move(r.copier_))
                 {
                 }
             #endif
             #ifdef SPIMPL_HAS_AUTO_PTR
                 template <class U>
-                impl_ptr(std::auto_ptr<U> &&u, typename std::enable_if<std::is_convertible<U *, pointer>::value
+                impl_ptr(std::auto_ptr<U> &&u,
-                                                                           && is_default_manageable::value,
+                         typename std::enable_if<std::is_convertible<U *, pointer>::value
-                                                                       dummy_t_>::type
+                                                     && is_default_manageable::value,
-                                               = dummy_t_()) SPIMPL_NOEXCEPT
+                                                 dummy_t_>::type
-                    : ptr_(u.release(), &details::default_delete<T>),
+                         = dummy_t_()) SPIMPL_NOEXCEPT : ptr_(u.release(), &details::default_delete<T>),
-                      copier_(&details::default_copy<T>)
+                                                         copier_(&details::default_copy<T>)
                 {
                 }
             #endif
                 template <class U>
                 impl_ptr(std::unique_ptr<U> &&u,
                          typename std::enable_if<std::is_convertible<U *, pointer>::value
                                                      && is_default_manageable::value,
                                                  dummy_t_>::type
                          = dummy_t_()) SPIMPL_NOEXCEPT : ptr_(u.release(), &details::default_delete<T>),
                                                          copier_(&details::default_copy<T>)
                 {
                 }
                 template <class U, class D, class C>
                 impl_ptr(std::unique_ptr<U, D> &&u, C &&c,
                          typename std::enable_if<std::is_convertible<U *, pointer>::value
                                                      && std::is_convertible<D, deleter_type>::value
                                                      && std::is_convertible<C, copier_type>::value,
                                                  dummy_t_>::type
                          = dummy_t_()) SPIMPL_NOEXCEPT : ptr_(std::move(u)),
                                                          copier_(std::forward<C>(c))
                 {
                 }
                 template <class U, class D, class C>
                 impl_ptr(impl_ptr<U, D, C> &&u,
                          typename std::enable_if<std::is_convertible<U *, pointer>::value
                                                      && std::is_convertible<D, deleter_type>::value
                                                      && std::is_convertible<C, copier_type>::value,
                                                  dummy_t_>::type
                          = dummy_t_()) SPIMPL_NOEXCEPT : ptr_(std::move(u.ptr_)),
                                                          copier_(std::move(u.copier_))
                 {
                 }
                 impl_ptr &operator=(const impl_ptr &r)
                 {
                     if (this == &r)
                         return *this;
                     return operator=(r.clone());
                 }
             #ifndef SPIMPL_NO_CPP11_DEFAULT_MOVE_SPEC_FUNC
                 impl_ptr &operator=(impl_ptr &&r) SPIMPL_NOEXCEPT = default;
             #else
                 impl_ptr &operator=(impl_ptr &&r) SPIMPL_NOEXCEPT
                 {
                     ptr_ = std::move(r.ptr_);
                     copier_ = std::move(r.copier_);
                     return *this;
                 }
             #endif
                 template <class U, class D, class C>
                 typename std::enable_if<std::is_convertible<U *, pointer>::value
                                             && std::is_convertible<D, deleter_type>::value
                                             && std::is_convertible<C, copier_type>::value,
                                         impl_ptr &>::type
                 operator=(impl_ptr<U, D, C> &&u) SPIMPL_NOEXCEPT
                 {
                     ptr_ = std::move(u.ptr_);
                     copier_ = std::move(u.copier_);
                     return *this;
                 }
                 template <class U, class D, class C>
                 typename std::enable_if<std::is_convertible<U *, pointer>::value
                                             && std::is_convertible<D, deleter_type>::value
                                             && std::is_convertible<C, copier_type>::value,
                                         impl_ptr &>::type
                 operator=(const impl_ptr<U, D, C> &u)
                 {
                     return operator=(u.clone());
                 }
             //
             #ifdef SPIMPL_HAS_AUTO_PTR
                 template <class U>
                 typename std::enable_if<std::is_convertible<U *, pointer>::value
                                             && is_default_manageable::value,
                                         impl_ptr &>::type
                 operator=(std::auto_ptr<U> &&u) SPIMPL_NOEXCEPT
                 {
                     return operator=(impl_ptr(std::move(u)));
                 }
             #endif
                 template <class U>
                 typename std::enable_if<std::is_convertible<U *, pointer>::value
                                             && is_default_manageable::value,
                                         impl_ptr &>::type
                 operator=(std::unique_ptr<U> &&u) SPIMPL_NOEXCEPT
                 {
                     return operator=(impl_ptr(std::move(u)));
                 }
                 impl_ptr clone() const
                 {
                     return impl_ptr(ptr_ ? copier_(ptr_.get()) : nullptr, ptr_.get_deleter(), copier_);
                 }
                 typename std::remove_reference<T>::type &operator*() const { return *ptr_; }
                 pointer operator->() const SPIMPL_NOEXCEPT { return get(); }
                 pointer get() const SPIMPL_NOEXCEPT { return ptr_.get(); }
                 void swap(impl_ptr &u) SPIMPL_NOEXCEPT
                 {
                     using std::swap;
                     ptr_.swap(u.ptr_);
                     swap(copier_, u.copier_);
                 }
                 pointer release() SPIMPL_NOEXCEPT { return ptr_.release(); }
                 unique_ptr_type release_unique() SPIMPL_NOEXCEPT { return std::move(ptr_); }
                 explicit operator bool() const SPIMPL_NOEXCEPT { return static_cast<bool>(ptr_); }
                 typename std::remove_reference<deleter_type>::type &get_deleter() SPIMPL_NOEXCEPT
                 {
                     return ptr_.get_deleter();
                 }
                 const typename std::remove_reference<deleter_type>::type &get_deleter() const SPIMPL_NOEXCEPT
                 {
                     return ptr_.get_deleter();
                 }
                 typename std::remove_reference<copier_type>::type &get_copier() SPIMPL_NOEXCEPT
                 {
                     return copier_;
                 }
                 const typename std::remove_reference<copier_type>::type &get_copier() const SPIMPL_NOEXCEPT
                 {
                     return copier_;
                 }
             private:
                 unique_ptr_type ptr_;
                 copier_type copier_;
             };
             template <class T, class D, class C>
             inline void swap(impl_ptr<T, D, C> &l, impl_ptr<T, D, C> &r) SPIMPL_NOEXCEPT
             {
                 l.swap(r);
             }
             template <class T1, class D1, class C1, class T2, class D2, class C2>
             inline bool operator==(const impl_ptr<T1, D1, C1> &l, const impl_ptr<T2, D2, C2> &r)
             {
                 return l.get() == r.get();
             }
             template <class T1, class D1, class C1, class T2, class D2, class C2>
             inline bool operator!=(const impl_ptr<T1, D1, C1> &l, const impl_ptr<T2, D2, C2> &r)
             {
                 return !(l == r);
             }
             template <class T1, class D1, class C1, class T2, class D2, class C2>
             inline bool operator<(const impl_ptr<T1, D1, C1> &l, const impl_ptr<T2, D2, C2> &r)
             {
                 using P1 = typename impl_ptr<T1, D1, C1>::pointer;
                 using P2 = typename impl_ptr<T2, D2, C2>::pointer;
                 using CT = typename std::common_type<P1, P2>::type;
                 return std::less<CT>()(l.get(), r.get());
             }
             template <class T1, class D1, class C1, class T2, class D2, class C2>
             inline bool operator>(const impl_ptr<T1, D1, C1> &l, const impl_ptr<T2, D2, C2> &r)
             {
                 return r < l;
             }
             template <class T1, class D1, class C1, class T2, class D2, class C2>
             inline bool operator<=(const impl_ptr<T1, D1, C1> &l, const impl_ptr<T2, D2, C2> &r)
             {
                 return !(r < l);
             }
             template <class T1, class D1, class C1, class T2, class D2, class C2>
             inline bool operator>=(const impl_ptr<T1, D1, C1> &l, const impl_ptr<T2, D2, C2> &r)
             {
                 return !(l < r);
             }
             template <class T, class D, class C>
             inline bool operator==(const impl_ptr<T, D, C> &p, std::nullptr_t) SPIMPL_NOEXCEPT
             {
                 return !p;
             }
             template <class T, class D, class C>
             inline bool operator==(std::nullptr_t, const impl_ptr<T, D, C> &p) SPIMPL_NOEXCEPT
             {
                 return !p;
             }
             template <class T, class D, class C>
             inline bool operator!=(const impl_ptr<T, D, C> &p, std::nullptr_t) SPIMPL_NOEXCEPT
             {
                 return static_cast<bool>(p);
             }
             template <class T, class D, class C>
             inline bool operator!=(std::nullptr_t, const impl_ptr<T, D, C> &p) SPIMPL_NOEXCEPT
             {
                 return static_cast<bool>(p);
             }
             template <class T, class D, class C>
             inline bool operator<(const impl_ptr<T, D, C> &l, std::nullptr_t)
             {
                 using P = typename impl_ptr<T, D, C>::pointer;
                 return std::less<P>()(l.get(), nullptr);
             }
             template <class T, class D, class C>
             inline bool operator<(std::nullptr_t, const impl_ptr<T, D, C> &p)
             {
                 using P = typename impl_ptr<T, D, C>::pointer;
                 return std::less<P>()(nullptr, p.get());
             }
             template <class T, class D, class C>
             inline bool operator>(const impl_ptr<T, D, C> &p, std::nullptr_t)
             {
                 return nullptr < p;
             }
             template <class T, class D, class C>
             inline bool operator>(std::nullptr_t, const impl_ptr<T, D, C> &p)
             {
                 return p < nullptr;
             }
             template <class T, class D, class C>
             inline bool operator<=(const impl_ptr<T, D, C> &p, std::nullptr_t)
             {
                 return !(nullptr < p);
             }
             template <class T, class D, class C>
             inline bool operator<=(std::nullptr_t, const impl_ptr<T, D, C> &p)
             {
                 return !(p < nullptr);
             }
             template <class T, class D, class C>
             inline bool operator>=(const impl_ptr<T, D, C> &p, std::nullptr_t)
             {
                 return !(p < nullptr);
             }
             template <class T, class D, class C>
             inline bool operator>=(std::nullptr_t, const impl_ptr<T, D, C> &p)
             {
                 return !(nullptr < p);
             }
             template <class T, class... Args>
             inline impl_ptr<T> make_impl(Args &&... args)
             {
                 return impl_ptr<T>(new T(std::forward<Args>(args)...), &details::default_delete<T>,
                                    &details::default_copy<T>);
             }
             // Helpers to manage unique impl, stored in std::unique_ptr
             template <class T, class Deleter = void (*)(T *)>
             using unique_impl_ptr = std::unique_ptr<T, Deleter>;
             template <class T, class... Args>
             inline unique_impl_ptr<T> make_unique_impl(Args &&... args)
             {
                 static_assert(!std::is_array<T>::value, "unique_impl_ptr does not support arrays");
                 return unique_impl_ptr<T>(new T(std::forward<Args>(args)...), &details::default_delete<T>);
             }
             }
             namespace std {
             template <class T, class D, class C>
             struct hash<spimpl::impl_ptr<T, D, C> > {
                 using argument_type = spimpl::impl_ptr<T, D, C>;
                 using result_type = size_t;
                 result_type operator()(const argument_type &p) const SPIMPL_NOEXCEPT
                 {
                     return hash<typename argument_type::pointer>()(p.get());
                 }
             };
             }
             #endif // SPIMPL_H_

core/include/DataSource/DataSourceController.h +30 -8

             #ifndef SCIQLOP_DATASOURCECONTROLLER_H
             #define SCIQLOP_DATASOURCECONTROLLER_H
-            #include "DataSourceController.h"
             #include <QLoggingCategory>
             #include <QObject>
+            #include <QUuid>
             #include <Common/spimpl.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_DataSourceController)
+            class DataSourceItem;
             /**
-             * @brief The DataSourceController class aims to make the link between SciQlop
+             * @brief The DataSourceController class aims to make the link between SciQlop and its plugins. This
-             * and its plugins. This is the intermediate class that SciQlop have to use
+             * is the intermediate class that SciQlop has to use in the way to connect a data source. Please
-             * in the way to connect a data source. Please first use load method to intialize
+             * first use register method to initialize a plugin specified by its metadata name (JSON plugin
-             * a plugin specified by its metadata name (JSON plugin source) then others specifics
+             * source) then others specifics method will be able to access it. You can load a data source driver
-             * method will ba able to access it.
+             * plugin then create a data source.
-             * You can load a data source driver plugin then create a data source.
              */
             class DataSourceController : public QObject {
                 Q_OBJECT
             public:
                 explicit DataSourceController(QObject *parent = 0);
                 virtual ~DataSourceController();
+                /**
+                 * Registers a data source. The method delivers a unique id that can be used afterwards to
+                 * access to the data source properties (structure, connection parameters, data provider, etc.)
+                 * @param dataSourceName the name of the data source
+                 * @return the unique id with which the data source has been registered
+                 */
+                QUuid registerDataSource(const QString &dataSourceName) noexcept;
+                /**
+                 * Sets the structure of a data source. The controller takes ownership of the structure.
+                 * @param dataSourceUid the unique id with which the data source has been registered into the
+                 * controller. If it is invalid, the method has no effect.
+                 * @param dataSourceItem the structure of the data source
+                 * @sa registerDataSource()
+                 */
+                void setDataSourceItem(const QUuid &dataSourceUid,
+                                       std::unique_ptr<DataSourceItem> dataSourceItem) noexcept;
             public slots:
                 /// Manage init/end of the controller
                 void initialize();
                 void finalize();
+            signals:
+                /// Signal emitted when a structure has been set for a data source
+                void dataSourceItemSet(const DataSourceItem &dataSourceItem);
             private:
                 void waitForFinish();
                 class DataSourceControllerPrivate;
                 spimpl::unique_impl_ptr<DataSourceControllerPrivate> impl;
             };
             #endif // SCIQLOP_DATASOURCECONTROLLER_H

core/src/DataSource/DataSourceController.cpp +41 -11

-            #include "DataSource/DataSourceController.h"
+            #include <DataSource/DataSourceController.h>
+            #include <DataSource/DataSourceItem.h>
             #include <QMutex>
             #include <QThread>
             #include <QDir>
             #include <QStandardPaths>
             Q_LOGGING_CATEGORY(LOG_DataSourceController, "DataSourceController")
             class DataSourceController::DataSourceControllerPrivate {
             public:
-                DataSourceControllerPrivate() {}
                 QMutex m_WorkingMutex;
+                /// Data sources registered
+                QHash<QUuid, QString> m_DataSources;
+                /// Data sources structures
+                std::map<QUuid, std::unique_ptr<DataSourceItem> > m_DataSourceItems;
             };
             DataSourceController::DataSourceController(QObject *parent)
                     : impl{spimpl::make_unique_impl<DataSourceControllerPrivate>()}
             {
-                qCDebug(LOG_DataSourceController()) << tr("Construction du DataSourceController")
+                qCDebug(LOG_DataSourceController())
-                                                    << QThread::currentThread();
+                    << tr("DataSourceController construction") << QThread::currentThread();
             }
             DataSourceController::~DataSourceController()
             {
-                qCDebug(LOG_DataSourceController()) << tr("Desctruction du DataSourceController")
+                qCDebug(LOG_DataSourceController())
-                                                    << QThread::currentThread();
+                    << tr("DataSourceController destruction") << QThread::currentThread();
                 this->waitForFinish();
             }
+            QUuid DataSourceController::registerDataSource(const QString &dataSourceName) noexcept
+            {
+                auto dataSourceUid = QUuid::createUuid();
+                impl->m_DataSources.insert(dataSourceUid, dataSourceName);
+                return dataSourceUid;
+            }
+            void DataSourceController::setDataSourceItem(
+                const QUuid &dataSourceUid, std::unique_ptr<DataSourceItem> dataSourceItem) noexcept
+            {
+                if (impl->m_DataSources.contains(dataSourceUid)) {
+                    impl->m_DataSourceItems.insert(std::make_pair(dataSourceUid, std::move(dataSourceItem)));
+                    // Retrieves the data source item to emit the signal with it
+                    auto it = impl->m_DataSourceItems.find(dataSourceUid);
+                    if (it != impl->m_DataSourceItems.end()) {
+                        emit dataSourceItemSet(*it->second);
+                    }
+                }
+                else {
+                    qCWarning(LOG_DataSourceController()) << tr("Can't set data source item for uid %1 : no "
+                                                                "data source has been registered with the uid")
+                                                                 .arg(dataSourceUid.toString());
+                }
+            }
             void DataSourceController::initialize()
             {
-                qCDebug(LOG_DataSourceController()) << tr("initialize du DataSourceController")
+                qCDebug(LOG_DataSourceController())
-                                                    << QThread::currentThread();
+                    << tr("DataSourceController init") << QThread::currentThread();
                 impl->m_WorkingMutex.lock();
-                qCDebug(LOG_DataSourceController()) << tr("initialize du DataSourceController END");
+                qCDebug(LOG_DataSourceController()) << tr("DataSourceController init END");
             }
             void DataSourceController::finalize()
             {
                 impl->m_WorkingMutex.unlock();
             }
             void DataSourceController::waitForFinish()
             {
-                QMutexLocker locker(&impl->m_WorkingMutex);
+                QMutexLocker locker{&impl->m_WorkingMutex};
             }

formatting/vera-exclusions/exclusions.txt +4 0

             # On ignore toutes les règles vera++ pour le fichier spimpl
             .*IPSIS_S04_METHOD.*found: Q_DECLARE_LOGGING_CATEGORY.*
             .*IPSIS_S04_VARIABLE.*found: impl.*
+            # Ignore false positive relative to 'noexcept' keyword
+            .*IPSIS_S04_VARIABLE.*found: noexcept
+            .*IPSIS_S06.*found: noexcept

gui/CMakeLists.txt +3 -1

             ## gui - CMakeLists.txt
             STRING(TOLOWER ${CMAKE_PROJECT_NAME} LIBRARY_PREFFIX)
             SET(SQPGUI_LIBRARY_NAME "${LIBRARY_PREFFIX}_gui${DEBUG_SUFFIX}")
             SET(SOURCES_DIR "${CMAKE_CURRENT_SOURCE_DIR}/src")
             SET(INCLUDES_DIR "${CMAKE_CURRENT_SOURCE_DIR}/include")
             SET(UI_FOLDER "${CMAKE_CURRENT_SOURCE_DIR}/ui")
             SET(RES_FOLDER "${CMAKE_CURRENT_SOURCE_DIR}/resources")
             # Include gui directory
             include_directories("${INCLUDES_DIR}")
             include_directories("${CMAKE_CURRENT_BINARY_DIR}")
             # Set a variable to display a warning in the version files.
             SET(SCIQLOP_CMAKE_GENERATION_WARNING "DON'T CHANGE THIS FILE. AUTOGENERATED BY CMAKE.")
             #
             # Find Qt modules
             #
             SCIQLOP_FIND_QT(Core Widgets)
             #
             # Find dependent libraries
             # ========================
             find_package(sciqlop-core)
             SET(LIBRARIES ${SCIQLOP-CORE_LIBRARIES})
             INCLUDE_DIRECTORIES(${SCIQLOP-CORE_INCLUDE_DIR})
             # Add sqpcore to the list of libraries to use
             list(APPEND LIBRARIES ${SQPCORE_LIBRARY_NAME})
             # Add dependent shared libraries
             list(APPEND SHARED_LIBRARIES ${SQPCORE_SHARED_LIBRARIES})
             # Ui files
             FILE (GLOB_RECURSE PROJECT_FORMS ${UI_FOLDER}/*.ui)
             # Resources files
             FILE (GLOB_RECURSE PROJECT_RESOURCES ${RES_FOLDER}/*.qrc)
             #
             # Compile the library library
             #
             FILE (GLOB_RECURSE MODULE_SOURCES
                     ${INCLUDES_DIR}/*.h
                     ${SOURCES_DIR}/*.c
                     ${SOURCES_DIR}/*.cpp
                     ${SOURCES_DIR}/*.h
                     ${PROJECT_FORMS})
             QT5_ADD_RESOURCES(RCC_HDRS
               ${PROJECT_RESOURCES}
             )
             QT5_WRAP_UI(UIS_HDRS
              ${PROJECT_FORMS}
             )
             ADD_LIBRARY(${SQPGUI_LIBRARY_NAME} ${MODULE_SOURCES} ${UIS_HDRS} ${RCC_HDRS})
             set_property(TARGET ${SQPGUI_LIBRARY_NAME} PROPERTY CXX_STANDARD 14)
             set_property(TARGET ${SQPGUI_LIBRARY_NAME} PROPERTY CXX_STANDARD_REQUIRED ON)
             TARGET_LINK_LIBRARIES(${SQPGUI_LIBRARY_NAME} ${LIBRARIES})
             qt5_use_modules(${SQPGUI_LIBRARY_NAME} Core Widgets)
             # From cmake documentation: http://www.cmake.org/cmake/help/v3.0/manual/cmake-buildsystem.7.html
             # Entries in the COMPILE_DEFINITIONS are prefixed with -D or /D and added to the compile line in an unspecified order.
             # The DEFINE_SYMBOL target property is also added as a compile definition as a special convenience case for SHARED and MODULE library targets
             IF(BUILD_SHARED_LIBS)
                     SET_TARGET_PROPERTIES(${SQPGUI_LIBRARY_NAME} PROPERTIES COMPILE_DEFINITIONS "SCIQLOP_EXPORT")
             ELSE()
                     TARGET_COMPILE_DEFINITIONS(${SQPGUI_LIBRARY_NAME} PUBLIC "SCIQLOP_STATIC_LIBRARIES")
             ENDIF()
             # Set the variable to parent scope so that the other projects can copy the
             # dependent shared libraries
             SCIQLOP_SET_TO_PARENT_SCOPE(SQPGUI_LIBRARY_NAME)
             # Copy extern shared libraries to the lib folder
             SCIQLOP_COPY_TO_TARGET(LIBRARY ${SQPGUI_LIBRARY_NAME})
             # Add the files to the list of files to be analyzed
             LIST(APPEND CHECKSTYLE_INPUT_FILES ${MODULE_SOURCES})
             SCIQLOP_SET_TO_PARENT_SCOPE(CHECKSTYLE_INPUT_FILES)
             # Vera++ exclusion files
             #LIST(APPEND CHECKSTYLE_EXCLUSION_FILES ${CMAKE_CURRENT_SOURCE_DIR}/path/to/exclusionFiles.tcl)
             SCIQLOP_SET_TO_PARENT_SCOPE(CHECKSTYLE_EXCLUSION_FILES)
             #
             # Compile the tests
             #
             IF(BUILD_TESTS)
                     INCLUDE_DIRECTORIES(${SOURCES_DIR})
                     FILE (GLOB_RECURSE TESTS_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/Test*.cpp)
                     FILE (GLOB_RECURSE TESTS_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/Test*.h)
                     SET( TEST_LIBRARIES ${SQPGUI_LIBRARY_NAME})
                     FOREACH( testFile ${TESTS_SOURCES} )
                             GET_FILENAME_COMPONENT( testDirectory ${testFile} DIRECTORY )
                             GET_FILENAME_COMPONENT( testName ${testFile} NAME_WE )
                             # Add to the list of sources files all the sources in the same
                             # directory that aren't another test
                             FILE (GLOB currentTestSources
                                     ${testDirectory}/*.c
                                     ${testDirectory}/*.cpp
                                     ${testDirectory}/*.h)
                             LIST (REMOVE_ITEM currentTestSources ${TESTS_SOURCES})
-                            LIST (REMOVE_ITEM currentTestSources ${TESTS_HEADERS})
+                            # LIST (REMOVE_ITEM currentTestSources ${TESTS_HEADERS})
                             ADD_EXECUTABLE(${testName} ${testFile} ${currentTestSources})
+                            set_property(TARGET ${testName} PROPERTY CXX_STANDARD 14)
+                            set_property(TARGET ${testName} PROPERTY CXX_STANDARD_REQUIRED ON)
                             TARGET_LINK_LIBRARIES( ${testName} ${TEST_LIBRARIES} )
                             qt5_use_modules(${testName} Test)
                             ADD_TEST( NAME ${testName} COMMAND ${testName} )
                             SCIQLOP_COPY_TO_TARGET(RUNTIME ${testName} ${EXTERN_SHARED_LIBRARIES})
                     ENDFOREACH( testFile )
                     LIST(APPEND testFilesToFormat ${TESTS_SOURCES})
                     LIST(APPEND testFilesToFormat ${TESTS_HEADERS})
                     LIST(APPEND FORMATTING_INPUT_FILES ${testFilesToFormat})
                     SCIQLOP_SET_TO_PARENT_SCOPE(FORMATTING_INPUT_FILES)
             ENDIF(BUILD_TESTS)
             #
             # Set the files that must be formatted by clang-format.
             #
             LIST (APPEND FORMATTING_INPUT_FILES ${MODULE_SOURCES})
             SCIQLOP_SET_TO_PARENT_SCOPE(FORMATTING_INPUT_FILES)
             #
             # Set the directories that doxygen must browse to generate the
             # documentation.
             #
             # Source directories:
             LIST (APPEND DOXYGEN_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/docs")
             LIST (APPEND DOXYGEN_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/src")
             SCIQLOP_SET_TO_PARENT_SCOPE(DOXYGEN_INPUT_DIRS)
             # Source directories to exclude from the documentation generation
             #LIST (APPEND DOXYGEN_EXCLUDE_PATTERNS "${CMAKE_CURRENT_SOURCE_DIR}/path/to/subdir/*")
             SCIQLOP_SET_TO_PARENT_SCOPE(DOXYGEN_EXCLUDE_PATTERNS)
             #
             # Set the directories with the sources to analyze and propagate the
             # modification to the parent scope
             #
             # Source directories to analyze:
             LIST (APPEND ANALYSIS_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/src")
             LIST (APPEND ANALYSIS_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/tests")
             SCIQLOP_SET_TO_PARENT_SCOPE(ANALYSIS_INPUT_DIRS)
             # Source directories to exclude from the analysis
             #LIST (APPEND ANALYSIS_EXCLUDE_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/path/to/subdir")
             SCIQLOP_SET_TO_PARENT_SCOPE(ANALYSIS_EXCLUDE_DIRS)

gui/include/SqpApplication.h +12 -3

             #ifndef SCIQLOP_SQPAPPLICATION_H
             #define SCIQLOP_SQPAPPLICATION_H
             #include "SqpApplication.h"
             #include <QApplication>
             #include <QLoggingCategory>
             #include <Common/spimpl.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_SqpApplication)
+            #if defined(sqpApp)
+            #undef sqpApp
+            #endif
+            #define sqpApp (static_cast<SqpApplication *>(QCoreApplication::instance()))
+            class DataSourceController;
             /**
              * @brief The SqpApplication class aims to make the link between SciQlop
-             * and its plugins. This is the intermediate class that SciQlop have to use
+             * and its plugins. This is the intermediate class that SciQlop has to use
-             * in the way to connect a data source. Please first use load method to intialize
+             * in the way to connect a data source. Please first use load method to initialize
              * a plugin specified by its metadata name (JSON plugin source) then others specifics
-             * method will ba able to access it.
+             * method will be able to access it.
              * You can load a data source driver plugin then create a data source.
              */
             class SqpApplication : public QApplication {
                 Q_OBJECT
             public:
                 explicit SqpApplication(int &argc, char **argv);
                 virtual ~SqpApplication();
                 void initialize();
+                DataSourceController &dataSourceController() const noexcept;
             private:
                 class SqpApplicationPrivate;
                 spimpl::unique_impl_ptr<SqpApplicationPrivate> impl;
             };
             #endif // SCIQLOP_SQPAPPLICATION_H

gui/src/SqpApplication.cpp +13 -7

             #include "SqpApplication.h"
             #include <DataSource/DataSourceController.h>
             #include <QThread>
             Q_LOGGING_CATEGORY(LOG_SqpApplication, "SqpApplication")
             class SqpApplication::SqpApplicationPrivate {
             public:
-                SqpApplicationPrivate() {}
+                SqpApplicationPrivate() : m_DataSourceController{std::make_unique<DataSourceController>()}
+                {
+                    m_DataSourceController->moveToThread(&m_DataSourceControllerThread);
+                }
                 virtual ~SqpApplicationPrivate()
                 {
-                    qCInfo(LOG_SqpApplication()) << tr("Desctruction du SqpApplicationPrivate");
+                    qCInfo(LOG_SqpApplication()) << tr("SqpApplicationPrivate destruction");
                     m_DataSourceControllerThread.quit();
                     m_DataSourceControllerThread.wait();
                 }
                 std::unique_ptr<DataSourceController> m_DataSourceController;
                 QThread m_DataSourceControllerThread;
             };
             SqpApplication::SqpApplication(int &argc, char **argv)
-                    : QApplication(argc, argv), impl{spimpl::make_unique_impl<SqpApplicationPrivate>()}
+                    : QApplication{argc, argv}, impl{spimpl::make_unique_impl<SqpApplicationPrivate>()}
             {
-                qCInfo(LOG_SqpApplication()) << tr("Construction du SqpApplication");
+                qCInfo(LOG_SqpApplication()) << tr("SqpApplication construction");
-                impl->m_DataSourceController = std::make_unique<DataSourceController>();
-                impl->m_DataSourceController->moveToThread(&impl->m_DataSourceControllerThread);
                 connect(&impl->m_DataSourceControllerThread, &QThread::started,
                         impl->m_DataSourceController.get(), &DataSourceController::initialize);
                 connect(&impl->m_DataSourceControllerThread, &QThread::finished,
                         impl->m_DataSourceController.get(), &DataSourceController::finalize);
                 impl->m_DataSourceControllerThread.start();
             }
             SqpApplication::~SqpApplication()
             {
             }
             void SqpApplication::initialize()
             {
             }
+            DataSourceController &SqpApplication::dataSourceController() const noexcept
+            {
+                return *impl->m_DataSourceController;
+            }

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