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