xref: /freebsd-11.0-release/contrib/libc++/include/experimental/optional

// -*- C++ -*-
//===-------------------------- optional ----------------------------------===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

#ifndef _LIBCPP_OPTIONAL
#define _LIBCPP_OPTIONAL

/*
    optional synopsis

// C++1y

#include <initializer_list>

namespace std { namespace experimental {

// optional for object types
template <class T>
class optional
{
public:
    typedef T value_type;

    // constructors
    constexpr optional() noexcept;
    constexpr optional(nullopt_t) noexcept;
    optional(const optional&);
    optional(optional&&) noexcept(is_nothrow_move_constructible<T>::value);
    constexpr optional(const T&);
    constexpr optional(T&&);
    template <class... Args> constexpr explicit optional(in_place_t, Args&&...);
    template <class U, class... Args>
        constexpr explicit optional(in_place_t, initializer_list<U>, Args&&...);

    // destructor
    ~optional();

    // assignment
    optional& operator=(nullopt_t) noexcept;
    optional& operator=(const optional&);
    optional& operator=(optional&&)
        noexcept(is_nothrow_move_assignable<T>::value &&
                 is_nothrow_move_constructible<T>::value);
    template <class U> optional& operator=(U&&);
    template <class... Args> void emplace(Args&&...);
    template <class U, class... Args> void emplace(initializer_list<U>, Args&&...);

    // swap
    void swap(optional&)
        noexcept(is_nothrow_move_constructible<T>::value &&
                 noexcept(swap(declval<T&>(), declval<T&>())));

    // observers
    constexpr T const* operator->() const;
    T* operator->();
    constexpr T const& operator*() const;
    T& operator*();
    constexpr explicit operator bool() const noexcept;
    constexpr T const& value() const;
    T& value();
    template <class U> constexpr T value_or(U&&) const&;
    template <class U> T value_or(U&&) &&;
};

// In-place construction
struct in_place_t{};
constexpr in_place_t in_place{};

// Disengaged state indicator
struct nullopt_t{see below};
constexpr nullopt_t nullopt(unspecified);

// class bad_optional_access
class bad_optional_access
    : public logic_error
{
public:
    explicit bad_optional_access(const string& what_arg);
    explicit bad_optional_access(const char* what_arg);
};

// Relational operators
template <class T> constexpr bool operator==(const optional<T>&, const optional<T>&);
template <class T> constexpr bool operator< (const optional<T>&, const optional<T>&);

// Comparison with nullopt
template <class T> constexpr bool operator==(const optional<T>&, nullopt_t) noexcept;
template <class T> constexpr bool operator==(nullopt_t, const optional<T>&) noexcept;
template <class T> constexpr bool operator<(const optional<T>&, nullopt_t) noexcept;
template <class T> constexpr bool operator<(nullopt_t, const optional<T>&) noexcept;

// Comparison with T
template <class T> constexpr bool operator==(const optional<T>&, const T&);
template <class T> constexpr bool operator==(const T&, const optional<T>&);
template <class T> constexpr bool operator<(const optional<T>&, const T&);
template <class T> constexpr bool operator<(const T&, const optional<T>&);

// Specialized algorithms
template <class T> void swap(optional<T>&, optional<T>&) noexcept(see below);
template <class T> constexpr optional<typename decay<T>::type> make_optional(T&&);

// hash support
template <class T> struct hash;
template <class T> struct hash<optional<T>>;

}}  // std::experimental

*/

#include <__config>
#include <functional>
#include <stdexcept>

namespace std { namespace experimental {

class _LIBCPP_EXCEPTION_ABI bad_optional_access
    : public logic_error
{
public:
#if _LIBCPP_STD_VER > 11
    _LIBCPP_INLINE_VISIBILITY explicit bad_optional_access(const string& __arg)
        : logic_error(__arg) {}
    _LIBCPP_INLINE_VISIBILITY explicit bad_optional_access(const char* __arg)
        : logic_error(__arg) {}
    _LIBCPP_INLINE_VISIBILITY bad_optional_access(const bad_optional_access&) noexcept = default;
    _LIBCPP_INLINE_VISIBILITY bad_optional_access& operator=(const bad_optional_access&) noexcept = default;
#else
private:
    bad_optional_access(const bad_optional_access&);
    bad_optional_access& operator=(const bad_optional_access&);
public:
#endif  // _LIBCPP_STD_VER > 11
    // Get the key function ~bad_optional_access() into the dylib even if not compiling for C++1y
    virtual ~bad_optional_access() _NOEXCEPT;
};

}}  // std::experimental

