__functional_base revision 308143
1203181Smarcel// -*- C++ -*- 2203181Smarcel//===----------------------------------------------------------------------===// 3203181Smarcel// 4203181Smarcel// The LLVM Compiler Infrastructure 5203181Smarcel// 6203181Smarcel// This file is dual licensed under the MIT and the University of Illinois Open 7203181Smarcel// Source Licenses. See LICENSE.TXT for details. 8203181Smarcel// 9203181Smarcel//===----------------------------------------------------------------------===// 10203181Smarcel 11203181Smarcel#ifndef _LIBCPP_FUNCTIONAL_BASE 12203181Smarcel#define _LIBCPP_FUNCTIONAL_BASE 13203181Smarcel 14203181Smarcel#include <__config> 15203181Smarcel#include <type_traits> 16203181Smarcel#include <typeinfo> 17203181Smarcel#include <exception> 18203181Smarcel#include <new> 19203181Smarcel 20203181Smarcel#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 21203181Smarcel#pragma GCC system_header 22203181Smarcel#endif 23203181Smarcel 24203181Smarcel_LIBCPP_BEGIN_NAMESPACE_STD 25203181Smarcel 26203181Smarceltemplate <class _Arg, class _Result> 27203181Smarcelstruct _LIBCPP_TYPE_VIS_ONLY unary_function 28203714Smarcel{ 29203181Smarcel typedef _Arg argument_type; 30203181Smarcel typedef _Result result_type; 31203181Smarcel}; 32203181Smarcel 33203714Smarceltemplate <class _Arg1, class _Arg2, class _Result> 34203181Smarcelstruct _LIBCPP_TYPE_VIS_ONLY binary_function 35203181Smarcel{ 36203181Smarcel typedef _Arg1 first_argument_type; 37203181Smarcel typedef _Arg2 second_argument_type; 38203181Smarcel typedef _Result result_type; 39203714Smarcel}; 40203714Smarcel 41203714Smarceltemplate <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY hash; 42203714Smarcel 43203181Smarceltemplate <class _Tp> 44203181Smarcelstruct __has_result_type 45203181Smarcel{ 46203714Smarcelprivate: 47203714Smarcel struct __two {char __lx; char __lxx;}; 48203714Smarcel template <class _Up> static __two __test(...); 49203714Smarcel template <class _Up> static char __test(typename _Up::result_type* = 0); 50203181Smarcelpublic: 51203181Smarcel static const bool value = sizeof(__test<_Tp>(0)) == 1; 52203181Smarcel}; 53203181Smarcel 54203181Smarcel#if _LIBCPP_STD_VER > 11 55203181Smarceltemplate <class _Tp = void> 56203181Smarcel#else 57203181Smarceltemplate <class _Tp> 58203181Smarcel#endif 59203181Smarcelstruct _LIBCPP_TYPE_VIS_ONLY less : binary_function<_Tp, _Tp, bool> 60203714Smarcel{ 61203181Smarcel _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 62203714Smarcel bool operator()(const _Tp& __x, const _Tp& __y) const 63203181Smarcel {return __x < __y;} 64203714Smarcel}; 65203714Smarcel 66203714Smarcel#if _LIBCPP_STD_VER > 11 67203181Smarceltemplate <> 68203181Smarcelstruct _LIBCPP_TYPE_VIS_ONLY less<void> 69203714Smarcel{ 70203181Smarcel template <class _T1, class _T2> 71203181Smarcel _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 72203714Smarcel auto operator()(_T1&& __t, _T2&& __u) const 73203181Smarcel { return _VSTD::forward<_T1>(__t) < _VSTD::forward<_T2>(__u); } 74203181Smarcel typedef void is_transparent; 75203181Smarcel}; 76203181Smarcel#endif 77203181Smarcel 78203181Smarcel// addressof 79203181Smarcel 80203181Smarceltemplate <class _Tp> 81203181Smarcelinline _LIBCPP_INLINE_VISIBILITY 82203181Smarcel_Tp* 83203181Smarceladdressof(_Tp& __x) _NOEXCEPT 84203714Smarcel{ 85203181Smarcel return (_Tp*)&reinterpret_cast<const volatile char&>(__x); 86203714Smarcel} 87203181Smarcel 88203714Smarcel#if defined(_LIBCPP_HAS_OBJC_ARC) && !defined(_LIBCPP_PREDEFINED_OBJC_ARC_ADDRESSOF) 89203181Smarcel// Objective-C++ Automatic Reference Counting uses qualified pointers 90203181Smarcel// that require special addressof() signatures. When 91203181Smarcel// _LIBCPP_PREDEFINED_OBJC_ARC_ADDRESSOF is defined, the compiler 92203181Smarcel// itself is providing these definitions. Otherwise, we provide them. 93203181Smarceltemplate <class _Tp> 94210823Sjoelinline _LIBCPP_INLINE_VISIBILITY 95203181Smarcel__strong _Tp* 96203181Smarceladdressof(__strong _Tp& __x) _NOEXCEPT 97203181Smarcel{ 98203181Smarcel return &__x; 99203714Smarcel} 100203181Smarcel 101203181Smarcel#ifdef _LIBCPP_HAS_OBJC_ARC_WEAK 102203181Smarceltemplate <class _Tp> 103203181Smarcelinline _LIBCPP_INLINE_VISIBILITY 104203714Smarcel__weak _Tp* 105203714Smarceladdressof(__weak _Tp& __x) _NOEXCEPT 106203714Smarcel{ 107203714Smarcel return &__x; 108203181Smarcel} 109203714Smarcel#endif 110203181Smarcel 111203181Smarceltemplate <class _Tp> 112203181Smarcelinline _LIBCPP_INLINE_VISIBILITY 113203181Smarcel__autoreleasing _Tp* 114203181Smarceladdressof(__autoreleasing _Tp& __x) _NOEXCEPT 115203181Smarcel{ 116203181Smarcel return &__x; 117203181Smarcel} 118203181Smarcel 119203181Smarceltemplate <class _Tp> 120203181Smarcelinline _LIBCPP_INLINE_VISIBILITY 121203181Smarcel__unsafe_unretained _Tp* 122203181Smarceladdressof(__unsafe_unretained _Tp& __x) _NOEXCEPT 123203181Smarcel{ 124203181Smarcel return &__x; 125203181Smarcel} 126203181Smarcel#endif 127203181Smarcel 128203181Smarcel#ifdef _LIBCPP_HAS_NO_VARIADICS 129203181Smarcel 130203181Smarcel#include <__functional_base_03> 131203181Smarcel 132203181Smarcel#else // _LIBCPP_HAS_NO_VARIADICS 133203181Smarcel 134203181Smarcel// __weak_result_type 135203181Smarcel 136203181Smarceltemplate <class _Tp> 137203714Smarcelstruct __derives_from_unary_function 138203181Smarcel{ 139203181Smarcelprivate: 140203181Smarcel struct __two {char __lx; char __lxx;}; 141203181Smarcel static __two __test(...); 142203714Smarcel template <class _Ap, class _Rp> 143203181Smarcel 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 _Ret> 423struct __invoke_void_return_wrapper 424{ 425 template <class ..._Args> 426 static _Ret __call(_Args&&... __args) 427 { 428 return __invoke(_VSTD::forward<_Args>(__args)...); 429 } 430}; 431 432template <> 433struct __invoke_void_return_wrapper<void> 434{ 435 template <class ..._Args> 436 static void __call(_Args&&... __args) 437 { 438 __invoke(_VSTD::forward<_Args>(__args)...); 439 } 440}; 441 442template <class _Tp> 443class _LIBCPP_TYPE_VIS_ONLY reference_wrapper 444 : public __weak_result_type<_Tp> 445{ 446public: 447 // types 448 typedef _Tp type; 449private: 450 type* __f_; 451 452public: 453 // construct/copy/destroy 454 _LIBCPP_INLINE_VISIBILITY reference_wrapper(type& __f) _NOEXCEPT 455 : __f_(_VSTD::addressof(__f)) {} 456#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 457 private: reference_wrapper(type&&); public: // = delete; // do not bind to temps 458#endif 459 460 // access 461 _LIBCPP_INLINE_VISIBILITY operator type& () const _NOEXCEPT {return *__f_;} 462 _LIBCPP_INLINE_VISIBILITY type& get() const _NOEXCEPT {return *__f_;} 463 464 // invoke 465 template <class... _ArgTypes> 466 _LIBCPP_INLINE_VISIBILITY 467 typename __invoke_of<type&, _ArgTypes...>::type 468 operator() (_ArgTypes&&... __args) const 469 { 470 return __invoke(get(), _VSTD::forward<_ArgTypes>(__args)...); 471 } 472}; 473 474template <class _Tp> struct __is_reference_wrapper_impl : public false_type {}; 475template <class _Tp> struct __is_reference_wrapper_impl<reference_wrapper<_Tp> > : public true_type {}; 476template <class _Tp> struct __is_reference_wrapper 477 : public __is_reference_wrapper_impl<typename remove_cv<_Tp>::type> {}; 478 479template <class _Tp> 480inline _LIBCPP_INLINE_VISIBILITY 481reference_wrapper<_Tp> 482ref(_Tp& __t) _NOEXCEPT 483{ 484 return reference_wrapper<_Tp>(__t); 485} 486 487template <class _Tp> 488inline _LIBCPP_INLINE_VISIBILITY 489reference_wrapper<_Tp> 490ref(reference_wrapper<_Tp> __t) _NOEXCEPT 491{ 492 return ref(__t.get()); 493} 494 495template <class _Tp> 496inline _LIBCPP_INLINE_VISIBILITY 497reference_wrapper<const _Tp> 498cref(const _Tp& __t) _NOEXCEPT 499{ 500 return reference_wrapper<const _Tp>(__t); 501} 502 503template <class _Tp> 504inline _LIBCPP_INLINE_VISIBILITY 505reference_wrapper<const _Tp> 506cref(reference_wrapper<_Tp> __t) _NOEXCEPT 507{ 508 return cref(__t.get()); 509} 510 511#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 512#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS 513 514template <class _Tp> void ref(const _Tp&&) = delete; 515template <class _Tp> void cref(const _Tp&&) = delete; 516 517#else // _LIBCPP_HAS_NO_DELETED_FUNCTIONS 518 519template <class _Tp> void ref(const _Tp&&);// = delete; 520template <class _Tp> void cref(const _Tp&&);// = delete; 521 522#endif // _LIBCPP_HAS_NO_DELETED_FUNCTIONS 523 524#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 525 526#endif // _LIBCPP_HAS_NO_VARIADICS 527 528#if _LIBCPP_STD_VER > 11 529template <class _Tp1, class _Tp2 = void> 530struct __is_transparent 531{ 532private: 533 struct __two {char __lx; char __lxx;}; 534 template <class _Up> static __two __test(...); 535 template <class _Up> static char __test(typename _Up::is_transparent* = 0); 536public: 537 static const bool value = sizeof(__test<_Tp1>(0)) == 1; 538}; 539#endif 540 541// allocator_arg_t 542 543struct _LIBCPP_TYPE_VIS_ONLY allocator_arg_t { }; 544 545#if defined(_LIBCPP_HAS_NO_CONSTEXPR) || defined(_LIBCPP_BUILDING_MEMORY) 546extern const allocator_arg_t allocator_arg; 547#else 548constexpr allocator_arg_t allocator_arg = allocator_arg_t(); 549#endif 550 551// uses_allocator 552 553template <class _Tp> 554struct __has_allocator_type 555{ 556private: 557 struct __two {char __lx; char __lxx;}; 558 template <class _Up> static __two __test(...); 559 template <class _Up> static char __test(typename _Up::allocator_type* = 0); 560public: 561 static const bool value = sizeof(__test<_Tp>(0)) == 1; 562}; 563 564template <class _Tp, class _Alloc, bool = __has_allocator_type<_Tp>::value> 565struct __uses_allocator 566 : public integral_constant<bool, 567 is_convertible<_Alloc, typename _Tp::allocator_type>::value> 568{ 569}; 570 571template <class _Tp, class _Alloc> 572struct __uses_allocator<_Tp, _Alloc, false> 573 : public false_type 574{ 575}; 576 577template <class _Tp, class _Alloc> 578struct _LIBCPP_TYPE_VIS_ONLY uses_allocator 579 : public __uses_allocator<_Tp, _Alloc> 580{ 581}; 582 583#ifndef _LIBCPP_HAS_NO_VARIADICS 584 585// allocator construction 586 587template <class _Tp, class _Alloc, class ..._Args> 588struct __uses_alloc_ctor_imp 589{ 590 static const bool __ua = uses_allocator<_Tp, _Alloc>::value; 591 static const bool __ic = 592 is_constructible<_Tp, allocator_arg_t, _Alloc, _Args...>::value; 593 static const int value = __ua ? 2 - __ic : 0; 594}; 595 596template <class _Tp, class _Alloc, class ..._Args> 597struct __uses_alloc_ctor 598 : integral_constant<int, __uses_alloc_ctor_imp<_Tp, _Alloc, _Args...>::value> 599 {}; 600 601template <class _Tp, class _Allocator, class... _Args> 602inline _LIBCPP_INLINE_VISIBILITY 603void __user_alloc_construct_impl (integral_constant<int, 0>, _Tp *__storage, const _Allocator &, _Args &&... __args ) 604{ 605 new (__storage) _Tp (_VSTD::forward<_Args>(__args)...); 606} 607 608template <class _Tp, class _Allocator, class... _Args> 609inline _LIBCPP_INLINE_VISIBILITY 610void __user_alloc_construct_impl (integral_constant<int, 1>, _Tp *__storage, const _Allocator &__a, _Args &&... __args ) 611{ 612 new (__storage) _Tp (allocator_arg, __a, _VSTD::forward<_Args>(__args)...); 613} 614 615template <class _Tp, class _Allocator, class... _Args> 616inline _LIBCPP_INLINE_VISIBILITY 617void __user_alloc_construct_impl (integral_constant<int, 2>, _Tp *__storage, const _Allocator &__a, _Args &&... __args ) 618{ 619 new (__storage) _Tp (_VSTD::forward<_Args>(__args)..., __a); 620} 621 622template <class _Tp, class _Allocator, class... _Args> 623inline _LIBCPP_INLINE_VISIBILITY 624void __user_alloc_construct (_Tp *__storage, const _Allocator &__a, _Args &&... __args) 625{ 626 __user_alloc_construct_impl( 627 __uses_alloc_ctor<_Tp, _Allocator>(), 628 __storage, __a, _VSTD::forward<_Args>(__args)... 629 ); 630} 631#endif // _LIBCPP_HAS_NO_VARIADICS 632 633_LIBCPP_END_NAMESPACE_STD 634 635#endif // _LIBCPP_FUNCTIONAL_BASE 636