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 131 // __weak_result_type 132 133 template <class _Tp> 134 struct __derives_from_unary_function 135 { 136 private: 137 struct __two {char __lx; char __lxx;}; 138 static __two __test(...); 139 template <class _Ap, class _Rp> 140 static unary_function<_Ap, _Rp> 141 __test(const volatile unary_function<_Ap, _Rp>*); 142 public: 143 static const bool value = !is_same<decltype(__test((_Tp*)0)), __two>::value; 144 typedef decltype(__test((_Tp*)0)) type; 145 }; 146 147 template <class _Tp> 148 struct __derives_from_binary_function 149 { 150 private: 151 struct __two {char __lx; char __lxx;}; 152 static __two __test(...); 153 template <class _A1, class _A2, class _Rp> 154 static binary_function<_A1, _A2, _Rp> 155 __test(const volatile binary_function<_A1, _A2, _Rp>*); 156 public: 157 static const bool value = !is_same<decltype(__test((_Tp*)0)), __two>::value; 158 typedef decltype(__test((_Tp*)0)) type; 159 }; 160 161 template <class _Tp, bool = __derives_from_unary_function<_Tp>::value> 162 struct __maybe_derive_from_unary_function // bool is true 163 : public __derives_from_unary_function<_Tp>::type 164 { 165 }; 166 167 template <class _Tp> 168 struct __maybe_derive_from_unary_function<_Tp, false> 169 { 170 }; 171 172 template <class _Tp, bool = __derives_from_binary_function<_Tp>::value> 173 struct __maybe_derive_from_binary_function // bool is true 174 : public __derives_from_binary_function<_Tp>::type 175 { 176 }; 177 178 template <class _Tp> 179 struct __maybe_derive_from_binary_function<_Tp, false> 180 { 181 }; 182 183 template <class _Tp, bool = __has_result_type<_Tp>::value> 184 struct __weak_result_type_imp // bool is true 185 : public __maybe_derive_from_unary_function<_Tp>, 186 public __maybe_derive_from_binary_function<_Tp> 187 { 188 typedef typename _Tp::result_type result_type; 189 }; 190 191 template <class _Tp> 192 struct __weak_result_type_imp<_Tp, false> 193 : public __maybe_derive_from_unary_function<_Tp>, 194 public __maybe_derive_from_binary_function<_Tp> 195 { 196 }; 197 198 template <class _Tp> 199 struct __weak_result_type 200 : public __weak_result_type_imp<_Tp> 201 { 202 }; 203 204 // 0 argument case 205 206 template <class _Rp> 207 struct __weak_result_type<_Rp ()> 208 { 209 typedef _Rp result_type; 210 }; 211 212 template <class _Rp> 213 struct __weak_result_type<_Rp (&)()> 214 { 215 typedef _Rp result_type; 216 }; 217 218 template <class _Rp> 219 struct __weak_result_type<_Rp (*)()> 220 { 221 typedef _Rp result_type; 222 }; 223 224 // 1 argument case 225 226 template <class _Rp, class _A1> 227 struct __weak_result_type<_Rp (_A1)> 228 : public unary_function<_A1, _Rp> 229 { 230 }; 231 232 template <class _Rp, class _A1> 233 struct __weak_result_type<_Rp (&)(_A1)> 234 : public unary_function<_A1, _Rp> 235 { 236 }; 237 238 template <class _Rp, class _A1> 239 struct __weak_result_type<_Rp (*)(_A1)> 240 : public unary_function<_A1, _Rp> 241 { 242 }; 243 244 template <class _Rp, class _Cp> 245 struct __weak_result_type<_Rp (_Cp::*)()> 246 : public unary_function<_Cp*, _Rp> 247 { 248 }; 249 250 template <class _Rp, class _Cp> 251 struct __weak_result_type<_Rp (_Cp::*)() const> 252 : public unary_function<const _Cp*, _Rp> 253 { 254 }; 255 256 template <class _Rp, class _Cp> 257 struct __weak_result_type<_Rp (_Cp::*)() volatile> 258 : public unary_function<volatile _Cp*, _Rp> 259 { 260 }; 261 262 template <class _Rp, class _Cp> 263 struct __weak_result_type<_Rp (_Cp::*)() const volatile> 264 : public unary_function<const volatile _Cp*, _Rp> 265 { 266 }; 267 268 // 2 argument case 269 270 template <class _Rp, class _A1, class _A2> 271 struct __weak_result_type<_Rp (_A1, _A2)> 272 : public binary_function<_A1, _A2, _Rp> 273 { 274 }; 275 276 template <class _Rp, class _A1, class _A2> 277 struct __weak_result_type<_Rp (*)(_A1, _A2)> 278 : public binary_function<_A1, _A2, _Rp> 279 { 280 }; 281 282 template <class _Rp, class _A1, class _A2> 283 struct __weak_result_type<_Rp (&)(_A1, _A2)> 284 : public binary_function<_A1, _A2, _Rp> 285 { 286 }; 287 288 template <class _Rp, class _Cp, class _A1> 289 struct __weak_result_type<_Rp (_Cp::*)(_A1)> 290 : public binary_function<_Cp*, _A1, _Rp> 291 { 292 }; 293 294 template <class _Rp, class _Cp, class _A1> 295 struct __weak_result_type<_Rp (_Cp::*)(_A1) const> 296 : public binary_function<const _Cp*, _A1, _Rp> 297 { 298 }; 299 300 template <class _Rp, class _Cp, class _A1> 301 struct __weak_result_type<_Rp (_Cp::*)(_A1) volatile> 302 : public binary_function<volatile _Cp*, _A1, _Rp> 303 { 304 }; 305 306 template <class _Rp, class _Cp, class _A1> 307 struct __weak_result_type<_Rp (_Cp::*)(_A1) const volatile> 308 : public binary_function<const volatile _Cp*, _A1, _Rp> 309 { 310 }; 311 312 313 #ifndef _LIBCPP_HAS_NO_VARIADICS 314 // 3 or more arguments 315 316 template <class _Rp, class _A1, class _A2, class _A3, class ..._A4> 317 struct __weak_result_type<_Rp (_A1, _A2, _A3, _A4...)> 318 { 319 typedef _Rp result_type; 320 }; 321 322 template <class _Rp, class _A1, class _A2, class _A3, class ..._A4> 323 struct __weak_result_type<_Rp (&)(_A1, _A2, _A3, _A4...)> 324 { 325 typedef _Rp result_type; 326 }; 327 328 template <class _Rp, class _A1, class _A2, class _A3, class ..._A4> 329 struct __weak_result_type<_Rp (*)(_A1, _A2, _A3, _A4...)> 330 { 331 typedef _Rp result_type; 332 }; 333 334 template <class _Rp, class _Cp, class _A1, class _A2, class ..._A3> 335 struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2, _A3...)> 336 { 337 typedef _Rp result_type; 338 }; 339 340 template <class _Rp, class _Cp, class _A1, class _A2, class ..._A3> 341 struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2, _A3...) const> 342 { 343 typedef _Rp result_type; 344 }; 345 346 template <class _Rp, class _Cp, class _A1, class _A2, class ..._A3> 347 struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2, _A3...) volatile> 348 { 349 typedef _Rp result_type; 350 }; 351 352 template <class _Rp, class _Cp, class _A1, class _A2, class ..._A3> 353 struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2, _A3...) const volatile> 354 { 355 typedef _Rp result_type; 356 }; 357 358 #endif // _LIBCPP_HAS_NO_VARIADICS 359 360 // __invoke 361 362 #ifndef _LIBCPP_HAS_NO_VARIADICS 363 364 // bullets 1 and 2 365 366 template <class _Fp, class _A0, class ..._Args, 367 class> 368 inline _LIBCPP_INLINE_VISIBILITY 369 auto 370 __invoke(_Fp&& __f, _A0&& __a0, _Args&& ...__args) 371 -> decltype((_VSTD::forward<_A0>(__a0).*__f)(_VSTD::forward<_Args>(__args)...)) 372 { 373 return (_VSTD::forward<_A0>(__a0).*__f)(_VSTD::forward<_Args>(__args)...); 374 } 375 376 template <class _Fp, class _A0, class ..._Args, 377 class> 378 inline _LIBCPP_INLINE_VISIBILITY 379 auto 380 __invoke(_Fp&& __f, _A0&& __a0, _Args&& ...__args) 381 -> decltype(((*_VSTD::forward<_A0>(__a0)).*__f)(_VSTD::forward<_Args>(__args)...)) 382 { 383 return ((*_VSTD::forward<_A0>(__a0)).*__f)(_VSTD::forward<_Args>(__args)...); 384 } 385 386 // bullets 3 and 4 387 388 template <class _Fp, class _A0, 389 class> 390 inline _LIBCPP_INLINE_VISIBILITY 391 auto 392 __invoke(_Fp&& __f, _A0&& __a0) 393 -> decltype(_VSTD::forward<_A0>(__a0).*__f) 394 { 395 return _VSTD::forward<_A0>(__a0).*__f; 396 } 397 398 template <class _Fp, class _A0, 399 class> 400 inline _LIBCPP_INLINE_VISIBILITY 401 auto 402 __invoke(_Fp&& __f, _A0&& __a0) 403 -> decltype((*_VSTD::forward<_A0>(__a0)).*__f) 404 { 405 return (*_VSTD::forward<_A0>(__a0)).*__f; 406 } 407 408 // bullet 5 409 410 template <class _Fp, class ..._Args> 411 inline _LIBCPP_INLINE_VISIBILITY 412 auto 413 __invoke(_Fp&& __f, _Args&& ...__args) 414 -> decltype(_VSTD::forward<_Fp>(__f)(_VSTD::forward<_Args>(__args)...)) 415 { 416 return _VSTD::forward<_Fp>(__f)(_VSTD::forward<_Args>(__args)...); 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 #else // _LIBCPP_HAS_NO_VARIADICS 425 426 #include <__functional_base_03> 427 428 #endif // _LIBCPP_HAS_NO_VARIADICS 429 430 431 template <class _Ret> 432 struct __invoke_void_return_wrapper 433 { 434 #ifndef _LIBCPP_HAS_NO_VARIADICS 435 template <class ..._Args> 436 static _Ret __call(_Args&&... __args) { 437 return __invoke(_VSTD::forward<_Args>(__args)...); 438 } 439 #else 440 template <class _Fn> 441 static _Ret __call(_Fn __f) { 442 return __invoke(__f); 443 } 444 445 template <class _Fn, class _A0> 446 static _Ret __call(_Fn __f, _A0& __a0) { 447 return __invoke(__f, __a0); 448 } 449 450 template <class _Fn, class _A0, class _A1> 451 static _Ret __call(_Fn __f, _A0& __a0, _A1& __a1) { 452 return __invoke(__f, __a0, __a1); 453 } 454 455 template <class _Fn, class _A0, class _A1, class _A2> 456 static _Ret __call(_Fn __f, _A0& __a0, _A1& __a1, _A2& __a2){ 457 return __invoke(__f, __a0, __a1, __a2); 458 } 459 #endif 460 }; 461 462 template <> 463 struct __invoke_void_return_wrapper<void> 464 { 465 #ifndef _LIBCPP_HAS_NO_VARIADICS 466 template <class ..._Args> 467 static void __call(_Args&&... __args) { 468 __invoke(_VSTD::forward<_Args>(__args)...); 469 } 470 #else 471 template <class _Fn> 472 static void __call(_Fn __f) { 473 __invoke(__f); 474 } 475 476 template <class _Fn, class _A0> 477 static void __call(_Fn __f, _A0& __a0) { 478 __invoke(__f, __a0); 479 } 480 481 template <class _Fn, class _A0, class _A1> 482 static void __call(_Fn __f, _A0& __a0, _A1& __a1) { 483 __invoke(__f, __a0, __a1); 484 } 485 486 template <class _Fn, class _A0, class _A1, class _A2> 487 static void __call(_Fn __f, _A0& __a0, _A1& __a1, _A2& __a2) { 488 __invoke(__f, __a0, __a1, __a2); 489 } 490 #endif 491 }; 492 493 template <class _Tp> 494 class _LIBCPP_TYPE_VIS_ONLY reference_wrapper 495 : public __weak_result_type<_Tp> 496 { 497 public: 498 // types 499 typedef _Tp type; 500 private: 501 type* __f_; 502 503 public: 504 // construct/copy/destroy 505 _LIBCPP_INLINE_VISIBILITY reference_wrapper(type& __f) _NOEXCEPT 506 : __f_(_VSTD::addressof(__f)) {} 507 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 508 private: reference_wrapper(type&&); public: // = delete; // do not bind to temps 509 #endif 510 511 // access 512 _LIBCPP_INLINE_VISIBILITY operator type& () const _NOEXCEPT {return *__f_;} 513 _LIBCPP_INLINE_VISIBILITY type& get() const _NOEXCEPT {return *__f_;} 514 515 #ifndef _LIBCPP_HAS_NO_VARIADICS 516 // invoke 517 template <class... _ArgTypes> 518 _LIBCPP_INLINE_VISIBILITY 519 typename __invoke_of<type&, _ArgTypes...>::type 520 operator() (_ArgTypes&&... __args) const 521 { 522 return __invoke(get(), _VSTD::forward<_ArgTypes>(__args)...); 523 } 524 #else 525 526 _LIBCPP_INLINE_VISIBILITY 527 typename __invoke_return<type>::type 528 operator() () const 529 { 530 return __invoke(get()); 531 } 532 533 template <class _A0> 534 _LIBCPP_INLINE_VISIBILITY 535 typename __invoke_return0<type&, _A0>::type 536 operator() (_A0& __a0) const 537 { 538 return __invoke<type&, _A0>(get(), __a0); 539 } 540 541 template <class _A0, class _A1> 542 _LIBCPP_INLINE_VISIBILITY 543 typename __invoke_return1<type&, _A0, _A1>::type 544 operator() (_A0& __a0, _A1& __a1) const 545 { 546 return __invoke<type&, _A0, _A1>(get(), __a0, __a1); 547 } 548 549 template <class _A0, class _A1, class _A2> 550 _LIBCPP_INLINE_VISIBILITY 551 typename __invoke_return2<type&, _A0, _A1, _A2>::type 552 operator() (_A0& __a0, _A1& __a1, _A2& __a2) const 553 { 554 return __invoke<type&, _A0, _A1, _A2>(get(), __a0, __a1, __a2); 555 } 556 #endif // _LIBCPP_HAS_NO_VARIADICS 557 }; 558 559 template <class _Tp> struct __is_reference_wrapper_impl : public false_type {}; 560 template <class _Tp> struct __is_reference_wrapper_impl<reference_wrapper<_Tp> > : public true_type {}; 561 template <class _Tp> struct __is_reference_wrapper 562 : public __is_reference_wrapper_impl<typename remove_cv<_Tp>::type> {}; 563 564 template <class _Tp> 565 inline _LIBCPP_INLINE_VISIBILITY 566 reference_wrapper<_Tp> 567 ref(_Tp& __t) _NOEXCEPT 568 { 569 return reference_wrapper<_Tp>(__t); 570 } 571 572 template <class _Tp> 573 inline _LIBCPP_INLINE_VISIBILITY 574 reference_wrapper<_Tp> 575 ref(reference_wrapper<_Tp> __t) _NOEXCEPT 576 { 577 return ref(__t.get()); 578 } 579 580 template <class _Tp> 581 inline _LIBCPP_INLINE_VISIBILITY 582 reference_wrapper<const _Tp> 583 cref(const _Tp& __t) _NOEXCEPT 584 { 585 return reference_wrapper<const _Tp>(__t); 586 } 587 588 template <class _Tp> 589 inline _LIBCPP_INLINE_VISIBILITY 590 reference_wrapper<const _Tp> 591 cref(reference_wrapper<_Tp> __t) _NOEXCEPT 592 { 593 return cref(__t.get()); 594 } 595 596 #ifndef _LIBCPP_HAS_NO_VARIADICS 597 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 598 #ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS 599 600 template <class _Tp> void ref(const _Tp&&) = delete; 601 template <class _Tp> void cref(const _Tp&&) = delete; 602 603 #else // _LIBCPP_HAS_NO_DELETED_FUNCTIONS 604 605 template <class _Tp> void ref(const _Tp&&);// = delete; 606 template <class _Tp> void cref(const _Tp&&);// = delete; 607 608 #endif // _LIBCPP_HAS_NO_DELETED_FUNCTIONS 609 610 #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 611 612 #endif // _LIBCPP_HAS_NO_VARIADICS 613 614 #if _LIBCPP_STD_VER > 11 615 template <class _Tp1, class _Tp2 = void> 616 struct __is_transparent 617 { 618 private: 619 struct __two {char __lx; char __lxx;}; 620 template <class _Up> static __two __test(...); 621 template <class _Up> static char __test(typename _Up::is_transparent* = 0); 622 public: 623 static const bool value = sizeof(__test<_Tp1>(0)) == 1; 624 }; 625 #endif 626 627 // allocator_arg_t 628 629 struct _LIBCPP_TYPE_VIS_ONLY allocator_arg_t { }; 630 631 #if defined(_LIBCPP_HAS_NO_CONSTEXPR) || defined(_LIBCPP_BUILDING_MEMORY) 632 extern const allocator_arg_t allocator_arg; 633 #else 634 constexpr allocator_arg_t allocator_arg = allocator_arg_t(); 635 #endif 636 637 // uses_allocator 638 639 template <class _Tp> 640 struct __has_allocator_type 641 { 642 private: 643 struct __two {char __lx; char __lxx;}; 644 template <class _Up> static __two __test(...); 645 template <class _Up> static char __test(typename _Up::allocator_type* = 0); 646 public: 647 static const bool value = sizeof(__test<_Tp>(0)) == 1; 648 }; 649 650 template <class _Tp, class _Alloc, bool = __has_allocator_type<_Tp>::value> 651 struct __uses_allocator 652 : public integral_constant<bool, 653 is_convertible<_Alloc, typename _Tp::allocator_type>::value> 654 { 655 }; 656 657 template <class _Tp, class _Alloc> 658 struct __uses_allocator<_Tp, _Alloc, false> 659 : public false_type 660 { 661 }; 662 663 template <class _Tp, class _Alloc> 664 struct _LIBCPP_TYPE_VIS_ONLY uses_allocator 665 : public __uses_allocator<_Tp, _Alloc> 666 { 667 }; 668 669 #ifndef _LIBCPP_HAS_NO_VARIADICS 670 671 // allocator construction 672 673 template <class _Tp, class _Alloc, class ..._Args> 674 struct __uses_alloc_ctor_imp 675 { 676 static const bool __ua = uses_allocator<_Tp, _Alloc>::value; 677 static const bool __ic = 678 is_constructible<_Tp, allocator_arg_t, _Alloc, _Args...>::value; 679 static const int value = __ua ? 2 - __ic : 0; 680 }; 681 682 template <class _Tp, class _Alloc, class ..._Args> 683 struct __uses_alloc_ctor 684 : integral_constant<int, __uses_alloc_ctor_imp<_Tp, _Alloc, _Args...>::value> 685 {}; 686 687 template <class _Tp, class _Allocator, class... _Args> 688 inline _LIBCPP_INLINE_VISIBILITY 689 void __user_alloc_construct_impl (integral_constant<int, 0>, _Tp *__storage, const _Allocator &, _Args &&... __args ) 690 { 691 new (__storage) _Tp (_VSTD::forward<_Args>(__args)...); 692 } 693 694 template <class _Tp, class _Allocator, class... _Args> 695 inline _LIBCPP_INLINE_VISIBILITY 696 void __user_alloc_construct_impl (integral_constant<int, 1>, _Tp *__storage, const _Allocator &__a, _Args &&... __args ) 697 { 698 new (__storage) _Tp (allocator_arg, __a, _VSTD::forward<_Args>(__args)...); 699 } 700 701 template <class _Tp, class _Allocator, class... _Args> 702 inline _LIBCPP_INLINE_VISIBILITY 703 void __user_alloc_construct_impl (integral_constant<int, 2>, _Tp *__storage, const _Allocator &__a, _Args &&... __args ) 704 { 705 new (__storage) _Tp (_VSTD::forward<_Args>(__args)..., __a); 706 } 707 708 template <class _Tp, class _Allocator, class... _Args> 709 inline _LIBCPP_INLINE_VISIBILITY 710 void __user_alloc_construct (_Tp *__storage, const _Allocator &__a, _Args &&... __args) 711 { 712 __user_alloc_construct_impl( 713 __uses_alloc_ctor<_Tp, _Allocator>(), 714 __storage, __a, _VSTD::forward<_Args>(__args)... 715 ); 716 } 717 #endif // _LIBCPP_HAS_NO_VARIADICS 718 719 _LIBCPP_END_NAMESPACE_STD 720 721 #endif // _LIBCPP_FUNCTIONAL_BASE 722
