##// END OF EJS Templates
HG_REPOSITORIES » LPP » SciQLOP_Repos » SciQLop
RSS
Remove coverage from windows build...
perrinel -
r76:6f69134168e5
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,38 +1,38
1 1 /*------------------------------------------------------------------------------
2 2 -- This file is a part of the QLop Software
3 3 -- Copyright (C) 2015, Plasma Physics Laboratory - CNRS
4 4 --
5 5 -- This program is free software; you can redistribute it and/or modify
6 6 -- it under the terms of the GNU General Public License as published by
7 7 -- the Free Software Foundation; either version 2 of the License, or
8 8 -- (at your option) any later version.
9 9 --
10 10 -- This program is distributed in the hope that it will be useful,
11 11 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
12 12 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 13 -- GNU General Public License for more details.
14 14 --
15 15 -- You should have received a copy of the GNU General Public License
16 16 -- along with this program; if not, write to the Free Software
17 17 -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 18 -------------------------------------------------------------------------------*/
19 19 /*-- Author : Alexis Jeandet
20 20 -- Mail : alexis.jeandet@member.fsf.org
21 21 ----------------------------------------------------------------------------*/
22 #include "mainwindow.h"
22 #include "MainWindow.h"
23 23 #include <QProcessEnvironment>
24 24 #include <QThread>
25 25 #include <SqpApplication.h>
26 26 #include <qglobal.h>
27 27
28 28 int main(int argc, char *argv[])
29 29 {
30 30 SqpApplication a{argc, argv};
31 31 SqpApplication::setOrganizationName("LPP");
32 32 SqpApplication::setOrganizationDomain("lpp.fr");
33 33 SqpApplication::setApplicationName("SciQLop");
34 34 MainWindow w;
35 35 w.show();
36 36
37 37 return a.exec();
38 38 }
Show file before | Show file after | Hide comments
@@ -1,145 +1,147
1 1
2 2 ## core - CMakeLists.txt
3 3 STRING(TOLOWER ${CMAKE_PROJECT_NAME} LIBRARY_PREFFIX)
4 4 SET(SQPCORE_LIBRARY_NAME "${LIBRARY_PREFFIX}_core${DEBUG_SUFFIX}")
5 5 SET(SOURCES_DIR "${CMAKE_CURRENT_SOURCE_DIR}/src/")
6 6 SET(INCLUDES_DIR "${CMAKE_CURRENT_SOURCE_DIR}/include/")
7 7
8 8 # Include core directory
9 9 include_directories("${INCLUDES_DIR}")
10 10
11 11 # Set a variable to display a warning in the version files.
12 12 SET(SCIQLOP_CMAKE_GENERATION_WARNING "DON'T CHANGE THIS FILE. AUTOGENERATED BY CMAKE.")
13 13 # Generate the version file from the cmake version variables. The version
14 14 # variables are defined in the cmake/sciqlop_version.cmake file.
15 15 CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/resources/Version.h.in"
16 16 "${INCLUDES_DIR}/Version.h")
17 17 CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/resources/Version.cpp.in"
18 18 "${SOURCES_DIR}/Version.cpp")
19 19
20 20 # Find dependent modules
21 21 find_package(sciqlop-plugin)
22 22 INCLUDE_DIRECTORIES(${SCIQLOP-PLUGIN_INCLUDE_DIR})
23 23
24 24 #
25 25 # Find Qt modules
26 26 #
27 27 SCIQLOP_FIND_QT(Core)
28 28
29 29 #
30 30 # Compile the library library
31 31 #
32 32 FILE (GLOB_RECURSE MODULE_SOURCES
33 33 ${INCLUDES_DIR}/*.h
34 34 ${SOURCES_DIR}/*.c
35 35 ${SOURCES_DIR}/*.cpp
36 36 ${SOURCES_DIR}/*.h)
37 37
38 38 ADD_LIBRARY(${SQPCORE_LIBRARY_NAME} ${MODULE_SOURCES})
39 39 set_property(TARGET ${SQPCORE_LIBRARY_NAME} PROPERTY CXX_STANDARD 14)
40 40 set_property(TARGET ${SQPCORE_LIBRARY_NAME} PROPERTY CXX_STANDARD_REQUIRED ON)
41 41 TARGET_LINK_LIBRARIES(${SQPCORE_LIBRARY_NAME})
42 42 qt5_use_modules(${SQPCORE_LIBRARY_NAME} Core)
43 43
44 44 # From cmake documentation: http://www.cmake.org/cmake/help/v3.0/manual/cmake-buildsystem.7.html
45 45 # Entries in the COMPILE_DEFINITIONS are prefixed with -D or /D and added to the compile line in an unspecified order.
46 46 # The DEFINE_SYMBOL target property is also added as a compile definition as a special convenience case for SHARED and MODULE library targets
47 47 IF(BUILD_SHARED_LIBS)
48 48 SET_TARGET_PROPERTIES(${SQPCORE_LIBRARY_NAME} PROPERTIES COMPILE_DEFINITIONS "SCIQLOP_EXPORT")
49 49 ELSE()
50 50 TARGET_COMPILE_DEFINITIONS(${SQPCORE_LIBRARY_NAME} PUBLIC "SCIQLOP_STATIC_LIBRARIES")
51 51 ENDIF()
52 52
53 53 # Set the variable to parent scope so that the other projects can copy the
54 54 # dependent shared libraries
55 55 SCIQLOP_SET_TO_PARENT_SCOPE(SQPCORE_LIBRARY_NAME)
56 56
57 57 # Copy extern shared libraries to the lib folder
58 58 SCIQLOP_COPY_TO_TARGET(LIBRARY ${SQPCORE_LIBRARY_NAME} ${EXTERN_SHARED_LIBRARIES})
59 59
60 60 # Add the files to the list of files to be analyzed
61 61 LIST(APPEND CHECKSTYLE_INPUT_FILES ${MODULE_SOURCES})
62 62 SCIQLOP_SET_TO_PARENT_SCOPE(CHECKSTYLE_INPUT_FILES)
63 63 # Vera++ exclusion files
64 64 LIST(APPEND CHECKSTYLE_EXCLUSION_FILES ${CMAKE_CURRENT_SOURCE_DIR}/vera-exclusions/exclusions.txt)
65 65 SCIQLOP_SET_TO_PARENT_SCOPE(CHECKSTYLE_EXCLUSION_FILES)
66 66
67 67 #
68 68 # Compile the tests
69 69 #
70 70 IF(BUILD_TESTS)
71 71 INCLUDE_DIRECTORIES(${SOURCES_DIR})
72 72 FILE (GLOB_RECURSE TESTS_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/Test*.cpp)
73 73 FILE (GLOB_RECURSE TESTS_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/Test*.h)
74 74 SET( TEST_LIBRARIES ${SQPCORE_LIBRARY_NAME})
75 75
76 76 SET(TARGETS_COV)
77 77 FOREACH( testFile ${TESTS_SOURCES} )
78 78 GET_FILENAME_COMPONENT( testDirectory ${testFile} DIRECTORY )
79 79 GET_FILENAME_COMPONENT( testName ${testFile} NAME_WE )
80 80
81 81 # Add to the list of sources files all the sources in the same
82 82 # directory that aren't another test
83 83 FILE (GLOB currentTestSources
84 84 ${testDirectory}/*.c
85 85 ${testDirectory}/*.cpp
86 86 ${testDirectory}/*.h)
87 87 LIST (REMOVE_ITEM currentTestSources ${TESTS_SOURCES})
88 88 # LIST (REMOVE_ITEM currentTestSources ${TESTS_HEADERS})
89 89
90 90 ADD_EXECUTABLE(${testName} ${testFile} ${currentTestSources})
91 91 set_property(TARGET ${testName} PROPERTY CXX_STANDARD 14)
92 92 set_property(TARGET ${testName} PROPERTY CXX_STANDARD_REQUIRED ON)
93 93 TARGET_LINK_LIBRARIES( ${testName} ${TEST_LIBRARIES} )
94 94 qt5_use_modules(${testName} Test)
95 95
96 96 ADD_TEST( NAME ${testName} COMMAND ${testName} )
97 97
98 98 SCIQLOP_COPY_TO_TARGET(RUNTIME ${testName} ${EXTERN_SHARED_LIBRARIES})
99 99 set(Coverage_NAME ${testName})
100 SETUP_TARGET_FOR_COVERAGE(TARGET ${testName}_coverage OUTPUT ${testFile}-path NAME ${testFile} EXECUTABLE ${testName})
101 LIST( APPEND TARGETS_COV ${testName}_coverage)
100 if(UNIX)
101 SETUP_TARGET_FOR_COVERAGE(TARGET ${testName}_coverage OUTPUT ${testFile}-path NAME ${testFile} EXECUTABLE ${testName})
102 LIST( APPEND TARGETS_COV ${testName}_coverage)
103 endif(UNIX)
102 104
103 105 ENDFOREACH( testFile )
104 106
105 107 add_custom_target(coverage)
106 108
107 109 FOREACH( target_cov ${TARGETS_COV} )
108 110 add_custom_command(TARGET coverage PRE_BUILD COMMAND make ${target_cov})
109 111 ENDFOREACH( target_cov )
110 112
111 113 LIST(APPEND testFilesToFormat ${TESTS_SOURCES})
112 114 LIST(APPEND testFilesToFormat ${TESTS_HEADERS})
113 115 LIST(APPEND FORMATTING_INPUT_FILES ${testFilesToFormat})
114 116 SCIQLOP_SET_TO_PARENT_SCOPE(FORMATTING_INPUT_FILES)
115 117 ENDIF(BUILD_TESTS)
116 118
117 119 #
118 120 # Set the files that must be formatted by clang-format.
119 121 #
120 122 LIST (APPEND FORMATTING_INPUT_FILES ${MODULE_SOURCES})
121 123 SCIQLOP_SET_TO_PARENT_SCOPE(FORMATTING_INPUT_FILES)
122 124
123 125 #
124 126 # Set the directories that doxygen must browse to generate the
125 127 # documentation.
126 128 #
127 129 # Source directories:
128 130 LIST (APPEND DOXYGEN_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/docs")
129 131 LIST (APPEND DOXYGEN_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/src")
130 132 SCIQLOP_SET_TO_PARENT_SCOPE(DOXYGEN_INPUT_DIRS)
131 133 # Source directories to exclude from the documentation generation
132 134 #LIST (APPEND DOXYGEN_EXCLUDE_PATTERNS "${CMAKE_CURRENT_SOURCE_DIR}/path/to/subdir/*")
133 135 SCIQLOP_SET_TO_PARENT_SCOPE(DOXYGEN_EXCLUDE_PATTERNS)
134 136
135 137 #
136 138 # Set the directories with the sources to analyze and propagate the
137 139 # modification to the parent scope
138 140 #
139 141 # Source directories to analyze:
140 142 LIST (APPEND ANALYSIS_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/src")
141 143 LIST (APPEND ANALYSIS_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/tests")
142 144 SCIQLOP_SET_TO_PARENT_SCOPE(ANALYSIS_INPUT_DIRS)
143 145 # Source directories to exclude from the analysis
144 146 #LIST (APPEND ANALYSIS_EXCLUDE_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/path/to/subdir")
145 147 SCIQLOP_SET_TO_PARENT_SCOPE(ANALYSIS_EXCLUDE_DIRS)
Show file before | Show file after | Hide comments
@@ -1,462 +1,460
1 1 /*
2 2 ====================================================================
3 3 A Smart Pointer to IMPLementation (i.e. Smart PIMPL or just SPIMPL).
4 4 ====================================================================
5 5
6 6 Version: 1.1
7 7
8 8 Latest version:
9 9 https://github.com/oliora/samples/blob/master/spimpl.h
10 10 Rationale and description:
11 11 http://oliora.github.io/2015/12/29/pimpl-and-rule-of-zero.html
12 12
13 13 Copyright (c) 2015 Andrey Upadyshev (oliora@gmail.com)
14 14
15 15 Distributed under the Boost Software License, Version 1.0.
16 16 See http://www.boost.org/LICENSE_1_0.txt
17 17
18 18 Changes history
19 19 ---------------
20 20 v1.1:
21 21 - auto_ptr support is disabled by default for C++17 compatibility
22 22 v1.0:
23 23 - Released
24 24 */
25 25
26 26 #ifndef SPIMPL_H_
27 27 #define SPIMPL_H_
28 28
29 29 #include <cassert>
30 30 #include <memory>
31 31 #include <type_traits>
32 32
33 33 #if defined _MSC_VER && _MSC_VER < 1900 // MS Visual Studio before VS2015
34 34 #define SPIMPL_NO_CPP11_NOEXCEPT
35 35 #define SPIMPL_NO_CPP11_CONSTEXPR
36 36 #define SPIMPL_NO_CPP11_DEFAULT_MOVE_SPEC_FUNC
37 37 #endif
38 38
39 39 #if !defined SPIMPL_NO_CPP11_NOEXCEPT
40 40 #define SPIMPL_NOEXCEPT noexcept
41 41 #else
42 42 #define SPIMPL_NOEXCEPT
43 43 #endif
44 44
45 45 #if !defined SPIMPL_NO_CPP11_CONSTEXPR
46 46 #define SPIMPL_CONSTEXPR constexpr
47 47 #else
48 48 #define SPIMPL_CONSTEXPR
49 49 #endif
50 50
51 51 // define SPIMPL_HAS_AUTO_PTR to enable constructor and assignment operator that accept
52 52 // std::auto_ptr
53 53 // TODO: auto detect std::auto_ptr support
54 54
55 55
56 56 namespace spimpl {
57 57 namespace details {
58 58 template <class T>
59 59 T *default_copy(T *src)
60 60 {
61 61 static_assert(sizeof(T) > 0, "default_copy cannot copy incomplete type");
62 62 static_assert(!std::is_void<T>::value, "default_copy cannot copy incomplete type");
63 63 return new T(*src);
64 64 }
65 65
66 66 template <class T>
67 67 void default_delete(T *p) SPIMPL_NOEXCEPT
68 68 {
69 69 static_assert(sizeof(T) > 0, "default_delete cannot delete incomplete type");
70 70 static_assert(!std::is_void<T>::value, "default_delete cannot delete incomplete type");
71 71 delete p;
72 72 }
73 73
74 74 template <class T>
75 75 struct default_deleter {
76 76 using type = void (*)(T *);
77 77 };
78 78
79 79 template <class T>
80 80 using default_deleter_t = typename default_deleter<T>::type;
81 81
82 82 template <class T>
83 83 struct default_copier {
84 84 using type = T *(*)(T *);
85 85 };
86 86
87 87 template <class T>
88 88 using default_copier_t = typename default_copier<T>::type;
89 89
90 90 template <class T, class D, class C>
91 91 struct is_default_manageable
92 : public std::integral_constant<bool,
93 std::is_same<D, default_deleter_t<T> >::value
94 && std::is_same<C, default_copier_t<T> >::value> {
92 : public std::integral_constant<bool, std::is_same<D, default_deleter_t<T> >::value
93 && std::is_same<C, default_copier_t<T> >::value> {
95 94 };
96 95 }
97 96
98 97
99 98 template <class T, class Deleter = details::default_deleter_t<T>,
100 99 class Copier = details::default_copier_t<T> >
101 100 class impl_ptr {
102 101 private:
103 102 static_assert(!std::is_array<T>::value,
104 103 "impl_ptr specialization for arrays is not implemented");
105 104 struct dummy_t_ {
106 105 int dummy__;
107 106 };
108 107
109 108 public:
110 109 using pointer = T *;
111 110 using element_type = T;
112 111 using copier_type = typename std::decay<Copier>::type;
113 112 using deleter_type = typename std::decay<Deleter>::type;
114 113 using unique_ptr_type = std::unique_ptr<T, deleter_type>;
115 114 using is_default_manageable = details::is_default_manageable<T, deleter_type, copier_type>;
116 115
117 116 SPIMPL_CONSTEXPR impl_ptr() SPIMPL_NOEXCEPT : ptr_(nullptr, deleter_type{}),
118 117 copier_(copier_type{})
119 118 {
120 119 }
121 120
122 121 SPIMPL_CONSTEXPR impl_ptr(std::nullptr_t) SPIMPL_NOEXCEPT : impl_ptr() {}
123 122
124 123 template <class D, class C>
125 124 impl_ptr(pointer p, D &&d, C &&c,
126 125 typename std::enable_if<std::is_convertible<D, deleter_type>::value
127 126 && std::is_convertible<C, copier_type>::value,
128 127 dummy_t_>::type
129 128 = dummy_t_()) SPIMPL_NOEXCEPT : ptr_(std::move(p), std::forward<D>(d)),
130 129 copier_(std::forward<C>(c))
131 130 {
132 131 }
133 132
134 133 template <class U>
135 impl_ptr(U *u,
136 typename std::enable_if<std::is_convertible<U *, pointer>::value
137 && is_default_manageable::value,
138 dummy_t_>::type
139 = dummy_t_()) SPIMPL_NOEXCEPT
134 impl_ptr(U *u, typename std::enable_if<std::is_convertible<U *, pointer>::value
135 && is_default_manageable::value,
136 dummy_t_>::type
137 = dummy_t_()) SPIMPL_NOEXCEPT
140 138 : impl_ptr(u, &details::default_delete<T>, &details::default_copy<T>)
141 139 {
142 140 }
143 141
144 142 impl_ptr(const impl_ptr &r) : impl_ptr(r.clone()) {}
145 143
146 144 #ifndef SPIMPL_NO_CPP11_DEFAULT_MOVE_SPEC_FUNC
147 145 impl_ptr(impl_ptr &&r) SPIMPL_NOEXCEPT = default;
148 146 #else
149 147 impl_ptr(impl_ptr &&r) SPIMPL_NOEXCEPT : ptr_(std::move(r.ptr_)), copier_(std::move(r.copier_))
150 148 {
151 149 }
152 150 #endif
153 151
154 152 #ifdef SPIMPL_HAS_AUTO_PTR
155 153 template <class U>
156 impl_ptr(std::auto_ptr<U> &&u,
157 typename std::enable_if<std::is_convertible<U *, pointer>::value
158 && is_default_manageable::value,
159 dummy_t_>::type
160 = dummy_t_()) SPIMPL_NOEXCEPT : ptr_(u.release(), &details::default_delete<T>),
161 copier_(&details::default_copy<T>)
154 impl_ptr(std::auto_ptr<U> &&u, typename std::enable_if<std::is_convertible<U *, pointer>::value
155 && is_default_manageable::value,
156 dummy_t_>::type
157 = dummy_t_()) SPIMPL_NOEXCEPT
158 : ptr_(u.release(), &details::default_delete<T>),
159 copier_(&details::default_copy<T>)
162 160 {
163 161 }
164 162 #endif
165 163
166 164 template <class U>
167 165 impl_ptr(std::unique_ptr<U> &&u,
168 166 typename std::enable_if<std::is_convertible<U *, pointer>::value
169 167 && is_default_manageable::value,
170 168 dummy_t_>::type
171 169 = dummy_t_()) SPIMPL_NOEXCEPT : ptr_(u.release(), &details::default_delete<T>),
172 170 copier_(&details::default_copy<T>)
173 171 {
174 172 }
175 173
176 174 template <class U, class D, class C>
177 175 impl_ptr(std::unique_ptr<U, D> &&u, C &&c,
178 176 typename std::enable_if<std::is_convertible<U *, pointer>::value
179 177 && std::is_convertible<D, deleter_type>::value
180 178 && std::is_convertible<C, copier_type>::value,
181 179 dummy_t_>::type
182 180 = dummy_t_()) SPIMPL_NOEXCEPT : ptr_(std::move(u)),
183 181 copier_(std::forward<C>(c))
184 182 {
185 183 }
186 184
187 185 template <class U, class D, class C>
188 186 impl_ptr(impl_ptr<U, D, C> &&u,
189 187 typename std::enable_if<std::is_convertible<U *, pointer>::value
190 188 && std::is_convertible<D, deleter_type>::value
191 189 && std::is_convertible<C, copier_type>::value,
192 190 dummy_t_>::type
193 191 = dummy_t_()) SPIMPL_NOEXCEPT : ptr_(std::move(u.ptr_)),
194 192 copier_(std::move(u.copier_))
195 193 {
196 194 }
197 195
198 196 impl_ptr &operator=(const impl_ptr &r)
199 197 {
200 198 if (this == &r)
201 199 return *this;
202 200
203 201 return operator=(r.clone());
204 202 }
205 203
206 204 #ifndef SPIMPL_NO_CPP11_DEFAULT_MOVE_SPEC_FUNC
207 205 impl_ptr &operator=(impl_ptr &&r) SPIMPL_NOEXCEPT = default;
208 206 #else
209 207 impl_ptr &operator=(impl_ptr &&r) SPIMPL_NOEXCEPT
210 208 {
211 209 ptr_ = std::move(r.ptr_);
212 210 copier_ = std::move(r.copier_);
213 211 return *this;
214 212 }
215 213 #endif
216 214
217 215 template <class U, class D, class C>
218 216 typename std::enable_if<std::is_convertible<U *, pointer>::value
219 217 && std::is_convertible<D, deleter_type>::value
220 218 && std::is_convertible<C, copier_type>::value,
221 219 impl_ptr &>::type
222 220 operator=(impl_ptr<U, D, C> &&u) SPIMPL_NOEXCEPT
223 221 {
224 222 ptr_ = std::move(u.ptr_);
225 223 copier_ = std::move(u.copier_);
226 224 return *this;
227 225 }
228 226
229 227 template <class U, class D, class C>
230 228 typename std::enable_if<std::is_convertible<U *, pointer>::value
231 229 && std::is_convertible<D, deleter_type>::value
232 230 && std::is_convertible<C, copier_type>::value,
233 231 impl_ptr &>::type
234 232 operator=(const impl_ptr<U, D, C> &u)
235 233 {
236 234 return operator=(u.clone());
237 235 }
238 236
239 237 //
240 238
241 239 #ifdef SPIMPL_HAS_AUTO_PTR
242 240 template <class U>
243 241 typename std::enable_if<std::is_convertible<U *, pointer>::value
244 242 && is_default_manageable::value,
245 243 impl_ptr &>::type
246 244 operator=(std::auto_ptr<U> &&u) SPIMPL_NOEXCEPT
247 245 {
248 246 return operator=(impl_ptr(std::move(u)));
249 247 }
250 248 #endif
251 249
252 250 template <class U>
253 251 typename std::enable_if<std::is_convertible<U *, pointer>::value
254 252 && is_default_manageable::value,
255 253 impl_ptr &>::type
256 254 operator=(std::unique_ptr<U> &&u) SPIMPL_NOEXCEPT
257 255 {
258 256 return operator=(impl_ptr(std::move(u)));
259 257 }
260 258
261 259 impl_ptr clone() const
262 260 {
263 261 return impl_ptr(ptr_ ? copier_(ptr_.get()) : nullptr, ptr_.get_deleter(), copier_);
264 262 }
265 263
266 264 typename std::remove_reference<T>::type &operator*() const { return *ptr_; }
267 265 pointer operator->() const SPIMPL_NOEXCEPT { return get(); }
268 266 pointer get() const SPIMPL_NOEXCEPT { return ptr_.get(); }
269 267
270 268 void swap(impl_ptr &u) SPIMPL_NOEXCEPT
271 269 {
272 270 using std::swap;
273 271 ptr_.swap(u.ptr_);
274 272 swap(copier_, u.copier_);
275 273 }
276 274
277 275 pointer release() SPIMPL_NOEXCEPT { return ptr_.release(); }
278 276
279 277 unique_ptr_type release_unique() SPIMPL_NOEXCEPT { return std::move(ptr_); }
280 278
281 279 explicit operator bool() const SPIMPL_NOEXCEPT { return static_cast<bool>(ptr_); }
282 280
283 281 typename std::remove_reference<deleter_type>::type &get_deleter() SPIMPL_NOEXCEPT
284 282 {
285 283 return ptr_.get_deleter();
286 284 }
287 285 const typename std::remove_reference<deleter_type>::type &get_deleter() const SPIMPL_NOEXCEPT
288 286 {
289 287 return ptr_.get_deleter();
290 288 }
291 289
292 290 typename std::remove_reference<copier_type>::type &get_copier() SPIMPL_NOEXCEPT
293 291 {
294 292 return copier_;
295 293 }
296 294 const typename std::remove_reference<copier_type>::type &get_copier() const SPIMPL_NOEXCEPT
297 295 {
298 296 return copier_;
299 297 }
300 298
301 299 private:
302 300 unique_ptr_type ptr_;
303 301 copier_type copier_;
304 302 };
305 303
306 304
307 305 template <class T, class D, class C>
308 306 inline void swap(impl_ptr<T, D, C> &l, impl_ptr<T, D, C> &r) SPIMPL_NOEXCEPT
309 307 {
310 308 l.swap(r);
311 309 }
312 310
313 311
314 312 template <class T1, class D1, class C1, class T2, class D2, class C2>
315 313 inline bool operator==(const impl_ptr<T1, D1, C1> &l, const impl_ptr<T2, D2, C2> &r)
316 314 {
317 315 return l.get() == r.get();
318 316 }
319 317
320 318 template <class T1, class D1, class C1, class T2, class D2, class C2>
321 319 inline bool operator!=(const impl_ptr<T1, D1, C1> &l, const impl_ptr<T2, D2, C2> &r)
322 320 {
323 321 return !(l == r);
324 322 }
325 323
326 324 template <class T1, class D1, class C1, class T2, class D2, class C2>
327 325 inline bool operator<(const impl_ptr<T1, D1, C1> &l, const impl_ptr<T2, D2, C2> &r)
328 326 {
329 327 using P1 = typename impl_ptr<T1, D1, C1>::pointer;
330 328 using P2 = typename impl_ptr<T2, D2, C2>::pointer;
331 329 using CT = typename std::common_type<P1, P2>::type;
332 330 return std::less<CT>()(l.get(), r.get());
333 331 }
334 332
335 333 template <class T1, class D1, class C1, class T2, class D2, class C2>
336 334 inline bool operator>(const impl_ptr<T1, D1, C1> &l, const impl_ptr<T2, D2, C2> &r)
337 335 {
338 336 return r < l;
339 337 }
340 338
341 339 template <class T1, class D1, class C1, class T2, class D2, class C2>
342 340 inline bool operator<=(const impl_ptr<T1, D1, C1> &l, const impl_ptr<T2, D2, C2> &r)
343 341 {
344 342 return !(r < l);
345 343 }
346 344
347 345 template <class T1, class D1, class C1, class T2, class D2, class C2>
348 346 inline bool operator>=(const impl_ptr<T1, D1, C1> &l, const impl_ptr<T2, D2, C2> &r)
349 347 {
350 348 return !(l < r);
351 349 }
352 350
353 351 template <class T, class D, class C>
354 352 inline bool operator==(const impl_ptr<T, D, C> &p, std::nullptr_t) SPIMPL_NOEXCEPT
355 353 {
356 354 return !p;
357 355 }
358 356
359 357 template <class T, class D, class C>
360 358 inline bool operator==(std::nullptr_t, const impl_ptr<T, D, C> &p) SPIMPL_NOEXCEPT
361 359 {
362 360 return !p;
363 361 }
364 362
365 363 template <class T, class D, class C>
366 364 inline bool operator!=(const impl_ptr<T, D, C> &p, std::nullptr_t) SPIMPL_NOEXCEPT
367 365 {
368 366 return static_cast<bool>(p);
369 367 }
370 368
371 369 template <class T, class D, class C>
372 370 inline bool operator!=(std::nullptr_t, const impl_ptr<T, D, C> &p) SPIMPL_NOEXCEPT
373 371 {
374 372 return static_cast<bool>(p);
375 373 }
376 374
377 375 template <class T, class D, class C>
378 376 inline bool operator<(const impl_ptr<T, D, C> &l, std::nullptr_t)
379 377 {
380 378 using P = typename impl_ptr<T, D, C>::pointer;
381 379 return std::less<P>()(l.get(), nullptr);
382 380 }
383 381
384 382 template <class T, class D, class C>
385 383 inline bool operator<(std::nullptr_t, const impl_ptr<T, D, C> &p)
386 384 {
387 385 using P = typename impl_ptr<T, D, C>::pointer;
388 386 return std::less<P>()(nullptr, p.get());
389 387 }
390 388
391 389 template <class T, class D, class C>
392 390 inline bool operator>(const impl_ptr<T, D, C> &p, std::nullptr_t)
393 391 {
394 392 return nullptr < p;
395 393 }
396 394
397 395 template <class T, class D, class C>
398 396 inline bool operator>(std::nullptr_t, const impl_ptr<T, D, C> &p)
399 397 {
400 398 return p < nullptr;
401 399 }
402 400
403 401 template <class T, class D, class C>
404 402 inline bool operator<=(const impl_ptr<T, D, C> &p, std::nullptr_t)
405 403 {
406 404 return !(nullptr < p);
407 405 }
408 406
409 407 template <class T, class D, class C>
410 408 inline bool operator<=(std::nullptr_t, const impl_ptr<T, D, C> &p)
411 409 {
412 410 return !(p < nullptr);
413 411 }
414 412
415 413 template <class T, class D, class C>
416 414 inline bool operator>=(const impl_ptr<T, D, C> &p, std::nullptr_t)
417 415 {
418 416 return !(p < nullptr);
419 417 }
420 418
421 419 template <class T, class D, class C>
422 420 inline bool operator>=(std::nullptr_t, const impl_ptr<T, D, C> &p)
423 421 {
424 422 return !(nullptr < p);
425 423 }
426 424
427 425
428 426 template <class T, class... Args>
429 427 inline impl_ptr<T> make_impl(Args &&... args)
430 428 {
431 429 return impl_ptr<T>(new T(std::forward<Args>(args)...), &details::default_delete<T>,
432 430 &details::default_copy<T>);
433 431 }
434 432
435 433
436 434 // Helpers to manage unique impl, stored in std::unique_ptr
437 435
438 436 template <class T, class Deleter = void (*)(T *)>
439 437 using unique_impl_ptr = std::unique_ptr<T, Deleter>;
440 438
441 439 template <class T, class... Args>
442 440 inline unique_impl_ptr<T> make_unique_impl(Args &&... args)
443 441 {
444 442 static_assert(!std::is_array<T>::value, "unique_impl_ptr does not support arrays");
445 443 return unique_impl_ptr<T>(new T(std::forward<Args>(args)...), &details::default_delete<T>);
446 444 }
447 445 }
448 446
449 447 namespace std {
450 448 template <class T, class D, class C>
451 449 struct hash<spimpl::impl_ptr<T, D, C> > {
452 450 using argument_type = spimpl::impl_ptr<T, D, C>;
453 451 using result_type = size_t;
454 452
455 453 result_type operator()(const argument_type &p) const SPIMPL_NOEXCEPT
456 454 {
457 455 return hash<typename argument_type::pointer>()(p.get());
458 456 }
459 457 };
460 458 }
461 459
462 460 #endif // SPIMPL_H_
Show file before | Show file after | Hide comments
@@ -1,78 +1,78
1 1 #include <DataSource/DataSourceController.h>
2 2 #include <DataSource/DataSourceItem.h>
3 3
4 4 #include <QMutex>
5 5 #include <QThread>
6 6
7 7 #include <QDir>
8 8 #include <QStandardPaths>
9 9
10 10 Q_LOGGING_CATEGORY(LOG_DataSourceController, "DataSourceController")
11 11
12 12 class DataSourceController::DataSourceControllerPrivate {
13 13 public:
14 14 QMutex m_WorkingMutex;
15 15 /// Data sources registered
16 16 QHash<QUuid, QString> m_DataSources;
17 17 /// Data sources structures
18 18 std::map<QUuid, std::unique_ptr<DataSourceItem> > m_DataSourceItems;
19 19 };
20 20
21 21 DataSourceController::DataSourceController(QObject *parent)
22 22 : impl{spimpl::make_unique_impl<DataSourceControllerPrivate>()}
23 23 {
24 qCDebug(LOG_DataSourceController())
25 << tr("DataSourceController construction") << QThread::currentThread();
24 qCDebug(LOG_DataSourceController()) << tr("DataSourceController construction")
25 << QThread::currentThread();
26 26 }
27 27
28 28 DataSourceController::~DataSourceController()
29 29 {
30 qCDebug(LOG_DataSourceController())
31 << tr("DataSourceController destruction") << QThread::currentThread();
30 qCDebug(LOG_DataSourceController()) << tr("DataSourceController destruction")
31 << QThread::currentThread();
32 32 this->waitForFinish();
33 33 }
34 34
35 35 QUuid DataSourceController::registerDataSource(const QString &dataSourceName) noexcept
36 36 {
37 37 auto dataSourceUid = QUuid::createUuid();
38 38 impl->m_DataSources.insert(dataSourceUid, dataSourceName);
39 39
40 40 return dataSourceUid;
41 41 }
42 42
43 43 void DataSourceController::setDataSourceItem(
44 44 const QUuid &dataSourceUid, std::unique_ptr<DataSourceItem> dataSourceItem) noexcept
45 45 {
46 46 if (impl->m_DataSources.contains(dataSourceUid)) {
47 47 impl->m_DataSourceItems.insert(std::make_pair(dataSourceUid, std::move(dataSourceItem)));
48 48
49 49 // Retrieves the data source item to emit the signal with it
50 50 auto it = impl->m_DataSourceItems.find(dataSourceUid);
51 51 if (it != impl->m_DataSourceItems.end()) {
52 52 emit dataSourceItemSet(*it->second);
53 53 }
54 54 }
55 55 else {
56 56 qCWarning(LOG_DataSourceController()) << tr("Can't set data source item for uid %1 : no "
57 57 "data source has been registered with the uid")
58 58 .arg(dataSourceUid.toString());
59 59 }
60 60 }
61 61
62 62 void DataSourceController::initialize()
63 63 {
64 qCDebug(LOG_DataSourceController())
65 << tr("DataSourceController init") << QThread::currentThread();
64 qCDebug(LOG_DataSourceController()) << tr("DataSourceController init")
65 << QThread::currentThread();
66 66 impl->m_WorkingMutex.lock();
67 67 qCDebug(LOG_DataSourceController()) << tr("DataSourceController init END");
68 68 }
69 69
70 70 void DataSourceController::finalize()
71 71 {
72 72 impl->m_WorkingMutex.unlock();
73 73 }
74 74
75 75 void DataSourceController::waitForFinish()
76 76 {
77 77 QMutexLocker locker{&impl->m_WorkingMutex};
78 78 }
Show file before | Show file after | Hide comments
@@ -1,46 +1,46
1 1 #include <Visualization/VisualizationController.h>
2 2
3 3 #include <QMutex>
4 4 #include <QThread>
5 5
6 6 #include <QDir>
7 7 #include <QStandardPaths>
8 8
9 9 Q_LOGGING_CATEGORY(LOG_VisualizationController, "VisualizationController")
10 10
11 11 class VisualizationController::VisualizationControllerPrivate {
12 12 public:
13 13 QMutex m_WorkingMutex;
14 14 };
15 15
16 16 VisualizationController::VisualizationController(QObject *parent)
17 17 : impl{spimpl::make_unique_impl<VisualizationControllerPrivate>()}
18 18 {
19 qCDebug(LOG_VisualizationController())
20 << tr("VisualizationController construction") << QThread::currentThread();
19 qCDebug(LOG_VisualizationController()) << tr("VisualizationController construction")
20 << QThread::currentThread();
21 21 }
22 22
23 23 VisualizationController::~VisualizationController()
24 24 {
25 qCDebug(LOG_VisualizationController())
26 << tr("VisualizationController destruction") << QThread::currentThread();
25 qCDebug(LOG_VisualizationController()) << tr("VisualizationController destruction")
26 << QThread::currentThread();
27 27 this->waitForFinish();
28 28 }
29 29
30 30 void VisualizationController::initialize()
31 31 {
32 qCDebug(LOG_VisualizationController())
33 << tr("VisualizationController init") << QThread::currentThread();
32 qCDebug(LOG_VisualizationController()) << tr("VisualizationController init")
33 << QThread::currentThread();
34 34 impl->m_WorkingMutex.lock();
35 35 qCDebug(LOG_VisualizationController()) << tr("VisualizationController init END");
36 36 }
37 37
38 38 void VisualizationController::finalize()
39 39 {
40 40 impl->m_WorkingMutex.unlock();
41 41 }
42 42
43 43 void VisualizationController::waitForFinish()
44 44 {
45 45 QMutexLocker locker{&impl->m_WorkingMutex};
46 46 }
General Comments 0
You need to be logged in to leave comments. Login now