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