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         { return _VSTD::forward<_T1>(__t) < _VSTD::forward<_T2>(__u); }
  74     typedef void is_transparent;
  75 };
  76 #endif
  77
  78 // addressof
  79
  80 template <class _Tp>
  81 inline _LIBCPP_INLINE_VISIBILITY
  82 _Tp*
  83 addressof(_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.
  93 template <class _Tp>
  94 inline _LIBCPP_INLINE_VISIBILITY
  95 __strong _Tp*
  96 addressof(__strong _Tp& __x) _NOEXCEPT
  97 {
  98   return &__x;
  99 }
 100
 101 #ifdef _LIBCPP_HAS_OBJC_ARC_WEAK
 102 template <class _Tp>
 103 inline _LIBCPP_INLINE_VISIBILITY
 104 __weak _Tp*
 105 addressof(__weak _Tp& __x) _NOEXCEPT
 106 {
 107   return &__x;
 108 }
 109 #endif
 110
 111 template <class _Tp>
 112 inline _LIBCPP_INLINE_VISIBILITY
 113 __autoreleasing _Tp*
 114 addressof(__autoreleasing _Tp& __x) _NOEXCEPT
 115 {
 116   return &__x;
 117 }
 118
 119 template <class _Tp>
 120 inline _LIBCPP_INLINE_VISIBILITY
 121 __unsafe_unretained _Tp*
 122 addressof(__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
 136 template <class _Tp>
 137 struct __derives_from_unary_function
 138 {
 139 private:
 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>*);
 145 public:
 146     static const bool value = !is_same<decltype(__test((_Tp*)0)), __two>::value;
 147     typedef decltype(__test((_Tp*)0)) type;
 148 };
 149
 150 template <class _Tp>
 151 struct __derives_from_binary_function
 152 {
 153 private:
 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>*);
 159 public:
 160     static const bool value = !is_same<decltype(__test((_Tp*)0)), __two>::value;
 161     typedef decltype(__test((_Tp*)0)) type;
 162 };
 163
 164 template <class _Tp, bool = __derives_from_unary_function<_Tp>::value>
 165 struct __maybe_derive_from_unary_function  // bool is true
 166     : public __derives_from_unary_function<_Tp>::type
 167 {
 168 };
 169
 170 template <class _Tp>
 171 struct __maybe_derive_from_unary_function<_Tp, false>
 172 {
 173 };
 174
 175 template <class _Tp, bool = __derives_from_binary_function<_Tp>::value>
 176 struct __maybe_derive_from_binary_function  // bool is true
 177     : public __derives_from_binary_function<_Tp>::type
 178 {
 179 };
 180
 181 template <class _Tp>
 182 struct __maybe_derive_from_binary_function<_Tp, false>
 183 {
 184 };
 185
 186 template <class _Tp, bool = __has_result_type<_Tp>::value>
 187 struct __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
 194 template <class _Tp>
 195 struct __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
 201 template <class _Tp>
 202 struct __weak_result_type
 203     : public __weak_result_type_imp<_Tp>
 204 {
 205 };
 206
 207 // 0 argument case
 208
 209 template <class _Rp>
 210 struct __weak_result_type<_Rp ()>
 211 {
 212     typedef _Rp result_type;
 213 };
 214
 215 template <class _Rp>
 216 struct __weak_result_type<_Rp (&)()>
 217 {
 218     typedef _Rp result_type;
 219 };
 220
 221 template <class _Rp>
 222 struct __weak_result_type<_Rp (*)()>
 223 {
 224     typedef _Rp result_type;
 225 };
 226
 227 // 1 argument case
 228
 229 template <class _Rp, class _A1>
 230 struct __weak_result_type<_Rp (_A1)>
 231     : public unary_function<_A1, _Rp>
 232 {
 233 };
 234
 235 template <class _Rp, class _A1>
 236 struct __weak_result_type<_Rp (&)(_A1)>
 237     : public unary_function<_A1, _Rp>
 238 {
 239 };
 240
 241 template <class _Rp, class _A1>
 242 struct __weak_result_type<_Rp (*)(_A1)>
 243     : public unary_function<_A1, _Rp>
 244 {
 245 };
 246
 247 template <class _Rp, class _Cp>
 248 struct __weak_result_type<_Rp (_Cp::*)()>
 249     : public unary_function<_Cp*, _Rp>
 250 {
 251 };
 252
 253 template <class _Rp, class _Cp>
 254 struct __weak_result_type<_Rp (_Cp::*)() const>
 255     : public unary_function<const _Cp*, _Rp>
 256 {
 257 };
 258
 259 template <class _Rp, class _Cp>
 260 struct __weak_result_type<_Rp (_Cp::*)() volatile>
 261     : public unary_function<volatile _Cp*, _Rp>
 262 {
 263 };
 264
 265 template <class _Rp, class _Cp>
 266 struct __weak_result_type<_Rp (_Cp::*)() const volatile>
 267     : public unary_function<const volatile _Cp*, _Rp>
 268 {
 269 };
 270
 271 // 2 argument case
 272
 273 template <class _Rp, class _A1, class _A2>
 274 struct __weak_result_type<_Rp (_A1, _A2)>
 275     : public binary_function<_A1, _A2, _Rp>
 276 {
 277 };
 278
 279 template <class _Rp, class _A1, class _A2>
 280 struct __weak_result_type<_Rp (*)(_A1, _A2)>
 281     : public binary_function<_A1, _A2, _Rp>
 282 {
 283 };
 284
 285 template <class _Rp, class _A1, class _A2>
 286 struct __weak_result_type<_Rp (&)(_A1, _A2)>
 287     : public binary_function<_A1, _A2, _Rp>
 288 {
 289 };
 290
 291 template <class _Rp, class _Cp, class _A1>
 292 struct __weak_result_type<_Rp (_Cp::*)(_A1)>
 293     : public binary_function<_Cp*, _A1, _Rp>
 294 {
 295 };
 296
 297 template <class _Rp, class _Cp, class _A1>
 298 struct __weak_result_type<_Rp (_Cp::*)(_A1) const>
 299     : public binary_function<const _Cp*, _A1, _Rp>
 300 {
 301 };
 302
 303 template <class _Rp, class _Cp, class _A1>
 304 struct __weak_result_type<_Rp (_Cp::*)(_A1) volatile>
 305     : public binary_function<volatile _Cp*, _A1, _Rp>
 306 {
 307 };
 308
 309 template <class _Rp, class _Cp, class _A1>
 310 struct __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
 317 template <class _Rp, class _A1, class _A2, class _A3, class ..._A4>
 318 struct __weak_result_type<_Rp (_A1, _A2, _A3, _A4...)>
 319 {
 320     typedef _Rp result_type;
 321 };
 322
 323 template <class _Rp, class _A1, class _A2, class _A3, class ..._A4>
 324 struct __weak_result_type<_Rp (&)(_A1, _A2, _A3, _A4...)>
 325 {
 326     typedef _Rp result_type;
 327 };
 328
 329 template <class _Rp, class _A1, class _A2, class _A3, class ..._A4>
 330 struct __weak_result_type<_Rp (*)(_A1, _A2, _A3, _A4...)>
 331 {
 332     typedef _Rp result_type;
 333 };
 334
 335 template <class _Rp, class _Cp, class _A1, class _A2, class ..._A3>
 336 struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2, _A3...)>
 337 {
 338     typedef _Rp result_type;
 339 };
 340
 341 template <class _Rp, class _Cp, class _A1, class _A2, class ..._A3>
 342 struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2, _A3...) const>
 343 {
 344     typedef _Rp result_type;
 345 };
 346
 347 template <class _Rp, class _Cp, class _A1, class _A2, class ..._A3>
 348 struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2, _A3...) volatile>
 349 {
 350     typedef _Rp result_type;
 351 };
 352
 353 template <class _Rp, class _Cp, class _A1, class _A2, class ..._A3>
 354 struct __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
 363 template <class _Fp, class _A0, class ..._Args,
 364             class>
 365 inline _LIBCPP_INLINE_VISIBILITY
 366 auto
 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
 373 template <class _Fp, class _A0, class ..._Args,
 374             class>
 375 inline _LIBCPP_INLINE_VISIBILITY
 376 auto
 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
 385 template <class _Fp, class _A0,
 386             class>
 387 inline _LIBCPP_INLINE_VISIBILITY
 388 auto
 389 __invoke(_Fp&& __f, _A0&& __a0)
 390     -> decltype(_VSTD::forward<_A0>(__a0).*__f)
 391 {
 392     return _VSTD::forward<_A0>(__a0).*__f;
 393 }
 394
 395 template <class _Fp, class _A0,
 396             class>
 397 inline _LIBCPP_INLINE_VISIBILITY
 398 auto
 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
 407 template <class _Fp, class ..._Args>
 408 inline _LIBCPP_INLINE_VISIBILITY
 409 auto
 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
 416 template <class _Tp, class ..._Args>
 417 struct __invoke_return
 418 {
 419     typedef decltype(__invoke(_VSTD::declval<_Tp>(), _VSTD::declval<_Args>()...)) type;
 420 };
 421
 422 template <class _Tp>
 423 class _LIBCPP_TYPE_VIS_ONLY reference_wrapper
 424     : public __weak_result_type<_Tp>
 425 {
 426 public:
 427     // types
 428     typedef _Tp type;
 429 private:
 430     type* __f_;
 431
 432 public:
 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
 454 template <class _Tp> struct __is_reference_wrapper_impl : public false_type {};
 455 template <class _Tp> struct __is_reference_wrapper_impl<reference_wrapper<_Tp> > : public true_type {};
 456 template <class _Tp> struct __is_reference_wrapper
 457     : public __is_reference_wrapper_impl<typename remove_cv<_Tp>::type> {};
 458
 459 template <class _Tp>
 460 inline _LIBCPP_INLINE_VISIBILITY
 461 reference_wrapper<_Tp>
 462 ref(_Tp& __t) _NOEXCEPT
 463 {
 464     return reference_wrapper<_Tp>(__t);
 465 }
 466
 467 template <class _Tp>
 468 inline _LIBCPP_INLINE_VISIBILITY
 469 reference_wrapper<_Tp>
 470 ref(reference_wrapper<_Tp> __t) _NOEXCEPT
 471 {
 472     return ref(__t.get());
 473 }
 474
 475 template <class _Tp>
 476 inline _LIBCPP_INLINE_VISIBILITY
 477 reference_wrapper<const _Tp>
 478 cref(const _Tp& __t) _NOEXCEPT
 479 {
 480     return reference_wrapper<const _Tp>(__t);
 481 }
 482
 483 template <class _Tp>
 484 inline _LIBCPP_INLINE_VISIBILITY
 485 reference_wrapper<const _Tp>
 486 cref(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
 494 template <class _Tp> void ref(const _Tp&&) = delete;
 495 template <class _Tp> void cref(const _Tp&&) = delete;
 496
 497 #else  // _LIBCPP_HAS_NO_DELETED_FUNCTIONS
 498
 499 template <class _Tp> void ref(const _Tp&&);// = delete;
 500 template <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
 509 template <class _Tp1, class _Tp2 = void>
 510 struct __is_transparent
 511 {
 512 private:
 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);
 516 public:
 517     static const bool value = sizeof(__test<_Tp1>(0)) == 1;
 518 };
 519 #endif
 520
 521 // allocator_arg_t
 522
 523 struct _LIBCPP_TYPE_VIS_ONLY allocator_arg_t { };
 524
 525 #if defined(_LIBCPP_HAS_NO_CONSTEXPR) || defined(_LIBCPP_BUILDING_MEMORY)
 526 extern const allocator_arg_t allocator_arg;
 527 #else
 528 constexpr allocator_arg_t allocator_arg = allocator_arg_t();
 529 #endif
 530
 531 // uses_allocator
 532
 533 template <class _Tp>
 534 struct __has_allocator_type
 535 {
 536 private:
 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);
 540 public:
 541     static const bool value = sizeof(__test<_Tp>(0)) == 1;
 542 };
 543
 544 template <class _Tp, class _Alloc, bool = __has_allocator_type<_Tp>::value>
 545 struct __uses_allocator
 546     : public integral_constant<bool,
 547         is_convertible<_Alloc, typename _Tp::allocator_type>::value>
 548 {
 549 };
 550
 551 template <class _Tp, class _Alloc>
 552 struct __uses_allocator<_Tp, _Alloc, false>
 553     : public false_type
 554 {
 555 };
 556
 557 template <class _Tp, class _Alloc>
 558 struct _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
 567 template <class _Tp, class _Alloc, class ..._Args>
 568 struct __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
 576 template <class _Tp, class _Alloc, class ..._Args>
 577 struct __uses_alloc_ctor
 578     : integral_constant<int, __uses_alloc_ctor_imp<_Tp, _Alloc, _Args...>::value>
 579     {};
 580
 581 template <class _Tp, class _Allocator, class... _Args>
 582 inline _LIBCPP_INLINE_VISIBILITY
 583 void __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
 588 template <class _Tp, class _Allocator, class... _Args>
 589 inline _LIBCPP_INLINE_VISIBILITY
 590 void __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
 595 template <class _Tp, class _Allocator, class... _Args>
 596 inline _LIBCPP_INLINE_VISIBILITY
 597 void __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
 602 template <class _Tp, class _Allocator, class... _Args>
 603 inline _LIBCPP_INLINE_VISIBILITY
 604 void __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