1//===----------------------------------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#ifndef _LIBCPP___OPTIONAL_OPTIONAL_REF_H
10#define _LIBCPP___OPTIONAL_OPTIONAL_REF_H
11
12#include <__assert>
13#include <__concepts/invocable.h>
14#include <__config>
15#include <__functional/invoke.h>
16#include <__fwd/optional.h>
17#include <__iterator/bounded_iter.h>
18#include <__iterator/capacity_aware_iterator.h>
19#include <__memory/addressof.h>
20#include <__optional/common.h>
21#include <__optional/comparison.h>
22#include <__optional/hash.h>
23#include <__optional/nullopt_t.h>
24#include <__optional/swap.h>
25#include <__type_traits/add_pointer.h>
26#include <__type_traits/decay.h>
27#include <__type_traits/invoke.h>
28#include <__type_traits/is_array.h>
29#include <__type_traits/is_constructible.h>
30#include <__type_traits/is_convertible.h>
31#include <__type_traits/is_nothrow_constructible.h>
32#include <__type_traits/is_object.h>
33#include <__type_traits/is_reference.h>
34#include <__type_traits/is_same.h>
35#include <__type_traits/reference_constructs_from_temporary.h>
36#include <__type_traits/remove_cv.h>
37#include <__type_traits/remove_cvref.h>
38#include <__type_traits/remove_reference.h>
39#include <__utility/forward.h>
40#include <__utility/in_place.h>
41#include <__utility/move.h>
42#include <__utility/swap.h>
43
44#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
45# pragma GCC system_header
46#endif
47
48_LIBCPP_PUSH_MACROS
49#include <__undef_macros>
50
51#if _LIBCPP_STD_VER >= 26
52
53_LIBCPP_BEGIN_NAMESPACE_STD
54
55template <class _Tp>
56struct __optional_ref_iterator_base {};
57
58# if _LIBCPP_HAS_EXPERIMENTAL_OPTIONAL_ITERATOR
59
60template <class _Tp>
61 requires(is_object_v<_Tp> && !__is_unbounded_array_v<_Tp>)
62struct __optional_ref_iterator_base<_Tp&> {
63# ifdef _LIBCPP_ABI_BOUNDED_ITERATORS_IN_OPTIONAL
64 using iterator = __bounded_iter<_Tp*>;
65# else
66 using iterator = __capacity_aware_iterator<_Tp*, optional<_Tp&>, 1>;
67# endif
68};
69
70# endif
71
72template <class _Tp>
73class optional<_Tp&> : public __optional_ref_iterator_base<_Tp&> {
74public:
75 using value_type = _Tp;
76 static_assert(!is_same_v<remove_cv_t<_Tp>, in_place_t>, "instantiation of optional with in_place_t is ill-formed");
77 static_assert(!is_same_v<remove_cv_t<_Tp>, nullopt_t>, "instantiation of optional with nullopt_t is ill-formed");
78
79private:
80 template <class>
81 friend class optional;
82
83 _Tp* __value_ = nullptr;
84
85 template <class _Up>
86 _LIBCPP_HIDE_FROM_ABI constexpr void __convert_init_ref_val(_Up&& __val) {
87 _Tp& __r(std::forward<_Up>(__val));
88 __value_ = std::addressof(__r);
89 }
90
91 template <class _Up, class _QualUp>
92 static constexpr bool __check_optionalU_ctor =
93 !is_same_v<remove_cv_t<_Tp>, optional<_Up>> && !is_same_v<_Tp&, _Up> && is_constructible_v<_Tp&, _QualUp>;
94
95 template <class _Fp, class... _Args>
96 constexpr optional(__optional_construct_from_invoke_tag, _Fp&& __f, _Args&&... __args) {
97 __convert_init_ref_val(std::forward<invoke_result_t<_Fp, _Args...>>(
98 std::invoke(std::forward<_Fp>(__f), std::forward<_Args>(__args)...)));
99 }
100
101 template <class _UArg>
102 _LIBCPP_HIDE_FROM_ABI constexpr void __construct(_UArg&& __val) {
103 static_assert(!__reference_constructs_from_temporary_v<_Tp, _UArg>,
104 "Attempted to construct a reference element in tuple from a "
105 "possible temporary");
106 __convert_init_ref_val(std::forward<_UArg>(__val));
107 }
108
109 template <class _That>
110 _LIBCPP_HIDE_FROM_ABI constexpr void __construct_from(_That&& __opt) {
111 if (__opt.has_value())
112 __construct(std::forward<_That>(__opt).value());
113 }
114
115 static constexpr bool __has_iterator_ = requires { typename __optional_ref_iterator_base<_Tp&>::iterator; };
116
117public:
118 constexpr optional() noexcept = default;
119 constexpr optional(nullopt_t) noexcept {}
120 constexpr optional(const optional&) noexcept = default;
121
122 template <class _Arg>
123 requires(is_constructible_v<_Tp&, _Arg> && !reference_constructs_from_temporary_v<_Tp&, _Arg>)
124 constexpr explicit optional(in_place_t, _Arg&& __arg) {
125 static_assert(!__reference_constructs_from_temporary_v<_Tp, _Arg>,
126 "Attempted to construct a reference element in optional from a "
127 "possible temporary");
128 __convert_init_ref_val(std::forward<_Arg>(__arg));
129 }
130
131 template <class _Up>
132 requires(!is_same_v<remove_cvref_t<_Up>, optional> && !is_same_v<remove_cvref_t<_Up>, in_place_t> &&
133 is_constructible_v<_Tp&, _Up> && !reference_constructs_from_temporary_v<_Tp&, _Up>)
134 constexpr explicit(!is_convertible_v<_Up, _Tp&>) optional(_Up&& __v) noexcept(is_nothrow_constructible_v<_Tp&, _Up>)
135 : optional(in_place, std::forward<_Up>(__v)) {}
136
137 template <class _Up>
138 requires(__check_optionalU_ctor<_Up, _Up&> && !reference_constructs_from_temporary_v<_Tp&, _Up&>)
139 constexpr explicit(!is_convertible_v<_Up&, _Tp&>)
140 optional(optional<_Up>& __rhs) noexcept(is_nothrow_constructible_v<_Tp&, _Up&>) {
141 this->__construct_from(__rhs);
142 }
143
144 template <class _Up>
145 requires(__check_optionalU_ctor<_Up, const _Up&> && !reference_constructs_from_temporary_v<_Tp&, const _Up&>)
146 constexpr explicit(!is_convertible_v<const _Up&, _Tp&>)
147 optional(const optional<_Up>& __rhs) noexcept(is_nothrow_constructible_v<_Tp&, const _Up&>) {
148 this->__construct_from(__rhs);
149 }
150
151 template <class _Up>
152 requires(__check_optionalU_ctor<_Up, _Up> && !reference_constructs_from_temporary_v<_Tp&, _Up>)
153 constexpr explicit(!is_convertible_v<_Up, _Tp&>)
154 optional(optional<_Up>&& __rhs) noexcept(is_nothrow_constructible_v<_Tp&, _Up>) {
155 this->__construct_from(std::move(__rhs));
156 }
157
158 template <class _Up>
159 requires(__check_optionalU_ctor<_Up, const _Up> && !reference_constructs_from_temporary_v<_Tp&, const _Up>)
160 constexpr explicit(!is_convertible_v<const _Up, _Tp&>)
161 optional(const optional<_Up>&& __rhs) noexcept(is_nothrow_constructible_v<_Tp&, const _Up>) {
162 this->__construct_from(std::move(__rhs));
163 }
164
165 // deleted overloads
166
167 template <class _Up>
168 requires(!is_same_v<remove_cvref_t<_Up>, optional> && !is_same_v<remove_cvref_t<_Up>, in_place_t> &&
169 is_constructible_v<_Tp&, _Up> && reference_constructs_from_temporary_v<_Tp&, _Up>)
170 constexpr explicit(!is_convertible_v<_Up, _Tp&>)
171 optional(_Up&& __v) noexcept(is_nothrow_constructible_v<_Tp&, _Up>) = delete;
172
173 template <class _Up>
174 requires(__check_optionalU_ctor<_Up, _Up&> && reference_constructs_from_temporary_v<_Tp&, _Up&>)
175 constexpr explicit(!is_convertible_v<_Up&, _Tp&>)
176 optional(optional<_Up>& __rhs) noexcept(is_nothrow_constructible_v<_Tp&, _Up&>) = delete;
177
178 template <class _Up>
179 requires(__check_optionalU_ctor<_Up, const _Up&> && reference_constructs_from_temporary_v<_Tp&, const _Up&>)
180 constexpr explicit(!is_convertible_v<const _Up&, _Tp&>)
181 optional(const optional<_Up>& __rhs) noexcept(is_nothrow_constructible_v<_Tp&, const _Up&>) = delete;
182
183 template <class _Up>
184 requires(__check_optionalU_ctor<_Up, _Up> && reference_constructs_from_temporary_v<_Tp&, _Up>)
185 constexpr explicit(!is_convertible_v<_Up, _Tp&>)
186 optional(optional<_Up>&& __rhs) noexcept(is_nothrow_constructible_v<_Tp&, _Up>) = delete;
187
188 template <class _Up>
189 requires(__check_optionalU_ctor<_Up, const _Up> && reference_constructs_from_temporary_v<_Tp&, const _Up>)
190 constexpr explicit(!is_convertible_v<const _Up, _Tp&>)
191 optional(const optional<_Up>&& __rhs) noexcept(is_nothrow_constructible_v<_Tp&, const _Up>) = delete;
192
193 constexpr ~optional() = default;
194
195 _LIBCPP_HIDE_FROM_ABI constexpr optional& operator=(nullopt_t) noexcept {
196 reset();
197 return *this;
198 }
199
200 constexpr optional& operator=(const optional&) noexcept = default;
201
202 template <class _Up>
203 requires(is_constructible_v<_Tp&, _Up> && !reference_constructs_from_temporary_v<_Tp&, _Up>)
204 constexpr _Tp& emplace(_Up&& __u) noexcept(is_nothrow_constructible_v<_Tp&, _Up>) {
205 this->__construct(std::forward<_Up>(__u));
206
207 return *__value_;
208 }
209
210 constexpr void swap(optional& __rhs) noexcept { std::swap(this->__value_, __rhs.__value_); }
211
212 // [optional.ref.observe]
213 _LIBCPP_HIDE_FROM_ABI constexpr add_pointer_t<_Tp> operator->() const noexcept {
214 _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(this->has_value(), "optional operator-> called on a disengaged value");
215 return __value_;
216 }
217
218 [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp& operator*() const noexcept {
219 _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(this->has_value(), "optional operator* called on a disengaged value");
220 return *__value_;
221 }
222
223 constexpr explicit operator bool() const noexcept { return has_value(); }
224
225 [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool has_value() const noexcept { return __value_ != nullptr; }
226
227 [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp& value() const {
228 if (!this->has_value())
229 std::__throw_bad_optional_access();
230 return *__value_;
231 }
232
233 template <class _Up = remove_cv_t<_Tp>>
234 requires(!is_array_v<_Tp> && is_object_v<_Tp>)
235 [[nodiscard]] constexpr decay_t<_Tp> value_or(_Up&& __v) const {
236 using _XTp = remove_cv_t<_Tp>;
237 static_assert(is_constructible_v<_XTp, _Tp&>, "optional<T&>::value_or: remove_cv_t<T> must be constructible");
238 static_assert(is_convertible_v<_Up, _XTp>, "optional<T&>::value_or: U must be convertible to remove_cv_t<T>");
239 return this->has_value() ? *__value_ : static_cast<_XTp>(std::forward<_Up>(__v));
240 }
241
242 template <class _Func>
243 [[nodiscard]] constexpr auto and_then(_Func&& __f) const {
244 using _Up = invoke_result_t<_Func, _Tp&>;
245 static_assert(
246 __is_std_optional_v<remove_cvref_t<_Up>>, "Result of f(value()) must be a specialization of std::optional");
247 if (*this)
248 return std::invoke(std::forward<_Func>(__f), value());
249 return remove_cvref_t<_Up>();
250 }
251
252 template <class _Func>
253 [[nodiscard]] constexpr optional<remove_cv_t<invoke_result_t<_Func, _Tp&>>> transform(_Func&& __f) const {
254 using _Up = remove_cv_t<invoke_result_t<_Func, _Tp&>>;
255 static_assert(!is_array_v<_Up>, "Result of f(value()) should not be an Array");
256 static_assert(!is_same_v<_Up, in_place_t>, "Result of f(value()) should not be std::in_place_t");
257 static_assert(!is_same_v<_Up, nullopt_t>, "Result of f(value()) should not be std::nullopt_t");
258 static_assert(
259 __is_valid_optional_contained_type<_Up>, "Result of f(value()) should be a valid contained type for optional");
260
261 if (*this)
262 return optional<_Up>(__optional_construct_from_invoke_tag{}, std::forward<_Func>(__f), value());
263 return optional<_Up>();
264 }
265
266 template <invocable _Func>
267 [[nodiscard]] constexpr optional or_else(_Func&& __f) const {
268 static_assert(is_same_v<remove_cvref_t<invoke_result_t<_Func>>, optional>,
269 "Result of f() should be the same type as this optional");
270 if (*this)
271 return *this;
272 return std::forward<_Func>(__f)();
273 }
274
275 _LIBCPP_HIDE_FROM_ABI constexpr void reset() noexcept { __value_ = nullptr; }
276
277 // [optional.ref.iterators], iterator support
278# if _LIBCPP_HAS_EXPERIMENTAL_OPTIONAL_ITERATOR
279
280 [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto begin() const noexcept
281 requires __has_iterator_
282 {
283# ifdef _LIBCPP_ABI_BOUNDED_ITERATORS_IN_OPTIONAL
284 return std::__make_bounded_iter(__value_, __value_, __value_ + (this->has_value() ? 1 : 0));
285# else
286 return std::__make_capacity_aware_iterator<_Tp*, optional<_Tp&>, 1>(__value_);
287# endif
288 }
289
290 [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto end() const noexcept
291 requires __has_iterator_
292 {
293 return begin() + (this->has_value() ? 1 : 0);
294 }
295# endif
296};
297
298_LIBCPP_END_NAMESPACE_STD
299
300#endif // _LIBCPP_STD_VER >= 26
301
302_LIBCPP_POP_MACROS
303
304#endif // _LIBCPP___OPTIONAL_OPTIONAL_REF_H
305