#pragma once

#ifndef NONSTD_OPTIONAL_LITE_HPP

#define NONSTD_OPTIONAL_LITE_HPP

#define optional_lite_MAJOR 3

#define optional_lite_MINOR 2

#define optional_lite_PATCH 0

#define optional_lite_VERSION optional_STRINGIFY(optional_lite_MAJOR) "." optional_STRINGIFY(optional_lite_MINOR) "." optional_STRINGIFY(optional_lite_PATCH)

#define optional_STRINGIFY( x ) optional_STRINGIFY_( x )

#define optional_STRINGIFY_( x ) #x

#define optional_OPTIONAL_DEFAULT 0

#define optional_OPTIONAL_NONSTD 1

#define optional_OPTIONAL_STD 2

#if !defined( optional_CONFIG_SELECT_OPTIONAL )

# define optional_CONFIG_SELECT_OPTIONAL ( optional_HAVE_STD_OPTIONAL ? optional_OPTIONAL_STD : optional_OPTIONAL_NONSTD )

#endif

#ifndef optional_CONFIG_NO_EXCEPTIONS

# if defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)

# define optional_CONFIG_NO_EXCEPTIONS 0

# else

# define optional_CONFIG_NO_EXCEPTIONS 1

# endif

#endif

#ifndef optional_CPLUSPLUS

# if defined(_MSVC_LANG ) && !defined(__clang__)

# define optional_CPLUSPLUS (_MSC_VER == 1900 ? 201103L : _MSVC_LANG )

# else

# define optional_CPLUSPLUS __cplusplus

# endif

#endif

#define optional_CPP98_OR_GREATER ( optional_CPLUSPLUS >= 199711L )

#define optional_CPP11_OR_GREATER ( optional_CPLUSPLUS >= 201103L )

#define optional_CPP11_OR_GREATER_ ( optional_CPLUSPLUS >= 201103L )

#define optional_CPP14_OR_GREATER ( optional_CPLUSPLUS >= 201402L )

#define optional_CPP17_OR_GREATER ( optional_CPLUSPLUS >= 201703L )

#define optional_CPP20_OR_GREATER ( optional_CPLUSPLUS >= 202000L )

#define optional_CPLUSPLUS_V ( optional_CPLUSPLUS / 100 - (optional_CPLUSPLUS > 200000 ? 2000 : 1994) )

#if optional_CPP17_OR_GREATER && defined(__has_include )

# if __has_include( <optional> )

# define optional_HAVE_STD_OPTIONAL 1

# else

# define optional_HAVE_STD_OPTIONAL 0

# endif

#else

# define optional_HAVE_STD_OPTIONAL 0

#endif

#define optional_USES_STD_OPTIONAL ( (optional_CONFIG_SELECT_OPTIONAL == optional_OPTIONAL_STD) || ((optional_CONFIG_SELECT_OPTIONAL == optional_OPTIONAL_DEFAULT) && optional_HAVE_STD_OPTIONAL) )

#ifndef nonstd_lite_HAVE_IN_PLACE_TYPES

#define nonstd_lite_HAVE_IN_PLACE_TYPES 1

#if optional_CPP17_OR_GREATER

#include <utility>

namespace nonstd {

using std::in_place;

using std::in_place_type;

using std::in_place_index;

using std::in_place_t;

using std::in_place_type_t;

using std::in_place_index_t;

#define nonstd_lite_in_place_t( T) std::in_place_t

#define nonstd_lite_in_place_type_t( T) std::in_place_type_t<T>

#define nonstd_lite_in_place_index_t(K) std::in_place_index_t<K>

#define nonstd_lite_in_place( T) std::in_place_t{}

#define nonstd_lite_in_place_type( T) std::in_place_type_t<T>{}

#define nonstd_lite_in_place_index(K) std::in_place_index_t<K>{}

} // namespace nonstd

#else // optional_CPP17_OR_GREATER

#include <cstddef>

