contrib/libc++/include/__functional_base

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