HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r1074:ff7cd045358c

Merge pull request from SciQLop-fork develop...

trabillard -

r1074:ff7cd045358c

parent child

Context file:

r1074:ff7cd045358c

cmake/FindCatalogueAPI.cmake created 644 +29 0

@@ -0,0 +1,29
	1	# - Try to find CatalogueAPI Module
	2	# Once done this will define
	3	# CATALOGUEAPI_FOUND - System has CatalogueAPI
	4	# CATALOGUEAPI_INCLUDE_DIRS - The CatalogueAPI include directories
	5	# CATALOGUEAPI_LIBRARIES - The libraries needed to use CatalogueAPI
	6	# CATALOGUEAPI_SHARED_LIBRARIES - The shared libraries for CatalogueAPI
	7
	8	set(CATALOGUEAPI_ROOT_DIR "${CATALOGUEAPI_EXTERN_FOLDER}"
	9	CACHE PATHS
	10	"Path to the installation of CatalogueAPI"
	11	${libRootDirForceValue})
	12
	13	find_path(CATALOGUEAPI_INCLUDE_DIR CatalogueDao.h
	14	HINTS ${CATALOGUEAPI_ROOT_DIR} ${CATALOGUEAPI_EXTERN_FOLDER}
	15	PATH_SUFFIXES src )
	16
	17	find_library(CATALOGUEAPI_LIBRARY NAMES CatalogueAPI
	18	HINTS ${CATALOGUEAPI_ROOT_DIR} ${CATALOGUEAPI_EXTERN_FOLDER}
	19	PATH_SUFFIXES lib)
	20
	21	set(CATALOGUEAPI_LIBRARIES ${CATALOGUEAPI_LIBRARY} )
	22	set(CATALOGUEAPI_INCLUDE_DIRS ${CATALOGUEAPI_INCLUDE_DIR} )
	23
	24	include(FindPackageHandleStandardArgs)
	25	# handle the QUIETLY and REQUIRED arguments and set CATALOGUEAPI_FOUND to TRUE
	26	# if all listed variables are TRUE
	27	find_package_handle_standard_args(CatalogueAPI FOUND_VAR CATALOGUEAPI_FOUND
	28	REQUIRED_VARS CATALOGUEAPI_LIBRARY CATALOGUEAPI_INCLUDE_DIR)
	29	mark_as_advanced(CATALOGUEAPI_INCLUDE_DIR CATALOGUEAPI_LIBRARY )

core/include/Catalogue/CatalogueController.h created 644 +51 0

@@ -0,0 +1,51
	1	#ifndef SCIQLOP_CATALOGUECONTROLLER_H
	2	#define SCIQLOP_CATALOGUECONTROLLER_H
	3
	4	#include "CoreGlobal.h"
	5
	6	#include <Data/SqpRange.h>
	7
	8	#include <QLoggingCategory>
	9	#include <QObject>
	10	#include <QUuid>
	11
	12	#include <Common/spimpl.h>
	13
	14	Q_DECLARE_LOGGING_CATEGORY(LOG_CatalogueController)
	15
	16	class DataSourceItem;
	17	class Variable;
	18
	19	/**
	20	* @brief The CatalogueController class aims to make the link between SciQlop and its plugins.
	21	* This is the intermediate class that SciQlop has to use in the way to connect a data source.
	22	* Please first use register method to initialize a plugin specified by its metadata name (JSON
	23	* plugin source) then others specifics method will be able to access it. You can load a data source
	24	* driver plugin then create a data source.
	25	*/
	26	class SCIQLOP_CORE_EXPORT CatalogueController : public QObject {
	27	Q_OBJECT
	28	public:
	29	explicit CatalogueController(QObject *parent = 0);
	30	virtual ~CatalogueController();
	31
	32	signals:
	33	/// Signal emitted when a variable is about to be deleted from SciQlop
	34	void variableAboutToBeDeleted(std::shared_ptr<Variable> variable);
	35
	36	/// Signal emitted when a data acquisition is requested on a range for a variable
	37	void rangeChanged(std::shared_ptr<Variable> variable, const SqpRange &range);
	38
	39	public slots:
	40	/// Manage init/end of the controller
	41	void initialize();
	42	void finalize();
	43
	44	private:
	45	void waitForFinish();
	46
	47	class CatalogueControllerPrivate;
	48	spimpl::unique_impl_ptr<CatalogueControllerPrivate> impl;
	49	};
	50
	51	#endif // SCIQLOP_CATALOGUECONTROLLER_H

core/src/Catalogue/CatalogueController.cpp created 644 +52 0

