optional File Reference

#include <initializer_list>
#include <stdexcept>
#include <type_traits>
#include <utility>
#include <xmemory0>
#include <xsmf_control.h>

Classes
struct	nullopt_t
struct	nullopt_t::_Tag
class	bad_optional_access
struct	_Optional_destruct_base< _Ty, bool >
struct	_Optional_destruct_base< _Ty, true >
struct	_Optional_destruct_base< _Ty, false >
struct	_Optional_construct_base< _Ty >
struct	_Optional_copymove_base< _Ty, bool >
struct	_Optional_copymove_base< _Ty, true >
struct	_Optional_copymove_base< _Ty, false >
struct	hash< optional< _Ty > >

Macros
#define	_OPTIONAL_

Functions
template<class _Ty >
class	__declspec (empty_bases) optional
template<class _Ty >
constexpr bool	operator== (const optional< _Ty > &_Left, const optional< _Ty > &_Right)
template<class _Ty >
constexpr bool	operator!= (const optional< _Ty > &_Left, const optional< _Ty > &_Right)
template<class _Ty >
constexpr bool	operator< (const optional< _Ty > &_Left, const optional< _Ty > &_Right)
template<class _Ty >
constexpr bool	operator> (const optional< _Ty > &_Left, const optional< _Ty > &_Right)
template<class _Ty >
constexpr bool	operator<= (const optional< _Ty > &_Left, const optional< _Ty > &_Right)
template<class _Ty >
constexpr bool	operator>= (const optional< _Ty > &_Left, const optional< _Ty > &_Right)
template<class _Ty >
constexpr bool	operator== (const optional< _Ty > &_Left, nullopt_t) _NOEXCEPT
template<class _Ty >
constexpr bool	operator== (nullopt_t, const optional< _Ty > &_Right) _NOEXCEPT
template<class _Ty >
constexpr bool	operator!= (const optional< _Ty > &_Left, nullopt_t) _NOEXCEPT
template<class _Ty >
constexpr bool	operator!= (nullopt_t, const optional< _Ty > &_Right) _NOEXCEPT
template<class _Ty >
constexpr bool	operator< (const optional< _Ty > &, nullopt_t) _NOEXCEPT
template<class _Ty >
constexpr bool	operator< (nullopt_t, const optional< _Ty > &_Right) _NOEXCEPT
template<class _Ty >
constexpr bool	operator<= (const optional< _Ty > &_Left, nullopt_t) _NOEXCEPT
template<class _Ty >
constexpr bool	operator<= (nullopt_t, const optional< _Ty > &) _NOEXCEPT
template<class _Ty >
constexpr bool	operator> (const optional< _Ty > &_Left, nullopt_t) _NOEXCEPT
template<class _Ty >
constexpr bool	operator> (nullopt_t, const optional< _Ty > &) _NOEXCEPT
template<class _Ty >
constexpr bool	operator>= (const optional< _Ty > &, nullopt_t) _NOEXCEPT
template<class _Ty >
constexpr bool	operator>= (nullopt_t, const optional< _Ty > &_Right) _NOEXCEPT
template<class _Ty >
constexpr bool	operator== (const optional< _Ty > &_Left, const _Ty &_Right)
template<class _Ty >
constexpr bool	operator== (const _Ty &_Left, const optional< _Ty > &_Right)
template<class _Ty >
constexpr bool	operator!= (const optional< _Ty > &_Left, const _Ty &_Right)
template<class _Ty >
constexpr bool	operator!= (const _Ty &_Left, const optional< _Ty > &_Right)
template<class _Ty >
constexpr bool	operator< (const optional< _Ty > &_Left, const _Ty &_Right)
template<class _Ty >
constexpr bool	operator< (const _Ty &_Left, const optional< _Ty > &_Right)
template<class _Ty >
constexpr bool	operator<= (const optional< _Ty > &_Left, const _Ty &_Right)
template<class _Ty >
constexpr bool	operator<= (const _Ty &_Left, const optional< _Ty > &_Right)
template<class _Ty >
constexpr bool	operator> (const optional< _Ty > &_Left, const _Ty &_Right)
template<class _Ty >
constexpr bool	operator> (const _Ty &_Left, const optional< _Ty > &_Right)
template<class _Ty >
constexpr bool	operator>= (const optional< _Ty > &_Left, const _Ty &_Right)
template<class _Ty >
constexpr bool	operator>= (const _Ty &_Left, const optional< _Ty > &_Right)
template<class _Ty , class = enable_if_t<is_move_constructible<_Ty>::value && is_swappable<_Ty>::value>>
void	swap (optional< _Ty > &_Left, optional< _Ty > &_Right) _NOEXCEPT_OP(_NOEXCEPT_OP(_Left.swap(_Right)))
template<class _Ty >
constexpr optional< decay_t< _Ty > >	make_optional (_Ty &&_Value)
template<class _Ty , class... _Types>
constexpr optional< _Ty >	make_optional (_Types &&..._Args)
template<class _Ty , class _Elem , class... _Types>
constexpr optional< _Ty >	make_optional (initializer_list< _Elem > _Ilist, _Types &&..._Args)

