11#ifndef NONSTD_OPTIONAL_LITE_HPP
12#define NONSTD_OPTIONAL_LITE_HPP
14#define optional_lite_MAJOR 3
15#define optional_lite_MINOR 4
16#define optional_lite_PATCH 0
18#define optional_lite_VERSION optional_STRINGIFY(optional_lite_MAJOR) "." optional_STRINGIFY(optional_lite_MINOR) "." optional_STRINGIFY(optional_lite_PATCH)
20#define optional_STRINGIFY( x ) optional_STRINGIFY_( x )
21#define optional_STRINGIFY_( x ) #x
25#define optional_OPTIONAL_DEFAULT 0
26#define optional_OPTIONAL_NONSTD 1
27#define optional_OPTIONAL_STD 2
32# if __has_include(<nonstd/optional.tweak.hpp>)
33# include <nonstd/optional.tweak.hpp>
35#define optional_HAVE_TWEAK_HEADER 1
37#define optional_HAVE_TWEAK_HEADER 0
43#if !defined( optional_CONFIG_SELECT_OPTIONAL )
44# define optional_CONFIG_SELECT_OPTIONAL ( optional_HAVE_STD_OPTIONAL ? optional_OPTIONAL_STD : optional_OPTIONAL_NONSTD )
49#ifndef optional_CONFIG_NO_EXCEPTIONS
53# if defined(__cpp_exceptions) || defined(__EXCEPTIONS) || (_HAS_EXCEPTIONS)
54# define optional_CONFIG_NO_EXCEPTIONS 0
56# define optional_CONFIG_NO_EXCEPTIONS 1
63#ifndef optional_CPLUSPLUS
64# if defined(_MSVC_LANG ) && !defined(__clang__)
65# define optional_CPLUSPLUS (_MSC_VER == 1900 ? 201103L : _MSVC_LANG )
67# define optional_CPLUSPLUS __cplusplus
71#define optional_CPP98_OR_GREATER ( optional_CPLUSPLUS >= 199711L )
72#define optional_CPP11_OR_GREATER ( optional_CPLUSPLUS >= 201103L )
73#define optional_CPP11_OR_GREATER_ ( optional_CPLUSPLUS >= 201103L )
74#define optional_CPP14_OR_GREATER ( optional_CPLUSPLUS >= 201402L )
75#define optional_CPP17_OR_GREATER ( optional_CPLUSPLUS >= 201703L )
76#define optional_CPP20_OR_GREATER ( optional_CPLUSPLUS >= 202000L )
80#define optional_CPLUSPLUS_V ( optional_CPLUSPLUS / 100 - (optional_CPLUSPLUS > 200000 ? 2000 : 1994) )
84#if optional_CPP17_OR_GREATER && defined(__has_include )
85# if __has_include( <optional> )
86# define optional_HAVE_STD_OPTIONAL 1
88# define optional_HAVE_STD_OPTIONAL 0
91# define optional_HAVE_STD_OPTIONAL 0
94#define optional_USES_STD_OPTIONAL ( (optional_CONFIG_SELECT_OPTIONAL == optional_OPTIONAL_STD) || ((optional_CONFIG_SELECT_OPTIONAL == optional_OPTIONAL_DEFAULT) && optional_HAVE_STD_OPTIONAL) )
100#ifndef nonstd_lite_HAVE_IN_PLACE_TYPES
101#define nonstd_lite_HAVE_IN_PLACE_TYPES 1
105#if optional_CPP17_OR_GREATER
114using std::in_place_t;
115using std::in_place_type_t;
116using std::in_place_index_t;
118#define nonstd_lite_in_place_t( T) std::in_place_t
119#define nonstd_lite_in_place_type_t( T) std::in_place_type_t<T>
120#define nonstd_lite_in_place_index_t(K) std::in_place_index_t<K>
122#define nonstd_lite_in_place( T) std::in_place_t{}
123#define nonstd_lite_in_place_type( T) std::in_place_type_t<T>{}
124#define nonstd_lite_in_place_index(K) std::in_place_index_t<K>{}
136struct in_place_type_tag {};
138template< std::
size_t K >
139struct in_place_index_tag {};
146inline in_place_t
in_place( detail::in_place_type_tag<T> = detail::in_place_type_tag<T>() )
151template< std::
size_t K >
152inline in_place_t
in_place( detail::in_place_index_tag<K> = detail::in_place_index_tag<K>() )
158inline in_place_t
in_place_type( detail::in_place_type_tag<T> = detail::in_place_type_tag<T>() )
163template< std::
size_t K >
164inline in_place_t
in_place_index( detail::in_place_index_tag<K> = detail::in_place_index_tag<K>() )
171#define nonstd_lite_in_place_t( T) nonstd::in_place_t(&)( nonstd::detail::in_place_type_tag<T> )
172#define nonstd_lite_in_place_type_t( T) nonstd::in_place_t(&)( nonstd::detail::in_place_type_tag<T> )
173#define nonstd_lite_in_place_index_t(K) nonstd::in_place_t(&)( nonstd::detail::in_place_index_tag<K> )
175#define nonstd_lite_in_place( T) nonstd::in_place_type<T>
176#define nonstd_lite_in_place_type( T) nonstd::in_place_type<T>
177#define nonstd_lite_in_place_index(K) nonstd::in_place_index<K>
188#if optional_USES_STD_OPTIONAL
195 using std::bad_optional_access;
199 using std::nullopt_t;
201 using std::operator==;
202 using std::operator!=;
203 using std::operator<;
204 using std::operator<=;
205 using std::operator>;
206 using std::operator>=;
218#ifndef optional_CONFIG_MAX_ALIGN_HACK
219# define optional_CONFIG_MAX_ALIGN_HACK 0
222#ifndef optional_CONFIG_ALIGN_AS
226#ifndef optional_CONFIG_ALIGN_AS_FALLBACK
227# define optional_CONFIG_ALIGN_AS_FALLBACK double
232#if defined(__clang__)
233# pragma clang diagnostic push
234# pragma clang diagnostic ignored "-Wundef"
235#elif defined(__GNUC__)
236# pragma GCC diagnostic push
237# pragma GCC diagnostic ignored "-Wundef"
238#elif defined(_MSC_VER )
239# pragma warning( push )
243#define optional_BETWEEN( v, lo, hi ) ( (lo) <= (v) && (v) < (hi) )
259#if defined(_MSC_VER ) && !defined(__clang__)
260# define optional_COMPILER_MSVC_VER (_MSC_VER )
261# define optional_COMPILER_MSVC_VERSION (_MSC_VER / 10 - 10 * ( 5 + (_MSC_VER < 1900 ) ) )
263# define optional_COMPILER_MSVC_VER 0
264# define optional_COMPILER_MSVC_VERSION 0
267#define optional_COMPILER_VERSION( major, minor, patch ) ( 10 * (10 * (major) + (minor) ) + (patch) )
269#if defined(__GNUC__) && !defined(__clang__)
270# define optional_COMPILER_GNUC_VERSION optional_COMPILER_VERSION(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
272# define optional_COMPILER_GNUC_VERSION 0
275#if defined(__clang__)
276# define optional_COMPILER_CLANG_VERSION optional_COMPILER_VERSION(__clang_major__, __clang_minor__, __clang_patchlevel__)
278# define optional_COMPILER_CLANG_VERSION 0
281#if optional_BETWEEN(optional_COMPILER_MSVC_VERSION, 70, 140 )
282# pragma warning( disable: 4345 )
285#if optional_BETWEEN(optional_COMPILER_MSVC_VERSION, 70, 150 )
286# pragma warning( disable: 4814 )
291#define optional_HAVE(FEATURE) ( optional_HAVE_##FEATURE )
294# define optional_HAS_CPP0X _HAS_CPP0X
296# define optional_HAS_CPP0X 0
301#if optional_COMPILER_MSVC_VER >= 1900
302# undef optional_CPP11_OR_GREATER
303# define optional_CPP11_OR_GREATER 1
306#define optional_CPP11_90 (optional_CPP11_OR_GREATER_ || optional_COMPILER_MSVC_VER >= 1500)
307#define optional_CPP11_100 (optional_CPP11_OR_GREATER_ || optional_COMPILER_MSVC_VER >= 1600)
308#define optional_CPP11_110 (optional_CPP11_OR_GREATER_ || optional_COMPILER_MSVC_VER >= 1700)
309#define optional_CPP11_120 (optional_CPP11_OR_GREATER_ || optional_COMPILER_MSVC_VER >= 1800)
310#define optional_CPP11_140 (optional_CPP11_OR_GREATER_ || optional_COMPILER_MSVC_VER >= 1900)
311#define optional_CPP11_141 (optional_CPP11_OR_GREATER_ || optional_COMPILER_MSVC_VER >= 1910)
313#define optional_CPP14_000 (optional_CPP14_OR_GREATER)
314#define optional_CPP17_000 (optional_CPP17_OR_GREATER)
317#define optional_CPP11_140_G490 ((optional_CPP11_OR_GREATER_ && optional_COMPILER_GNUC_VERSION >= 490) || (optional_COMPILER_MSVC_VER >= 1910))
320#define optional_CPP11_110_C350 ( optional_CPP11_110 && !optional_BETWEEN( optional_COMPILER_CLANG_VERSION, 1, 350 ) )
323#define optional_CPP11_110_C350_G500 \
324 ( optional_CPP11_110 && \
325 !( optional_BETWEEN( optional_COMPILER_CLANG_VERSION, 1, 350 ) \
326 || optional_BETWEEN( optional_COMPILER_GNUC_VERSION , 1, 500 ) ) )
330#define optional_HAVE_CONSTEXPR_11 optional_CPP11_140
331#define optional_HAVE_IS_DEFAULT optional_CPP11_140
332#define optional_HAVE_NOEXCEPT optional_CPP11_140
333#define optional_HAVE_NULLPTR optional_CPP11_100
334#define optional_HAVE_REF_QUALIFIER optional_CPP11_140_G490
335#define optional_HAVE_INITIALIZER_LIST optional_CPP11_140
339#define optional_HAVE_CONSTEXPR_14 optional_CPP14_000
343#define optional_HAVE_NODISCARD optional_CPP17_000
347#define optional_HAVE_CONDITIONAL optional_CPP11_120
348#define optional_HAVE_REMOVE_CV optional_CPP11_120
349#define optional_HAVE_TYPE_TRAITS optional_CPP11_90
351#define optional_HAVE_TR1_TYPE_TRAITS (!! optional_COMPILER_GNUC_VERSION )
352#define optional_HAVE_TR1_ADD_POINTER (!! optional_COMPILER_GNUC_VERSION )
354#define optional_HAVE_IS_ASSIGNABLE optional_CPP11_110_C350
355#define optional_HAVE_IS_MOVE_CONSTRUCTIBLE optional_CPP11_110_C350
356#define optional_HAVE_IS_NOTHROW_MOVE_ASSIGNABLE optional_CPP11_110_C350
357#define optional_HAVE_IS_NOTHROW_MOVE_CONSTRUCTIBLE optional_CPP11_110_C350
358#define optional_HAVE_IS_TRIVIALLY_COPY_CONSTRUCTIBLE optional_CPP11_110_C350_G500
359#define optional_HAVE_IS_TRIVIALLY_MOVE_CONSTRUCTIBLE optional_CPP11_110_C350_G500
363#if optional_HAVE( CONSTEXPR_11 )
364# define optional_constexpr constexpr
366# define optional_constexpr
369#if optional_HAVE( IS_DEFAULT )
370# define optional_is_default = default;
372# define optional_is_default {}
375#if optional_HAVE( CONSTEXPR_14 )
376# define optional_constexpr14 constexpr
378# define optional_constexpr14
381#if optional_HAVE( NODISCARD )
382# define optional_nodiscard [[nodiscard]]
384# define optional_nodiscard
387#if optional_HAVE( NOEXCEPT )
388# define optional_noexcept noexcept
390# define optional_noexcept
393#if optional_HAVE( NULLPTR )
394# define optional_nullptr nullptr
396# define optional_nullptr NULL
399#if optional_HAVE( REF_QUALIFIER )
401# define optional_ref_qual &
402# define optional_refref_qual &&
404# define optional_ref_qual
405# define optional_refref_qual
410#if optional_CONFIG_NO_EXCEPTIONS
416#if optional_CPP11_OR_GREATER
417# include <functional>
420#if optional_HAVE( INITIALIZER_LIST )
421# include <initializer_list>
424#if optional_HAVE( TYPE_TRAITS )
425# include <type_traits>
426#elif optional_HAVE( TR1_TYPE_TRAITS )
427# include <tr1/type_traits>
432#if optional_CPP11_OR_GREATER
434#define optional_REQUIRES_0(...) \
435 template< bool B = (__VA_ARGS__), typename std::enable_if<B, int>::type = 0 >
437#define optional_REQUIRES_T(...) \
438 , typename std::enable_if< (__VA_ARGS__), int >::type = 0
440#define optional_REQUIRES_R(R, ...) \
441 typename std::enable_if< (__VA_ARGS__), R>::type
443#define optional_REQUIRES_A(...) \
444 , typename std::enable_if< (__VA_ARGS__), void*>::type = nullptr
452namespace nonstd {
namespace optional_lite {
462#if optional_CPP11_OR_GREATER
465 template<
typename T > T &
move( T & t ) {
return t; }
468#if optional_HAVE( CONDITIONAL )
469 using std::conditional;
472 template<
typename T,
typename F >
struct conditional<false, T, F> {
typedef F
type; };
475#if optional_HAVE( IS_ASSIGNABLE )
476 using std::is_assignable;
481#if optional_HAVE( IS_MOVE_CONSTRUCTIBLE )
482 using std::is_move_constructible;
487#if optional_HAVE( IS_NOTHROW_MOVE_ASSIGNABLE )
488 using std::is_nothrow_move_assignable;
493#if optional_HAVE( IS_NOTHROW_MOVE_CONSTRUCTIBLE )
494 using std::is_nothrow_move_constructible;
499#if optional_HAVE( IS_TRIVIALLY_COPY_CONSTRUCTIBLE )
500 using std::is_trivially_copy_constructible;
505#if optional_HAVE( IS_TRIVIALLY_MOVE_CONSTRUCTIBLE )
506 using std::is_trivially_move_constructible;
513#if optional_CPP11_OR_GREATER
519#if optional_CPP17_OR_GREATER
521using std::is_swappable;
522using std::is_nothrow_swappable;
524#elif optional_CPP11_OR_GREATER
532 template< typename T, typename = decltype( swap( std::declval<T&>(), std::declval<T&>() ) ) >
539struct is_nothrow_swappable
543 template<
typename T >
544 static constexpr bool satisfies()
546 return noexcept(
swap( std::declval<T&>(), std::declval<T&>() ) );
549 template<
typename T >
550 static auto test(
int ) -> std11::integral_constant<bool, satisfies<T>()>{}
560template<
typename T >
561struct is_swappable : decltype( detail::is_swappable::test<T>(0) ){};
563template<
typename T >
564struct is_nothrow_swappable : decltype( detail::is_nothrow_swappable::test<T>(0) ){};
574template<
typename T >
577 typedef typename std::remove_cv< typename std::remove_reference<T>::type >::type type;
586template<
typename T >
595template<
typename Head,
typename Tail >
602#if optional_CONFIG_MAX_ALIGN_HACK
606#define optional_UNIQUE( name ) optional_UNIQUE2( name, __LINE__ )
607#define optional_UNIQUE2( name, line ) optional_UNIQUE3( name, line )
608#define optional_UNIQUE3( name, line ) name ## line
610#define optional_ALIGN_TYPE( type ) \
611 type optional_UNIQUE( _t ); struct_t< type > optional_UNIQUE( _st )
613template<
typename T >
640 Unknown ( * optional_UNIQUE(_) )( Unknown );
641 Unknown * Unknown::* optional_UNIQUE(_);
642 Unknown ( Unknown::* optional_UNIQUE(_) )( Unknown );
644 struct_t< Unknown ( * )( Unknown) > optional_UNIQUE(_);
645 struct_t< Unknown * Unknown::* > optional_UNIQUE(_);
646 struct_t< Unknown ( Unknown::* )(Unknown) > optional_UNIQUE(_);
649#undef optional_UNIQUE
650#undef optional_UNIQUE2
651#undef optional_UNIQUE3
653#undef optional_ALIGN_TYPE
655#elif defined( optional_CONFIG_ALIGN_AS )
659#define optional_ALIGN_AS( unused ) \
660 optional_CONFIG_ALIGN_AS
666#define optional_ALIGN_AS( to_align ) \
667 typename type_of_size< alignment_types, alignment_of< to_align >::value >::type
669template<
typename T >
672template<
typename T >
680template<
size_t A,
size_t S >
683 enum { value = A < S ? A : S };
686template<
typename T >
693template<
typename List,
size_t N >
697 N ==
sizeof(
typename List::head ),
711#define optional_ALIGN_TYPE( type ) \
712 typelist< type , typelist< struct_t< type >
738 > > > > > > > > > > > > > >
739 > > > > > > > > > > > > > >
743#undef optional_ALIGN_TYPE
749template<
typename T >
769#if optional_CPP11_OR_GREATER
781 template< class... Args >
784 emplace( std::forward<Args>(args)... );
787 template<
class... Args >
788 void emplace( Args&&... args )
793 template< class U, class... Args >
794 void emplace(
std::initializer_list<U> il, Args&&... args )
808 return as<value_type>();
813 return as<value_type>();
826#if optional_HAVE( REF_QUALIFIER )
840#if optional_CPP11_OR_GREATER
842 using aligned_storage_t =
typename std::aligned_storage<
sizeof(
value_type),
alignof(
value_type) >::type;
843 aligned_storage_t
data;
845#elif optional_CONFIG_MAX_ALIGN_HACK
847 typedef struct {
unsigned char data[
sizeof(
value_type) ]; } aligned_storage_t;
850 aligned_storage_t
data;
858# undef optional_ALIGN_AS
872 template <
typename U>
875 return reinterpret_cast<U*
>(
ptr() );
878 template <
typename U>
881 return reinterpret_cast<U
const *
>(
ptr() );
895#if optional_HAVE( CONSTEXPR_11 )
904#if ! optional_CONFIG_NO_EXCEPTIONS
906class bad_optional_access :
public std::logic_error
909 explicit bad_optional_access()
910 : logic_error(
"bad optional access" ) {}
932 : has_value_( false )
939 : has_value_(
false )
944#if optional_CPP11_OR_GREATER
953 : has_value_( other.has_value() )
961#if optional_CPP11_OR_GREATER
964 template<
typename U = T
973 : has_value_( other.has_value() )
975 if ( other.has_value() )
977 contained.construct_value(
std::move( other.contained.value() ) );
984 std::is_constructible<T, U const &>::value
985 && !std::is_constructible<T, optional<U> & >
::value
986 && !std::is_constructible<T, optional<U> && >
::value
987 && !std::is_constructible<T, optional<U>
const & >
::value
988 && !std::is_constructible<T, optional<U>
const && >
::value
989 && !std::is_convertible< optional<U> & , T>
::value
990 && !std::is_convertible< optional<U> && , T>
::value
991 && !std::is_convertible< optional<U>
const & , T>
::value
992 && !std::is_convertible< optional<U>
const &&, T>
::value
993 && !std::is_convertible< U const & , T>::value
996 explicit optional( optional<U>
const & other )
997 : has_value_( other.has_value() )
999 if ( other.has_value() )
1001 contained.construct_value( T{ other.contained.value() } );
1007 template<
typename U
1008#if optional_CPP11_OR_GREATER
1009 optional_REQUIRES_T(
1010 std::is_constructible<T, U const &>::value
1011 && !std::is_constructible<T, optional<U> & >
::value
1012 && !std::is_constructible<T, optional<U> && >
::value
1013 && !std::is_constructible<T, optional<U>
const & >
::value
1014 && !std::is_constructible<T, optional<U>
const && >
::value
1015 && !std::is_convertible< optional<U> & , T>
::value
1016 && !std::is_convertible< optional<U> && , T>
::value
1017 && !std::is_convertible< optional<U>
const & , T>
::value
1018 && !std::is_convertible< optional<U>
const &&, T>
::value
1019 && std::is_convertible< U const & , T>::value
1025 : has_value_( other.has_value() )
1033#if optional_CPP11_OR_GREATER
1036 template<
typename U
1037 optional_REQUIRES_T(
1038 std::is_constructible<T, U &&>::value
1047 && !std::is_convertible< U &&, T>::value
1052 : has_value_( other.has_value() )
1054 if ( other.has_value() )
1056 contained.construct_value( T{
std::move( other.contained.value() ) } );
1061 template<
typename U
1062 optional_REQUIRES_T(
1063 std::is_constructible<T, U &&>::value
1064 && !std::is_constructible<T, optional<U> & >
::value
1065 && !std::is_constructible<T, optional<U> && >
::value
1066 && !std::is_constructible<T, optional<U>
const & >
::value
1067 && !std::is_constructible<T, optional<U>
const && >
::value
1068 && !std::is_convertible< optional<U> & , T>
::value
1069 && !std::is_convertible< optional<U> && , T>
::value
1070 && !std::is_convertible< optional<U>
const & , T>
::value
1071 && !std::is_convertible< optional<U>
const &&, T>
::value
1072 && std::is_convertible< U &&, T>::value
1076 optional( optional<U> && other )
1077 : has_value_( other.has_value() )
1079 if ( other.has_value() )
1081 contained.construct_value(
std::move( other.contained.value() ) );
1086 template<
typename... Args
1087 optional_REQUIRES_T(
1088 std::is_constructible<T, Args&&...>::value
1092 : has_value_( true )
1093 , contained( T(
std::forward<Args>(args)...) )
1097 template<
typename U,
typename... Args
1098 optional_REQUIRES_T(
1099 std::is_constructible<T, std::initializer_list<U>&, Args&&...>
::value
1103 : has_value_( true )
1104 , contained( T( il,
std::forward<Args>(args)...) )
1108 template<
typename U = T
1109 optional_REQUIRES_T(
1110 std::is_constructible<T, U&&>::value
1112 && !std::is_same<
typename std20::remove_cvref<U>::type, optional<T>>
::value
1113 && !std::is_convertible<U&&, T>::value
1117 : has_value_( true )
1122 template<
typename U = T
1123 optional_REQUIRES_T(
1124 std::is_constructible<T, U&&>::value
1126 && !std::is_same<
typename std20::remove_cvref<U>::type, optional<T>>
::value
1127 && std::is_convertible<U&&, T>::value
1132 : has_value_( true )
1140 : has_value_( true )
1141 , contained(
value )
1152 contained.destruct_value();
1166#if optional_CPP11_OR_GREATER
1168 optional_REQUIRES_R(
1176 std11::is_nothrow_move_assignable<T>::
value
1177 && std11::is_nothrow_move_constructible<T>::
value
1183 if ( (has_value() ==
true ) && (other.
has_value() ==
false) ) { reset(); }
1184 else if ( (has_value() ==
false) && (other.
has_value() ==
true ) ) { initialize( *other ); }
1185 else if ( (has_value() ==
true ) && (other.
has_value() ==
true ) ) { contained.value() = *other; }
1189#if optional_CPP11_OR_GREATER
1193 optional_REQUIRES_R(
1199 operator=(
optional && other ) noexcept
1201 if ( (has_value() ==
true ) && (other.
has_value() ==
false) ) { reset(); }
1202 else if ( (has_value() ==
false) && (other.
has_value() ==
true ) ) { initialize(
std::move( *other ) ); }
1203 else if ( (has_value() ==
true ) && (other.
has_value() ==
true ) ) { contained.value() =
std::move( *other ); }
1208 template<
typename U = T >
1210 optional_REQUIRES_R(
1212 std::is_constructible<T , U>::value
1215 && !std::is_same<
typename std20::remove_cvref<U>::type, optional<T>>
::value
1216 && !(std::is_scalar<T>::value && std::is_same<T,
typename std::decay<U>::type>
::value)
1218 operator=( U &&
value )
1222 contained.value() = std::forward<U>(
value );
1226 initialize( T( std::forward<U>(
value ) ) );
1234 template<
typename U >
1237 if ( has_value() ) contained.
value() =
value;
1238 else initialize( T(
value ) );
1245 template<
typename U >
1246#if optional_CPP11_OR_GREATER
1248 optional_REQUIRES_R(
1250 std::is_constructible< T , U const &>::value
1273#if optional_CPP11_OR_GREATER
1276 template<
typename U >
1278 optional_REQUIRES_R(
1280 std::is_constructible< T , U>::value
1301 template<
typename... Args
1302 optional_REQUIRES_T(
1303 std::is_constructible<T, Args&&...>::value
1306 T& emplace( Args&&... args )
1309 contained.emplace( std::forward<Args>(args)... );
1311 return contained.value();
1315 template<
typename U,
typename... Args
1316 optional_REQUIRES_T(
1317 std::is_constructible<T, std::initializer_list<U>&, Args&&...>
::value
1320 T& emplace( std::initializer_list<U> il, Args&&... args )
1323 contained.emplace( il, std::forward<Args>(args)... );
1325 return contained.value();
1333#if optional_CPP11_OR_GREATER
1336 && std17::is_nothrow_swappable<T>::value
1341 if ( (has_value() ==
true ) && (other.
has_value() == true ) ) {
swap( **
this, *other ); }
1342 else if ( (has_value() ==
false) && (other.
has_value() ==
true ) ) { initialize(
std11::move(*other) ); other.
reset(); }
1350 return assert( has_value() ),
1351 contained.value_ptr();
1356 return assert( has_value() ),
1357 contained.value_ptr();
1362 return assert( has_value() ),
1368 return assert( has_value() ),
1372#if optional_HAVE( REF_QUALIFIER )
1386#if optional_CPP11_OR_GREATER
1407#if optional_CONFIG_NO_EXCEPTIONS
1408 assert( has_value() );
1410 if ( ! has_value() )
1412 throw bad_optional_access();
1415 return contained.value();
1420#if optional_CONFIG_NO_EXCEPTIONS
1421 assert( has_value() );
1423 if ( ! has_value() )
1425 throw bad_optional_access();
1428 return contained.value();
1431#if optional_HAVE( REF_QUALIFIER ) && ( !optional_COMPILER_GNUC_VERSION || optional_COMPILER_GNUC_VERSION >= 490 )
1446#if optional_CPP11_OR_GREATER
1448 template<
typename U >
1451 return has_value() ? contained.value() :
static_cast<T
>(std::forward<U>( v ) );
1454 template<
typename U >
1457 return has_value() ?
std::move( contained.value() ) : static_cast<T>(
std::forward<U>(
v ) );
1462 template<
typename U >
1465 return has_value() ? contained.value() :
static_cast<value_type>( v );
1476 contained.destruct_value();
1485 template<
typename V >
1488 assert( ! has_value() );
1489 contained.construct_value(
value );
1493#if optional_CPP11_OR_GREATER
1494 template<
typename V >
1495 void initialize( V &&
value )
1497 assert( ! has_value() );
1512template<
typename T,
typename U >
1515 return bool(x) != bool(y) ? false : !bool( x ) ? true : *x == *y;
1518template<
typename T,
typename U >
1524template<
typename T,
typename U >
1527 return (!y) ? false : (!x) ?
true : *x < *y;
1530template<
typename T,
typename U >
1536template<
typename T,
typename U >
1542template<
typename T,
typename U >
1550template<
typename T >
1556template<
typename T >
1562template<
typename T >
1568template<
typename T >
1574template<
typename T >
1580template<
typename T >
1586template<
typename T >
1592template<
typename T >
1598template<
typename T >
1604template<
typename T >
1610template<
typename T >
1616template<
typename T >
1624template<
typename T,
typename U >
1627 return bool(x) ? *x == v :
false;
1630template<
typename T,
typename U >
1633 return bool(x) ? v == *x :
false;
1636template<
typename T,
typename U >
1639 return bool(x) ? *x != v :
true;
1642template<
typename T,
typename U >
1645 return bool(x) ? v != *x :
true;
1648template<
typename T,
typename U >
1651 return bool(x) ? *x < v :
true;
1654template<
typename T,
typename U >
1657 return bool(x) ? v < *x :
false;
1660template<
typename T,
typename U >
1663 return bool(x) ? *x <= v :
true;
1666template<
typename T,
typename U >
1669 return bool(x) ? v <= *x :
false;
1672template<
typename T,
typename U >
1675 return bool(x) ? *x > v :
false;
1678template<
typename T,
typename U >
1681 return bool(x) ? v > *x :
true;
1684template<
typename T,
typename U >
1687 return bool(x) ? *x >= v :
false;
1690template<
typename T,
typename U >
1693 return bool(x) ? v >= *x :
true;
1699#if optional_CPP11_OR_GREATER
1700 optional_REQUIRES_T(
1702 && std17::is_swappable<T>::value )
1706#if optional_CPP11_OR_GREATER
1707 noexcept(
noexcept( x.
swap(y) ) )
1713#if optional_CPP11_OR_GREATER
1715template<
typename T >
1721template<
typename T,
typename...Args >
1727template<
typename T,
typename U,
typename... Args >
1735template<
typename T >
1745using optional_lite::optional;
1746using optional_lite::nullopt_t;
1749#if ! optional_CONFIG_NO_EXCEPTIONS
1750using optional_lite::bad_optional_access;
1757#if optional_CPP11_OR_GREATER
1764struct hash<
nonstd::optional<T> >
1769 return bool( v ) ? std::hash<T>{}( *v ) : 0;
1777#if defined(__clang__)
1778# pragma clang diagnostic pop
1779#elif defined(__GNUC__)
1780# pragma GCC diagnostic pop
1781#elif defined(_MSC_VER )
1782# pragma warning( pop )
void reset() optional_noexcept
void initialize(V const &value)
optional_constexpr optional(nullopt_t) optional_noexcept
optional & operator=(U const &value)
optional(optional< U > const &other)
void swap(optional &other)
optional & operator=(optional< U > const &other)
optional_constexpr value_type value_or(U const &v) const
void this_type_does_not_support_comparisons() const
detail::storage_t< value_type > contained
optional_constexpr bool has_value() const optional_noexcept
optional_constexpr14 value_type const & value() const optional_ref_qual
optional & operator=(nullopt_t) optional_noexcept
optional_constexpr optional() optional_noexcept
optional & operator=(optional const &other)
optional_constexpr14 value_type & value() optional_ref_qual
optional(value_type const &value)
optional_constexpr14 optional(optional const &other)
typedef optional_ALIGN_TYPE(char)
bool_constant< false > false_type
bool_constant< true > true_type
optional_constexpr bool operator<(optional< T > const &x, optional< U > const &y)
optional_constexpr bool operator>(optional< T > const &x, optional< U > const &y)
optional_constexpr bool operator<=(optional< T > const &x, optional< U > const &y)
optional_constexpr bool operator==(optional< T > const &x, optional< U > const &y)
const nullopt_t nullopt((nullopt_t::init()))
optional< T > make_optional(T const &value)
void swap(optional< T > &x, optional< T > &y)
optional_constexpr bool operator!=(optional< T > const &x, optional< U > const &y)
optional_constexpr bool operator>=(optional< T > const &x, optional< U > const &y)
in_place_t in_place_type(detail::in_place_type_tag< T >=detail::in_place_type_tag< T >())
in_place_t in_place_index(detail::in_place_index_tag< K >=detail::in_place_index_tag< K >())
in_place_t in_place(detail::in_place_type_tag< T >=detail::in_place_type_tag< T >())
constexpr std::size_t N
A special marker that means infinite repetitions.
std::enable_if< std::is_same< Parameter_Container, query_string_params_t >::value||std::is_same< Parameter_Container, router::route_params_t >::value, Value_Type >::type value_or(const Parameter_Container ¶ms, string_view_t key, Value_Type default_value)
Get parameter value or a given default.
optional_CONFIG_ALIGN_AS_FALLBACK type
std11::conditional< N==sizeof(typenameList::head), typenameList::head, typenametype_of_size< typenameList::tail, N >::type >::type type
optional_constexpr nullopt_t(init) optional_noexcept
#define optional_refref_qual
#define optional_constexpr
#define nonstd_lite_in_place( T)
#define optional_is_default
#define optional_constexpr14
#define nonstd_lite_in_place_t( T)
#define optional_noexcept
#define optional_CONFIG_ALIGN_AS_FALLBACK
#define optional_nodiscard
#define optional_ref_qual
C++03 constructed union to hold value.
optional_nodiscard void const * ptr() const optional_noexcept
optional_nodiscard value_type const * value_ptr() const
optional_nodiscard void * ptr() optional_noexcept
optional_nodiscard U const * as() const
storage_t() optional_is_default explicit storage_t(value_type const &v)
typedef optional_ALIGN_AS(value_type) align_as_type
optional_nodiscard U * as()
value_type & value() optional_ref_qual
optional_nodiscard value_type const & value() const optional_ref_qual
void construct_value(value_type const &v)