@@ -0,0 +1,52
	1	#include <Catalogue/CatalogueController.h>
	2
	3	#include <Variable/Variable.h>
	4
	5	#include <CatalogueDao.h>
	6
	7	#include <QMutex>
	8	#include <QThread>
	9
	10	#include <QDir>
	11	#include <QStandardPaths>
	12
	13	Q_LOGGING_CATEGORY(LOG_CatalogueController, "CatalogueController")
	14
	15	class CatalogueController::CatalogueControllerPrivate {
	16	public:
	17	QMutex m_WorkingMutex;
	18	CatalogueDao m_CatalogueDao;
	19	};
	20
	21	CatalogueController::CatalogueController(QObject *parent)
	22	: impl{spimpl::make_unique_impl<CatalogueControllerPrivate>()}
	23	{
	24	qCDebug(LOG_CatalogueController()) << tr("CatalogueController construction")
	25	<< QThread::currentThread();
	26	}
	27
	28	CatalogueController::~CatalogueController()
	29	{
	30	qCDebug(LOG_CatalogueController()) << tr("CatalogueController destruction")
	31	<< QThread::currentThread();
	32	this->waitForFinish();
	33	}
	34
	35	void CatalogueController::initialize()
	36	{
	37	qCDebug(LOG_CatalogueController()) << tr("CatalogueController init")
	38	<< QThread::currentThread();
	39	impl->m_WorkingMutex.lock();
	40	impl->m_CatalogueDao.initialize();
	41	qCDebug(LOG_CatalogueController()) << tr("CatalogueController init END");
	42	}
	43
	44	void CatalogueController::finalize()
	45	{
	46	impl->m_WorkingMutex.unlock();
	47	}
	48
	49	void CatalogueController::waitForFinish()
	50	{
	51	QMutexLocker locker{&impl->m_WorkingMutex};
	52	}

extern/CatalogueAPI.cmake created 644 +73 0

@@ -0,0 +1,73
	1	# - Clone and build CatalogueAPI Module
	2	include(ExternalProject)
	3
	4	find_package(Git REQUIRED)
	5
	6	if(WIN32)
	7	find_program(MesonExec meson PATHS C:/Appli/Meson)
	8	if(NOT MesonExec)
	9	Message("Error: Meson not found")
	10	else()
	11	message("Meson found: ${MesonExec}" )
	12	endif()
	13	find_program(NinjaExec ninja PATHS C:/Appli/Meson)
	14	if(NOT NinjaExec)
	15	Message("Error: Ninja not found")
	16	else()
	17	message("Ninja found: ${NinjaExec}" )
	18	endif()
	19	endif()
	20	if(NOT MesonExec)
	21	set (MesonExec meson)
	22	endif()
	23	if(NOT NinjaExec)
	24	set (NinjaExec ninja)
	25	endif()
	26
	27	SET(CATALOGUEAPI_SOURCES_PATH ${CMAKE_SOURCE_DIR}/3rdparty/CatalogueAPI)
	28	SET(CATALOGUEAPI_BUILD_PATH ${CATALOGUEAPI_SOURCES_PATH}/build)
	29	SET(CATALOGUEAPI_QXORM_LIB_PATH ${CATALOGUEAPI_BUILD_PATH}/subprojects/QxOrm)
	30	SET(CatalogueAPI_build_type plain)
	31
	32	if(CMAKE_BUILD_TYPE STREQUAL "")
	33	set(CMAKE_BUILD_TYPE Release)
	34	endif()
	35	string(TOLOWER ${CMAKE_BUILD_TYPE} CMAKE_BUILD_TYPE_TOLOWER)
	36
	37	ExternalProject_Add(
	38	CatalogueAPI
	39
	40	GIT_REPOSITORY https://perrinel@hephaistos.lpp.polytechnique.fr/rhodecode/GIT_REPOSITORIES/LPP/Users/mperrinel/CatalogueAPI
	41	GIT_TAG develop
	42
	43	UPDATE_COMMAND ${GIT_EXECUTABLE} pull
	44	PATCH_COMMAND ""
	45
	46	SOURCE_DIR "${CATALOGUEAPI_SOURCES_PATH}"
	47	CONFIGURE_COMMAND ${MesonExec} --prefix=${CATALOGUEAPI_SOURCES_PATH} --buildtype=${CMAKE_BUILD_TYPE_TOLOWER} "${CATALOGUEAPI_SOURCES_PATH}" "${CATALOGUEAPI_BUILD_PATH}"
	48
	49	BUILD_COMMAND ${NinjaExec} -C "${CATALOGUEAPI_BUILD_PATH}"
	50	INSTALL_COMMAND ${NinjaExec} -C "${CATALOGUEAPI_BUILD_PATH}" install
	51	LOG_DOWNLOAD 1
	52	LOG_UPDATE 1
	53	)
	54
	55	set(CATALOG_LIB_PATH lib)
	56	if(WIN32)
	57	set(CATALOG_LIB_PATH bin)
	58	endif()
	59
	60	ExternalProject_Add_Step(
	61	CatalogueAPI CopyToBin
	62	COMMAND ${CMAKE_COMMAND} -E copy_directory ${CATALOGUEAPI_SOURCES_PATH}/lib64 ${CATALOGUEAPI_SOURCES_PATH}/${CATALOG_LIB_PATH}
	63	COMMAND ${CMAKE_COMMAND} -E copy_directory ${CATALOGUEAPI_QXORM_LIB_PATH} ${CATALOGUEAPI_SOURCES_PATH}/${CATALOG_LIB_PATH}
	64	DEPENDEES install
	65	)
	66
	67
	68	set(CATALOGUEAPI_INCLUDE ${CATALOGUEAPI_SOURCES_PATH}/src)
	69	set(CATALOGUEAPI_LIBRARIES ${CATALOGUEAPI_SOURCES_PATH}/${CATALOG_LIB_PATH}/${CMAKE_SHARED_LIBRARY_PREFIX}CatalogueAPI${CMAKE_SHARED_LIBRARY_SUFFIX})
	70	list(APPEND CATALOGUEAPI_LIBRARIES ${CATALOGUEAPI_SOURCES_PATH}/${CATALOG_LIB_PATH}/${CMAKE_SHARED_LIBRARY_PREFIX}QxOrm${CMAKE_SHARED_LIBRARY_SUFFIX})
	71
	72	mark_as_advanced(CATALOGUEAPI_INCLUDE)
	73	mark_as_advanced(CATALOGUEAPI_LIBRARIES)