#if _LIBCPP_STD_VER > 11

#include <initializer_list>
#include <type_traits>
#include <new>
#include <__functional_base>

#include <__undef_min_max>

#ifdef _LIBCPP_DEBUG
#   include <__debug>
#else
#   define _LIBCPP_ASSERT(x, m) ((void)0)
#endif

#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif

namespace std { namespace experimental { inline namespace __library_fundamentals_v1 {

struct in_place_t {};
constexpr in_place_t in_place{};

struct nullopt_t
{
    explicit constexpr nullopt_t(int) noexcept {}
};

constexpr nullopt_t nullopt{0};

template <class _Tp, bool = is_trivially_destructible<_Tp>::value>
class __optional_storage
{
protected:
    typedef _Tp value_type;
    union
    {
        char __null_state_;
        value_type __val_;
    };
    bool __engaged_ = false;

    _LIBCPP_INLINE_VISIBILITY
    ~__optional_storage()
    {
        if (__engaged_)
            __val_.~value_type();
    }

    _LIBCPP_INLINE_VISIBILITY
    constexpr __optional_storage() noexcept
        :  __null_state_('\0') {}

    _LIBCPP_INLINE_VISIBILITY
    __optional_storage(const __optional_storage& __x)
        :  __engaged_(__x.__engaged_)
        {
            if (__engaged_)
                ::new(_VSTD::addressof(__val_)) value_type(__x.__val_);
        }

    _LIBCPP_INLINE_VISIBILITY
    __optional_storage(__optional_storage&& __x)
                      noexcept(is_nothrow_move_constructible<value_type>::value)
        :  __engaged_(__x.__engaged_)
        {
            if (__engaged_)
                ::new(_VSTD::addressof(__val_)) value_type(_VSTD::move(__x.__val_));
        }

    _LIBCPP_INLINE_VISIBILITY
    constexpr __optional_storage(const value_type& __v)
        :  __val_(__v),
           __engaged_(true) {}

    _LIBCPP_INLINE_VISIBILITY
    constexpr __optional_storage(value_type&& __v)
        :  __val_(_VSTD::move(__v)),
           __engaged_(true) {}

    template <class... _Args>
    _LIBCPP_INLINE_VISIBILITY
    constexpr
    explicit __optional_storage(in_place_t, _Args&&... __args)
       :  __val_(_VSTD::forward<_Args>(__args)...),
           __engaged_(true) {}
};

template <class _Tp>
class __optional_storage<_Tp, true>
{
protected:
    typedef _Tp value_type;
    union
    {
        char __null_state_;
        value_type __val_;
    };
    bool __engaged_ = false;

    _LIBCPP_INLINE_VISIBILITY
    constexpr __optional_storage() noexcept
        :  __null_state_('\0') {}

    _LIBCPP_INLINE_VISIBILITY
    __optional_storage(const __optional_storage& __x)
        :  __engaged_(__x.__engaged_)
        {
            if (__engaged_)
                ::new(_VSTD::addressof(__val_)) value_type(__x.__val_);
        }

    _LIBCPP_INLINE_VISIBILITY
    __optional_storage(__optional_storage&& __x)
                      noexcept(is_nothrow_move_constructible<value_type>::value)
        :  __engaged_(__x.__engaged_)
        {
            if (__engaged_)
                ::new(_VSTD::addressof(__val_)) value_type(_VSTD::move(__x.__val_));
        }

    _LIBCPP_INLINE_VISIBILITY
    constexpr __optional_storage(const value_type& __v)
        :  __val_(__v),
           __engaged_(true) {}

