1// -*- C++ -*-
2//===----------------------------------------------------------------------===//
3//
4// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5// See https://llvm.org/LICENSE.txt for license information.
6// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7//
8//===----------------------------------------------------------------------===//
9
10#ifndef _LIBCPP_ANY
11#define _LIBCPP_ANY
12
13/*
14 any synopsis
15
16namespace std {
17
18 class bad_any_cast : public bad_cast
19 {
20 public:
21 virtual const char* what() const noexcept;
22 };
23
24 class any
25 {
26 public:
27
28 // 6.3.1 any construct/destruct
29 any() noexcept;
30
31 any(const any& other);
32 any(any&& other) noexcept;
33
34 template <class ValueType>
35 any(ValueType&& value);
36
37 ~any();
38
39 // 6.3.2 any assignments
40 any& operator=(const any& rhs);
41 any& operator=(any&& rhs) noexcept;
42
43 template <class ValueType>
44 any& operator=(ValueType&& rhs);
45
46 // 6.3.3 any modifiers
47 template <class ValueType, class... Args>
48 decay_t<ValueType>& emplace(Args&&... args);
49 template <class ValueType, class U, class... Args>
50 decay_t<ValueType>& emplace(initializer_list<U>, Args&&...);
51 void reset() noexcept;
52 void swap(any& rhs) noexcept;
53
54 // 6.3.4 any observers
55 bool has_value() const noexcept;
56 const type_info& type() const noexcept;
57 };
58
59 // 6.4 Non-member functions
60 void swap(any& x, any& y) noexcept;
61
62 template <class T, class ...Args>
63 any make_any(Args&& ...args);
64 template <class T, class U, class ...Args>
65 any make_any(initializer_list<U>, Args&& ...args);
66
67 template<class ValueType>
68 ValueType any_cast(const any& operand);
69 template<class ValueType>
70 ValueType any_cast(any& operand);
71 template<class ValueType>
72 ValueType any_cast(any&& operand);
73
74 template<class ValueType>
75 const ValueType* any_cast(const any* operand) noexcept;
76 template<class ValueType>
77 ValueType* any_cast(any* operand) noexcept;
78
79} // namespace std
80
81*/
82
83#include <__config>
84#include <__memory/allocator.h>
85#include <__memory/allocator_destructor.h>
86#include <__memory/allocator_traits.h>
87#include <__memory/unique_ptr.h>
88#include <__type_traits/add_const.h>
89#include <__type_traits/add_pointer.h>
90#include <__type_traits/aligned_storage.h>
91#include <__type_traits/conditional.h>
92#include <__type_traits/decay.h>
93#include <__type_traits/is_constructible.h>
94#include <__type_traits/is_function.h>
95#include <__type_traits/is_nothrow_constructible.h>
96#include <__type_traits/is_reference.h>
97#include <__type_traits/is_same.h>
98#include <__type_traits/is_void.h>
99#include <__type_traits/remove_cv.h>
100#include <__type_traits/remove_cvref.h>
101#include <__type_traits/remove_reference.h>
102#include <__utility/forward.h>
103#include <__utility/in_place.h>
104#include <__utility/move.h>
105#include <__utility/unreachable.h>
106#include <__verbose_abort>
107#include <initializer_list>
108#include <typeinfo>
109#include <version>
110
111#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
112# pragma GCC system_header
113#endif
114
115_LIBCPP_PUSH_MACROS
116#include <__undef_macros>
117
118namespace std {
119class _LIBCPP_EXPORTED_FROM_ABI _LIBCPP_AVAILABILITY_BAD_ANY_CAST bad_any_cast : public bad_cast {
120public:
121 const char* what() const _NOEXCEPT override;
122};
123} // namespace std
124
125_LIBCPP_BEGIN_NAMESPACE_STD
126
127#if _LIBCPP_STD_VER >= 17
128
129_LIBCPP_NORETURN inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST void __throw_bad_any_cast() {
130# ifndef _LIBCPP_HAS_NO_EXCEPTIONS
131 throw bad_any_cast();
132# else
133 _LIBCPP_VERBOSE_ABORT("bad_any_cast was thrown in -fno-exceptions mode");
134# endif
135}
136
137// Forward declarations
138class _LIBCPP_TEMPLATE_VIS any;
139
140template <class _ValueType>
141_LIBCPP_HIDE_FROM_ABI add_pointer_t<add_const_t<_ValueType>> any_cast(any const*) _NOEXCEPT;
142
143template <class _ValueType>
144_LIBCPP_HIDE_FROM_ABI add_pointer_t<_ValueType> any_cast(any*) _NOEXCEPT;
145
146namespace __any_imp {
147_LIBCPP_SUPPRESS_DEPRECATED_PUSH
148using _Buffer = aligned_storage_t<3 * sizeof(void*), alignof(void*)>;
149_LIBCPP_SUPPRESS_DEPRECATED_POP
150
151template <class _Tp>
152using _IsSmallObject =
153 integral_constant<bool,
154 sizeof(_Tp) <= sizeof(_Buffer) && alignof(_Buffer) % alignof(_Tp) == 0 &&
155 is_nothrow_move_constructible<_Tp>::value >;
156
157enum class _Action { _Destroy, _Copy, _Move, _Get, _TypeInfo };
158
159template <class _Tp>
160struct _SmallHandler;
161template <class _Tp>
162struct _LargeHandler;
163
164template <class _Tp>
165struct _LIBCPP_TEMPLATE_VIS __unique_typeinfo {
166 static constexpr int __id = 0;
167};
168template <class _Tp>
169constexpr int __unique_typeinfo<_Tp>::__id;
170
171template <class _Tp>
172inline _LIBCPP_HIDE_FROM_ABI constexpr const void* __get_fallback_typeid() {
173 return &__unique_typeinfo<remove_cv_t<remove_reference_t<_Tp>>>::__id;
174}
175
176template <class _Tp>
177inline _LIBCPP_HIDE_FROM_ABI bool __compare_typeid(type_info const* __id, const void* __fallback_id) {
178# if !defined(_LIBCPP_HAS_NO_RTTI)
179 if (__id && *__id == typeid(_Tp))
180 return true;
181# endif
182 return !__id && __fallback_id == __any_imp::__get_fallback_typeid<_Tp>();
183}
184
185template <class _Tp>
186using _Handler = conditional_t< _IsSmallObject<_Tp>::value, _SmallHandler<_Tp>, _LargeHandler<_Tp>>;
187
188} // namespace __any_imp
189
190class _LIBCPP_TEMPLATE_VIS any {
191public:
192 // construct/destruct
193 _LIBCPP_HIDE_FROM_ABI constexpr any() _NOEXCEPT : __h_(nullptr) {}
194
195 _LIBCPP_HIDE_FROM_ABI any(any const& __other) : __h_(nullptr) {
196 if (__other.__h_)
197 __other.__call(_Action::_Copy, this);
198 }
199
200 _LIBCPP_HIDE_FROM_ABI any(any&& __other) _NOEXCEPT : __h_(nullptr) {
201 if (__other.__h_)
202 __other.__call(_Action::_Move, this);
203 }
204
205 template < class _ValueType,
206 class _Tp = decay_t<_ValueType>,
207 class = enable_if_t< !is_same<_Tp, any>::value && !__is_inplace_type<_ValueType>::value &&
208 is_copy_constructible<_Tp>::value> >
209 _LIBCPP_HIDE_FROM_ABI any(_ValueType&& __value);
210
211 template <class _ValueType,
212 class... _Args,
213 class _Tp = decay_t<_ValueType>,
214 class = enable_if_t< is_constructible<_Tp, _Args...>::value && is_copy_constructible<_Tp>::value > >
215 _LIBCPP_HIDE_FROM_ABI explicit any(in_place_type_t<_ValueType>, _Args&&... __args);
216
217 template <class _ValueType,
218 class _Up,
219 class... _Args,
220 class _Tp = decay_t<_ValueType>,
221 class = enable_if_t< is_constructible<_Tp, initializer_list<_Up>&, _Args...>::value &&
222 is_copy_constructible<_Tp>::value> >
223 _LIBCPP_HIDE_FROM_ABI explicit any(in_place_type_t<_ValueType>, initializer_list<_Up>, _Args&&... __args);
224
225 _LIBCPP_HIDE_FROM_ABI ~any() { this->reset(); }
226
227 // assignments
228 _LIBCPP_HIDE_FROM_ABI any& operator=(any const& __rhs) {
229 any(__rhs).swap(*this);
230 return *this;
231 }
232
233 _LIBCPP_HIDE_FROM_ABI any& operator=(any&& __rhs) _NOEXCEPT {
234 any(std::move(__rhs)).swap(*this);
235 return *this;
236 }
237
238 template < class _ValueType,
239 class _Tp = decay_t<_ValueType>,
240 class = enable_if_t< !is_same<_Tp, any>::value && is_copy_constructible<_Tp>::value> >
241 _LIBCPP_HIDE_FROM_ABI any& operator=(_ValueType&& __rhs);
242
243 template <class _ValueType,
244 class... _Args,
245 class _Tp = decay_t<_ValueType>,
246 class = enable_if_t< is_constructible<_Tp, _Args...>::value && is_copy_constructible<_Tp>::value> >
247 _LIBCPP_HIDE_FROM_ABI _Tp& emplace(_Args&&...);
248
249 template <class _ValueType,
250 class _Up,
251 class... _Args,
252 class _Tp = decay_t<_ValueType>,
253 class = enable_if_t< is_constructible<_Tp, initializer_list<_Up>&, _Args...>::value &&
254 is_copy_constructible<_Tp>::value> >
255 _LIBCPP_HIDE_FROM_ABI _Tp& emplace(initializer_list<_Up>, _Args&&...);
256
257 // 6.3.3 any modifiers
258 _LIBCPP_HIDE_FROM_ABI void reset() _NOEXCEPT {
259 if (__h_)
260 this->__call(_Action::_Destroy);
261 }
262
263 _LIBCPP_HIDE_FROM_ABI void swap(any& __rhs) _NOEXCEPT;
264
265 // 6.3.4 any observers
266 _LIBCPP_HIDE_FROM_ABI bool has_value() const _NOEXCEPT { return __h_ != nullptr; }
267
268# if !defined(_LIBCPP_HAS_NO_RTTI)
269 _LIBCPP_HIDE_FROM_ABI const type_info& type() const _NOEXCEPT {
270 if (__h_) {
271 return *static_cast<type_info const*>(this->__call(_Action::_TypeInfo));
272 } else {
273 return typeid(void);
274 }
275 }
276# endif
277
278private:
279 typedef __any_imp::_Action _Action;
280 using _HandleFuncPtr = void* (*)(_Action, any const*, any*, const type_info*, const void* __fallback_info);
281
282 union _Storage {
283 _LIBCPP_HIDE_FROM_ABI constexpr _Storage() : __ptr(nullptr) {}
284 void* __ptr;
285 __any_imp::_Buffer __buf;
286 };
287
288 _LIBCPP_HIDE_FROM_ABI void*
289 __call(_Action __a, any* __other = nullptr, type_info const* __info = nullptr, const void* __fallback_info = nullptr)
290 const {
291 return __h_(__a, this, __other, __info, __fallback_info);
292 }
293
294 _LIBCPP_HIDE_FROM_ABI void* __call(
295 _Action __a, any* __other = nullptr, type_info const* __info = nullptr, const void* __fallback_info = nullptr) {
296 return __h_(__a, this, __other, __info, __fallback_info);
297 }
298
299 template <class>
300 friend struct __any_imp::_SmallHandler;
301 template <class>
302 friend struct __any_imp::_LargeHandler;
303
304 template <class _ValueType>
305 friend add_pointer_t<add_const_t<_ValueType>> any_cast(any const*) _NOEXCEPT;
306
307 template <class _ValueType>
308 friend add_pointer_t<_ValueType> any_cast(any*) _NOEXCEPT;
309
310 _HandleFuncPtr __h_ = nullptr;
311 _Storage __s_;
312};
313
314namespace __any_imp {
315template <class _Tp>
316struct _LIBCPP_TEMPLATE_VIS _SmallHandler {
317 _LIBCPP_HIDE_FROM_ABI static void*
318 __handle(_Action __act, any const* __this, any* __other, type_info const* __info, const void* __fallback_info) {
319 switch (__act) {
320 case _Action::_Destroy:
321 __destroy(const_cast<any&>(*__this));
322 return nullptr;
323 case _Action::_Copy:
324 __copy(*__this, *__other);
325 return nullptr;
326 case _Action::_Move:
327 __move(const_cast<any&>(*__this), *__other);
328 return nullptr;
329 case _Action::_Get:
330 return __get(const_cast<any&>(*__this), __info, __fallback_info);
331 case _Action::_TypeInfo:
332 return __type_info();
333 }
334 __libcpp_unreachable();
335 }
336
337 template <class... _Args>
338 _LIBCPP_HIDE_FROM_ABI static _Tp& __create(any& __dest, _Args&&... __args) {
339 typedef allocator<_Tp> _Alloc;
340 typedef allocator_traits<_Alloc> _ATraits;
341 _Alloc __a;
342 _Tp* __ret = static_cast<_Tp*>(static_cast<void*>(&__dest.__s_.__buf));
343 _ATraits::construct(__a, __ret, std::forward<_Args>(__args)...);
344 __dest.__h_ = &_SmallHandler::__handle;
345 return *__ret;
346 }
347
348private:
349 _LIBCPP_HIDE_FROM_ABI static void __destroy(any& __this) {
350 typedef allocator<_Tp> _Alloc;
351 typedef allocator_traits<_Alloc> _ATraits;
352 _Alloc __a;
353 _Tp* __p = static_cast<_Tp*>(static_cast<void*>(&__this.__s_.__buf));
354 _ATraits::destroy(__a, __p);
355 __this.__h_ = nullptr;
356 }
357
358 _LIBCPP_HIDE_FROM_ABI static void __copy(any const& __this, any& __dest) {
359 _SmallHandler::__create(__dest, *static_cast<_Tp const*>(static_cast<void const*>(&__this.__s_.__buf)));
360 }
361
362 _LIBCPP_HIDE_FROM_ABI static void __move(any& __this, any& __dest) {
363 _SmallHandler::__create(__dest, std::move(*static_cast<_Tp*>(static_cast<void*>(&__this.__s_.__buf))));
364 __destroy(__this);
365 }
366
367 _LIBCPP_HIDE_FROM_ABI static void* __get(any& __this, type_info const* __info, const void* __fallback_id) {
368 if (__any_imp::__compare_typeid<_Tp>(__info, __fallback_id))
369 return static_cast<void*>(&__this.__s_.__buf);
370 return nullptr;
371 }
372
373 _LIBCPP_HIDE_FROM_ABI static void* __type_info() {
374# if !defined(_LIBCPP_HAS_NO_RTTI)
375 return const_cast<void*>(static_cast<void const*>(&typeid(_Tp)));
376# else
377 return nullptr;
378# endif
379 }
380};
381
382template <class _Tp>
383struct _LIBCPP_TEMPLATE_VIS _LargeHandler {
384 _LIBCPP_HIDE_FROM_ABI static void*
385 __handle(_Action __act, any const* __this, any* __other, type_info const* __info, void const* __fallback_info) {
386 switch (__act) {
387 case _Action::_Destroy:
388 __destroy(const_cast<any&>(*__this));
389 return nullptr;
390 case _Action::_Copy:
391 __copy(*__this, *__other);
392 return nullptr;
393 case _Action::_Move:
394 __move(const_cast<any&>(*__this), *__other);
395 return nullptr;
396 case _Action::_Get:
397 return __get(const_cast<any&>(*__this), __info, __fallback_info);
398 case _Action::_TypeInfo:
399 return __type_info();
400 }
401 __libcpp_unreachable();
402 }
403
404 template <class... _Args>
405 _LIBCPP_HIDE_FROM_ABI static _Tp& __create(any& __dest, _Args&&... __args) {
406 typedef allocator<_Tp> _Alloc;
407 typedef allocator_traits<_Alloc> _ATraits;
408 typedef __allocator_destructor<_Alloc> _Dp;
409 _Alloc __a;
410 unique_ptr<_Tp, _Dp> __hold(_ATraits::allocate(__a, 1), _Dp(__a, 1));
411 _Tp* __ret = __hold.get();
412 _ATraits::construct(__a, __ret, std::forward<_Args>(__args)...);
413 __dest.__s_.__ptr = __hold.release();
414 __dest.__h_ = &_LargeHandler::__handle;
415 return *__ret;
416 }
417
418private:
419 _LIBCPP_HIDE_FROM_ABI static void __destroy(any& __this) {
420 typedef allocator<_Tp> _Alloc;
421 typedef allocator_traits<_Alloc> _ATraits;
422 _Alloc __a;
423 _Tp* __p = static_cast<_Tp*>(__this.__s_.__ptr);
424 _ATraits::destroy(__a, __p);
425 _ATraits::deallocate(__a, __p, 1);
426 __this.__h_ = nullptr;
427 }
428
429 _LIBCPP_HIDE_FROM_ABI static void __copy(any const& __this, any& __dest) {
430 _LargeHandler::__create(__dest, *static_cast<_Tp const*>(__this.__s_.__ptr));
431 }
432
433 _LIBCPP_HIDE_FROM_ABI static void __move(any& __this, any& __dest) {
434 __dest.__s_.__ptr = __this.__s_.__ptr;
435 __dest.__h_ = &_LargeHandler::__handle;
436 __this.__h_ = nullptr;
437 }
438
439 _LIBCPP_HIDE_FROM_ABI static void* __get(any& __this, type_info const* __info, void const* __fallback_info) {
440 if (__any_imp::__compare_typeid<_Tp>(__info, __fallback_info))
441 return static_cast<void*>(__this.__s_.__ptr);
442 return nullptr;
443 }
444
445 _LIBCPP_HIDE_FROM_ABI static void* __type_info() {
446# if !defined(_LIBCPP_HAS_NO_RTTI)
447 return const_cast<void*>(static_cast<void const*>(&typeid(_Tp)));
448# else
449 return nullptr;
450# endif
451 }
452};
453
454} // namespace __any_imp
455
456template <class _ValueType, class _Tp, class>
457any::any(_ValueType&& __v) : __h_(nullptr) {
458 __any_imp::_Handler<_Tp>::__create(*this, std::forward<_ValueType>(__v));
459}
460
461template <class _ValueType, class... _Args, class _Tp, class>
462any::any(in_place_type_t<_ValueType>, _Args&&... __args) {
463 __any_imp::_Handler<_Tp>::__create(*this, std::forward<_Args>(__args)...);
464}
465
466template <class _ValueType, class _Up, class... _Args, class _Tp, class>
467any::any(in_place_type_t<_ValueType>, initializer_list<_Up> __il, _Args&&... __args) {
468 __any_imp::_Handler<_Tp>::__create(*this, __il, std::forward<_Args>(__args)...);
469}
470
471template <class _ValueType, class, class>
472inline _LIBCPP_HIDE_FROM_ABI any& any::operator=(_ValueType&& __v) {
473 any(std::forward<_ValueType>(__v)).swap(*this);
474 return *this;
475}
476
477template <class _ValueType, class... _Args, class _Tp, class>
478inline _LIBCPP_HIDE_FROM_ABI _Tp& any::emplace(_Args&&... __args) {
479 reset();
480 return __any_imp::_Handler<_Tp>::__create(*this, std::forward<_Args>(__args)...);
481}
482
483template <class _ValueType, class _Up, class... _Args, class _Tp, class>
484inline _LIBCPP_HIDE_FROM_ABI _Tp& any::emplace(initializer_list<_Up> __il, _Args&&... __args) {
485 reset();
486 return __any_imp::_Handler<_Tp>::__create(*this, __il, std::forward<_Args>(__args)...);
487}
488
489inline _LIBCPP_HIDE_FROM_ABI void any::swap(any& __rhs) _NOEXCEPT {
490 if (this == &__rhs)
491 return;
492 if (__h_ && __rhs.__h_) {
493 any __tmp;
494 __rhs.__call(_Action::_Move, &__tmp);
495 this->__call(_Action::_Move, &__rhs);
496 __tmp.__call(_Action::_Move, this);
497 } else if (__h_) {
498 this->__call(_Action::_Move, &__rhs);
499 } else if (__rhs.__h_) {
500 __rhs.__call(_Action::_Move, this);
501 }
502}
503
504// 6.4 Non-member functions
505
506inline _LIBCPP_HIDE_FROM_ABI void swap(any& __lhs, any& __rhs) _NOEXCEPT { __lhs.swap(__rhs); }
507
508template <class _Tp, class... _Args>
509inline _LIBCPP_HIDE_FROM_ABI any make_any(_Args&&... __args) {
510 return any(in_place_type<_Tp>, std::forward<_Args>(__args)...);
511}
512
513template <class _Tp, class _Up, class... _Args>
514inline _LIBCPP_HIDE_FROM_ABI any make_any(initializer_list<_Up> __il, _Args&&... __args) {
515 return any(in_place_type<_Tp>, __il, std::forward<_Args>(__args)...);
516}
517
518template <class _ValueType>
519inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST _ValueType any_cast(any const& __v) {
520 using _RawValueType = __remove_cvref_t<_ValueType>;
521 static_assert(is_constructible<_ValueType, _RawValueType const&>::value,
522 "ValueType is required to be a const lvalue reference "
523 "or a CopyConstructible type");
524 auto __tmp = std::any_cast<add_const_t<_RawValueType>>(&__v);
525 if (__tmp == nullptr)
526 __throw_bad_any_cast();
527 return static_cast<_ValueType>(*__tmp);
528}
529
530template <class _ValueType>
531inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST _ValueType any_cast(any& __v) {
532 using _RawValueType = __remove_cvref_t<_ValueType>;
533 static_assert(is_constructible<_ValueType, _RawValueType&>::value,
534 "ValueType is required to be an lvalue reference "
535 "or a CopyConstructible type");
536 auto __tmp = std::any_cast<_RawValueType>(&__v);
537 if (__tmp == nullptr)
538 __throw_bad_any_cast();
539 return static_cast<_ValueType>(*__tmp);
540}
541
542template <class _ValueType>
543inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST _ValueType any_cast(any&& __v) {
544 using _RawValueType = __remove_cvref_t<_ValueType>;
545 static_assert(is_constructible<_ValueType, _RawValueType>::value,
546 "ValueType is required to be an rvalue reference "
547 "or a CopyConstructible type");
548 auto __tmp = std::any_cast<_RawValueType>(&__v);
549 if (__tmp == nullptr)
550 __throw_bad_any_cast();
551 return static_cast<_ValueType>(std::move(*__tmp));
552}
553
554template <class _ValueType>
555inline _LIBCPP_HIDE_FROM_ABI add_pointer_t<add_const_t<_ValueType>> any_cast(any const* __any) _NOEXCEPT {
556 static_assert(!is_void_v<_ValueType>, "_ValueType may not be void.");
557 static_assert(!is_reference<_ValueType>::value, "_ValueType may not be a reference.");
558 return std::any_cast<_ValueType>(const_cast<any*>(__any));
559}
560
561template <class _RetType>
562inline _LIBCPP_HIDE_FROM_ABI _RetType __pointer_or_func_cast(void* __p, /*IsFunction*/ false_type) noexcept {
563 return static_cast<_RetType>(__p);
564}
565
566template <class _RetType>
567inline _LIBCPP_HIDE_FROM_ABI _RetType __pointer_or_func_cast(void*, /*IsFunction*/ true_type) noexcept {
568 return nullptr;
569}
570
571template <class _ValueType>
572_LIBCPP_HIDE_FROM_ABI add_pointer_t<_ValueType> any_cast(any* __any) _NOEXCEPT {
573 using __any_imp::_Action;
574 static_assert(!is_void_v<_ValueType>, "_ValueType may not be void.");
575 static_assert(!is_reference<_ValueType>::value, "_ValueType may not be a reference.");
576 typedef add_pointer_t<_ValueType> _ReturnType;
577 if (__any && __any->__h_) {
578 void* __p = __any->__call(
579 _Action::_Get,
580 nullptr,
581# if !defined(_LIBCPP_HAS_NO_RTTI)
582 &typeid(_ValueType),
583# else
584 nullptr,
585# endif
586 __any_imp::__get_fallback_typeid<_ValueType>());
587 return std::__pointer_or_func_cast<_ReturnType>(__p, is_function<_ValueType>{});
588 }
589 return nullptr;
590}
591
592#endif // _LIBCPP_STD_VER >= 17
593
594_LIBCPP_END_NAMESPACE_STD
595
596_LIBCPP_POP_MACROS
597
598#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 17
599# include <chrono>
600#endif
601
602#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
603# include <atomic>
604# include <concepts>
605# include <cstdlib>
606# include <iosfwd>
607# include <iterator>
608# include <memory>
609# include <stdexcept>
610# include <type_traits>
611# include <variant>
612#endif
613
614#endif // _LIBCPP_ANY
615