Variables
constexpr nullopt_t	nullopt {nullopt_t::_Tag{}}

Macro Definition Documentation

#define _OPTIONAL_

Function Documentation

template<class _Ty >

class __declspec

(

empty_bases

)

        : private _Optional_copymove_base<_Ty>,
        private _SMF_control_copy<is_copy_constructible<_Ty>::value>,
        private _SMF_control_move<is_move_constructible<_Ty>::value>,
        private _SMF_control_copy_assign<is_copy_constructible<_Ty>::value && is_copy_assignable<_Ty>::value>,
        private _SMF_control_move_assign<is_move_constructible<_Ty>::value && is_move_assignable<_Ty>::value>
    {   // optional for object types
public:
    static_assert(!is_reference<_Ty>::value,
        "T in optional<T> cannot be a reference type (N4606 [optional.syn]/1).");
    static_assert(!is_same<remove_cv_t<_Ty>, nullopt_t>::value,
        "T in optional<T> cannot be nullopt_t (N4606 [optional.syn]/1).");
    static_assert(!is_same<remove_cv_t<_Ty>, in_place_t>::value,
        "T in optional<T> cannot be in_place_t (N4606 [optional.syn]/1).");
    static_assert(is_reference<_Ty>::value || is_object<_Ty>::value,
        "T in optional<T> must be an object type (N4606 [optional.object]/3).");
    static_assert(is_destructible<_Ty>::value && !is_array<_Ty>::value,
        "T in optional<T> must satisfy the requirements of Destructible (N4606 [optional.object]/3).");

    using value_type = _Ty;

    // constructors [optional.object.ctor]
    constexpr optional() _NOEXCEPT
        : _Optional_copymove_base<_Ty>{}
        {   // initialize to empty state
        }
    constexpr optional(nullopt_t) _NOEXCEPT
        : _Optional_copymove_base<_Ty>{}
        {   // initialize to empty state
        }

    template<class... _Types,
        class = enable_if_t<is_constructible<_Ty, _Types...>::value>>
        constexpr explicit optional(in_place_t, _Types&&... _Args)
        : _Optional_copymove_base<_Ty>(in_place, _STD forward<_Types>(_Args)...)
        {   // initialize contained value from _Args...
        }

    template<class _Elem,
        class... _Types,
        class = enable_if_t<is_constructible<_Ty, initializer_list<_Elem>&, _Types...>::value>>
        constexpr explicit optional(in_place_t, initializer_list<_Elem> _Ilist, _Types&&... _Args)
        : _Optional_copymove_base<_Ty>(in_place, _Ilist, _STD forward<_Types>(_Args)...)
        {   // initialize contained value from _Ilist and _Args...
        }

    template<class _Ty2>
        using _AllowDirectConversion = bool_constant<
            !is_same<_Ty2, in_place_t>::value
            && !is_same<optional, decay_t<_Ty2>>::value
            && is_constructible<_Ty, _Ty2>::value>;
    template<class _Ty2 = _Ty,
        enable_if_t<conjunction<_AllowDirectConversion<_Ty2>, is_convertible<_Ty2, _Ty>>::value, int> = 0>
        constexpr optional(_Ty2&& _Right)
        : _Optional_copymove_base<_Ty>(in_place, _STD forward<_Ty2>(_Right))
        {   // initialize contained value from _Right
        }
    template<class _Ty2 = _Ty,
        enable_if_t<conjunction<_AllowDirectConversion<_Ty2>, negation<is_convertible<_Ty2, _Ty>>>::value, int> = 0>
        constexpr explicit optional(_Ty2&& _Right)
        : _Optional_copymove_base<_Ty>(in_place, _STD forward<_Ty2>(_Right))
        {   // initialize contained value from _Right
        }

    template<class _Ty2>
        struct _AllowUnwrapping
            : bool_constant<
                !(is_constructible_v<_Ty, optional<_Ty2>&>
                || is_constructible_v<_Ty, const optional<_Ty2>&>
                || is_constructible_v<_Ty, const optional<_Ty2>>
                || is_constructible_v<_Ty, optional<_Ty2>>
                || is_convertible_v<optional<_Ty2>&, _Ty>
                || is_convertible_v<const optional<_Ty2>&, _Ty>
                || is_convertible_v<const optional<_Ty2>, _Ty>
                || is_convertible_v<optional<_Ty2>, _Ty>)>
            {};

    template<class _Ty2,
        enable_if_t<conjunction<
            is_constructible<_Ty, const _Ty2&>,
            _AllowUnwrapping<_Ty2>,
            is_convertible<const _Ty2&, _Ty>>::value, int> = 0>
        optional(const optional<_Ty2>& _Right)
        {   // possibly initialize contained value from _Right
        if (_Right)
            {
            this->_Construct(*_Right);
            }
        }
    template<class _Ty2,
        enable_if_t<conjunction<
            is_constructible<_Ty, const _Ty2&>,
            _AllowUnwrapping<_Ty2>,
            negation<is_convertible<const _Ty2&, _Ty>>>::value, int> = 0>
        explicit optional(const optional<_Ty2>& _Right)
        {   // possibly initialize contained value from _Right
        if (_Right)
            {
            this->_Construct(*_Right);
            }
        }

    template<class _Ty2,
        enable_if_t<conjunction<
            is_constructible<_Ty, _Ty2>,
            _AllowUnwrapping<_Ty2>,
            is_convertible<_Ty2, _Ty>>::value, int> = 0>
        optional(optional<_Ty2>&& _Right)
        {   // possibly initialize contained value from _Right
        if (_Right)
            {
            this->_Construct(_STD move(*_Right));
            }
        }
    template<class _Ty2,
        enable_if_t<conjunction<
            is_constructible<_Ty, _Ty2>,
            _AllowUnwrapping<_Ty2>,
            negation<is_convertible<_Ty2, _Ty>>>::value, int> = 0>
        explicit optional(optional<_Ty2>&& _Right)
        {   // possibly initialize contained value from _Right
        if (_Right)
            {
            this->_Construct(_STD move(*_Right));
            }
        }

    // assignment [optional.object.assign]
    optional& operator=(nullopt_t) _NOEXCEPT
        {   // destroy any contained value and transition to empty state
        reset();
        return (*this);
        }

    template<class _Ty2 = _Ty,
        class = enable_if_t<conjunction<
            bool_constant<
                !is_same<optional, decay_t<_Ty2>>::value
                && !(is_scalar<_Ty>::value && is_same<_Ty, decay_t<_Ty2>>::value)>,
            is_constructible<_Ty, _Ty2>,
            is_assignable<_Ty&, _Ty2>>::value>>
        optional& operator=(_Ty2&& _Right)
        {   // assign/initialize contained value from _Right
        this->_Assign(_STD forward<_Ty2>(_Right));
        return (*this);
        }

    template<class _Ty2>
        struct _AllowUnwrappingAssignment
            : bool_constant<
                !(is_assignable_v<_Ty&, optional<_Ty2>&>
                || is_assignable_v<_Ty&, const optional<_Ty2>&>
                || is_assignable_v<_Ty&, const optional<_Ty2>>
                || is_assignable_v<_Ty&, optional<_Ty2>>)>
            {};

    template<class _Ty2,
        class = enable_if_t<conjunction<
            is_constructible<_Ty, const _Ty2&>,
            is_assignable<_Ty&, const _Ty2&>,
            _AllowUnwrappingAssignment<_Ty2>>::value>>
        optional& operator=(const optional<_Ty2>& _Right)
        {   // assign/initialize/destroy contained value from _Right
        if (_Right)
            {
            this->_Assign(*_Right);
            }
        else
            {
            reset();
            }
        return (*this);
        }

    template<class _Ty2,
        class = enable_if_t<conjunction<
            is_constructible<_Ty, _Ty2>,
            is_assignable<_Ty&, _Ty2>,
            _AllowUnwrappingAssignment<_Ty2>>::value>>
        optional& operator=(optional<_Ty2>&& _Right)
        {   // assign/initialize/destroy contained value from _Right
        if (_Right)
            {
            this->_Assign(_STD move(*_Right));
            }
        else
            {
            reset();
            }
        return (*this);
        }

    template<class... _Types>
        void emplace(_Types&&... _Args)
        {   // destroy any contained value, then initialize from _Args...
        reset();
        this->_Construct(_STD forward<_Types>(_Args)...);
        }

    template<class _Elem,
        class... _Types,
        class = enable_if_t<is_constructible<
            _Ty, initializer_list<_Elem>&, _Types...>::value>>
        void emplace(initializer_list<_Elem> _Ilist, _Types&&... _Args)
        {   // destroy any contained value, then initialize from _Ilist and _Args...
        reset();
        this->_Construct(_Ilist, _STD forward<_Types>(_Args)...);
        }

    // swap [optional.object.swap]
    void swap(optional& _Right)
        _NOEXCEPT_OP(is_nothrow_move_constructible<_Ty>::value && is_nothrow_swappable<_Ty>::value)
        {   // exchange state with _Right
        static_assert(is_move_constructible<_Ty>::value,
            "optional<T>::swap requires T to be move constructible (N4606 [optional.object.swap]/1).");
        static_assert(is_swappable<_Ty>::value,
            "optional<T>::swap requires T to be swappable (N4606 [optional.object.swap]/1).");
        const bool _Engaged = has_value();
        if (_Engaged == _Right.has_value())
            {
            if (_Engaged)
                {
                _Swap_adl(**this, *_Right);
                }
            }
        else
            {
                optional& _Source = *this ? *this : _Right;
                optional& _Target = *this ? _Right : *this;
                _Target._Construct(_STD move(*_Source));
                _Source.reset();
            }
        }

    // observers [optional.object.observe]
    constexpr const _Ty * operator->() const
        {   // return pointer to contained value
        return (_STD addressof(this->_Value));
        }
    _CONSTEXPR14 _Ty * operator->()
        {   // return pointer to contained value
        return (_STD addressof(this->_Value));
        }

    constexpr const _Ty& operator*() const &
        {   // return reference to contained value
        return (this->_Value);
        }
    _CONSTEXPR14 _Ty& operator*() &
        {   // return reference to contained value
        return (this->_Value);
        }
    _CONSTEXPR14 _Ty&& operator*() &&
        {   // return reference to contained value
        return (_STD move(this->_Value));
        }
    constexpr const _Ty&& operator*() const &&
        {   // return reference to contained value
        return (_STD move(this->_Value));
        }

    constexpr explicit operator bool() const _NOEXCEPT
        {   // return true iff *this contains a value
        return (this->_Has_value);
        }
    constexpr bool has_value() const _NOEXCEPT
        {   // return true iff *this contains a value
        return (this->_Has_value);
        }

    constexpr const _Ty& value() const &
        {   // return reference to contained value or throw if none
        return ((void)(has_value() || (_THROW_NCEE(bad_optional_access, _EMPTY_ARGUMENT), true)), **this);
        }
    _CONSTEXPR14 _Ty& value() &
        {   // return reference to contained value or throw if none
        return ((void)(has_value() || (_THROW_NCEE(bad_optional_access, _EMPTY_ARGUMENT), true)), **this);
        }
    _CONSTEXPR14 _Ty&& value() &&
        {   // return reference to contained value or throw if none
        return ((void)(has_value() || (_THROW_NCEE(bad_optional_access, _EMPTY_ARGUMENT), true)), _STD move(**this));
        }
    constexpr const _Ty&& value() const &&
        {   // return reference to contained value or throw if none
        return ((void)(has_value() || (_THROW_NCEE(bad_optional_access, _EMPTY_ARGUMENT), true)), _STD move(**this));
        }

    template<class _Ty2>
        constexpr _Ty value_or(_Ty2&& _Right) const &
        {   // return contained value or _Right if none
        static_assert(is_copy_constructible<_Ty>::value,
            "The const overload of optional<T>::value_or requires T to be copy constructible "
            "(N4606 [optional.object.observe]).");
        static_assert(is_convertible<_Ty2, _Ty>::value,
            "optional<T>::value_or(U) requires U to be convertible to T (N4606 [optional.object.observe]).");
        return (*this ? **this : static_cast<_Ty>(_STD forward<_Ty2>(_Right)));
        }
    template<class _Ty2>
        _CONSTEXPR14 _Ty value_or(_Ty2&& _Right) &&
        {   // return contained value or _Right if none
        static_assert(is_move_constructible<_Ty>::value,
            "The rvalue overload of optional<T>::value_or requires T to be move constructible "
            "(N4606 [optional.object.observe]).");
        static_assert(is_convertible<_Ty2, _Ty>::value,
            "optional<T>::value_or(U) requires U to be convertible to T (N4606 [optional.object.observe]).");
        return (*this ? _STD move(**this) : static_cast<_Ty>(_STD forward<_Ty2>(_Right)));
        }

    // modifiers [optional.object.mod]
    using _Optional_copymove_base<_Ty>::reset;
    };

