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