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