1// -*- C++ -*- 2//===----------------------------------------------------------------------===// 3// 4// The LLVM Compiler Infrastructure 5// 6// This file is dual licensed under the MIT and the University of Illinois Open 7// Source Licenses. See LICENSE.TXT for details. 8// 9//===----------------------------------------------------------------------===// 10 11#ifndef _LIBCPP_FUNCTIONAL_BASE 12#define _LIBCPP_FUNCTIONAL_BASE 13 14#include <__config> 15#include <type_traits> 16#include <typeinfo> 17#include <exception> 18#include <new> 19 20#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 21#pragma GCC system_header 22#endif 23 24_LIBCPP_BEGIN_NAMESPACE_STD 25 26template <class _Arg, class _Result> 27struct _LIBCPP_TYPE_VIS_ONLY unary_function 28{ 29 typedef _Arg argument_type; 30 typedef _Result result_type; 31}; 32 33template <class _Arg1, class _Arg2, class _Result> 34struct _LIBCPP_TYPE_VIS_ONLY binary_function 35{ 36 typedef _Arg1 first_argument_type; 37 typedef _Arg2 second_argument_type; 38 typedef _Result result_type; 39}; 40 41template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY hash; 42 43template <class _Tp> 44struct __has_result_type 45{ 46private: 47 struct __two {char __lx; char __lxx;}; 48 template <class _Up> static __two __test(...); 49 template <class _Up> static char __test(typename _Up::result_type* = 0); 50public: 51 static const bool value = sizeof(__test<_Tp>(0)) == 1; 52}; 53 54#if _LIBCPP_STD_VER > 11 55template <class _Tp = void> 56#else 57template <class _Tp> 58#endif 59struct _LIBCPP_TYPE_VIS_ONLY less : binary_function<_Tp, _Tp, bool> 60{ 61 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 62 bool operator()(const _Tp& __x, const _Tp& __y) const 63 {return __x < __y;} 64}; 65 66#if _LIBCPP_STD_VER > 11 67template <> 68struct _LIBCPP_TYPE_VIS_ONLY less<void> 69{ 70 template <class _T1, class _T2> 71 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 72 auto operator()(_T1&& __t, _T2&& __u) const 73 { return _VSTD::forward<_T1>(__t) < _VSTD::forward<_T2>(__u); } 74 typedef void is_transparent; 75}; 76#endif 77 78// addressof 79 80template <class _Tp> 81inline _LIBCPP_INLINE_VISIBILITY 82_Tp* 83addressof(_Tp& __x) _NOEXCEPT 84{ 85 return (_Tp*)&reinterpret_cast<const volatile char&>(__x); 86} 87 88#if defined(_LIBCPP_HAS_OBJC_ARC) && !defined(_LIBCPP_PREDEFINED_OBJC_ARC_ADDRESSOF) 89// Objective-C++ Automatic Reference Counting uses qualified pointers 90// that require special addressof() signatures. When 91// _LIBCPP_PREDEFINED_OBJC_ARC_ADDRESSOF is defined, the compiler 92// itself is providing these definitions. Otherwise, we provide them. 93template <class _Tp> 94inline _LIBCPP_INLINE_VISIBILITY 95__strong _Tp* 96addressof(__strong _Tp& __x) _NOEXCEPT 97{ 98 return &__x; 99} 100 101#ifdef _LIBCPP_HAS_OBJC_ARC_WEAK 102template <class _Tp> 103inline _LIBCPP_INLINE_VISIBILITY 104__weak _Tp* 105addressof(__weak _Tp& __x) _NOEXCEPT 106{ 107 return &__x; 108} 109#endif 110 111template <class _Tp> 112inline _LIBCPP_INLINE_VISIBILITY 113__autoreleasing _Tp* 114addressof(__autoreleasing _Tp& __x) _NOEXCEPT 115{ 116 return &__x; 117} 118 119template <class _Tp> 120inline _LIBCPP_INLINE_VISIBILITY 121__unsafe_unretained _Tp* 122addressof(__unsafe_unretained _Tp& __x) _NOEXCEPT 123{ 124 return &__x; 125} 126#endif 127 128#ifdef _LIBCPP_HAS_NO_VARIADICS 129 130#include <__functional_base_03> 131 132#else // _LIBCPP_HAS_NO_VARIADICS 133 134// __weak_result_type 135 136template <class _Tp> 137struct __derives_from_unary_function 138{ 139private: 140 struct __two {char __lx; char __lxx;}; 141 static __two __test(...); 142 template <class _Ap, class _Rp> 143 static unary_function<_Ap, _Rp> 144 __test(const volatile unary_function<_Ap, _Rp>*); 145public: 146 static const bool value = !is_same<decltype(__test((_Tp*)0)), __two>::value; 147 typedef decltype(__test((_Tp*)0)) type; 148}; 149 150template <class _Tp> 151struct __derives_from_binary_function 152{ 153private: 154 struct __two {char __lx; char __lxx;}; 155 static __two __test(...); 156 template <class _A1, class _A2, class _Rp> 157 static binary_function<_A1, _A2, _Rp> 158 __test(const volatile binary_function<_A1, _A2, _Rp>*); 159public: 160 static const bool value = !is_same<decltype(__test((_Tp*)0)), __two>::value; 161 typedef decltype(__test((_Tp*)0)) type; 162}; 163 164template <class _Tp, bool = __derives_from_unary_function<_Tp>::value> 165struct __maybe_derive_from_unary_function // bool is true 166 : public __derives_from_unary_function<_Tp>::type 167{ 168}; 169 170template <class _Tp> 171struct __maybe_derive_from_unary_function<_Tp, false> 172{ 173}; 174 175template <class _Tp, bool = __derives_from_binary_function<_Tp>::value> 176struct __maybe_derive_from_binary_function // bool is true 177 : public __derives_from_binary_function<_Tp>::type 178{ 179}; 180 181template <class _Tp> 182struct __maybe_derive_from_binary_function<_Tp, false> 183{ 184}; 185 186template <class _Tp, bool = __has_result_type<_Tp>::value> 187struct __weak_result_type_imp // bool is true 188 : public __maybe_derive_from_unary_function<_Tp>, 189 public __maybe_derive_from_binary_function<_Tp> 190{ 191 typedef typename _Tp::result_type result_type; 192}; 193 194template <class _Tp> 195struct __weak_result_type_imp<_Tp, false> 196 : public __maybe_derive_from_unary_function<_Tp>, 197 public __maybe_derive_from_binary_function<_Tp> 198{ 199}; 200 201template <class _Tp> 202struct __weak_result_type 203 : public __weak_result_type_imp<_Tp> 204{ 205}; 206 207// 0 argument case 208 209template <class _Rp> 210struct __weak_result_type<_Rp ()> 211{ 212 typedef _Rp result_type; 213}; 214 215template <class _Rp> 216struct __weak_result_type<_Rp (&)()> 217{ 218 typedef _Rp result_type; 219}; 220 221template <class _Rp> 222struct __weak_result_type<_Rp (*)()> 223{ 224 typedef _Rp result_type; 225}; 226 227// 1 argument case 228 229template <class _Rp, class _A1> 230struct __weak_result_type<_Rp (_A1)> 231 : public unary_function<_A1, _Rp> 232{ 233}; 234 235template <class _Rp, class _A1> 236struct __weak_result_type<_Rp (&)(_A1)> 237 : public unary_function<_A1, _Rp> 238{ 239}; 240 241template <class _Rp, class _A1> 242struct __weak_result_type<_Rp (*)(_A1)> 243 : public unary_function<_A1, _Rp> 244{ 245}; 246 247template <class _Rp, class _Cp> 248struct __weak_result_type<_Rp (_Cp::*)()> 249 : public unary_function<_Cp*, _Rp> 250{ 251}; 252 253template <class _Rp, class _Cp> 254struct __weak_result_type<_Rp (_Cp::*)() const> 255 : public unary_function<const _Cp*, _Rp> 256{ 257}; 258 259template <class _Rp, class _Cp> 260struct __weak_result_type<_Rp (_Cp::*)() volatile> 261 : public unary_function<volatile _Cp*, _Rp> 262{ 263}; 264 265template <class _Rp, class _Cp> 266struct __weak_result_type<_Rp (_Cp::*)() const volatile> 267 : public unary_function<const volatile _Cp*, _Rp> 268{ 269}; 270 271// 2 argument case 272 273template <class _Rp, class _A1, class _A2> 274struct __weak_result_type<_Rp (_A1, _A2)> 275 : public binary_function<_A1, _A2, _Rp> 276{ 277}; 278 279template <class _Rp, class _A1, class _A2> 280struct __weak_result_type<_Rp (*)(_A1, _A2)> 281 : public binary_function<_A1, _A2, _Rp> 282{ 283}; 284 285template <class _Rp, class _A1, class _A2> 286struct __weak_result_type<_Rp (&)(_A1, _A2)> 287 : public binary_function<_A1, _A2, _Rp> 288{ 289}; 290 291template <class _Rp, class _Cp, class _A1> 292struct __weak_result_type<_Rp (_Cp::*)(_A1)> 293 : public binary_function<_Cp*, _A1, _Rp> 294{ 295}; 296 297template <class _Rp, class _Cp, class _A1> 298struct __weak_result_type<_Rp (_Cp::*)(_A1) const> 299 : public binary_function<const _Cp*, _A1, _Rp> 300{ 301}; 302 303template <class _Rp, class _Cp, class _A1> 304struct __weak_result_type<_Rp (_Cp::*)(_A1) volatile> 305 : public binary_function<volatile _Cp*, _A1, _Rp> 306{ 307}; 308 309template <class _Rp, class _Cp, class _A1> 310struct __weak_result_type<_Rp (_Cp::*)(_A1) const volatile> 311 : public binary_function<const volatile _Cp*, _A1, _Rp> 312{ 313}; 314 315// 3 or more arguments 316 317template <class _Rp, class _A1, class _A2, class _A3, class ..._A4> 318struct __weak_result_type<_Rp (_A1, _A2, _A3, _A4...)> 319{ 320 typedef _Rp result_type; 321}; 322 323template <class _Rp, class _A1, class _A2, class _A3, class ..._A4> 324struct __weak_result_type<_Rp (&)(_A1, _A2, _A3, _A4...)> 325{ 326 typedef _Rp result_type; 327}; 328 329template <class _Rp, class _A1, class _A2, class _A3, class ..._A4> 330struct __weak_result_type<_Rp (*)(_A1, _A2, _A3, _A4...)> 331{ 332 typedef _Rp result_type; 333}; 334 335template <class _Rp, class _Cp, class _A1, class _A2, class ..._A3> 336struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2, _A3...)> 337{ 338 typedef _Rp result_type; 339}; 340 341template <class _Rp, class _Cp, class _A1, class _A2, class ..._A3> 342struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2, _A3...) const> 343{ 344 typedef _Rp result_type; 345}; 346 347template <class _Rp, class _Cp, class _A1, class _A2, class ..._A3> 348struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2, _A3...) volatile> 349{ 350 typedef _Rp result_type; 351}; 352 353template <class _Rp, class _Cp, class _A1, class _A2, class ..._A3> 354struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2, _A3...) const volatile> 355{ 356 typedef _Rp result_type; 357}; 358 359// __invoke 360 361// bullets 1 and 2 362 363template <class _Fp, class _A0, class ..._Args, 364 class> 365inline _LIBCPP_INLINE_VISIBILITY 366auto 367__invoke(_Fp&& __f, _A0&& __a0, _Args&& ...__args) 368 -> decltype((_VSTD::forward<_A0>(__a0).*__f)(_VSTD::forward<_Args>(__args)...)) 369{ 370 return (_VSTD::forward<_A0>(__a0).*__f)(_VSTD::forward<_Args>(__args)...); 371} 372 373template <class _Fp, class _A0, class ..._Args, 374 class> 375inline _LIBCPP_INLINE_VISIBILITY 376auto 377__invoke(_Fp&& __f, _A0&& __a0, _Args&& ...__args) 378 -> decltype(((*_VSTD::forward<_A0>(__a0)).*__f)(_VSTD::forward<_Args>(__args)...)) 379{ 380 return ((*_VSTD::forward<_A0>(__a0)).*__f)(_VSTD::forward<_Args>(__args)...); 381} 382 383// bullets 3 and 4 384 385template <class _Fp, class _A0, 386 class> 387inline _LIBCPP_INLINE_VISIBILITY 388auto 389__invoke(_Fp&& __f, _A0&& __a0) 390 -> decltype(_VSTD::forward<_A0>(__a0).*__f) 391{ 392 return _VSTD::forward<_A0>(__a0).*__f; 393} 394 395template <class _Fp, class _A0, 396 class> 397inline _LIBCPP_INLINE_VISIBILITY 398auto 399__invoke(_Fp&& __f, _A0&& __a0) 400 -> decltype((*_VSTD::forward<_A0>(__a0)).*__f) 401{ 402 return (*_VSTD::forward<_A0>(__a0)).*__f; 403} 404 405// bullet 5 406 407template <class _Fp, class ..._Args> 408inline _LIBCPP_INLINE_VISIBILITY 409auto 410__invoke(_Fp&& __f, _Args&& ...__args) 411 -> decltype(_VSTD::forward<_Fp>(__f)(_VSTD::forward<_Args>(__args)...)) 412{ 413 return _VSTD::forward<_Fp>(__f)(_VSTD::forward<_Args>(__args)...); 414} 415 416template <class _Tp, class ..._Args> 417struct __invoke_return 418{ 419 typedef decltype(__invoke(_VSTD::declval<_Tp>(), _VSTD::declval<_Args>()...)) type; 420}; 421 422template <class _Tp> 423class _LIBCPP_TYPE_VIS_ONLY reference_wrapper 424 : public __weak_result_type<_Tp> 425{ 426public: 427 // types 428 typedef _Tp type; 429private: 430 type* __f_; 431 432public: 433 // construct/copy/destroy 434 _LIBCPP_INLINE_VISIBILITY reference_wrapper(type& __f) _NOEXCEPT 435 : __f_(_VSTD::addressof(__f)) {} 436#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 437 private: reference_wrapper(type&&); public: // = delete; // do not bind to temps 438#endif 439 440 // access 441 _LIBCPP_INLINE_VISIBILITY operator type& () const _NOEXCEPT {return *__f_;} 442 _LIBCPP_INLINE_VISIBILITY type& get() const _NOEXCEPT {return *__f_;} 443 444 // invoke 445 template <class... _ArgTypes> 446 _LIBCPP_INLINE_VISIBILITY 447 typename __invoke_of<type&, _ArgTypes...>::type 448 operator() (_ArgTypes&&... __args) const 449 { 450 return __invoke(get(), _VSTD::forward<_ArgTypes>(__args)...); 451 } 452}; 453 454template <class _Tp> struct __is_reference_wrapper_impl : public false_type {}; 455template <class _Tp> struct __is_reference_wrapper_impl<reference_wrapper<_Tp> > : public true_type {}; 456template <class _Tp> struct __is_reference_wrapper 457 : public __is_reference_wrapper_impl<typename remove_cv<_Tp>::type> {}; 458 459template <class _Tp> 460inline _LIBCPP_INLINE_VISIBILITY 461reference_wrapper<_Tp> 462ref(_Tp& __t) _NOEXCEPT 463{ 464 return reference_wrapper<_Tp>(__t); 465} 466 467template <class _Tp> 468inline _LIBCPP_INLINE_VISIBILITY 469reference_wrapper<_Tp> 470ref(reference_wrapper<_Tp> __t) _NOEXCEPT 471{ 472 return ref(__t.get()); 473} 474 475template <class _Tp> 476inline _LIBCPP_INLINE_VISIBILITY 477reference_wrapper<const _Tp> 478cref(const _Tp& __t) _NOEXCEPT 479{ 480 return reference_wrapper<const _Tp>(__t); 481} 482 483template <class _Tp> 484inline _LIBCPP_INLINE_VISIBILITY 485reference_wrapper<const _Tp> 486cref(reference_wrapper<_Tp> __t) _NOEXCEPT 487{ 488 return cref(__t.get()); 489} 490 491#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 492#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS 493 494template <class _Tp> void ref(const _Tp&&) = delete; 495template <class _Tp> void cref(const _Tp&&) = delete; 496 497#else // _LIBCPP_HAS_NO_DELETED_FUNCTIONS 498 499template <class _Tp> void ref(const _Tp&&);// = delete; 500template <class _Tp> void cref(const _Tp&&);// = delete; 501 502#endif // _LIBCPP_HAS_NO_DELETED_FUNCTIONS 503 504#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 505 506#endif // _LIBCPP_HAS_NO_VARIADICS 507 508#if _LIBCPP_STD_VER > 11 509template <class _Tp1, class _Tp2 = void> 510struct __is_transparent 511{ 512private: 513 struct __two {char __lx; char __lxx;}; 514 template <class _Up> static __two __test(...); 515 template <class _Up> static char __test(typename _Up::is_transparent* = 0); 516public: 517 static const bool value = sizeof(__test<_Tp1>(0)) == 1; 518}; 519#endif 520 521// allocator_arg_t 522 523struct _LIBCPP_TYPE_VIS_ONLY allocator_arg_t { }; 524 525#if defined(_LIBCPP_HAS_NO_CONSTEXPR) || defined(_LIBCPP_BUILDING_MEMORY) 526extern const allocator_arg_t allocator_arg; 527#else 528constexpr allocator_arg_t allocator_arg = allocator_arg_t(); 529#endif 530 531// uses_allocator 532 533template <class _Tp> 534struct __has_allocator_type 535{ 536private: 537 struct __two {char __lx; char __lxx;}; 538 template <class _Up> static __two __test(...); 539 template <class _Up> static char __test(typename _Up::allocator_type* = 0); 540public: 541 static const bool value = sizeof(__test<_Tp>(0)) == 1; 542}; 543 544template <class _Tp, class _Alloc, bool = __has_allocator_type<_Tp>::value> 545struct __uses_allocator 546 : public integral_constant<bool, 547 is_convertible<_Alloc, typename _Tp::allocator_type>::value> 548{ 549}; 550 551template <class _Tp, class _Alloc> 552struct __uses_allocator<_Tp, _Alloc, false> 553 : public false_type 554{ 555}; 556 557template <class _Tp, class _Alloc> 558struct _LIBCPP_TYPE_VIS_ONLY uses_allocator 559 : public __uses_allocator<_Tp, _Alloc> 560{ 561}; 562 563#ifndef _LIBCPP_HAS_NO_VARIADICS 564 565// allocator construction 566 567template <class _Tp, class _Alloc, class ..._Args> 568struct __uses_alloc_ctor_imp 569{ 570 static const bool __ua = uses_allocator<_Tp, _Alloc>::value; 571 static const bool __ic = 572 is_constructible<_Tp, allocator_arg_t, _Alloc, _Args...>::value; 573 static const int value = __ua ? 2 - __ic : 0; 574}; 575 576template <class _Tp, class _Alloc, class ..._Args> 577struct __uses_alloc_ctor 578 : integral_constant<int, __uses_alloc_ctor_imp<_Tp, _Alloc, _Args...>::value> 579 {}; 580 581template <class _Tp, class _Allocator, class... _Args> 582inline _LIBCPP_INLINE_VISIBILITY 583void __user_alloc_construct_impl (integral_constant<int, 0>, _Tp *__storage, const _Allocator &, _Args &&... __args ) 584{ 585 new (__storage) _Tp (_VSTD::forward<_Args>(__args)...); 586} 587 588template <class _Tp, class _Allocator, class... _Args> 589inline _LIBCPP_INLINE_VISIBILITY 590void __user_alloc_construct_impl (integral_constant<int, 1>, _Tp *__storage, const _Allocator &__a, _Args &&... __args ) 591{ 592 new (__storage) _Tp (allocator_arg, __a, _VSTD::forward<_Args>(__args)...); 593} 594 595template <class _Tp, class _Allocator, class... _Args> 596inline _LIBCPP_INLINE_VISIBILITY 597void __user_alloc_construct_impl (integral_constant<int, 2>, _Tp *__storage, const _Allocator &__a, _Args &&... __args ) 598{ 599 new (__storage) _Tp (_VSTD::forward<_Args>(__args)..., __a); 600} 601 602template <class _Tp, class _Allocator, class... _Args> 603inline _LIBCPP_INLINE_VISIBILITY 604void __user_alloc_construct (_Tp *__storage, const _Allocator &__a, _Args &&... __args) 605{ 606 __user_alloc_construct_impl( 607 __uses_alloc_ctor<_Tp, _Allocator>(), 608 __storage, __a, _VSTD::forward<_Args>(__args)... 609 ); 610} 611#endif // _LIBCPP_HAS_NO_VARIADICS 612 613_LIBCPP_END_NAMESPACE_STD 614 615#endif // _LIBCPP_FUNCTIONAL_BASE 616