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
reset()436 void reset() noexcept { clear(); }
437
438 // 20.5.4.3, assignment
operator =(nullopt_t)439 optional& operator=(nullopt_t) noexcept
440 {
441 clear();
442 return *this;
443 }
444
operator =(const optional & rhs)445 optional& operator=(const optional& rhs)
446 {
447 if (initialized() == true && rhs.initialized() == false) clear();
448 else if (initialized() == false && rhs.initialized() == true) initialize(*rhs);
449 else if (initialized() == true && rhs.initialized() == true) contained_val() = *rhs;
450 return *this;
451 }
452
operator =(optional && rhs)453 optional& operator=(optional&& rhs)
454 noexcept(is_nothrow_move_assignable<T>::value && is_nothrow_move_constructible<T>::value)
455 {
456 if (initialized() == true && rhs.initialized() == false) clear();
457 else if (initialized() == false && rhs.initialized() == true) initialize(std::move(*rhs));
458 else if (initialized() == true && rhs.initialized() == true) contained_val() = std::move(*rhs);
459 return *this;
460 }
461
462 template <class U>
operator =(U && v)463 auto operator=(U&& v)
464 -> typename enable_if
465 <
466 is_same<typename decay<U>::type, T>::value,
467 optional&
468 >::type
469 {
470 if (initialized()) { contained_val() = std::forward<U>(v); }
471 else { initialize(std::forward<U>(v)); }
472 return *this;
473 }
474
475
476 template <class... Args>
emplace(Args &&...args)477 void emplace(Args&&... args)
478 {
479 clear();
480 initialize(std::forward<Args>(args)...);
481 }
482
483 template <class U, class... Args>
emplace(initializer_list<U> il,Args &&...args)484 void emplace(initializer_list<U> il, Args&&... args)
485 {
486 clear();
487 initialize<U, Args...>(il, std::forward<Args>(args)...);
488 }
489
490 // 20.5.4.4, Swap
swap(optional<T> & rhs)491 void swap(optional<T>& rhs) noexcept(is_nothrow_move_constructible<T>::value && noexcept(swap(declval<T&>(), declval<T&>())))
492 {
493 if (initialized() == true && rhs.initialized() == false) { rhs.initialize(std::move(**this)); clear(); }
494 else if (initialized() == false && rhs.initialized() == true) { initialize(std::move(*rhs)); rhs.clear(); }
495 else if (initialized() == true && rhs.initialized() == true) { using std::swap; swap(**this, *rhs); }
496 }
497
498 // 20.5.4.5, Observers
499
operator bool() const500 explicit constexpr operator bool() const noexcept { return initialized(); }
has_value() const501 constexpr bool has_value() const noexcept { return initialized(); }
502
operator ->() const503 constexpr T const* operator ->() const {
504 return TR2_OPTIONAL_ASSERTED_EXPRESSION(initialized(), dataptr());
505 }
506
507 # if OPTIONAL_HAS_MOVE_ACCESSORS == 1
508
operator ->()509 OPTIONAL_MUTABLE_CONSTEXPR T* operator ->() {
510 assert (initialized());
511 return dataptr();
512 }
513
operator *() const514 constexpr T const& operator *() const& {
515 return TR2_OPTIONAL_ASSERTED_EXPRESSION(initialized(), contained_val());
516 }
517
operator *()518 OPTIONAL_MUTABLE_CONSTEXPR T& operator *() & {
519 assert (initialized());
520 return contained_val();
521 }
522
operator *()523 OPTIONAL_MUTABLE_CONSTEXPR T&& operator *() && {
524 assert (initialized());
525 return constexpr_move(contained_val());
526 }
527
value() const528 constexpr T const& value() const& {
529 return initialized() ? contained_val() : (throw bad_optional_access("bad optional access"), contained_val());
530 }
531
value()532 OPTIONAL_MUTABLE_CONSTEXPR T& value() & {
533 return initialized() ? contained_val() : (throw bad_optional_access("bad optional access"), contained_val());
534 }
535
value()536 OPTIONAL_MUTABLE_CONSTEXPR T&& value() && {
537 if (!initialized()) throw bad_optional_access("bad optional access");
538 return std::move(contained_val());
539 }
540
541 # else
542
operator ->()543 T* operator ->() {
544 assert (initialized());
545 return dataptr();
546 }
547
operator *() const548 constexpr T const& operator *() const {
549 return TR2_OPTIONAL_ASSERTED_EXPRESSION(initialized(), contained_val());
550 }
551
operator *()552 T& operator *() {
553 assert (initialized());
554 return contained_val();
555 }
556
value() const557 constexpr T const& value() const {
558 return initialized() ? contained_val() : (throw bad_optional_access("bad optional access"), contained_val());
559 }
560
value()561 T& value() {
562 return initialized() ? contained_val() : (throw bad_optional_access("bad optional access"), contained_val());
563 }
564
565 # endif
566
567 # if OPTIONAL_HAS_THIS_RVALUE_REFS == 1
568
569 template <class V>
value_or(V && v) const570 constexpr T value_or(V&& v) const&
571 {
572 return *this ? **this : detail_::convert<T>(constexpr_forward<V>(v));
573 }
574
575 # if OPTIONAL_HAS_MOVE_ACCESSORS == 1
576
577 template <class V>
value_or(V && v)578 OPTIONAL_MUTABLE_CONSTEXPR T value_or(V&& v) &&
579 {
580 return *this ? constexpr_move(const_cast<optional<T>&>(*this).contained_val()) : detail_::convert<T>(constexpr_forward<V>(v));
581 }
582
583 # else
584
585 template <class V>
value_or(V && v)586 T value_or(V&& v) &&
587 {
588 return *this ? constexpr_move(const_cast<optional<T>&>(*this).contained_val()) : detail_::convert<T>(constexpr_forward<V>(v));
589 }
590
591 # endif
592
593 # else
594
595 template <class V>
value_or(V && v) const596 constexpr T value_or(V&& v) const
597 {
598 return *this ? **this : detail_::convert<T>(constexpr_forward<V>(v));
599 }
600
601 # endif
602
603 };
604
605
606 template <class T>
607 class optional<T&>
608 {
609 static_assert( !std::is_same<T, nullopt_t>::value, "bad T" );
610 static_assert( !std::is_same<T, in_place_t>::value, "bad T" );
611 T* ref;
612
613 public:
614
615 // 20.5.5.1, construction/destruction
optional()616 constexpr optional() noexcept : ref(nullptr) {}
617
optional(nullopt_t)618 constexpr optional(nullopt_t) noexcept : ref(nullptr) {}
619
optional(T & v)620 constexpr optional(T& v) noexcept : ref(detail_::static_addressof(v)) {}
621
622 optional(T&&) = delete;
623
optional(const optional & rhs)624 constexpr optional(const optional& rhs) noexcept : ref(rhs.ref) {}
625
optional(in_place_t,T & v)626 explicit constexpr optional(in_place_t, T& v) noexcept : ref(detail_::static_addressof(v)) {}
627
628 explicit optional(in_place_t, T&&) = delete;
629
630 ~optional() = default;
631
632 // 20.5.5.2, mutation
operator =(nullopt_t)633 optional& operator=(nullopt_t) noexcept {
634 ref = nullptr;
635 return *this;
636 }
637
638 // optional& operator=(const optional& rhs) noexcept {
639 // ref = rhs.ref;
640 // return *this;
641 // }
642
643 // optional& operator=(optional&& rhs) noexcept {
644 // ref = rhs.ref;
645 // return *this;
646 // }
647
648 template <typename U>
operator =(U && rhs)649 auto operator=(U&& rhs) noexcept
650 -> typename enable_if
651 <
652 is_same<typename decay<U>::type, optional<T&>>::value,
653 optional&
654 >::type
655 {
656 ref = rhs.ref;
657 return *this;
658 }
659
660 template <typename U>
661 auto operator=(U&& rhs) noexcept
662 -> typename enable_if
663 <
664 !is_same<typename decay<U>::type, optional<T&>>::value,
665 optional&
666 >::type
667 = delete;
668
emplace(T & v)669 void emplace(T& v) noexcept {
670 ref = detail_::static_addressof(v);
671 }
672
673 void emplace(T&&) = delete;
674
675
swap(optional<T &> & rhs)676 void swap(optional<T&>& rhs) noexcept
677 {
678 std::swap(ref, rhs.ref);
679 }
680
681 // 20.5.5.3, observers
operator ->() const682 constexpr T* operator->() const {
683 return TR2_OPTIONAL_ASSERTED_EXPRESSION(ref, ref);
684 }
685
operator *() const686 constexpr T& operator*() const {
687 return TR2_OPTIONAL_ASSERTED_EXPRESSION(ref, *ref);
688 }
689
value() const690 constexpr T& value() const {
691 return ref ? *ref : (throw bad_optional_access("bad optional access"), *ref);
692 }
693
operator bool() const694 explicit constexpr operator bool() const noexcept {
695 return ref != nullptr;
696 }
has_value() const697 constexpr bool has_value() const noexcept { return ref != nullptr; }
698
699 template <class V>
value_or(V && v) const700 constexpr typename decay<T>::type value_or(V&& v) const
701 {
702 return *this ? **this : detail_::convert<typename decay<T>::type>(constexpr_forward<V>(v));
703 }
704 };
705
706
707 template <class T>
708 class optional<T&&>
709 {
710 static_assert( sizeof(T) == 0, "optional rvalue references disallowed" );
711 };
712
713
714 // 20.5.8, Relational operators
operator ==(const optional<T> & x,const optional<T> & y)715 template <class T> constexpr bool operator==(const optional<T>& x, const optional<T>& y)
716 {
717 return bool(x) != bool(y) ? false : bool(x) == false ? true : *x == *y;
718 }
719
operator !=(const optional<T> & x,const optional<T> & y)720 template <class T> constexpr bool operator!=(const optional<T>& x, const optional<T>& y)
721 {
722 return !(x == y);
723 }
724
operator <(const optional<T> & x,const optional<T> & y)725 template <class T> constexpr bool operator<(const optional<T>& x, const optional<T>& y)
726 {
727 return (!y) ? false : (!x) ? true : *x < *y;
728 }
729
operator >(const optional<T> & x,const optional<T> & y)730 template <class T> constexpr bool operator>(const optional<T>& x, const optional<T>& y)
731 {
732 return (y < x);
733 }
734
operator <=(const optional<T> & x,const optional<T> & y)735 template <class T> constexpr bool operator<=(const optional<T>& x, const optional<T>& y)
736 {
737 return !(y < x);
738 }
739
operator >=(const optional<T> & x,const optional<T> & y)740 template <class T> constexpr bool operator>=(const optional<T>& x, const optional<T>& y)
741 {
742 return !(x < y);
743 }
744
745
746 // 20.5.9, Comparison with nullopt
operator ==(const optional<T> & x,nullopt_t)747 template <class T> constexpr bool operator==(const optional<T>& x, nullopt_t) noexcept
748 {
749 return (!x);
750 }
751
operator ==(nullopt_t,const optional<T> & x)752 template <class T> constexpr bool operator==(nullopt_t, const optional<T>& x) noexcept
753 {
754 return (!x);
755 }
756
operator !=(const optional<T> & x,nullopt_t)757 template <class T> constexpr bool operator!=(const optional<T>& x, nullopt_t) noexcept
758 {
759 return bool(x);
760 }
761
operator !=(nullopt_t,const optional<T> & x)762 template <class T> constexpr bool operator!=(nullopt_t, const optional<T>& x) noexcept
763 {
764 return bool(x);
765 }
766
operator <(const optional<T> &,nullopt_t)767 template <class T> constexpr bool operator<(const optional<T>&, nullopt_t) noexcept
768 {
769 return false;
770 }
771
operator <(nullopt_t,const optional<T> & x)772 template <class T> constexpr bool operator<(nullopt_t, const optional<T>& x) noexcept
773 {
774 return bool(x);
775 }
776
operator <=(const optional<T> & x,nullopt_t)777 template <class T> constexpr bool operator<=(const optional<T>& x, nullopt_t) noexcept
778 {
779 return (!x);
780 }
781
operator <=(nullopt_t,const optional<T> &)782 template <class T> constexpr bool operator<=(nullopt_t, const optional<T>&) noexcept
783 {
784 return true;
785 }
786
operator >(const optional<T> & x,nullopt_t)787 template <class T> constexpr bool operator>(const optional<T>& x, nullopt_t) noexcept
788 {
789 return bool(x);
790 }
791
operator >(nullopt_t,const optional<T> &)792 template <class T> constexpr bool operator>(nullopt_t, const optional<T>&) noexcept
793 {
794 return false;
795 }
796
operator >=(const optional<T> &,nullopt_t)797 template <class T> constexpr bool operator>=(const optional<T>&, nullopt_t) noexcept
798 {
799 return true;
800 }
801
operator >=(nullopt_t,const optional<T> & x)802 template <class T> constexpr bool operator>=(nullopt_t, const optional<T>& x) noexcept
803 {
804 return (!x);
805 }
806
807
808
809 // 20.5.10, Comparison with T
operator ==(const optional<T> & x,const T & v)810 template <class T> constexpr bool operator==(const optional<T>& x, const T& v)
811 {
812 return bool(x) ? *x == v : false;
813 }
814
operator ==(const T & v,const optional<T> & x)815 template <class T> constexpr bool operator==(const T& v, const optional<T>& x)
816 {
817 return bool(x) ? v == *x : false;
818 }
819
operator !=(const optional<T> & x,const T & v)820 template <class T> constexpr bool operator!=(const optional<T>& x, const T& v)
821 {
822 return bool(x) ? *x != v : true;
823 }
824
operator !=(const T & v,const optional<T> & x)825 template <class T> constexpr bool operator!=(const T& v, const optional<T>& x)
826 {
827 return bool(x) ? v != *x : true;
828 }
829
operator <(const optional<T> & x,const T & v)830 template <class T> constexpr bool operator<(const optional<T>& x, const T& v)
831 {
832 return bool(x) ? *x < v : true;
833 }
834
operator >(const T & v,const optional<T> & x)835 template <class T> constexpr bool operator>(const T& v, const optional<T>& x)
836 {
837 return bool(x) ? v > *x : true;
838 }
839
operator >(const optional<T> & x,const T & v)840 template <class T> constexpr bool operator>(const optional<T>& x, const T& v)
841 {
842 return bool(x) ? *x > v : false;
843 }
844
operator <(const T & v,const optional<T> & x)845 template <class T> constexpr bool operator<(const T& v, const optional<T>& x)
846 {
847 return bool(x) ? v < *x : false;
848 }
849
operator >=(const optional<T> & x,const T & v)850 template <class T> constexpr bool operator>=(const optional<T>& x, const T& v)
851 {
852 return bool(x) ? *x >= v : false;
853 }
854
operator <=(const T & v,const optional<T> & x)855 template <class T> constexpr bool operator<=(const T& v, const optional<T>& x)
856 {
857 return bool(x) ? v <= *x : false;
858 }
859
operator <=(const optional<T> & x,const T & v)860 template <class T> constexpr bool operator<=(const optional<T>& x, const T& v)
861 {
862 return bool(x) ? *x <= v : true;
863 }
864
operator >=(const T & v,const optional<T> & x)865 template <class T> constexpr bool operator>=(const T& v, const optional<T>& x)
866 {
867 return bool(x) ? v >= *x : true;
868 }
869
870
871 // Comparison of optional<T&> with T
operator ==(const optional<T &> & x,const T & v)872 template <class T> constexpr bool operator==(const optional<T&>& x, const T& v)
873 {
874 return bool(x) ? *x == v : false;
875 }
876
operator ==(const T & v,const optional<T &> & x)877 template <class T> constexpr bool operator==(const T& v, const optional<T&>& x)
878 {
879 return bool(x) ? v == *x : false;
880 }
881
operator !=(const optional<T &> & x,const T & v)882 template <class T> constexpr bool operator!=(const optional<T&>& x, const T& v)
883 {
884 return bool(x) ? *x != v : true;
885 }
886
operator !=(const T & v,const optional<T &> & x)887 template <class T> constexpr bool operator!=(const T& v, const optional<T&>& x)
888 {
889 return bool(x) ? v != *x : true;
890 }
891
operator <(const optional<T &> & x,const T & v)892 template <class T> constexpr bool operator<(const optional<T&>& x, const T& v)
893 {
894 return bool(x) ? *x < v : true;
895 }
896
operator >(const T & v,const optional<T &> & x)897 template <class T> constexpr bool operator>(const T& v, const optional<T&>& x)
898 {
899 return bool(x) ? v > *x : true;
900 }
901
operator >(const optional<T &> & x,const T & v)902 template <class T> constexpr bool operator>(const optional<T&>& x, const T& v)
903 {
904 return bool(x) ? *x > v : false;
905 }
906
operator <(const T & v,const optional<T &> & x)907 template <class T> constexpr bool operator<(const T& v, const optional<T&>& x)
908 {
909 return bool(x) ? v < *x : false;
910 }
911
operator >=(const optional<T &> & x,const T & v)912 template <class T> constexpr bool operator>=(const optional<T&>& x, const T& v)
913 {
914 return bool(x) ? *x >= v : false;
915 }
916
operator <=(const T & v,const optional<T &> & x)917 template <class T> constexpr bool operator<=(const T& v, const optional<T&>& x)
918 {
919 return bool(x) ? v <= *x : false;
920 }
921
operator <=(const optional<T &> & x,const T & v)922 template <class T> constexpr bool operator<=(const optional<T&>& x, const T& v)
923 {
924 return bool(x) ? *x <= v : true;
925 }
926
operator >=(const T & v,const optional<T &> & x)927 template <class T> constexpr bool operator>=(const T& v, const optional<T&>& x)
928 {
929 return bool(x) ? v >= *x : true;
930 }
931
932 // Comparison of optional<T const&> with T
operator ==(const optional<const T &> & x,const T & v)933 template <class T> constexpr bool operator==(const optional<const T&>& x, const T& v)
934 {
935 return bool(x) ? *x == v : false;
936 }
937
operator ==(const T & v,const optional<const T &> & x)938 template <class T> constexpr bool operator==(const T& v, const optional<const T&>& x)
939 {
940 return bool(x) ? v == *x : false;
941 }
942
operator !=(const optional<const T &> & x,const T & v)943 template <class T> constexpr bool operator!=(const optional<const T&>& x, const T& v)
944 {
945 return bool(x) ? *x != v : true;
946 }
947
operator !=(const T & v,const optional<const T &> & x)948 template <class T> constexpr bool operator!=(const T& v, const optional<const T&>& x)
949 {
950 return bool(x) ? v != *x : true;
951 }
952
operator <(const optional<const T &> & x,const T & v)953 template <class T> constexpr bool operator<(const optional<const T&>& x, const T& v)
954 {
955 return bool(x) ? *x < v : true;
956 }
957
operator >(const T & v,const optional<const T &> & x)958 template <class T> constexpr bool operator>(const T& v, const optional<const T&>& x)
959 {
960 return bool(x) ? v > *x : true;
961 }
962
operator >(const optional<const T &> & x,const T & v)963 template <class T> constexpr bool operator>(const optional<const T&>& x, const T& v)
964 {
965 return bool(x) ? *x > v : false;
966 }
967
operator <(const T & v,const optional<const T &> & x)968 template <class T> constexpr bool operator<(const T& v, const optional<const T&>& x)
969 {
970 return bool(x) ? v < *x : false;
971 }
972
operator >=(const optional<const T &> & x,const T & v)973 template <class T> constexpr bool operator>=(const optional<const T&>& x, const T& v)
974 {
975 return bool(x) ? *x >= v : false;
976 }
977
operator <=(const T & v,const optional<const T &> & x)978 template <class T> constexpr bool operator<=(const T& v, const optional<const T&>& x)
979 {
980 return bool(x) ? v <= *x : false;
981 }
982
operator <=(const optional<const T &> & x,const T & v)983 template <class T> constexpr bool operator<=(const optional<const T&>& x, const T& v)
984 {
985 return bool(x) ? *x <= v : true;
986 }
987
operator >=(const T & v,const optional<const T &> & x)988 template <class T> constexpr bool operator>=(const T& v, const optional<const T&>& x)
989 {
990 return bool(x) ? v >= *x : true;
991 }
992
993
994 // 20.5.12, Specialized algorithms
995 template <class T>
swap(optional<T> & x,optional<T> & y)996 void swap(optional<T>& x, optional<T>& y) noexcept(noexcept(x.swap(y)))
997 {
998 x.swap(y);
999 }
1000
1001
1002 template <class T>
make_optional(T && v)1003 constexpr optional<typename decay<T>::type> make_optional(T&& v)
1004 {
1005 return optional<typename decay<T>::type>(constexpr_forward<T>(v));
1006 }
1007
1008 template <class X>
make_optional(reference_wrapper<X> v)1009 constexpr optional<X&> make_optional(reference_wrapper<X> v)
1010 {
1011 return optional<X&>(v.get());
1012 }
1013
1014
1015 } // namespace experimental
1016 } // namespace std
1017
1018 namespace std
1019 {
1020 template <typename T>
1021 struct hash<std::experimental::optional<T>>
1022 {
1023 typedef typename hash<T>::result_type result_type;
1024 typedef std::experimental::optional<T> argument_type;
1025
operator ()std::hash1026 constexpr result_type operator()(argument_type const& arg) const {
1027 return arg ? std::hash<T>{}(*arg) : result_type{};
1028 }
1029 };
1030
1031 template <typename T>
1032 struct hash<std::experimental::optional<T&>>
1033 {
1034 typedef typename hash<T>::result_type result_type;
1035 typedef std::experimental::optional<T&> argument_type;
1036
operator ()std::hash1037 constexpr result_type operator()(argument_type const& arg) const {
1038 return arg ? std::hash<T>{}(*arg) : result_type{};
1039 }
1040 };
1041 }
1042
1043 # undef TR2_OPTIONAL_REQUIRES
1044 # undef TR2_OPTIONAL_ASSERTED_EXPRESSION
1045
1046 # endif //___OPTIONAL_HPP___
1047