namespace nonstd {

namespace detail {

template< class T >

struct in_place_type_tag {};

template< std::size_t K >

struct in_place_index_tag {};

} // namespace detail

struct in_place_t {};

template< class T >

inline in_place_t in_place( detail::in_place_type_tag<T> /*unused*/ = detail::in_place_type_tag<T>() )

{

return in_place_t();

}

template< std::size_t K >

inline in_place_t in_place( detail::in_place_index_tag<K> /*unused*/ = detail::in_place_index_tag<K>() )

{

return in_place_t();

}

template< class T >

inline in_place_t in_place_type( detail::in_place_type_tag<T> /*unused*/ = detail::in_place_type_tag<T>() )

{

return in_place_t();

}

template< std::size_t K >

inline in_place_t in_place_index( detail::in_place_index_tag<K> /*unused*/ = detail::in_place_index_tag<K>() )

{

return in_place_t();

}

#define nonstd_lite_in_place_t( T) nonstd::in_place_t(&)( nonstd::detail::in_place_type_tag<T> )

#define nonstd_lite_in_place_type_t( T) nonstd::in_place_t(&)( nonstd::detail::in_place_type_tag<T> )

#define nonstd_lite_in_place_index_t(K) nonstd::in_place_t(&)( nonstd::detail::in_place_index_tag<K> )

#define nonstd_lite_in_place( T) nonstd::in_place_type<T>

#define nonstd_lite_in_place_type( T) nonstd::in_place_type<T>

#define nonstd_lite_in_place_index(K) nonstd::in_place_index<K>

} // namespace nonstd

#endif // optional_CPP17_OR_GREATER

#endif // nonstd_lite_HAVE_IN_PLACE_TYPES

#if optional_USES_STD_OPTIONAL

#include <optional>

namespace nonstd {

using std::optional;

using std::bad_optional_access;

using std::hash;

using std::nullopt;

using std::nullopt_t;

using std::operator==;

using std::operator!=;

using std::operator<;

using std::operator<=;

using std::operator>;

using std::operator>=;

using std::make_optional;

using std::swap;

}

#else // optional_USES_STD_OPTIONAL

#include <cassert>

#include <utility>

#ifndef optional_CONFIG_MAX_ALIGN_HACK

# define optional_CONFIG_MAX_ALIGN_HACK 0

#endif

#ifndef optional_CONFIG_ALIGN_AS

#endif

#ifndef optional_CONFIG_ALIGN_AS_FALLBACK

# define optional_CONFIG_ALIGN_AS_FALLBACK double

#endif

#if defined(__clang__)

# pragma clang diagnostic push

# pragma clang diagnostic ignored "-Wundef"

#elif defined(__GNUC__)

# pragma GCC diagnostic push

# pragma GCC diagnostic ignored "-Wundef"

#elif defined(_MSC_VER )

# pragma warning( push )

#endif

#define optional_BETWEEN( v, lo, hi ) ( (lo) <= (v) && (v) < (hi) )

#if defined(_MSC_VER ) && !defined(__clang__)

# define optional_COMPILER_MSVC_VER (_MSC_VER )

# define optional_COMPILER_MSVC_VERSION (_MSC_VER / 10 - 10 * ( 5 + (_MSC_VER < 1900 ) ) )

#else

# define optional_COMPILER_MSVC_VER 0

# define optional_COMPILER_MSVC_VERSION 0

#endif

#define optional_COMPILER_VERSION( major, minor, patch ) ( 10 * (10 * (major) + (minor) ) + (patch) )

#if defined(__GNUC__) && !defined(__clang__)

# define optional_COMPILER_GNUC_VERSION optional_COMPILER_VERSION(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)

#else

# define optional_COMPILER_GNUC_VERSION 0

#endif

#if defined(__clang__)

# define optional_COMPILER_CLANG_VERSION optional_COMPILER_VERSION(__clang_major__, __clang_minor__, __clang_patchlevel__)

#else

# define optional_COMPILER_CLANG_VERSION 0

#endif

#if optional_BETWEEN(optional_COMPILER_MSVC_VERSION, 70, 140 )

# pragma warning( disable: 4345 ) // initialization behavior changed

#endif

#if optional_BETWEEN(optional_COMPILER_MSVC_VERSION, 70, 150 )