template<class _Ty >

constexpr optional<decay_t<_Ty> > make_optional

(

_Ty &&

_Value

)

    {   // Construct an optional from _Value
    return (optional<decay_t<_Ty>>{_STD forward<_Ty>(_Value)});
    }

template<class _Ty , class... _Types>

constexpr optional<_Ty> make_optional

(

_Types &&...

_Args

)

    {   // Construct an optional from _Args
    return (optional<_Ty>{in_place, _STD forward<_Types>(_Args)...});
    }

template<class _Ty , class _Elem , class... _Types>

constexpr optional<_Ty> make_optional	(	initializer_list< _Elem >	_Ilist,
		_Types &&...	_Args
	)

    {   // Construct an optional from _Ilist and _Args
    return (optional<_Ty>{in_place, _Ilist, _STD forward<_Types>(_Args)...});
    }

template<class _Ty >

constexpr bool operator!=	(	const optional< _Ty > &	_Left,
		const optional< _Ty > &	_Right
	)

    {
    return (_Left.has_value() != _Right.has_value() || (_Left && *_Left != *_Right));
    }

template<class _Ty >

constexpr bool operator!=	(	const optional< _Ty > &	_Left,
		nullopt_t
	)

    {
    return (_Left.has_value());
    }

template<class _Ty >

