contrib/libc++/include/__functional_base_03

   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_03
  12 #define _LIBCPP_FUNCTIONAL_BASE_03
  13
  14 // manual variadic expansion for <functional>
  15
  16 // __weak_result_type
  17
  18 template <class _Tp>
  19 struct __derives_from_unary_function
  20 {
  21 private:
  22     struct __two {char __lx; char __lxx;};
  23     static __two __test(...);
  24     template <class _Ap, class _Rp>
  25         static unary_function<_Ap, _Rp>
  26         __test(const volatile unary_function<_Ap, _Rp>*);
  27 public:
  28     static const bool value = !is_same<decltype(__test((_Tp*)0)), __two>::value;
  29     typedef decltype(__test((_Tp*)0)) type;
  30 };
  31
  32 template <class _Tp>
  33 struct __derives_from_binary_function
  34 {
  35 private:
  36     struct __two {char __lx; char __lxx;};
  37     static __two __test(...);
  38     template <class _A1, class _A2, class _Rp>
  39         static binary_function<_A1, _A2, _Rp>
  40         __test(const volatile binary_function<_A1, _A2, _Rp>*);
  41 public:
  42     static const bool value = !is_same<decltype(__test((_Tp*)0)), __two>::value;
  43     typedef decltype(__test((_Tp*)0)) type;
  44 };
  45
  46 template <class _Tp, bool = __derives_from_unary_function<_Tp>::value>
  47 struct __maybe_derive_from_unary_function  // bool is true
  48     : public __derives_from_unary_function<_Tp>::type
  49 {
  50 };
  51
  52 template <class _Tp>
  53 struct __maybe_derive_from_unary_function<_Tp, false>
  54 {
  55 };
  56
  57 template <class _Tp, bool = __derives_from_binary_function<_Tp>::value>
  58 struct __maybe_derive_from_binary_function  // bool is true
  59     : public __derives_from_binary_function<_Tp>::type
  60 {
  61 };
  62
  63 template <class _Tp>
  64 struct __maybe_derive_from_binary_function<_Tp, false>
  65 {
  66 };
  67
  68 template <class _Tp, bool = __has_result_type<_Tp>::value>
  69 struct __weak_result_type_imp // bool is true
  70     : public __maybe_derive_from_unary_function<_Tp>,
  71       public __maybe_derive_from_binary_function<_Tp>
  72 {
  73     typedef typename _Tp::result_type result_type;
  74 };
  75
  76 template <class _Tp>
  77 struct __weak_result_type_imp<_Tp, false>
  78     : public __maybe_derive_from_unary_function<_Tp>,
  79       public __maybe_derive_from_binary_function<_Tp>
  80 {
  81 };
  82
  83 template <class _Tp>
  84 struct __weak_result_type
  85     : public __weak_result_type_imp<typename remove_reference<_Tp>::type>
  86 {
  87 };
  88
  89 // 0 argument case
  90
  91 template <class _Rp>
  92 struct __weak_result_type<_Rp ()>
  93 {
  94     typedef _Rp result_type;
  95 };
  96
  97 template <class _Rp>
  98 struct __weak_result_type<_Rp (&)()>
  99 {
 100     typedef _Rp result_type;
 101 };
 102
 103 template <class _Rp>
 104 struct __weak_result_type<_Rp (*)()>
 105 {
 106     typedef _Rp result_type;
 107 };
 108
 109 // 1 argument case
 110
 111 template <class _Rp, class _A1>
 112 struct __weak_result_type<_Rp (_A1)>
 113     : public unary_function<_A1, _Rp>
 114 {
 115 };
 116
 117 template <class _Rp, class _A1>
 118 struct __weak_result_type<_Rp (&)(_A1)>
 119     : public unary_function<_A1, _Rp>
 120 {
 121 };
 122
 123 template <class _Rp, class _A1>
 124 struct __weak_result_type<_Rp (*)(_A1)>
 125     : public unary_function<_A1, _Rp>
 126 {
 127 };
 128
 129 template <class _Rp, class _Cp>
 130 struct __weak_result_type<_Rp (_Cp::*)()>
 131     : public unary_function<_Cp*, _Rp>
 132 {
 133 };
 134
 135 template <class _Rp, class _Cp>
 136 struct __weak_result_type<_Rp (_Cp::*)() const>
 137     : public unary_function<const _Cp*, _Rp>
 138 {
 139 };
 140
 141 template <class _Rp, class _Cp>
 142 struct __weak_result_type<_Rp (_Cp::*)() volatile>
 143     : public unary_function<volatile _Cp*, _Rp>
 144 {
 145 };
 146
 147 template <class _Rp, class _Cp>
 148 struct __weak_result_type<_Rp (_Cp::*)() const volatile>
 149     : public unary_function<const volatile _Cp*, _Rp>
 150 {
 151 };
 152
 153 // 2 argument case
 154
 155 template <class _Rp, class _A1, class _A2>
 156 struct __weak_result_type<_Rp (_A1, _A2)>
 157     : public binary_function<_A1, _A2, _Rp>
 158 {
 159 };
 160
 161 template <class _Rp, class _A1, class _A2>
 162 struct __weak_result_type<_Rp (*)(_A1, _A2)>
 163     : public binary_function<_A1, _A2, _Rp>
 164 {
 165 };
 166
 167 template <class _Rp, class _A1, class _A2>
 168 struct __weak_result_type<_Rp (&)(_A1, _A2)>
 169     : public binary_function<_A1, _A2, _Rp>
 170 {
 171 };
 172
 173 template <class _Rp, class _Cp, class _A1>
 174 struct __weak_result_type<_Rp (_Cp::*)(_A1)>
 175     : public binary_function<_Cp*, _A1, _Rp>
 176 {
 177 };
 178
 179 template <class _Rp, class _Cp, class _A1>
 180 struct __weak_result_type<_Rp (_Cp::*)(_A1) const>
 181     : public binary_function<const _Cp*, _A1, _Rp>
 182 {
 183 };
 184
 185 template <class _Rp, class _Cp, class _A1>
 186 struct __weak_result_type<_Rp (_Cp::*)(_A1) volatile>
 187     : public binary_function<volatile _Cp*, _A1, _Rp>
 188 {
 189 };
 190
 191 template <class _Rp, class _Cp, class _A1>
 192 struct __weak_result_type<_Rp (_Cp::*)(_A1) const volatile>
 193     : public binary_function<const volatile _Cp*, _A1, _Rp>
 194 {
 195 };
 196
 197 // 3 or more arguments
 198
 199 template <class _Rp, class _A1, class _A2, class _A3>
 200 struct __weak_result_type<_Rp (_A1, _A2, _A3)>
 201 {
 202     typedef _Rp result_type;
 203 };
 204
 205 template <class _Rp, class _A1, class _A2, class _A3>
 206 struct __weak_result_type<_Rp (&)(_A1, _A2, _A3)>
 207 {
 208     typedef _Rp result_type;
 209 };
 210
 211 template <class _Rp, class _A1, class _A2, class _A3>
 212 struct __weak_result_type<_Rp (*)(_A1, _A2, _A3)>
 213 {
 214     typedef _Rp result_type;
 215 };
 216
 217 template <class _Rp, class _Cp, class _A1, class _A2>
 218 struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2)>
 219 {
 220     typedef _Rp result_type;
 221 };
 222
 223 template <class _Rp, class _Cp, class _A1, class _A2>
 224 struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2) const>
 225 {
 226     typedef _Rp result_type;
 227 };
 228
 229 template <class _Rp, class _Cp, class _A1, class _A2>
 230 struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2) volatile>
 231 {
 232     typedef _Rp result_type;
 233 };
 234
 235 // __invoke
 236
 237 // __ref_return0
 238 //
 239 // template <class _Tp, bool _HasResultType>
 240 // struct ________ref_return0  // _HasResultType is true
 241 // {
 242 //     typedef typename _Tp::result_type type;
 243 // };
 244 //
 245 // template <class _Tp>
 246 // struct ________ref_return0<_Tp, false>
 247 // {
 248 //     typedef void type;
 249 // };
 250 //
 251 // template <class _Tp, bool _IsClass>
 252 // struct ____ref_return0  // _IsClass is true
 253 //     : public ________ref_return0<_Tp, __has_result_type<typename remove_cv<_Tp>::type>::value>
 254 // {
 255 // };
 256 //
 257 // template <class _Tp, bool _HasResultType>
 258 // struct ______ref_return0  // _HasResultType is true
 259 // {
 260 //     typedef typename __callable_type<_Tp>::result_type type;
 261 // };
 262 //
 263 // template <class _Tp>
 264 // struct ______ref_return0<_Tp, false>  // pointer to member data
 265 // {
 266 //     typedef void type;
 267 // };
 268 //
 269 // template <class _Tp>
 270 // struct ____ref_return0<_Tp, false>
 271 //     : public ______ref_return0<typename remove_cv<_Tp>::type,
 272 //                  __has_result_type<__callable_type<typename remove_cv<_Tp>::type> >::value>
 273 // {
 274 // };
 275 //
 276 // template <class _Tp>
 277 // struct __ref_return0
 278 //     : public ____ref_return0<typename remove_reference<_Tp>::type,
 279 //                    is_class<typename remove_reference<_Tp>::type>::value>
 280 // {
 281 // };
 282 //
 283 // __ref_return1
 284 //
 285 // template <class _Tp, bool _IsClass, class _A0>
 286 // struct ____ref_return1  // _IsClass is true
 287 // {
 288 //     typedef typename result_of<_Tp(_A0)>::type type;
 289 // };
 290 //
 291 // template <class _Tp, bool _HasResultType, class _A0>
 292 // struct ______ref_return1  // _HasResultType is true
 293 // {
 294 //     typedef typename __callable_type<_Tp>::result_type type;
 295 // };
 296 //
 297 // template <class _Tp, class _A0, bool>
 298 // struct __ref_return1_member_data1;
 299 //
 300 // template <class _Rp, class _Cp, class _A0>
 301 // struct __ref_return1_member_data1<_Rp _Cp::*, _A0, true>
 302 // {
 303 //     typedef typename __apply_cv<_A0, _Rp>::type& type;
 304 // };
 305 //
 306 // template <class _Rp, class _Cp, class _A0>
 307 // struct __ref_return1_member_data1<_Rp _Cp::*, _A0, false>
 308 // {
 309 //     static _A0 __a;
 310 //     typedef typename __apply_cv<decltype(*__a), _Rp>::type& type;
 311 // };
 312 //
 313 // template <class _Tp, class _A0>
 314 // struct __ref_return1_member_data;
 315 //
 316 // template <class _Rp, class _Cp, class _A0>
 317 // struct __ref_return1_member_data<_Rp _Cp::*, _A0>
 318 //     : public __ref_return1_member_data1<_Rp _Cp::*, _A0,
 319 //                 is_same<typename remove_cv<_Cp>::type,
 320 //                         typename remove_cv<typename remove_reference<_A0>::type>::type>::value>
 321 // {
 322 // };
 323 //
 324 // template <class _Tp, class _A0>
 325 // struct ______ref_return1<_Tp, false, _A0>  // pointer to member data
 326 //     : public __ref_return1_member_data<typename remove_cv<_Tp>::type, _A0>
 327 // {
 328 // };
 329 //
 330 // template <class _Tp, class _A0>
 331 // struct ____ref_return1<_Tp, false, _A0>
 332 //     : public ______ref_return1<typename remove_cv<_Tp>::type,
 333 //                  __has_result_type<__callable_type<typename remove_cv<_Tp>::type> >::value, _A0>
 334 // {
 335 // };
 336 //
 337 // template <class _Tp, class _A0>
 338 // struct __ref_return1
 339 //     : public ____ref_return1<typename remove_reference<_Tp>::type,
 340 //                    is_class<typename remove_reference<_Tp>::type>::value, _A0>
 341 // {
 342 // };
 343 //
 344 // __ref_return2
 345 //
 346 // template <class _Tp, bool _IsClass, class _A0, class _A1>
 347 // struct ____ref_return2  // _IsClass is true
 348 // {
 349 //     typedef typename result_of<_Tp(_A0, _A1)>::type type;
 350 // };
 351 //
 352 // template <class _Tp, bool _HasResultType, class _A0, class _A1>
 353 // struct ______ref_return2  // _HasResultType is true
 354 // {
 355 //     typedef typename __callable_type<_Tp>::result_type type;
 356 // };
 357 //
 358 // template <class _Tp>
 359 // struct ______ref_return2<_Tp, false, class _A0, class _A1>  // pointer to member data
 360 // {
 361 //     static_assert(sizeof(_Tp) == 0, "An attempt has been made to `call` a pointer"
 362 //                          " to member data with too many arguments.");
 363 // };
 364 //
 365 // template <class _Tp, class _A0, class _A1>
 366 // struct ____ref_return2<_Tp, false, _A0, _A1>
 367 //     : public ______ref_return2<typename remove_cv<_Tp>::type,
 368 //                  __has_result_type<__callable_type<typename remove_cv<_Tp>::type> >::value, _A0, _A1>
 369 // {
 370 // };
 371 //
 372 // template <class _Tp, class _A0, class _A1>
 373 // struct __ref_return2
 374 //     : public ____ref_return2<typename remove_reference<_Tp>::type,
 375 //                    is_class<typename remove_reference<_Tp>::type>::value, _A0, _A1>
 376 // {
 377 // };
 378 //
 379 // __ref_return3
 380 //
 381 // template <class _Tp, bool _IsClass, class _A0, class _A1, class _A2>
 382 // struct ____ref_return3  // _IsClass is true
 383 // {
 384 //     typedef typename result_of<_Tp(_A0, _A1, _A2)>::type type;
 385 // };
 386 //
 387 // template <class _Tp, bool _HasResultType, class _A0, class _A1, class _A2>
 388 // struct ______ref_return3  // _HasResultType is true
 389 // {
 390 //     typedef typename __callable_type<_Tp>::result_type type;
 391 // };
 392 //
 393 // template <class _Tp>
 394 // struct ______ref_return3<_Tp, false, class _A0, class _A1, class _A2>  // pointer to member data
 395 // {
 396 //     static_assert(sizeof(_Tp) == 0, "An attempt has been made to `call` a pointer"
 397 //                          " to member data with too many arguments.");
 398 // };
 399 //
 400 // template <class _Tp, class _A0, class _A1, class _A2>
 401 // struct ____ref_return3<_Tp, false, _A0, _A1, _A2>
 402 //     : public ______ref_return3<typename remove_cv<_Tp>::type,
 403 //                  __has_result_type<__callable_type<typename remove_cv<_Tp>::type> >::value, _A0, _A1, _A2>
 404 // {
 405 // };
 406 //
 407 // template <class _Tp, class _A0, class _A1, class _A2>
 408 // struct __ref_return3
 409 //     : public ____ref_return3<typename remove_reference<_Tp>::type,
 410 //                    is_class<typename remove_reference<_Tp>::type>::value, _A0, _A1, _A2>
 411 // {
 412 // };
 413
 414 // first bullet
 415
 416 template <class _Rp, class _Tp, class _T1>
 417 inline _LIBCPP_INLINE_VISIBILITY
 418 typename enable_if
 419 <
 420     is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
 421     _Rp
 422 >::type
 423 __invoke(_Rp (_Tp::*__f)(), _T1& __t1)
 424 {
 425     return (__t1.*__f)();
 426 }
 427
 428 template <class _Rp, class _Tp, class _T1, class _A0>
 429 inline _LIBCPP_INLINE_VISIBILITY
 430 typename enable_if
 431 <
 432     is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
 433     _Rp
 434 >::type
 435 __invoke(_Rp (_Tp::*__f)(_A0), _T1& __t1, _A0& __a0)
 436 {
 437     return (__t1.*__f)(__a0);
 438 }
 439
 440 template <class _Rp, class _Tp, class _T1, class _A0, class _A1>
 441 inline _LIBCPP_INLINE_VISIBILITY
 442 typename enable_if
 443 <
 444     is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
 445     _Rp
 446 >::type
 447 __invoke(_Rp (_Tp::*__f)(_A0, _A1), _T1& __t1, _A0& __a0, _A1& __a1)
 448 {
 449     return (__t1.*__f)(__a0, __a1);
 450 }
 451
 452 template <class _Rp, class _Tp, class _T1, class _A0, class _A1, class _A2>
 453 inline _LIBCPP_INLINE_VISIBILITY
 454 typename enable_if
 455 <
 456     is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
 457     _Rp
 458 >::type
 459 __invoke(_Rp (_Tp::*__f)(_A0, _A1, _A2), _T1& __t1, _A0& __a0, _A1& __a1, _A2& __a2)
 460 {
 461     return (__t1.*__f)(__a0, __a1, __a2);
 462 }
 463
 464 template <class _Rp, class _Tp, class _T1>
 465 inline _LIBCPP_INLINE_VISIBILITY
 466 typename enable_if
 467 <
 468     is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
 469     _Rp
 470 >::type
 471 __invoke(_Rp (_Tp::*__f)() const, _T1& __t1)
 472 {
 473     return (__t1.*__f)();
 474 }
 475
 476 template <class _Rp, class _Tp, class _T1, class _A0>
 477 inline _LIBCPP_INLINE_VISIBILITY
 478 typename enable_if
 479 <
 480     is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
 481     _Rp
 482 >::type
 483 __invoke(_Rp (_Tp::*__f)(_A0) const, _T1& __t1, _A0& __a0)
 484 {
 485     return (__t1.*__f)(__a0);
 486 }
 487
 488 template <class _Rp, class _Tp, class _T1, class _A0, class _A1>
 489 inline _LIBCPP_INLINE_VISIBILITY
 490 typename enable_if
 491 <
 492     is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
 493     _Rp
 494 >::type
 495 __invoke(_Rp (_Tp::*__f)(_A0, _A1) const, _T1& __t1, _A0& __a0, _A1& __a1)
 496 {
 497     return (__t1.*__f)(__a0, __a1);
 498 }
 499
 500 template <class _Rp, class _Tp, class _T1, class _A0, class _A1, class _A2>
 501 inline _LIBCPP_INLINE_VISIBILITY
 502 typename enable_if
 503 <
 504     is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
 505     _Rp
 506 >::type
 507 __invoke(_Rp (_Tp::*__f)(_A0, _A1, _A2) const, _T1& __t1, _A0& __a0, _A1& __a1, _A2& __a2)
 508 {
 509     return (__t1.*__f)(__a0, __a1, __a2);
 510 }
 511
 512 template <class _Rp, class _Tp, class _T1>
 513 inline _LIBCPP_INLINE_VISIBILITY
 514 typename enable_if
 515 <
 516     is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
 517     _Rp
 518 >::type
 519 __invoke(_Rp (_Tp::*__f)() volatile, _T1& __t1)
 520 {
 521     return (__t1.*__f)();
 522 }
 523
 524 template <class _Rp, class _Tp, class _T1, class _A0>
 525 inline _LIBCPP_INLINE_VISIBILITY
 526 typename enable_if
 527 <
 528     is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
 529     _Rp
 530 >::type
 531 __invoke(_Rp (_Tp::*__f)(_A0) volatile, _T1& __t1, _A0& __a0)
 532 {
 533     return (__t1.*__f)(__a0);
 534 }
 535
 536 template <class _Rp, class _Tp, class _T1, class _A0, class _A1>
 537 inline _LIBCPP_INLINE_VISIBILITY
 538 typename enable_if
 539 <
 540     is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
 541     _Rp
 542 >::type
 543 __invoke(_Rp (_Tp::*__f)(_A0, _A1) volatile, _T1& __t1, _A0& __a0, _A1& __a1)
 544 {
 545     return (__t1.*__f)(__a0, __a1);
 546 }
 547
 548 template <class _Rp, class _Tp, class _T1, class _A0, class _A1, class _A2>
 549 inline _LIBCPP_INLINE_VISIBILITY
 550 typename enable_if
 551 <
 552     is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
 553     _Rp
 554 >::type
 555 __invoke(_Rp (_Tp::*__f)(_A0, _A1, _A2) volatile, _T1& __t1, _A0& __a0, _A1& __a1, _A2& __a2)
 556 {
 557     return (__t1.*__f)(__a0, __a1, __a2);
 558 }
 559
 560 template <class _Rp, class _Tp, class _T1>
 561 inline _LIBCPP_INLINE_VISIBILITY
 562 typename enable_if
 563 <
 564     is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
 565     _Rp
 566 >::type
 567 __invoke(_Rp (_Tp::*__f)() const volatile, _T1& __t1)
 568 {
 569     return (__t1.*__f)();
 570 }
 571
 572 template <class _Rp, class _Tp, class _T1, class _A0>
 573 inline _LIBCPP_INLINE_VISIBILITY
 574 typename enable_if
 575 <
 576     is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
 577     _Rp
 578 >::type
 579 __invoke(_Rp (_Tp::*__f)(_A0) const volatile, _T1& __t1, _A0& __a0)
 580 {
 581     return (__t1.*__f)(__a0);
 582 }
 583
 584 template <class _Rp, class _Tp, class _T1, class _A0, class _A1>
 585 inline _LIBCPP_INLINE_VISIBILITY
 586 typename enable_if
 587 <
 588     is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
 589     _Rp
 590 >::type
 591 __invoke(_Rp (_Tp::*__f)(_A0, _A1) const volatile, _T1& __t1, _A0& __a0, _A1& __a1)
 592 {
 593     return (__t1.*__f)(__a0, __a1);
 594 }
 595
 596 template <class _Rp, class _Tp, class _T1, class _A0, class _A1, class _A2>
 597 inline _LIBCPP_INLINE_VISIBILITY
 598 typename enable_if
 599 <
 600     is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
 601     _Rp
 602 >::type
 603 __invoke(_Rp (_Tp::*__f)(_A0, _A1, _A2) const volatile, _T1& __t1, _A0& __a0, _A1& __a1, _A2& __a2)
 604 {
 605     return (__t1.*__f)(__a0, __a1, __a2);
 606 }
 607
 608 // second bullet
 609
 610 template <class _Rp, class _Tp, class _T1>
 611 inline _LIBCPP_INLINE_VISIBILITY
 612 typename enable_if
 613 <
 614     !is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
 615     _Rp
 616 >::type
 617 __invoke(_Rp (_Tp::*__f)(), _T1 __t1)
 618 {
 619     return ((*__t1).*__f)();
 620 }
 621
 622 template <class _Rp, class _Tp, class _T1, class _A0>
 623 inline _LIBCPP_INLINE_VISIBILITY
 624 typename enable_if
 625 <
 626     !is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
 627     _Rp
 628 >::type
 629 __invoke(_Rp (_Tp::*__f)(_A0), _T1 __t1, _A0& __a0)
 630 {
 631     return ((*__t1).*__f)(__a0);
 632 }
 633
 634 template <class _Rp, class _Tp, class _T1, class _A0, class _A1>
 635 inline _LIBCPP_INLINE_VISIBILITY
 636 typename enable_if
 637 <
 638     !is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
 639     _Rp
 640 >::type
 641 __invoke(_Rp (_Tp::*__f)(_A0, _A1), _T1 __t1, _A0& __a0, _A1& __a1)
 642 {
 643     return ((*__t1).*__f)(__a0, __a1);
 644 }
 645
 646 template <class _Rp, class _Tp, class _T1, class _A0, class _A1, class _A2>
 647 inline _LIBCPP_INLINE_VISIBILITY
 648 typename enable_if
 649 <
 650     !is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
 651     _Rp
 652 >::type
 653 __invoke(_Rp (_Tp::*__f)(_A0, _A1, _A2), _T1 __t1, _A0& __a0, _A1& __a1, _A2& __a2)
 654 {
 655     return ((*__t1).*__f)(__a0, __a1, __a2);
 656 }
 657
 658 template <class _Rp, class _Tp, class _T1>
 659 inline _LIBCPP_INLINE_VISIBILITY
 660 typename enable_if
 661 <
 662     !is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
 663     _Rp
 664 >::type
 665 __invoke(_Rp (_Tp::*__f)() const, _T1 __t1)
 666 {
 667     return ((*__t1).*__f)();
 668 }
 669
 670 template <class _Rp, class _Tp, class _T1, class _A0>
 671 inline _LIBCPP_INLINE_VISIBILITY
 672 typename enable_if
 673 <
 674     !is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
 675     _Rp
 676 >::type
 677 __invoke(_Rp (_Tp::*__f)(_A0) const, _T1 __t1, _A0& __a0)
 678 {
 679     return ((*__t1).*__f)(__a0);
 680 }
 681
 682 template <class _Rp, class _Tp, class _T1, class _A0, class _A1>
 683 inline _LIBCPP_INLINE_VISIBILITY
 684 typename enable_if
 685 <
 686     !is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
 687     _Rp
 688 >::type
 689 __invoke(_Rp (_Tp::*__f)(_A0, _A1) const, _T1 __t1, _A0& __a0, _A1& __a1)
 690 {
 691     return ((*__t1).*__f)(__a0, __a1);
 692 }
 693
 694 template <class _Rp, class _Tp, class _T1, class _A0, class _A1, class _A2>
 695 inline _LIBCPP_INLINE_VISIBILITY
 696 typename enable_if
 697 <
 698     !is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
 699     _Rp
 700 >::type
 701 __invoke(_Rp (_Tp::*__f)(_A0, _A1, _A2) const, _T1 __t1, _A0& __a0, _A1& __a1, _A2& __a2)
 702 {
 703     return ((*__t1).*__f)(__a0, __a1, __a2);
 704 }
 705
 706 template <class _Rp, class _Tp, class _T1>
 707 inline _LIBCPP_INLINE_VISIBILITY
 708 typename enable_if
 709 <
 710     !is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
 711     _Rp
 712 >::type
 713 __invoke(_Rp (_Tp::*__f)() volatile, _T1 __t1)
 714 {
 715     return ((*__t1).*__f)();
 716 }
 717
 718 template <class _Rp, class _Tp, class _T1, class _A0>
 719 inline _LIBCPP_INLINE_VISIBILITY
 720 typename enable_if
 721 <
 722     !is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
 723     _Rp
 724 >::type
 725 __invoke(_Rp (_Tp::*__f)(_A0) volatile, _T1 __t1, _A0& __a0)
 726 {
 727     return ((*__t1).*__f)(__a0);
 728 }
 729
 730 template <class _Rp, class _Tp, class _T1, class _A0, class _A1>
 731 inline _LIBCPP_INLINE_VISIBILITY
 732 typename enable_if
 733 <
 734     !is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
 735     _Rp
 736 >::type
 737 __invoke(_Rp (_Tp::*__f)(_A0, _A1) volatile, _T1 __t1, _A0& __a0, _A1& __a1)
 738 {
 739     return ((*__t1).*__f)(__a0, __a1);
 740 }
 741
 742 template <class _Rp, class _Tp, class _T1, class _A0, class _A1, class _A2>
 743 inline _LIBCPP_INLINE_VISIBILITY
 744 typename enable_if
 745 <
 746     !is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
 747     _Rp
 748 >::type
 749 __invoke(_Rp (_Tp::*__f)(_A0, _A1, _A2) volatile, _T1 __t1, _A0& __a0, _A1& __a1, _A2& __a2)
 750 {
 751     return ((*__t1).*__f)(__a0, __a1, __a2);
 752 }
 753
 754 template <class _Rp, class _Tp, class _T1>
 755 inline _LIBCPP_INLINE_VISIBILITY
 756 typename enable_if
 757 <
 758     !is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
 759     _Rp
 760 >::type
 761 __invoke(_Rp (_Tp::*__f)() const volatile, _T1 __t1)
 762 {
 763     return ((*__t1).*__f)();
 764 }
 765
 766 template <class _Rp, class _Tp, class _T1, class _A0>
 767 inline _LIBCPP_INLINE_VISIBILITY
 768 typename enable_if
 769 <
 770     !is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
 771     _Rp
 772 >::type
 773 __invoke(_Rp (_Tp::*__f)(_A0) const volatile, _T1 __t1, _A0& __a0)
 774 {
 775     return ((*__t1).*__f)(__a0);
 776 }
 777
 778 template <class _Rp, class _Tp, class _T1, class _A0, class _A1>
 779 inline _LIBCPP_INLINE_VISIBILITY
 780 typename enable_if
 781 <
 782     !is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
 783     _Rp
 784 >::type
 785 __invoke(_Rp (_Tp::*__f)(_A0, _A1) const volatile, _T1 __t1, _A0& __a0, _A1& __a1)
 786 {
 787     return ((*__t1).*__f)(__a0, __a1);
 788 }
 789
 790 template <class _Rp, class _Tp, class _T1, class _A0, class _A1, class _A2>
 791 inline _LIBCPP_INLINE_VISIBILITY
 792 typename enable_if
 793 <
 794     !is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
 795     _Rp
 796 >::type
 797 __invoke(_Rp (_Tp::*__f)(_A0, _A1, _A2) const volatile, _T1 __t1, _A0& __a0, _A1& __a1, _A2& __a2)
 798 {
 799     return ((*__t1).*__f)(__a0, __a1, __a2);
 800 }
 801
 802 // third bullet
 803
 804 template <class _Rp, class _Tp, class _T1>
 805 inline _LIBCPP_INLINE_VISIBILITY
 806 typename enable_if
 807 <
 808     is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
 809     typename __apply_cv<_T1, _Rp>::type&
 810 >::type
 811 __invoke(_Rp _Tp::* __f, _T1& __t1)
 812 {
 813     return __t1.*__f;
 814 }
 815
 816 template <class _Rp, class _Tp>
 817 inline _LIBCPP_INLINE_VISIBILITY
 818 void
 819 __invoke(_Rp _Tp::*)
 820 {
 821 }
 822
 823 // template <class _Dp, class _Rp, class _Tp, class _T1>
 824 // inline _LIBCPP_INLINE_VISIBILITY
 825 // typename enable_if
 826 // <
 827 //     is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
 828 //     typename __ref_return1<_Rp _Tp::*, _T1>::type
 829 // >::type
 830 // __invoke(_Rp _Tp::* __f, _T1& __t1)
 831 // {
 832 //     return __t1.*__f;
 833 // }
 834
 835 // forth bullet
 836
 837 template <class _T1, class _Rp, bool>
 838 struct __4th_helper
 839 {
 840 };
 841
 842 template <class _T1, class _Rp>
 843 struct __4th_helper<_T1, _Rp, true>
 844 {
 845     typedef typename __apply_cv<decltype(*_VSTD::declval<_T1>()), _Rp>::type type;
 846 };
 847
 848 template <class _Rp, class _Tp, class _T1>
 849 inline _LIBCPP_INLINE_VISIBILITY
 850 typename __4th_helper<_T1, _Rp,
 851                       !is_base_of<_Tp,
 852                                   typename remove_reference<_T1>::type
 853                                  >::value
 854                      >::type&
 855 __invoke(_Rp _Tp::* __f, _T1& __t1)
 856 {
 857     return (*__t1).*__f;
 858 }
 859
 860 // template <class _Dp, class _Rp, class _Tp, class _T1>
 861 // inline _LIBCPP_INLINE_VISIBILITY
 862 // typename enable_if
 863 // <
 864 //     !is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
 865 //     typename __ref_return1<_Rp _Tp::*, _T1>::type
 866 // >::type
 867 // __invoke(_Rp _Tp::* __f, _T1 __t1)
 868 // {
 869 //     return (*__t1).*__f;
 870 // }
 871
 872 // fifth bullet
 873
 874 template <class _Fp>
 875 inline _LIBCPP_INLINE_VISIBILITY
 876 decltype(declval<_Fp>()())
 877 __invoke(_Fp __f)
 878 {
 879     return __f();
 880 }
 881
 882 template <class _Fp, class _A0>
 883 inline _LIBCPP_INLINE_VISIBILITY
 884 decltype(declval<_Fp>()(declval<_A0&>()))
 885 __invoke(_Fp __f, _A0& __a0)
 886 {
 887     return __f(__a0);
 888 }
 889
 890 template <class _Fp, class _A0, class _A1>
 891 inline _LIBCPP_INLINE_VISIBILITY
 892 decltype(declval<_Fp>()(declval<_A0&>(), declval<_A1&>()))
 893 __invoke(_Fp __f, _A0& __a0, _A1& __a1)
 894 {
 895     return __f(__a0, __a1);
 896 }
 897
 898 template <class _Fp, class _A0, class _A1, class _A2>
 899 inline _LIBCPP_INLINE_VISIBILITY
 900 decltype(declval<_Fp>()(declval<_A0&>(), declval<_A1&>(), declval<_A2&>()))
 901 __invoke(_Fp __f, _A0& __a0, _A1& __a1, _A2& __a2)
 902 {
 903     return __f(__a0, __a1, __a2);
 904 }
 905
 906 // template <class _Rp, class _Fp>
 907 // inline _LIBCPP_INLINE_VISIBILITY
 908 // _Rp
 909 // __invoke(_Fp& __f)
 910 // {
 911 //     return __f();
 912 // }
 913 //
 914 // template <class _Rp, class _Fp, class _A0>
 915 // inline _LIBCPP_INLINE_VISIBILITY
 916 // typename enable_if
 917 // <
 918 //     !is_member_pointer<_Fp>::value,
 919 //     _Rp
 920 // >::type
 921 // __invoke(_Fp& __f, _A0& __a0)
 922 // {
 923 //     return __f(__a0);
 924 // }
 925 //
 926 // template <class _Rp, class _Fp, class _A0, class _A1>
 927 // inline _LIBCPP_INLINE_VISIBILITY
 928 // _Rp
 929 // __invoke(_Fp& __f, _A0& __a0, _A1& __a1)
 930 // {
 931 //     return __f(__a0, __a1);
 932 // }
 933 //
 934 // template <class _Rp, class _Fp, class _A0, class _A1, class _A2>
 935 // inline _LIBCPP_INLINE_VISIBILITY
 936 // _Rp
 937 // __invoke(_Fp& __f, _A0& __a0, _A1& __a1, _A2& __a2)
 938 // {
 939 //     return __f(__a0, __a1, __a2);
 940 // }
 941
 942 template <class _Tp>
 943 struct __has_type
 944 {
 945 private:
 946     struct __two {char __lx; char __lxx;};
 947     template <class _Up> static __two __test(...);
 948     template <class _Up> static char __test(typename _Up::type* = 0);
 949 public:
 950     static const bool value = sizeof(__test<_Tp>(0)) == 1;
 951 };
 952
 953 template <class _Fp, bool = __has_result_type<__weak_result_type<_Fp> >::value>
 954 struct __invoke_return
 955 {
 956     typedef typename __weak_result_type<_Fp>::result_type type;
 957 };
 958
 959 template <class _Fp>
 960 struct __invoke_return<_Fp, false>
 961 {
 962     typedef decltype(__invoke(_VSTD::declval<_Fp>())) type;
 963 };
 964
 965 template <class _Tp, class _A0>
 966 struct __invoke_return0
 967 {
 968     typedef decltype(__invoke(_VSTD::declval<_Tp>(), _VSTD::declval<_A0>())) type;
 969 };
 970
 971 template <class _Rp, class _Tp, class _A0>
 972 struct __invoke_return0<_Rp _Tp::*, _A0>
 973 {
 974     typedef typename __apply_cv<_A0, _Rp>::type& type;
 975 };
 976
 977 template <class _Rp, class _Tp, class _A0>
 978 struct __invoke_return0<_Rp _Tp::*, _A0*>
 979 {
 980     typedef typename __apply_cv<_A0, _Rp>::type& type;
 981 };
 982
 983 template <class _Tp, class _A0, class _A1>
 984 struct __invoke_return1
 985 {
 986     typedef decltype(__invoke(_VSTD::declval<_Tp>(), _VSTD::declval<_A0>(),
 987                                                     _VSTD::declval<_A1>())) type;
 988 };
 989
 990 template <class _Tp, class _A0, class _A1, class _A2>
 991 struct __invoke_return2
 992 {
 993     typedef decltype(__invoke(_VSTD::declval<_Tp>(), _VSTD::declval<_A0>(),
 994                                                     _VSTD::declval<_A1>(),
 995                                                     _VSTD::declval<_A2>())) type;
 996 };
 997
 998 template <class _Tp>
 999 class _LIBCPP_TYPE_VIS reference_wrapper
