GIT_REPOSITORIES/LPP/Users/mperrinel/SCIQLOP-Initialisation Commit - r425:b8af3b4730c2

Exports core module as a shared library...

Alexandre Leroux -

r425:b8af3b4730c2

parent child

Context file:

r425:b8af3b4730c2

Collapse all files

core/include/CoreGlobal.h created 644 +12 0

@@ -0,0 +1,12
	1	#ifndef SCIQLOP_COREGLOBAL_H
	2	#define SCIQLOP_COREGLOBAL_H
	3
	4	#include <QtCore/QtGlobal>
	5
	6	#ifdef CORE_LIB
	7	#define SCIQLOP_CORE_EXPORT Q_DECL_EXPORT
	8	#else
	9	#define SCIQLOP_CORE_EXPORT Q_DECL_IMPORT
	10	#endif
	11
	12	#endif // SCIQLOP_COREGLOBAL_H

core/CMakeLists.txt +3 0

             ## 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 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)
             INSTALL(TARGETS ${SQPCORE_LIBRARY_NAME}
               RUNTIME DESTINATION ${INSTALL_BINARY_DIR}
               LIBRARY DESTINATION ${INSTALL_LIBRARY_DIR}
               ARCHIVE DESTINATION ${INSTALL_LIBRARY_DIR}
             )
             # 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})
                     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)
             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/Data/IDataProvider.h +3 -1

             #ifndef SCIQLOP_IDATAPROVIDER_H
             #define SCIQLOP_IDATAPROVIDER_H
+            #include "CoreGlobal.h"
             #include <memory>
             #include <QObject>
             #include <QUuid>
             #include <Common/MetaTypes.h>
             #include <Data/SqpDateTime.h>
             #include <functional>
             class DataProviderParameters;
             class IDataSeries;
             class QNetworkReply;
             class QNetworkRequest;
             /**
              * @brief The IDataProvider interface aims to declare a data provider.
              *
              * A data provider is an entity that generates data and returns it according to various parameters
              * (time interval, product to retrieve the data, etc.)
              *
              * @sa IDataSeries
              */
