HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r1485:4f6ae2f1ca26

Added cpp_utils as subproject and removed few warnings...

jeandet -

r1485:4f6ae2f1ca26

parent child

Context file:

r1485:4f6ae2f1ca26

app/PySide2-bindings/meson.build +2 -1

             shiboken2 = find_program('shiboken2')
             qmake = find_program('qmake-qt5','qmake')
             pymod = import('python')
             python3 = pymod.find_installation('python3', modules:['PySide2','shiboken2', 'shiboken2_generator'])
             qt5_modules = ['QtCore','QtGui','QtWidgets']
             qt_headers_path = run_command(qmake, '-query', 'QT_INSTALL_HEADERS').stdout().strip('\n')
             generated_srcs  = run_command(python3, 'src_list.py', 'meson').stdout().split(';')
             modules_arg = '--modules=@0@'.format(','.join(qt5_modules))
             shiboken2_build_flags = run_command(python3, 'shiboken-helper.py', '--includes', modules_arg).stdout().strip('\n').split(' ')
             shiboken2_link_flags  = run_command(python3, 'shiboken-helper.py', '--libs', modules_arg).stdout().strip('\n').split(' ')
             shiboken2_typesystem  = run_command(python3, 'shiboken-helper.py', '--typesystem').stdout().strip('\n')
             sciqlop_bindings_incs = shiboken2_build_flags + [
                 '-I'+meson.current_source_dir()+'/../../gui/include',
                 '-I'+meson.current_source_dir()+'/../../core/include',
                 '-I'+meson.current_source_dir()+'/../../subprojects/TimeSeries/include',
+                '-I'+meson.current_source_dir()+'/../../subprojects/cpp_utils/include',
                 '-I'+python3.get_path('include'),
                 '-I'+qt_headers_path
                 ]
             foreach mod:qt5_modules
                 sciqlop_bindings_incs += ['-I'+qt_headers_path+'/'+mod]
             endforeach
             sciqlop_bindings_src = files('bindings.h', 'PyDataProvider.h', 'numpy_wrappers.h', 'numpy_wrappers.cpp')
             subdir('SciQLopBindings')
             shiboken_dep = declare_dependency(compile_args: shiboken2_build_flags, link_args: shiboken2_link_flags)
             sciqlop_bindings = python3.extension_module('SciQLopBindings',sciqlop_bindings_src,shiboken2_generator_out,
-                    dependencies : [sciqlop_app_dep, python3.dependency(), shiboken_dep],
+                    dependencies : [sciqlop_app_dep, python3.dependency(), shiboken_dep, cpp_utils_dep],
             )
             configure_file(input:'main.py', output:'main.py', copy:true)
             configure_file(input:'TestPlugin.py', output:'TestPlugin.py', copy:true)
             executable('sciqlop', 'main.cpp', dependencies :python3.dependency())

app/PySide2-bindings/numpy_wrappers.h +4 0

             #ifndef NUMPY_WRAPPERS_H
             #define NUMPY_WRAPPERS_H
             #include <Data/ScalarTimeSerie.h>
             #include <Data/VectorTimeSerie.h>
             #define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
             #if defined(slots) && (defined(__GNUC__) || defined(_MSC_VER) || defined(__clang__))
             #pragma push_macro("slots")
             #undef slots
             extern "C"
             {
             /*
              * Python 2 uses the "register" keyword, which is deprecated in C++ 11
              * and forbidden in C++17.
              */
             #if defined(__clang__)
             #pragma clang diagnostic push
             #pragma clang diagnostic ignored "-Wdeprecated-register"
             #endif
             #include <Python.h>
             #include <numpy/arrayobject.h>
             #if defined(__clang__)
             #pragma clang diagnostic pop
             #endif
             }
             #else
             #include <Python.h>
             #include <numpy/arrayobject.h>
             #endif
             #include <assert.h>
             #include <map>