subprojects/CatalogueAPI.wrap created 644 +4 0

@@ -0,0 +1,4
	1	[wrap-git]
	2	directory=CatalogueAPI
	3	url=https://hephaistos.lpp.polytechnique.fr/rhodecode/GIT_REPOSITORIES/LPP/Users/mperrinel/CatalogueAPI.git
	4	revision=head

subprojects/QxOrm.wrap created 644 +5 0

@@ -0,0 +1,5
	1	[wrap-git]
	2	directory=QxOrm
	3	url=https://github.com/jeandet/qxorm.git
	4	revision=head
	5

.gitignore +1 0

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

CMakeLists.txt +6 0

             ## Main CMakeLists for SCIQLOP
             CMAKE_MINIMUM_REQUIRED (VERSION 3.6.1)
             cmake_policy(VERSION 3.6)
             PROJECT(SCIQLOP)
+            #
+            # build the CatalogueAPI dependencu
+            #
+            INCLUDE("extern/CatalogueAPI.cmake")
             #
             # build the project
             #
             INCLUDE("cmake/sciqlop.cmake")

cmake/sciqlop_package_qt.cmake +1 -1

             STRING(TOLOWER ${CMAKE_BUILD_TYPE} CMAKE_BUILD_TYPE_TO_LOWER)
-            SET(WINDEPLOYQT_ARGS --${CMAKE_BUILD_TYPE_TO_LOWER} --list mapping --no-system-d3d-compiler --compiler-runtime --dry-run)
+            SET(WINDEPLOYQT_ARGS --${CMAKE_BUILD_TYPE_TO_LOWER} --list mapping -network -sql --no-system-d3d-compiler --compiler-runtime --dry-run)
             #FOREACH(qtModule @_qt5_modules@)
             # STRING(TOLOWER ${qtModule} qtLowerModule)
             # SET(WINDEPLOYQT_ARGS ${WINDEPLOYQT_ARGS} -${qtLowerModule})
             #ENDFOREACH()
             EXECUTE_PROCESS(
             COMMAND windeployqt ${WINDEPLOYQT_ARGS} -printsupport ${SCIQLOP_EXE_LOCATION}
             OUTPUT_VARIABLE QT_FILES
             )
             IF( QT_FILES )
             STRING(REPLACE "\n" ";" QT_FILES ${QT_FILES})
             LIST(APPEND QT_FILES_LIST ${QT_FILES})
             FOREACH(QtFile ${QT_FILES_LIST})
              STRING(REPLACE "\"" "" QtFile ${QtFile})
              STRING(REPLACE "\\" "/" QtFile ${QtFile})
              STRING(REGEX MATCH "^(.*) " QtFileSource ${QtFile})
              STRING(REGEX MATCH " (.*)$" QtFileTarget ${QtFile})
              STRING(STRIP ${QtFileSource} QtFileSource)
              STRING(STRIP ${QtFileTarget} QtFileTarget)
              GET_FILENAME_COMPONENT(QtFileTargetDir ${QtFileTarget} DIRECTORY)
              IF(NOT EXISTS "${CMAKE_INSTALL_PREFIX}/${EXECUTABLE_OUTPUT_PATH}/${QtFileTarget}")
                GET_FILENAME_COMPONENT(QtFileTargetDir ${QtFileTarget} DIRECTORY)
                FILE(INSTALL DESTINATION "${EXECUTABLE_OUTPUT_PATH}/${QtFileTargetDir}" FILES "${QtFileSource}")
              ENDIF()
             ENDFOREACH()
             ENDIF()
             MESSAGE( "Exec windeployqt done" )

