contrib/libc++/include/functional

   1 // -*- C++ -*-
   2 //===------------------------ functional ----------------------------------===//
   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
  12 #define _LIBCPP_FUNCTIONAL
  13
  14 /*
  15     functional synopsis
  16
  17 namespace std
  18 {
  19
  20 template <class Arg, class Result>
  21 struct unary_function
  22 {
  23     typedef Arg    argument_type;
  24     typedef Result result_type;
  25 };
  26
  27 template <class Arg1, class Arg2, class Result>
  28 struct 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 T>
  36 class reference_wrapper
  37     : public unary_function<T1, R> // if wrapping a unary functor
  38     : public binary_function<T1, T2, R> // if wraping a binary functor
  39 {
  40 public:
  41     // types
  42     typedef T type;
  43     typedef see below result_type; // Not always defined
  44
  45     // construct/copy/destroy
  46     reference_wrapper(T&) noexcept;
  47     reference_wrapper(T&&) = delete; // do not bind to temps
  48     reference_wrapper(const reference_wrapper<T>& x) noexcept;
  49
  50     // assignment
  51     reference_wrapper& operator=(const reference_wrapper<T>& x) noexcept;
  52
  53     // access
  54     operator T& () const noexcept;
  55     T& get() const noexcept;
  56
  57     // invoke
  58     template <class... ArgTypes>
  59       typename result_of<T(ArgTypes...)>::type
  60           operator() (ArgTypes&&...) const;
  61 };
  62
  63 template <class T> reference_wrapper<T> ref(T& t) noexcept;
  64 template <class T> void ref(const T&& t) = delete;
  65 template <class T> reference_wrapper<T> ref(reference_wrapper<T>t) noexcept;
  66
  67 template <class T> reference_wrapper<const T> cref(const T& t) noexcept;
  68 template <class T> void cref(const T&& t) = delete;
  69 template <class T> reference_wrapper<const T> cref(reference_wrapper<T> t) noexcept;
  70
  71 template <class T>
  72 struct plus : binary_function<T, T, T>
  73 {
  74     T operator()(const T& x, const T& y) const;
  75 };
  76
  77 template <class T>
  78 struct minus : binary_function<T, T, T>
  79 {
  80     T operator()(const T& x, const T& y) const;
  81 };
  82
  83 template <class T>
  84 struct multiplies : binary_function<T, T, T>
  85 {
  86     T operator()(const T& x, const T& y) const;
  87 };
  88
  89 template <class T>
  90 struct divides : binary_function<T, T, T>
  91 {
  92     T operator()(const T& x, const T& y) const;
  93 };
  94
  95 template <class T>
  96 struct modulus : binary_function<T, T, T>
  97 {
  98     T operator()(const T& x, const T& y) const;
  99 };
 100
 101 template <class T>
 102 struct negate : unary_function<T, T>
 103 {
 104     T operator()(const T& x) const;
 105 };
 106
 107 template <class T>
 108 struct equal_to : binary_function<T, T, bool>
 109 {
 110     bool operator()(const T& x, const T& y) const;
 111 };
 112
 113 template <class T>
 114 struct not_equal_to : binary_function<T, T, bool>
 115 {
 116     bool operator()(const T& x, const T& y) const;
 117 };
 118
 119 template <class T>
 120 struct greater : binary_function<T, T, bool>
 121 {
 122     bool operator()(const T& x, const T& y) const;
 123 };
 124
 125 template <class T>
 126 struct less : binary_function<T, T, bool>
 127 {
 128     bool operator()(const T& x, const T& y) const;
 129 };
 130
 131 template <class T>
 132 struct greater_equal : binary_function<T, T, bool>
 133 {
 134     bool operator()(const T& x, const T& y) const;
 135 };
 136
 137 template <class T>
 138 struct less_equal : binary_function<T, T, bool>
 139 {
 140     bool operator()(const T& x, const T& y) const;
 141 };
 142
 143 template <class T>
 144 struct logical_and : binary_function<T, T, bool>
 145 {
 146     bool operator()(const T& x, const T& y) const;
 147 };
 148
 149 template <class T>
 150 struct logical_or : binary_function<T, T, bool>
 151 {
 152     bool operator()(const T& x, const T& y) const;
 153 };
 154
 155 template <class T>
 156 struct logical_not : unary_function<T, bool>
 157 {
 158     bool operator()(const T& x) const;
 159 };
 160
 161 template <class Predicate>
 162 class unary_negate
 163     : public unary_function<typename Predicate::argument_type, bool>
 164 {
 165 public:
 166     explicit unary_negate(const Predicate& pred);
 167     bool operator()(const typename Predicate::argument_type& x) const;
 168 };
 169
 170 template <class Predicate> unary_negate<Predicate> not1(const Predicate& pred);
 171
 172 template <class Predicate>
 173 class binary_negate
 174     : public binary_function<typename Predicate::first_argument_type,
 175                              typename Predicate::second_argument_type,
 176                              bool>
 177 {
 178 public:
 179     explicit binary_negate(const Predicate& pred);
 180     bool operator()(const typename Predicate::first_argument_type& x,
 181                     const typename Predicate::second_argument_type& y) const;
 182 };
 183
 184 template <class Predicate> binary_negate<Predicate> not2(const Predicate& pred);
 185
 186 template<class T> struct is_bind_expression;
 187 template<class T> struct is_placeholder;
 188
 189 template<class Fn, class... BoundArgs>
 190   unspecified bind(Fn&&, BoundArgs&&...);
 191 template<class R, class Fn, class... BoundArgs>
 192   unspecified bind(Fn&&, BoundArgs&&...);
 193
 194 namespace placeholders {
 195   // M is the implementation-defined number of placeholders
 196   extern unspecified _1;
 197   extern unspecified _2;
 198   .
 199   .
 200   .
 201   extern unspecified _Mp;
 202 }
 203
 204 template <class Operation>
 205 class binder1st
 206     : public unary_function<typename Operation::second_argument_type,
 207                             typename Operation::result_type>
 208 {
 209 protected:
 210     Operation                               op;
 211     typename Operation::first_argument_type value;
 212 public:
 213     binder1st(const Operation& x, const typename Operation::first_argument_type y);
 214     typename Operation::result_type operator()(      typename Operation::second_argument_type& x) const;
 215     typename Operation::result_type operator()(const typename Operation::second_argument_type& x) const;
 216 };
 217
 218 template <class Operation, class T>
 219 binder1st<Operation> bind1st(const Operation& op, const T& x);
 220
 221 template <class Operation>
 222 class binder2nd
 223     : public unary_function<typename Operation::first_argument_type,
 224                             typename Operation::result_type>
 225 {
 226 protected:
 227     Operation                                op;
 228     typename Operation::second_argument_type value;
 229 public:
 230     binder2nd(const Operation& x, const typename Operation::second_argument_type y);
 231     typename Operation::result_type operator()(      typename Operation::first_argument_type& x) const;
 232     typename Operation::result_type operator()(const typename Operation::first_argument_type& x) const;
 233 };
 234
 235 template <class Operation, class T>
 236 binder2nd<Operation> bind2nd(const Operation& op, const T& x);
 237
 238 template <class Arg, class Result>
 239 class pointer_to_unary_function : public unary_function<Arg, Result>
 240 {
 241 public:
 242     explicit pointer_to_unary_function(Result (*f)(Arg));
 243     Result operator()(Arg x) const;
 244 };
 245
 246 template <class Arg, class Result>
 247 pointer_to_unary_function<Arg,Result> ptr_fun(Result (*f)(Arg));
 248
 249 template <class Arg1, class Arg2, class Result>
 250 class pointer_to_binary_function : public binary_function<Arg1, Arg2, Result>
 251 {
 252 public:
 253     explicit pointer_to_binary_function(Result (*f)(Arg1, Arg2));
 254     Result operator()(Arg1 x, Arg2 y) const;
 255 };
 256
 257 template <class Arg1, class Arg2, class Result>
 258 pointer_to_binary_function<Arg1,Arg2,Result> ptr_fun(Result (*f)(Arg1,Arg2));
 259
 260 template<class S, class T>
 261 class mem_fun_t : public unary_function<T*, S>
 262 {
 263 public:
 264     explicit mem_fun_t(S (T::*p)());
 265     S operator()(T* p) const;
 266 };
 267
 268 template<class S, class T, class A>
 269 class mem_fun1_t : public binary_function<T*, A, S>
 270 {
 271 public:
 272     explicit mem_fun1_t(S (T::*p)(A));
 273     S operator()(T* p, A x) const;
 274 };
 275
 276 template<class S, class T>          mem_fun_t<S,T>    mem_fun(S (T::*f)());
 277 template<class S, class T, class A> mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A));
 278
 279 template<class S, class T>
 280 class mem_fun_ref_t : public unary_function<T, S>
 281 {
 282 public:
 283     explicit mem_fun_ref_t(S (T::*p)());
 284     S operator()(T& p) const;
 285 };
 286
 287 template<class S, class T, class A>
 288 class mem_fun1_ref_t : public binary_function<T, A, S>
 289 {
 290 public:
 291     explicit mem_fun1_ref_t(S (T::*p)(A));
 292     S operator()(T& p, A x) const;
 293 };
 294
 295 template<class S, class T>          mem_fun_ref_t<S,T>    mem_fun_ref(S (T::*f)());
 296 template<class S, class T, class A> mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A));
 297
 298 template <class S, class T>
 299 class const_mem_fun_t : public unary_function<const T*, S>
 300 {
 301 public:
 302     explicit const_mem_fun_t(S (T::*p)() const);
 303     S operator()(const T* p) const;
 304 };
 305
 306 template <class S, class T, class A>
 307 class const_mem_fun1_t : public binary_function<const T*, A, S>
 308 {
 309 public:
 310     explicit const_mem_fun1_t(S (T::*p)(A) const);
 311     S operator()(const T* p, A x) const;
 312 };
 313
 314 template <class S, class T>          const_mem_fun_t<S,T>    mem_fun(S (T::*f)() const);
 315 template <class S, class T, class A> const_mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A) const);
 316
 317 template <class S, class T>
 318 class const_mem_fun_ref_t : public unary_function<T, S>
 319 {
 320 public:
 321     explicit const_mem_fun_ref_t(S (T::*p)() const);
 322     S operator()(const T& p) const;
 323 };
 324
 325 template <class S, class T, class A>
 326 class const_mem_fun1_ref_t : public binary_function<T, A, S>
 327 {
 328 public:
 329     explicit const_mem_fun1_ref_t(S (T::*p)(A) const);
 330     S operator()(const T& p, A x) const;
 331 };
 332
 333 template <class S, class T>          const_mem_fun_ref_t<S,T>    mem_fun_ref(S (T::*f)() const);
 334 template <class S, class T, class A> const_mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A) const);
 335
 336 template<class R, class T> unspecified mem_fn(R T::*);
 337 template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...));
 338 template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) const);
 339 template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) volatile);
 340 template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) const volatile);
 341 template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) &);
 342 template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) const &);
 343 template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) volatile &);
 344 template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) const volatile &);
 345 template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) &&);
 346 template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) const &&);
 347 template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) volatile &&);
 348 template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) const volatile &&);
 349
 350 class bad_function_call
 351     : public exception
 352 {
 353 };
 354
 355 template<class> class function; // undefined
 356
 357 template<class R, class... ArgTypes>
 358 class function<R(ArgTypes...)>
 359   : public unary_function<T1, R>      // iff sizeof...(ArgTypes) == 1 and
 360                                       // ArgTypes contains T1
 361   : public binary_function<T1, T2, R> // iff sizeof...(ArgTypes) == 2 and
 362                                       // ArgTypes contains T1 and T2
 363 {
 364 public:
 365     typedef R result_type;
 366
 367     // construct/copy/destroy:
 368     function() noexcept;
 369     function(nullptr_t) noexcept;
 370     function(const function&);
 371     function(function&&) noexcept;
 372     template<class F>
 373       function(F);
 374     template<Allocator Alloc>
 375       function(allocator_arg_t, const Alloc&) noexcept;
 376     template<Allocator Alloc>
 377       function(allocator_arg_t, const Alloc&, nullptr_t) noexcept;
 378     template<Allocator Alloc>
 379       function(allocator_arg_t, const Alloc&, const function&);
 380     template<Allocator Alloc>
 381       function(allocator_arg_t, const Alloc&, function&&);
 382     template<class F, Allocator Alloc>
 383       function(allocator_arg_t, const Alloc&, F);
 384
 385     function& operator=(const function&);
 386     function& operator=(function&&) noexcept;
 387     function& operator=(nullptr_t) noexcept;
 388     template<class F>
 389       function& operator=(F&&);
 390     template<class F>
 391       function& operator=(reference_wrapper<F>) noexcept;
 392
 393     ~function();
 394
 395     // function modifiers:
 396     void swap(function&) noexcept;
 397     template<class F, class Alloc>
 398       void assign(F&&, const Alloc&);
 399
 400     // function capacity:
 401     explicit operator bool() const noexcept;
 402
 403     // function invocation:
 404     R operator()(ArgTypes...) const;
 405
 406     // function target access:
 407     const std::type_info& target_type() const noexcept;
 408     template <typename T>       T* target() noexcept;
 409     template <typename T> const T* target() const noexcept;
 410 };
 411
 412 // Null pointer comparisons:
 413 template <class R, class ... ArgTypes>
 414   bool operator==(const function<R(ArgTypes...)>&, nullptr_t) noexcept;
 415
 416 template <class R, class ... ArgTypes>
 417   bool operator==(nullptr_t, const function<R(ArgTypes...)>&) noexcept;
 418
 419 template <class R, class ... ArgTypes>
 420   bool operator!=(const function<R(ArgTypes...)>&, nullptr_t) noexcept;
 421
 422 template <class  R, class ... ArgTypes>
 423   bool operator!=(nullptr_t, const function<R(ArgTypes...)>&) noexcept;
 424
 425 // specialized algorithms:
 426 template <class  R, class ... ArgTypes>
 427   void swap(function<R(ArgTypes...)>&, function<R(ArgTypes...)>&) noexcept;
 428
 429 template <class T> struct hash;
 430
 431 template <> struct hash<bool>;
 432 template <> struct hash<char>;
 433 template <> struct hash<signed char>;
 434 template <> struct hash<unsigned char>;
 435 template <> struct hash<char16_t>;
 436 template <> struct hash<char32_t>;
 437 template <> struct hash<wchar_t>;
 438 template <> struct hash<short>;
 439 template <> struct hash<unsigned short>;
 440 template <> struct hash<int>;
 441 template <> struct hash<unsigned int>;
 442 template <> struct hash<long>;
 443 template <> struct hash<long long>;
 444 template <> struct hash<unsigned long>;
 445 template <> struct hash<unsigned long long>;
 446
 447 template <> struct hash<float>;
 448 template <> struct hash<double>;
 449 template <> struct hash<long double>;
 450
 451 template<class T> struct hash<T*>;
 452
 453 }  // std
 454
 455 POLICY:  For non-variadic implementations, the number of arguments is limited
 456          to 3.  It is hoped that the need for non-variadic implementations
 457          will be minimal.
 458
 459 */
 460
 461 #include <__config>
 462 #include <type_traits>
 463 #include <typeinfo>
 464 #include <exception>
 465 #include <memory>
 466 #include <tuple>
 467
 468 #include <__functional_base>
 469
 470 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 471 #pragma GCC system_header
 472 #endif
 473
 474 _LIBCPP_BEGIN_NAMESPACE_STD
 475
 476 template <class _Tp>
 477 struct _LIBCPP_VISIBLE plus : binary_function<_Tp, _Tp, _Tp>
 478 {
 479     _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const
 480         {return __x + __y;}
 481 };
 482
 483 template <class _Tp>
 484 struct _LIBCPP_VISIBLE minus : binary_function<_Tp, _Tp, _Tp>
 485 {
 486     _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const
 487         {return __x - __y;}
 488 };
 489
 490 template <class _Tp>
 491 struct _LIBCPP_VISIBLE multiplies : binary_function<_Tp, _Tp, _Tp>
 492 {
 493     _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const
 494         {return __x * __y;}
 495 };
 496
 497 template <class _Tp>
 498 struct _LIBCPP_VISIBLE divides : binary_function<_Tp, _Tp, _Tp>
 499 {
 500     _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const
 501         {return __x / __y;}
 502 };
 503
 504 template <class _Tp>
 505 struct _LIBCPP_VISIBLE modulus : binary_function<_Tp, _Tp, _Tp>
 506 {
 507     _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const
 508         {return __x % __y;}
 509 };
 510
 511 template <class _Tp>
 512 struct _LIBCPP_VISIBLE negate : unary_function<_Tp, _Tp>
 513 {
 514     _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x) const
 515         {return -__x;}
 516 };
 517
 518 template <class _Tp>
 519 struct _LIBCPP_VISIBLE equal_to : binary_function<_Tp, _Tp, bool>
 520 {
 521     _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const
 522         {return __x == __y;}
 523 };
 524
 525 template <class _Tp>
 526 struct _LIBCPP_VISIBLE not_equal_to : binary_function<_Tp, _Tp, bool>
 527 {
 528     _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const
 529         {return __x != __y;}
 530 };
 531
 532 template <class _Tp>
 533 struct _LIBCPP_VISIBLE greater : binary_function<_Tp, _Tp, bool>
 534 {
 535     _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const
 536         {return __x > __y;}
 537 };
 538
 539 // less in <__functional_base>
 540
 541 template <class _Tp>
 542 struct _LIBCPP_VISIBLE greater_equal : binary_function<_Tp, _Tp, bool>
 543 {
 544     _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const
 545         {return __x >= __y;}
 546 };
 547
 548 template <class _Tp>
 549 struct _LIBCPP_VISIBLE less_equal : binary_function<_Tp, _Tp, bool>
 550 {
 551     _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const
 552         {return __x <= __y;}
 553 };
 554
 555 template <class _Tp>
 556 struct _LIBCPP_VISIBLE logical_and : binary_function<_Tp, _Tp, bool>
 557 {
 558     _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const
 559         {return __x && __y;}
 560 };
 561
 562 template <class _Tp>
 563 struct _LIBCPP_VISIBLE logical_or : binary_function<_Tp, _Tp, bool>
 564 {
 565     _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const
 566         {return __x || __y;}
 567 };
 568
 569 template <class _Tp>
 570 struct _LIBCPP_VISIBLE logical_not : unary_function<_Tp, bool>
 571 {
 572     _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x) const
 573         {return !__x;}
 574 };
 575
 576 template <class _Tp>
 577 struct _LIBCPP_VISIBLE bit_and : binary_function<_Tp, _Tp, _Tp>
 578 {
 579     _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const
 580         {return __x & __y;}
 581 };
 582
 583 template <class _Tp>
 584 struct _LIBCPP_VISIBLE bit_or : binary_function<_Tp, _Tp, _Tp>
 585 {
 586     _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const
 587         {return __x | __y;}
 588 };
 589
 590 template <class _Tp>
 591 struct _LIBCPP_VISIBLE bit_xor : binary_function<_Tp, _Tp, _Tp>
 592 {
 593     _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const
 594         {return __x ^ __y;}
 595 };
 596
 597 template <class _Predicate>
 598 class _LIBCPP_VISIBLE unary_negate
 599     : public unary_function<typename _Predicate::argument_type, bool>
 600 {
 601     _Predicate __pred_;
 602 public:
 603     _LIBCPP_INLINE_VISIBILITY explicit unary_negate(const _Predicate& __pred)
 604         : __pred_(__pred) {}
 605     _LIBCPP_INLINE_VISIBILITY bool operator()(const typename _Predicate::argument_type& __x) const
 606         {return !__pred_(__x);}
 607 };
 608
 609 template <class _Predicate>
 610 inline _LIBCPP_INLINE_VISIBILITY
 611 unary_negate<_Predicate>
 612 not1(const _Predicate& __pred) {return unary_negate<_Predicate>(__pred);}
 613
 614 template <class _Predicate>
 615 class _LIBCPP_VISIBLE binary_negate
 616     : public binary_function<typename _Predicate::first_argument_type,
 617                              typename _Predicate::second_argument_type,
 618                              bool>
 619 {
 620     _Predicate __pred_;
 621 public:
 622     _LIBCPP_INLINE_VISIBILITY explicit binary_negate(const _Predicate& __pred)
 623         : __pred_(__pred) {}
 624     _LIBCPP_INLINE_VISIBILITY bool operator()(const typename _Predicate::first_argument_type& __x,
 625                     const typename _Predicate::second_argument_type& __y) const
 626         {return !__pred_(__x, __y);}
 627 };
 628
 629 template <class _Predicate>
 630 inline _LIBCPP_INLINE_VISIBILITY
 631 binary_negate<_Predicate>
 632 not2(const _Predicate& __pred) {return binary_negate<_Predicate>(__pred);}
 633
 634 template <class __Operation>
 635 class _LIBCPP_VISIBLE binder1st
 636     : public unary_function<typename __Operation::second_argument_type,
 637                             typename __Operation::result_type>
 638 {
 639 protected:
 640     __Operation                               op;
 641     typename __Operation::first_argument_type value;
 642 public:
 643     _LIBCPP_INLINE_VISIBILITY binder1st(const __Operation& __x,
 644                                const typename __Operation::first_argument_type __y)
 645         : op(__x), value(__y) {}
 646     _LIBCPP_INLINE_VISIBILITY typename __Operation::result_type operator()
 647         (typename __Operation::second_argument_type& __x) const
 648             {return op(value, __x);}
 649     _LIBCPP_INLINE_VISIBILITY typename __Operation::result_type operator()
 650         (const typename __Operation::second_argument_type& __x) const
 651             {return op(value, __x);}
 652 };
 653
 654 template <class __Operation, class _Tp>
 655 inline _LIBCPP_INLINE_VISIBILITY
 656 binder1st<__Operation>
 657 bind1st(const __Operation& __op, const _Tp& __x)
 658     {return binder1st<__Operation>(__op, __x);}
 659
 660 template <class __Operation>
 661 class _LIBCPP_VISIBLE binder2nd
 662     : public unary_function<typename __Operation::first_argument_type,
 663                             typename __Operation::result_type>
 664 {
 665 protected:
 666     __Operation                                op;
 667     typename __Operation::second_argument_type value;
 668 public:
 669     _LIBCPP_INLINE_VISIBILITY
 670     binder2nd(const __Operation& __x, const typename __Operation::second_argument_type __y)
 671         : op(__x), value(__y) {}
 672     _LIBCPP_INLINE_VISIBILITY typename __Operation::result_type operator()
 673         (      typename __Operation::first_argument_type& __x) const
 674             {return op(__x, value);}
 675     _LIBCPP_INLINE_VISIBILITY typename __Operation::result_type operator()
 676         (const typename __Operation::first_argument_type& __x) const
 677             {return op(__x, value);}
 678 };
 679
 680 template <class __Operation, class _Tp>
 681 inline _LIBCPP_INLINE_VISIBILITY
 682 binder2nd<__Operation>
 683 bind2nd(const __Operation& __op, const _Tp& __x)
 684     {return binder2nd<__Operation>(__op, __x);}
 685
 686 template <class _Arg, class _Result>
 687 class _LIBCPP_VISIBLE pointer_to_unary_function
 688     : public unary_function<_Arg, _Result>
 689 {
 690     _Result (*__f_)(_Arg);
 691 public:
 692     _LIBCPP_INLINE_VISIBILITY explicit pointer_to_unary_function(_Result (*__f)(_Arg))
 693         : __f_(__f) {}
 694     _LIBCPP_INLINE_VISIBILITY _Result operator()(_Arg __x) const
 695         {return __f_(__x);}
 696 };
 697
 698 template <class _Arg, class _Result>
 699 inline _LIBCPP_INLINE_VISIBILITY
 700 pointer_to_unary_function<_Arg,_Result>
 701 ptr_fun(_Result (*__f)(_Arg))
 702     {return pointer_to_unary_function<_Arg,_Result>(__f);}
 703
 704 template <class _Arg1, class _Arg2, class _Result>
 705 class _LIBCPP_VISIBLE pointer_to_binary_function
 706     : public binary_function<_Arg1, _Arg2, _Result>
 707 {
 708     _Result (*__f_)(_Arg1, _Arg2);
 709 public:
 710     _LIBCPP_INLINE_VISIBILITY explicit pointer_to_binary_function(_Result (*__f)(_Arg1, _Arg2))
 711         : __f_(__f) {}
 712     _LIBCPP_INLINE_VISIBILITY _Result operator()(_Arg1 __x, _Arg2 __y) const
 713         {return __f_(__x, __y);}
 714 };
 715
 716 template <class _Arg1, class _Arg2, class _Result>
 717 inline _LIBCPP_INLINE_VISIBILITY
 718 pointer_to_binary_function<_Arg1,_Arg2,_Result>
 719 ptr_fun(_Result (*__f)(_Arg1,_Arg2))
 720     {return pointer_to_binary_function<_Arg1,_Arg2,_Result>(__f);}
 721
 722 template<class _Sp, class _Tp>
 723 class _LIBCPP_VISIBLE mem_fun_t : public unary_function<_Tp*, _Sp>
 724 {
 725     _Sp (_Tp::*__p_)();
 726 public:
 727     _LIBCPP_INLINE_VISIBILITY explicit mem_fun_t(_Sp (_Tp::*__p)())
 728         : __p_(__p) {}
 729     _LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp* __p) const
 730         {return (__p->*__p_)();}
 731 };
 732
 733 template<class _Sp, class _Tp, class _Ap>
 734 class _LIBCPP_VISIBLE mem_fun1_t : public binary_function<_Tp*, _Ap, _Sp>
 735 {
 736     _Sp (_Tp::*__p_)(_Ap);
 737 public:
 738     _LIBCPP_INLINE_VISIBILITY explicit mem_fun1_t(_Sp (_Tp::*__p)(_Ap))
 739         : __p_(__p) {}
 740     _LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp* __p, _Ap __x) const
 741         {return (__p->*__p_)(__x);}
 742 };
 743
 744 template<class _Sp, class _Tp>
 745 inline _LIBCPP_INLINE_VISIBILITY
 746 mem_fun_t<_Sp,_Tp>
 747 mem_fun(_Sp (_Tp::*__f)())
 748     {return mem_fun_t<_Sp,_Tp>(__f);}
 749
 750 template<class _Sp, class _Tp, class _Ap>
 751 inline _LIBCPP_INLINE_VISIBILITY
 752 mem_fun1_t<_Sp,_Tp,_Ap>
 753 mem_fun(_Sp (_Tp::*__f)(_Ap))
 754     {return mem_fun1_t<_Sp,_Tp,_Ap>(__f);}
 755
 756 template<class _Sp, class _Tp>
 757 class _LIBCPP_VISIBLE mem_fun_ref_t : public unary_function<_Tp, _Sp>
 758 {
 759     _Sp (_Tp::*__p_)();
 760 public:
 761     _LIBCPP_INLINE_VISIBILITY explicit mem_fun_ref_t(_Sp (_Tp::*__p)())
 762         : __p_(__p) {}
 763     _LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp& __p) const
 764         {return (__p.*__p_)();}
 765 };
 766
 767 template<class _Sp, class _Tp, class _Ap>
 768 class _LIBCPP_VISIBLE mem_fun1_ref_t : public binary_function<_Tp, _Ap, _Sp>
 769 {
 770     _Sp (_Tp::*__p_)(_Ap);
 771 public:
 772     _LIBCPP_INLINE_VISIBILITY explicit mem_fun1_ref_t(_Sp (_Tp::*__p)(_Ap))
 773         : __p_(__p) {}
 774     _LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp& __p, _Ap __x) const
 775         {return (__p.*__p_)(__x);}
 776 };
 777
 778 template<class _Sp, class _Tp>
 779 inline _LIBCPP_INLINE_VISIBILITY
 780 mem_fun_ref_t<_Sp,_Tp>
 781 mem_fun_ref(_Sp (_Tp::*__f)())
 782     {return mem_fun_ref_t<_Sp,_Tp>(__f);}
 783
 784 template<class _Sp, class _Tp, class _Ap>
 785 inline _LIBCPP_INLINE_VISIBILITY
 786 mem_fun1_ref_t<_Sp,_Tp,_Ap>
 787 mem_fun_ref(_Sp (_Tp::*__f)(_Ap))
 788     {return mem_fun1_ref_t<_Sp,_Tp,_Ap>(__f);}
 789
 790 template <class _Sp, class _Tp>
 791 class _LIBCPP_VISIBLE const_mem_fun_t : public unary_function<const _Tp*, _Sp>
 792 {
 793     _Sp (_Tp::*__p_)() const;
 794 public:
 795     _LIBCPP_INLINE_VISIBILITY explicit const_mem_fun_t(_Sp (_Tp::*__p)() const)
 796         : __p_(__p) {}
 797     _LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp* __p) const
 798         {return (__p->*__p_)();}
 799 };
 800
 801 template <class _Sp, class _Tp, class _Ap>
 802 class _LIBCPP_VISIBLE const_mem_fun1_t : public binary_function<const _Tp*, _Ap, _Sp>
 803 {
 804     _Sp (_Tp::*__p_)(_Ap) const;
 805 public:
 806     _LIBCPP_INLINE_VISIBILITY explicit const_mem_fun1_t(_Sp (_Tp::*__p)(_Ap) const)
 807         : __p_(__p) {}
 808     _LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp* __p, _Ap __x) const
 809         {return (__p->*__p_)(__x);}
 810 };
 811
 812 template <class _Sp, class _Tp>
 813 inline _LIBCPP_INLINE_VISIBILITY
 814 const_mem_fun_t<_Sp,_Tp>
 815 mem_fun(_Sp (_Tp::*__f)() const)
 816     {return const_mem_fun_t<_Sp,_Tp>(__f);}
 817
 818 template <class _Sp, class _Tp, class _Ap>
 819 inline _LIBCPP_INLINE_VISIBILITY
 820 const_mem_fun1_t<_Sp,_Tp,_Ap>
 821 mem_fun(_Sp (_Tp::*__f)(_Ap) const)
 822     {return const_mem_fun1_t<_Sp,_Tp,_Ap>(__f);}
 823
 824 template <class _Sp, class _Tp>
 825 class _LIBCPP_VISIBLE const_mem_fun_ref_t : public unary_function<_Tp, _Sp>
 826 {
 827     _Sp (_Tp::*__p_)() const;
 828 public:
 829     _LIBCPP_INLINE_VISIBILITY explicit const_mem_fun_ref_t(_Sp (_Tp::*__p)() const)
 830         : __p_(__p) {}
 831     _LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp& __p) const
 832         {return (__p.*__p_)();}
 833 };
 834
 835 template <class _Sp, class _Tp, class _Ap>
 836 class _LIBCPP_VISIBLE const_mem_fun1_ref_t
 837     : public binary_function<_Tp, _Ap, _Sp>
 838 {
 839     _Sp (_Tp::*__p_)(_Ap) const;
 840 public:
 841     _LIBCPP_INLINE_VISIBILITY explicit const_mem_fun1_ref_t(_Sp (_Tp::*__p)(_Ap) const)
 842         : __p_(__p) {}
 843     _LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp& __p, _Ap __x) const
 844         {return (__p.*__p_)(__x);}
 845 };
 846
 847 template <class _Sp, class _Tp>
 848 inline _LIBCPP_INLINE_VISIBILITY
 849 const_mem_fun_ref_t<_Sp,_Tp>
 850 mem_fun_ref(_Sp (_Tp::*__f)() const)
 851     {return const_mem_fun_ref_t<_Sp,_Tp>(__f);}
 852
 853 template <class _Sp, class _Tp, class _Ap>
 854 inline _LIBCPP_INLINE_VISIBILITY
 855 const_mem_fun1_ref_t<_Sp,_Tp,_Ap>
 856 mem_fun_ref(_Sp (_Tp::*__f)(_Ap) const)
 857     {return const_mem_fun1_ref_t<_Sp,_Tp,_Ap>(__f);}
 858
 859 #ifdef _LIBCPP_HAS_NO_VARIADICS
 860
 861 #include <__functional_03>
 862
 863 #else  // _LIBCPP_HAS_NO_VARIADICS
 864
 865 template <class _Tp>
 866 class __mem_fn
 867     : public __weak_result_type<_Tp>
 868 {
 869 public:
 870     // types
 871     typedef _Tp type;
 872 private:
 873     type __f_;
 874
 875 public:
 876     _LIBCPP_INLINE_VISIBILITY __mem_fn(type __f) : __f_(__f) {}
 877
 878     // invoke
 879     template <class... _ArgTypes>
 880        _LIBCPP_INLINE_VISIBILITY
 881        typename __invoke_return<type, _ArgTypes...>::type
 882           operator() (_ArgTypes&&... __args)
 883           {
 884               return __invoke(__f_, _VSTD::forward<_ArgTypes>(__args)...);
 885           }
 886 };
 887
 888 template<class _Rp, class _Tp>
 889 inline _LIBCPP_INLINE_VISIBILITY
 890 __mem_fn<_Rp _Tp::*>
 891 mem_fn(_Rp _Tp::* __pm)
 892 {
 893     return __mem_fn<_Rp _Tp::*>(__pm);
 894 }
 895
 896 template<class _Rp, class _Tp, class ..._Args>
 897 inline _LIBCPP_INLINE_VISIBILITY
 898 __mem_fn<_Rp (_Tp::*)(_Args...)>
 899 mem_fn(_Rp (_Tp::* __pm)(_Args...))
 900 {
 901     return __mem_fn<_Rp (_Tp::*)(_Args...)>(__pm);
 902 }
 903
 904 template<class _Rp, class _Tp, class ..._Args>
 905 inline _LIBCPP_INLINE_VISIBILITY
 906 __mem_fn<_Rp (_Tp::*)(_Args...) const>
 907 mem_fn(_Rp (_Tp::* __pm)(_Args...) const)
 908 {
 909     return __mem_fn<_Rp (_Tp::*)(_Args...) const>(__pm);
 910 }
 911
 912 template<class _Rp, class _Tp, class ..._Args>
 913 inline _LIBCPP_INLINE_VISIBILITY
 914 __mem_fn<_Rp (_Tp::*)(_Args...) volatile>
 915 mem_fn(_Rp (_Tp::* __pm)(_Args...) volatile)
 916 {
 917     return __mem_fn<_Rp (_Tp::*)(_Args...) volatile>(__pm);
 918 }
 919
 920 template<class _Rp, class _Tp, class ..._Args>
 921 inline _LIBCPP_INLINE_VISIBILITY
 922 __mem_fn<_Rp (_Tp::*)(_Args...) const volatile>
 923 mem_fn(_Rp (_Tp::* __pm)(_Args...) const volatile)
 924 {
 925     return __mem_fn<_Rp (_Tp::*)(_Args...) const volatile>(__pm);
 926 }
 927
 928 // bad_function_call
 929
 930 class _LIBCPP_EXCEPTION_ABI bad_function_call
 931     : public exception
 932 {
 933 };
 934
 935 template<class _Fp> class _LIBCPP_VISIBLE function; // undefined
 936
 937 namespace __function
 938 {
 939
 940 template<class _Rp, class ..._ArgTypes>
 941 struct __maybe_derive_from_unary_function
 942 {
 943 };
 944
 945 template<class _Rp, class _A1>
 946 struct __maybe_derive_from_unary_function<_Rp(_A1)>
 947     : public unary_function<_A1, _Rp>
 948 {
 949 };
 950
 951 template<class _Rp, class ..._ArgTypes>
 952 struct __maybe_derive_from_binary_function
 953 {
 954 };
 955
 956 template<class _Rp, class _A1, class _A2>
 957 struct __maybe_derive_from_binary_function<_Rp(_A1, _A2)>
 958     : public binary_function<_A1, _A2, _Rp>
 959 {
 960 };
 961
 962 template<class _Fp> class __base;
 963
 964 template<class _Rp, class ..._ArgTypes>
 965 class __base<_Rp(_ArgTypes...)>
 966 {
 967     __base(const __base&);
 968     __base& operator=(const __base&);
 969 public:
 970     _LIBCPP_INLINE_VISIBILITY __base() {}
 971     _LIBCPP_INLINE_VISIBILITY virtual ~__base() {}
 972     virtual __base* __clone() const = 0;
 973     virtual void __clone(__base*) const = 0;
 974     virtual void destroy() _NOEXCEPT = 0;
 975     virtual void destroy_deallocate() _NOEXCEPT = 0;
 976     virtual _Rp operator()(_ArgTypes&& ...) = 0;
 977 #ifndef _LIBCPP_NO_RTTI
 978     virtual const void* target(const type_info&) const _NOEXCEPT = 0;
 979     virtual const std::type_info& target_type() const _NOEXCEPT = 0;
 980 #endif  // _LIBCPP_NO_RTTI
 981 };
 982
 983 template<class _FD, class _Alloc, class _FB> class __func;
 984
 985 template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
 986 class __func<_Fp, _Alloc, _Rp(_ArgTypes...)>
 987     : public  __base<_Rp(_ArgTypes...)>
 988 {
 989     __compressed_pair<_Fp, _Alloc> __f_;
 990 public:
 991     _LIBCPP_INLINE_VISIBILITY
 992     explicit __func(_Fp&& __f)
 993         : __f_(piecewise_construct, _VSTD::forward_as_tuple(_VSTD::move(__f)),
 994                                     _VSTD::forward_as_tuple()) {}
 995     _LIBCPP_INLINE_VISIBILITY
 996     explicit __func(const _Fp& __f, const _Alloc& __a)
 997         : __f_(piecewise_construct, _VSTD::forward_as_tuple(__f),
 998                                     _VSTD::forward_as_tuple(__a)) {}
 999
1000     _LIBCPP_INLINE_VISIBILITY
1001     explicit __func(const _Fp& __f, _Alloc&& __a)
1002         : __f_(piecewise_construct, _VSTD::forward_as_tuple(__f),
1003                                     _VSTD::forward_as_tuple(_VSTD::move(__a))) {}
1004
1005     _LIBCPP_INLINE_VISIBILITY
1006     explicit __func(_Fp&& __f, _Alloc&& __a)
1007         : __f_(piecewise_construct, _VSTD::forward_as_tuple(_VSTD::move(__f)),
1008                                     _VSTD::forward_as_tuple(_VSTD::move(__a))) {}
1009     virtual __base<_Rp(_ArgTypes...)>* __clone() const;
1010     virtual void __clone(__base<_Rp(_ArgTypes...)>*) const;
1011     virtual void destroy() _NOEXCEPT;
1012     virtual void destroy_deallocate() _NOEXCEPT;
1013     virtual _Rp operator()(_ArgTypes&& ... __arg);
1014 #ifndef _LIBCPP_NO_RTTI
1015     virtual const void* target(const type_info&) const _NOEXCEPT;
1016     virtual const std::type_info& target_type() const _NOEXCEPT;
1017 #endif  // _LIBCPP_NO_RTTI
1018 };
1019
1020 template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
1021 __base<_Rp(_ArgTypes...)>*
1022 __func<_Fp, _Alloc, _Rp(_ArgTypes...)>::__clone() const
1023 {
1024     typedef typename _Alloc::template rebind<__func>::other _Ap;
1025     _Ap __a(__f_.second());
1026     typedef __allocator_destructor<_Ap> _Dp;
1027     unique_ptr<__func, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
1028     ::new (__hold.get()) __func(__f_.first(), _Alloc(__a));
1029     return __hold.release();
1030 }
1031
1032 template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
1033 void
1034 __func<_Fp, _Alloc, _Rp(_ArgTypes...)>::__clone(__base<_Rp(_ArgTypes...)>* __p) const
1035 {
1036     ::new (__p) __func(__f_.first(), __f_.second());
1037 }
1038
1039 template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
1040 void
1041 __func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy() _NOEXCEPT
1042 {
1043     __f_.~__compressed_pair<_Fp, _Alloc>();
1044 }
1045
1046 template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
1047 void
1048 __func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy_deallocate() _NOEXCEPT
1049 {
1050     typedef typename _Alloc::template rebind<__func>::other _Ap;
1051     _Ap __a(__f_.second());
1052     __f_.~__compressed_pair<_Fp, _Alloc>();
1053     __a.deallocate(this, 1);
1054 }
1055
1056 template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
1057 _Rp
1058 __func<_Fp, _Alloc, _Rp(_ArgTypes...)>::operator()(_ArgTypes&& ... __arg)
1059 {
1060     return __invoke(__f_.first(), _VSTD::forward<_ArgTypes>(__arg)...);
1061 }
1062
1063 #ifndef _LIBCPP_NO_RTTI
1064
1065 template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
1066 const void*
1067 __func<_Fp, _Alloc, _Rp(_ArgTypes...)>::target(const type_info& __ti) const _NOEXCEPT
1068 {
1069     if (__ti == typeid(_Fp))
1070         return &__f_.first();
1071     return (const void*)0;
1072 }
1073
1074 template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
1075 const std::type_info&
1076 __func<_Fp, _Alloc, _Rp(_ArgTypes...)>::target_type() const _NOEXCEPT
1077 {
1078     return typeid(_Fp);
1079 }
1080
1081 #endif  // _LIBCPP_NO_RTTI
1082
1083 }  // __function
1084
1085 template<class _Rp, class ..._ArgTypes>
1086 class _LIBCPP_VISIBLE function<_Rp(_ArgTypes...)>
1087     : public __function::__maybe_derive_from_unary_function<_Rp(_ArgTypes...)>,
1088       public __function::__maybe_derive_from_binary_function<_Rp(_ArgTypes...)>
1089 {
1090     typedef __function::__base<_Rp(_ArgTypes...)> __base;
1091     aligned_storage<3*sizeof(void*)>::type __buf_;
1092     __base* __f_;
1093
1094     template <class _Fp>
1095         _LIBCPP_INLINE_VISIBILITY
1096         static bool __not_null(const _Fp&) {return true;}
1097     template <class _R2, class ..._Ap>
1098         _LIBCPP_INLINE_VISIBILITY
1099         static bool __not_null(_R2 (*__p)(_Ap...)) {return __p;}
1100     template <class _R2, class _Cp, class ..._Ap>
1101         _LIBCPP_INLINE_VISIBILITY
1102         static bool __not_null(_R2 (_Cp::*__p)(_Ap...)) {return __p;}
1103     template <class _R2, class _Cp, class ..._Ap>
1104         _LIBCPP_INLINE_VISIBILITY
1105         static bool __not_null(_R2 (_Cp::*__p)(_Ap...) const) {return __p;}
1106     template <class _R2, class _Cp, class ..._Ap>
1107         _LIBCPP_INLINE_VISIBILITY
1108         static bool __not_null(_R2 (_Cp::*__p)(_Ap...) volatile) {return __p;}
1109     template <class _R2, class _Cp, class ..._Ap>
1110         _LIBCPP_INLINE_VISIBILITY
1111         static bool __not_null(_R2 (_Cp::*__p)(_Ap...) const volatile) {return __p;}
1112     template <class _R2, class ..._Ap>
1113         _LIBCPP_INLINE_VISIBILITY
1114         static bool __not_null(const function<_Rp(_Ap...)>& __p) {return __p;}
1115
1116     template <class _Fp, bool = __invokable<_Fp&, _ArgTypes...>::value>
1117         struct __callable;
1118     template <class _Fp>
1119         struct __callable<_Fp, true>
1120         {
1121             static const bool value =
1122                 is_convertible<typename __invoke_of<_Fp&, _ArgTypes...>::type,
1123                                _Rp>::value;
1124         };
1125     template <class _Fp>
1126         struct __callable<_Fp, false>
1127         {
1128             static const bool value = false;
1129         };
1130 public:
1131     typedef _Rp result_type;
1132
1133     // construct/copy/destroy:
1134     _LIBCPP_INLINE_VISIBILITY
1135     function() _NOEXCEPT : __f_(0) {}
1136     _LIBCPP_INLINE_VISIBILITY
1137     function(nullptr_t) _NOEXCEPT : __f_(0) {}
1138     function(const function&);
1139     function(function&&) _NOEXCEPT;
1140     template<class _Fp>
1141       function(_Fp,
1142                typename enable_if<__callable<_Fp>::value>::type* = 0);
1143
1144     template<class _Alloc>
1145       _LIBCPP_INLINE_VISIBILITY
1146       function(allocator_arg_t, const _Alloc&) _NOEXCEPT : __f_(0) {}
1147     template<class _Alloc>
1148       _LIBCPP_INLINE_VISIBILITY
1149       function(allocator_arg_t, const _Alloc&, nullptr_t) _NOEXCEPT : __f_(0) {}
1150     template<class _Alloc>
1151       function(allocator_arg_t, const _Alloc&, const function&);
1152     template<class _Alloc>
1153       function(allocator_arg_t, const _Alloc&, function&&);
1154     template<class _Fp, class _Alloc>
1155       function(allocator_arg_t, const _Alloc& __a, _Fp __f,
1156                typename enable_if<__callable<_Fp>::value>::type* = 0);
1157
1158     function& operator=(const function&);
1159     function& operator=(function&&) _NOEXCEPT;
1160     function& operator=(nullptr_t) _NOEXCEPT;
1161     template<class _Fp>
1162       typename enable_if
1163       <
1164         __callable<typename decay<_Fp>::type>::value,
1165         function&
1166       >::type
1167       operator=(_Fp&&);
1168
1169     ~function();
1170
1171     // function modifiers:
1172     void swap(function&) _NOEXCEPT;
1173     template<class _Fp, class _Alloc>
1174       _LIBCPP_INLINE_VISIBILITY
1175       void assign(_Fp&& __f, const _Alloc& __a)
1176         {function(allocator_arg, __a, _VSTD::forward<_Fp>(__f)).swap(*this);}
1177
1178     // function capacity:
1179     _LIBCPP_INLINE_VISIBILITY
1180         _LIBCPP_EXPLICIT operator bool() const _NOEXCEPT {return __f_;}
1181
1182     // deleted overloads close possible hole in the type system
1183     template<class _R2, class... _ArgTypes2>
1184       bool operator==(const function<_R2(_ArgTypes2...)>&) const = delete;
1185     template<class _R2, class... _ArgTypes2>
1186       bool operator!=(const function<_R2(_ArgTypes2...)>&) const = delete;
1187 public:
1188     // function invocation:
1189     _Rp operator()(_ArgTypes...) const;
1190
1191 #ifndef _LIBCPP_NO_RTTI
1192     // function target access:
1193     const std::type_info& target_type() const _NOEXCEPT;
1194     template <typename _Tp> _Tp* target() _NOEXCEPT;
1195     template <typename _Tp> const _Tp* target() const _NOEXCEPT;
1196 #endif  // _LIBCPP_NO_RTTI
1197 };
1198
1199 template<class _Rp, class ..._ArgTypes>
1200 function<_Rp(_ArgTypes...)>::function(const function& __f)
1201 {
1202     if (__f.__f_ == 0)
1203         __f_ = 0;
1204     else if (__f.__f_ == (const __base*)&__f.__buf_)
1205     {
1206         __f_ = (__base*)&__buf_;
1207         __f.__f_->__clone(__f_);
1208     }
1209     else
1210         __f_ = __f.__f_->__clone();
1211 }
1212
1213 template<class _Rp, class ..._ArgTypes>
1214 template <class _Alloc>
1215 function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc&,
1216                                      const function& __f)
1217 {
1218     if (__f.__f_ == 0)
1219         __f_ = 0;
1220     else if (__f.__f_ == (const __base*)&__f.__buf_)
1221     {
1222         __f_ = (__base*)&__buf_;
1223         __f.__f_->__clone(__f_);
1224     }
1225     else
1226         __f_ = __f.__f_->__clone();
1227 }
1228
1229 template<class _Rp, class ..._ArgTypes>
1230 function<_Rp(_ArgTypes...)>::function(function&& __f) _NOEXCEPT
1231 {
1232     if (__f.__f_ == 0)
1233         __f_ = 0;
1234     else if (__f.__f_ == (__base*)&__f.__buf_)
1235     {
1236         __f_ = (__base*)&__buf_;
1237         __f.__f_->__clone(__f_);
1238     }
1239     else
1240     {
1241         __f_ = __f.__f_;
1242         __f.__f_ = 0;
1243     }
1244 }
1245
1246 template<class _Rp, class ..._ArgTypes>
1247 template <class _Alloc>
1248 function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc&,
1249                                      function&& __f)
1250 {
1251     if (__f.__f_ == 0)
1252         __f_ = 0;
1253     else if (__f.__f_ == (__base*)&__f.__buf_)
1254     {
1255         __f_ = (__base*)&__buf_;
1256         __f.__f_->__clone(__f_);
1257     }
1258     else
1259     {
1260         __f_ = __f.__f_;
1261         __f.__f_ = 0;
1262     }
1263 }
1264
1265 template<class _Rp, class ..._ArgTypes>
1266 template <class _Fp>
1267 function<_Rp(_ArgTypes...)>::function(_Fp __f,
1268                                      typename enable_if<__callable<_Fp>::value>::type*)
1269     : __f_(0)
1270 {
1271     if (__not_null(__f))
1272     {
1273         typedef __function::__func<_Fp, allocator<_Fp>, _Rp(_ArgTypes...)> _FF;
1274         if (sizeof(_FF) <= sizeof(__buf_) && is_nothrow_copy_constructible<_Fp>::value)
1275         {
1276             __f_ = (__base*)&__buf_;
1277             ::new (__f_) _FF(_VSTD::move(__f));
1278         }
1279         else
1280         {
1281             typedef allocator<_FF> _Ap;
1282             _Ap __a;
1283             typedef __allocator_destructor<_Ap> _Dp;
1284             unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
1285             ::new (__hold.get()) _FF(_VSTD::move(__f), allocator<_Fp>(__a));
1286             __f_ = __hold.release();
1287         }
1288     }
1289 }
1290
1291 template<class _Rp, class ..._ArgTypes>
1292 template <class _Fp, class _Alloc>
1293 function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc& __a0, _Fp __f,
1294                                      typename enable_if<__callable<_Fp>::value>::type*)
1295     : __f_(0)
1296 {
1297     typedef allocator_traits<_Alloc> __alloc_traits;
1298     if (__not_null(__f))
1299     {
1300         typedef __function::__func<_Fp, _Alloc, _Rp(_ArgTypes...)> _FF;
1301         if (sizeof(_FF) <= sizeof(__buf_) && is_nothrow_copy_constructible<_Fp>::value)
1302         {
1303             __f_ = (__base*)&__buf_;
1304             ::new (__f_) _FF(_VSTD::move(__f));
1305         }
1306         else
1307         {
1308             typedef typename __alloc_traits::template
1309 #ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
1310                 rebind_alloc<_FF>
1311 #else
1312                 rebind_alloc<_FF>::other
1313 #endif
1314                                                          _Ap;
1315             _Ap __a(__a0);
1316             typedef __allocator_destructor<_Ap> _Dp;
1317             unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
1318             ::new (__hold.get()) _FF(_VSTD::move(__f), _Alloc(__a));
1319             __f_ = __hold.release();
1320         }
1321     }
1322 }
1323
1324 template<class _Rp, class ..._ArgTypes>
1325 function<_Rp(_ArgTypes...)>&
1326 function<_Rp(_ArgTypes...)>::operator=(const function& __f)
1327 {
1328     function(__f).swap(*this);
1329     return *this;
1330 }
1331
1332 template<class _Rp, class ..._ArgTypes>
1333 function<_Rp(_ArgTypes...)>&
1334 function<_Rp(_ArgTypes...)>::operator=(function&& __f) _NOEXCEPT
1335 {
1336     if (__f_ == (__base*)&__buf_)
1337         __f_->destroy();
1338     else if (__f_)
1339         __f_->destroy_deallocate();
1340     __f_ = 0;
1341     if (__f.__f_ == 0)
1342         __f_ = 0;
1343     else if (__f.__f_ == (__base*)&__f.__buf_)
1344     {
1345         __f_ = (__base*)&__buf_;
1346         __f.__f_->__clone(__f_);
1347     }
1348     else
1349     {
1350         __f_ = __f.__f_;
1351         __f.__f_ = 0;
1352     }
1353 }
1354
1355 template<class _Rp, class ..._ArgTypes>
1356 function<_Rp(_ArgTypes...)>&
1357 function<_Rp(_ArgTypes...)>::operator=(nullptr_t) _NOEXCEPT
1358 {
1359     if (__f_ == (__base*)&__buf_)
1360         __f_->destroy();
1361     else if (__f_)
1362         __f_->destroy_deallocate();
1363     __f_ = 0;
1364 }
1365
1366 template<class _Rp, class ..._ArgTypes>
1367 template <class _Fp>
1368 typename enable_if
1369 <
1370     function<_Rp(_ArgTypes...)>::template __callable<typename decay<_Fp>::type>::value,
1371     function<_Rp(_ArgTypes...)>&
1372 >::type
1373 function<_Rp(_ArgTypes...)>::operator=(_Fp&& __f)
1374 {
1375     function(_VSTD::forward<_Fp>(__f)).swap(*this);
1376     return *this;
1377 }
1378
1379 template<class _Rp, class ..._ArgTypes>
1380 function<_Rp(_ArgTypes...)>::~function()
1381 {
1382     if (__f_ == (__base*)&__buf_)
1383         __f_->destroy();
1384     else if (__f_)
1385         __f_->destroy_deallocate();
1386 }
1387
1388 template<class _Rp, class ..._ArgTypes>
1389 void
1390 function<_Rp(_ArgTypes...)>::swap(function& __f) _NOEXCEPT
1391 {
1392     if (__f_ == (__base*)&__buf_ && __f.__f_ == (__base*)&__f.__buf_)
1393     {
1394         typename aligned_storage<sizeof(__buf_)>::type __tempbuf;
1395         __base* __t = (__base*)&__tempbuf;
1396         __f_->__clone(__t);
1397         __f_->destroy();
1398         __f_ = 0;
1399         __f.__f_->__clone((__base*)&__buf_);
1400         __f.__f_->destroy();
1401         __f.__f_ = 0;
1402         __f_ = (__base*)&__buf_;
1403         __t->__clone((__base*)&__f.__buf_);
1404         __t->destroy();
1405         __f.__f_ = (__base*)&__f.__buf_;
1406     }
1407     else if (__f_ == (__base*)&__buf_)
1408     {
1409         __f_->__clone((__base*)&__f.__buf_);
1410         __f_->destroy();
1411         __f_ = __f.__f_;
1412         __f.__f_ = (__base*)&__f.__buf_;
1413     }
1414     else if (__f.__f_ == (__base*)&__f.__buf_)
1415     {
1416         __f.__f_->__clone((__base*)&__buf_);
1417         __f.__f_->destroy();
1418         __f.__f_ = __f_;
1419         __f_ = (__base*)&__buf_;
1420     }
1421     else
1422         _VSTD::swap(__f_, __f.__f_);
1423 }
1424
1425 template<class _Rp, class ..._ArgTypes>
1426 _Rp
1427 function<_Rp(_ArgTypes...)>::operator()(_ArgTypes... __arg) const
1428 {
1429 #ifndef _LIBCPP_NO_EXCEPTIONS
1430     if (__f_ == 0)
1431         throw bad_function_call();
1432 #endif  // _LIBCPP_NO_EXCEPTIONS
1433     return (*__f_)(_VSTD::forward<_ArgTypes>(__arg)...);
1434 }
1435
1436 #ifndef _LIBCPP_NO_RTTI
1437
1438 template<class _Rp, class ..._ArgTypes>
1439 const std::type_info&
1440 function<_Rp(_ArgTypes...)>::target_type() const _NOEXCEPT
1441 {
1442     if (__f_ == 0)
1443         return typeid(void);
1444     return __f_->target_type();
1445 }
1446
1447 template<class _Rp, class ..._ArgTypes>
1448 template <typename _Tp>
1449 _Tp*
1450 function<_Rp(_ArgTypes...)>::target() _NOEXCEPT
1451 {
1452     if (__f_ == 0)
1453         return (_Tp*)0;
1454     return (_Tp*)__f_->target(typeid(_Tp));
1455 }
1456
1457 template<class _Rp, class ..._ArgTypes>
1458 template <typename _Tp>
1459 const _Tp*
1460 function<_Rp(_ArgTypes...)>::target() const _NOEXCEPT
1461 {
1462     if (__f_ == 0)
1463         return (const _Tp*)0;
1464     return (const _Tp*)__f_->target(typeid(_Tp));
1465 }
1466
1467 #endif  // _LIBCPP_NO_RTTI
1468
1469 template <class _Rp, class... _ArgTypes>
1470 inline _LIBCPP_INLINE_VISIBILITY
1471 bool
1472 operator==(const function<_Rp(_ArgTypes...)>& __f, nullptr_t) _NOEXCEPT {return !__f;}
1473
1474 template <class _Rp, class... _ArgTypes>
1475 inline _LIBCPP_INLINE_VISIBILITY
1476 bool
1477 operator==(nullptr_t, const function<_Rp(_ArgTypes...)>& __f) _NOEXCEPT {return !__f;}
1478
1479 template <class _Rp, class... _ArgTypes>
1480 inline _LIBCPP_INLINE_VISIBILITY
1481 bool
1482 operator!=(const function<_Rp(_ArgTypes...)>& __f, nullptr_t) _NOEXCEPT {return (bool)__f;}
1483
1484 template <class _Rp, class... _ArgTypes>
1485 inline _LIBCPP_INLINE_VISIBILITY
1486 bool
1487 operator!=(nullptr_t, const function<_Rp(_ArgTypes...)>& __f) _NOEXCEPT {return (bool)__f;}
1488
1489 template <class _Rp, class... _ArgTypes>
1490 inline _LIBCPP_INLINE_VISIBILITY
1491 void
1492 swap(function<_Rp(_ArgTypes...)>& __x, function<_Rp(_ArgTypes...)>& __y) _NOEXCEPT
1493 {return __x.swap(__y);}
1494
1495 template<class _Tp> struct __is_bind_expression : public false_type {};
1496 template<class _Tp> struct _LIBCPP_VISIBLE is_bind_expression
1497     : public __is_bind_expression<typename remove_cv<_Tp>::type> {};
1498
1499 template<class _Tp> struct __is_placeholder : public integral_constant<int, 0> {};
1500 template<class _Tp> struct _LIBCPP_VISIBLE is_placeholder
1501     : public __is_placeholder<typename remove_cv<_Tp>::type> {};
1502
1503 namespace placeholders
1504 {
1505
1506 template <int _Np> struct __ph {};
1507
1508 extern __ph<1>   _1;
1509 extern __ph<2>   _2;
1510 extern __ph<3>   _3;
1511 extern __ph<4>   _4;
1512 extern __ph<5>   _5;
1513 extern __ph<6>   _6;
1514 extern __ph<7>   _7;
1515 extern __ph<8>   _8;
1516 extern __ph<9>   _9;
1517 extern __ph<10> _10;
1518
1519 }  // placeholders
1520
1521 template<int _Np>
1522 struct __is_placeholder<placeholders::__ph<_Np> >
1523     : public integral_constant<int, _Np> {};
1524
1525 template <class _Tp, class _Uj>
1526 inline _LIBCPP_INLINE_VISIBILITY
1527 _Tp&
1528 __mu(reference_wrapper<_Tp> __t, _Uj&)
1529 {
1530     return __t.get();
1531 }
1532
1533 template <class _Ti, class ..._Uj, size_t ..._Indx>
1534 inline _LIBCPP_INLINE_VISIBILITY
1535 typename __invoke_of<_Ti&, _Uj...>::type
1536 __mu_expand(_Ti& __ti, tuple<_Uj...>& __uj, __tuple_indices<_Indx...>)
1537 {
1538     return __ti(_VSTD::forward<_Uj>(get<_Indx>(__uj))...);
1539 }
1540
1541 template <class _Ti, class ..._Uj>
1542 inline _LIBCPP_INLINE_VISIBILITY
1543 typename enable_if
1544 <
1545     is_bind_expression<_Ti>::value,
1546     typename __invoke_of<_Ti&, _Uj...>::type
1547 >::type
1548 __mu(_Ti& __ti, tuple<_Uj...>& __uj)
1549 {
1550     typedef typename __make_tuple_indices<sizeof...(_Uj)>::type __indices;
1551     return  __mu_expand(__ti, __uj, __indices());
1552 }
1553
1554 template <bool IsPh, class _Ti, class _Uj>
1555 struct __mu_return2 {};
1556
1557 template <class _Ti, class _Uj>
1558 struct __mu_return2<true, _Ti, _Uj>
1559 {
1560     typedef typename tuple_element<is_placeholder<_Ti>::value - 1, _Uj>::type type;
1561 };
1562
1563 template <class _Ti, class _Uj>
1564 inline _LIBCPP_INLINE_VISIBILITY
1565 typename enable_if
1566 <
1567     0 < is_placeholder<_Ti>::value,
1568     typename __mu_return2<0 < is_placeholder<_Ti>::value, _Ti, _Uj>::type
1569 >::type
1570 __mu(_Ti&, _Uj& __uj)
1571 {
1572     const size_t _Indx = is_placeholder<_Ti>::value - 1;
1573     return _VSTD::forward<typename tuple_element<_Indx, _Uj>::type>(get<_Indx>(__uj));
1574 }
1575
1576 template <class _Ti, class _Uj>
1577 inline _LIBCPP_INLINE_VISIBILITY
1578 typename enable_if
1579 <
1580     !is_bind_expression<_Ti>::value &&
1581     is_placeholder<_Ti>::value == 0 &&
1582     !__is_reference_wrapper<_Ti>::value,
1583     _Ti&
1584 >::type
1585 __mu(_Ti& __ti, _Uj&)
1586 {
1587     return __ti;
1588 }
1589
1590 template <class _Ti, bool IsReferenceWrapper, bool IsBindEx, bool IsPh,
1591           class _TupleUj>
1592 struct ____mu_return;
1593
1594 template <class _Ti, class ..._Uj>
1595 struct ____mu_return<_Ti, false, true, false, tuple<_Uj...> >
1596 {
1597     typedef typename __invoke_of<_Ti&, _Uj...>::type type;
1598 };
1599
1600 template <class _Ti, class _TupleUj>
1601 struct ____mu_return<_Ti, false, false, true, _TupleUj>
1602 {
1603     typedef typename tuple_element<is_placeholder<_Ti>::value - 1,
1604                                    _TupleUj>::type&& type;
1605 };
1606
1607 template <class _Ti, class _TupleUj>
1608 struct ____mu_return<_Ti, true, false, false, _TupleUj>
1609 {
1610     typedef typename _Ti::type& type;
1611 };
1612
1613 template <class _Ti, class _TupleUj>
1614 struct ____mu_return<_Ti, false, false, false, _TupleUj>
1615 {
1616     typedef _Ti& type;
1617 };
1618
1619 template <class _Ti, class _TupleUj>
1620 struct __mu_return
1621     : public ____mu_return<_Ti,
1622                            __is_reference_wrapper<_Ti>::value,
1623                            is_bind_expression<_Ti>::value,
1624                            0 < is_placeholder<_Ti>::value,
1625                            _TupleUj>
1626 {
1627 };
1628
1629 template <class _Fp, class _BoundArgs, class _TupleUj>
1630 struct __bind_return;
1631
1632 template <class _Fp, class ..._BoundArgs, class _TupleUj>
1633 struct __bind_return<_Fp, tuple<_BoundArgs...>, _TupleUj>
1634 {
1635     typedef typename __invoke_of
1636     <
1637         _Fp&,
1638         typename __mu_return
1639         <
1640             _BoundArgs,
1641             _TupleUj
1642         >::type...
1643     >::type type;
1644 };
1645
1646 template <class _Fp, class ..._BoundArgs, class _TupleUj>
1647 struct __bind_return<_Fp, const tuple<_BoundArgs...>, _TupleUj>
1648 {
1649     typedef typename __invoke_of
1650     <
1651         _Fp&,
1652         typename __mu_return
1653         <
1654             const _BoundArgs,
1655             _TupleUj
1656         >::type...
1657     >::type type;
1658 };
1659
1660 template <class _Fp, class _BoundArgs, size_t ..._Indx, class _Args>
1661 inline _LIBCPP_INLINE_VISIBILITY
1662 typename __bind_return<_Fp, _BoundArgs, _Args>::type
1663 __apply_functor(_Fp& __f, _BoundArgs& __bound_args, __tuple_indices<_Indx...>,
1664                 _Args&& __args)
1665 {
1666     return __invoke(__f, __mu(get<_Indx>(__bound_args), __args)...);
1667 }
1668
1669 template<class _Fp, class ..._BoundArgs>
1670 class __bind
1671     : public __weak_result_type<typename decay<_Fp>::type>
1672 {
1673     typedef typename decay<_Fp>::type _Fd;
1674     typedef tuple<typename decay<_BoundArgs>::type...> _Td;
1675     _Fd __f_;
1676     _Td __bound_args_;
1677
1678     typedef typename __make_tuple_indices<sizeof...(_BoundArgs)>::type __indices;
1679 public:
1680 #ifdef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
1681
1682     _LIBCPP_INLINE_VISIBILITY
1683     __bind(const __bind& __b)
1684         : __f_(__b.__f_),
1685           __bound_args_(__b.__bound_args_) {}
1686
1687     _LIBCPP_INLINE_VISIBILITY
1688     __bind& operator=(const __bind& __b)
1689     {
1690         __f_ = __b.__f_;
1691         __bound_args_ = __b.__bound_args_;
1692         return *this;
1693     }
1694
1695     _LIBCPP_INLINE_VISIBILITY
1696     __bind(__bind&& __b)
1697         : __f_(_VSTD::move(__b.__f_)),
1698           __bound_args_(_VSTD::move(__b.__bound_args_)) {}
1699
1700     _LIBCPP_INLINE_VISIBILITY
1701     __bind& operator=(__bind&& __b)
1702     {
1703         __f_ = _VSTD::move(__b.__f_);
1704         __bound_args_ = _VSTD::move(__b.__bound_args_);
1705         return *this;
1706     }
1707
1708 #endif  // _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
1709
1710     template <class _Gp, class ..._BA>
1711       _LIBCPP_INLINE_VISIBILITY
1712       explicit __bind(_Gp&& __f, _BA&& ...__bound_args)
1713         : __f_(_VSTD::forward<_Gp>(__f)),
1714           __bound_args_(_VSTD::forward<_BA>(__bound_args)...) {}
1715
1716     template <class ..._Args>
1717         _LIBCPP_INLINE_VISIBILITY
1718         typename __bind_return<_Fd, _Td, tuple<_Args&&...> >::type
1719         operator()(_Args&& ...__args)
1720         {
1721             return __apply_functor(__f_, __bound_args_, __indices(),
1722                                   tuple<_Args&&...>(_VSTD::forward<_Args>(__args)...));
1723         }
1724
1725     template <class ..._Args>
1726         _LIBCPP_INLINE_VISIBILITY
1727         typename __bind_return<_Fd, _Td, tuple<_Args&&...> >::type
1728         operator()(_Args&& ...__args) const
1729         {
1730             return __apply_functor(__f_, __bound_args_, __indices(),
1731                                    tuple<_Args&&...>(_VSTD::forward<_Args>(__args)...));
1732         }
1733 };
1734
1735 template<class _Fp, class ..._BoundArgs>
1736 struct __is_bind_expression<__bind<_Fp, _BoundArgs...> > : public true_type {};
1737
1738 template<class _Rp, class _Fp, class ..._BoundArgs>
1739 class __bind_r
1740     : public __bind<_Fp, _BoundArgs...>
1741 {
1742     typedef __bind<_Fp, _BoundArgs...> base;
1743 public:
1744     typedef _Rp result_type;
1745
1746 #ifdef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
1747
1748     _LIBCPP_INLINE_VISIBILITY
1749     __bind_r(const __bind_r& __b)
1750         : base(_VSTD::forward<const base&>(__b)) {}
1751
1752     _LIBCPP_INLINE_VISIBILITY
1753     __bind_r& operator=(const __bind_r& __b)
1754     {
1755         base::operator=(_VSTD::forward<const base&>(__b));
1756         return *this;
1757     }
1758
1759     _LIBCPP_INLINE_VISIBILITY
1760     __bind_r(__bind_r&& __b)
1761         : base(_VSTD::forward<base>(__b)) {}
1762
1763     _LIBCPP_INLINE_VISIBILITY
1764     __bind_r& operator=(__bind_r&& __b)
1765     {
1766         base::operator=(_VSTD::forward<base>(__b));
1767         return *this;
1768     }
1769
1770 #endif  // _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
1771
1772     template <class _Gp, class ..._BA>
1773       _LIBCPP_INLINE_VISIBILITY
1774       explicit __bind_r(_Gp&& __f, _BA&& ...__bound_args)
1775         : base(_VSTD::forward<_Gp>(__f),
1776                _VSTD::forward<_BA>(__bound_args)...) {}
1777
1778     template <class ..._Args>
1779         _LIBCPP_INLINE_VISIBILITY
1780         result_type
1781         operator()(_Args&& ...__args)
1782         {
1783             return base::operator()(_VSTD::forward<_Args>(__args)...);
1784         }
1785
1786     template <class ..._Args>
1787         _LIBCPP_INLINE_VISIBILITY
1788         result_type
1789         operator()(_Args&& ...__args) const
1790         {
1791             return base::operator()(_VSTD::forward<_Args>(__args)...);
1792         }
1793 };
1794
1795 template<class _Rp, class _Fp, class ..._BoundArgs>
1796 struct __is_bind_expression<__bind_r<_Rp, _Fp, _BoundArgs...> > : public true_type {};
1797
1798 template<class _Fp, class ..._BoundArgs>
1799 inline _LIBCPP_INLINE_VISIBILITY
1800 __bind<_Fp, _BoundArgs...>
1801 bind(_Fp&& __f, _BoundArgs&&... __bound_args)
1802 {
1803     typedef __bind<_Fp, _BoundArgs...> type;
1804     return type(_VSTD::forward<_Fp>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...);
1805 }
1806
1807 template<class _Rp, class _Fp, class ..._BoundArgs>
1808 inline _LIBCPP_INLINE_VISIBILITY
1809 __bind_r<_Rp, _Fp, _BoundArgs...>
1810 bind(_Fp&& __f, _BoundArgs&&... __bound_args)
1811 {
1812     typedef __bind_r<_Rp, _Fp, _BoundArgs...> type;
1813     return type(_VSTD::forward<_Fp>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...);
1814 }
1815
1816 #endif  // _LIBCPP_HAS_NO_VARIADICS
1817
1818 template <>
1819 struct _LIBCPP_VISIBLE hash<bool>
1820     : public unary_function<bool, size_t>
1821 {
1822     _LIBCPP_INLINE_VISIBILITY
1823     size_t operator()(bool __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
1824 };
1825
1826 template <>
1827 struct _LIBCPP_VISIBLE hash<char>
1828     : public unary_function<char, size_t>
1829 {
1830     _LIBCPP_INLINE_VISIBILITY
1831     size_t operator()(char __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
1832 };
1833
1834 template <>
1835 struct _LIBCPP_VISIBLE hash<signed char>
1836     : public unary_function<signed char, size_t>
1837 {
1838     _LIBCPP_INLINE_VISIBILITY
1839     size_t operator()(signed char __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
1840 };
1841
1842 template <>
1843 struct _LIBCPP_VISIBLE hash<unsigned char>
1844     : public unary_function<unsigned char, size_t>
1845 {
1846     _LIBCPP_INLINE_VISIBILITY
1847     size_t operator()(unsigned char __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
1848 };
1849
1850 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
1851
1852 template <>
1853 struct _LIBCPP_VISIBLE hash<char16_t>
1854     : public unary_function<char16_t, size_t>
1855 {
1856     _LIBCPP_INLINE_VISIBILITY
1857     size_t operator()(char16_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
1858 };
1859
1860 template <>
1861 struct _LIBCPP_VISIBLE hash<char32_t>
1862     : public unary_function<char32_t, size_t>
1863 {
1864     _LIBCPP_INLINE_VISIBILITY
1865     size_t operator()(char32_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
1866 };
1867
1868 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
1869
1870 template <>
1871 struct _LIBCPP_VISIBLE hash<wchar_t>
1872     : public unary_function<wchar_t, size_t>
1873 {
1874     _LIBCPP_INLINE_VISIBILITY
1875     size_t operator()(wchar_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
1876 };
1877
1878 template <>
1879 struct _LIBCPP_VISIBLE hash<short>
1880     : public unary_function<short, size_t>
1881 {
1882     _LIBCPP_INLINE_VISIBILITY
1883     size_t operator()(short __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
1884 };
1885
1886 template <>
1887 struct _LIBCPP_VISIBLE hash<unsigned short>
1888     : public unary_function<unsigned short, size_t>
1889 {
1890     _LIBCPP_INLINE_VISIBILITY
1891     size_t operator()(unsigned short __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
1892 };
1893
1894 template <>
1895 struct _LIBCPP_VISIBLE hash<int>
1896     : public unary_function<int, size_t>
1897 {
1898     _LIBCPP_INLINE_VISIBILITY
1899     size_t operator()(int __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
1900 };
1901
1902 template <>
1903 struct _LIBCPP_VISIBLE hash<unsigned int>
1904     : public unary_function<unsigned int, size_t>
1905 {
1906     _LIBCPP_INLINE_VISIBILITY
1907     size_t operator()(unsigned int __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
1908 };
1909
1910 template <>
1911 struct _LIBCPP_VISIBLE hash<long>
1912     : public unary_function<long, size_t>
1913 {
1914     _LIBCPP_INLINE_VISIBILITY
1915     size_t operator()(long __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
1916 };
1917
1918 template <>
1919 struct _LIBCPP_VISIBLE hash<unsigned long>
1920     : public unary_function<unsigned long, size_t>
1921 {
1922     _LIBCPP_INLINE_VISIBILITY
1923     size_t operator()(unsigned long __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
1924 };
1925
1926 template <>
1927 struct _LIBCPP_VISIBLE hash<long long>
1928     : public __scalar_hash<long long>
1929 {
1930 };
1931
1932 template <>
1933 struct _LIBCPP_VISIBLE hash<unsigned long long>
1934     : public __scalar_hash<unsigned long long>
1935 {
1936 };
1937
1938 template <>
1939 struct _LIBCPP_VISIBLE hash<float>
1940     : public __scalar_hash<float>
1941 {
1942     _LIBCPP_INLINE_VISIBILITY
1943     size_t operator()(float __v) const _NOEXCEPT
1944     {
1945         // -0.0 and 0.0 should return same hash
1946        if (__v == 0)
1947            return 0;
1948         return __scalar_hash<float>::operator()(__v);
1949     }
1950 };
1951
1952 template <>
1953 struct _LIBCPP_VISIBLE hash<double>
1954     : public __scalar_hash<double>
1955 {
1956     _LIBCPP_INLINE_VISIBILITY
1957     size_t operator()(double __v) const _NOEXCEPT
1958     {
1959         // -0.0 and 0.0 should return same hash
1960        if (__v == 0)
1961            return 0;
1962         return __scalar_hash<double>::operator()(__v);
1963     }
1964 };
1965
1966 template <>
1967 struct _LIBCPP_VISIBLE hash<long double>
1968     : public __scalar_hash<long double>
1969 {
1970     _LIBCPP_INLINE_VISIBILITY
1971     size_t operator()(long double __v) const _NOEXCEPT
1972     {
1973         // -0.0 and 0.0 should return same hash
1974         if (__v == 0)
1975             return 0;
1976 #if defined(__i386__)
1977         // Zero out padding bits
1978         union
1979         {
1980             long double __t;
1981             struct
1982             {
1983                 size_t __a;
1984                 size_t __b;
1985                 size_t __c;
1986                 size_t __d;
1987             };
1988         } __u;
1989         __u.__a = 0;
1990         __u.__b = 0;
1991         __u.__c = 0;
1992         __u.__d = 0;
1993         __u.__t = __v;
1994         return __u.__a ^ __u.__b ^ __u.__c ^ __u.__d;
1995 #elif defined(__x86_64__)
1996         // Zero out padding bits
1997         union
1998         {
1999             long double __t;
2000             struct
2001             {
2002                 size_t __a;
2003                 size_t __b;
2004             };
2005         } __u;
2006         __u.__a = 0;
2007         __u.__b = 0;
2008         __u.__t = __v;
2009         return __u.__a ^ __u.__b;
2010 #else
2011         return __scalar_hash<long double>::operator()(__v);
2012 #endif
2013     }
2014 };
2015
2016 // struct hash<T*> in <memory>
2017
2018 _LIBCPP_END_NAMESPACE_STD
2019
2020 #endif  // _LIBCPP_FUNCTIONAL