1000     : public __weak_result_type<_Tp>
1001 {
1002 public:
1003     // types
1004     typedef _Tp type;
1005 private:
1006     type* __f_;
1007
1008 public:
1009     // construct/copy/destroy
1010     _LIBCPP_INLINE_VISIBILITY reference_wrapper(type& __f) : __f_(&__f) {}
1011
1012     // access
1013     _LIBCPP_INLINE_VISIBILITY operator type&    () const {return *__f_;}
1014     _LIBCPP_INLINE_VISIBILITY          type& get() const {return *__f_;}
1015
1016     // invoke
1017
1018     _LIBCPP_INLINE_VISIBILITY
1019     typename __invoke_return<type&>::type
1020        operator() () const
1021        {
1022            return __invoke(get());
1023        }
1024
1025     template <class _A0>
1026        _LIBCPP_INLINE_VISIBILITY
1027        typename __invoke_return0<type&, _A0>::type
1028           operator() (_A0& __a0) const
1029           {
1030               return __invoke(get(), __a0);
1031           }
1032
1033     template <class _A0, class _A1>
1034        _LIBCPP_INLINE_VISIBILITY
1035        typename __invoke_return1<type&, _A0, _A1>::type
1036           operator() (_A0& __a0, _A1& __a1) const
1037           {
1038               return __invoke(get(), __a0, __a1);
1039           }
1040
1041     template <class _A0, class _A1, class _A2>
1042        _LIBCPP_INLINE_VISIBILITY
1043        typename __invoke_return2<type&, _A0, _A1, _A2>::type
1044           operator() (_A0& __a0, _A1& __a1, _A2& __a2) const
1045           {
1046               return __invoke(get(), __a0, __a1, __a2);
1047           }
1048 };
1049
1050 template <class _Tp> struct ____is_reference_wrapper : public false_type {};
1051 template <class _Tp> struct ____is_reference_wrapper<reference_wrapper<_Tp> > : public true_type {};
1052 template <class _Tp> struct __is_reference_wrapper
1053     : public ____is_reference_wrapper<typename remove_cv<_Tp>::type> {};
1054
1055 template <class _Tp>
1056 inline _LIBCPP_INLINE_VISIBILITY
1057 reference_wrapper<_Tp>
1058 ref(_Tp& __t)
1059 {
1060     return reference_wrapper<_Tp>(__t);
1061 }
1062
1063 template <class _Tp>
1064 inline _LIBCPP_INLINE_VISIBILITY
1065 reference_wrapper<_Tp>
1066 ref(reference_wrapper<_Tp> __t)
1067 {
1068     return ref(__t.get());
1069 }
1070
1071 template <class _Tp>
1072 inline _LIBCPP_INLINE_VISIBILITY
1073 reference_wrapper<const _Tp>
1074 cref(const _Tp& __t)
1075 {
1076     return reference_wrapper<const _Tp>(__t);
1077 }
1078
1079 template <class _Tp>
1080 inline _LIBCPP_INLINE_VISIBILITY
1081 reference_wrapper<const _Tp>
1082 cref(reference_wrapper<_Tp> __t)
1083 {
1084     return cref(__t.get());
1085 }
1086
1087 #endif  // _LIBCPP_FUNCTIONAL_BASE_03