1 // Copyright (C) 2011 - 2012 Andrzej Krzemienski.
2 //
3 // Use, modification, and distribution is subject to the Boost Software
4 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
5 // http://www.boost.org/LICENSE_1_0.txt)
6 //
7 // The idea and interface is based on Boost.Optional library
8 // authored by Fernando Luis Cacciola Carballal
9
10 # ifndef ___OPTIONAL_HPP___
11 # define ___OPTIONAL_HPP___
12
13 # include <utility>
14 # include <type_traits>
15 # include <initializer_list>
16 # include <cassert>
17 # include <functional>
18 # include <string>
19 # include <stdexcept>
20
21 # define TR2_OPTIONAL_REQUIRES(...) typename enable_if<__VA_ARGS__::value, bool>::type = false
22
23 # if defined __GNUC__ // NOTE: GNUC is also defined for Clang
24 # if (__GNUC__ == 4) && (__GNUC_MINOR__ >= 8)
25 # define TR2_OPTIONAL_GCC_4_8_AND_HIGHER___
26 # elif (__GNUC__ > 4)
27 # define TR2_OPTIONAL_GCC_4_8_AND_HIGHER___
28 # endif
29 #
30 # if (__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)
31 # define TR2_OPTIONAL_GCC_4_7_AND_HIGHER___
32 # elif (__GNUC__ > 4)
33 # define TR2_OPTIONAL_GCC_4_7_AND_HIGHER___
34 # endif
35 #
36 # if (__GNUC__ == 4) && (__GNUC_MINOR__ == 8) && (__GNUC_PATCHLEVEL__ >= 1)
37 # define TR2_OPTIONAL_GCC_4_8_1_AND_HIGHER___
38 # elif (__GNUC__ == 4) && (__GNUC_MINOR__ >= 9)
39 # define TR2_OPTIONAL_GCC_4_8_1_AND_HIGHER___
40 # elif (__GNUC__ > 4)
41 # define TR2_OPTIONAL_GCC_4_8_1_AND_HIGHER___
42 # endif
43 # endif
44 #
45 # if defined __clang_major__
46 # if (__clang_major__ == 3 && __clang_minor__ >= 5)
47 # define TR2_OPTIONAL_CLANG_3_5_AND_HIGHTER_
48 # elif (__clang_major__ > 3)
49 # define TR2_OPTIONAL_CLANG_3_5_AND_HIGHTER_
50 # endif
51 # if defined TR2_OPTIONAL_CLANG_3_5_AND_HIGHTER_
52 # define TR2_OPTIONAL_CLANG_3_4_2_AND_HIGHER_
53 # elif (__clang_major__ == 3 && __clang_minor__ == 4 && __clang_patchlevel__ >= 2)
54 # define TR2_OPTIONAL_CLANG_3_4_2_AND_HIGHER_
55 # endif
56 # endif
57 #
58 # if defined _MSC_VER
59 # if (_MSC_VER >= 1900)
60 # define TR2_OPTIONAL_MSVC_2015_AND_HIGHER___
61 # endif
62 # endif
63
64 # if defined __clang__
65 # if (__clang_major__ > 2) || (__clang_major__ == 2) && (__clang_minor__ >= 9)
66 # define OPTIONAL_HAS_THIS_RVALUE_REFS 1
67 # else
68 # define OPTIONAL_HAS_THIS_RVALUE_REFS 0
69 # endif
70 # elif defined TR2_OPTIONAL_GCC_4_8_1_AND_HIGHER___
71 # define OPTIONAL_HAS_THIS_RVALUE_REFS 1
72 # elif defined TR2_OPTIONAL_MSVC_2015_AND_HIGHER___
73 # define OPTIONAL_HAS_THIS_RVALUE_REFS 1
74 # else
75 # define OPTIONAL_HAS_THIS_RVALUE_REFS 0
76 # endif
77
78
79 # if defined TR2_OPTIONAL_GCC_4_8_1_AND_HIGHER___
80 # define OPTIONAL_HAS_CONSTEXPR_INIT_LIST 1
81 # define OPTIONAL_CONSTEXPR_INIT_LIST constexpr
82 # else
83 # define OPTIONAL_HAS_CONSTEXPR_INIT_LIST 0
84 # define OPTIONAL_CONSTEXPR_INIT_LIST
85 # endif
86
87 # if defined TR2_OPTIONAL_CLANG_3_5_AND_HIGHTER_ && (defined __cplusplus) && (__cplusplus != 201103L)
88 # define OPTIONAL_HAS_MOVE_ACCESSORS 1
89 # else
90 # define OPTIONAL_HAS_MOVE_ACCESSORS 0
91 # endif
92
93 # // In C++11 constexpr implies const, so we need to make non-const members also non-constexpr
94 # if (defined __cplusplus) && (__cplusplus == 201103L)
95 # define OPTIONAL_MUTABLE_CONSTEXPR
96 # else
97 # define OPTIONAL_MUTABLE_CONSTEXPR constexpr
98 # endif
99
100 namespace std{
101
102 namespace experimental{
103
104 // BEGIN workaround for missing is_trivially_destructible
105 # if defined TR2_OPTIONAL_GCC_4_8_AND_HIGHER___
106 // leave it: it is already there
107 # elif defined TR2_OPTIONAL_CLANG_3_4_2_AND_HIGHER_
108 // leave it: it is already there
109 # elif defined TR2_OPTIONAL_MSVC_2015_AND_HIGHER___
110 // leave it: it is already there
111 # elif defined TR2_OPTIONAL_DISABLE_EMULATION_OF_TYPE_TRAITS
112 // leave it: the user doesn't want it
113 # else
114 template <typename T>
115 using is_trivially_destructible = std::has_trivial_destructor<T>;
116 # endif
117 // END workaround for missing is_trivially_destructible
118
119 # if (defined TR2_OPTIONAL_GCC_4_7_AND_HIGHER___)
120 // leave it; our metafunctions are already defined.
121 # elif defined TR2_OPTIONAL_CLANG_3_4_2_AND_HIGHER_
122 // leave it; our metafunctions are already defined.
123 # elif defined TR2_OPTIONAL_MSVC_2015_AND_HIGHER___
124 // leave it: it is already there
125 # elif defined TR2_OPTIONAL_DISABLE_EMULATION_OF_TYPE_TRAITS
126 // leave it: the user doesn't want it
127 # else
128
129
130 // workaround for missing traits in GCC and CLANG
131 template <class T>
132 struct is_nothrow_move_constructible
133 {
134 constexpr static bool value = std::is_nothrow_constructible<T, T&&>::value;
135 };
136
137
138 template <class T, class U>
139 struct is_assignable
140 {
141 template <class X, class Y>
142 constexpr static bool has_assign(...) { return false; }
143
144 template <class X, class Y, size_t S = sizeof((std::declval<X>() = std::declval<Y>(), true)) >
145 // the comma operator is necessary for the cases where operator= returns void
146 constexpr static bool has_assign(bool) { return true; }
147
148 constexpr static bool value = has_assign<T, U>(true);
149 };
150
151
152 template <class T>
153 struct is_nothrow_move_assignable
154 {
155 template <class X, bool has_any_move_assign>
156 struct has_nothrow_move_assign {
157 constexpr static bool value = false;
158 };
159
160 template <class X>
161 struct has_nothrow_move_assign<X, true> {
162 constexpr static bool value = noexcept( std::declval<X&>() = std::declval<X&&>() );
163 };
164
165 constexpr static bool value = has_nothrow_move_assign<T, is_assignable<T&, T&&>::value>::value;
166 };
167 // end workaround
168
169
170 # endif
171
172
173
174 // 20.5.4, optional for object types
175 template <class T> class optional;
176
177 // 20.5.5, optional for lvalue reference types
178 template <class T> class optional<T&>;
179
180
181 // workaround: std utility functions aren't constexpr yet
constexpr_forward(typename std::remove_reference<T>::type & t)182 template <class T> inline constexpr T&& constexpr_forward(typename std::remove_reference<T>::type& t) noexcept
183 {
184 return static_cast<T&&>(t);
185 }
186
constexpr_forward(typename std::remove_reference<T>::type && t)187 template <class T> inline constexpr T&& constexpr_forward(typename std::remove_reference<T>::type&& t) noexcept
188 {
189 static_assert(!std::is_lvalue_reference<T>::value, "!!");
190 return static_cast<T&&>(t);
191 }
192
constexpr_move(T && t)193 template <class T> inline constexpr typename std::remove_reference<T>::type&& constexpr_move(T&& t) noexcept
194 {
195 return static_cast<typename std::remove_reference<T>::type&&>(t);
196 }
197
198
199 #if defined NDEBUG
200 # define TR2_OPTIONAL_ASSERTED_EXPRESSION(CHECK, EXPR) (EXPR)
201 #else
202 # define TR2_OPTIONAL_ASSERTED_EXPRESSION(CHECK, EXPR) ((CHECK) ? (EXPR) : ([]{assert(!#CHECK);}(), (EXPR)))
203 #endif
204
205
206 namespace detail_
207 {
208
209 // static_addressof: a constexpr version of addressof
210 template <typename T>
211 struct has_overloaded_addressof
212 {
213 template <class X>
has_overloadstd::experimental::detail_::has_overloaded_addressof214 constexpr static bool has_overload(...) { return false; }
215
216 template <class X, size_t S = sizeof(std::declval<X&>().operator&()) >
has_overloadstd::experimental::detail_::has_overloaded_addressof217 constexpr static bool has_overload(bool) { return true; }
218
219 constexpr static bool value = has_overload<T>(true);
220 };
221
222 template <typename T, TR2_OPTIONAL_REQUIRES(!has_overloaded_addressof<T>)>
static_addressof(T & ref)223 constexpr T* static_addressof(T& ref)
224 {
225 return &ref;
226 }
227
228 template <typename T, TR2_OPTIONAL_REQUIRES(has_overloaded_addressof<T>)>
229 T* static_addressof(T& ref)
230 {
231 return std::addressof(ref);
232 }
233
234
235 // the call to convert<A>(b) has return type A and converts b to type A iff b decltype(b) is implicitly convertible to A
236 template <class U>
convert(U v)237 constexpr U convert(U v) { return v; }
238
239 } // namespace detail
240
241
242 constexpr struct trivial_init_t{} trivial_init{};
243
244
245 // 20.5.6, In-place construction
246 constexpr struct in_place_t{} in_place{};
247
248
249 // 20.5.7, Disengaged state indicator
250 struct nullopt_t
251 {
252 struct init{};
nullopt_tstd::experimental::nullopt_t253 constexpr explicit nullopt_t(init){}
254 };
255 constexpr nullopt_t nullopt{nullopt_t::init()};
256
257
258 // 20.5.8, class bad_optional_access
259 class bad_optional_access : public logic_error {
260 public:
bad_optional_access(const string & what_arg)261 explicit bad_optional_access(const string& what_arg) : logic_error{what_arg} {}
bad_optional_access(const char * what_arg)262 explicit bad_optional_access(const char* what_arg) : logic_error{what_arg} {}
263 };
264
265
266 template <class T>
267 union storage_t
268 {
269 unsigned char dummy_;
270 T value_;
271
storage_t(trivial_init_t)272 constexpr storage_t( trivial_init_t ) noexcept : dummy_() {};
273
274 template <class... Args>
storage_t(Args &&...args)275 constexpr storage_t( Args&&... args ) : value_(constexpr_forward<Args>(args)...) {}
276
~storage_t()277 ~storage_t(){}
278 };
279
280
281 template <class T>
282 union constexpr_storage_t
283 {
284 unsigned char dummy_;
285 T value_;
286
constexpr_storage_t(trivial_init_t)287 constexpr constexpr_storage_t( trivial_init_t ) noexcept : dummy_() {};
288
289 template <class... Args>
constexpr_storage_t(Args &&...args)290 constexpr constexpr_storage_t( Args&&... args ) : value_(constexpr_forward<Args>(args)...) {}
291
292 ~constexpr_storage_t() = default;
293 };
294
295
296 template <class T>
297 struct optional_base
298 {
299 bool init_;
300 storage_t<T> storage_;
301
optional_basestd::experimental::optional_base302 constexpr optional_base() noexcept : init_(false), storage_(trivial_init) {};
303
optional_basestd::experimental::optional_base304 explicit constexpr optional_base(const T& v) : init_(true), storage_(v) {}
305
optional_basestd::experimental::optional_base306 explicit constexpr optional_base(T&& v) : init_(true), storage_(constexpr_move(v)) {}
307
optional_basestd::experimental::optional_base308 template <class... Args> explicit optional_base(in_place_t, Args&&... args)
309 : init_(true), storage_(constexpr_forward<Args>(args)...) {}
310
311 template <class U, class... Args, TR2_OPTIONAL_REQUIRES(is_constructible<T, std::initializer_list<U>>)>
optional_basestd::experimental::optional_base312 explicit optional_base(in_place_t, std::initializer_list<U> il, Args&&... args)
313 : init_(true), storage_(il, std::forward<Args>(args)...) {}
314
~optional_basestd::experimental::optional_base315 ~optional_base() { if (init_) storage_.value_.T::~T(); }
316 };
317
318
319 template <class T>
320 struct constexpr_optional_base
321 {
322 bool init_;
323 constexpr_storage_t<T> storage_;
324
constexpr_optional_basestd::experimental::constexpr_optional_base325 constexpr constexpr_optional_base() noexcept : init_(false), storage_(trivial_init) {};
326
constexpr_optional_basestd::experimental::constexpr_optional_base327 explicit constexpr constexpr_optional_base(const T& v) : init_(true), storage_(v) {}
328
constexpr_optional_basestd::experimental::constexpr_optional_base329 explicit constexpr constexpr_optional_base(T&& v) : init_(true), storage_(constexpr_move(v)) {}
330
constexpr_optional_basestd::experimental::constexpr_optional_base331 template <class... Args> explicit constexpr constexpr_optional_base(in_place_t, Args&&... args)
332 : init_(true), storage_(constexpr_forward<Args>(args)...) {}
333
334 template <class U, class... Args, TR2_OPTIONAL_REQUIRES(is_constructible<T, std::initializer_list<U>>)>
constexpr_optional_basestd::experimental::constexpr_optional_base335 OPTIONAL_CONSTEXPR_INIT_LIST explicit constexpr_optional_base(in_place_t, std::initializer_list<U> il, Args&&... args)
336 : init_(true), storage_(il, std::forward<Args>(args)...) {}
337
338 ~constexpr_optional_base() = default;
339 };
340
341 template <class T>
342 using OptionalBase = typename std::conditional<
343 is_trivially_destructible<T>::value,
344 constexpr_optional_base<typename std::remove_const<T>::type>,
345 optional_base<typename std::remove_const<T>::type>
346 >::type;
347
348
349
350 template <class T>
351 class optional : private OptionalBase<T>
352 {
353 static_assert( !std::is_same<typename std::decay<T>::type, nullopt_t>::value, "bad T" );
354 static_assert( !std::is_same<typename std::decay<T>::type, in_place_t>::value, "bad T" );
355
356
initialized() const357 constexpr bool initialized() const noexcept { return OptionalBase<T>::init_; }
dataptr()358 typename std::remove_const<T>::type* dataptr() { return std::addressof(OptionalBase<T>::storage_.value_); }
dataptr() const359 constexpr const T* dataptr() const { return detail_::static_addressof(OptionalBase<T>::storage_.value_); }
360
361 # if OPTIONAL_HAS_THIS_RVALUE_REFS == 1
contained_val() const362 constexpr const T& contained_val() const& { return OptionalBase<T>::storage_.value_; }
363 # if OPTIONAL_HAS_MOVE_ACCESSORS == 1
contained_val()364 OPTIONAL_MUTABLE_CONSTEXPR T&& contained_val() && { return std::move(OptionalBase<T>::storage_.value_); }
contained_val()365 OPTIONAL_MUTABLE_CONSTEXPR T& contained_val() & { return OptionalBase<T>::storage_.value_; }
366 # else
contained_val()367 T& contained_val() & { return OptionalBase<T>::storage_.value_; }
contained_val()368 T&& contained_val() && { return std::move(OptionalBase<T>::storage_.value_); }
369 # endif
370 # else
contained_val() const371 constexpr const T& contained_val() const { return OptionalBase<T>::storage_.value_; }
contained_val()372 T& contained_val() { return OptionalBase<T>::storage_.value_; }
373 # endif
374
clear()375 void clear() noexcept {
376 if (initialized()) dataptr()->T::~T();
377 OptionalBase<T>::init_ = false;
378 }
379
380 template <class... Args>
initialize(Args &&...args)381 void initialize(Args&&... args) noexcept(noexcept(T(std::forward<Args>(args)...)))
382 {
383 assert(!OptionalBase<T>::init_);
384 ::new (static_cast<void*>(dataptr())) T(std::forward<Args>(args)...);
385 OptionalBase<T>::init_ = true;
386 }
387
388 template <class U, class... Args>
initialize(std::initializer_list<U> il,Args &&...args)389 void initialize(std::initializer_list<U> il, Args&&... args) noexcept(noexcept(T(il, std::forward<Args>(args)...)))
390 {
391 assert(!OptionalBase<T>::init_);
392 ::new (static_cast<void*>(dataptr())) T(il, std::forward<Args>(args)...);
393 OptionalBase<T>::init_ = true;
394 }
395
396 public:
397 typedef T value_type;
398
399 // 20.5.5.1, constructors
optional()400 constexpr optional() noexcept : OptionalBase<T>() {};
optional(nullopt_t)401 constexpr optional(nullopt_t) noexcept : OptionalBase<T>() {};
402
optional(const optional & rhs)403 optional(const optional& rhs)
404 : OptionalBase<T>()
405 {
406 if (rhs.initialized()) {
407 ::new (static_cast<void*>(dataptr())) T(*rhs);
408 OptionalBase<T>::init_ = true;
409 }
410 }
411
optional(optional && rhs)412 optional(optional&& rhs) noexcept(is_nothrow_move_constructible<T>::value)
413 : OptionalBase<T>()
414 {
415 if (rhs.initialized()) {
416 ::new (static_cast<void*>(dataptr())) T(std::move(*rhs));
417 OptionalBase<T>::init_ = true;
418 }
419 }
420
optional(const T & v)421 constexpr optional(const T& v) : OptionalBase<T>(v) {}
422
optional(T && v)423 constexpr optional(T&& v) : OptionalBase<T>(constexpr_move(v)) {}
424
425 template <class... Args>
optional(in_place_t,Args &&...args)426 explicit constexpr optional(in_place_t, Args&&... args)
427 : OptionalBase<T>(in_place_t{}, constexpr_forward<Args>(args)...) {}
428
429 template <class U, class... Args, TR2_OPTIONAL_REQUIRES(is_constructible<T, std::initializer_list<U>>)>
optional(in_place_t,std::initializer_list<U> il,Args &&...args)430 OPTIONAL_CONSTEXPR_INIT_LIST explicit optional(in_place_t, std::initializer_list<U> il, Args&&... args)
431 : OptionalBase<T>(in_place_t{}, il, constexpr_forward<Args>(args)...) {}
432
433 // 20.5.4.2, Destructor
434 ~optional() = default;
435
436 // 20.5.4.3, assignment
operator =(nullopt_t)437 optional& operator=(nullopt_t) noexcept
438 {
439 clear();
440 return *this;
441 }
442
operator =(const optional & rhs)443 optional& operator=(const optional& rhs)
444 {
445 if (initialized() == true && rhs.initialized() == false) clear();
446 else if (initialized() == false && rhs.initialized() == true) initialize(*rhs);
447 else if (initialized() == true && rhs.initialized() == true) contained_val() = *rhs;
448 return *this;
449 }
450
operator =(optional && rhs)451 optional& operator=(optional&& rhs)
452 noexcept(is_nothrow_move_assignable<T>::value && is_nothrow_move_constructible<T>::value)
453 {
454 if (initialized() == true && rhs.initialized() == false) clear();
455 else if (initialized() == false && rhs.initialized() == true) initialize(std::move(*rhs));
456 else if (initialized() == true && rhs.initialized() == true) contained_val() = std::move(*rhs);
457 return *this;
458 }
459
460 template <class U>
operator =(U && v)461 auto operator=(U&& v)
462 -> typename enable_if
463 <
464 is_same<typename decay<U>::type, T>::value,
465 optional&
466 >::type
467 {
468 if (initialized()) { contained_val() = std::forward<U>(v); }
469 else { initialize(std::forward<U>(v)); }
470 return *this;
471 }
472
473
474 template <class... Args>
emplace(Args &&...args)475 void emplace(Args&&... args)
476 {
477 clear();
478 initialize(std::forward<Args>(args)...);
479 }
480
481 template <class U, class... Args>
emplace(initializer_list<U> il,Args &&...args)482 void emplace(initializer_list<U> il, Args&&... args)
483 {
484 clear();
485 initialize<U, Args...>(il, std::forward<Args>(args)...);
486 }
487
488 // 20.5.4.4, Swap
swap(optional<T> & rhs)489 void swap(optional<T>& rhs) noexcept(is_nothrow_move_constructible<T>::value && noexcept(swap(declval<T&>(), declval<T&>())))
490 {
491 if (initialized() == true && rhs.initialized() == false) { rhs.initialize(std::move(**this)); clear(); }
492 else if (initialized() == false && rhs.initialized() == true) { initialize(std::move(*rhs)); rhs.clear(); }
493 else if (initialized() == true && rhs.initialized() == true) { using std::swap; swap(**this, *rhs); }
494 }
495
496 // 20.5.4.5, Observers
497
operator bool() const498 explicit constexpr operator bool() const noexcept { return initialized(); }
499
operator ->() const500 constexpr T const* operator ->() const {
501 return TR2_OPTIONAL_ASSERTED_EXPRESSION(initialized(), dataptr());
502 }
503
504 # if OPTIONAL_HAS_MOVE_ACCESSORS == 1
505
operator ->()506 OPTIONAL_MUTABLE_CONSTEXPR T* operator ->() {
507 assert (initialized());
508 return dataptr();
509 }
510
operator *() const511 constexpr T const& operator *() const& {
512 return TR2_OPTIONAL_ASSERTED_EXPRESSION(initialized(), contained_val());
513 }
514
operator *()515 OPTIONAL_MUTABLE_CONSTEXPR T& operator *() & {
516 assert (initialized());
517 return contained_val();
518 }
519
operator *()520 OPTIONAL_MUTABLE_CONSTEXPR T&& operator *() && {
521 assert (initialized());
522 return constexpr_move(contained_val());
523 }
524
value() const525 constexpr T const& value() const& {
526 return initialized() ? contained_val() : (throw bad_optional_access("bad optional access"), contained_val());
527 }
528
value()529 OPTIONAL_MUTABLE_CONSTEXPR T& value() & {
530 return initialized() ? contained_val() : (throw bad_optional_access("bad optional access"), contained_val());
531 }
532
value()533 OPTIONAL_MUTABLE_CONSTEXPR T&& value() && {
534 if (!initialized()) throw bad_optional_access("bad optional access");
535 return std::move(contained_val());
536 }
537
538 # else
539
operator ->()540 T* operator ->() {
541 assert (initialized());
542 return dataptr();
543 }
544
operator *() const545 constexpr T const& operator *() const {
546 return TR2_OPTIONAL_ASSERTED_EXPRESSION(initialized(), contained_val());
547 }
548
operator *()549 T& operator *() {
550 assert (initialized());
551 return contained_val();
552 }
553
value() const554 constexpr T const& value() const {
555 return initialized() ? contained_val() : (throw bad_optional_access("bad optional access"), contained_val());
556 }
557
value()558 T& value() {
559 return initialized() ? contained_val() : (throw bad_optional_access("bad optional access"), contained_val());
560 }
561
562 # endif
563
564 # if OPTIONAL_HAS_THIS_RVALUE_REFS == 1
565
566 template <class V>
value_or(V && v) const567 constexpr T value_or(V&& v) const&
568 {
569 return *this ? **this : detail_::convert<T>(constexpr_forward<V>(v));
570 }
571
572 # if OPTIONAL_HAS_MOVE_ACCESSORS == 1
573
574 template <class V>
value_or(V && v)575 OPTIONAL_MUTABLE_CONSTEXPR T value_or(V&& v) &&
576 {
577 return *this ? constexpr_move(const_cast<optional<T>&>(*this).contained_val()) : detail_::convert<T>(constexpr_forward<V>(v));
578 }
579
580 # else
581
582 template <class V>
value_or(V && v)583 T value_or(V&& v) &&
584 {
585 return *this ? constexpr_move(const_cast<optional<T>&>(*this).contained_val()) : detail_::convert<T>(constexpr_forward<V>(v));
586 }
587
588 # endif
589
590 # else
591
592 template <class V>
value_or(V && v) const593 constexpr T value_or(V&& v) const
594 {
595 return *this ? **this : detail_::convert<T>(constexpr_forward<V>(v));
596 }
597
598 # endif
599
600 };
601
602
603 template <class T>
604 class optional<T&>
605 {
606 static_assert( sizeof(T) == 0, "optional rvalue references disallowed" );
607 };
608
609
610 template <class T>
611 class optional<T&&>
612 {
613 static_assert( sizeof(T) == 0, "optional rvalue references disallowed" );
614 };
615
616
617 // 20.5.8, Relational operators
operator ==(const optional<T> & x,const optional<T> & y)618 template <class T> constexpr bool operator==(const optional<T>& x, const optional<T>& y)
619 {
620 return bool(x) != bool(y) ? false : bool(x) == false ? true : *x == *y;
621 }
622
operator !=(const optional<T> & x,const optional<T> & y)623 template <class T> constexpr bool operator!=(const optional<T>& x, const optional<T>& y)
624 {
625 return !(x == y);
626 }
627
operator <(const optional<T> & x,const optional<T> & y)628 template <class T> constexpr bool operator<(const optional<T>& x, const optional<T>& y)
629 {
630 return (!y) ? false : (!x) ? true : *x < *y;
631 }
632
operator >(const optional<T> & x,const optional<T> & y)633 template <class T> constexpr bool operator>(const optional<T>& x, const optional<T>& y)
634 {
635 return (y < x);
636 }
637
operator <=(const optional<T> & x,const optional<T> & y)638 template <class T> constexpr bool operator<=(const optional<T>& x, const optional<T>& y)
639 {
640 return !(y < x);
641 }
642
operator >=(const optional<T> & x,const optional<T> & y)643 template <class T> constexpr bool operator>=(const optional<T>& x, const optional<T>& y)
644 {
645 return !(x < y);
646 }
647
648
649 // 20.5.9, Comparison with nullopt
operator ==(const optional<T> & x,nullopt_t)650 template <class T> constexpr bool operator==(const optional<T>& x, nullopt_t) noexcept
651 {
652 return (!x);
653 }
654
operator ==(nullopt_t,const optional<T> & x)655 template <class T> constexpr bool operator==(nullopt_t, const optional<T>& x) noexcept
656 {
657 return (!x);
658 }
659
operator !=(const optional<T> & x,nullopt_t)660 template <class T> constexpr bool operator!=(const optional<T>& x, nullopt_t) noexcept
661 {
662 return bool(x);
663 }
664
operator !=(nullopt_t,const optional<T> & x)665 template <class T> constexpr bool operator!=(nullopt_t, const optional<T>& x) noexcept
666 {
667 return bool(x);
668 }
669
operator <(const optional<T> &,nullopt_t)670 template <class T> constexpr bool operator<(const optional<T>&, nullopt_t) noexcept
671 {
672 return false;
673 }
674
operator <(nullopt_t,const optional<T> & x)675 template <class T> constexpr bool operator<(nullopt_t, const optional<T>& x) noexcept
676 {
677 return bool(x);
678 }
679
operator <=(const optional<T> & x,nullopt_t)680 template <class T> constexpr bool operator<=(const optional<T>& x, nullopt_t) noexcept
681 {
682 return (!x);
683 }
684
operator <=(nullopt_t,const optional<T> &)685 template <class T> constexpr bool operator<=(nullopt_t, const optional<T>&) noexcept
686 {
687 return true;
688 }
689
operator >(const optional<T> & x,nullopt_t)690 template <class T> constexpr bool operator>(const optional<T>& x, nullopt_t) noexcept
691 {
692 return bool(x);
693 }
694
operator >(nullopt_t,const optional<T> &)695 template <class T> constexpr bool operator>(nullopt_t, const optional<T>&) noexcept
696 {
697 return false;
698 }
699
operator >=(const optional<T> &,nullopt_t)700 template <class T> constexpr bool operator>=(const optional<T>&, nullopt_t) noexcept
701 {
702 return true;
703 }
704
operator >=(nullopt_t,const optional<T> & x)705 template <class T> constexpr bool operator>=(nullopt_t, const optional<T>& x) noexcept
706 {
707 return (!x);
708 }
709
710
711
712 // 20.5.10, Comparison with T
operator ==(const optional<T> & x,const T & v)713 template <class T> constexpr bool operator==(const optional<T>& x, const T& v)
714 {
715 return bool(x) ? *x == v : false;
716 }
717
operator ==(const T & v,const optional<T> & x)718 template <class T> constexpr bool operator==(const T& v, const optional<T>& x)
719 {
720 return bool(x) ? v == *x : false;
721 }
722
operator !=(const optional<T> & x,const T & v)723 template <class T> constexpr bool operator!=(const optional<T>& x, const T& v)
724 {
725 return bool(x) ? *x != v : true;
726 }
727
operator !=(const T & v,const optional<T> & x)728 template <class T> constexpr bool operator!=(const T& v, const optional<T>& x)
729 {
730 return bool(x) ? v != *x : true;
731 }
732
operator <(const optional<T> & x,const T & v)733 template <class T> constexpr bool operator<(const optional<T>& x, const T& v)
734 {
735 return bool(x) ? *x < v : true;
736 }
737
operator >(const T & v,const optional<T> & x)738 template <class T> constexpr bool operator>(const T& v, const optional<T>& x)
739 {
740 return bool(x) ? v > *x : true;
741 }
742
operator >(const optional<T> & x,const T & v)743 template <class T> constexpr bool operator>(const optional<T>& x, const T& v)
744 {
745 return bool(x) ? *x > v : false;
746 }
747
operator <(const T & v,const optional<T> & x)748 template <class T> constexpr bool operator<(const T& v, const optional<T>& x)
749 {
750 return bool(x) ? v < *x : false;
751 }
752
operator >=(const optional<T> & x,const T & v)753 template <class T> constexpr bool operator>=(const optional<T>& x, const T& v)
754 {
755 return bool(x) ? *x >= v : false;
756 }
757
operator <=(const T & v,const optional<T> & x)758 template <class T> constexpr bool operator<=(const T& v, const optional<T>& x)
759 {
760 return bool(x) ? v <= *x : false;
761 }
762
operator <=(const optional<T> & x,const T & v)763 template <class T> constexpr bool operator<=(const optional<T>& x, const T& v)
764 {
765 return bool(x) ? *x <= v : true;
766 }
767
operator >=(const T & v,const optional<T> & x)768 template <class T> constexpr bool operator>=(const T& v, const optional<T>& x)
769 {
770 return bool(x) ? v >= *x : true;
771 }
772
773
774 // Comparison of optional<T&> with T
operator ==(const optional<T &> & x,const T & v)775 template <class T> constexpr bool operator==(const optional<T&>& x, const T& v)
776 {
777 return bool(x) ? *x == v : false;
778 }
779
operator ==(const T & v,const optional<T &> & x)780 template <class T> constexpr bool operator==(const T& v, const optional<T&>& x)
781 {
782 return bool(x) ? v == *x : false;
783 }
784
operator !=(const optional<T &> & x,const T & v)785 template <class T> constexpr bool operator!=(const optional<T&>& x, const T& v)
786 {
787 return bool(x) ? *x != v : true;
788 }
789
operator !=(const T & v,const optional<T &> & x)790 template <class T> constexpr bool operator!=(const T& v, const optional<T&>& x)
791 {
792 return bool(x) ? v != *x : true;
793 }
794
operator <(const optional<T &> & x,const T & v)795 template <class T> constexpr bool operator<(const optional<T&>& x, const T& v)
796 {
797 return bool(x) ? *x < v : true;
798 }
799
operator >(const T & v,const optional<T &> & x)800 template <class T> constexpr bool operator>(const T& v, const optional<T&>& x)
801 {
802 return bool(x) ? v > *x : true;
803 }
804
operator >(const optional<T &> & x,const T & v)805 template <class T> constexpr bool operator>(const optional<T&>& x, const T& v)
806 {
807 return bool(x) ? *x > v : false;
808 }
809
operator <(const T & v,const optional<T &> & x)810 template <class T> constexpr bool operator<(const T& v, const optional<T&>& x)
811 {
812 return bool(x) ? v < *x : false;
813 }
814
operator >=(const optional<T &> & x,const T & v)815 template <class T> constexpr bool operator>=(const optional<T&>& x, const T& v)
816 {
817 return bool(x) ? *x >= v : false;
818 }
819
operator <=(const T & v,const optional<T &> & x)820 template <class T> constexpr bool operator<=(const T& v, const optional<T&>& x)
821 {
822 return bool(x) ? v <= *x : false;
823 }
824
operator <=(const optional<T &> & x,const T & v)825 template <class T> constexpr bool operator<=(const optional<T&>& x, const T& v)
826 {
827 return bool(x) ? *x <= v : true;
828 }
829
operator >=(const T & v,const optional<T &> & x)830 template <class T> constexpr bool operator>=(const T& v, const optional<T&>& x)
831 {
832 return bool(x) ? v >= *x : true;
833 }
834
835 // Comparison of optional<T const&> with T
operator ==(const optional<const T &> & x,const T & v)836 template <class T> constexpr bool operator==(const optional<const T&>& x, const T& v)
837 {
838 return bool(x) ? *x == v : false;
839 }
840
operator ==(const T & v,const optional<const T &> & x)841 template <class T> constexpr bool operator==(const T& v, const optional<const T&>& x)
842 {
843 return bool(x) ? v == *x : false;
844 }
845
operator !=(const optional<const T &> & x,const T & v)846 template <class T> constexpr bool operator!=(const optional<const T&>& x, const T& v)
847 {
848 return bool(x) ? *x != v : true;
849 }
850
operator !=(const T & v,const optional<const T &> & x)851 template <class T> constexpr bool operator!=(const T& v, const optional<const T&>& x)
852 {
853 return bool(x) ? v != *x : true;
854 }
855
operator <(const optional<const T &> & x,const T & v)856 template <class T> constexpr bool operator<(const optional<const T&>& x, const T& v)
857 {
858 return bool(x) ? *x < v : true;
859 }
860
operator >(const T & v,const optional<const T &> & x)861 template <class T> constexpr bool operator>(const T& v, const optional<const T&>& x)
862 {
863 return bool(x) ? v > *x : true;
864 }
865
operator >(const optional<const T &> & x,const T & v)866 template <class T> constexpr bool operator>(const optional<const T&>& x, const T& v)
867 {
868 return bool(x) ? *x > v : false;
869 }
870
operator <(const T & v,const optional<const T &> & x)871 template <class T> constexpr bool operator<(const T& v, const optional<const T&>& x)
872 {
873 return bool(x) ? v < *x : false;
874 }
875
operator >=(const optional<const T &> & x,const T & v)876 template <class T> constexpr bool operator>=(const optional<const T&>& x, const T& v)
877 {
878 return bool(x) ? *x >= v : false;
879 }
880
operator <=(const T & v,const optional<const T &> & x)881 template <class T> constexpr bool operator<=(const T& v, const optional<const T&>& x)
882 {
883 return bool(x) ? v <= *x : false;
884 }
885
operator <=(const optional<const T &> & x,const T & v)886 template <class T> constexpr bool operator<=(const optional<const T&>& x, const T& v)
887 {
888 return bool(x) ? *x <= v : true;
889 }
890
operator >=(const T & v,const optional<const T &> & x)891 template <class T> constexpr bool operator>=(const T& v, const optional<const T&>& x)
892 {
893 return bool(x) ? v >= *x : true;
894 }
895
896
897 // 20.5.12, Specialized algorithms
898 template <class T>
swap(optional<T> & x,optional<T> & y)899 void swap(optional<T>& x, optional<T>& y) noexcept(noexcept(x.swap(y)))
900 {
901 x.swap(y);
902 }
903
904
905 template <class T>
make_optional(T && v)906 constexpr optional<typename decay<T>::type> make_optional(T&& v)
907 {
908 return optional<typename decay<T>::type>(constexpr_forward<T>(v));
909 }
910
911 template <class X>
make_optional(reference_wrapper<X> v)912 constexpr optional<X&> make_optional(reference_wrapper<X> v)
913 {
914 return optional<X&>(v.get());
915 }
916
917
918 } // namespace experimental
919 } // namespace std
920
921 namespace std
922 {
923 template <typename T>
924 struct hash<std::experimental::optional<T>>
925 {
926 typedef typename hash<T>::result_type result_type;
927 typedef std::experimental::optional<T> argument_type;
928
operator ()std::hash929 constexpr result_type operator()(argument_type const& arg) const {
930 return arg ? std::hash<T>{}(*arg) : result_type{};
931 }
932 };
933
934 template <typename T>
935 struct hash<std::experimental::optional<T&>>
936 {
937 typedef typename hash<T>::result_type result_type;
938 typedef std::experimental::optional<T&> argument_type;
939
operator ()std::hash940 constexpr result_type operator()(argument_type const& arg) const {
941 return arg ? std::hash<T>{}(*arg) : result_type{};
942 }
943 };
944 }
945
946 # undef TR2_OPTIONAL_REQUIRES
947 # undef TR2_OPTIONAL_ASSERTED_EXPRESSION
948
949 # endif //___OPTIONAL_HPP___
950