From a9e659619f592c49b352af16253ec0b79c207956 Mon Sep 17 00:00:00 2001 From: Eric Fiselier Date: Wed, 12 Oct 2016 07:46:20 +0000 Subject: [PATCH] Implement N4606 optional Summary: Adapt implementation of Library Fundamentals TS optional into an implementation of N4606 optional. - Update relational operators per http://wg21.link/P0307 - Update to requirements of http://wg21.link/P0032 - Extension: Implement trivial copy/move construction/assignment for `optional` when `T` is trivially copyable. Audit P/Rs for optional LWG issues: - 2756 "C++ WP optional should 'forward' T's implicit conversions" Implemented, which also resolves 2753 "Optional's constructors and assignments need constraints" (modulo my refusal to explicitly delete the move operations, which is a design error that I'm working on correcting in the 2756 P/R). - 2736 "nullopt_t insufficiently constrained" Already conforming. I've added a test ensuring that `nullopt_t` is not copy-initializable from an empty braced-init-list, which I believe is the root intent of the issue, to avoid regression. - 2740 "constexpr optional::operator->" Already conforming. - 2746 "Inconsistency between requirements for emplace between optional and variant" No P/R, but note that the author's '"suggested resolution" is already implemented. - 2748 "swappable traits for optionals" Already conforming. - 2753 "Optional's constructors and assignments need constraints" Implemented. Most of the work for this patch was done by Casey Carter @ Microsoft. Thank you Casey! Reviewers: mclow.lists, CaseyCarter, EricWF Differential Revision: https://reviews.llvm.org/D22741 llvm-svn: 283980 --- libcxx/.gitignore | 3 + libcxx/include/__config | 4 + libcxx/include/optional | 1313 +++++++++++++++++ libcxx/include/type_traits | 4 +- libcxx/src/optional.cpp | 12 +- .../optional.object.assign/copy.pass.cpp | 81 + .../optional.object.assign/move.pass.cpp | 78 + .../optional.object.ctor/copy.pass.cpp | 59 + .../optional.object.ctor/move.pass.cpp | 60 + .../special_member_gen.pass.cpp | 66 + .../utilities/optional/version.pass.cpp | 20 + .../is_nothrow_swappable_with.pass.cpp | 2 +- .../default.pass.cpp | 23 + .../derive.pass.cpp | 25 + .../optional.comp_with_t/equal.pass.cpp | 53 + .../optional.comp_with_t/greater.pass.cpp | 55 + .../greater_equal.pass.cpp | 55 + .../optional.comp_with_t/less_equal.pass.cpp | 55 + .../optional.comp_with_t/less_than.pass.cpp | 55 + .../optional.comp_with_t/not_equal.pass.cpp | 53 + .../optional/optional.hash/hash.pass.cpp | 48 + .../optional/optional.nullops/equal.pass.cpp | 39 + .../optional.nullops/greater.pass.cpp | 39 + .../optional.nullops/greater_equal.pass.cpp | 39 + .../optional.nullops/less_equal.pass.cpp | 40 + .../optional.nullops/less_than.pass.cpp | 39 + .../optional.nullops/not_equal.pass.cpp | 39 + .../not_brace_initializable.fail.cpp | 25 + .../optional.nullopt/nullopt_t.pass.cpp | 38 + .../assign_value.pass.cpp | 261 ++++ .../const_optional_U.pass.cpp | 254 ++++ .../optional.object.assign/copy.pass.cpp | 102 ++ .../optional.object.assign/emplace.pass.cpp | 237 +++ .../emplace_initializer_list.pass.cpp | 113 ++ .../optional.object.assign/move.pass.cpp | 174 +++ .../optional.object.assign/nullopt_t.pass.cpp | 67 + .../optional_U.pass.cpp | 268 ++++ .../optional.object.ctor/U.pass.cpp | 137 ++ .../optional.object.ctor/const_T.pass.cpp | 123 ++ .../const_optional_U.pass.cpp | 134 ++ .../optional.object.ctor/copy.pass.cpp | 150 ++ .../optional.object.ctor/default.pass.cpp | 81 + .../explicit_const_optional_U.pass.cpp | 121 ++ .../explicit_optional_U.pass.cpp | 84 ++ .../optional.object.ctor/in_place_t.pass.cpp | 144 ++ .../initializer_list.pass.cpp | 116 ++ .../optional.object.ctor/move.pass.cpp | 196 +++ .../optional.object.ctor/nullopt_t.pass.cpp | 73 + .../optional.object.ctor/optional_U.pass.cpp | 93 ++ .../optional.object.ctor/rvalue_T.pass.cpp | 148 ++ .../optional.object.dtor/dtor.pass.cpp | 68 + .../optional.object.mod/reset.pass.cpp | 61 + .../optional.object.observe/bool.pass.cpp | 37 + .../dereference.pass.cpp | 73 + .../dereference_const.pass.cpp | 69 + .../dereference_const_rvalue.pass.cpp | 69 + .../dereference_rvalue.pass.cpp | 73 + .../has_value.pass.cpp | 37 + .../optional.object.observe/op_arrow.pass.cpp | 72 + .../op_arrow_const.pass.cpp | 76 + .../optional.object.observe/value.pass.cpp | 73 + .../value_const.fail.cpp | 33 + .../value_const.pass.cpp | 64 + .../value_const_rvalue.pass.cpp | 64 + .../optional.object.observe/value_or.pass.cpp | 68 + .../value_or_const.pass.cpp | 77 + .../value_rvalue.pass.cpp | 72 + .../optional.object.swap/swap.pass.cpp | 306 ++++ ...onal_requires_destructible_object.fail.cpp | 50 + .../special_member_gen.pass.cpp | 74 + .../optional/optional.object/types.pass.cpp | 38 + .../optional/optional.relops/equal.pass.cpp | 74 + .../optional.relops/greater_equal.pass.cpp | 70 + .../optional.relops/greater_than.pass.cpp | 70 + .../optional.relops/less_equal.pass.cpp | 70 + .../optional.relops/less_than.pass.cpp | 70 + .../optional.relops/not_equal.pass.cpp | 74 + .../optional.specalg/make_optional.pass.cpp | 51 + .../make_optional_explicit.pass.cpp | 45 + ...ptional_explicit_initializer_list.pass.cpp | 53 + .../optional/optional.specalg/swap.pass.cpp | 352 +++++ .../optional.syn/optional_in_place_t.fail.cpp | 26 + ...ptional_includes_initializer_list.pass.cpp | 22 + .../optional.syn/optional_nullopt_t.fail.cpp | 29 + libcxx/test/support/archetypes.hpp | 322 +++- libcxx/test/support/archetypes.ipp | 141 +- 86 files changed, 8469 insertions(+), 52 deletions(-) create mode 100644 libcxx/include/optional create mode 100644 libcxx/test/libcxx/utilities/optional/optional.object/optional.object.assign/copy.pass.cpp create mode 100644 libcxx/test/libcxx/utilities/optional/optional.object/optional.object.assign/move.pass.cpp create mode 100644 libcxx/test/libcxx/utilities/optional/optional.object/optional.object.ctor/copy.pass.cpp create mode 100644 libcxx/test/libcxx/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp create mode 100644 libcxx/test/libcxx/utilities/optional/optional.object/special_member_gen.pass.cpp create mode 100644 libcxx/test/libcxx/utilities/optional/version.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.bad_optional_access/default.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.bad_optional_access/derive.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.comp_with_t/equal.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.comp_with_t/greater.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.comp_with_t/greater_equal.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.comp_with_t/less_equal.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.comp_with_t/less_than.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.comp_with_t/not_equal.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.hash/hash.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.nullops/equal.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.nullops/greater.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.nullops/greater_equal.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.nullops/less_equal.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.nullops/less_than.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.nullops/not_equal.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.nullopt/not_brace_initializable.fail.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.nullopt/nullopt_t.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.object/optional.object.assign/assign_value.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.object/optional.object.assign/const_optional_U.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.object/optional.object.assign/copy.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.object/optional.object.assign/emplace.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.object/optional.object.assign/emplace_initializer_list.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.object/optional.object.assign/move.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.object/optional.object.assign/nullopt_t.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.object/optional.object.assign/optional_U.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/U.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/const_T.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/const_optional_U.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/copy.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/default.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/explicit_const_optional_U.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/explicit_optional_U.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/in_place_t.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/initializer_list.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/nullopt_t.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/optional_U.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/rvalue_T.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.object/optional.object.dtor/dtor.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.object/optional.object.mod/reset.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.object/optional.object.observe/bool.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.object/optional.object.observe/dereference.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.object/optional.object.observe/dereference_const.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.object/optional.object.observe/dereference_const_rvalue.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.object/optional.object.observe/dereference_rvalue.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.object/optional.object.observe/has_value.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.object/optional.object.observe/op_arrow.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.object/optional.object.observe/op_arrow_const.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.object/optional.object.observe/value.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.object/optional.object.observe/value_const.fail.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.object/optional.object.observe/value_const.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.object/optional.object.observe/value_const_rvalue.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.object/optional.object.observe/value_or.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.object/optional.object.observe/value_or_const.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.object/optional.object.observe/value_rvalue.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.object/optional.object.swap/swap.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.object/optional_requires_destructible_object.fail.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.object/special_member_gen.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.object/types.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.relops/equal.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.relops/greater_equal.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.relops/greater_than.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.relops/less_equal.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.relops/less_than.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.relops/not_equal.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.specalg/make_optional.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.specalg/make_optional_explicit.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.specalg/make_optional_explicit_initializer_list.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.specalg/swap.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.syn/optional_in_place_t.fail.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.syn/optional_includes_initializer_list.pass.cpp create mode 100644 libcxx/test/std/utilities/optional/optional.syn/optional_nullopt_t.fail.cpp diff --git a/libcxx/.gitignore b/libcxx/.gitignore index db7f90d448c05..49657ed8102fb 100644 --- a/libcxx/.gitignore +++ b/libcxx/.gitignore @@ -56,3 +56,6 @@ target/ # MSVC libraries test harness env.lst keep.lst + +# Editor by-products +.vscode/ diff --git a/libcxx/include/__config b/libcxx/include/__config index db55b2c8152e7..b18bd46bafa7a 100644 --- a/libcxx/include/__config +++ b/libcxx/include/__config @@ -914,6 +914,10 @@ extern "C" void __sanitizer_annotate_contiguous_container( #define _LIBCPP_SAFE_STATIC #endif +#if !__has_builtin(__builtin_addressof) && _GNUC_VER < 700 +#define _LIBCPP_HAS_NO_BUILTIN_ADDRESSOF +#endif + #endif // __cplusplus #endif // _LIBCPP_CONFIG diff --git a/libcxx/include/optional b/libcxx/include/optional new file mode 100644 index 0000000000000..46252c7e0e01d --- /dev/null +++ b/libcxx/include/optional @@ -0,0 +1,1313 @@ +// -*- 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++1z + +namespace std { + // 20.6.3, optional for object types + template class optional; + + // 20.6.4, no-value state indicator + struct nullopt_t{see below }; + constexpr nullopt_t nullopt(unspecified ); + + // 20.6.5, class bad_optional_access + class bad_optional_access; + + // 20.6.6, relational operators + template + constexpr bool operator==(const optional&, const optional&); + template + constexpr bool operator!=(const optional&, const optional&); + template + constexpr bool operator<(const optional&, const optional&); + template + constexpr bool operator>(const optional&, const optional&); + template + constexpr bool operator<=(const optional&, const optional&); + template + constexpr bool operator>=(const optional&, const optional&); + template constexpr bool operator==(const optional&, nullopt_t) noexcept; + template constexpr bool operator==(nullopt_t, const optional&) noexcept; + template constexpr bool operator!=(const optional&, nullopt_t) noexcept; + template constexpr bool operator!=(nullopt_t, const optional&) noexcept; + template constexpr bool operator<(const optional&, nullopt_t) noexcept; + template constexpr bool operator<(nullopt_t, const optional&) noexcept; + template constexpr bool operator<=(const optional&, nullopt_t) noexcept; + template constexpr bool operator<=(nullopt_t, const optional&) noexcept; + template constexpr bool operator>(const optional&, nullopt_t) noexcept; + template constexpr bool operator>(nullopt_t, const optional&) noexcept; + template constexpr bool operator>=(const optional&, nullopt_t) noexcept; + template constexpr bool operator>=(nullopt_t, const optional&) noexcept; + + // 20.6.8, comparison with T + template constexpr bool operator==(const optional&, const T&); + template constexpr bool operator==(const T&, const optional&); + template constexpr bool operator!=(const optional&, const T&); + template constexpr bool operator!=(const T&, const optional&); + template constexpr bool operator<(const optional&, const T&); + template constexpr bool operator<(const T&, const optional&); + template constexpr bool operator<=(const optional&, const T&); + template constexpr bool operator<=(const T&, const optional&); + template constexpr bool operator>(const optional&, const T&); + template constexpr bool operator>(const T&, const optional&); + template constexpr bool operator>=(const optional&, const T&); + template constexpr bool operator>=(const T&, const optional&); + + // 20.6.9, specialized algorithms + template void swap(optional&, optional&) noexcept(see below ); + template constexpr optional make_optional(T&&); + template + constexpr optional make_optional(Args&&... args); + template + constexpr optional make_optional(initializer_list il, Args&&... args); + + // 20.6.10, hash support + template struct hash; + template struct hash>; + + template class optional { + public: + using value_type = T; + + // 20.6.3.1, constructors + constexpr optional() noexcept; + constexpr optional(nullopt_t) noexcept; + optional(const optional &); + optional(optional &&) noexcept(see below ); + template constexpr explicit optional(in_place_t, Args &&...); + template + constexpr explicit optional(in_place_t, initializer_list, Args &&...); + template + constexpr EXPLICIT optional(U &&); + template + constexpr EXPLICIT optional(const optional &); + template + constexpr EXPLICIT optional(optional &&); + + // 20.6.3.2, destructor + ~optional(); + + // 20.6.3.3, assignment + optional &operator=(nullopt_t) noexcept; + optional &operator=(const optional &); + optional &operator=(optional &&) noexcept(see below ); + template optional &operator=(U &&); + template optional &operator=(const optional &); + template optional &operator=(optional &&); + template void emplace(Args &&...); + template + void emplace(initializer_list, Args &&...); + + // 20.6.3.4, swap + void swap(optional &) noexcept(see below ); + + // 20.6.3.5, observers + constexpr T const *operator->() const; + constexpr T *operator->(); + constexpr T const &operator*() const &; + constexpr T &operator*() &; + constexpr T &&operator*() &&; + constexpr const T &&operator*() const &&; + 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 constexpr T value_or(U &&) const &; + template constexpr T value_or(U &&) &&; + + // 20.6.3.6, modifiers + void reset() noexcept; + + private: + T *val; // exposition only + }; +} // namespace std + +*/ + +#include <__config> +#include <__debug> +#include <__functional_base> +#include <__undef_min_max> +#include +#include +#include +#include +#include +#include + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +namespace std // purposefully not using versioning namespace +{ + +class _LIBCPP_EXCEPTION_ABI bad_optional_access + : public logic_error +{ +public: + _LIBCPP_INLINE_VISIBILITY + bad_optional_access() : logic_error("bad optional access") {} + + // Get the key function ~bad_optional_access() into the dylib + _LIBCPP_FUNC_VIS + virtual ~bad_optional_access() _NOEXCEPT; +}; + +} // std + +#if _LIBCPP_STD_VER > 14 + +_LIBCPP_BEGIN_NAMESPACE_STD + +_LIBCPP_NORETURN +inline _LIBCPP_INLINE_VISIBILITY +void __throw_bad_optional_access() { +#ifndef _LIBCPP_NO_EXCEPTIONS + throw bad_optional_access(); +#else + _VSTD::abort(); +#endif +} + +struct nullopt_t +{ + struct __secret_tag { _LIBCPP_INLINE_VISIBILITY explicit __secret_tag() = default; }; + _LIBCPP_INLINE_VISIBILITY constexpr explicit nullopt_t(__secret_tag, __secret_tag) noexcept {} +}; + +/* inline */ constexpr nullopt_t nullopt{nullopt_t::__secret_tag{}, nullopt_t::__secret_tag{}}; + +template ::value> +struct __optional_destruct_base; + +template +struct __optional_destruct_base<_Tp, false> +{ + typedef _Tp value_type; + static_assert(is_object_v, + "instantiation of optional with a non-object type is undefined behavior"); + union + { + char __null_state_; + value_type __val_; + }; + bool __engaged_; + + _LIBCPP_INLINE_VISIBILITY + ~__optional_destruct_base() + { + if (__engaged_) + __val_.~value_type(); + } + + _LIBCPP_INLINE_VISIBILITY + constexpr __optional_destruct_base() noexcept + : __null_state_(), + __engaged_(false) {} + + template + _LIBCPP_INLINE_VISIBILITY + constexpr explicit __optional_destruct_base(in_place_t, _Args&&... __args) + : __val_(_VSTD::forward<_Args>(__args)...), + __engaged_(true) {} + + _LIBCPP_INLINE_VISIBILITY + void reset() noexcept + { + if (__engaged_) + { + __val_.~value_type(); + __engaged_ = false; + } + } +}; + +template +struct __optional_destruct_base<_Tp, true> +{ + typedef _Tp value_type; + static_assert(is_object_v, + "instantiation of optional with a non-object type is undefined behavior"); + union + { + char __null_state_; + value_type __val_; + }; + bool __engaged_; + + _LIBCPP_INLINE_VISIBILITY + constexpr __optional_destruct_base() noexcept + : __null_state_(), + __engaged_(false) {} + + template + _LIBCPP_INLINE_VISIBILITY + constexpr explicit __optional_destruct_base(in_place_t, _Args&&... __args) + : __val_(_VSTD::forward<_Args>(__args)...), + __engaged_(true) {} + + _LIBCPP_INLINE_VISIBILITY + void reset() noexcept + { + if (__engaged_) + { + __engaged_ = false; + } + } +}; + +template ::value> +struct __optional_storage_base : __optional_destruct_base<_Tp> +{ + using __base = __optional_destruct_base<_Tp>; + using value_type = _Tp; + using __base::__base; + + _LIBCPP_INLINE_VISIBILITY + constexpr bool has_value() const noexcept + { + return this->__engaged_; + } + + _LIBCPP_INLINE_VISIBILITY + constexpr value_type& __get() & noexcept + { + return this->__val_; + } + _LIBCPP_INLINE_VISIBILITY + constexpr const value_type& __get() const& noexcept + { + return this->__val_; + } + _LIBCPP_INLINE_VISIBILITY + constexpr value_type&& __get() && noexcept + { + return _VSTD::move(this->__val_); + } + _LIBCPP_INLINE_VISIBILITY + constexpr const value_type&& __get() const&& noexcept + { + return _VSTD::move(this->__val_); + } + + template + _LIBCPP_INLINE_VISIBILITY + void __construct(_Args&&... __args) + { + _LIBCPP_ASSERT(!has_value(), "__construct called for engaged __optional_storage"); + ::new((void*)_VSTD::addressof(this->__val_)) value_type(_VSTD::forward<_Args>(__args)...); + this->__engaged_ = true; + } + + template + _LIBCPP_INLINE_VISIBILITY + void __construct_from(_That&& __opt) + { + if (__opt.has_value()) + __construct(_VSTD::forward<_That>(__opt).__get()); + } + + template + _LIBCPP_INLINE_VISIBILITY + void __assign_from(_That&& __opt) + { + if (this->__engaged_ == __opt.has_value()) + { + if (this->__engaged_) + this->__val_ = _VSTD::forward<_That>(__opt).__get(); + } + else + { + if (this->__engaged_) + this->reset(); + else + __construct(_VSTD::forward<_That>(__opt).__get()); + } + } +}; + +// optional is currently required ill-formed, however it may to be in the +// future. For this reason it has already been implemented to ensure we can +// make the change in an ABI compatible manner. +template +struct __optional_storage_base<_Tp, true> +{ + using value_type = _Tp; + using __raw_type = remove_reference_t<_Tp>; + __raw_type* __value_; + + template + static constexpr bool __can_bind_reference() { + using _RawUp = typename remove_reference<_Up>::type; + using _UpPtr = _RawUp*; + using _RawTp = typename remove_reference<_Tp>::type; + using _TpPtr = _RawTp*; + using _CheckLValueArg = integral_constant::value && is_convertible<_UpPtr, _TpPtr>::value) + || is_same<_RawUp, reference_wrapper<_RawTp>>::value + || is_same<_RawUp, reference_wrapper::type>>::value + >; + return (is_lvalue_reference<_Tp>::value && _CheckLValueArg::value) + || (is_rvalue_reference<_Tp>::value && !is_lvalue_reference<_Up>::value && + is_convertible<_UpPtr, _TpPtr>::value); + } + + _LIBCPP_INLINE_VISIBILITY + constexpr __optional_storage_base() noexcept + : __value_(nullptr) {} + + template + _LIBCPP_INLINE_VISIBILITY + constexpr explicit __optional_storage_base(in_place_t, _UArg&& __uarg) + : __value_(_VSTD::addressof(__uarg)) + { + static_assert(__can_bind_reference<_UArg>(), + "Attempted to construct a reference element in tuple from a " + "possible temporary"); + } + + _LIBCPP_INLINE_VISIBILITY + void reset() noexcept { __value_ = nullptr; } + + _LIBCPP_INLINE_VISIBILITY + constexpr bool has_value() const noexcept + { return __value_ != nullptr; } + + _LIBCPP_INLINE_VISIBILITY + constexpr value_type& __get() const& noexcept + { return *__value_; } + + _LIBCPP_INLINE_VISIBILITY + constexpr value_type&& __get() const&& noexcept + { return _VSTD::forward(*__value_); } + + template + _LIBCPP_INLINE_VISIBILITY + void __construct(_UArg&& __val) + { + _LIBCPP_ASSERT(!has_value(), "__construct called for engaged __optional_storage"); + static_assert(__can_bind_reference<_UArg>(), + "Attempted to construct a reference element in tuple from a " + "possible temporary"); + __value_ = _VSTD::addressof(__val); + } + + template + _LIBCPP_INLINE_VISIBILITY + void __construct_from(_That&& __opt) + { + if (__opt.has_value()) + __construct(_VSTD::forward<_That>(__opt).__get()); + } + + template + _LIBCPP_INLINE_VISIBILITY + void __assign_from(_That&& __opt) + { + if (has_value() == __opt.has_value()) + { + if (has_value()) + *__value_ = _VSTD::forward<_That>(__opt).__get(); + } + else + { + if (has_value()) + reset(); + else + __construct(_VSTD::forward<_That>(__opt).__get()); + } + } +}; + +template ::value> +struct __optional_storage; + +template +struct __optional_storage<_Tp, true> : __optional_storage_base<_Tp> +{ + using __optional_storage_base<_Tp>::__optional_storage_base; +}; + +template +struct __optional_storage<_Tp, false> : __optional_storage_base<_Tp> +{ + using value_type = _Tp; + using __optional_storage_base<_Tp>::__optional_storage_base; + + _LIBCPP_INLINE_VISIBILITY + __optional_storage() = default; + + _LIBCPP_INLINE_VISIBILITY + __optional_storage(const __optional_storage& __opt) + { + this->__construct_from(__opt); + } + + _LIBCPP_INLINE_VISIBILITY + __optional_storage(__optional_storage&& __opt) + noexcept(is_nothrow_move_constructible_v) + { + this->__construct_from(_VSTD::move(__opt)); + } + + _LIBCPP_INLINE_VISIBILITY + __optional_storage& operator=(const __optional_storage& __opt) + { + this->__assign_from(__opt); + return *this; + } + + _LIBCPP_INLINE_VISIBILITY + __optional_storage& operator=(__optional_storage&& __opt) + noexcept(is_nothrow_move_assignable_v && + is_nothrow_move_constructible_v) + { + this->__assign_from(_VSTD::move(__opt)); + return *this; + } +}; + +template +using __optional_sfinae_ctor_base_t = __sfinae_ctor_base< + is_copy_constructible<_Tp>::value, + is_move_constructible<_Tp>::value +>; + +template +using __optional_sfinae_assign_base_t = __sfinae_assign_base< + (is_copy_constructible<_Tp>::value && is_copy_assignable<_Tp>::value), + (is_move_constructible<_Tp>::value && is_move_assignable<_Tp>::value) +>; + +template +class optional + : private __optional_storage<_Tp> + , private __optional_sfinae_ctor_base_t<_Tp> + , private __optional_sfinae_assign_base_t<_Tp> +{ + using __base = __optional_storage<_Tp>; +public: + using value_type = _Tp; + +private: + // Disable the reference extension using this static assert. + static_assert(!is_same_v, + "instantiation of optional with in_place_t is ill-formed"); + static_assert(!is_same_v<__uncvref_t, nullopt_t>, + "instantiation of optional with nullopt_t is ill-formed"); + static_assert(!is_reference_v, + "instantiation of optional with a reference type is ill-formed"); + static_assert(is_destructible_v, + "instantiation of optional with a non-destructible type is ill-formed"); + + // LWG2756: conditionally explicit conversion from _Up + struct _CheckOptionalArgsConstructor { + template + static constexpr bool __enable_implicit() { + return is_constructible_v<_Tp, _Up&&> && + is_convertible_v<_Up&&, _Tp>; + } + + template + static constexpr bool __enable_explicit() { + return is_constructible_v<_Tp, _Up&&> && + !is_convertible_v<_Up&&, _Tp>; + } + }; + template + using _CheckOptionalArgsCtor = conditional_t< + !is_same_v && + !is_same_v, optional>, + _CheckOptionalArgsConstructor, + __check_tuple_constructor_fail + >; + template + struct _CheckOptionalLikeConstructor { + template > + using __check_constructible_from_opt = __lazy_or< + is_constructible<_Tp, _Opt&>, + is_constructible<_Tp, _Opt const&>, + is_constructible<_Tp, _Opt&&>, + is_constructible<_Tp, _Opt const&&>, + is_convertible<_Opt&, _Tp>, + is_convertible<_Opt const&, _Tp>, + is_convertible<_Opt&&, _Tp>, + is_convertible<_Opt const&&, _Tp> + >; + template > + using __check_assignable_from_opt = __lazy_or< + is_assignable<_Tp&, _Opt&>, + is_assignable<_Tp&, _Opt const&>, + is_assignable<_Tp&, _Opt&&>, + is_assignable<_Tp&, _Opt const&&> + >; + template + static constexpr bool __enable_implicit() { + return is_convertible<_QUp, _Tp>::value && + !__check_constructible_from_opt<_Up>::value; + } + template + static constexpr bool __enable_explicit() { + return !is_convertible<_QUp, _Tp>::value && + !__check_constructible_from_opt<_Up>::value; + } + template + static constexpr bool __enable_assign() { + // Construction and assignability of _Qup to _Tp has already been + // checked. + return !__check_constructible_from_opt<_Up>::value && + !__check_assignable_from_opt<_Up>::value; + } + }; + + template + using _CheckOptionalLikeCtor = conditional_t< + __lazy_and< + __lazy_not>, + is_constructible<_Tp, _QualUp> + >::value, + _CheckOptionalLikeConstructor<_QualUp>, + __check_tuple_constructor_fail + >; + template + using _CheckOptionalLikeAssign = conditional_t< + __lazy_and< + __lazy_not>, + is_constructible<_Tp, _QualUp>, + is_assignable<_Tp&, _QualUp> + >::value, + _CheckOptionalLikeConstructor<_QualUp>, + __check_tuple_constructor_fail + >; +public: + + _LIBCPP_INLINE_VISIBILITY constexpr optional() noexcept {} + _LIBCPP_INLINE_VISIBILITY optional(const optional&) = default; + _LIBCPP_INLINE_VISIBILITY optional(optional&&) = default; + _LIBCPP_INLINE_VISIBILITY constexpr optional(nullopt_t) noexcept {} + + template > + > + _LIBCPP_INLINE_VISIBILITY + constexpr explicit optional(in_place_t, _Args&&... __args) + : __base(in_place, _VSTD::forward<_Args>(__args)...) {} + + template &, _Args...>> + > + _LIBCPP_INLINE_VISIBILITY + constexpr explicit optional(in_place_t, initializer_list<_Up> __il, _Args&&... __args) + : __base(in_place, __il, _VSTD::forward<_Args>(__args)...) {} + + template ::template __enable_implicit<_Up>() + , int> = 0> + _LIBCPP_INLINE_VISIBILITY + constexpr optional(_Up&& __v) + : __base(in_place, _VSTD::forward<_Up>(__v)) {} + + template ::template __enable_explicit<_Up>() + , int> = 0> + _LIBCPP_INLINE_VISIBILITY + constexpr explicit optional(_Up&& __v) + : __base(in_place, _VSTD::forward<_Up>(__v)) {} + + // LWG2756: conditionally explicit conversion from const optional<_Up>& + template ::template __enable_implicit<_Up>() + , int> = 0> + _LIBCPP_INLINE_VISIBILITY + optional(const optional<_Up>& __v) + { + this->__construct_from(__v); + } + template ::template __enable_explicit<_Up>() + , int> = 0> + _LIBCPP_INLINE_VISIBILITY + explicit optional(const optional<_Up>& __v) + { + this->__construct_from(__v); + } + + // LWG2756: conditionally explicit conversion from optional<_Up>&& + template ::template __enable_implicit<_Up>() + , int> = 0> + _LIBCPP_INLINE_VISIBILITY + optional(optional<_Up>&& __v) + { + this->__construct_from(_VSTD::move(__v)); + } + template ::template __enable_explicit<_Up>() + , int> = 0> + _LIBCPP_INLINE_VISIBILITY + explicit optional(optional<_Up>&& __v) + { + this->__construct_from(_VSTD::move(__v)); + } + + _LIBCPP_INLINE_VISIBILITY + optional& operator=(nullopt_t) noexcept + { + reset(); + return *this; + } + + _LIBCPP_INLINE_VISIBILITY optional& operator=(const optional&) = default; + _LIBCPP_INLINE_VISIBILITY optional& operator=(optional&&) = default; + + // LWG2756 + template && + !(is_same_v<_Up, value_type> && is_scalar_v) && + is_constructible_v && + is_assignable_v + > + > + _LIBCPP_INLINE_VISIBILITY + optional& + operator=(_Up&& __v) + { + if (this->has_value()) + this->__get() = _VSTD::forward<_Up>(__v); + else + this->__construct(_VSTD::forward<_Up>(__v)); + return *this; + } + + // LWG2756 + template ::template __enable_assign<_Up>() + , int> = 0> + _LIBCPP_INLINE_VISIBILITY + optional& + operator=(const optional<_Up>& __v) + { + this->__assign_from(__v); + return *this; + } + + // LWG2756 + template ::template __enable_assign<_Up>() + , int> = 0> + _LIBCPP_INLINE_VISIBILITY + optional& + operator=(optional<_Up>&& __v) + { + this->__assign_from(_VSTD::move(__v)); + return *this; + } + + template + > + > + _LIBCPP_INLINE_VISIBILITY + void + emplace(_Args&&... __args) + { + reset(); + this->__construct(_VSTD::forward<_Args>(__args)...); + } + + template &, _Args...> + > + > + _LIBCPP_INLINE_VISIBILITY + void + emplace(initializer_list<_Up> __il, _Args&&... __args) + { + reset(); + this->__construct(__il, _VSTD::forward<_Args>(__args)...); + } + + _LIBCPP_INLINE_VISIBILITY + void swap(optional& __opt) + noexcept(is_nothrow_move_constructible_v && + is_nothrow_swappable_v) + { + if (this->has_value() == __opt.has_value()) + { + using _VSTD::swap; + if (this->has_value()) + swap(this->__get(), __opt.__get()); + } + else + { + if (this->has_value()) + { + __opt.__construct(_VSTD::move(this->__get())); + reset(); + } + else + { + this->__construct(_VSTD::move(__opt.__get())); + __opt.reset(); + } + } + } + + _LIBCPP_INLINE_VISIBILITY + constexpr + add_pointer_t + operator->() const + { + _LIBCPP_ASSERT(this->has_value(), "optional operator-> called for disengaged value"); +#ifndef _LIBCPP_HAS_NO_BUILTIN_ADDRESSOF + return _VSTD::addressof(this->__get()); +#else + return __operator_arrow(__has_operator_addressof{}, this->__get()); +#endif + } + + _LIBCPP_INLINE_VISIBILITY + constexpr + add_pointer_t + operator->() + { + _LIBCPP_ASSERT(this->has_value(), "optional operator-> called for disengaged value"); +#ifndef _LIBCPP_HAS_NO_BUILTIN_ADDRESSOF + return _VSTD::addressof(this->__get()); +#else + return __operator_arrow(__has_operator_addressof{}, this->__get()); +#endif + } + + _LIBCPP_INLINE_VISIBILITY + constexpr + const value_type& + operator*() const& + { + _LIBCPP_ASSERT(this->has_value(), "optional operator* called for disengaged value"); + return this->__get(); + } + + _LIBCPP_INLINE_VISIBILITY + constexpr + value_type& + operator*() & + { + _LIBCPP_ASSERT(this->has_value(), "optional operator* called for disengaged value"); + return this->__get(); + } + + _LIBCPP_INLINE_VISIBILITY + constexpr + value_type&& + operator*() && + { + _LIBCPP_ASSERT(this->has_value(), "optional operator* called for disengaged value"); + return _VSTD::move(this->__get()); + } + + _LIBCPP_INLINE_VISIBILITY + constexpr + const value_type&& + operator*() const&& + { + _LIBCPP_ASSERT(this->has_value(), "optional operator* called for disengaged value"); + return _VSTD::move(this->__get()); + } + + _LIBCPP_INLINE_VISIBILITY + constexpr explicit operator bool() const noexcept { return has_value(); } + + using __base::has_value; + using __base::__get; + + _LIBCPP_INLINE_VISIBILITY + constexpr value_type const& value() const& + { + if (!this->has_value()) + __throw_bad_optional_access(); + return this->__get(); + } + + _LIBCPP_INLINE_VISIBILITY + constexpr value_type& value() & + { + if (!this->has_value()) + __throw_bad_optional_access(); + return this->__get(); + } + + _LIBCPP_INLINE_VISIBILITY + constexpr value_type&& value() && + { + if (!this->has_value()) + __throw_bad_optional_access(); + return _VSTD::move(this->__get()); + } + + _LIBCPP_INLINE_VISIBILITY + constexpr value_type const&& value() const&& + { + if (!this->has_value()) + __throw_bad_optional_access(); + return _VSTD::move(this->__get()); + } + + template + _LIBCPP_INLINE_VISIBILITY + constexpr value_type value_or(_Up&& __v) const& + { + static_assert(is_copy_constructible_v, + "optional::value_or: T must be copy constructible"); + static_assert(is_convertible_v<_Up, value_type>, + "optional::value_or: U must be convertible to T"); + return this->has_value() ? this->__get() : + static_cast(_VSTD::forward<_Up>(__v)); + } + + template + _LIBCPP_INLINE_VISIBILITY + value_type value_or(_Up&& __v) && + { + static_assert(is_move_constructible_v, + "optional::value_or: T must be move constructible"); + static_assert(is_convertible_v<_Up, value_type>, + "optional::value_or: U must be convertible to T"); + return this->has_value() ? _VSTD::move(this->__get()) : + static_cast(_VSTD::forward<_Up>(__v)); + } + + using __base::reset; + +private: + template + _LIBCPP_INLINE_VISIBILITY + static _Up* + __operator_arrow(true_type, _Up& __x) + { + return _VSTD::addressof(__x); + } + + template + _LIBCPP_INLINE_VISIBILITY + static constexpr _Up* + __operator_arrow(false_type, _Up& __x) + { + return &__x; + } +}; + +// Comparisons between optionals +template +_LIBCPP_INLINE_VISIBILITY constexpr +enable_if_t< + is_convertible_v() == + _VSTD::declval()), bool>, + bool +> +operator==(const optional<_Tp>& __x, const optional<_Tp>& __y) +{ + if (static_cast(__x) != static_cast(__y)) + return false; + if (!static_cast(__x)) + return true; + return *__x == *__y; +} + +template +_LIBCPP_INLINE_VISIBILITY constexpr +enable_if_t< + is_convertible_v() != + _VSTD::declval()), bool>, + bool +> +operator!=(const optional<_Tp>& __x, const optional<_Tp>& __y) +{ + if (static_cast(__x) != static_cast(__y)) + return true; + if (!static_cast(__x)) + return false; + return *__x != *__y; +} + +template +_LIBCPP_INLINE_VISIBILITY constexpr +enable_if_t< + is_convertible_v() < + _VSTD::declval()), bool>, + bool +> +operator<(const optional<_Tp>& __x, const optional<_Tp>& __y) +{ + if (!static_cast(__y)) + return false; + if (!static_cast(__x)) + return true; + return *__x < *__y; +} + +template +_LIBCPP_INLINE_VISIBILITY constexpr +enable_if_t< + is_convertible_v() > + _VSTD::declval()), bool>, + bool +> +operator>(const optional<_Tp>& __x, const optional<_Tp>& __y) +{ + if (!static_cast(__x)) + return false; + if (!static_cast(__y)) + return true; + return *__x > *__y; +} + +template +_LIBCPP_INLINE_VISIBILITY constexpr +enable_if_t< + is_convertible_v() <= + _VSTD::declval()), bool>, + bool +> +operator<=(const optional<_Tp>& __x, const optional<_Tp>& __y) +{ + if (!static_cast(__x)) + return true; + if (!static_cast(__y)) + return false; + return *__x <= *__y; +} + +template +_LIBCPP_INLINE_VISIBILITY constexpr +enable_if_t< + is_convertible_v() >= + _VSTD::declval()), bool>, + bool +> +operator>=(const optional<_Tp>& __x, const optional<_Tp>& __y) +{ + if (!static_cast(__y)) + return true; + if (!static_cast(__x)) + return false; + return *__x >= *__y; +} + +// Comparisons with nullopt +template +_LIBCPP_INLINE_VISIBILITY constexpr +bool +operator==(const optional<_Tp>& __x, nullopt_t) noexcept +{ + return !static_cast(__x); +} + +template +_LIBCPP_INLINE_VISIBILITY constexpr +bool +operator==(nullopt_t, const optional<_Tp>& __x) noexcept +{ + return !static_cast(__x); +} + +template +_LIBCPP_INLINE_VISIBILITY constexpr +bool +operator!=(const optional<_Tp>& __x, nullopt_t) noexcept +{ + return static_cast(__x); +} + +template +_LIBCPP_INLINE_VISIBILITY constexpr +bool +operator!=(nullopt_t, const optional<_Tp>& __x) noexcept +{ + return static_cast(__x); +} + +template +_LIBCPP_INLINE_VISIBILITY constexpr +bool +operator<(const optional<_Tp>&, nullopt_t) noexcept +{ + return false; +} + +template +_LIBCPP_INLINE_VISIBILITY constexpr +bool +operator<(nullopt_t, const optional<_Tp>& __x) noexcept +{ + return static_cast(__x); +} + +template +_LIBCPP_INLINE_VISIBILITY constexpr +bool +operator<=(const optional<_Tp>& __x, nullopt_t) noexcept +{ + return !static_cast(__x); +} + +template +_LIBCPP_INLINE_VISIBILITY constexpr +bool +operator<=(nullopt_t, const optional<_Tp>& __x) noexcept +{ + return true; +} + +template +_LIBCPP_INLINE_VISIBILITY constexpr +bool +operator>(const optional<_Tp>& __x, nullopt_t) noexcept +{ + return static_cast(__x); +} + +template +_LIBCPP_INLINE_VISIBILITY constexpr +bool +operator>(nullopt_t, const optional<_Tp>& __x) noexcept +{ + return false; +} + +template +_LIBCPP_INLINE_VISIBILITY constexpr +bool +operator>=(const optional<_Tp>&, nullopt_t) noexcept +{ + return true; +} + +template +_LIBCPP_INLINE_VISIBILITY constexpr +bool +operator>=(nullopt_t, const optional<_Tp>& __x) noexcept +{ + return !static_cast(__x); +} + +// Comparisons with T +template +_LIBCPP_INLINE_VISIBILITY constexpr +enable_if_t< + is_convertible_v() == + _VSTD::declval()), bool>, + bool +> +operator==(const optional<_Tp>& __x, const _Tp& __v) +{ + return static_cast(__x) ? *__x == __v : false; +} + +template +_LIBCPP_INLINE_VISIBILITY constexpr +enable_if_t< + is_convertible_v() == + _VSTD::declval()), bool>, + bool +> +operator==(const _Tp& __v, const optional<_Tp>& __x) +{ + return static_cast(__x) ? __v == *__x : false; +} + +template +_LIBCPP_INLINE_VISIBILITY constexpr +enable_if_t< + is_convertible_v() != + _VSTD::declval()), bool>, + bool +> +operator!=(const optional<_Tp>& __x, const _Tp& __v) +{ + return static_cast(__x) ? *__x != __v : true; +} + +template +_LIBCPP_INLINE_VISIBILITY constexpr +enable_if_t< + is_convertible_v() != + _VSTD::declval()), bool>, + bool +> +operator!=(const _Tp& __v, const optional<_Tp>& __x) +{ + return static_cast(__x) ? __v != *__x : true; +} + +template +_LIBCPP_INLINE_VISIBILITY constexpr +enable_if_t< + is_convertible_v() < + _VSTD::declval()), bool>, + bool +> +operator<(const optional<_Tp>& __x, const _Tp& __v) +{ + return static_cast(__x) ? *__x < __v : true; +} + +template +_LIBCPP_INLINE_VISIBILITY constexpr +enable_if_t< + is_convertible_v() < + _VSTD::declval()), bool>, + bool +> +operator<(const _Tp& __v, const optional<_Tp>& __x) +{ + return static_cast(__x) ? __v < *__x : false; +} + +template +_LIBCPP_INLINE_VISIBILITY constexpr +enable_if_t< + is_convertible_v() <= + _VSTD::declval()), bool>, + bool +> +operator<=(const optional<_Tp>& __x, const _Tp& __v) +{ + return static_cast(__x) ? *__x <= __v : true; +} + +template +_LIBCPP_INLINE_VISIBILITY constexpr +enable_if_t< + is_convertible_v() <= + _VSTD::declval()), bool>, + bool +> +operator<=(const _Tp& __v, const optional<_Tp>& __x) +{ + return static_cast(__x) ? __v <= *__x : false; +} + +template +_LIBCPP_INLINE_VISIBILITY constexpr +enable_if_t< + is_convertible_v() > + _VSTD::declval()), bool>, + bool +> +operator>(const optional<_Tp>& __x, const _Tp& __v) +{ + return static_cast(__x) ? *__x > __v : false; +} + +template +_LIBCPP_INLINE_VISIBILITY constexpr +enable_if_t< + is_convertible_v() > + _VSTD::declval()), bool>, + bool +> +operator>(const _Tp& __v, const optional<_Tp>& __x) +{ + return static_cast(__x) ? __v > *__x : true; +} + +template +_LIBCPP_INLINE_VISIBILITY constexpr +enable_if_t< + is_convertible_v() >= + _VSTD::declval()), bool>, + bool +> +operator>=(const optional<_Tp>& __x, const _Tp& __v) +{ + return static_cast(__x) ? *__x >= __v : false; +} + +template +_LIBCPP_INLINE_VISIBILITY constexpr +enable_if_t< + is_convertible_v() >= + _VSTD::declval()), bool>, + bool +> +operator>=(const _Tp& __v, const optional<_Tp>& __x) +{ + return static_cast(__x) ? __v >= *__x : true; +} + + +template +inline _LIBCPP_INLINE_VISIBILITY +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))) +{ + __x.swap(__y); +} + +template +_LIBCPP_INLINE_VISIBILITY constexpr +optional> make_optional(_Tp&& __v) +{ + return optional>(_VSTD::forward<_Tp>(__v)); +} + +template +_LIBCPP_INLINE_VISIBILITY constexpr +optional<_Tp> make_optional(_Args&&... __args) +{ + return optional<_Tp>(in_place, _VSTD::forward<_Args>(__args)...); +} + +template +_LIBCPP_INLINE_VISIBILITY constexpr +optional<_Tp> make_optional(initializer_list<_Up> __il, _Args&&... __args) +{ + return optional<_Tp>(in_place, __il, _VSTD::forward<_Args>(__args)...); +} + +template +struct _LIBCPP_TYPE_VIS_ONLY hash > +{ + typedef optional<_Tp> argument_type; + typedef size_t result_type; + + _LIBCPP_INLINE_VISIBILITY + result_type operator()(const argument_type& __opt) const _NOEXCEPT + { + return static_cast(__opt) ? hash<_Tp>()(*__opt) : 0; + } +}; + +_LIBCPP_END_NAMESPACE_STD + +#endif // _LIBCPP_STD_VER > 14 + +#endif // _LIBCPP_OPTIONAL diff --git a/libcxx/include/type_traits b/libcxx/include/type_traits index 06ee3e7e45da7..43687a7c684de 100644 --- a/libcxx/include/type_traits +++ b/libcxx/include/type_traits @@ -425,7 +425,7 @@ template using enable_if_t = typename enable_if<_Bp #endif // addressof -#if __has_builtin(__builtin_addressof) || _GNUC_VER >= 700 +#ifndef _LIBCPP_HAS_NO_BUILTIN_ADDRESSOF template inline _LIBCPP_CONSTEXPR_AFTER_CXX14 @@ -446,7 +446,7 @@ addressof(_Tp& __x) _NOEXCEPT return (_Tp*)&reinterpret_cast(__x); } -#endif // __has_builtin(__builtin_addressof) +#endif // _LIBCPP_HAS_NO_BUILTIN_ADDRESSOF #if defined(_LIBCPP_HAS_OBJC_ARC) && !defined(_LIBCPP_PREDEFINED_OBJC_ARC_ADDRESSOF) // Objective-C++ Automatic Reference Counting uses qualified pointers diff --git a/libcxx/src/optional.cpp b/libcxx/src/optional.cpp index 8c5dd76d86d6b..f2fbfdfec1cee 100644 --- a/libcxx/src/optional.cpp +++ b/libcxx/src/optional.cpp @@ -7,18 +7,18 @@ // //===----------------------------------------------------------------------===// +#include "optional" #include "experimental/optional" -_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL +namespace std +{ -#ifdef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS +bad_optional_access::~bad_optional_access() _NOEXCEPT = default; -bad_optional_access::~bad_optional_access() _NOEXCEPT {} +} // std -#else +_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL bad_optional_access::~bad_optional_access() _NOEXCEPT = default; -#endif - _LIBCPP_END_NAMESPACE_EXPERIMENTAL diff --git a/libcxx/test/libcxx/utilities/optional/optional.object/optional.object.assign/copy.pass.cpp b/libcxx/test/libcxx/utilities/optional/optional.object/optional.object.assign/copy.pass.cpp new file mode 100644 index 0000000000000..e4de92fbd0138 --- /dev/null +++ b/libcxx/test/libcxx/utilities/optional/optional.object/optional.object.assign/copy.pass.cpp @@ -0,0 +1,81 @@ +//===----------------------------------------------------------------------===// +// +// 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. +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++98, c++03, c++11, c++14 +// XFAIL: libcpp-no-exceptions +// + +// optional& operator=(const optional& rhs); + +#include +#include +#include + +using std::optional; + +struct X {}; + +struct Y +{ + Y() = default; + Y& operator=(const Y&) { return *this; } +}; + +struct Z1 +{ + Z1() = default; + Z1(Z1&&) = default; + Z1(const Z1&) = default; + Z1& operator=(Z1&&) = default; + Z1& operator=(const Z1&) = delete; +}; + +struct Z2 +{ + Z2() = default; + Z2(Z2&&) = default; + Z2(const Z2&) = delete; + Z2& operator=(Z2&&) = default; + Z2& operator=(const Z2&) = default; +}; + +#if __cplusplus >= 201402 +template +constexpr bool +test() +{ + optional opt; + optional opt2; + opt = opt2; + return true; +} +#endif + +int main() +{ + { + using T = int; + static_assert((std::is_trivially_copy_assignable>::value), ""); +#if __cplusplus >= 201402 + static_assert(test(), ""); +#endif + } + { + using T = X; + static_assert((std::is_trivially_copy_assignable>::value), ""); +#if __cplusplus >= 201402 + static_assert(test(), ""); +#endif + } + static_assert(!(std::is_trivially_copy_assignable>::value), ""); + static_assert(!(std::is_trivially_copy_assignable>::value), ""); + + static_assert(!(std::is_copy_assignable>::value), ""); + static_assert(!(std::is_copy_assignable>::value), ""); +} diff --git a/libcxx/test/libcxx/utilities/optional/optional.object/optional.object.assign/move.pass.cpp b/libcxx/test/libcxx/utilities/optional/optional.object/optional.object.assign/move.pass.cpp new file mode 100644 index 0000000000000..e2eaa8ce6a0ef --- /dev/null +++ b/libcxx/test/libcxx/utilities/optional/optional.object/optional.object.assign/move.pass.cpp @@ -0,0 +1,78 @@ +//===----------------------------------------------------------------------===// +// +// 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. +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++98, c++03, c++11, c++14 +// XFAIL: libcpp-no-exceptions +// + +// optional& operator=(optional&& rhs); + +#include +#include +#include +#include + +using std::optional; + +struct X {}; + +struct Y +{ + Y() = default; + Y& operator=(Y&&) { return *this; } +}; + +struct Z1 +{ + Z1() = default; + Z1(Z1&&) = default; + Z1& operator=(Z1&&) = delete; +}; + +struct Z2 +{ + Z2() = default; + Z2(Z2&&) = delete; + Z2& operator=(Z2&&) = default; +}; + +#if __cplusplus >= 201402 +template +constexpr bool +test() +{ + optional opt; + optional opt2; + opt = std::move(opt2); + return true; +} +#endif + +int main() +{ + { + using T = int; + static_assert((std::is_trivially_copy_constructible>::value), ""); +#if __cplusplus >= 201402 + static_assert(test(), ""); +#endif + } + { + using T = X; + static_assert((std::is_trivially_copy_constructible>::value), ""); +#if __cplusplus >= 201402 + static_assert(test(), ""); +#endif + } + static_assert(!(std::is_trivially_move_assignable>::value), ""); + static_assert(!(std::is_trivially_move_assignable>::value), ""); + + static_assert(!(std::is_move_assignable>::value), ""); + static_assert(!(std::is_move_assignable>::value), ""); +} diff --git a/libcxx/test/libcxx/utilities/optional/optional.object/optional.object.ctor/copy.pass.cpp b/libcxx/test/libcxx/utilities/optional/optional.object/optional.object.ctor/copy.pass.cpp new file mode 100644 index 0000000000000..75e763507b2c0 --- /dev/null +++ b/libcxx/test/libcxx/utilities/optional/optional.object/optional.object.ctor/copy.pass.cpp @@ -0,0 +1,59 @@ +//===----------------------------------------------------------------------===// +// +// 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. +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++98, c++03, c++11, c++14 +// XFAIL: libcpp-no-exceptions +// + +// optional(const optional& rhs); + +#include +#include +#include + +using std::optional; + +struct X {}; + +struct Y +{ + Y() = default; + Y(const Y&) {} +}; + +struct Z +{ + Z() = default; + Z(Z&&) = delete; + Z(const Z&) = delete; + Z& operator=(Z&&) = delete; + Z& operator=(const Z&) = delete; +}; + +int main() +{ + { + using T = int; + static_assert((std::is_trivially_copy_constructible>::value), ""); + constexpr optional opt; + constexpr optional opt2 = opt; + (void)opt2; + } + { + using T = X; + static_assert((std::is_trivially_copy_constructible>::value), ""); + constexpr optional opt; + constexpr optional opt2 = opt; + (void)opt2; + } + static_assert(!(std::is_trivially_copy_constructible>::value), ""); + static_assert(!(std::is_trivially_copy_constructible>::value), ""); + + static_assert(!(std::is_copy_constructible>::value), ""); +} diff --git a/libcxx/test/libcxx/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp b/libcxx/test/libcxx/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp new file mode 100644 index 0000000000000..e6d9bb8421c76 --- /dev/null +++ b/libcxx/test/libcxx/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp @@ -0,0 +1,60 @@ +//===----------------------------------------------------------------------===// +// +// 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. +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++98, c++03, c++11, c++14 +// XFAIL: libcpp-no-exceptions +// + +// optional(optional&& rhs); + +#include +#include +#include +#include + +using std::optional; + +struct X {}; + +struct Y +{ + Y() = default; + Y(Y&&) {} +}; + +struct Z +{ + Z() = default; + Z(Z&&) = delete; + Z(const Z&) = delete; + Z& operator=(Z&&) = delete; + Z& operator=(const Z&) = delete; +}; + +int main() +{ + { + using T = int; + static_assert((std::is_trivially_copy_constructible>::value), ""); + constexpr optional opt; + constexpr optional opt2 = std::move(opt); + (void)opt2; + } + { + using T = X; + static_assert((std::is_trivially_copy_constructible>::value), ""); + constexpr optional opt; + constexpr optional opt2 = std::move(opt); + (void)opt2; + } + static_assert(!(std::is_trivially_move_constructible>::value), ""); + static_assert(!(std::is_trivially_move_constructible>::value), ""); + + static_assert(!(std::is_move_constructible>::value), ""); +} diff --git a/libcxx/test/libcxx/utilities/optional/optional.object/special_member_gen.pass.cpp b/libcxx/test/libcxx/utilities/optional/optional.object/special_member_gen.pass.cpp new file mode 100644 index 0000000000000..9493d6bb766cf --- /dev/null +++ b/libcxx/test/libcxx/utilities/optional/optional.object/special_member_gen.pass.cpp @@ -0,0 +1,66 @@ +//===----------------------------------------------------------------------===// +// +// 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. +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++98, c++03, c++11, c++14 +// + + +#include +#include +#include + +#include "archetypes.hpp" + +template +struct SpecialMemberTest { + using O = std::optional; + + template