# pragma warning( disable: 4814 ) // in C++14 'constexpr' will not imply 'const'

#endif

#define optional_HAVE(FEATURE) ( optional_HAVE_##FEATURE )

#ifdef _HAS_CPP0X

# define optional_HAS_CPP0X _HAS_CPP0X

#else

# define optional_HAS_CPP0X 0

#endif

#if optional_COMPILER_MSVC_VER >= 1900

# undef optional_CPP11_OR_GREATER

# define optional_CPP11_OR_GREATER 1

#endif

#define optional_CPP11_90 (optional_CPP11_OR_GREATER_ || optional_COMPILER_MSVC_VER >= 1500)

#define optional_CPP11_100 (optional_CPP11_OR_GREATER_ || optional_COMPILER_MSVC_VER >= 1600)

#define optional_CPP11_110 (optional_CPP11_OR_GREATER_ || optional_COMPILER_MSVC_VER >= 1700)

#define optional_CPP11_120 (optional_CPP11_OR_GREATER_ || optional_COMPILER_MSVC_VER >= 1800)

#define optional_CPP11_140 (optional_CPP11_OR_GREATER_ || optional_COMPILER_MSVC_VER >= 1900)

#define optional_CPP11_141 (optional_CPP11_OR_GREATER_ || optional_COMPILER_MSVC_VER >= 1910)

#define optional_CPP14_000 (optional_CPP14_OR_GREATER)

#define optional_CPP17_000 (optional_CPP17_OR_GREATER)

#define optional_HAVE_CONSTEXPR_11 optional_CPP11_140

#define optional_HAVE_IS_DEFAULT optional_CPP11_140

#define optional_HAVE_NOEXCEPT optional_CPP11_140

#define optional_HAVE_NULLPTR optional_CPP11_100

#define optional_HAVE_REF_QUALIFIER optional_CPP11_140

#define optional_HAVE_CONSTEXPR_14 optional_CPP14_000

#define optional_HAVE_NODISCARD optional_CPP17_000

#define optional_HAVE_CONDITIONAL optional_CPP11_120

#define optional_HAVE_REMOVE_CV optional_CPP11_120

#define optional_HAVE_TYPE_TRAITS optional_CPP11_90

#define optional_HAVE_TR1_TYPE_TRAITS (!! optional_COMPILER_GNUC_VERSION )

#define optional_HAVE_TR1_ADD_POINTER (!! optional_COMPILER_GNUC_VERSION )

#if optional_HAVE( CONSTEXPR_11 )

# define optional_constexpr constexpr

#else

# define optional_constexpr /*constexpr*/

#endif

#if optional_HAVE( IS_DEFAULT )

# define optional_is_default = default;

#else

# define optional_is_default {}

#endif

#if optional_HAVE( CONSTEXPR_14 )

# define optional_constexpr14 constexpr

#else

# define optional_constexpr14 /*constexpr*/

#endif

#if optional_HAVE( NODISCARD )

# define optional_nodiscard [[nodiscard]]

#else

# define optional_nodiscard /*[[nodiscard]]*/

#endif

#if optional_HAVE( NOEXCEPT )

# define optional_noexcept noexcept

#else

# define optional_noexcept /*noexcept*/

#endif

#if optional_HAVE( NULLPTR )

# define optional_nullptr nullptr

#else

# define optional_nullptr NULL

#endif

#if optional_HAVE( REF_QUALIFIER )

# define optional_ref_qual &

# define optional_refref_qual &&

#else

# define optional_ref_qual /*&*/

# define optional_refref_qual /*&&*/

#endif

#if optional_CONFIG_NO_EXCEPTIONS

#else

# include <stdexcept>

#endif

#if optional_CPP11_OR_GREATER

# include <functional>

#endif

#if optional_HAVE( INITIALIZER_LIST )

# include <initializer_list>

#endif

#if optional_HAVE( TYPE_TRAITS )

# include <type_traits>

#elif optional_HAVE( TR1_TYPE_TRAITS )

# include <tr1/type_traits>

#endif

