// -*- C++ -*- //===----------------------------------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef _LIBCPP_OPTIONAL #define _LIBCPP_OPTIONAL /* optional synopsis // C++1z namespace std { // [optional.optional], class template optional template <class T> class optional; template<class T> concept is-derived-from-optional = requires(const T& t) { // exposition only []<class U>(const optional<U>&){ }(t); }; // [optional.nullopt], no-value state indicator struct nullopt_t{see below }; inline constexpr nullopt_t nullopt(unspecified ); // [optional.bad.access], class bad_optional_access class bad_optional_access; // [optional.relops], relational operators template <class T, class U> constexpr bool operator==(const optional<T>&, const optional<U>&); template <class T, class U> constexpr bool operator!=(const optional<T>&, const optional<U>&); template <class T, class U> constexpr bool operator<(const optional<T>&, const optional<U>&); template <class T, class U> constexpr bool operator>(const optional<T>&, const optional<U>&); template <class T, class U> constexpr bool operator<=(const optional<T>&, const optional<U>&); template <class T, class U> constexpr bool operator>=(const optional<T>&, const optional<U>&); template<class T, three_way_comparable_with<T> U> constexpr compare_three_way_result_t<T, U> operator<=>(const optional<T>&, const optional<U>&); // since C++20 // [optional.nullops], 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; // until C++17 template<class T> constexpr bool operator!=(const optional<T>&, nullopt_t) noexcept; // until C++17 template<class T> constexpr bool operator!=(nullopt_t, const optional<T>&) noexcept; // until C++17 template<class T> constexpr bool operator<(const optional<T>&, nullopt_t) noexcept; // until C++17 template<class T> constexpr bool operator<(nullopt_t, const optional<T>&) noexcept; // until C++17 template<class T> constexpr bool operator<=(const optional<T>&, nullopt_t) noexcept; // until C++17 template<class T> constexpr bool operator<=(nullopt_t, const optional<T>&) noexcept; // until C++17 template<class T> constexpr bool operator>(const optional<T>&, nullopt_t) noexcept; // until C++17 template<class T> constexpr bool operator>(nullopt_t, const optional<T>&) noexcept; // until C++17 template<class T> constexpr bool operator>=(const optional<T>&, nullopt_t) noexcept; // until C++17 template<class T> constexpr bool operator>=(nullopt_t, const optional<T>&) noexcept; // until C++17 template<class T> constexpr strong_ordering operator<=>(const optional<T>&, nullopt_t) noexcept; // since C++20 // [optional.comp.with.t], comparison with T template<class T, class U> constexpr bool operator==(const optional<T>&, const U&); template<class T, class U> constexpr bool operator==(const T&, const optional<U>&); template<class T, class U> constexpr bool operator!=(const optional<T>&, const U&); template<class T, class U> constexpr bool operator!=(const T&, const optional<U>&); template<class T, class U> constexpr bool operator<(const optional<T>&, const U&); template<class T, class U> constexpr bool operator<(const T&, const optional<U>&); template<class T, class U> constexpr bool operator<=(const optional<T>&, const U&); template<class T, class U> constexpr bool operator<=(const T&, const optional<U>&); template<class T, class U> constexpr bool operator>(const optional<T>&, const U&); template<class T, class U> constexpr bool operator>(const T&, const optional<U>&); template<class T, class U> constexpr bool operator>=(const optional<T>&, const U&); template<class T, class U> constexpr bool operator>=(const T&, const optional<U>&); template<class T, class U> requires (!is-derived-from-optional<U>) && three_way_comparable_with<T, U> constexpr compare_three_way_result_t<T, U> operator<=>(const optional<T>&, const U&); // since C++20 // [optional.specalg], specialized algorithms template<class T> void swap(optional<T>&, optional<T>&) noexcept(see below ); // constexpr in C++20 template<class T> constexpr optional<see below > make_optional(T&&); template<class T, class... Args> constexpr optional<T> make_optional(Args&&... args); template<class T, class U, class... Args> constexpr optional<T> make_optional(initializer_list<U> il, Args&&... args); // [optional.hash], hash support template<class T> struct hash; template<class T> struct hash<optional<T>>; template<class T> class optional { public: using value_type = T; // [optional.ctor], constructors constexpr optional() noexcept; constexpr optional(nullopt_t) noexcept; constexpr optional(const optional &); constexpr optional(optional &&) noexcept(see below); 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 &&...); template<class U = T> constexpr explicit(see-below) optional(U &&); template<class U> explicit(see-below) optional(const optional<U> &); // constexpr in C++20 template<class U> explicit(see-below) optional(optional<U> &&); // constexpr in C++20 // [optional.dtor], destructor ~optional(); // constexpr in C++20 // [optional.assign], assignment optional &operator=(nullopt_t) noexcept; // constexpr in C++20 constexpr optional &operator=(const optional &); constexpr optional &operator=(optional &&) noexcept(see below); template<class U = T> optional &operator=(U &&); // constexpr in C++20 template<class U> optional &operator=(const optional<U> &); // constexpr in C++20 template<class U> optional &operator=(optional<U> &&); // constexpr in C++20 template<class... Args> T& emplace(Args &&...); // constexpr in C++20 template<class U, class... Args> T& emplace(initializer_list<U>, Args &&...); // constexpr in C++20 // [optional.swap], swap void swap(optional &) noexcept(see below ); // constexpr in C++20 // [optional.observe], observers constexpr T const *operator->() const noexcept; constexpr T *operator->() noexcept; constexpr T const &operator*() const & noexcept; constexpr T &operator*() & noexcept; constexpr T &&operator*() && noexcept; constexpr const T &&operator*() const && noexcept; constexpr explicit operator bool() const noexcept; constexpr bool has_value() const noexcept; constexpr T const &value() const &; constexpr T &value() &; constexpr T &&value() &&; constexpr const T &&value() const &&; template<class U> constexpr T value_or(U &&) const &; template<class U> constexpr T value_or(U &&) &&; // [optional.monadic], monadic operations template<class F> constexpr auto and_then(F&& f) &; // since C++23 template<class F> constexpr auto and_then(F&& f) &&; // since C++23 template<class F> constexpr auto and_then(F&& f) const&; // since C++23 template<class F> constexpr auto and_then(F&& f) const&&; // since C++23 template<class F> constexpr auto transform(F&& f) &; // since C++23 template<class F> constexpr auto transform(F&& f) &&; // since C++23 template<class F> constexpr auto transform(F&& f) const&; // since C++23 template<class F> constexpr auto transform(F&& f) const&&; // since C++23 template<class F> constexpr optional or_else(F&& f) &&; // since C++23 template<class F> constexpr optional or_else(F&& f) const&; // since C++23 // [optional.mod], modifiers void reset() noexcept; // constexpr in C++20 private: T *val; // exposition only }; template<class T> optional(T) -> optional<T>; } // namespace std */ #include <__assert> #include <__compare/compare_three_way_result.h> #include <__compare/three_way_comparable.h> #include <__concepts/invocable.h> #include <__config> #include <__exception/exception.h> #include <__functional/hash.h> #include <__functional/invoke.h> #include <__functional/unary_function.h> #include <__fwd/functional.h> #include <__memory/addressof.h> #include <__memory/construct_at.h> #include <__tuple/sfinae_helpers.h> #include <__type_traits/add_pointer.h> #include <__type_traits/conditional.h> #include <__type_traits/conjunction.h> #include <__type_traits/decay.h> #include <__type_traits/disjunction.h> #include <__type_traits/is_array.h> #include <__type_traits/is_assignable.h> #include <__type_traits/is_constructible.h> #include <__type_traits/is_convertible.h> #include <__type_traits/is_destructible.h> #include <__type_traits/is_nothrow_assignable.h> #include <__type_traits/is_nothrow_constructible.h> #include <__type_traits/is_object.h> #include <__type_traits/is_reference.h> #include <__type_traits/is_scalar.h> #include <__type_traits/is_swappable.h> #include <__type_traits/is_trivially_assignable.h> #include <__type_traits/is_trivially_constructible.h> #include <__type_traits/is_trivially_destructible.h> #include <__type_traits/is_trivially_relocatable.h> #include <__type_traits/negation.h> #include <__type_traits/remove_const.h> #include <__type_traits/remove_cvref.h> #include <__type_traits/remove_reference.h> #include <__utility/declval.h> #include <__utility/forward.h> #include <__utility/in_place.h> #include <__utility/move.h> #include <__utility/swap.h> #include <__verbose_abort> #include <initializer_list> #include <new> #include <version> // standard-mandated includes // [optional.syn] #include <compare> #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) # pragma GCC system_header #endif _LIBCPP_PUSH_MACROS #include <__undef_macros> namespace std // purposefully not using versioning namespace { class _LIBCPP_EXPORTED_FROM_ABI _LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS bad_optional_access : public exception { … }; } // namespace std #if _LIBCPP_STD_VER >= 17 _LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_NORETURN inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS void __throw_bad_optional_access() { … } struct nullopt_t { … }; inline constexpr nullopt_t nullopt{ … }; struct __optional_construct_from_invoke_tag { … }; template <class _Tp, bool = is_trivially_destructible<_Tp>::value> struct __optional_destruct_base; __optional_destruct_base<_Tp, false>; __optional_destruct_base<_Tp, true>; template <class _Tp, bool = is_reference<_Tp>::value> struct __optional_storage_base : __optional_destruct_base<_Tp> { … }; // optional<T&> is currently required to be ill-formed. However, it may // be allowed in the future. For this reason, it has already been implemented // to ensure we can make the change in an ABI-compatible manner. __optional_storage_base<_Tp, true>; template <class _Tp, bool = is_trivially_copy_constructible<_Tp>::value> struct __optional_copy_base : __optional_storage_base<_Tp> { … }; __optional_copy_base<_Tp, false>; template <class _Tp, bool = is_trivially_move_constructible<_Tp>::value> struct __optional_move_base : __optional_copy_base<_Tp> { … }; __optional_move_base<_Tp, false>; template <class _Tp, bool = is_trivially_destructible<_Tp>::value && is_trivially_copy_constructible<_Tp>::value && is_trivially_copy_assignable<_Tp>::value> struct __optional_copy_assign_base : __optional_move_base<_Tp> { … }; __optional_copy_assign_base<_Tp, false>; template <class _Tp, bool = is_trivially_destructible<_Tp>::value && is_trivially_move_constructible<_Tp>::value && is_trivially_move_assignable<_Tp>::value> struct __optional_move_assign_base : __optional_copy_assign_base<_Tp> { … }; __optional_move_assign_base<_Tp, false>; __optional_sfinae_ctor_base_t; __optional_sfinae_assign_base_t; template <class _Tp> class optional; # if _LIBCPP_STD_VER >= 20 __is_derived_from_optional; # endif // _LIBCPP_STD_VER >= 20 template <class _Tp> struct __is_std_optional : false_type { … }; __is_std_optional<optional<_Tp>>; template <class _Tp> class _LIBCPP_DECLSPEC_EMPTY_BASES optional : private __optional_move_assign_base<_Tp>, private __optional_sfinae_ctor_base_t<_Tp>, private __optional_sfinae_assign_base_t<_Tp> { … }; # if _LIBCPP_STD_VER >= 17 template <class _Tp> optional(_Tp) -> optional<_Tp>; # endif // Comparisons between optionals template <class _Tp, class _Up> _LIBCPP_HIDE_FROM_ABI constexpr enable_if_t< is_convertible_v<decltype(std::declval<const _Tp&>() == std::declval<const _Up&>()), bool>, bool > operator==(const optional<_Tp>& __x, const optional<_Up>& __y) { … } template <class _Tp, class _Up> _LIBCPP_HIDE_FROM_ABI constexpr enable_if_t< is_convertible_v<decltype(std::declval<const _Tp&>() != std::declval<const _Up&>()), bool>, bool > operator!=(const optional<_Tp>& __x, const optional<_Up>& __y) { … } template <class _Tp, class _Up> _LIBCPP_HIDE_FROM_ABI constexpr enable_if_t< is_convertible_v<decltype(std::declval<const _Tp&>() < std::declval<const _Up&>()), bool>, bool > operator<(const optional<_Tp>& __x, const optional<_Up>& __y) { … } template <class _Tp, class _Up> _LIBCPP_HIDE_FROM_ABI constexpr enable_if_t< is_convertible_v<decltype(std::declval<const _Tp&>() > std::declval<const _Up&>()), bool>, bool > operator>(const optional<_Tp>& __x, const optional<_Up>& __y) { … } template <class _Tp, class _Up> _LIBCPP_HIDE_FROM_ABI constexpr enable_if_t< is_convertible_v<decltype(std::declval<const _Tp&>() <= std::declval<const _Up&>()), bool>, bool > operator<=(const optional<_Tp>& __x, const optional<_Up>& __y) { … } template <class _Tp, class _Up> _LIBCPP_HIDE_FROM_ABI constexpr enable_if_t< is_convertible_v<decltype(std::declval<const _Tp&>() >= std::declval<const _Up&>()), bool>, bool > operator>=(const optional<_Tp>& __x, const optional<_Up>& __y) { … } # if _LIBCPP_STD_VER >= 20 template <class _Tp, three_way_comparable_with<_Tp> _Up> _LIBCPP_HIDE_FROM_ABI constexpr compare_three_way_result_t<_Tp, _Up> operator<=>(const optional<_Tp>& __x, const optional<_Up>& __y) { … } # endif // _LIBCPP_STD_VER >= 20 // Comparisons with nullopt template <class _Tp> _LIBCPP_HIDE_FROM_ABI constexpr bool operator==(const optional<_Tp>& __x, nullopt_t) noexcept { … } # if _LIBCPP_STD_VER <= 17 template <class _Tp> _LIBCPP_HIDE_FROM_ABI constexpr bool operator==(nullopt_t, const optional<_Tp>& __x) noexcept { return !static_cast<bool>(__x); } template <class _Tp> _LIBCPP_HIDE_FROM_ABI constexpr bool operator!=(const optional<_Tp>& __x, nullopt_t) noexcept { return static_cast<bool>(__x); } template <class _Tp> _LIBCPP_HIDE_FROM_ABI constexpr bool operator!=(nullopt_t, const optional<_Tp>& __x) noexcept { return static_cast<bool>(__x); } template <class _Tp> _LIBCPP_HIDE_FROM_ABI constexpr bool operator<(const optional<_Tp>&, nullopt_t) noexcept { return false; } template <class _Tp> _LIBCPP_HIDE_FROM_ABI constexpr bool operator<(nullopt_t, const optional<_Tp>& __x) noexcept { return static_cast<bool>(__x); } template <class _Tp> _LIBCPP_HIDE_FROM_ABI constexpr bool operator<=(const optional<_Tp>& __x, nullopt_t) noexcept { return !static_cast<bool>(__x); } template <class _Tp> _LIBCPP_HIDE_FROM_ABI constexpr bool operator<=(nullopt_t, const optional<_Tp>&) noexcept { return true; } template <class _Tp> _LIBCPP_HIDE_FROM_ABI constexpr bool operator>(const optional<_Tp>& __x, nullopt_t) noexcept { return static_cast<bool>(__x); } template <class _Tp> _LIBCPP_HIDE_FROM_ABI constexpr bool operator>(nullopt_t, const optional<_Tp>&) noexcept { return false; } template <class _Tp> _LIBCPP_HIDE_FROM_ABI constexpr bool operator>=(const optional<_Tp>&, nullopt_t) noexcept { return true; } template <class _Tp> _LIBCPP_HIDE_FROM_ABI constexpr bool operator>=(nullopt_t, const optional<_Tp>& __x) noexcept { return !static_cast<bool>(__x); } # else // _LIBCPP_STD_VER <= 17 template <class _Tp> _LIBCPP_HIDE_FROM_ABI constexpr strong_ordering operator<=>(const optional<_Tp>& __x, nullopt_t) noexcept { … } # endif // _LIBCPP_STD_VER <= 17 // Comparisons with T template <class _Tp, class _Up> _LIBCPP_HIDE_FROM_ABI constexpr enable_if_t< is_convertible_v<decltype(std::declval<const _Tp&>() == std::declval<const _Up&>()), bool>, bool > operator==(const optional<_Tp>& __x, const _Up& __v) { … } template <class _Tp, class _Up> _LIBCPP_HIDE_FROM_ABI constexpr enable_if_t< is_convertible_v<decltype(std::declval<const _Tp&>() == std::declval<const _Up&>()), bool>, bool > operator==(const _Tp& __v, const optional<_Up>& __x) { … } template <class _Tp, class _Up> _LIBCPP_HIDE_FROM_ABI constexpr enable_if_t< is_convertible_v<decltype(std::declval<const _Tp&>() != std::declval<const _Up&>()), bool>, bool > operator!=(const optional<_Tp>& __x, const _Up& __v) { … } template <class _Tp, class _Up> _LIBCPP_HIDE_FROM_ABI constexpr enable_if_t< is_convertible_v<decltype(std::declval<const _Tp&>() != std::declval<const _Up&>()), bool>, bool > operator!=(const _Tp& __v, const optional<_Up>& __x) { … } template <class _Tp, class _Up> _LIBCPP_HIDE_FROM_ABI constexpr enable_if_t< is_convertible_v<decltype(std::declval<const _Tp&>() < std::declval<const _Up&>()), bool>, bool > operator<(const optional<_Tp>& __x, const _Up& __v) { … } template <class _Tp, class _Up> _LIBCPP_HIDE_FROM_ABI constexpr enable_if_t< is_convertible_v<decltype(std::declval<const _Tp&>() < std::declval<const _Up&>()), bool>, bool > operator<(const _Tp& __v, const optional<_Up>& __x) { … } template <class _Tp, class _Up> _LIBCPP_HIDE_FROM_ABI constexpr enable_if_t< is_convertible_v<decltype(std::declval<const _Tp&>() <= std::declval<const _Up&>()), bool>, bool > operator<=(const optional<_Tp>& __x, const _Up& __v) { … } template <class _Tp, class _Up> _LIBCPP_HIDE_FROM_ABI constexpr enable_if_t< is_convertible_v<decltype(std::declval<const _Tp&>() <= std::declval<const _Up&>()), bool>, bool > operator<=(const _Tp& __v, const optional<_Up>& __x) { … } template <class _Tp, class _Up> _LIBCPP_HIDE_FROM_ABI constexpr enable_if_t< is_convertible_v<decltype(std::declval<const _Tp&>() > std::declval<const _Up&>()), bool>, bool > operator>(const optional<_Tp>& __x, const _Up& __v) { … } template <class _Tp, class _Up> _LIBCPP_HIDE_FROM_ABI constexpr enable_if_t< is_convertible_v<decltype(std::declval<const _Tp&>() > std::declval<const _Up&>()), bool>, bool > operator>(const _Tp& __v, const optional<_Up>& __x) { … } template <class _Tp, class _Up> _LIBCPP_HIDE_FROM_ABI constexpr enable_if_t< is_convertible_v<decltype(std::declval<const _Tp&>() >= std::declval<const _Up&>()), bool>, bool > operator>=(const optional<_Tp>& __x, const _Up& __v) { … } template <class _Tp, class _Up> _LIBCPP_HIDE_FROM_ABI constexpr enable_if_t< is_convertible_v<decltype(std::declval<const _Tp&>() >= std::declval<const _Up&>()), bool>, bool > operator>=(const _Tp& __v, const optional<_Up>& __x) { … } # if _LIBCPP_STD_VER >= 20 template <class _Tp, class _Up> requires(!__is_derived_from_optional<_Up>) && three_way_comparable_with<_Tp, _Up> _LIBCPP_HIDE_FROM_ABI constexpr compare_three_way_result_t<_Tp, _Up> operator<=>(const optional<_Tp>& __x, const _Up& __v) { … } # endif // _LIBCPP_STD_VER >= 20 template <class _Tp> inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 enable_if_t< is_move_constructible_v<_Tp> && is_swappable_v<_Tp>, void > swap(optional<_Tp>& __x, optional<_Tp>& __y) noexcept(noexcept(__x.swap(__y))) { … } template <class _Tp> _LIBCPP_HIDE_FROM_ABI constexpr optional<decay_t<_Tp>> make_optional(_Tp&& __v) { … } template <class _Tp, class... _Args> _LIBCPP_HIDE_FROM_ABI constexpr optional<_Tp> make_optional(_Args&&... __args) { … } template <class _Tp, class _Up, class... _Args> _LIBCPP_HIDE_FROM_ABI constexpr optional<_Tp> make_optional(initializer_list<_Up> __il, _Args&&... __args) { … } hash<__enable_hash_helper<optional<_Tp>, remove_const_t<_Tp>>>; _LIBCPP_END_NAMESPACE_STD #endif // _LIBCPP_STD_VER >= 17 _LIBCPP_POP_MACROS #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20 # include <atomic> # include <climits> # include <concepts> # include <ctime> # include <iterator> # include <limits> # include <memory> # include <ratio> # include <stdexcept> # include <tuple> # include <type_traits> # include <typeinfo> # include <utility> # include <variant> #endif #endif // _LIBCPP_OPTIONAL
Codebase Browser
chromium