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

source code of flutter_engine/third_party/libcxx/include/any