11#ifndef NONSTD_OPTIONAL_LITE_HPP
12#define NONSTD_OPTIONAL_LITE_HPP
14#define optional_lite_MAJOR 3
15#define optional_lite_MINOR 5
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_EXTENSIONS
50#define optional_CONFIG_NO_EXTENSIONS 0
55#ifndef optional_CONFIG_NO_EXCEPTIONS
59# if defined(__cpp_exceptions) || defined(__EXCEPTIONS) || (defined(_HAS_EXCEPTIONS) && (_HAS_EXCEPTIONS))
60# define optional_CONFIG_NO_EXCEPTIONS 0
62# define optional_CONFIG_NO_EXCEPTIONS 1
69#ifndef optional_CPLUSPLUS
70# if defined(_MSVC_LANG ) && !defined(__clang__)
71# define optional_CPLUSPLUS (_MSC_VER == 1900 ? 201103L : _MSVC_LANG )
73# define optional_CPLUSPLUS __cplusplus
77#define optional_CPP98_OR_GREATER ( optional_CPLUSPLUS >= 199711L )
78#define optional_CPP11_OR_GREATER ( optional_CPLUSPLUS >= 201103L )
79#define optional_CPP11_OR_GREATER_ ( optional_CPLUSPLUS >= 201103L )
80#define optional_CPP14_OR_GREATER ( optional_CPLUSPLUS >= 201402L )
81#define optional_CPP17_OR_GREATER ( optional_CPLUSPLUS >= 201703L )
82#define optional_CPP20_OR_GREATER ( optional_CPLUSPLUS >= 202000L )
86#define optional_CPLUSPLUS_V ( optional_CPLUSPLUS / 100 - (optional_CPLUSPLUS > 200000 ? 2000 : 1994) )
90#if optional_CPP17_OR_GREATER && defined(__has_include )
91# if __has_include( <optional> )
92# define optional_HAVE_STD_OPTIONAL 1
94# define optional_HAVE_STD_OPTIONAL 0
97# define optional_HAVE_STD_OPTIONAL 0
100#define optional_USES_STD_OPTIONAL ( (optional_CONFIG_SELECT_OPTIONAL == optional_OPTIONAL_STD) || ((optional_CONFIG_SELECT_OPTIONAL == optional_OPTIONAL_DEFAULT) && optional_HAVE_STD_OPTIONAL) )
106#ifndef nonstd_lite_HAVE_IN_PLACE_TYPES
107#define nonstd_lite_HAVE_IN_PLACE_TYPES 1
111#if optional_CPP17_OR_GREATER
118using std::in_place_type;
119using std::in_place_index;
120using std::in_place_t;
121using std::in_place_type_t;
122using std::in_place_index_t;
124#define nonstd_lite_in_place_t( T) std::in_place_t
125#define nonstd_lite_in_place_type_t( T) std::in_place_type_t<T>
126#define nonstd_lite_in_place_index_t(K) std::in_place_index_t<K>
128#define nonstd_lite_in_place( T) std::in_place_t{}
129#define nonstd_lite_in_place_type( T) std::in_place_type_t<T>{}
130#define nonstd_lite_in_place_index(K) std::in_place_index_t<K>{}
142struct in_place_type_tag {};
144template< std::
size_t K >
145struct in_place_index_tag {};
152inline in_place_t
in_place( detail::in_place_type_tag<T> = detail::in_place_type_tag<T>() )
157template< std::
size_t K >
158inline in_place_t
in_place( detail::in_place_index_tag<K> = detail::in_place_index_tag<K>() )
164inline in_place_t
in_place_type( detail::in_place_type_tag<T> = detail::in_place_type_tag<T>() )
169template< std::
size_t K >
170inline in_place_t
in_place_index( detail::in_place_index_tag<K> = detail::in_place_index_tag<K>() )
177#define nonstd_lite_in_place_t( T) nonstd::in_place_t(&)( nonstd::detail::in_place_type_tag<T> )
178#define nonstd_lite_in_place_type_t( T) nonstd::in_place_t(&)( nonstd::detail::in_place_type_tag<T> )
179#define nonstd_lite_in_place_index_t(K) nonstd::in_place_t(&)( nonstd::detail::in_place_index_tag<K> )
181#define nonstd_lite_in_place( T) nonstd::in_place_type<T>
182#define nonstd_lite_in_place_type( T) nonstd::in_place_type<T>
183#define nonstd_lite_in_place_index(K) nonstd::in_place_index<K>
194#if optional_USES_STD_OPTIONAL
201 using std::bad_optional_access;
205 using std::nullopt_t;
207 using std::operator==;
208 using std::operator!=;
209 using std::operator<;
210 using std::operator<=;
211 using std::operator>;
212 using std::operator>=;
213 using std::make_optional;
224#ifndef optional_CONFIG_MAX_ALIGN_HACK
225# define optional_CONFIG_MAX_ALIGN_HACK 0
228#ifndef optional_CONFIG_ALIGN_AS
232#ifndef optional_CONFIG_ALIGN_AS_FALLBACK
233# define optional_CONFIG_ALIGN_AS_FALLBACK double
238#if defined(__clang__)
239# pragma clang diagnostic push
240# pragma clang diagnostic ignored "-Wundef"
241#elif defined(__GNUC__)
242# pragma GCC diagnostic push
243# pragma GCC diagnostic ignored "-Wundef"
244#elif defined(_MSC_VER )
245# pragma warning( push )
249#define optional_BETWEEN( v, lo, hi ) ( (lo) <= (v) && (v) < (hi) )
265#if defined(_MSC_VER ) && !defined(__clang__)
266# define optional_COMPILER_MSVC_VER (_MSC_VER )
267# define optional_COMPILER_MSVC_VERSION (_MSC_VER / 10 - 10 * ( 5 + (_MSC_VER < 1900 ) ) )
269# define optional_COMPILER_MSVC_VER 0
270# define optional_COMPILER_MSVC_VERSION 0
273#define optional_COMPILER_VERSION( major, minor, patch ) ( 10 * (10 * (major) + (minor) ) + (patch) )
275#if defined(__GNUC__) && !defined(__clang__)
276# define optional_COMPILER_GNUC_VERSION optional_COMPILER_VERSION(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
278# define optional_COMPILER_GNUC_VERSION 0
281#if defined(__clang__)
282# define optional_COMPILER_CLANG_VERSION optional_COMPILER_VERSION(__clang_major__, __clang_minor__, __clang_patchlevel__)
284# define optional_COMPILER_CLANG_VERSION 0
287#if optional_BETWEEN(optional_COMPILER_MSVC_VERSION, 70, 140 )
288# pragma warning( disable: 4345 )
291#if optional_BETWEEN(optional_COMPILER_MSVC_VERSION, 70, 150 )
292# pragma warning( disable: 4814 )
297#define optional_HAVE(FEATURE) ( optional_HAVE_##FEATURE )
300# define optional_HAS_CPP0X _HAS_CPP0X
302# define optional_HAS_CPP0X 0
307#if optional_COMPILER_MSVC_VER >= 1900
308# undef optional_CPP11_OR_GREATER
309# define optional_CPP11_OR_GREATER 1
312#define optional_CPP11_90 (optional_CPP11_OR_GREATER_ || optional_COMPILER_MSVC_VER >= 1500)
313#define optional_CPP11_100 (optional_CPP11_OR_GREATER_ || optional_COMPILER_MSVC_VER >= 1600)
314#define optional_CPP11_110 (optional_CPP11_OR_GREATER_ || optional_COMPILER_MSVC_VER >= 1700)
315#define optional_CPP11_120 (optional_CPP11_OR_GREATER_ || optional_COMPILER_MSVC_VER >= 1800)
316#define optional_CPP11_140 (optional_CPP11_OR_GREATER_ || optional_COMPILER_MSVC_VER >= 1900)
317#define optional_CPP11_141 (optional_CPP11_OR_GREATER_ || optional_COMPILER_MSVC_VER >= 1910)
319#define optional_CPP14_000 (optional_CPP14_OR_GREATER)
320#define optional_CPP17_000 (optional_CPP17_OR_GREATER)
323#define optional_CPP11_140_C290_G490 ((optional_CPP11_OR_GREATER_ && (optional_COMPILER_CLANG_VERSION >= 290 || optional_COMPILER_GNUC_VERSION >= 490)) || (optional_COMPILER_MSVC_VER >= 1900))
326#define optional_CPP11_110_C350 ( optional_CPP11_110 && !optional_BETWEEN( optional_COMPILER_CLANG_VERSION, 1, 350 ) )
329#define optional_CPP11_110_C350_G500 \
330 ( optional_CPP11_110 && \
331 !( optional_BETWEEN( optional_COMPILER_CLANG_VERSION, 1, 350 ) \
332 || optional_BETWEEN( optional_COMPILER_GNUC_VERSION , 1, 500 ) ) )
336#define optional_HAVE_CONSTEXPR_11 optional_CPP11_140
337#define optional_HAVE_IS_DEFAULT optional_CPP11_140
338#define optional_HAVE_NOEXCEPT optional_CPP11_140
339#define optional_HAVE_NULLPTR optional_CPP11_100
340#define optional_HAVE_REF_QUALIFIER optional_CPP11_140_C290_G490
341#define optional_HAVE_STATIC_ASSERT optional_CPP11_110
342#define optional_HAVE_INITIALIZER_LIST optional_CPP11_140
346#define optional_HAVE_CONSTEXPR_14 optional_CPP14_000
350#define optional_HAVE_NODISCARD optional_CPP17_000
354#define optional_HAVE_CONDITIONAL optional_CPP11_120
355#define optional_HAVE_REMOVE_CV optional_CPP11_120
356#define optional_HAVE_TYPE_TRAITS optional_CPP11_90
358#define optional_HAVE_TR1_TYPE_TRAITS (!! optional_COMPILER_GNUC_VERSION )
359#define optional_HAVE_TR1_ADD_POINTER (!! optional_COMPILER_GNUC_VERSION )
361#define optional_HAVE_IS_ASSIGNABLE optional_CPP11_110_C350
362#define optional_HAVE_IS_MOVE_CONSTRUCTIBLE optional_CPP11_110_C350
363#define optional_HAVE_IS_NOTHROW_MOVE_ASSIGNABLE optional_CPP11_110_C350
364#define optional_HAVE_IS_NOTHROW_MOVE_CONSTRUCTIBLE optional_CPP11_110_C350
365#define optional_HAVE_IS_TRIVIALLY_COPY_CONSTRUCTIBLE optional_CPP11_110_C350_G500
366#define optional_HAVE_IS_TRIVIALLY_MOVE_CONSTRUCTIBLE optional_CPP11_110_C350_G500
370#if optional_HAVE( CONSTEXPR_11 )
371# define optional_constexpr constexpr
373# define optional_constexpr
376#if optional_HAVE( IS_DEFAULT )
377# define optional_is_default = default;
379# define optional_is_default {}
382#if optional_HAVE( CONSTEXPR_14 )
383# define optional_constexpr14 constexpr
385# define optional_constexpr14
388#if optional_HAVE( NODISCARD )
389# define optional_nodiscard [[nodiscard]]
391# define optional_nodiscard
394#if optional_HAVE( NOEXCEPT )
395# define optional_noexcept noexcept
397# define optional_noexcept
400#if optional_HAVE( NULLPTR )
401# define optional_nullptr nullptr
403# define optional_nullptr NULL
406#if optional_HAVE( REF_QUALIFIER )
408# define optional_ref_qual &
409# define optional_refref_qual &&
411# define optional_ref_qual
412# define optional_refref_qual
415#if optional_HAVE( STATIC_ASSERT )
416# define optional_static_assert(expr, text) static_assert(expr, text);
418# define optional_static_assert(expr, text)
423#if optional_CONFIG_NO_EXCEPTIONS
429#if optional_CPP11_OR_GREATER
430# include <functional>
433#if optional_HAVE( INITIALIZER_LIST )
434# include <initializer_list>
437#if optional_HAVE( TYPE_TRAITS )
438# include <type_traits>
439#elif optional_HAVE( TR1_TYPE_TRAITS )
440# include <tr1/type_traits>
445#if optional_CPP11_OR_GREATER
447#define optional_REQUIRES_0(...) \
448 template< bool B = (__VA_ARGS__), typename std::enable_if<B, int>::type = 0 >
450#define optional_REQUIRES_T(...) \
451 , typename std::enable_if< (__VA_ARGS__), int >::type = 0
453#define optional_REQUIRES_R(R, ...) \
454 typename std::enable_if< (__VA_ARGS__), R>::type
456#define optional_REQUIRES_A(...) \
457 , typename std::enable_if< (__VA_ARGS__), void*>::type = nullptr
465namespace nonstd {
namespace optional_lite {
475#if optional_CPP11_OR_GREATER
478 template<
typename T > T &
move( T & t ) {
return t; }
481#if optional_HAVE( CONDITIONAL )
482 using std::conditional;
485 template<
typename T,
typename F >
struct conditional<false, T, F> {
typedef F
type; };
488#if optional_HAVE( IS_ASSIGNABLE )
489 using std::is_assignable;
494#if optional_HAVE( IS_MOVE_CONSTRUCTIBLE )
495 using std::is_move_constructible;
500#if optional_HAVE( IS_NOTHROW_MOVE_ASSIGNABLE )
501 using std::is_nothrow_move_assignable;
506#if optional_HAVE( IS_NOTHROW_MOVE_CONSTRUCTIBLE )
507 using std::is_nothrow_move_constructible;
512#if optional_HAVE( IS_TRIVIALLY_COPY_CONSTRUCTIBLE )
513 using std::is_trivially_copy_constructible;
518#if optional_HAVE( IS_TRIVIALLY_MOVE_CONSTRUCTIBLE )
519 using std::is_trivially_move_constructible;
526#if optional_CPP11_OR_GREATER
532#if optional_CPP17_OR_GREATER
534using std::is_swappable;
535using std::is_nothrow_swappable;
537#elif optional_CPP11_OR_GREATER
545 template< typename T, typename = decltype( swap( std::declval<T&>(), std::declval<T&>() ) ) >
552struct is_nothrow_swappable
556 template<
typename T >
557 static constexpr bool satisfies()
559 return noexcept( swap( std::declval<T&>(), std::declval<T&>() ) );
562 template<
typename T >
563 static auto test(
int ) -> std11::integral_constant<bool, satisfies<T>()>{}
566 static auto test(...) -> std11::false_type;
573template<
typename T >
574struct is_swappable : decltype( detail::is_swappable::test<T>(0) ){};
576template<
typename T >
577struct is_nothrow_swappable : decltype( detail::is_nothrow_swappable::test<T>(0) ){};
587template<
typename T >
590 typedef typename std::remove_cv< typename std::remove_reference<T>::type >::type type;
599template<
typename T >
608template<
typename Head,
typename Tail >
615#if optional_CONFIG_MAX_ALIGN_HACK
619#define optional_UNIQUE( name ) optional_UNIQUE2( name, __LINE__ )
620#define optional_UNIQUE2( name, line ) optional_UNIQUE3( name, line )
621#define optional_UNIQUE3( name, line ) name ## line
623#define optional_ALIGN_TYPE( type ) \
624 type optional_UNIQUE( _t ); struct_t< type > optional_UNIQUE( _st )
626template<
typename T >
653 Unknown ( * optional_UNIQUE(_) )( Unknown );
654 Unknown * Unknown::* optional_UNIQUE(_);
655 Unknown ( Unknown::* optional_UNIQUE(_) )( Unknown );
657 struct_t< Unknown ( * )( Unknown) > optional_UNIQUE(_);
658 struct_t< Unknown * Unknown::* > optional_UNIQUE(_);
659 struct_t< Unknown ( Unknown::* )(Unknown) > optional_UNIQUE(_);
662#undef optional_UNIQUE
663#undef optional_UNIQUE2
664#undef optional_UNIQUE3
666#undef optional_ALIGN_TYPE
668#elif defined( optional_CONFIG_ALIGN_AS )
672#define optional_ALIGN_AS( unused ) \
673 optional_CONFIG_ALIGN_AS
679#define optional_ALIGN_AS( to_align ) \
680 typename type_of_size< alignment_types, alignment_of< to_align >::value >::type
682template<
typename T >
685template<
typename T >
693template<
size_t A,
size_t S >
696 enum { value = A < S ? A : S };
699template<
typename T >
706template<
typename List,
size_t N >
710 N ==
sizeof(
typename List::head ),
724#define optional_ALIGN_TYPE( type ) \
725 typelist< type , typelist< struct_t< type >
751 > > > > > > > > > > > > > >
752 > > > > > > > > > > > > > >
756#undef optional_ALIGN_TYPE
762template<
typename T >
782#if optional_CPP11_OR_GREATER
794 template< class... Args >
797 emplace( std::forward<Args>(args)... );
800 template<
class... Args >
801 void emplace( Args&&... args )
806 template< class U, class... Args >
807 void emplace(
std::initializer_list<U> il, Args&&... args )
821 return as<value_type>();
826 return as<value_type>();
839#if optional_HAVE( REF_QUALIFIER )
843 return std::move(
value() );
848 return std::move(
value() );
853#if optional_CPP11_OR_GREATER
855 using aligned_storage_t =
typename std::aligned_storage<
sizeof(
value_type),
alignof(
value_type) >::type;
856 aligned_storage_t
data;
858#elif optional_CONFIG_MAX_ALIGN_HACK
860 typedef struct {
unsigned char data[
sizeof(
value_type) ]; } aligned_storage_t;
863 aligned_storage_t
data;
871# undef optional_ALIGN_AS
885 template <
typename U>
888 return reinterpret_cast<U*
>(
ptr() );
891 template <
typename U>
894 return reinterpret_cast<U
const *
>(
ptr() );
908#if optional_HAVE( CONSTEXPR_11 )
917#if ! optional_CONFIG_NO_EXCEPTIONS
919class bad_optional_access :
public std::logic_error
922 explicit bad_optional_access()
923 : logic_error(
"bad optional access" ) {}
934 "T in optional<T> must not be of type 'nullopt_t'.")
937 "T in optional<T> must not be of type 'in_place_t'.")
939 optional_static_assert(( std::is_object<T>::value && std::is_destructible<T>::value && !std::is_array<T>::value ),
940 "T in optional<T> must meet the Cpp17Destructible requirements.")
943 template<
typename >
friend class optional;
954 : has_value_( false )
961 : has_value_(
false )
966#if optional_CPP11_OR_GREATER
975 : has_value_( other.has_value() )
983#if optional_CPP11_OR_GREATER
986 template<
typename U = T
995 : has_value_( other.has_value() )
997 if ( other.has_value() )
999 contained.construct_value( std::move( other.contained.value() ) );
1004 template<
typename U
1005 optional_REQUIRES_T(
1006 std::is_constructible<T, U const &>::value
1007 && !std::is_constructible<T, optional<U> & >::value
1008 && !std::is_constructible<T, optional<U> && >::value
1009 && !std::is_constructible<T, optional<U>
const & >::value
1010 && !std::is_constructible<T, optional<U>
const && >::value
1011 && !std::is_convertible< optional<U> & , T>::value
1012 && !std::is_convertible< optional<U> && , T>::value
1013 && !std::is_convertible< optional<U>
const & , T>::value
1014 && !std::is_convertible< optional<U>
const &&, T>::value
1015 && !std::is_convertible< U const & , T>::value
1018 explicit optional( optional<U>
const & other )
1019 : has_value_( other.has_value() )
1021 if ( other.has_value() )
1023 contained.construct_value( T{ other.contained.value() } );
1029 template<
typename U
1030#if optional_CPP11_OR_GREATER
1031 optional_REQUIRES_T(
1032 std::is_constructible<T, U const &>::value
1033 && !std::is_constructible<T, optional<U> & >::value
1034 && !std::is_constructible<T, optional<U> && >::value
1035 && !std::is_constructible<T, optional<U>
const & >::value
1036 && !std::is_constructible<T, optional<U>
const && >::value
1037 && !std::is_convertible< optional<U> & , T>::value
1038 && !std::is_convertible< optional<U> && , T>::value
1039 && !std::is_convertible< optional<U>
const & , T>::value
1040 && !std::is_convertible< optional<U>
const &&, T>::value
1041 && std::is_convertible< U const & , T>::value
1047 : has_value_( other.has_value() )
1055#if optional_CPP11_OR_GREATER
1058 template<
typename U
1059 optional_REQUIRES_T(
1060 std::is_constructible<T, U &&>::value
1061 && !std::is_constructible<T,
optional<U> & >::value
1062 && !std::is_constructible<T,
optional<U> && >::value
1063 && !std::is_constructible<T,
optional<U> const & >::value
1064 && !std::is_constructible<T,
optional<U> const && >::value
1065 && !std::is_convertible<
optional<U> & , T>::value
1066 && !std::is_convertible<
optional<U> && , T>::value
1067 && !std::is_convertible<
optional<U> const & , T>::value
1068 && !std::is_convertible<
optional<U> const &&, T>::value
1069 && !std::is_convertible< U &&, T>::value
1074 : has_value_( other.has_value() )
1076 if ( other.has_value() )
1078 contained.construct_value( T{ std::move( other.contained.value() ) } );
1083 template<
typename U
1084 optional_REQUIRES_T(
1085 std::is_constructible<T, U &&>::value
1086 && !std::is_constructible<T, optional<U> & >::value
1087 && !std::is_constructible<T, optional<U> && >::value
1088 && !std::is_constructible<T, optional<U>
const & >::value
1089 && !std::is_constructible<T, optional<U>
const && >::value
1090 && !std::is_convertible< optional<U> & , T>::value
1091 && !std::is_convertible< optional<U> && , T>::value
1092 && !std::is_convertible< optional<U>
const & , T>::value
1093 && !std::is_convertible< optional<U>
const &&, T>::value
1094 && std::is_convertible< U &&, T>::value
1098 optional( optional<U> && other )
1099 : has_value_( other.has_value() )
1101 if ( other.has_value() )
1103 contained.construct_value( std::move( other.contained.value() ) );
1108 template<
typename... Args
1109 optional_REQUIRES_T(
1110 std::is_constructible<T, Args&&...>::value
1114 : has_value_( true )
1115 , contained(
in_place,
std::forward<Args>(args)... )
1119 template<
typename U,
typename... Args
1120 optional_REQUIRES_T(
1121 std::is_constructible<T, std::initializer_list<U>&, Args&&...>::value
1125 : has_value_( true )
1126 , contained( T( il,
std::forward<Args>(args)...) )
1130 template<
typename U = T
1131 optional_REQUIRES_T(
1132 std::is_constructible<T, U&&>::value
1134 && !std::is_same<
typename std20::remove_cvref<U>::type, optional<T>>::value
1135 && !std::is_convertible<U&&, T>::value
1139 : has_value_( true )
1144 template<
typename U = T
1145 optional_REQUIRES_T(
1146 std::is_constructible<T, U&&>::value
1148 && !std::is_same<
typename std20::remove_cvref<U>::type, optional<T>>::value
1149 && std::is_convertible<U&&, T>::value
1154 : has_value_( true )
1162 : has_value_( true )
1163 , contained( value )
1174 contained.destruct_value();
1188#if optional_CPP11_OR_GREATER
1190 optional_REQUIRES_R(
1198 std11::is_nothrow_move_assignable<T>::value
1199 && std11::is_nothrow_move_constructible<T>::value
1205 if ( (has_value() ==
true ) && (other.
has_value() ==
false) ) { reset(); }
1206 else if ( (has_value() ==
false) && (other.
has_value() ==
true ) ) { initialize( *other ); }
1207 else if ( (has_value() ==
true ) && (other.
has_value() ==
true ) ) { contained.value() = *other; }
1211#if optional_CPP11_OR_GREATER
1215 optional_REQUIRES_R(
1221 operator=(
optional && other ) noexcept
1223 if ( (has_value() ==
true ) && (other.
has_value() ==
false) ) { reset(); }
1224 else if ( (has_value() ==
false) && (other.
has_value() ==
true ) ) { initialize( std::move( *other ) ); }
1225 else if ( (has_value() ==
true ) && (other.
has_value() ==
true ) ) { contained.value() = std::move( *other ); }
1230 template<
typename U = T >
1232 optional_REQUIRES_R(
1234 std::is_constructible<T , U>::value
1235 && std11::is_assignable<T&, U>::value
1237 && !std::is_same<
typename std20::remove_cvref<U>::type, optional<T>>::value
1238 && !(std::is_scalar<T>::value && std::is_same<T,
typename std::decay<U>::type>::value)
1240 operator=( U && value )
1244 contained.value() = std::forward<U>( value );
1248 initialize( T( std::forward<U>( value ) ) );
1256 template<
typename U >
1259 if ( has_value() ) contained.
value() = value;
1260 else initialize( T( value ) );
1267 template<
typename U >
1268#if optional_CPP11_OR_GREATER
1270 optional_REQUIRES_R(
1272 std::is_constructible< T , U const &>::value
1274 && !std::is_constructible<T,
optional<U> & >::value
1275 && !std::is_constructible<T,
optional<U> && >::value
1276 && !std::is_constructible<T,
optional<U> const & >::value
1277 && !std::is_constructible<T,
optional<U> const && >::value
1278 && !std::is_convertible<
optional<U> & , T>::value
1279 && !std::is_convertible<
optional<U> && , T>::value
1280 && !std::is_convertible<
optional<U> const & , T>::value
1281 && !std::is_convertible<
optional<U> const &&, T>::value
1295#if optional_CPP11_OR_GREATER
1298 template<
typename U >
1300 optional_REQUIRES_R(
1302 std::is_constructible< T , U>::value
1304 && !std::is_constructible<T,
optional<U> & >::value
1305 && !std::is_constructible<T,
optional<U> && >::value
1306 && !std::is_constructible<T,
optional<U> const & >::value
1307 && !std::is_constructible<T,
optional<U> const && >::value
1308 && !std::is_convertible<
optional<U> & , T>::value
1309 && !std::is_convertible<
optional<U> && , T>::value
1310 && !std::is_convertible<
optional<U> const & , T>::value
1311 && !std::is_convertible<
optional<U> const &&, T>::value
1319 return *
this =
optional( std::move( other ) );
1323 template<
typename... Args
1324 optional_REQUIRES_T(
1325 std::is_constructible<T, Args&&...>::value
1328 T& emplace( Args&&... args )
1331 contained.emplace( std::forward<Args>(args)... );
1333 return contained.value();
1337 template<
typename U,
typename... Args
1338 optional_REQUIRES_T(
1339 std::is_constructible<T, std::initializer_list<U>&, Args&&...>::value
1342 T& emplace( std::initializer_list<U> il, Args&&... args )
1345 contained.emplace( il, std::forward<Args>(args)... );
1347 return contained.value();
1355#if optional_CPP11_OR_GREATER
1358 && std17::is_nothrow_swappable<T>::value
1363 if ( (has_value() ==
true ) && (other.
has_value() == true ) ) {
swap( **
this, *other ); }
1364 else if ( (has_value() ==
false) && (other.
has_value() ==
true ) ) { initialize( std11::move(*other) ); other.
reset(); }
1365 else if ( (has_value() ==
true ) && (other.
has_value() ==
false) ) { other.
initialize( std11::move(**
this) ); reset(); }
1372 return assert( has_value() ),
1373 contained.value_ptr();
1378 return assert( has_value() ),
1379 contained.value_ptr();
1384 return assert( has_value() ),
1390 return assert( has_value() ),
1394#if optional_HAVE( REF_QUALIFIER )
1398 return std::move( **
this );
1403 return std::move( **
this );
1408#if optional_CPP11_OR_GREATER
1416 return has_value() ? &optional::this_type_does_not_support_comparisons : 0;
1429#if optional_CONFIG_NO_EXCEPTIONS
1430 assert( has_value() );
1432 if ( ! has_value() )
1434 throw bad_optional_access();
1437 return contained.value();
1442#if optional_CONFIG_NO_EXCEPTIONS
1443 assert( has_value() );
1445 if ( ! has_value() )
1447 throw bad_optional_access();
1450 return contained.value();
1453#if optional_HAVE( REF_QUALIFIER ) && ( !optional_COMPILER_GNUC_VERSION || optional_COMPILER_GNUC_VERSION >= 490 )
1458 return std::move( value() );
1463 return std::move( value() );
1468#if optional_HAVE( REF_QUALIFIER )
1470 template<
typename U >
1473 return has_value() ? contained.value() :
static_cast<T
>(std::forward<U>( v ) );
1476 template<
typename U >
1479#if optional_COMPILER_CLANG_VERSION
1480 return has_value() ? ( contained.value() ) :
static_cast<T
>(std::forward<U>( v ) );
1482 return has_value() ? std::move( contained.value() ) : static_cast<T>(
std::forward<U>(
v ) );
1488 template<
typename U >
1491 return has_value() ? contained.value() :
static_cast<value_type>( v );
1496#if !optional_CONFIG_NO_EXTENSIONS
1497#if optional_HAVE( REF_QUALIFIER )
1499 template<
typename F >
1502 return has_value() ? contained.value() : f();
1505 template<
typename F >
1510 return std::move( contained.value() );
1520 template<
typename F >
1523 return has_value() ? contained.value() : f();
1535 contained.destruct_value();
1544 template<
typename V >
1547 assert( ! has_value() );
1548 contained.construct_value( value );
1552#if optional_CPP11_OR_GREATER
1553 template<
typename V >
1554 void initialize( V && value )
1556 assert( ! has_value() );
1557 contained.construct_value( std::move( value ) );
1571template<
typename T,
typename U >
1574 return bool(x) != bool(y) ? false : !bool( x ) ? true : *x == *y;
1577template<
typename T,
typename U >
1583template<
typename T,
typename U >
1586 return (!y) ? false : (!x) ?
true : *x < *y;
1589template<
typename T,
typename U >
1595template<
typename T,
typename U >
1601template<
typename T,
typename U >
1609template<
typename T >
1615template<
typename T >
1621template<
typename T >
1627template<
typename T >
1633template<
typename T >
1639template<
typename T >
1645template<
typename T >
1651template<
typename T >
1657template<
typename T >
1663template<
typename T >
1669template<
typename T >
1675template<
typename T >
1683template<
typename T,
typename U >
1686 return bool(x) ? *x == v :
false;
1689template<
typename T,
typename U >
1692 return bool(x) ? v == *x :
false;
1695template<
typename T,
typename U >
1698 return bool(x) ? *x != v :
true;
1701template<
typename T,
typename U >
1704 return bool(x) ? v != *x :
true;
1707template<
typename T,
typename U >
1710 return bool(x) ? *x < v :
true;
1713template<
typename T,
typename U >
1716 return bool(x) ? v < *x :
false;
1719template<
typename T,
typename U >
1722 return bool(x) ? *x <= v :
true;
1725template<
typename T,
typename U >
1728 return bool(x) ? v <= *x :
false;
1731template<
typename T,
typename U >
1734 return bool(x) ? *x > v :
false;
1737template<
typename T,
typename U >
1740 return bool(x) ? v > *x :
true;
1743template<
typename T,
typename U >
1746 return bool(x) ? *x >= v :
false;
1749template<
typename T,
typename U >
1752 return bool(x) ? v >= *x :
true;
1758#if optional_CPP11_OR_GREATER
1759 optional_REQUIRES_T(
1761 && std17::is_swappable<T>::value )
1765#if optional_CPP11_OR_GREATER
1766 noexcept(
noexcept( x.
swap(y) ) )
1772#if optional_CPP11_OR_GREATER
1774template<
typename T >
1780template<
typename T,
typename...Args >
1786template<
typename T,
typename U,
typename... Args >
1794template<
typename T >
1804using optional_lite::optional;
1805using optional_lite::nullopt_t;
1808#if ! optional_CONFIG_NO_EXCEPTIONS
1809using optional_lite::bad_optional_access;
1816#if optional_CPP11_OR_GREATER
1823struct hash<
nonstd::optional<T> >
1828 return bool( v ) ? std::hash<T>{}( *v ) : 0;
1836#if defined(__clang__)
1837# pragma clang diagnostic pop
1838#elif defined(__GNUC__)
1839# pragma GCC diagnostic pop
1840#elif defined(_MSC_VER )
1841# 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_constexpr value_type value_or_eval(F f) const
optional_constexpr14 value_type & value() optional_ref_qual
optional(value_type const &value)
optional_constexpr14 optional(optional const &other)
bool_constant< false > false_type
bool_constant< true > true_type
optional_nodiscard optional_constexpr bool operator>(optional< T > const &x, optional< U > const &y)
optional_nodiscard 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)
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 >())
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 nonstd_lite_in_place( T)
#define nonstd_lite_in_place_t( T)
#define optional_refref_qual
#define optional_constexpr
#define optional_static_assert(expr, text)
#define optional_is_default
#define optional_ALIGN_TYPE(type)
#define optional_constexpr14
#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)