core/CMakeLists.txt +18 -4

             ## 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/")
             SET(TESTS_RESOURCES_DIR "${CMAKE_CURRENT_SOURCE_DIR}/tests-resources")
             # 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 dependent modules
             find_package(sciqlop-plugin)
             INCLUDE_DIRECTORIES(${SCIQLOP-PLUGIN_INCLUDE_DIR})
             #
             # Find Qt modules
             #
             SCIQLOP_FIND_QT(Core Network)
             #
             # Compile the library library
             #
             ADD_DEFINITIONS(-DCORE_LIB)
             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 Network)
+            # Find CATALOGUE_API
+            include_directories("${CATALOGUEAPI_INCLUDE}")
+            TARGET_LINK_LIBRARIES(${SQPCORE_LIBRARY_NAME} ${CATALOGUEAPI_LIBRARIES})
             INSTALL(TARGETS ${SQPCORE_LIBRARY_NAME}
               RUNTIME DESTINATION ${INSTALL_BINARY_DIR}
               LIBRARY DESTINATION ${INSTALL_LIBRARY_DIR}
               ARCHIVE DESTINATION ${INSTALL_LIBRARY_DIR}
             )
+            add_dependencies(${SQPCORE_LIBRARY_NAME} CatalogueAPI)
             # 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
+            ## Copy extern shared libraries to the lib folder
-            SCIQLOP_COPY_TO_TARGET(LIBRARY ${SQPCORE_LIBRARY_NAME} ${EXTERN_SHARED_LIBRARIES})
+            LIST (APPEND ${EXTERN_SHARED_LIBRARIES} ${CATALOGUEAPI_LIBRARIES})
+            SET (COPY_LIBS_DESTINATION LIBRARY)
+            if(APPLE)
+                SET (COPY_LIBS_DESTINATION RUNTIME)
+            endif()
+            add_custom_command(TARGET ${SQPCORE_LIBRARY_NAME} POST_BUILD
+                COMMAND ${CMAKE_COMMAND} -E copy ${CATALOGUEAPI_LIBRARIES} ${EXECUTABLE_OUTPUT_PATH}
+            )
             # 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})
+                    list(APPEND TEST_LIBRARIES ${CATALOGUEAPI_LIBRARIES})
                     SET(TARGETS_COV)
             	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})
                             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})
                             set(Coverage_NAME ${testName})
                             if(UNIX)
                                 SETUP_TARGET_FOR_COVERAGE(TARGET ${testName}_coverage OUTPUT ${testFile}-path NAME ${testFile} EXECUTABLE ${testName})
                                 LIST( APPEND TARGETS_COV ${testName}_coverage)
                             endif(UNIX)
                     ENDFOREACH( testFile )
                     add_custom_target(coverage)
                     FOREACH( target_cov ${TARGETS_COV} )
                         add_custom_command(TARGET coverage PRE_BUILD COMMAND make ${target_cov})
                     ENDFOREACH( target_cov )
             	LIST(APPEND testFilesToFormat ${TESTS_SOURCES})
             	LIST(APPEND testFilesToFormat ${TESTS_HEADERS})
             	LIST(APPEND FORMATTING_INPUT_FILES ${testFilesToFormat})
                     SCIQLOP_SET_TO_PARENT_SCOPE(FORMATTING_INPUT_FILES)
                     ADD_DEFINITIONS(-DCORE_TESTS_RESOURCES_DIR="${TESTS_RESOURCES_DIR}")
             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/meson.build +9 -2

