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