#if optional_CPP11_OR_GREATER

#define optional_REQUIRES_0(...) \

template< bool B = (__VA_ARGS__), typename std::enable_if<B, int>::type = 0 >

#define optional_REQUIRES_T(...) \

, typename = typename std::enable_if< (__VA_ARGS__), nonstd::optional_lite::detail::enabler >::type

#define optional_REQUIRES_R(R, ...) \

typename std::enable_if< (__VA_ARGS__), R>::type

#define optional_REQUIRES_A(...) \

, typename std::enable_if< (__VA_ARGS__), void*>::type = nullptr

#endif

namespace nonstd { namespace optional_lite {

namespace std11 {

#if optional_CPP11_OR_GREATER

using std::move;

#else

template< typename T > T & move( T & t ) { return t; }

#endif

#if optional_HAVE( CONDITIONAL )

using std::conditional;

#else

template< bool B, typename T, typename F > struct conditional { typedef T type; };

template< typename T, typename F > struct conditional<false, T, F> { typedef F type; };

#endif // optional_HAVE_CONDITIONAL

} // namespace std11

#if optional_CPP11_OR_GREATER

namespace std17 {

#if optional_CPP17_OR_GREATER

using std::is_swappable;

using std::is_nothrow_swappable;

#elif optional_CPP11_OR_GREATER

namespace detail {

using std::swap;

struct is_swappable

};

struct is_nothrow_swappable

};

} // namespace detail

template< typename T >

struct is_swappable : decltype( detail::is_swappable::test<T>(0) ){};

template< typename T >

struct is_nothrow_swappable : decltype( detail::is_nothrow_swappable::test<T>(0) ){};

#endif // optional_CPP17_OR_GREATER

} // namespace std17

namespace std20 {

template< typename T >

struct remove_cvref

{

typedef typename std::remove_cv< typename std::remove_reference<T>::type >::type type;

};

} // namespace std20

#endif // optional_CPP11_OR_GREATER

template< typename T >

class optional;

namespace detail {

#if optional_CPP11_OR_GREATER

enum class enabler{};

#endif

struct nulltype{};

template< typename Head, typename Tail >

struct typelist

};

#if optional_CONFIG_MAX_ALIGN_HACK

#define optional_UNIQUE( name ) optional_UNIQUE2( name, __LINE__ )

#define optional_UNIQUE2( name, line ) optional_UNIQUE3( name, line )

#define optional_UNIQUE3( name, line ) name ## line

#define optional_ALIGN_TYPE( type ) \

type optional_UNIQUE( _t ); struct_t< type > optional_UNIQUE( _st )

template< typename T >

struct struct_t { T _; };

union max_align_t

{

optional_ALIGN_TYPE( char );

optional_ALIGN_TYPE( short int );

optional_ALIGN_TYPE( int );

optional_ALIGN_TYPE( long int );

optional_ALIGN_TYPE( float );

optional_ALIGN_TYPE( double );

optional_ALIGN_TYPE( long double );

optional_ALIGN_TYPE( char * );

optional_ALIGN_TYPE( short int * );

optional_ALIGN_TYPE( int * );

optional_ALIGN_TYPE( long int * );

optional_ALIGN_TYPE( float * );

optional_ALIGN_TYPE( double * );

optional_ALIGN_TYPE( long double * );

optional_ALIGN_TYPE( void * );

#ifdef HAVE_LONG_LONG

optional_ALIGN_TYPE( long long );

#endif

struct Unknown;

Unknown ( * optional_UNIQUE(_) )( Unknown );

Unknown * Unknown::* optional_UNIQUE(_);

Unknown ( Unknown::* optional_UNIQUE(_) )( Unknown );

struct_t< Unknown ( * )( Unknown) > optional_UNIQUE(_);

struct_t< Unknown * Unknown::* > optional_UNIQUE(_);

struct_t< Unknown ( Unknown::* )(Unknown) > optional_UNIQUE(_);

};

#undef optional_UNIQUE

#undef optional_UNIQUE2

#undef optional_UNIQUE3

#undef optional_ALIGN_TYPE