constexpr bool operator!=	(	nullopt_t	,
		const optional< _Ty > &	_Right
	)

    {
    return (_Right.has_value());
    }

template<class _Ty >

constexpr bool operator!=	(	const optional< _Ty > &	_Left,
		const _Ty &	_Right
	)

    {
    return (_Left ? *_Left != _Right : true);
    }

template<class _Ty >

constexpr bool operator!=	(	const _Ty &	_Left,
		const optional< _Ty > &	_Right
	)

    {
    return (_Right ? _Left != *_Right : true);
    }

template<class _Ty >

constexpr bool operator<	(	const optional< _Ty > &	_Left,
		const optional< _Ty > &	_Right
	)

    {
    return (_Right && (!_Left || *_Left < *_Right));
    }

template<class _Ty >

constexpr bool operator<	(	const optional< _Ty > &	,
		nullopt_t
	)

    {
    return (false);
    }

template<class _Ty >

constexpr bool operator<	(	nullopt_t	,
		const optional< _Ty > &	_Right
	)

    {
    return (_Right.has_value());
    }

template<class _Ty >

constexpr bool operator<	(	const optional< _Ty > &	_Left,
		const _Ty &	_Right
	)

    {
    return (_Left ? *_Left < _Right : true);
    }

template<class _Ty >