+            qxorm_dep = dependency('QxOrm', required : true, fallback:['QxOrm','qxorm_dep'])
+            catalogueapi_dep = dependency('CatalogueAPI', required : true, fallback:['CatalogueAPI','CatalogueAPI_dep'])
             core_moc_headers = [
+              'include/Catalogue/CatalogueController.h',
               'include/Data/IDataProvider.h',
               'include/DataSource/DataSourceController.h',
               'include/DataSource/DataSourceItemAction.h',
               'include/Network/NetworkController.h',
               'include/Time/TimeController.h',
               'include/Variable/Variable.h',
               'include/Variable/VariableCacheController.h',
               'include/Variable/VariableController.h',
               'include/Variable/VariableAcquisitionWorker.h',
               'include/Variable/VariableSynchronizationGroup.h',
               'include/Variable/VariableModel.h',
               'include/Visualization/VisualizationController.h'
             ]
             core_moc_files = qt5.preprocess(moc_headers : core_moc_headers)
             core_sources = [
               'src/Common/DateUtils.cpp',
               'src/Common/StringUtils.cpp',
               'src/Common/MimeTypesDef.cpp',
+              'src/Catalogue/CatalogueController.cpp',
               'src/Data/ScalarSeries.cpp',
               'src/Data/SpectrogramSeries.cpp',
               'src/Data/DataSeriesIterator.cpp',
               'src/Data/ArrayDataIterator.cpp',
               'src/Data/VectorSeries.cpp',
               'src/Data/OptionalAxis.cpp',
               'src/Data/DataSeriesUtils.cpp',
               'src/DataSource/DataSourceController.cpp',
               'src/DataSource/DataSourceItem.cpp',
               'src/DataSource/DataSourceItemAction.cpp',
               'src/DataSource/DataSourceItemMergeHelper.cpp',
               'src/Network/NetworkController.cpp',
               'src/Plugin/PluginManager.cpp',
               'src/Settings/SqpSettingsDefs.cpp',
               'src/Time/TimeController.cpp',
               'src/Variable/Variable.cpp',
               'src/Variable/VariableCacheController.cpp',
               'src/Variable/VariableController.cpp',
               'src/Variable/VariableAcquisitionWorker.cpp',
               'src/Variable/VariableSynchronizationGroup.cpp',
               'src/Variable/VariableModel.cpp',
               'src/Visualization/VisualizationController.cpp'
             ]
             core_inc = include_directories(['include', '../plugin/include'])
             sciqlop_core_lib = library('sciqlopcore',
                                    core_sources,
                                    core_moc_files,
                                    cpp_args : '-DCORE_LIB',
                                    include_directories : core_inc,
-                                   dependencies : [qt5core, qt5network],
+                                   dependencies : [qt5core, qt5network, catalogueapi_dep],
                                    install : true
                                    )
             sciqlop_core = declare_dependency(link_with : sciqlop_core_lib,
                                             include_directories : core_inc,
-                                            dependencies : [qt5core, qt5network])
+                                            dependencies : [qt5core, qt5network, catalogueapi_dep])
             subdir('tests')

gui/src/SqpApplication.cpp +15 0

             #include "SqpApplication.h"
+            #include <Catalogue/CatalogueController.h>
             #include <Data/IDataProvider.h>
             #include <DataSource/DataSourceController.h>
             #include <DragAndDrop/DragDropHelper.h>
             #include <Network/NetworkController.h>
             #include <QThread>
             #include <Time/TimeController.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <Variable/VariableModel.h>
             #include <Visualization/VisualizationController.h>
             Q_LOGGING_CATEGORY(LOG_SqpApplication, "SqpApplication")
             class SqpApplication::SqpApplicationPrivate {
             public:
                 SqpApplicationPrivate()
                         : m_DataSourceController{std::make_unique<DataSourceController>()},
                           m_VariableController{std::make_unique<VariableController>()},
                           m_TimeController{std::make_unique<TimeController>()},
                           m_NetworkController{std::make_unique<NetworkController>()},
                           m_VisualizationController{std::make_unique<VisualizationController>()},
                           m_DragDropHelper{std::make_unique<DragDropHelper>()},
+                          m_CatalogueController{std::make_unique<CatalogueController>()},
                           m_PlotInterractionMode(SqpApplication::PlotsInteractionMode::None),
                           m_PlotCursorMode(SqpApplication::PlotsCursorMode::NoCursor)
                 {
                     // /////////////////////////////// //
                     // Connections between controllers //
                     // /////////////////////////////// //
                     // VariableController <-> DataSourceController
                     connect(m_DataSourceController.get(),
                             SIGNAL(variableCreationRequested(const QString &, const QVariantHash &,
                                                              std::shared_ptr<IDataProvider>)),
                             m_VariableController.get(),
                             SLOT(createVariable(const QString &, const QVariantHash &,
                                                 std::shared_ptr<IDataProvider>)));
                     connect(m_VariableController->variableModel(), &VariableModel::requestVariable,
                             m_DataSourceController.get(), &DataSourceController::requestVariable);
                     // VariableController <-> VisualizationController
                     connect(m_VariableController.get(),
                             SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)),
                             m_VisualizationController.get(),
                             SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)), Qt::DirectConnection);
                     connect(m_VariableController.get(),
                             SIGNAL(rangeChanged(std::shared_ptr<Variable>, const SqpRange &)),
                             m_VisualizationController.get(),
                             SIGNAL(rangeChanged(std::shared_ptr<Variable>, const SqpRange &)));
                     m_DataSourceController->moveToThread(&m_DataSourceControllerThread);
                     m_DataSourceControllerThread.setObjectName("DataSourceControllerThread");
                     m_NetworkController->moveToThread(&m_NetworkControllerThread);
                     m_NetworkControllerThread.setObjectName("NetworkControllerThread");
                     m_VariableController->moveToThread(&m_VariableControllerThread);
                     m_VariableControllerThread.setObjectName("VariableControllerThread");
                     m_VisualizationController->moveToThread(&m_VisualizationControllerThread);
                     m_VisualizationControllerThread.setObjectName("VsualizationControllerThread");