+            #include <warnings.h>
             inline int init_numpy()
             {
+                DISABLE_WARNING_PUSH
+                DISABLE_WARNING_CONVERSION_NULL
                 import_array(); // PyError if not successful
+                DISABLE_WARNING_POP
                 return 0;
             }
             const static int numpy_initialized = init_numpy();
             template <typename dest_type = PyObject>
             struct PyObjectWrapper
             {
             private:
                 PyObject* _py_obj = nullptr;
                 void inc_refcount() { Py_XINCREF(_py_obj); }
                 void dec_refcount()
                 {
                     Py_XDECREF(_py_obj);
                     _py_obj = nullptr;
                 }
             public:
                 PyObjectWrapper() : _py_obj { nullptr } {}
                 PyObjectWrapper(const PyObjectWrapper& other) : _py_obj { other._py_obj } { inc_refcount(); }
                 PyObjectWrapper(PyObjectWrapper&& other) : _py_obj { other._py_obj } { inc_refcount(); }
                 explicit PyObjectWrapper(PyObject* obj) : _py_obj { obj } { inc_refcount(); }
                 ~PyObjectWrapper() { dec_refcount(); }
                 PyObjectWrapper& operator=(PyObjectWrapper&& other)
                 {
                     dec_refcount();
                     this->_py_obj = other._py_obj;
                     inc_refcount();
                     return *this;
                 }
                 PyObjectWrapper& operator=(const PyObjectWrapper& other)
                 {
                     dec_refcount();
                     this->_py_obj = other._py_obj;
                     inc_refcount();
                     return *this;
                 }
                 PyObject* py_object() { return _py_obj; }
                 inline dest_type* get() { return reinterpret_cast<dest_type*>(_py_obj); }
                 inline bool is_null() { return _py_obj == nullptr; }
             };
             struct NpArray_view
             {
             private:
                 PyObjectWrapper<PyArrayObject> _py_obj;
                 NpArray_view(const NpArray_view&& other) = delete;
             public:
                 static bool isNpArray(PyObject* obj)
                 {
                     auto arr = reinterpret_cast<PyArrayObject*>(obj);
                     auto is_c_aray = obj && PyArray_Check(arr) && PyArray_ISCARRAY(arr);
                     return is_c_aray;
                 }
                 NpArray_view() : _py_obj { nullptr } {}
                 NpArray_view(const NpArray_view& other) : _py_obj { other._py_obj } {}
                 NpArray_view(NpArray_view&& other) : _py_obj { other._py_obj } {}
                 explicit NpArray_view(PyObject* obj) : _py_obj { obj }
                 {
                     assert(isNpArray(obj));
                     assert(PyArray_ISFLOAT(_py_obj.get()));
                 }
                 NpArray_view& operator=(const NpArray_view& other)
                 {
                     this->_py_obj = other._py_obj;
                     return *this;
                 }
                 NpArray_view& operator=(NpArray_view&& other)
                 {
                     this->_py_obj = other._py_obj;
                     return *this;
                 }
                 std::vector<std::size_t> shape()
                 {
                     std::vector<std::size_t> shape;
                     if (!_py_obj.is_null())
                     {
                         if (int ndim = PyArray_NDIM(_py_obj.get()); ndim > 0)
                         {
                             if (ndim < 10)
                             {
                                 shape.resize(ndim);
                                 std::copy_n(PyArray_SHAPE(_py_obj.get()), ndim, std::begin(shape));
                             }
                         }
                     }
                     return shape;
                 }
                 std::size_t ndim()
                 {
                     if (!_py_obj.is_null())
                     {
                         return static_cast<std::size_t>(PyArray_NDIM(_py_obj.get()));
                     }
                     return 0;
                 }
                 std::size_t size(std::size_t index = 0)
                 {
                     if (!_py_obj.is_null())
                     {
                         if (index < static_cast<std::size_t>(PyArray_NDIM(_py_obj.get())))
                         {
                             return PyArray_SHAPE(_py_obj.get())[index];
                         }
                     }
                     return 0;
                 }
                 std::size_t flat_size()
                 {
                     auto s = this->shape();
                     return std::accumulate(
                         std::cbegin(s), std::cend(s), 1, [](const auto& a, const auto& b) { return a * b; });
                 }
                 double data(std::size_t pos)
                 {
                     if (!_py_obj.is_null())
                     {
                         return reinterpret_cast<double*>(PyArray_DATA(_py_obj.get()))[pos];
                     }
                     return nan("NAN");
                 }
                 std::vector<double> to_std_vect()
                 {
                     assert(!this->_py_obj.is_null());
                     auto sz = flat_size();
                     std::vector<double> v(sz);
                     auto d_ptr = reinterpret_cast<double*>(PyArray_DATA(_py_obj.get()));
                     std::copy(d_ptr, d_ptr + sz, std::begin(v));
                     return v;
                 }
                 std::vector<VectorTimeSerie::raw_value_type> to_std_vect_vect()
                 {
                     auto sz = size(0);
                     std::vector<VectorTimeSerie::raw_value_type> v(sz);
                     if (sz)
                     {
                         assert(ndim() == 2);
                         assert(size(1) == 3);
                         auto d_ptr
                             = reinterpret_cast<VectorTimeSerie::raw_value_type*>(PyArray_DATA(_py_obj.get()));
                         std::copy(d_ptr, d_ptr + sz, std::begin(v));
                     }
                     return v;
                 }
                 PyObject* py_object() { return _py_obj.py_object(); }
             };
             struct NpArray
             {
                 std::vector<std::size_t> shape;
                 std::vector<double> data;
                 static bool isNpArray(PyObject* obj) { return NpArray_view::isNpArray(obj); }
                 NpArray() = default;
                 explicit NpArray(PyObject* obj)
                 {
                     if (obj)
                     {
                         NpArray_view view { obj };
                         shape = view.shape();
                         data = view.to_std_vect();
                     }
                 }
                 inline std::size_t ndim() { return shape.size(); }
                 std::size_t size(std::size_t index = 0)
                 {
                     if (index < shape.size())
                         return shape[index];
                     return 0;
                 }
                 std::size_t flat_size()
                 {
                     return std::accumulate(std::cbegin(shape), std::cend(shape), 1,
                         [](const auto& a, const auto& b) { return a * b; });
                 }
                 // TODO temporary hack should find a way to avoid this copy
                 std::vector<VectorTimeSerie::raw_value_type> to_std_vect_vect()
                 {
                     auto sz = size(0);
                     std::vector<VectorTimeSerie::raw_value_type> v(sz);
                     if (sz)
                     {
                         assert(ndim() == 2);
                         assert(size(1) == 3);
                         auto d_ptr = reinterpret_cast<VectorTimeSerie::raw_value_type*>(data.data());
                         std::copy(d_ptr, d_ptr + sz, std::begin(v));
                     }
                     return v;
                 }
                 // TODO maybe ;)
                 PyObject* py_object() { return nullptr; }
             };
             inline int test_np_array(NpArray& arr)
             {
                 auto shape = arr.shape;
                 std::cout << "len(shape)=" << shape.size() << std::endl;
                 std::for_each(std::cbegin(shape), std::cend(shape), [](auto sz) {
                     static int i = 0;
                     std::cout << "shape[" << i++ << "]=" << sz << std::endl;
                 });
                 auto flatsize = std::accumulate(std::cbegin(shape), std::cend(shape), 0);
                 for (auto i = 0; i < flatsize; i++)
                 {
                     std::cout << "data[" << i << "]=" << arr.data[i] << std::endl;
                 }
                 return 1;
             }
             #endif //#ifndef NUMPY_WRAPPERS_H