-            class IDataProvider : public QObject {
+            class SCIQLOP_CORE_EXPORT IDataProvider : public QObject {
                 Q_OBJECT
             public:
                 virtual ~IDataProvider() noexcept = default;
                 /**
                  * @brief requestDataLoading provide datas for the data identified by identifier and parameters
                  */
                 virtual void requestDataLoading(QUuid identifier, const DataProviderParameters &parameters) = 0;
                 /**
                  * @brief requestDataAborting stop data loading of the data identified by identifier
                  */
                 virtual void requestDataAborting(QUuid identifier) = 0;
             signals:
                 /**
                  * @brief dataProvided send dataSeries under dateTime and that corresponds of the data
                  * identified by identifier
                  */
                 void dataProvided(QUuid identifier, std::shared_ptr<IDataSeries> dateSerie,
                                   const SqpDateTime &dateTime);
                 /**
                     * @brief dataProvided send dataSeries under dateTime and that corresponds of the data
                     * identified by identifier
                     */
                 void dataProvidedProgress(QUuid identifier, double progress);
                 /**
                  * @brief requestConstructed send a request for the data identified by identifier
                  * @callback is the methode call by the reply of the request when it is finished.
                  */
                 void requestConstructed(const QNetworkRequest &request, QUuid identifier,
                                         std::function<void(QNetworkReply *, QUuid)> callback);
             };
             // Required for using shared_ptr in signals/slots
             SCIQLOP_REGISTER_META_TYPE(IDATAPROVIDER_PTR_REGISTRY, std::shared_ptr<IDataProvider>)
             SCIQLOP_REGISTER_META_TYPE(IDATAPROVIDER_FUNCTION_REGISTRY,
                                        std::function<void(QNetworkReply *, QUuid)>)
             #endif // SCIQLOP_IDATAPROVIDER_H

core/include/Data/ScalarSeries.h +3 -1

             #ifndef SCIQLOP_SCALARSERIES_H
             #define SCIQLOP_SCALARSERIES_H
+            #include "CoreGlobal.h"
             #include <Data/DataSeries.h>
             /**
              * @brief The ScalarSeries class is the implementation for a data series representing a scalar.
              */
-            class ScalarSeries : public DataSeries<1> {
+            class SCIQLOP_CORE_EXPORT ScalarSeries : public DataSeries<1> {
             public:
                 /**
                  * Ctor with two vectors. The vectors must have the same size, otherwise a ScalarSeries with no
                  * values will be created.
                  * @param xAxisData x-axis data
                  * @param valuesData values data
                  */
                 explicit ScalarSeries(QVector<double> xAxisData, QVector<double> valuesData,
                                       const Unit &xAxisUnit, const Unit &valuesUnit);
                 std::unique_ptr<IDataSeries> clone() const;
             };
             #endif // SCIQLOP_SCALARSERIES_H

core/include/DataSource/DataSourceController.h +3 -1

             #ifndef SCIQLOP_DATASOURCECONTROLLER_H
             #define SCIQLOP_DATASOURCECONTROLLER_H
+            #include "CoreGlobal.h"
             #include <QLoggingCategory>
             #include <QObject>
             #include <QUuid>
             #include <Common/spimpl.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_DataSourceController)
             class DataSourceItem;
             class IDataProvider;
             /**
              * @brief The DataSourceController class aims to make the link between SciQlop and its plugins. This
              * is the intermediate class that SciQlop has to use in the way to connect a data source. Please
              * first use register method to initialize a plugin specified by its metadata name (JSON plugin
              * source) then others specifics method will be able to access it. You can load a data source driver
              * plugin then create a data source.
              */
-            class DataSourceController : public QObject {
+            class SCIQLOP_CORE_EXPORT 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. It must be not null to be registered
                  * @sa registerDataSource()
                  */
                 void setDataSourceItem(const QUuid &dataSourceUid,
                                        std::unique_ptr<DataSourceItem> dataSourceItem) noexcept;
                 /**
                  * Sets the data provider used to retrieve data from of a data source. The controller takes
                  * ownership of the provider.
                  * @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 dataProvider the provider of the data source
                  * @sa registerDataSource()
                  */
                 void setDataProvider(const QUuid &dataSourceUid,
                                      std::unique_ptr<IDataProvider> dataProvider) noexcept;
                 /**
                  * Loads an item (product) as a variable in SciQlop
                  * @param dataSourceUid the unique id of the data source containing the item. It is used to get
                  * the data provider associated to the data source, and pass it to for the variable creation
                  * @param productItem the item to load
                  */
                 void loadProductItem(const QUuid &dataSourceUid, const DataSourceItem &productItem) 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(DataSourceItem *dataSourceItem);
                 /**
                  * Signal emitted when a variable creation is asked for a product
                  * @param variableName the name of the variable
                  * @param variableMetadata the metadata of the variable
                  * @param variableProvider the provider that will be used to retrieve the data of the variable
                  * (can be null)
                  */
                 void variableCreationRequested(const QString &variableName,
                                                const QVariantHash &variableMetadata,
                                                std::shared_ptr<IDataProvider> variableProvider);
             private:
                 void waitForFinish();
                 class DataSourceControllerPrivate;
                 spimpl::unique_impl_ptr<DataSourceControllerPrivate> impl;
             };
             #endif // SCIQLOP_DATASOURCECONTROLLER_H

core/include/DataSource/DataSourceItem.h +3 -1

             #ifndef SCIQLOP_DATASOURCEITEM_H
             #define SCIQLOP_DATASOURCEITEM_H
+            #include "CoreGlobal.h"
             #include <Common/spimpl.h>
             #include <QVariant>
             #include <QVector>
             class DataSourceItemAction;
             /**
              * Possible types of an item
              */
             enum class DataSourceItemType { NODE, PRODUCT, COMPONENT };
             /**
              * @brief The DataSourceItem class aims to represent a structure element of a data source.
              * A data source has a tree structure that is made up of a main DataSourceItem object (root)
              * containing other DataSourceItem objects (children).
              * For each DataSourceItem can be associated a set of data representing it.
              */
-            class DataSourceItem {
+            class SCIQLOP_CORE_EXPORT DataSourceItem {
             public:
                 /// Key associated with the name of the item
                 static const QString NAME_DATA_KEY;
                 explicit DataSourceItem(DataSourceItemType type, const QString &name);
                 explicit DataSourceItem(DataSourceItemType type, QVariantHash data = {});
                 /// @return the actions of the item as a vector
                 QVector<DataSourceItemAction *> actions() const noexcept;
                 /**
                  * Adds an action to the item. The item takes ownership of the action, and the action is
                  * automatically associated to the item
                  * @param action the action to add
                  */
                 void addAction(std::unique_ptr<DataSourceItemAction> action) noexcept;
                 /**
                  * Adds a child to the item. The item takes ownership of the child.
                  * @param child the child to add
                  */
                 void appendChild(std::unique_ptr<DataSourceItem> child) noexcept;
                 /**
                  * Returns the item's child associated to an index
                  * @param childIndex the index to search
                  * @return a pointer to the child if index is valid, nullptr otherwise
                  */
                 DataSourceItem *child(int childIndex) const noexcept;
                 int childCount() const noexcept;
                 /**
                  * Get the data associated to a key
                  * @param key the key to search
                  * @return the data found if key is valid, default QVariant otherwise
                  */
                 QVariant data(const QString &key) const noexcept;
                 /// Gets all data
                 QVariantHash data() const noexcept;
                 bool isRoot() const noexcept;
                 QString name() const noexcept;
                 /**
                  * Get the item's parent
                  * @return a pointer to the parent if it exists, nullptr if the item is a root
                  */
                 DataSourceItem *parentItem() const noexcept;
                 /**
                  * Sets or appends a value to a key
                  * @param key the key
                  * @param value the value
                  * @param append if true, the value is added to the values already existing for the key,
                  * otherwise it replaces the existing values
                  */
                 void setData(const QString &key, const QVariant &value, bool append = false) noexcept;
                 DataSourceItemType type() const noexcept;
                 bool operator==(const DataSourceItem &other);
                 bool operator!=(const DataSourceItem &other);
             private:
                 class DataSourceItemPrivate;
                 spimpl::unique_impl_ptr<DataSourceItemPrivate> impl;
             };
             #endif // SCIQLOP_DATASOURCEITEMMODEL_H

core/include/DataSource/DataSourceItemAction.h +3 -1

             #ifndef SCIQLOP_DATASOURCEITEMACTION_H
             #define SCIQLOP_DATASOURCEITEMACTION_H
+            #include "CoreGlobal.h"
             #include <Common/spimpl.h>
             #include <QLoggingCategory>
             #include <QObject>
             #include <functional>
             Q_DECLARE_LOGGING_CATEGORY(LOG_DataSourceItemAction)
             class DataSourceItem;
             /**
              * @brief The DataSourceItemAction class represents an action on a data source item.
              *
              * An action is a function that will be executed when the slot execute() is called.
              */
-            class DataSourceItemAction : public QObject {
+            class SCIQLOP_CORE_EXPORT DataSourceItemAction : public QObject {
                 Q_OBJECT
             public:
                 /// Signature of the function associated to the action
                 using ExecuteFunction = std::function<void(DataSourceItem &dataSourceItem)>;
                 /**
                  * Ctor
                  * @param name the name of the action
                  * @param fun the function that will be called when the action is executed
                  * @sa execute()
                  */
                 explicit DataSourceItemAction(const QString &name, ExecuteFunction fun);
                 QString name() const noexcept;
                 /// Sets the data source item concerned by the action
                 void setDataSourceItem(DataSourceItem *dataSourceItem) noexcept;
             public slots:
                 /// Executes the action
                 void execute();
             private:
                 class DataSourceItemActionPrivate;
                 spimpl::unique_impl_ptr<DataSourceItemActionPrivate> impl;
             };
             #endif // SCIQLOP_DATASOURCEITEMACTION_H

core/include/Network/NetworkController.h +3 -1

             #ifndef SCIQLOP_NETWORKCONTROLLER_H
             #define SCIQLOP_NETWORKCONTROLLER_H
+            #include "CoreGlobal.h"
             #include <QLoggingCategory>
             #include <QObject>
             #include <QUuid>
             #include <Common/spimpl.h>
             #include <functional>
             Q_DECLARE_LOGGING_CATEGORY(LOG_NetworkController)
             class QNetworkReply;
             class QNetworkRequest;
             /**
              * @brief The NetworkController class aims to handle all network connection of SciQlop.
              */
-            class NetworkController : public QObject {
+            class SCIQLOP_CORE_EXPORT NetworkController : public QObject {
                 Q_OBJECT
             public:
                 explicit NetworkController(QObject *parent = 0);
                 void initialize();
                 void finalize();
             public slots:
                 /// Execute request and call callback when the reply is finished. Identifier is attached to the
                 /// callback
                 void onProcessRequested(const QNetworkRequest &request, QUuid identifier,
                                         std::function<void(QNetworkReply *, QUuid)> callback);
                 /// Cancel the request of identifier
                 void onReplyCanceled(QUuid identifier);
             signals:
                 void replyFinished(QNetworkReply *reply, QUuid identifier);
                 void replyDownloadProgress(QUuid identifier, double progress);
             private:
                 void waitForFinish();
                 class NetworkControllerPrivate;
                 spimpl::unique_impl_ptr<NetworkControllerPrivate> impl;
             };
             #endif // SCIQLOP_NETWORKCONTROLLER_H

core/include/Plugin/PluginManager.h +3 -1

             #ifndef SCIQLOP_PLUGINMANAGER_H
             #define SCIQLOP_PLUGINMANAGER_H
+            #include "CoreGlobal.h"
             #include <Common/spimpl.h>
             #include <QLoggingCategory>
             class QDir;
             Q_DECLARE_LOGGING_CATEGORY(LOG_PluginManager)
             /**
              * @brief The PluginManager class aims to handle the plugins loaded dynamically into SciQLop.
              */
-            class PluginManager {
+            class SCIQLOP_CORE_EXPORT PluginManager {
             public:
                 explicit PluginManager();
                 /**
                  * Loads plugins into SciQlop. The loaded plugins are those located in the directory passed in
                  * parameter
                  * @param pluginDir the directory containing the plugins
                  */
                 void loadPlugins(const QDir &pluginDir);
                 /// @returns the number of plugins loaded
                 int nbPluginsLoaded() const noexcept;
             private:
                 class PluginManagerPrivate;
                 spimpl::unique_impl_ptr<PluginManagerPrivate> impl;
             };
             #endif // SCIQLOP_PLUGINMANAGER_H

core/include/Time/TimeController.h +3 -1

             #ifndef SCIQLOP_TIMECONTROLLER_H
             #define SCIQLOP_TIMECONTROLLER_H
+            #include "CoreGlobal.h"
             #include <Data/SqpDateTime.h>
             #include <QLoggingCategory>
             #include <QObject>
             #include <Common/spimpl.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_TimeController)
             /**
              * @brief The TimeController class aims to handle the Time parameters notification in SciQlop.
              */
-            class TimeController : public QObject {
+            class SCIQLOP_CORE_EXPORT TimeController : public QObject {
                 Q_OBJECT
             public:
                 explicit TimeController(QObject *parent = 0);
                 SqpDateTime dateTime() const noexcept;
             signals:
                 /// Signal emitted to notify that time parameters has beed updated
                 void timeUpdated(SqpDateTime time);
             public slots:
                 /// Slot called when a new dateTime has been defined.
                 void onTimeToUpdate(SqpDateTime dateTime);
                 /// Slot called when the dateTime has to be notified. Call timeUpdated signal
                 void onTimeNotify();
             private:
                 class TimeControllerPrivate;
                 spimpl::unique_impl_ptr<TimeControllerPrivate> impl;
             };
             #endif // SCIQLOP_TIMECONTROLLER_H

core/include/Variable/Variable.h +3 -1

             #ifndef SCIQLOP_VARIABLE_H
             #define SCIQLOP_VARIABLE_H
+            #include "CoreGlobal.h"
             #include <Data/SqpDateTime.h>
             #include <QLoggingCategory>
             #include <QObject>
             #include <Common/MetaTypes.h>
             #include <Common/spimpl.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_Variable)
             class IDataSeries;
             class QString;
             /**
              * @brief The Variable class represents a variable in SciQlop.
              */
-            class Variable : public QObject {
+            class SCIQLOP_CORE_EXPORT Variable : public QObject {
                 Q_OBJECT
             public:
                 explicit Variable(const QString &name, const SqpDateTime &dateTime,
                                   const QVariantHash &metadata = {});
                 QString name() const noexcept;
                 SqpDateTime dateTime() const noexcept;
                 void setDateTime(const SqpDateTime &dateTime) noexcept;
                 /// @return the data of the variable, nullptr if there is no data
                 IDataSeries *dataSeries() const noexcept;
                 QVariantHash metadata() const noexcept;
                 bool contains(const SqpDateTime &dateTime) const noexcept;
                 bool intersect(const SqpDateTime &dateTime) const noexcept;
                 bool isInside(const SqpDateTime &dateTime) const noexcept;
             public slots:
                 void setDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept;
             signals:
                 void updated();
             private:
                 class VariablePrivate;
                 spimpl::unique_impl_ptr<VariablePrivate> impl;
             };
             // Required for using shared_ptr in signals/slots
             SCIQLOP_REGISTER_META_TYPE(VARIABLE_PTR_REGISTRY, std::shared_ptr<Variable>)
             #endif // SCIQLOP_VARIABLE_H

core/include/Variable/VariableCacheController.h +3 -1

             #ifndef SCIQLOP_VARIABLECACHECONTROLLER_H
             #define SCIQLOP_VARIABLECACHECONTROLLER_H
+            #include "CoreGlobal.h"
             #include <QLoggingCategory>
             #include <QObject>
             #include <Data/SqpDateTime.h>
             #include <QLoggingCategory>
             #include <Common/spimpl.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_VariableCacheController)
             class Variable;
             /// This class aims to store in the cache all of the dateTime already requested to the variable.
-            class VariableCacheController : public QObject {
+            class SCIQLOP_CORE_EXPORT VariableCacheController : public QObject {
                 Q_OBJECT
             public:
                 explicit VariableCacheController(QObject *parent = 0);
                 void addDateTime(std::shared_ptr<Variable> variable, const SqpDateTime &dateTime);
                 /// Clears cache concerning a variable
                 void clear(std::shared_ptr<Variable> variable) noexcept;
                 /// Return all of the SqpDataTime part of the dateTime whose are not in the cache
                 QVector<SqpDateTime> provideNotInCacheDateTimeList(std::shared_ptr<Variable> variable,
                                                                    const SqpDateTime &dateTime);
                 QVector<SqpDateTime> dateCacheList(std::shared_ptr<Variable> variable) const noexcept;
                 void displayCache(std::shared_ptr<Variable> variable) const;
             private:
                 class VariableCacheControllerPrivate;
                 spimpl::unique_impl_ptr<VariableCacheControllerPrivate> impl;
             };
             #endif // SCIQLOP_VARIABLECACHECONTROLLER_H

core/include/Variable/VariableController.h +3 -1

             #ifndef SCIQLOP_VARIABLECONTROLLER_H
             #define SCIQLOP_VARIABLECONTROLLER_H
+            #include "CoreGlobal.h"
             #include <Data/SqpDateTime.h>
             #include <QLoggingCategory>
             #include <QObject>
             #include <Common/spimpl.h>
             class IDataProvider;
             class QItemSelectionModel;
             class TimeController;
             class Variable;
             class VariableModel;
             Q_DECLARE_LOGGING_CATEGORY(LOG_VariableController)
             /**
              * @brief The VariableController class aims to handle the variables in SciQlop.
              */
-            class VariableController : public QObject {
+            class SCIQLOP_CORE_EXPORT VariableController : public QObject {
                 Q_OBJECT
             public:
                 explicit VariableController(QObject *parent = 0);
                 virtual ~VariableController();
                 VariableModel *variableModel() noexcept;
                 QItemSelectionModel *variableSelectionModel() noexcept;
                 void setTimeController(TimeController *timeController) noexcept;
                 /**
                  * Deletes from the controller the variable passed in parameter.
                  *
                  * Delete a variable includes:
                  * - the deletion of the various references to the variable in SciQlop
                  * - the deletion of the model variable
                  * - the deletion of the provider associated with the variable
                  * - removing the cache associated with the variable
                  *
                  * @param variable the variable to delete from the controller.
                  */
                 void deleteVariable(std::shared_ptr<Variable> variable) noexcept;
                 /**
                  * Deletes from the controller the variables passed in parameter.
                  * @param variables the variables to delete from the controller.
                  * @sa deleteVariable()
                  */
                 void deleteVariables(const QVector<std::shared_ptr<Variable> > &variables) noexcept;
                 /**
                  * @brief abort the variable retrieve data progression
                  */
                 void abortProgress(std::shared_ptr<Variable> variable);
             signals:
                 /// Signal emitted when a variable is about to be deleted from the controller
                 void variableAboutToBeDeleted(std::shared_ptr<Variable> variable);
                 /// Signal emitted when a data acquisition is requested on a range for a variable
                 void rangeChanged(std::shared_ptr<Variable> variable, const SqpDateTime &range);
             public slots:
                 /// Request the data loading of the variable whithin dateTime
                 void onRequestDataLoading(std::shared_ptr<Variable> variable, const SqpDateTime &dateTime);
                 /**
                  * Creates a new variable and adds it to the model
                  * @param name the name of the new variable
                  * @param metadata the metadata of the new variable
                  * @param provider the data provider for the new variable
                  */
                 void createVariable(const QString &name, const QVariantHash &metadata,
                                     std::shared_ptr<IDataProvider> provider) noexcept;
                 /// Update the temporal parameters of every selected variable to dateTime
                 void onDateTimeOnSelection(const SqpDateTime &dateTime);
                 void onVariableRetrieveDataInProgress(QUuid identifier, double progress);
                 void onAbortProgressRequested(std::shared_ptr<Variable> variable);
                 void initialize();
                 void finalize();
             private:
                 void waitForFinish();
                 class VariableControllerPrivate;
                 spimpl::unique_impl_ptr<VariableControllerPrivate> impl;
             };
             #endif // SCIQLOP_VARIABLECONTROLLER_H

core/include/Variable/VariableModel.h +2 -1

             #ifndef SCIQLOP_VARIABLEMODEL_H
             #define SCIQLOP_VARIABLEMODEL_H
+            #include "CoreGlobal.h"
             #include <Data/SqpDateTime.h>
             #include <QAbstractTableModel>
             #include <QLoggingCategory>
             #include <Common/MetaTypes.h>
             #include <Common/spimpl.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_VariableModel)
             enum VariableRoles { ProgressRole = Qt::UserRole };
             class IDataSeries;
             class Variable;
             /**
              * @brief The VariableModel class aims to hold the variables that have been created in SciQlop
              */
-            class VariableModel : public QAbstractTableModel {
+            class SCIQLOP_CORE_EXPORT VariableModel : public QAbstractTableModel {
                 Q_OBJECT
             public:
                 explicit VariableModel(QObject *parent = nullptr);
                 /**
                  * Creates a new variable in the model
                  * @param name the name of the new variable
                  * @param dateTime the dateTime of the new variable
                  * @param metadata the metadata associated to the new variable
                  * @return the pointer to the new variable
                  */
                 std::shared_ptr<Variable> createVariable(const QString &name, const SqpDateTime &dateTime,
                                                          const QVariantHash &metadata) noexcept;
                 /**
                  * Deletes a variable from the model, if it exists
                  * @param variable the variable to delete
                  */
                 void deleteVariable(std::shared_ptr<Variable> variable) noexcept;
                 std::shared_ptr<Variable> variable(int index) const;
                 void setDataProgress(std::shared_ptr<Variable> variable, double progress);
                 // /////////////////////////// //
                 // QAbstractTableModel methods //
                 // /////////////////////////// //
                 virtual int columnCount(const QModelIndex &parent = QModelIndex{}) const override;
                 virtual int rowCount(const QModelIndex &parent = QModelIndex{}) const override;
                 virtual QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
                 virtual QVariant headerData(int section, Qt::Orientation orientation,
                                             int role = Qt::DisplayRole) const override;
                 void abortProgress(const QModelIndex &index);
             signals:
                 void abortProgessRequested(std::shared_ptr<Variable> variable);
             private:
                 class VariableModelPrivate;
                 spimpl::unique_impl_ptr<VariableModelPrivate> impl;
             private slots:
                 /// Slot called when data of a variable has been updated
                 void onVariableUpdated() noexcept;
             };
             // Registers QVector<int> metatype so it can be used in VariableModel::dataChanged() signal
             SCIQLOP_REGISTER_META_TYPE(QVECTOR_INT_REGISTRY, QVector<int>)
             #endif // SCIQLOP_VARIABLEMODEL_H

core/include/Visualization/VisualizationController.h +3 -1

             #ifndef SCIQLOP_VISUALIZATIONCONTROLLER_H
             #define SCIQLOP_VISUALIZATIONCONTROLLER_H
+            #include "CoreGlobal.h"
             #include <Data/SqpDateTime.h>
             #include <QLoggingCategory>
             #include <QObject>
             #include <QUuid>
             #include <Common/spimpl.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationController)
             class DataSourceItem;
             class Variable;
             /**
              * @brief The VisualizationController class aims to make the link between SciQlop and its plugins.
              * This is the intermediate class that SciQlop has to use in the way to connect a data source.
              * Please first use register method to initialize a plugin specified by its metadata name (JSON
              * plugin source) then others specifics method will be able to access it. You can load a data source
              * driver plugin then create a data source.
              */
-            class VisualizationController : public QObject {
+            class SCIQLOP_CORE_EXPORT VisualizationController : public QObject {
                 Q_OBJECT
             public:
                 explicit VisualizationController(QObject *parent = 0);
                 virtual ~VisualizationController();
             signals:
                 /// Signal emitted when a variable is about to be deleted from SciQlop
                 void variableAboutToBeDeleted(std::shared_ptr<Variable> variable);
                 /// Signal emitted when a data acquisition is requested on a range for a variable
                 void rangeChanged(std::shared_ptr<Variable> variable, const SqpDateTime &range);
             public slots:
                 /// Manage init/end of the controller
                 void initialize();
                 void finalize();
             private:
                 void waitForFinish();
                 class VisualizationControllerPrivate;
                 spimpl::unique_impl_ptr<VisualizationControllerPrivate> impl;
             };
             #endif // SCIQLOP_VISUALIZATIONCONTROLLER_H

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