+                    m_CatalogueController->moveToThread(&m_CatalogueControllerThread);
+                    m_CatalogueControllerThread.setObjectName("CatalogueControllerThread");
                     // Additionnal init
                     m_VariableController->setTimeController(m_TimeController.get());
                 }
                 virtual ~SqpApplicationPrivate()
                 {
                     m_DataSourceControllerThread.quit();
                     m_DataSourceControllerThread.wait();
                     m_NetworkControllerThread.quit();
                     m_NetworkControllerThread.wait();
                     m_VariableControllerThread.quit();
                     m_VariableControllerThread.wait();
                     m_VisualizationControllerThread.quit();
                     m_VisualizationControllerThread.wait();
+                    m_CatalogueControllerThread.quit();
+                    m_CatalogueControllerThread.wait();
                 }
                 std::unique_ptr<DataSourceController> m_DataSourceController;
                 std::unique_ptr<VariableController> m_VariableController;
                 std::unique_ptr<TimeController> m_TimeController;
                 std::unique_ptr<NetworkController> m_NetworkController;
                 std::unique_ptr<VisualizationController> m_VisualizationController;
+                std::unique_ptr<CatalogueController> m_CatalogueController;
                 QThread m_DataSourceControllerThread;
                 QThread m_NetworkControllerThread;
                 QThread m_VariableControllerThread;
                 QThread m_VisualizationControllerThread;