#elif defined( optional_CONFIG_ALIGN_AS ) // optional_CONFIG_MAX_ALIGN_HACK

#define optional_ALIGN_AS( unused ) \

optional_CONFIG_ALIGN_AS

#else // optional_CONFIG_MAX_ALIGN_HACK

#define optional_ALIGN_AS( to_align ) \

typename type_of_size< alignment_types, alignment_of< to_align >::value >::type

template< typename T >

struct alignment_of;

template< typename T >

struct alignment_of_hack

};

template< size_t A, size_t S >

struct alignment_logic

{

enum { value = A < S ? A : S };

};

template< typename T >

struct alignment_of

};

template< typename List, size_t N >

struct type_of_size

};

template< size_t N >

struct type_of_size< nulltype, N >

{

typedef optional_CONFIG_ALIGN_AS_FALLBACK type;

};

template< typename T>

struct struct_t { T _; };

#define optional_ALIGN_TYPE( type ) \

typelist< type , typelist< struct_t< type >

struct Unknown;

optional_ALIGN_TYPE( char ),

optional_ALIGN_TYPE( short ),

optional_ALIGN_TYPE( int ),

optional_ALIGN_TYPE( long ),

optional_ALIGN_TYPE( float ),

optional_ALIGN_TYPE( double ),

optional_ALIGN_TYPE( long double ),

optional_ALIGN_TYPE( char *),

optional_ALIGN_TYPE( short * ),

optional_ALIGN_TYPE( int * ),

optional_ALIGN_TYPE( long * ),

optional_ALIGN_TYPE( float * ),

optional_ALIGN_TYPE( double * ),

optional_ALIGN_TYPE( long double * ),

optional_ALIGN_TYPE( Unknown ( * )( Unknown ) ),

optional_ALIGN_TYPE( Unknown * Unknown::* ),

optional_ALIGN_TYPE( Unknown ( Unknown::* )( Unknown ) ),

nulltype

> > > > > > > > > > > > > >

> > > > > > > > > > > > > >

> > > > > >

alignment_types;

#undef optional_ALIGN_TYPE

#endif // optional_CONFIG_MAX_ALIGN_HACK

template< typename T >

union storage_t

value_type & value() optional_ref_qual

{

return * value_ptr();

}

#if optional_CPP11_OR_GREATER

optional_nodiscard value_type const && value() const optional_refref_qual

{

return std::move( value() );

}

value_type && value() optional_refref_qual

{

return std::move( value() );

}

#endif

#if optional_CPP11_OR_GREATER

using aligned_storage_t = typename std::aligned_storage< sizeof(value_type), alignof(value_type) >::type;

aligned_storage_t data;

#elif optional_CONFIG_MAX_ALIGN_HACK

typedef struct { unsigned char data[ sizeof(value_type) ]; } aligned_storage_t;

max_align_t hack;

aligned_storage_t data;

#else

typedef optional_ALIGN_AS(value_type) align_as_type;

typedef struct { align_as_type data[ 1 + ( sizeof(value_type) - 1 ) / sizeof(align_as_type) ]; } aligned_storage_t;

aligned_storage_t data;

# undef optional_ALIGN_AS

#endif // optional_CONFIG_MAX_ALIGN_HACK

optional_nodiscard void * ptr() optional_noexcept

{

return &data;

}

optional_nodiscard void const * ptr() const optional_noexcept

{

return &data;

}

template <typename U>

optional_nodiscard U * as()

{

return reinterpret_cast<U*>( ptr() );

}

template <typename U>

optional_nodiscard U const * as() const

{

return reinterpret_cast<U const *>( ptr() );

}

};

} // namespace detail

struct nullopt_t

};

#if optional_HAVE( CONSTEXPR_11 )

constexpr nullopt_t nullopt{ nullopt_t::init{} };

#else

const nullopt_t nullopt(( nullopt_t::init() ));

#endif

#if ! optional_CONFIG_NO_EXCEPTIONS

class bad_optional_access : public std::logic_error

};

#endif //optional_CONFIG_NO_EXCEPTIONS

template< typename T>

class optional