constexpr bool operator<	(	const _Ty &	_Left,
		const optional< _Ty > &	_Right
	)

    {
    return (_Right ? _Left < *_Right : false);
    }

template<class _Ty >

constexpr bool operator<=	(	const optional< _Ty > &	_Left,
		const optional< _Ty > &	_Right
	)

    {
    return (!_Left || (_Right && *_Left <= *_Right));
    }

template<class _Ty >

constexpr bool operator<=	(	const optional< _Ty > &	_Left,
		nullopt_t
	)

    {
    return (!_Left.has_value());
    }

template<class _Ty >

constexpr bool operator<=	(	nullopt_t	,
		const optional< _Ty > &
	)

    {
    return (true);
    }

template<class _Ty >

constexpr bool operator<=	(	const optional< _Ty > &	_Left,
		const _Ty &	_Right
	)

    {
    return (_Left ? *_Left <= _Right : true);
    }

template<class _Ty >

constexpr bool operator<=	(	const _Ty &	_Left,
		const optional< _Ty > &	_Right
	)

    {
    return (_Right ? _Left <= *_Right : false);
    }

template<class _Ty >

constexpr bool operator==	(	const optional< _Ty > &	_Left,
		const optional< _Ty > &	_Right
	)

    {
    return (_Left.has_value() == _Right.has_value() && (!_Left || *_Left == *_Right));
    }