+                QThread m_CatalogueControllerThread;
                 std::unique_ptr<DragDropHelper> m_DragDropHelper;
                 SqpApplication::PlotsInteractionMode m_PlotInterractionMode;
                 SqpApplication::PlotsCursorMode m_PlotCursorMode;
             };
             SqpApplication::SqpApplication(int &argc, char **argv)
                     : QApplication{argc, argv}, impl{spimpl::make_unique_impl<SqpApplicationPrivate>()}
             {
                 qCDebug(LOG_SqpApplication()) << tr("SqpApplication construction") << QThread::currentThread();
                 connect(&impl->m_DataSourceControllerThread, &QThread::started,
                         impl->m_DataSourceController.get(), &DataSourceController::initialize);
                 connect(&impl->m_DataSourceControllerThread, &QThread::finished,
                         impl->m_DataSourceController.get(), &DataSourceController::finalize);
                 connect(&impl->m_NetworkControllerThread, &QThread::started, impl->m_NetworkController.get(),
                         &NetworkController::initialize);
                 connect(&impl->m_NetworkControllerThread, &QThread::finished, impl->m_NetworkController.get(),
                         &NetworkController::finalize);
                 connect(&impl->m_VariableControllerThread, &QThread::started, impl->m_VariableController.get(),
                         &VariableController::initialize);
                 connect(&impl->m_VariableControllerThread, &QThread::finished, impl->m_VariableController.get(),
                         &VariableController::finalize);
                 connect(&impl->m_VisualizationControllerThread, &QThread::started,
                         impl->m_VisualizationController.get(), &VisualizationController::initialize);
                 connect(&impl->m_VisualizationControllerThread, &QThread::finished,
                         impl->m_VisualizationController.get(), &VisualizationController::finalize);
+                connect(&impl->m_CatalogueControllerThread, &QThread::started,
+                        impl->m_CatalogueController.get(), &CatalogueController::initialize);
+                connect(&impl->m_CatalogueControllerThread, &QThread::finished,
+                        impl->m_CatalogueController.get(), &CatalogueController::finalize);
                 impl->m_DataSourceControllerThread.start();
                 impl->m_NetworkControllerThread.start();
                 impl->m_VariableControllerThread.start();
                 impl->m_VisualizationControllerThread.start();
+                impl->m_CatalogueControllerThread.start();
             }
             SqpApplication::~SqpApplication()
             {
             }
             void SqpApplication::initialize()
             {
             }
             DataSourceController &SqpApplication::dataSourceController() noexcept
             {
                 return *impl->m_DataSourceController;
             }
             NetworkController &SqpApplication::networkController() noexcept
             {
                 return *impl->m_NetworkController;
             }
             TimeController &SqpApplication::timeController() noexcept
             {
                 return *impl->m_TimeController;
             }
             VariableController &SqpApplication::variableController() noexcept
             {
                 return *impl->m_VariableController;
             }
             VisualizationController &SqpApplication::visualizationController() noexcept
             {
                 return *impl->m_VisualizationController;
             }
             DragDropHelper &SqpApplication::dragDropHelper() noexcept
             {
                 return *impl->m_DragDropHelper;
             }
             SqpApplication::PlotsInteractionMode SqpApplication::plotsInteractionMode() const
             {
                 return impl->m_PlotInterractionMode;
             }
             void SqpApplication::setPlotsInteractionMode(SqpApplication::PlotsInteractionMode mode)
             {
                 impl->m_PlotInterractionMode = mode;
             }
             SqpApplication::PlotsCursorMode SqpApplication::plotsCursorMode() const
             {
                 return impl->m_PlotCursorMode;
             }
             void SqpApplication::setPlotsCursorMode(SqpApplication::PlotsCursorMode mode)
             {
                 impl->m_PlotCursorMode = mode;
             }

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

             #include "CosinusProvider.h"
             #include "MockDefs.h"
             #include <Data/DataProviderParameters.h>
             #include <Data/ScalarSeries.h>
             #include <SqpApplication.h>
             #include <Time/TimeController.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <QObject>
             #include <QtTest>
             #include <cmath>
             #include <memory>
             namespace {
             /// Path for the tests
             const auto TESTS_RESOURCES_PATH = QFileInfo{
                 QString{MOCKPLUGIN_TESTS_RESOURCES_DIR},
                 "TestCosinusAcquisition"}.absoluteFilePath();
             /// Format of dates in data files
             const auto DATETIME_FORMAT = QStringLiteral("yyyy/MM/dd hh:mm:ss:zzz");
             /**
              * Verifies that the data in the candidate series are identical to the data in the reference series
              * in a specific range
              * @param candidate the candidate data series
              * @param range the range to check
              * @param reference the reference data series
              * @return true if the data of the candidate series and the reference series are identical in the
              * range, false otherwise
              */
             bool checkDataSeries(std::shared_ptr<IDataSeries> candidate, const SqpRange &range,
                                  std::shared_ptr<IDataSeries> reference)
             {
                 if (candidate == nullptr || reference == nullptr) {
                     return candidate == reference;
                 }
                 auto referenceIt = reference->xAxisRange(range.m_TStart, range.m_TEnd);
                 qInfo() << "candidateSize" << std::distance(candidate->cbegin(), candidate->cend());
                 qInfo() << "refSize" << std::distance(referenceIt.first, referenceIt.second);
                 return std::equal(candidate->cbegin(), candidate->cend(), referenceIt.first, referenceIt.second,
                                   [](const auto &it1, const auto &it2) {
                                       // - milliseconds precision for time
                                       // - 1e-6 precision for value
                                       return std::abs(it1.x() - it2.x()) < 1e-3
                                              && std::abs(it1.value() - it2.value()) < 1e-6;
                                   });
             }
             } // namespace
             /**
              * @brief The TestCosinusAcquisition class tests acquisition in SciQlop (operations like zooms in,
              * zooms out, pans) of data from CosinusProvider
              * @sa CosinusProvider
              */
             class TestCosinusAcquisition : public QObject {
                 Q_OBJECT
             private slots:
                 /// Input data for @sa testAcquisition()
                 void testAcquisition_data();
                 void testAcquisition();
             };
             void TestCosinusAcquisition::testAcquisition_data()
             {
                 // ////////////// //
                 // Test structure //
                 // ////////////// //
                 QTest::addColumn<SqpRange>("referenceRange");           // Range for generating reference series
                 QTest::addColumn<SqpRange>("initialRange");             // First acquisition
                 QTest::addColumn<int>("operationDelay");                // Acquisitions to make
                 QTest::addColumn<std::vector<SqpRange> >("operations"); // Acquisitions to make
                 // ////////// //
                 // Test cases //
                 // ////////// //
                 auto dateTime = [](int year, int month, int day, int hours, int minutes, int seconds) {
                     return DateUtils::secondsSinceEpoch(
                         QDateTime{{year, month, day}, {hours, minutes, seconds}, Qt::UTC});
                 };
                 QTest::newRow("cosinus")
                     << SqpRange{dateTime(2017, 1, 1, 12, 0, 0), dateTime(2017, 1, 1, 13, 0, 0)}
                     << SqpRange{dateTime(2017, 1, 1, 12, 30, 0), dateTime(2017, 1, 1, 12, 35, 1)} << 250
                     << std::vector<SqpRange>{
                            // Pan (jump) left
                            SqpRange{dateTime(2017, 1, 1, 12, 45, 0), dateTime(2017, 1, 1, 12, 50, 0)},
                            // Pan (jump) right
                            SqpRange{dateTime(2017, 1, 1, 12, 15, 0), dateTime(2017, 1, 1, 12, 20, 0)},
                            // Pan (overlay) right
                            SqpRange{dateTime(2017, 1, 1, 12, 14, 0), dateTime(2017, 1, 1, 12, 19, 0)},
                            // Pan (overlay) left
                            SqpRange{dateTime(2017, 1, 1, 12, 15, 0), dateTime(2017, 1, 1, 12, 20, 0)},
                            // Pan (overlay) left
                            SqpRange{dateTime(2017, 1, 1, 12, 16, 0), dateTime(2017, 1, 1, 12, 21, 0)},
                            // Zoom in
                            SqpRange{dateTime(2017, 1, 1, 12, 17, 30), dateTime(2017, 1, 1, 12, 19, 30)},
                            // Zoom out
                            SqpRange{dateTime(2017, 1, 1, 12, 12, 30), dateTime(2017, 1, 1, 12, 24, 30)}};
                 QTest::newRow("cosinus_big")
                     << SqpRange{dateTime(2017, 1, 1, 1, 0, 0), dateTime(2017, 1, 5, 13, 0, 0)}
                     << SqpRange{dateTime(2017, 1, 2, 6, 30, 0), dateTime(2017, 1, 2, 18, 30, 0)} << 5000
                     << std::vector<SqpRange>{
                            // Pan (jump) left
                            SqpRange{dateTime(2017, 1, 1, 13, 30, 0), dateTime(2017, 1, 1, 18, 30, 0)},
                            // Pan (jump) right
                            SqpRange{dateTime(2017, 1, 3, 4, 30, 0), dateTime(2017, 1, 3, 10, 30, 0)},
                            // Pan (overlay) right
                            SqpRange{dateTime(2017, 1, 3, 8, 30, 0), dateTime(2017, 1, 3, 12, 30, 0)},
                            // Pan (overlay) left
                            SqpRange{dateTime(2017, 1, 2, 8, 30, 0), dateTime(2017, 1, 3, 10, 30, 0)},
                            // Pan (overlay) left
                            SqpRange{dateTime(2017, 1, 1, 12, 30, 0), dateTime(2017, 1, 3, 5, 30, 0)},
                            // Zoom in
                            SqpRange{dateTime(2017, 1, 2, 2, 30, 0), dateTime(2017, 1, 2, 8, 30, 0)},
                            // Zoom out
                            SqpRange{dateTime(2017, 1, 1, 14, 30, 0), dateTime(2017, 1, 3, 12, 30, 0)}};
             }
             void TestCosinusAcquisition::testAcquisition()
             {
                 // Retrieves reference range
                 QFETCH(SqpRange, referenceRange);
                 CosinusProvider referenceProvider{};
                 auto dataSeries = referenceProvider.provideDataSeries(
-                    referenceRange, {{COSINUS_TYPE_KEY, "scalar"}, {COSINUS_FREQUENCY_KEY, 100.}});
+                    referenceRange, {{COSINUS_TYPE_KEY, "scalar"}, {COSINUS_FREQUENCY_KEY, 10.}});
                 auto end = dataSeries->cend() - 1;
                 qInfo() << dataSeries->nbPoints() << dataSeries->cbegin()->x() << end->x();
                 /// Lambda used to validate a variable at each step
                 auto validateVariable
                     = [dataSeries](std::shared_ptr<Variable> variable, const SqpRange &range) {
                           // Checks that the variable's range has changed
                           qInfo() << "range vs expected range" << variable->range() << range;
                           QCOMPARE(variable->range(), range);
                           // Checks the variable's data series
                           QVERIFY(checkDataSeries(variable->dataSeries(), variable->cacheRange(), dataSeries));
                       };
                 // Creates variable
                 QFETCH(SqpRange, initialRange);
                 sqpApp->timeController().onTimeToUpdate(initialRange);
                 auto provider = std::make_shared<CosinusProvider>();
                 auto variable = sqpApp->variableController().createVariable(
-                    "MMS", {{COSINUS_TYPE_KEY, "scalar"}, {COSINUS_FREQUENCY_KEY, 100.}}, provider);
+                    "MMS", {{COSINUS_TYPE_KEY, "scalar"}, {COSINUS_FREQUENCY_KEY, 10.}}, provider);
                 QFETCH(int, operationDelay);
                 QTest::qWait(operationDelay);
                 validateVariable(variable, initialRange);
                 QTest::qWait(operationDelay);
                 // Makes operations on the variable
                 QFETCH(std::vector<SqpRange>, operations);
                 for (const auto &operation : operations) {
                     // Asks request on the variable and waits during its execution
                     sqpApp->variableController().onRequestDataLoading({variable}, operation, false);
                     QTest::qWait(operationDelay);
                     validateVariable(variable, operation);
                 }
                 for (const auto &operation : operations) {
                     // Asks request on the variable and waits during its execution
                     sqpApp->variableController().onRequestDataLoading({variable}, operation, false);
                 }
                 QTest::qWait(operationDelay);
                 validateVariable(variable, operations.back());
             }
             int main(int argc, char *argv[])
             {
                 SqpApplication app{argc, argv};
                 app.setAttribute(Qt::AA_Use96Dpi, true);
                 TestCosinusAcquisition testObject{};
                 QTEST_SET_MAIN_SOURCE_PATH
                 return QTest::qExec(&testObject, argc, argv);
             }
             #include "TestCosinusAcquisition.moc"

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