OSDN -- Desenvolver e Download de Software Open Source
Estado tradução de Português translation status for pt
  • R/O
  • SSH
  • HTTPS

sprout: Commit


Commit MetaInfo

Revisão5254 (tree)
Hora2017-11-01 09:21:48
Autorbolero-murakami

Mensagem de Log

(mensagem de log vazia)

Mudança Sumário

Diff

--- sprout/utility/comparison.hpp (nonexistent)
+++ sprout/utility/comparison.hpp (revision 5254)
@@ -0,0 +1,530 @@
1+/*=============================================================================
2+ Copyright (c) 2011-2017 Bolero MURAKAMI
3+ https://github.com/bolero-MURAKAMI/Sprout
4+
5+ Distributed under the Boost Software License, Version 1.0. (See accompanying
6+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
7+=============================================================================*/
8+#ifndef SPROUT_UTILITY_COMPARISON_HPP
9+#define SPROUT_UTILITY_COMPARISON_HPP
10+
11+#include <sprout/config.hpp>
12+#include <sprout/utility/value_holder.hpp>
13+
14+namespace sprout {
15+ //
16+ // comparison_forwarder
17+ //
18+ template<typename Compare = void>
19+ class comparison_forwarder {
20+ public:
21+ typedef Compare compare_type;
22+ private:
23+ sprout::value_holder<compare_type const&> comp_;
24+ public:
25+ explicit SPROUT_CONSTEXPR comparison_forwarder(compare_type const& comp)
26+ : comp_(comp)
27+ {}
28+ SPROUT_CONSTEXPR compare_type const& comp() const {
29+ return comp_;
30+ }
31+ };
32+ template<>
33+ class comparison_forwarder<void> {};
34+ //
35+ // operator->*
36+ //
37+ template<typename Compare>
38+ inline SPROUT_CONSTEXPR sprout::comparison_forwarder<Compare>
39+ operator->*(sprout::comparison_forwarder<>, Compare const& comp) {
40+ return sprout::comparison_forwarder<Compare>(comp);
41+ }
42+
43+ //
44+ // comp
45+ //
46+ namespace {
47+ SPROUT_STATIC_CONSTEXPR sprout::comparison_forwarder<> comp = {};
48+ } // anonymous-namespace
49+
50+ //
51+ // comparison_holder
52+ //
53+ template<typename T, typename Compare = void>
54+ class comparison_holder {
55+ public:
56+ typedef T value_type;
57+ typedef Compare compare_type;
58+ private:
59+ sprout::value_holder<value_type const&> value_;
60+ sprout::value_holder<compare_type const&> comp_;
61+ public:
62+ SPROUT_CONSTEXPR comparison_holder(value_type const& value, compare_type const& comp)
63+ : value_(value), comp_(comp)
64+ {}
65+ SPROUT_CONSTEXPR value_type const& get() const {
66+ return value_;
67+ }
68+ SPROUT_CONSTEXPR compare_type const& comp() const {
69+ return comp_;
70+ }
71+ };
72+ template<typename T>
73+ class comparison_holder<T, void> {
74+ public:
75+ typedef T value_type;
76+ private:
77+ sprout::value_holder<value_type const&> value_;
78+ public:
79+ explicit SPROUT_CONSTEXPR comparison_holder(value_type const& value)
80+ : value_(value)
81+ {}
82+ SPROUT_CONSTEXPR value_type const& get() const {
83+ return value_;
84+ }
85+ };
86+
87+ //
88+ // operator%
89+ //
90+ template<typename T, typename Compare>
91+ inline SPROUT_CONSTEXPR sprout::comparison_holder<T, Compare>
92+ operator%(sprout::comparison_forwarder<Compare> const& lhs, T const& rhs) {
93+ return sprout::comparison_holder<T, Compare>(rhs, lhs.comp());
94+ }
95+ template<typename T>
96+ inline SPROUT_CONSTEXPR sprout::comparison_holder<T>
97+ operator%(sprout::comparison_forwarder<>, T const& rhs) {
98+ return sprout::comparison_holder<T>(rhs);
99+ }
100+
101+ //
102+ // comparison_base
103+ //
104+ template<typename T, typename Compare = void>
105+ class comparison_base {
106+ public:
107+ typedef T value_type;
108+ typedef Compare compare_type;
109+ private:
110+ sprout::value_holder<value_type const&> value_;
111+ sprout::value_holder<compare_type const&> comp_;
112+ bool cond_;
113+ public:
114+ SPROUT_CONSTEXPR comparison_base() SPROUT_DEFAULTED_DEFAULT_CONSTRUCTOR_DECL
115+ comparison_base(comparison_base const&) = default;
116+ SPROUT_CONSTEXPR comparison_base(value_type const& value, compare_type const& comp)
117+ : value_(value), comp_(comp), cond_(true)
118+ {}
119+ SPROUT_CONSTEXPR value_type const& get() const {
120+ return value_;
121+ }
122+ SPROUT_CONSTEXPR compare_type const& comp() const {
123+ return comp_;
124+ }
125+ SPROUT_CONSTEXPR operator bool() const {
126+ return cond_;
127+ }
128+ SPROUT_CONSTEXPR bool operator!() const {
129+ return !cond_;
130+ }
131+ };
132+ template<typename T>
133+ class comparison_base<T, void> {
134+ public:
135+ typedef T value_type;
136+ private:
137+ sprout::value_holder<value_type const&> value_;
138+ bool cond_;
139+ public:
140+ SPROUT_CONSTEXPR comparison_base() SPROUT_DEFAULTED_DEFAULT_CONSTRUCTOR_DECL
141+ comparison_base(comparison_base const&) = default;
142+ explicit SPROUT_CONSTEXPR comparison_base(value_type const& value)
143+ : value_(value), cond_(true)
144+ {}
145+ SPROUT_CONSTEXPR value_type const& get() const {
146+ return value_;
147+ }
148+ SPROUT_CONSTEXPR operator bool() const {
149+ return cond_;
150+ }
151+ SPROUT_CONSTEXPR bool operator!() const {
152+ return !cond_;
153+ }
154+ };
155+
156+ //
157+ // less_comparison
158+ //
159+ template<typename T, typename Compare = void>
160+ class less_comparison
161+ : public sprout::comparison_base<T, Compare>
162+ {
163+ public:
164+ typedef sprout::comparison_base<T, Compare> base_type;
165+ typedef typename base_type::value_type value_type;
166+ typedef typename base_type::compare_type compare_type;
167+ public:
168+ SPROUT_CONSTEXPR less_comparison() SPROUT_DEFAULTED_DEFAULT_CONSTRUCTOR_DECL
169+ less_comparison(less_comparison const&) = default;
170+ SPROUT_CONSTEXPR less_comparison(value_type const& value, compare_type const& comp)
171+ : base_type(value, comp)
172+ {}
173+ };
174+ template<typename T>
175+ class less_comparison<T, void>
176+ : public sprout::comparison_base<T>
177+ {
178+ public:
179+ typedef sprout::comparison_base<T> base_type;
180+ typedef typename base_type::value_type value_type;
181+ public:
182+ SPROUT_CONSTEXPR less_comparison() SPROUT_DEFAULTED_DEFAULT_CONSTRUCTOR_DECL
183+ less_comparison(less_comparison const&) = default;
184+ explicit SPROUT_CONSTEXPR less_comparison(value_type const& value)
185+ : base_type(value)
186+ {}
187+ };
188+ //
189+ // operator<
190+ // operator<=
191+ //
192+ template<typename T, typename Compare>
193+ inline SPROUT_CONSTEXPR sprout::less_comparison<T, Compare>
194+ operator<(sprout::comparison_forwarder<Compare> const& lhs, T const& rhs) {
195+ return sprout::less_comparison<T, Compare>(rhs, lhs.comp());
196+ }
197+ template<typename T>
198+ inline SPROUT_CONSTEXPR sprout::less_comparison<T>
199+ operator<(sprout::comparison_forwarder<>, T const& rhs) {
200+ return sprout::less_comparison<T>(rhs);
201+ }
202+ template<typename T, typename Compare>
203+ inline SPROUT_CONSTEXPR sprout::less_comparison<T, Compare>
204+ operator<=(sprout::comparison_forwarder<Compare> const& lhs, T const& rhs) {
205+ return sprout::less_comparison<T, Compare>(rhs, lhs.comp());
206+ }
207+ template<typename T>
208+ inline SPROUT_CONSTEXPR sprout::less_comparison<T>
209+ operator<=(sprout::comparison_forwarder<>, T const& rhs) {
210+ return sprout::less_comparison<T>(rhs);
211+ }
212+ //
213+ // operator<
214+ //
215+ template<typename T, typename Compare, typename U>
216+ inline SPROUT_CONSTEXPR sprout::less_comparison<U, Compare>
217+ operator<(sprout::comparison_holder<T, Compare> const& lhs, U const& rhs) {
218+ return lhs.comp()(lhs.get(), rhs) ? sprout::less_comparison<U, Compare>(rhs, lhs.comp())
219+ : sprout::less_comparison<U, Compare>()
220+ ;
221+ }
222+ template<typename T, typename U>
223+ inline SPROUT_CONSTEXPR sprout::less_comparison<U>
224+ operator<(sprout::comparison_holder<T> const& lhs, U const& rhs) {
225+ return lhs.get() < rhs ? sprout::less_comparison<U>(rhs)
226+ : sprout::less_comparison<U>()
227+ ;
228+ }
229+ template<typename T, typename Compare, typename U>
230+ inline SPROUT_CONSTEXPR sprout::less_comparison<U, Compare>
231+ operator<(sprout::less_comparison<T, Compare> const& lhs, U const& rhs) {
232+ return lhs.comp()(lhs.get(), rhs) ? sprout::less_comparison<U, Compare>(rhs, lhs.comp())
233+ : sprout::less_comparison<U, Compare>()
234+ ;
235+ }
236+ template<typename T, typename U>
237+ inline SPROUT_CONSTEXPR sprout::less_comparison<U>
238+ operator<(sprout::less_comparison<T> const& lhs, U const& rhs) {
239+ return lhs && lhs.get() < rhs ? sprout::less_comparison<U>(rhs)
240+ : sprout::less_comparison<U>()
241+ ;
242+ }
243+ //
244+ // operator<=
245+ //
246+ template<typename T, typename Compare, typename U>
247+ inline SPROUT_CONSTEXPR sprout::less_comparison<U, Compare>
248+ operator<=(sprout::comparison_holder<T, Compare> const& lhs, U const& rhs) {
249+ return !lhs.comp()(rhs, lhs.get()) ? sprout::less_comparison<U, Compare>(rhs, lhs.comp())
250+ : sprout::less_comparison<U, Compare>()
251+ ;
252+ }
253+ template<typename T, typename U>
254+ inline SPROUT_CONSTEXPR sprout::less_comparison<U>
255+ operator<=(sprout::comparison_holder<T> const& lhs, U const& rhs) {
256+ return lhs.get() <= rhs ? sprout::less_comparison<U>(rhs)
257+ : sprout::less_comparison<U>()
258+ ;
259+ }
260+ template<typename T, typename Compare, typename U>
261+ inline SPROUT_CONSTEXPR sprout::less_comparison<U, Compare>
262+ operator<=(sprout::less_comparison<T, Compare> const& lhs, U const& rhs) {
263+ return !lhs.comp()(rhs, lhs.get()) ? sprout::less_comparison<U, Compare>(rhs, lhs.comp())
264+ : sprout::less_comparison<U, Compare>()
265+ ;
266+ }
267+ template<typename T, typename U>
268+ inline SPROUT_CONSTEXPR sprout::less_comparison<U>
269+ operator<=(sprout::less_comparison<T> const& lhs, U const& rhs) {
270+ return lhs && lhs.get() <= rhs ? sprout::less_comparison<U>(rhs)
271+ : sprout::less_comparison<U>()
272+ ;
273+ }
274+ //
275+ // operator>
276+ // operator>=
277+ // operator==
278+ // operator!=
279+ //
280+ template<typename T, typename Compare, typename U>
281+ SPROUT_NON_CONSTEXPR void
282+ operator>(sprout::less_comparison<T, Compare> const&, U const&) SPROUT_DELETED_FUNCTION_DECL
283+ template<typename T, typename Compare, typename U>
284+ SPROUT_NON_CONSTEXPR void
285+ operator>=(sprout::less_comparison<T, Compare> const&, U const&) SPROUT_DELETED_FUNCTION_DECL
286+ template<typename T, typename Compare, typename U>
287+ SPROUT_NON_CONSTEXPR void
288+ operator==(sprout::less_comparison<T, Compare> const&, U const&) SPROUT_DELETED_FUNCTION_DECL
289+ template<typename T, typename Compare, typename U>
290+ SPROUT_NON_CONSTEXPR void
291+ operator!=(sprout::less_comparison<T, Compare> const&, U const&) SPROUT_DELETED_FUNCTION_DECL
292+
293+ //
294+ // greater_comparison
295+ //
296+ template<typename T, typename Compare = void>
297+ class greater_comparison
298+ : public sprout::comparison_base<T, Compare>
299+ {
300+ public:
301+ typedef sprout::comparison_base<T, Compare> base_type;
302+ typedef typename base_type::value_type value_type;
303+ typedef typename base_type::compare_type compare_type;
304+ public:
305+ SPROUT_CONSTEXPR greater_comparison() SPROUT_DEFAULTED_DEFAULT_CONSTRUCTOR_DECL
306+ greater_comparison(greater_comparison const&) = default;
307+ SPROUT_CONSTEXPR greater_comparison(value_type const& value, compare_type const& comp)
308+ : base_type(value, comp)
309+ {}
310+ };
311+ template<typename T>
312+ class greater_comparison<T, void>
313+ : public sprout::comparison_base<T>
314+ {
315+ public:
316+ typedef sprout::comparison_base<T> base_type;
317+ typedef typename base_type::value_type value_type;
318+ public:
319+ SPROUT_CONSTEXPR greater_comparison() SPROUT_DEFAULTED_DEFAULT_CONSTRUCTOR_DECL
320+ greater_comparison(greater_comparison const&) = default;
321+ explicit SPROUT_CONSTEXPR greater_comparison(value_type const& value)
322+ : base_type(value)
323+ {}
324+ };
325+ //
326+ // operator>
327+ // operator>=
328+ //
329+ template<typename T, typename Compare>
330+ inline SPROUT_CONSTEXPR sprout::greater_comparison<T, Compare>
331+ operator>(sprout::comparison_forwarder<Compare> const& lhs, T const& rhs) {
332+ return sprout::greater_comparison<T>(rhs, lhs.comp());
333+ }
334+ template<typename T>
335+ inline SPROUT_CONSTEXPR sprout::greater_comparison<T>
336+ operator>(sprout::comparison_forwarder<>, T const& rhs) {
337+ return sprout::greater_comparison<T>(rhs);
338+ }
339+ template<typename T, typename Compare>
340+ inline SPROUT_CONSTEXPR sprout::greater_comparison<T, Compare>
341+ operator>=(sprout::comparison_forwarder<Compare> const& lhs, T const& rhs) {
342+ return sprout::greater_comparison<T>(rhs, lhs.comp());
343+ }
344+ template<typename T>
345+ inline SPROUT_CONSTEXPR sprout::greater_comparison<T>
346+ operator>=(sprout::comparison_forwarder<>, T const& rhs) {
347+ return sprout::greater_comparison<T>(rhs);
348+ }
349+ //
350+ // operator>
351+ //
352+ template<typename T, typename Compare, typename U>
353+ inline SPROUT_CONSTEXPR sprout::greater_comparison<U, Compare>
354+ operator>(sprout::comparison_holder<T, Compare> const& lhs, U const& rhs) {
355+ return lhs.comp()(rhs, lhs.get()) ? sprout::greater_comparison<U, Compare>(rhs, lhs.comp())
356+ : sprout::greater_comparison<U, Compare>()
357+ ;
358+ }
359+ template<typename T, typename U>
360+ inline SPROUT_CONSTEXPR sprout::greater_comparison<U>
361+ operator>(sprout::comparison_holder<T> const& lhs, U const& rhs) {
362+ return rhs < lhs.get() ? sprout::greater_comparison<U>(rhs)
363+ : sprout::greater_comparison<U>()
364+ ;
365+ }
366+ template<typename T, typename Compare, typename U>
367+ inline SPROUT_CONSTEXPR sprout::greater_comparison<U, Compare>
368+ operator>(sprout::greater_comparison<T, Compare> const& lhs, U const& rhs) {
369+ return lhs.comp()(rhs, lhs.get()) ? sprout::greater_comparison<U, Compare>(rhs, lhs.comp())
370+ : sprout::greater_comparison<U, Compare>()
371+ ;
372+ }
373+ template<typename T, typename U>
374+ inline SPROUT_CONSTEXPR sprout::greater_comparison<U>
375+ operator>(sprout::greater_comparison<T> const& lhs, U const& rhs) {
376+ return lhs && rhs < lhs.get() ? sprout::greater_comparison<U>(rhs)
377+ : sprout::greater_comparison<U>()
378+ ;
379+ }
380+ //
381+ // operator>=
382+ //
383+ template<typename T, typename Compare, typename U>
384+ inline SPROUT_CONSTEXPR sprout::greater_comparison<U, Compare>
385+ operator>=(sprout::comparison_holder<T, Compare> const& lhs, U const& rhs) {
386+ return !lhs.comp()(lhs.get(), rhs) ? sprout::greater_comparison<U, Compare>(rhs, lhs.comp())
387+ : sprout::greater_comparison<U, Compare>()
388+ ;
389+ }
390+ template<typename T, typename U>
391+ inline SPROUT_CONSTEXPR sprout::greater_comparison<U>
392+ operator>=(sprout::comparison_holder<T> const& lhs, U const& rhs) {
393+ return !(lhs.get() < rhs) ? sprout::greater_comparison<U>(rhs)
394+ : sprout::greater_comparison<U>()
395+ ;
396+ }
397+ template<typename T, typename Compare, typename U>
398+ inline SPROUT_CONSTEXPR sprout::greater_comparison<U, Compare>
399+ operator>=(sprout::greater_comparison<T, Compare> const& lhs, U const& rhs) {
400+ return !lhs.comp()(lhs.get(), rhs) ? sprout::greater_comparison<U, Compare>(rhs, lhs.comp())
401+ : sprout::greater_comparison<U, Compare>()
402+ ;
403+ }
404+ template<typename T, typename U>
405+ inline SPROUT_CONSTEXPR sprout::greater_comparison<U>
406+ operator>=(sprout::greater_comparison<T> const& lhs, U const& rhs) {
407+ return lhs && !(lhs.get() < rhs) ? sprout::greater_comparison<U>(rhs)
408+ : sprout::greater_comparison<U>()
409+ ;
410+ }
411+ //
412+ // operator<
413+ // operator<=
414+ // operator==
415+ // operator!=
416+ //
417+ template<typename T, typename Compare, typename U>
418+ SPROUT_NON_CONSTEXPR void
419+ operator<(sprout::greater_comparison<T, Compare> const&, U const&) SPROUT_DELETED_FUNCTION_DECL
420+ template<typename T, typename Compare, typename U>
421+ SPROUT_NON_CONSTEXPR void
422+ operator<=(sprout::greater_comparison<T, Compare> const&, U const&) SPROUT_DELETED_FUNCTION_DECL
423+ template<typename T, typename Compare, typename U>
424+ SPROUT_NON_CONSTEXPR void
425+ operator==(sprout::greater_comparison<T, Compare> const&, U const&) SPROUT_DELETED_FUNCTION_DECL
426+ template<typename T, typename Compare, typename U>
427+ SPROUT_NON_CONSTEXPR void
428+ operator!=(sprout::greater_comparison<T, Compare> const&, U const&) SPROUT_DELETED_FUNCTION_DECL
429+
430+ //
431+ // equal_comparison
432+ //
433+ template<typename T, typename Compare = void>
434+ class equal_comparison
435+ : public sprout::comparison_base<T, Compare>
436+ {
437+ public:
438+ typedef sprout::comparison_base<T, Compare> base_type;
439+ typedef typename base_type::value_type value_type;
440+ typedef typename base_type::compare_type compare_type;
441+ public:
442+ SPROUT_CONSTEXPR equal_comparison() SPROUT_DEFAULTED_DEFAULT_CONSTRUCTOR_DECL
443+ equal_comparison(equal_comparison const&) = default;
444+ SPROUT_CONSTEXPR equal_comparison(value_type const& value, compare_type const& comp)
445+ : base_type(value, comp)
446+ {}
447+ };
448+ template<typename T>
449+ class equal_comparison<T, void>
450+ : public sprout::comparison_base<T>
451+ {
452+ public:
453+ typedef sprout::comparison_base<T> base_type;
454+ typedef typename base_type::value_type value_type;
455+ public:
456+ SPROUT_CONSTEXPR equal_comparison() SPROUT_DEFAULTED_DEFAULT_CONSTRUCTOR_DECL
457+ equal_comparison(equal_comparison const&) = default;
458+ explicit SPROUT_CONSTEXPR equal_comparison(value_type const& value)
459+ : base_type(value)
460+ {}
461+ };
462+ //
463+ // operator==
464+ //
465+ template<typename T, typename Compare>
466+ inline SPROUT_CONSTEXPR sprout::equal_comparison<T, Compare>
467+ operator==(sprout::comparison_forwarder<Compare> const& lhs, T const& rhs) {
468+ return sprout::equal_comparison<T>(rhs, lhs.comp());
469+ }
470+ template<typename T>
471+ inline SPROUT_CONSTEXPR sprout::equal_comparison<T>
472+ operator==(sprout::comparison_forwarder<>, T const& rhs) {
473+ return sprout::equal_comparison<T>(rhs);
474+ }
475+ //
476+ // operator==
477+ //
478+ template<typename T, typename Compare, typename U>
479+ inline SPROUT_CONSTEXPR sprout::equal_comparison<U, Compare>
480+ operator==(sprout::comparison_holder<T, Compare> const& lhs, U const& rhs) {
481+ return !lhs.comp()(lhs.get(), rhs) && !lhs.comp()(rhs, lhs.get()) ? sprout::equal_comparison<U, Compare>(rhs, lhs.comp())
482+ : sprout::equal_comparison<U, Compare>()
483+ ;
484+ }
485+ template<typename T, typename U>
486+ inline SPROUT_CONSTEXPR sprout::equal_comparison<U>
487+ operator==(sprout::comparison_holder<T> const& lhs, U const& rhs) {
488+ return !(lhs.get() < rhs) && !(rhs < lhs.get()) ? sprout::equal_comparison<U>(rhs)
489+ : sprout::equal_comparison<U>()
490+ ;
491+ }
492+ template<typename T, typename Compare, typename U>
493+ inline SPROUT_CONSTEXPR sprout::equal_comparison<U, Compare>
494+ operator==(sprout::equal_comparison<T, Compare> const& lhs, U const& rhs) {
495+ return !lhs.comp()(lhs.get(), rhs) && !lhs.comp()(rhs, lhs.get()) ? sprout::equal_comparison<U, Compare>(rhs, lhs.comp())
496+ : sprout::equal_comparison<U, Compare>()
497+ ;
498+ }
499+ template<typename T, typename U>
500+ inline SPROUT_CONSTEXPR sprout::equal_comparison<U>
501+ operator==(sprout::equal_comparison<T> const& lhs, U const& rhs) {
502+ return lhs && !(lhs.get() < rhs) && !(rhs < lhs.get()) ? sprout::equal_comparison<U>(rhs)
503+ : sprout::equal_comparison<U>()
504+ ;
505+ }
506+ //
507+ // operator<
508+ // operator<=
509+ // operator>
510+ // operator>=
511+ // operator!=
512+ //
513+ template<typename T, typename Compare, typename U>
514+ SPROUT_NON_CONSTEXPR void
515+ operator<(sprout::equal_comparison<T, Compare> const&, U const&) SPROUT_DELETED_FUNCTION_DECL
516+ template<typename T, typename Compare, typename U>
517+ SPROUT_NON_CONSTEXPR void
518+ operator<=(sprout::equal_comparison<T, Compare> const&, U const&) SPROUT_DELETED_FUNCTION_DECL
519+ template<typename T, typename Compare, typename U>
520+ SPROUT_NON_CONSTEXPR void
521+ operator>(sprout::equal_comparison<T, Compare> const&, U const&) SPROUT_DELETED_FUNCTION_DECL
522+ template<typename T, typename Compare, typename U>
523+ SPROUT_NON_CONSTEXPR void
524+ operator>=(sprout::equal_comparison<T, Compare> const&, U const&) SPROUT_DELETED_FUNCTION_DECL
525+ template<typename T, typename Compare, typename U>
526+ SPROUT_NON_CONSTEXPR void
527+ operator!=(sprout::equal_comparison<T, Compare> const&, U const&) SPROUT_DELETED_FUNCTION_DECL
528+} // namespace sprout
529+
530+#endif // #ifndef SPROUT_UTILITY_COMPARISON_HPP
--- sprout/utility.hpp (revision 5253)
+++ sprout/utility.hpp (revision 5254)
@@ -22,5 +22,6 @@
2222 #include <sprout/utility/any_convertible.hpp>
2323 #include <sprout/utility/use_default.hpp>
2424 #include <sprout/utility/loop.hpp>
25+#include <sprout/utility/comparison.hpp>
2526
2627 #endif // #ifndef SPROUT_UTILITY_HPP
--- sprout/valarray/gslice_array.hpp (revision 5253)
+++ sprout/valarray/gslice_array.hpp (revision 5254)
@@ -81,7 +81,7 @@
8181 sprout::valarray<std::size_t, M> size_;
8282 sprout::valarray<std::size_t, M> stride_;
8383 private:
84- gslice_array() = delete;
84+ gslice_array() SPROUT_DELETED_FUNCTION_DECL
8585 SPROUT_CONSTEXPR gslice_array(sprout::valarray<T, N>& arr, gslice_type const& gslice)
8686 : arr_(arr)
8787 , start_(gslice.start())
--- sprout/valarray/indirect_array.hpp (revision 5253)
+++ sprout/valarray/indirect_array.hpp (revision 5254)
@@ -42,7 +42,7 @@
4242 sprout::value_holder<valarray_type&> arr_;
4343 indexes_type indexes_;
4444 private:
45- indirect_array() = delete;
45+ indirect_array() SPROUT_DELETED_FUNCTION_DECL
4646 SPROUT_CONSTEXPR indirect_array(sprout::valarray<T, N>& arr, indexes_type const& indexes)
4747 : arr_(arr)
4848 , indexes_(indexes)
--- sprout/valarray/mask_array.hpp (revision 5253)
+++ sprout/valarray/mask_array.hpp (revision 5254)
@@ -45,7 +45,7 @@
4545 sprout::value_holder<valarray_type&> arr_;
4646 indexes_type indexes_;
4747 private:
48- mask_array() = delete;
48+ mask_array() SPROUT_DELETED_FUNCTION_DECL
4949 SPROUT_CONSTEXPR mask_array(sprout::valarray<T, N>& arr, mask_type const& mask)
5050 : arr_(arr)
5151 , indexes_(
--- sprout/valarray/slice_array.hpp (revision 5253)
+++ sprout/valarray/slice_array.hpp (revision 5254)
@@ -66,7 +66,7 @@
6666 sprout::value_holder<valarray_type&> arr_;
6767 sprout::slice slice_;
6868 private:
69- slice_array() = delete;
69+ slice_array() SPROUT_DELETED_FUNCTION_DECL
7070 SPROUT_CONSTEXPR slice_array(sprout::valarray<T, N>& arr, sprout::slice const& slice)
7171 : arr_(arr), slice_(slice)
7272 {}
Show on old repository browser