gui/include/SqpApplication.h 0 -2

             #ifndef SCIQLOP_SQPAPPLICATION_H
             #define SCIQLOP_SQPAPPLICATION_H
             #include "SqpApplication.h"
             #include <QAction>
             #include <QApplication>
             #include <QLoggingCategory>
             #include <QMenuBar>
             #include <QProxyStyle>
             #include <QStyleOption>
             #include <QWidget>
             #include <QWidgetAction>
             #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;
             class NetworkController;
             class TimeController;
             class VariableController;
             class VariableController2;
             class VariableModel2;
             class DragDropGuiController;
             class ActionsGuiController;
             class CatalogueController;
             /* stolen from here https://forum.qt.io/topic/90403/show-tooltip-immediatly/6 */
             class MyProxyStyle : public QProxyStyle
             {
             public:
                 using QProxyStyle::QProxyStyle;
                 int styleHint(StyleHint hint, const QStyleOption* option = nullptr,
                     const QWidget* widget = nullptr, QStyleHintReturn* returnData = nullptr) const override
                 {
-                    if (widget)
-                        auto cname = widget->metaObject()->className();
                     if (hint == QStyle::SH_ToolButton_PopupDelay && widget
                         /*&& widget->inherits(QWidgetAction::staticMetaObject.className())*/)
                     {
                         return 0;
                     }
                     return QProxyStyle::styleHint(hint, option, widget, returnData);
                 }
             };
             /**
              * @brief The SqpApplication 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 load 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 SqpApplication : public QApplication
             {
                 Q_OBJECT
             public:
                 explicit SqpApplication(int& argc, char** argv);
                 ~SqpApplication() override;
                 void initialize();
                 /// Accessors for the differents sciqlop controllers
                 DataSourceController& dataSourceController() noexcept;
                 NetworkController& networkController() noexcept;
                 TimeController& timeController() noexcept;
                 VariableController2& variableController() noexcept;
                 std::shared_ptr<VariableController2> variableControllerOwner() noexcept;
                 CatalogueController& catalogueController() noexcept;
                 /// Accessors for the differents sciqlop helpers, these helpers classes are like controllers but
                 /// doesn't live in a thread and access gui
                 DragDropGuiController& dragDropGuiController() noexcept;
                 ActionsGuiController& actionsGuiController() noexcept;
                 enum class PlotsInteractionMode
                 {
                     None,
                     ZoomBox,
                     DragAndDrop,
                     SelectionZones
                 };
                 enum class PlotsCursorMode
                 {
                     NoCursor,
                     Vertical,
                     Temporal,
                     Horizontal,
                     Cross
                 };
                 PlotsInteractionMode plotsInteractionMode() const;
                 void setPlotsInteractionMode(PlotsInteractionMode mode);
                 PlotsCursorMode plotsCursorMode() const;
                 void setPlotsCursorMode(PlotsCursorMode mode);
             private:
                 class SqpApplicationPrivate;
                 spimpl::unique_impl_ptr<SqpApplicationPrivate> impl;
             };
             inline SqpApplication* SqpApplication_ctor()
             {
                 static int argc;
                 static char** argv;
                 return new SqpApplication(argc, argv);
             }
             #endif // SCIQLOP_SQPAPPLICATION_H

gui/tests/catalogue/browser/main.cpp +1 0

             #include <QMainWindow>
             #include <QObject>
             #include <QScreen>
             #include <QString>
             #include <QWheelEvent>
             #include <QtTest>
             #include <cstdlib>
             #include <Common/cpp_utils.h>
             #include <SqpApplication.h>
             #include <GUITestUtils.h>
             #include <Catalogue/CatalogueController.h>
             #include <Catalogue2/browser.h>
             template <int EventsCount = 1000>
             auto build_CatalogueBrowser_test()
             {
                 sqpApp->catalogueController().add("test");
                 sqpApp->catalogueController().add("stuff");
                 sqpApp->catalogueController().add("default");
                 sqpApp->catalogueController().add("new catalogue", "default");
                 auto catalogue = sqpApp->catalogueController().add("new catalogue2", "default");
                 for (auto _ : std::array<char, EventsCount>())
                 {
+                    (void)_;
                     static int i = 0;
                     auto event = CatalogueController::make_event_ptr();
                     event->name = std::string("Event ") + std::to_string(i++);
                     event->tags = { "tag1", "tag2" };
                     event->products = { CatalogueController::Event_t::Product_t {
                                             std::string("Product2") + std::to_string(rand() % 30),
                                             static_cast<double>(1532357932 + rand() % 100),
                                             static_cast<double>(1532358932 + rand() % 100) },
                         CatalogueController::Event_t::Product_t {
                             std::string("Product2") + std::to_string(rand() % 30),
                             static_cast<double>(1532357932 + rand() % 200),
                             static_cast<double>(1532358932 + rand() % 200) },
                         CatalogueController::Event_t::Product_t {
                             std::string("Product2") + std::to_string(rand() % 30),
                             static_cast<double>(1532357932 + rand() % 70),
                             static_cast<double>(1532358932 + rand() % 70) } };
                     catalogue->add(event);
                 }
                 return std::make_unique<CataloguesBrowser>();
             }
             class A_CatalogueBrowser : public QObject
             {
                 Q_OBJECT
             public:
                 explicit A_CatalogueBrowser(QObject* parent = Q_NULLPTR) : QObject(parent) {}
             private slots:
                 void can_sort_events()
                 {
                     auto w = build_CatalogueBrowser_test();
                     QVERIFY(prepare_gui_test(w.get()));
                     // GET_CHILD_WIDGET_FOR_GUI_TESTS((*w.get()),,,)
                     for (int i = 0; i < 1000000; i++)
                     {
                         QThread::usleep(100);
                         QCoreApplication::processEvents();
                     }
                 }
             };
             QT_BEGIN_NAMESPACE
             QTEST_ADD_GPU_BLACKLIST_SUPPORT_DEFS
             QT_END_NAMESPACE
             int main(int argc, char* argv[])
             {
                 Q_INIT_RESOURCE(sqpguiresources);
                 SqpApplication app { argc, argv };
                 app.setAttribute(Qt::AA_Use96Dpi, true);
                 QTEST_DISABLE_KEYPAD_NAVIGATION;
                 QTEST_ADD_GPU_BLACKLIST_SUPPORT;
                 A_CatalogueBrowser tc;
                 QTEST_SET_MAIN_SOURCE_PATH;
                 return QTest::qExec(&tc, argc, argv);
             }
             #include "main.moc"

meson.build +2 0

             project('SciQLOP', 'cpp',default_options : ['cpp_std=c++17'], meson_version:'>=0.51.0')
             add_global_arguments('-DSCIQLOP_VERSION="1.1.0"', language : 'cpp')
             qt5 = import('qt5')
             qt5core = dependency('qt5', modules : 'Core')
             qt5widgets = dependency('qt5', modules : 'Widgets')
             qt5gui = dependency('qt5', modules : 'Gui')
             qt5svg = dependency('qt5', modules : 'Svg')
             qt5xml = dependency('qt5', modules : 'Xml')
             qt5network = dependency('qt5', modules : 'Network')
             qt5printsupport = dependency('qt5', modules : 'PrintSupport')
             qt5Concurrent = dependency('qt5', modules : 'Concurrent')
             qt5test = dependency('qt5', modules : 'Test')
+            cpp_utils_dep = dependency('cpp_utils', fallback:['cpp_utils','cpp_utils_dep'])
             moc = find_program('moc-qt5','moc')
             rcc = find_program('rcc-qt5','rcc')
             if build_machine.system()=='darwin'
               add_global_link_arguments('-headerpad_max_install_names', language : 'cpp')
               install_data('build_cfg/mac/sciqlopLOGO.icns', install_dir : 'Contents/Resources')
               install_data('build_cfg/mac/Info.plist', install_dir : 'Contents')
               meson.add_install_script('build_cfg/mac/install_script.sh')
             elif host_machine.system()=='windows'
               meson.add_install_script('build_cfg/windows/install_script.sh')
             elif host_machine.system()=='linux'
               install_data('app/resources/sciqlopLOGO.svg', install_dir : 'share/icons/hicolor/scalable/')
               install_data('app/resources/SciQLOP.desktop', install_dir : 'share/applications')
               install_data('app/resources/SciQLOP.appdata.xml', install_dir : 'share/metainfo')
             endif
             # Sets AMDA server that will be used during execution.
             # Available values are:
             # - "default": default AMDA server
             # - "amdatest": AMDA test server
             # - "hybrid": use both the default server and the test server (the server used is relative to each product, according to its "server" property in the JSON file)
             # - "localhost": use local AMDA server
             # Any other value will lead to the use of the default server
             add_project_arguments('-DSCIQLOP_AMDA_SERVER="hybrid"', language : 'cpp')
             subdir('core')
             subdir('gui')
             subdir('plugins')
             subdir('app')
             cppcheck = find_program('cppcheck', required : false)
             if cppcheck.found()
               run_target('cppcheck',
                           command : [cppcheck, '--enable=all',
                           '--project=' + join_paths(meson.build_root(), 'compile_commands.json')]
                           )
             endif

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