##// END OF EJS Templates
GIT_REPOSITORIES » LPP » Users » mperrinel » SCIQLOP-Initialisation
RSS

Fork of HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop

Correctio clang format spimpl.h
perrinel -
r47:8df81ad16071
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,462 +1,458
1 /*
1 /*
2 ====================================================================
2 ====================================================================
3 A Smart Pointer to IMPLementation (i.e. Smart PIMPL or just SPIMPL).
3 A Smart Pointer to IMPLementation (i.e. Smart PIMPL or just SPIMPL).
4 ====================================================================
4 ====================================================================
5
5
6 Version: 1.1
6 Version: 1.1
7
7
8 Latest version:
8 Latest version:
9 https://github.com/oliora/samples/blob/master/spimpl.h
9 https://github.com/oliora/samples/blob/master/spimpl.h
10 Rationale and description:
10 Rationale and description:
11 http://oliora.github.io/2015/12/29/pimpl-and-rule-of-zero.html
11 http://oliora.github.io/2015/12/29/pimpl-and-rule-of-zero.html
12
12
13 Copyright (c) 2015 Andrey Upadyshev (oliora@gmail.com)
13 Copyright (c) 2015 Andrey Upadyshev (oliora@gmail.com)
14
14
15 Distributed under the Boost Software License, Version 1.0.
15 Distributed under the Boost Software License, Version 1.0.
16 See http://www.boost.org/LICENSE_1_0.txt
16 See http://www.boost.org/LICENSE_1_0.txt
17
17
18 Changes history
18 Changes history
19 ---------------
19 ---------------
20 v1.1:
20 v1.1:
21 - auto_ptr support is disabled by default for C++17 compatibility
21 - auto_ptr support is disabled by default for C++17 compatibility
22 v1.0:
22 v1.0:
23 - Released
23 - Released
24 */
24 */
25
25
26 #ifndef SPIMPL_H_
26 #ifndef SPIMPL_H_
27 #define SPIMPL_H_
27 #define SPIMPL_H_
28
28
29 #include <cassert>
29 #include <cassert>
30 #include <memory>
30 #include <memory>
31 #include <type_traits>
31 #include <type_traits>
32
32
33 #if defined _MSC_VER && _MSC_VER < 1900 // MS Visual Studio before VS2015
33 #if defined _MSC_VER && _MSC_VER < 1900 // MS Visual Studio before VS2015
34 #define SPIMPL_NO_CPP11_NOEXCEPT
34 #define SPIMPL_NO_CPP11_NOEXCEPT
35 #define SPIMPL_NO_CPP11_CONSTEXPR
35 #define SPIMPL_NO_CPP11_CONSTEXPR
36 #define SPIMPL_NO_CPP11_DEFAULT_MOVE_SPEC_FUNC
36 #define SPIMPL_NO_CPP11_DEFAULT_MOVE_SPEC_FUNC
37 #endif
37 #endif
38
38
39 #if !defined SPIMPL_NO_CPP11_NOEXCEPT
39 #if !defined SPIMPL_NO_CPP11_NOEXCEPT
40 #define SPIMPL_NOEXCEPT noexcept
40 #define SPIMPL_NOEXCEPT noexcept
41 #else
41 #else
42 #define SPIMPL_NOEXCEPT
42 #define SPIMPL_NOEXCEPT
43 #endif
43 #endif
44
44
45 #if !defined SPIMPL_NO_CPP11_CONSTEXPR
45 #if !defined SPIMPL_NO_CPP11_CONSTEXPR
46 #define SPIMPL_CONSTEXPR constexpr
46 #define SPIMPL_CONSTEXPR constexpr
47 #else
47 #else
48 #define SPIMPL_CONSTEXPR
48 #define SPIMPL_CONSTEXPR
49 #endif
49 #endif
50
50
51 // define SPIMPL_HAS_AUTO_PTR to enable constructor and assignment operator that accept
51 // define SPIMPL_HAS_AUTO_PTR to enable constructor and assignment operator that accept
52 // std::auto_ptr
52 // std::auto_ptr
53 // TODO: auto detect std::auto_ptr support
53 // TODO: auto detect std::auto_ptr support
54
54
55
55
56 namespace spimpl {
56 namespace spimpl {
57 namespace details {
57 namespace details {
58 template <class T>
58 template <class T>
59 T *default_copy(T *src)
59 T *default_copy(T *src)
60 {
60 {
61 static_assert(sizeof(T) > 0, "default_copy cannot copy incomplete type");
61 static_assert(sizeof(T) > 0, "default_copy cannot copy incomplete type");
62 static_assert(!std::is_void<T>::value, "default_copy cannot copy incomplete type");
62 static_assert(!std::is_void<T>::value, "default_copy cannot copy incomplete type");
63 return new T(*src);
63 return new T(*src);
64 }
64 }
65
65
66 template <class T>
66 template <class T>
67 void default_delete(T *p) SPIMPL_NOEXCEPT
67 void default_delete(T *p) SPIMPL_NOEXCEPT
68 {
68 {
69 static_assert(sizeof(T) > 0, "default_delete cannot delete incomplete type");
69 static_assert(sizeof(T) > 0, "default_delete cannot delete incomplete type");
70 static_assert(!std::is_void<T>::value, "default_delete cannot delete incomplete type");
70 static_assert(!std::is_void<T>::value, "default_delete cannot delete incomplete type");
71 delete p;
71 delete p;
72 }
72 }
73
73
74 template <class T>
74 template <class T>
75 struct default_deleter {
75 struct default_deleter {
76 using type = void (*)(T *);
76 using type = void (*)(T *);
77 };
77 };
78
78
79 template <class T>
79 template <class T>
80 using default_deleter_t = typename default_deleter<T>::type;
80 using default_deleter_t = typename default_deleter<T>::type;
81
81
82 template <class T>
82 template <class T>
83 struct default_copier {
83 struct default_copier {
84 using type = T *(*)(T *);
84 using type = T *(*)(T *);
85 };
85 };
86
86
87 template <class T>
87 template <class T>
88 using default_copier_t = typename default_copier<T>::type;
88 using default_copier_t = typename default_copier<T>::type;
89
89
90 template <class T, class D, class C>
90 template <class T, class D, class C>
91 struct is_default_manageable
91 struct is_default_manageable
92 : public std::integral_constant<bool,
92 : public std::integral_constant<bool, std::is_same<D, default_deleter_t<T> >::value
93 std::is_same<D, default_deleter_t<T> >::value
94 && std::is_same<C, default_copier_t<T> >::value> {
93 && std::is_same<C, default_copier_t<T> >::value> {
95 };
94 };
96 }
95 }
97
96
98
97
99 template <class T, class Deleter = details::default_deleter_t<T>,
98 template <class T, class Deleter = details::default_deleter_t<T>,
100 class Copier = details::default_copier_t<T> >
99 class Copier = details::default_copier_t<T> >
101 class impl_ptr {
100 class impl_ptr {
102 private:
101 private:
103 static_assert(!std::is_array<T>::value,
102 static_assert(!std::is_array<T>::value,
104 "impl_ptr specialization for arrays is not implemented");
103 "impl_ptr specialization for arrays is not implemented");
105 struct dummy_t_ {
104 struct dummy_t_ {
106 int dummy__;
105 int dummy__;
107 };
106 };
108
107
109 public:
108 public:
110 using pointer = T *;
109 using pointer = T *;
111 using element_type = T;
110 using element_type = T;
112 using copier_type = typename std::decay<Copier>::type;
111 using copier_type = typename std::decay<Copier>::type;
113 using deleter_type = typename std::decay<Deleter>::type;
112 using deleter_type = typename std::decay<Deleter>::type;
114 using unique_ptr_type = std::unique_ptr<T, deleter_type>;
113 using unique_ptr_type = std::unique_ptr<T, deleter_type>;
115 using is_default_manageable = details::is_default_manageable<T, deleter_type, copier_type>;
114 using is_default_manageable = details::is_default_manageable<T, deleter_type, copier_type>;
116
115
117 SPIMPL_CONSTEXPR impl_ptr() SPIMPL_NOEXCEPT : ptr_(nullptr, deleter_type{}),
116 SPIMPL_CONSTEXPR impl_ptr() SPIMPL_NOEXCEPT : ptr_(nullptr, deleter_type{}),
118 copier_(copier_type{})
117 copier_(copier_type{})
119 {
118 {
120 }
119 }
121
120
122 SPIMPL_CONSTEXPR impl_ptr(std::nullptr_t) SPIMPL_NOEXCEPT : impl_ptr() {}
121 SPIMPL_CONSTEXPR impl_ptr(std::nullptr_t) SPIMPL_NOEXCEPT : impl_ptr() {}
123
122
124 template <class D, class C>
123 template <class D, class C>
125 impl_ptr(pointer p, D &&d, C &&c,
124 impl_ptr(pointer p, D &&d, C &&c,
126 typename std::enable_if<std::is_convertible<D, deleter_type>::value
125 typename std::enable_if<std::is_convertible<D, deleter_type>::value
127 && std::is_convertible<C, copier_type>::value,
126 && std::is_convertible<C, copier_type>::value,
128 dummy_t_>::type
127 dummy_t_>::type
129 = dummy_t_()) SPIMPL_NOEXCEPT : ptr_(std::move(p), std::forward<D>(d)),
128 = dummy_t_()) SPIMPL_NOEXCEPT : ptr_(std::move(p), std::forward<D>(d)),
130 copier_(std::forward<C>(c))
129 copier_(std::forward<C>(c))
131 {
130 {
132 }
131 }
133
132
134 template <class U>
133 template <class U>
135 impl_ptr(U *u,
134 impl_ptr(U *u, typename std::enable_if<std::is_convertible<U *, pointer>::value
136 typename std::enable_if<std::is_convertible<U *, pointer>::value
137 && is_default_manageable::value,
135 && is_default_manageable::value,
138 dummy_t_>::type
136 dummy_t_>::type
139 = dummy_t_()) SPIMPL_NOEXCEPT
137 = dummy_t_()) SPIMPL_NOEXCEPT
140 : impl_ptr(u, &details::default_delete<T>, &details::default_copy<T>)
138 : impl_ptr(u, &details::default_delete<T>, &details::default_copy<T>)
141 {
139 {
142 }
140 }
143
141
144 impl_ptr(const impl_ptr &r) : impl_ptr(r.clone()) {}
142 impl_ptr(const impl_ptr &r) : impl_ptr(r.clone()) {}
145
143
146 #ifndef SPIMPL_NO_CPP11_DEFAULT_MOVE_SPEC_FUNC
144 #ifndef SPIMPL_NO_CPP11_DEFAULT_MOVE_SPEC_FUNC
147 impl_ptr(impl_ptr &&r) SPIMPL_NOEXCEPT = default;
145 impl_ptr(impl_ptr &&r) SPIMPL_NOEXCEPT = default;
148 #else
146 #else
149 impl_ptr(impl_ptr &&r) SPIMPL_NOEXCEPT : ptr_(std::move(r.ptr_)), copier_(std::move(r.copier_))
147 impl_ptr(impl_ptr &&r) SPIMPL_NOEXCEPT : ptr_(std::move(r.ptr_)), copier_(std::move(r.copier_))
150 {
148 {
151 }
149 }
152 #endif
150 #endif
153
151
154 #ifdef SPIMPL_HAS_AUTO_PTR
152 #ifdef SPIMPL_HAS_AUTO_PTR
155 template <class U>
153 template <class U>
156 impl_ptr(std::auto_ptr<U> &&u,
154 impl_ptr(std::auto_ptr<U> &&u, typename std::enable_if<std::is_convertible<U *, pointer>::value
157 typename std::enable_if<std::is_convertible<U *, pointer>::value
158 && is_default_manageable::value,
155 && is_default_manageable::value,
159 dummy_t_>::type
156 dummy_t_>::type
160 = dummy_t_()) SPIMPL_NOEXCEPT : ptr_(u.release(), &details::default_delete<T>),
157 = dummy_t_()) SPIMPL_NOEXCEPT
158 : ptr_(u.release(), &details::default_delete<T>),
161 copier_(&details::default_copy<T>)
159 copier_(&details::default_copy<T>)
162 {
160 {
163 }
161 }
164 #endif
162 #endif
165
163
166 template <class U>
164 template <class U>
167 impl_ptr(std::unique_ptr<U> &&u,
165 impl_ptr(std::unique_ptr<U> &&u,
168 typename std::enable_if<std::is_convertible<U *, pointer>::value
166 typename std::enable_if<std::is_convertible<U *, pointer>::value
169 && is_default_manageable::value,
167 && is_default_manageable::value,
170 dummy_t_>::type
168 dummy_t_>::type
171 = dummy_t_()) SPIMPL_NOEXCEPT : ptr_(u.release(), &details::default_delete<T>),
169 = dummy_t_()) SPIMPL_NOEXCEPT : ptr_(u.release(), &details::default_delete<T>),
172 copier_(&details::default_copy<T>)
170 copier_(&details::default_copy<T>)
173 {
171 {
174 }
172 }
175
173
176 template <class U, class D, class C>
174 template <class U, class D, class C>
177 impl_ptr(std::unique_ptr<U, D> &&u, C &&c,
175 impl_ptr(std::unique_ptr<U, D> &&u, C &&c,
178 typename std::enable_if<std::is_convertible<U *, pointer>::value
176 typename std::enable_if<std::is_convertible<U *, pointer>::value
179 && std::is_convertible<D, deleter_type>::value
177 && std::is_convertible<D, deleter_type>::value
180 && std::is_convertible<C, copier_type>::value,
178 && std::is_convertible<C, copier_type>::value,
181 dummy_t_>::type
179 dummy_t_>::type
182 = dummy_t_()) SPIMPL_NOEXCEPT : ptr_(std::move(u)),
180 = dummy_t_()) SPIMPL_NOEXCEPT : ptr_(std::move(u)),
183 copier_(std::forward<C>(c))
181 copier_(std::forward<C>(c))
184 {
182 {
185 }
183 }
186
184
187 template <class U, class D, class C>
185 template <class U, class D, class C>
188 impl_ptr(impl_ptr<U, D, C> &&u,
186 impl_ptr(impl_ptr<U, D, C> &&u,
189 typename std::enable_if<std::is_convertible<U *, pointer>::value
187 typename std::enable_if<std::is_convertible<U *, pointer>::value
190 && std::is_convertible<D, deleter_type>::value
188 && std::is_convertible<D, deleter_type>::value
191 && std::is_convertible<C, copier_type>::value,
189 && std::is_convertible<C, copier_type>::value,
192 dummy_t_>::type
190 dummy_t_>::type
193 = dummy_t_()) SPIMPL_NOEXCEPT : ptr_(std::move(u.ptr_)),
191 = dummy_t_()) SPIMPL_NOEXCEPT : ptr_(std::move(u.ptr_)),
194 copier_(std::move(u.copier_))
192 copier_(std::move(u.copier_))
195 {
193 {
196 }
194 }
197
195
198 impl_ptr &operator=(const impl_ptr &r)
196 impl_ptr &operator=(const impl_ptr &r)
199 {
197 {
200 if (this == &r)
198 if (this == &r)
201 return *this;
199 return *this;
202
200
203 return operator=(r.clone());
201 return operator=(r.clone());
204 }
202 }
205
203
206 #ifndef SPIMPL_NO_CPP11_DEFAULT_MOVE_SPEC_FUNC
204 #ifndef SPIMPL_NO_CPP11_DEFAULT_MOVE_SPEC_FUNC
207 impl_ptr &operator=(impl_ptr &&r) SPIMPL_NOEXCEPT = default;
205 impl_ptr &operator=(impl_ptr &&r) SPIMPL_NOEXCEPT = default;
208 #else
206 #else
209 impl_ptr &operator=(impl_ptr &&r) SPIMPL_NOEXCEPT
207 impl_ptr &operator=(impl_ptr &&r) SPIMPL_NOEXCEPT
210 {
208 {
211 ptr_ = std::move(r.ptr_);
209 ptr_ = std::move(r.ptr_);
212 copier_ = std::move(r.copier_);
210 copier_ = std::move(r.copier_);
213 return *this;
211 return *this;
214 }
212 }
215 #endif
213 #endif
216
214
217 template <class U, class D, class C>
215 template <class U, class D, class C>
218 typename std::enable_if<std::is_convertible<U *, pointer>::value
216 typename std::enable_if<std::is_convertible<U *, pointer>::value
219 && std::is_convertible<D, deleter_type>::value
217 && std::is_convertible<D, deleter_type>::value
220 && std::is_convertible<C, copier_type>::value,
218 && std::is_convertible<C, copier_type>::value,
221 impl_ptr &>::type
219 impl_ptr &>::type
222 operator=(impl_ptr<U, D, C> &&u) SPIMPL_NOEXCEPT
220 operator=(impl_ptr<U, D, C> &&u) SPIMPL_NOEXCEPT
223 {
221 {
224 ptr_ = std::move(u.ptr_);
222 ptr_ = std::move(u.ptr_);
225 copier_ = std::move(u.copier_);
223 copier_ = std::move(u.copier_);
226 return *this;
224 return *this;
227 }
225 }
228
226
229 template <class U, class D, class C>
227 template <class U, class D, class C>
230 typename std::enable_if<std::is_convertible<U *, pointer>::value
228 typename std::enable_if<std::is_convertible<U *, pointer>::value
231 && std::is_convertible<D, deleter_type>::value
229 && std::is_convertible<D, deleter_type>::value
232 && std::is_convertible<C, copier_type>::value,
230 && std::is_convertible<C, copier_type>::value,
233 impl_ptr &>::type
231 impl_ptr &>::type
234 operator=(const impl_ptr<U, D, C> &u)
232 operator=(const impl_ptr<U, D, C> &u)
235 {
233 {
236 return operator=(u.clone());
234 return operator=(u.clone());
237 }
235 }
238
236
239 //
237 //
240
238
241 #ifdef SPIMPL_HAS_AUTO_PTR
239 #ifdef SPIMPL_HAS_AUTO_PTR
242 template <class U>
240 template <class U>
243 typename std::enable_if<std::is_convertible<U *, pointer>::value
241 typename std::enable_if<
244 && is_default_manageable::value,
242 std::is_convertible<U *, pointer>::value && is_default_manageable::value, impl_ptr &>::type
245 impl_ptr &>::type
246 operator=(std::auto_ptr<U> &&u) SPIMPL_NOEXCEPT
243 operator=(std::auto_ptr<U> &&u) SPIMPL_NOEXCEPT
247 {
244 {
248 return operator=(impl_ptr(std::move(u)));
245 return operator=(impl_ptr(std::move(u)));
249 }
246 }
250 #endif
247 #endif
251
248
252 template <class U>
249 template <class U>
253 typename std::enable_if<std::is_convertible<U *, pointer>::value
250 typename std::enable_if<
254 && is_default_manageable::value,
251 std::is_convertible<U *, pointer>::value && is_default_manageable::value, impl_ptr &>::type
255 impl_ptr &>::type
256 operator=(std::unique_ptr<U> &&u) SPIMPL_NOEXCEPT
252 operator=(std::unique_ptr<U> &&u) SPIMPL_NOEXCEPT
257 {
253 {
258 return operator=(impl_ptr(std::move(u)));
254 return operator=(impl_ptr(std::move(u)));
259 }
255 }
260
256
261 impl_ptr clone() const
257 impl_ptr clone() const
262 {
258 {
263 return impl_ptr(ptr_ ? copier_(ptr_.get()) : nullptr, ptr_.get_deleter(), copier_);
259 return impl_ptr(ptr_ ? copier_(ptr_.get()) : nullptr, ptr_.get_deleter(), copier_);
264 }
260 }
265
261
266 typename std::remove_reference<T>::type &operator*() const { return *ptr_; }
262 typename std::remove_reference<T>::type &operator*() const { return *ptr_; }
267 pointer operator->() const SPIMPL_NOEXCEPT { return get(); }
263 pointer operator->() const SPIMPL_NOEXCEPT { return get(); }
268 pointer get() const SPIMPL_NOEXCEPT { return ptr_.get(); }
264 pointer get() const SPIMPL_NOEXCEPT { return ptr_.get(); }
269
265
270 void swap(impl_ptr &u) SPIMPL_NOEXCEPT
266 void swap(impl_ptr &u) SPIMPL_NOEXCEPT
271 {
267 {
272 using std::swap;
268 using std::swap;
273 ptr_.swap(u.ptr_);
269 ptr_.swap(u.ptr_);
274 swap(copier_, u.copier_);
270 swap(copier_, u.copier_);
275 }
271 }
276
272
277 pointer release() SPIMPL_NOEXCEPT { return ptr_.release(); }
273 pointer release() SPIMPL_NOEXCEPT { return ptr_.release(); }
278
274
279 unique_ptr_type release_unique() SPIMPL_NOEXCEPT { return std::move(ptr_); }
275 unique_ptr_type release_unique() SPIMPL_NOEXCEPT { return std::move(ptr_); }
280
276
281 explicit operator bool() const SPIMPL_NOEXCEPT { return static_cast<bool>(ptr_); }
277 explicit operator bool() const SPIMPL_NOEXCEPT { return static_cast<bool>(ptr_); }
282
278
283 typename std::remove_reference<deleter_type>::type &get_deleter() SPIMPL_NOEXCEPT
279 typename std::remove_reference<deleter_type>::type &get_deleter() SPIMPL_NOEXCEPT
284 {
280 {
285 return ptr_.get_deleter();
281 return ptr_.get_deleter();
286 }
282 }
287 const typename std::remove_reference<deleter_type>::type &get_deleter() const SPIMPL_NOEXCEPT
283 const typename std::remove_reference<deleter_type>::type &get_deleter() const SPIMPL_NOEXCEPT
288 {
284 {
289 return ptr_.get_deleter();
285 return ptr_.get_deleter();
290 }
286 }
291
287
292 typename std::remove_reference<copier_type>::type &get_copier() SPIMPL_NOEXCEPT
288 typename std::remove_reference<copier_type>::type &get_copier() SPIMPL_NOEXCEPT
293 {
289 {
294 return copier_;
290 return copier_;
295 }
291 }
296 const typename std::remove_reference<copier_type>::type &get_copier() const SPIMPL_NOEXCEPT
292 const typename std::remove_reference<copier_type>::type &get_copier() const SPIMPL_NOEXCEPT
297 {
293 {
298 return copier_;
294 return copier_;
299 }
295 }
300
296
301 private:
297 private:
302 unique_ptr_type ptr_;
298 unique_ptr_type ptr_;
303 copier_type copier_;
299 copier_type copier_;
304 };
300 };
305
301
306
302
307 template <class T, class D, class C>
303 template <class T, class D, class C>
308 inline void swap(impl_ptr<T, D, C> &l, impl_ptr<T, D, C> &r) SPIMPL_NOEXCEPT
304 inline void swap(impl_ptr<T, D, C> &l, impl_ptr<T, D, C> &r) SPIMPL_NOEXCEPT
309 {
305 {
310 l.swap(r);
306 l.swap(r);
311 }
307 }
312
308
313
309
314 template <class T1, class D1, class C1, class T2, class D2, class C2>
310 template <class T1, class D1, class C1, class T2, class D2, class C2>
315 inline bool operator==(const impl_ptr<T1, D1, C1> &l, const impl_ptr<T2, D2, C2> &r)
311 inline bool operator==(const impl_ptr<T1, D1, C1> &l, const impl_ptr<T2, D2, C2> &r)
316 {
312 {
317 return l.get() == r.get();
313 return l.get() == r.get();
318 }
314 }
319
315
320 template <class T1, class D1, class C1, class T2, class D2, class C2>
316 template <class T1, class D1, class C1, class T2, class D2, class C2>
321 inline bool operator!=(const impl_ptr<T1, D1, C1> &l, const impl_ptr<T2, D2, C2> &r)
317 inline bool operator!=(const impl_ptr<T1, D1, C1> &l, const impl_ptr<T2, D2, C2> &r)
322 {
318 {
323 return !(l == r);
319 return !(l == r);
324 }
320 }
325
321
326 template <class T1, class D1, class C1, class T2, class D2, class C2>
322 template <class T1, class D1, class C1, class T2, class D2, class C2>
327 inline bool operator<(const impl_ptr<T1, D1, C1> &l, const impl_ptr<T2, D2, C2> &r)
323 inline bool operator<(const impl_ptr<T1, D1, C1> &l, const impl_ptr<T2, D2, C2> &r)
328 {
324 {
329 using P1 = typename impl_ptr<T1, D1, C1>::pointer;
325 using P1 = typename impl_ptr<T1, D1, C1>::pointer;
330 using P2 = typename impl_ptr<T2, D2, C2>::pointer;
326 using P2 = typename impl_ptr<T2, D2, C2>::pointer;
331 using CT = typename std::common_type<P1, P2>::type;
327 using CT = typename std::common_type<P1, P2>::type;
332 return std::less<CT>()(l.get(), r.get());
328 return std::less<CT>()(l.get(), r.get());
333 }
329 }
334
330
335 template <class T1, class D1, class C1, class T2, class D2, class C2>
331 template <class T1, class D1, class C1, class T2, class D2, class C2>
336 inline bool operator>(const impl_ptr<T1, D1, C1> &l, const impl_ptr<T2, D2, C2> &r)
332 inline bool operator>(const impl_ptr<T1, D1, C1> &l, const impl_ptr<T2, D2, C2> &r)
337 {
333 {
338 return r < l;
334 return r < l;
339 }
335 }
340
336
341 template <class T1, class D1, class C1, class T2, class D2, class C2>
337 template <class T1, class D1, class C1, class T2, class D2, class C2>
342 inline bool operator<=(const impl_ptr<T1, D1, C1> &l, const impl_ptr<T2, D2, C2> &r)
338 inline bool operator<=(const impl_ptr<T1, D1, C1> &l, const impl_ptr<T2, D2, C2> &r)
343 {
339 {
344 return !(r < l);
340 return !(r < l);
345 }
341 }
346
342
347 template <class T1, class D1, class C1, class T2, class D2, class C2>
343 template <class T1, class D1, class C1, class T2, class D2, class C2>
348 inline bool operator>=(const impl_ptr<T1, D1, C1> &l, const impl_ptr<T2, D2, C2> &r)
344 inline bool operator>=(const impl_ptr<T1, D1, C1> &l, const impl_ptr<T2, D2, C2> &r)
349 {
345 {
350 return !(l < r);
346 return !(l < r);
351 }
347 }
352
348
353 template <class T, class D, class C>
349 template <class T, class D, class C>
354 inline bool operator==(const impl_ptr<T, D, C> &p, std::nullptr_t) SPIMPL_NOEXCEPT
350 inline bool operator==(const impl_ptr<T, D, C> &p, std::nullptr_t) SPIMPL_NOEXCEPT
355 {
351 {
356 return !p;
352 return !p;
357 }
353 }
358
354
359 template <class T, class D, class C>
355 template <class T, class D, class C>
360 inline bool operator==(std::nullptr_t, const impl_ptr<T, D, C> &p) SPIMPL_NOEXCEPT
356 inline bool operator==(std::nullptr_t, const impl_ptr<T, D, C> &p) SPIMPL_NOEXCEPT
361 {
357 {
362 return !p;
358 return !p;
363 }
359 }
364
360
365 template <class T, class D, class C>
361 template <class T, class D, class C>
366 inline bool operator!=(const impl_ptr<T, D, C> &p, std::nullptr_t) SPIMPL_NOEXCEPT
362 inline bool operator!=(const impl_ptr<T, D, C> &p, std::nullptr_t) SPIMPL_NOEXCEPT
367 {
363 {
368 return static_cast<bool>(p);
364 return static_cast<bool>(p);
369 }
365 }
370
366
371 template <class T, class D, class C>
367 template <class T, class D, class C>
372 inline bool operator!=(std::nullptr_t, const impl_ptr<T, D, C> &p) SPIMPL_NOEXCEPT
368 inline bool operator!=(std::nullptr_t, const impl_ptr<T, D, C> &p) SPIMPL_NOEXCEPT
373 {
369 {
374 return static_cast<bool>(p);
370 return static_cast<bool>(p);
375 }
371 }
376
372
377 template <class T, class D, class C>
373 template <class T, class D, class C>
378 inline bool operator<(const impl_ptr<T, D, C> &l, std::nullptr_t)
374 inline bool operator<(const impl_ptr<T, D, C> &l, std::nullptr_t)
379 {
375 {
380 using P = typename impl_ptr<T, D, C>::pointer;
376 using P = typename impl_ptr<T, D, C>::pointer;
381 return std::less<P>()(l.get(), nullptr);
377 return std::less<P>()(l.get(), nullptr);
382 }
378 }
383
379
384 template <class T, class D, class C>
380 template <class T, class D, class C>
385 inline bool operator<(std::nullptr_t, const impl_ptr<T, D, C> &p)
381 inline bool operator<(std::nullptr_t, const impl_ptr<T, D, C> &p)
386 {
382 {
387 using P = typename impl_ptr<T, D, C>::pointer;
383 using P = typename impl_ptr<T, D, C>::pointer;
388 return std::less<P>()(nullptr, p.get());
384 return std::less<P>()(nullptr, p.get());
389 }
385 }
390
386
391 template <class T, class D, class C>
387 template <class T, class D, class C>
392 inline bool operator>(const impl_ptr<T, D, C> &p, std::nullptr_t)
388 inline bool operator>(const impl_ptr<T, D, C> &p, std::nullptr_t)
393 {
389 {
394 return nullptr < p;
390 return nullptr < p;
395 }
391 }
396
392
397 template <class T, class D, class C>
393 template <class T, class D, class C>
398 inline bool operator>(std::nullptr_t, const impl_ptr<T, D, C> &p)
394 inline bool operator>(std::nullptr_t, const impl_ptr<T, D, C> &p)
399 {
395 {
400 return p < nullptr;
396 return p < nullptr;
401 }
397 }
402
398
403 template <class T, class D, class C>
399 template <class T, class D, class C>
404 inline bool operator<=(const impl_ptr<T, D, C> &p, std::nullptr_t)
400 inline bool operator<=(const impl_ptr<T, D, C> &p, std::nullptr_t)
405 {
401 {
406 return !(nullptr < p);
402 return !(nullptr < p);
407 }
403 }
408
404
409 template <class T, class D, class C>
405 template <class T, class D, class C>
410 inline bool operator<=(std::nullptr_t, const impl_ptr<T, D, C> &p)
406 inline bool operator<=(std::nullptr_t, const impl_ptr<T, D, C> &p)
411 {
407 {
412 return !(p < nullptr);
408 return !(p < nullptr);
413 }
409 }
414
410
415 template <class T, class D, class C>
411 template <class T, class D, class C>
416 inline bool operator>=(const impl_ptr<T, D, C> &p, std::nullptr_t)
412 inline bool operator>=(const impl_ptr<T, D, C> &p, std::nullptr_t)
417 {
413 {
418 return !(p < nullptr);
414 return !(p < nullptr);
419 }
415 }
420
416
421 template <class T, class D, class C>
417 template <class T, class D, class C>
422 inline bool operator>=(std::nullptr_t, const impl_ptr<T, D, C> &p)
418 inline bool operator>=(std::nullptr_t, const impl_ptr<T, D, C> &p)
423 {
419 {
424 return !(nullptr < p);
420 return !(nullptr < p);
425 }
421 }
426
422
427
423
428 template <class T, class... Args>
424 template <class T, class... Args>
429 inline impl_ptr<T> make_impl(Args &&... args)
425 inline impl_ptr<T> make_impl(Args &&... args)
430 {
426 {
431 return impl_ptr<T>(new T(std::forward<Args>(args)...), &details::default_delete<T>,
427 return impl_ptr<T>(new T(std::forward<Args>(args)...), &details::default_delete<T>,
432 &details::default_copy<T>);
428 &details::default_copy<T>);
433 }
429 }
434
430
435
431
436 // Helpers to manage unique impl, stored in std::unique_ptr
432 // Helpers to manage unique impl, stored in std::unique_ptr
437
433
438 template <class T, class Deleter = void (*)(T *)>
434 template <class T, class Deleter = void (*)(T *)>
439 using unique_impl_ptr = std::unique_ptr<T, Deleter>;
435 using unique_impl_ptr = std::unique_ptr<T, Deleter>;
440
436
441 template <class T, class... Args>
437 template <class T, class... Args>
442 inline unique_impl_ptr<T> make_unique_impl(Args &&... args)
438 inline unique_impl_ptr<T> make_unique_impl(Args &&... args)
443 {
439 {
444 static_assert(!std::is_array<T>::value, "unique_impl_ptr does not support arrays");
440 static_assert(!std::is_array<T>::value, "unique_impl_ptr does not support arrays");
445 return unique_impl_ptr<T>(new T(std::forward<Args>(args)...), &details::default_delete<T>);
441 return unique_impl_ptr<T>(new T(std::forward<Args>(args)...), &details::default_delete<T>);
446 }
442 }
447 }
443 }
448
444
449 namespace std {
445 namespace std {
450 template <class T, class D, class C>
446 template <class T, class D, class C>
451 struct hash<spimpl::impl_ptr<T, D, C> > {
447 struct hash<spimpl::impl_ptr<T, D, C> > {
452 using argument_type = spimpl::impl_ptr<T, D, C>;
448 using argument_type = spimpl::impl_ptr<T, D, C>;
453 using result_type = size_t;
449 using result_type = size_t;
454
450
455 result_type operator()(const argument_type &p) const SPIMPL_NOEXCEPT
451 result_type operator()(const argument_type &p) const SPIMPL_NOEXCEPT
456 {
452 {
457 return hash<typename argument_type::pointer>()(p.get());
453 return hash<typename argument_type::pointer>()(p.get());
458 }
454 }
459 };
455 };
460 }
456 }
461
457
462 #endif // SPIMPL_H_
458 #endif // SPIMPL_H_
General Comments 0
You need to be logged in to leave comments. Login now