template<class _Ty >

constexpr bool operator==	(	const optional< _Ty > &	_Left,
		nullopt_t
	)

    {
    return (!_Left.has_value());
    }

template<class _Ty >

constexpr bool operator==	(	nullopt_t	,
		const optional< _Ty > &	_Right
	)

    {
    return (!_Right.has_value());
    }

template<class _Ty >

constexpr bool operator==	(	const optional< _Ty > &	_Left,
		const _Ty &	_Right
	)

    {
    return (_Left ? *_Left == _Right : false);
    }

template<class _Ty >

constexpr bool operator==	(	const _Ty &	_Left,
		const optional< _Ty > &	_Right
	)

    {
    return (_Right ? _Left == *_Right : false);
    }

template<class _Ty >

constexpr bool operator>	(	const optional< _Ty > &	_Left,
		const optional< _Ty > &	_Right
	)

    {
    return (_Left && (!_Right || *_Left > *_Right));
    }

template<class _Ty >

constexpr bool operator>	(	const optional< _Ty > &	_Left,
		nullopt_t
	)

    {
    return (_Left.has_value());
    }

template<class _Ty >

constexpr bool operator>	(	nullopt_t	,
		const optional< _Ty > &
	)

    {
    return (false);
    }

template<class _Ty >

constexpr bool operator>	(	const optional< _Ty > &	_Left,
		const _Ty &	_Right
	)

    {
    return (_Left ? *_Left > _Right : false);
    }

template<class _Ty >

constexpr bool operator>	(	const _Ty &	_Left,
		const optional< _Ty > &	_Right
	)

    {
    return (_Right ? _Left > *_Right : true);
    }

template<class _Ty >

constexpr bool operator>=	(	const optional< _Ty > &	_Left,
		const optional< _Ty > &	_Right
	)

    {
    return (!_Right || (_Left && *_Left >= *_Right));
    }

template<class _Ty >

constexpr bool operator>=	(	const optional< _Ty > &	,
		nullopt_t
	)

    {
    return (true);
    }

template<class _Ty >

constexpr bool operator>=	(	nullopt_t	,
		const optional< _Ty > &	_Right
	)

    {
    return (!_Right.has_value());
    }

template<class _Ty >

constexpr bool operator>=	(	const optional< _Ty > &	_Left,
		const _Ty &	_Right
	)

    {
    return (_Left ? *_Left >= _Right : false);
    }

template<class _Ty >

constexpr bool operator>=	(	const _Ty &	_Left,
		const optional< _Ty > &	_Right
	)

    {
    return (_Right ? _Left >= *_Right : true);
    }

template<class _Ty , class = enable_if_t<is_move_constructible<_Ty>::value && is_swappable<_Ty>::value>>

void swap ( optional< _Ty > &  _Left, optional< _Ty > &  _Right  )

inline

    {   // exchange the values of _Left and _Right
    _Left.swap(_Right);
    }

Variable Documentation

constexpr nullopt_t nullopt {nullopt_t::_Tag{}}