    _LIBCPP_INLINE_VISIBILITY
    constexpr __optional_storage(value_type&& __v)
        :  __val_(_VSTD::move(__v)),
           __engaged_(true) {}

    template <class... _Args>
    _LIBCPP_INLINE_VISIBILITY
    constexpr
    explicit __optional_storage(in_place_t, _Args&&... __args)
       :  __val_(_VSTD::forward<_Args>(__args)...),
           __engaged_(true) {}
};

template <class _Tp>
class optional
    : private __optional_storage<_Tp>
{
    typedef __optional_storage<_Tp> __base;
public:
    typedef _Tp value_type;

    static_assert(!is_reference<value_type>::value,
              "Instantiation of optional with a reference type is ill-formed.");
    static_assert(!is_same<typename remove_cv<value_type>::type, in_place_t>::value,
              "Instantiation of optional with a in_place_t type is ill-formed.");
    static_assert(!is_same<typename remove_cv<value_type>::type, nullopt_t>::value,
              "Instantiation of optional with a nullopt_t type is ill-formed.");
    static_assert(is_object<value_type>::value,
        "Instantiation of optional with a non-object type is undefined behavior.");
    static_assert(is_nothrow_destructible<value_type>::value,
        "Instantiation of optional with an object type that is not noexcept destructible is undefined behavior.");

    _LIBCPP_INLINE_VISIBILITY constexpr optional() noexcept {}
    _LIBCPP_INLINE_VISIBILITY optional(const optional&) = default;
    _LIBCPP_INLINE_VISIBILITY optional(optional&&) = default;
    _LIBCPP_INLINE_VISIBILITY ~optional() = default;
    _LIBCPP_INLINE_VISIBILITY constexpr optional(nullopt_t) noexcept {}
    _LIBCPP_INLINE_VISIBILITY constexpr optional(const value_type& __v)
        : __base(__v) {}
    _LIBCPP_INLINE_VISIBILITY constexpr optional(value_type&& __v)
        : __base(_VSTD::move(__v)) {}

    template <class... _Args,
              class = typename enable_if
                      <
                           is_constructible<value_type, _Args...>::value
                      >::type
             >
    _LIBCPP_INLINE_VISIBILITY
    constexpr
    explicit optional(in_place_t, _Args&&... __args)
        : __base(in_place, _VSTD::forward<_Args>(__args)...) {}

    template <class _Up, class... _Args,
              class = typename enable_if
                      <
                           is_constructible<value_type, initializer_list<_Up>&, _Args...>::value
                      >::type
             >
    _LIBCPP_INLINE_VISIBILITY
    constexpr
    explicit optional(in_place_t, initializer_list<_Up> __il, _Args&&... __args)
        : __base(in_place, __il, _VSTD::forward<_Args>(__args)...) {}

    _LIBCPP_INLINE_VISIBILITY
    optional& operator=(nullopt_t) noexcept
    {
        if (this->__engaged_)
        {
            this->__val_.~value_type();
            this->__engaged_ = false;
        }
        return *this;
    }

    _LIBCPP_INLINE_VISIBILITY
    optional&
    operator=(const optional& __opt)
    {
        if (this->__engaged_ == __opt.__engaged_)
        {
            if (this->__engaged_)
                this->__val_ = __opt.__val_;
        }
        else
        {
            if (this->__engaged_)
                this->__val_.~value_type();
            else
                ::new(_VSTD::addressof(this->__val_)) value_type(__opt.__val_);
            this->__engaged_ = __opt.__engaged_;
        }
        return *this;
    }

    _LIBCPP_INLINE_VISIBILITY
    optional&
    operator=(optional&& __opt)
        noexcept(is_nothrow_move_assignable<value_type>::value &&
                 is_nothrow_move_constructible<value_type>::value)
    {
        if (this->__engaged_ == __opt.__engaged_)
        {
            if (this->__engaged_)
                this->__val_ = _VSTD::move(__opt.__val_);
        }
        else
        {
            if (this->__engaged_)
                this->__val_.~value_type();
            else
                ::new(_VSTD::addressof(this->__val_)) value_type(_VSTD::move(__opt.__val_));
            this->__engaged_ = __opt.__engaged_;
        }
        return *this;
    }

    template <class _Up,
              class = typename enable_if
                      <
                          is_same<typename remove_reference<_Up>::type, value_type>::value &&
                          is_constructible<value_type, _Up>::value &&
                          is_assignable<value_type&, _Up>::value
                      >::type
             >
    _LIBCPP_INLINE_VISIBILITY
    optional&
    operator=(_Up&& __v)
    {
        if (this->__engaged_)
            this->__val_ = _VSTD::forward<_Up>(__v);
        else
        {
            ::new(_VSTD::addressof(this->__val_)) value_type(_VSTD::forward<_Up>(__v));
            this->__engaged_ = true;
        }
        return *this;
    }

    template <class... _Args,
              class = typename enable_if
                      <
                          is_constructible<value_type, _Args...>::value
                      >::type
             >
    _LIBCPP_INLINE_VISIBILITY
    void
    emplace(_Args&&... __args)
    {
        *this = nullopt;
        ::new(_VSTD::addressof(this->__val_)) value_type(_VSTD::forward<_Args>(__args)...);
        this->__engaged_ = true;
    }

    template <class _Up, class... _Args,
              class = typename enable_if
                      <
                          is_constructible<value_type, initializer_list<_Up>&, _Args...>::value
                      >::type
             >
    _LIBCPP_INLINE_VISIBILITY
    void
    emplace(initializer_list<_Up> __il, _Args&&... __args)
    {
        *this = nullopt;
        ::new(_VSTD::addressof(this->__val_)) value_type(__il, _VSTD::forward<_Args>(__args)...);
        this->__engaged_ = true;
    }

    _LIBCPP_INLINE_VISIBILITY
    void
    swap(optional& __opt)
        noexcept(is_nothrow_move_constructible<value_type>::value &&
                 __is_nothrow_swappable<value_type>::value)
    {
        using _VSTD::swap;
        if (this->__engaged_ == __opt.__engaged_)
        {
            if (this->__engaged_)
                swap(this->__val_, __opt.__val_);
        }
        else
        {
            if (this->__engaged_)
            {
                ::new(_VSTD::addressof(__opt.__val_)) value_type(_VSTD::move(this->__val_));
                this->__val_.~value_type();
            }
            else
            {
                ::new(_VSTD::addressof(this->__val_)) value_type(_VSTD::move(__opt.__val_));
                __opt.__val_.~value_type();
            }
            swap(this->__engaged_, __opt.__engaged_);
        }
    }

    _LIBCPP_INLINE_VISIBILITY
    constexpr
    value_type const*
    operator->() const
    {
        _LIBCPP_ASSERT(this->__engaged_, "optional operator-> called for disengaged value");
        return __operator_arrow(__has_operator_addressof<value_type>{});
    }

    _LIBCPP_INLINE_VISIBILITY
    value_type*
    operator->()
    {
        _LIBCPP_ASSERT(this->__engaged_, "optional operator-> called for disengaged value");
        return _VSTD::addressof(this->__val_);
    }

    _LIBCPP_INLINE_VISIBILITY
    constexpr
    const value_type&
    operator*() const
    {
        _LIBCPP_ASSERT(this->__engaged_, "optional operator* called for disengaged value");
        return this->__val_;
    }

    _LIBCPP_INLINE_VISIBILITY
    value_type&
    operator*()
    {
        _LIBCPP_ASSERT(this->__engaged_, "optional operator* called for disengaged value");
        return this->__val_;
    }

    _LIBCPP_INLINE_VISIBILITY
    constexpr explicit operator bool() const noexcept {return this->__engaged_;}

    _LIBCPP_INLINE_VISIBILITY
    constexpr value_type const& value() const
    {
        if (!this->__engaged_)
            throw bad_optional_access("optional<T>::value: not engaged");
        return this->__val_;
    }

    _LIBCPP_INLINE_VISIBILITY
    value_type& value()
    {
        if (!this->__engaged_)
            throw bad_optional_access("optional<T>::value: not engaged");
        return this->__val_;
    }

    template <class _Up>
    _LIBCPP_INLINE_VISIBILITY
    constexpr value_type value_or(_Up&& __v) const&
    {
        static_assert(is_copy_constructible<value_type>::value,
                      "optional<T>::value_or: T must be copy constructible");
        static_assert(is_convertible<_Up, value_type>::value,
                      "optional<T>::value_or: U must be convertible to T");
        return this->__engaged_ ? this->__val_ :
                                  static_cast<value_type>(_VSTD::forward<_Up>(__v));
    }

    template <class _Up>
    _LIBCPP_INLINE_VISIBILITY
    value_type value_or(_Up&& __v) &&
    {
        static_assert(is_move_constructible<value_type>::value,
                      "optional<T>::value_or: T must be move constructible");
        static_assert(is_convertible<_Up, value_type>::value,
                      "optional<T>::value_or: U must be convertible to T");
        return this->__engaged_ ? _VSTD::move(this->__val_) :
                                  static_cast<value_type>(_VSTD::forward<_Up>(__v));
    }

private:
    _LIBCPP_INLINE_VISIBILITY
    value_type const*
    __operator_arrow(true_type) const
    {
        return _VSTD::addressof(this->__val_);
    }

    _LIBCPP_INLINE_VISIBILITY
    constexpr
    value_type const*
    __operator_arrow(false_type) const
    {
        return &this->__val_;
    }
};

template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator==(const optional<_Tp>& __x, const optional<_Tp>& __y)
{
    if (static_cast<bool>(__x) != static_cast<bool>(__y))
        return false;
    if (!static_cast<bool>(__x))
        return true;
    return *__x == *__y;
}

template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator<(const optional<_Tp>& __x, const optional<_Tp>& __y)
{
    if (!static_cast<bool>(__y))
        return false;
    if (!static_cast<bool>(__x))
        return true;
    return less<_Tp>{}(*__x, *__y);
}

template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator==(const optional<_Tp>& __x, nullopt_t) noexcept
{
    return !static_cast<bool>(__x);
}

template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator==(nullopt_t, const optional<_Tp>& __x) noexcept
{
    return !static_cast<bool>(__x);
}

template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator<(const optional<_Tp>&, nullopt_t) noexcept
{
    return false;
}

template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator<(nullopt_t, const optional<_Tp>& __x) noexcept
{
    return static_cast<bool>(__x);
}

template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator==(const optional<_Tp>& __x, const _Tp& __v)
{
    return static_cast<bool>(__x) ? *__x == __v : false;
}

template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator==(const _Tp& __v, const optional<_Tp>& __x)
{
    return static_cast<bool>(__x) ? *__x == __v : false;
}

template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator<(const optional<_Tp>& __x, const _Tp& __v)
{
    return static_cast<bool>(__x) ? less<_Tp>{}(*__x, __v) : true;
}

template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator<(const _Tp& __v, const optional<_Tp>& __x)
{
    return static_cast<bool>(__x) ? less<_Tp>{}(__v, *__x) : false;
}

template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
void
swap(optional<_Tp>& __x, optional<_Tp>& __y) noexcept(noexcept(__x.swap(__y)))
{
    __x.swap(__y);
}

template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
optional<typename decay<_Tp>::type>
make_optional(_Tp&& __v)
{
    return optional<typename decay<_Tp>::type>(_VSTD::forward<_Tp>(__v));
}

}}}  // namespace std::experimental::__library_fundamentals_v1

_LIBCPP_BEGIN_NAMESPACE_STD

template <class _Tp>
struct _LIBCPP_TYPE_VIS_ONLY hash<std::experimental::optional<_Tp> >
{
    typedef std::experimental::optional<_Tp> argument_type;
    typedef size_t        result_type;

    _LIBCPP_INLINE_VISIBILITY
    result_type operator()(const argument_type& __opt) const _NOEXCEPT
    {
        return static_cast<bool>(__opt) ? hash<_Tp>()(*__opt) : 0;
    }
};

_LIBCPP_END_NAMESPACE_STD

#endif  // _LIBCPP_STD_VER > 11

#endif  // _LIBCPP_ARRAY