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_TYPE_VIS 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_TYPE_VIS 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_TYPE_VIS 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_TYPE_VIS 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_TYPE_VIS 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_TYPE_VIS 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_TYPE_VIS 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_TYPE_VIS 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_TYPE_VIS 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_TYPE_VIS 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_TYPE_VIS 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_TYPE_VIS 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_TYPE_VIS 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_TYPE_VIS 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_TYPE_VIS 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_TYPE_VIS 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_TYPE_VIS 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_TYPE_VIS 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_TYPE_VIS 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_TYPE_VIS 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_TYPE_VIS 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_TYPE_VIS 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_TYPE_VIS 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_TYPE_VIS 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_TYPE_VIS 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_TYPE_VIS 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_TYPE_VIS 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_TYPE_VIS 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_TYPE_VIS 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_TYPE_VIS 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_TYPE_VIS 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_TYPE_VIS 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_TYPE_VIS 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 typename 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 = !is_same<_Fp, function>::value && 1117 __invokable<_Fp&, _ArgTypes...>::value> 1118 struct __callable; 1119 template <class _Fp> 1120 struct __callable<_Fp, true> 1121 { 1122 static const bool value = 1123 is_convertible<typename __invoke_of<_Fp&, _ArgTypes...>::type, 1124 _Rp>::value; 1125 }; 1126 template <class _Fp> 1127 struct __callable<_Fp, false> 1128 { 1129 static const bool value = false; 1130 }; 1131 public: 1132 typedef _Rp result_type; 1133 1134 // construct/copy/destroy: 1135 _LIBCPP_INLINE_VISIBILITY 1136 function() _NOEXCEPT : __f_(0) {} 1137 _LIBCPP_INLINE_VISIBILITY 1138 function(nullptr_t) _NOEXCEPT : __f_(0) {} 1139 function(const function&); 1140 function(function&&) _NOEXCEPT; 1141 template<class _Fp> 1142 function(_Fp, typename enable_if 1143 < 1144 __callable<_Fp>::value && 1145 !is_same<_Fp, function>::value 1146 >::type* = 0); 1147 1148 template<class _Alloc> 1149 _LIBCPP_INLINE_VISIBILITY 1150 function(allocator_arg_t, const _Alloc&) _NOEXCEPT : __f_(0) {} 1151 template<class _Alloc> 1152 _LIBCPP_INLINE_VISIBILITY 1153 function(allocator_arg_t, const _Alloc&, nullptr_t) _NOEXCEPT : __f_(0) {} 1154 template<class _Alloc> 1155 function(allocator_arg_t, const _Alloc&, const function&); 1156 template<class _Alloc> 1157 function(allocator_arg_t, const _Alloc&, function&&); 1158 template<class _Fp, class _Alloc> 1159 function(allocator_arg_t, const _Alloc& __a, _Fp __f, 1160 typename enable_if<__callable<_Fp>::value>::type* = 0); 1161 1162 function& operator=(const function&); 1163 function& operator=(function&&) _NOEXCEPT; 1164 function& operator=(nullptr_t) _NOEXCEPT; 1165 template<class _Fp> 1166 typename enable_if 1167 < 1168 __callable<typename decay<_Fp>::type>::value && 1169 !is_same<typename remove_reference<_Fp>::type, function>::value, 1170 function& 1171 >::type 1172 operator=(_Fp&&); 1173 1174 ~function(); 1175 1176 // function modifiers: 1177 void swap(function&) _NOEXCEPT; 1178 template<class _Fp, class _Alloc> 1179 _LIBCPP_INLINE_VISIBILITY 1180 void assign(_Fp&& __f, const _Alloc& __a) 1181 {function(allocator_arg, __a, _VSTD::forward<_Fp>(__f)).swap(*this);} 1182 1183 // function capacity: 1184 _LIBCPP_INLINE_VISIBILITY 1185 _LIBCPP_EXPLICIT operator bool() const _NOEXCEPT {return __f_;} 1186 1187 // deleted overloads close possible hole in the type system 1188 template<class _R2, class... _ArgTypes2> 1189 bool operator==(const function<_R2(_ArgTypes2...)>&) const = delete; 1190 template<class _R2, class... _ArgTypes2> 1191 bool operator!=(const function<_R2(_ArgTypes2...)>&) const = delete; 1192 public: 1193 // function invocation: 1194 _Rp operator()(_ArgTypes...) const; 1195 1196 #ifndef _LIBCPP_NO_RTTI 1197 // function target access: 1198 const std::type_info& target_type() const _NOEXCEPT; 1199 template <typename _Tp> _Tp* target() _NOEXCEPT; 1200 template <typename _Tp> const _Tp* target() const _NOEXCEPT; 1201 #endif // _LIBCPP_NO_RTTI 1202 }; 1203 1204 template<class _Rp, class ..._ArgTypes> 1205 function<_Rp(_ArgTypes...)>::function(const function& __f) 1206 { 1207 if (__f.__f_ == 0) 1208 __f_ = 0; 1209 else if (__f.__f_ == (const __base*)&__f.__buf_) 1210 { 1211 __f_ = (__base*)&__buf_; 1212 __f.__f_->__clone(__f_); 1213 } 1214 else 1215 __f_ = __f.__f_->__clone(); 1216 } 1217 1218 template<class _Rp, class ..._ArgTypes> 1219 template <class _Alloc> 1220 function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc&, 1221 const function& __f) 1222 { 1223 if (__f.__f_ == 0) 1224 __f_ = 0; 1225 else if (__f.__f_ == (const __base*)&__f.__buf_) 1226 { 1227 __f_ = (__base*)&__buf_; 1228 __f.__f_->__clone(__f_); 1229 } 1230 else 1231 __f_ = __f.__f_->__clone(); 1232 } 1233 1234 template<class _Rp, class ..._ArgTypes> 1235 function<_Rp(_ArgTypes...)>::function(function&& __f) _NOEXCEPT 1236 { 1237 if (__f.__f_ == 0) 1238 __f_ = 0; 1239 else if (__f.__f_ == (__base*)&__f.__buf_) 1240 { 1241 __f_ = (__base*)&__buf_; 1242 __f.__f_->__clone(__f_); 1243 } 1244 else 1245 { 1246 __f_ = __f.__f_; 1247 __f.__f_ = 0; 1248 } 1249 } 1250 1251 template<class _Rp, class ..._ArgTypes> 1252 template <class _Alloc> 1253 function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc&, 1254 function&& __f) 1255 { 1256 if (__f.__f_ == 0) 1257 __f_ = 0; 1258 else if (__f.__f_ == (__base*)&__f.__buf_) 1259 { 1260 __f_ = (__base*)&__buf_; 1261 __f.__f_->__clone(__f_); 1262 } 1263 else 1264 { 1265 __f_ = __f.__f_; 1266 __f.__f_ = 0; 1267 } 1268 } 1269 1270 template<class _Rp, class ..._ArgTypes> 1271 template <class _Fp> 1272 function<_Rp(_ArgTypes...)>::function(_Fp __f, 1273 typename enable_if 1274 < 1275 __callable<_Fp>::value && 1276 !is_same<_Fp, function>::value 1277 >::type*) 1278 : __f_(0) 1279 { 1280 if (__not_null(__f)) 1281 { 1282 typedef __function::__func<_Fp, allocator<_Fp>, _Rp(_ArgTypes...)> _FF; 1283 if (sizeof(_FF) <= sizeof(__buf_) && is_nothrow_copy_constructible<_Fp>::value) 1284 { 1285 __f_ = (__base*)&__buf_; 1286 ::new (__f_) _FF(_VSTD::move(__f)); 1287 } 1288 else 1289 { 1290 typedef allocator<_FF> _Ap; 1291 _Ap __a; 1292 typedef __allocator_destructor<_Ap> _Dp; 1293 unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); 1294 ::new (__hold.get()) _FF(_VSTD::move(__f), allocator<_Fp>(__a)); 1295 __f_ = __hold.release(); 1296 } 1297 } 1298 } 1299 1300 template<class _Rp, class ..._ArgTypes> 1301 template <class _Fp, class _Alloc> 1302 function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc& __a0, _Fp __f, 1303 typename enable_if<__callable<_Fp>::value>::type*) 1304 : __f_(0) 1305 { 1306 typedef allocator_traits<_Alloc> __alloc_traits; 1307 if (__not_null(__f)) 1308 { 1309 typedef __function::__func<_Fp, _Alloc, _Rp(_ArgTypes...)> _FF; 1310 if (sizeof(_FF) <= sizeof(__buf_) && is_nothrow_copy_constructible<_Fp>::value) 1311 { 1312 __f_ = (__base*)&__buf_; 1313 ::new (__f_) _FF(_VSTD::move(__f)); 1314 } 1315 else 1316 { 1317 typedef typename __alloc_traits::template 1318 #ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES 1319 rebind_alloc<_FF> 1320 #else 1321 rebind_alloc<_FF>::other 1322 #endif 1323 _Ap; 1324 _Ap __a(__a0); 1325 typedef __allocator_destructor<_Ap> _Dp; 1326 unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); 1327 ::new (__hold.get()) _FF(_VSTD::move(__f), _Alloc(__a)); 1328 __f_ = __hold.release(); 1329 } 1330 } 1331 } 1332 1333 template<class _Rp, class ..._ArgTypes> 1334 function<_Rp(_ArgTypes...)>& 1335 function<_Rp(_ArgTypes...)>::operator=(const function& __f) 1336 { 1337 function(__f).swap(*this); 1338 return *this; 1339 } 1340 1341 template<class _Rp, class ..._ArgTypes> 1342 function<_Rp(_ArgTypes...)>& 1343 function<_Rp(_ArgTypes...)>::operator=(function&& __f) _NOEXCEPT 1344 { 1345 if (__f_ == (__base*)&__buf_) 1346 __f_->destroy(); 1347 else if (__f_) 1348 __f_->destroy_deallocate(); 1349 __f_ = 0; 1350 if (__f.__f_ == 0) 1351 __f_ = 0; 1352 else if (__f.__f_ == (__base*)&__f.__buf_) 1353 { 1354 __f_ = (__base*)&__buf_; 1355 __f.__f_->__clone(__f_); 1356 } 1357 else 1358 { 1359 __f_ = __f.__f_; 1360 __f.__f_ = 0; 1361 } 1362 return *this; 1363 } 1364 1365 template<class _Rp, class ..._ArgTypes> 1366 function<_Rp(_ArgTypes...)>& 1367 function<_Rp(_ArgTypes...)>::operator=(nullptr_t) _NOEXCEPT 1368 { 1369 if (__f_ == (__base*)&__buf_) 1370 __f_->destroy(); 1371 else if (__f_) 1372 __f_->destroy_deallocate(); 1373 __f_ = 0; 1374 return *this; 1375 } 1376 1377 template<class _Rp, class ..._ArgTypes> 1378 template <class _Fp> 1379 typename enable_if 1380 < 1381 function<_Rp(_ArgTypes...)>::template __callable<typename decay<_Fp>::type>::value && 1382 !is_same<typename remove_reference<_Fp>::type, function<_Rp(_ArgTypes...)>>::value, 1383 function<_Rp(_ArgTypes...)>& 1384 >::type 1385 function<_Rp(_ArgTypes...)>::operator=(_Fp&& __f) 1386 { 1387 function(_VSTD::forward<_Fp>(__f)).swap(*this); 1388 return *this; 1389 } 1390 1391 template<class _Rp, class ..._ArgTypes> 1392 function<_Rp(_ArgTypes...)>::~function() 1393 { 1394 if (__f_ == (__base*)&__buf_) 1395 __f_->destroy(); 1396 else if (__f_) 1397 __f_->destroy_deallocate(); 1398 } 1399 1400 template<class _Rp, class ..._ArgTypes> 1401 void 1402 function<_Rp(_ArgTypes...)>::swap(function& __f) _NOEXCEPT 1403 { 1404 if (__f_ == (__base*)&__buf_ && __f.__f_ == (__base*)&__f.__buf_) 1405 { 1406 typename aligned_storage<sizeof(__buf_)>::type __tempbuf; 1407 __base* __t = (__base*)&__tempbuf; 1408 __f_->__clone(__t); 1409 __f_->destroy(); 1410 __f_ = 0; 1411 __f.__f_->__clone((__base*)&__buf_); 1412 __f.__f_->destroy(); 1413 __f.__f_ = 0; 1414 __f_ = (__base*)&__buf_; 1415 __t->__clone((__base*)&__f.__buf_); 1416 __t->destroy(); 1417 __f.__f_ = (__base*)&__f.__buf_; 1418 } 1419 else if (__f_ == (__base*)&__buf_) 1420 { 1421 __f_->__clone((__base*)&__f.__buf_); 1422 __f_->destroy(); 1423 __f_ = __f.__f_; 1424 __f.__f_ = (__base*)&__f.__buf_; 1425 } 1426 else if (__f.__f_ == (__base*)&__f.__buf_) 1427 { 1428 __f.__f_->__clone((__base*)&__buf_); 1429 __f.__f_->destroy(); 1430 __f.__f_ = __f_; 1431 __f_ = (__base*)&__buf_; 1432 } 1433 else 1434 _VSTD::swap(__f_, __f.__f_); 1435 } 1436 1437 template<class _Rp, class ..._ArgTypes> 1438 _Rp 1439 function<_Rp(_ArgTypes...)>::operator()(_ArgTypes... __arg) const 1440 { 1441 #ifndef _LIBCPP_NO_EXCEPTIONS 1442 if (__f_ == 0) 1443 throw bad_function_call(); 1444 #endif // _LIBCPP_NO_EXCEPTIONS 1445 return (*__f_)(_VSTD::forward<_ArgTypes>(__arg)...); 1446 } 1447 1448 #ifndef _LIBCPP_NO_RTTI 1449 1450 template<class _Rp, class ..._ArgTypes> 1451 const std::type_info& 1452 function<_Rp(_ArgTypes...)>::target_type() const _NOEXCEPT 1453 { 1454 if (__f_ == 0) 1455 return typeid(void); 1456 return __f_->target_type(); 1457 } 1458 1459 template<class _Rp, class ..._ArgTypes> 1460 template <typename _Tp> 1461 _Tp* 1462 function<_Rp(_ArgTypes...)>::target() _NOEXCEPT 1463 { 1464 if (__f_ == 0) 1465 return (_Tp*)0; 1466 return (_Tp*)__f_->target(typeid(_Tp)); 1467 } 1468 1469 template<class _Rp, class ..._ArgTypes> 1470 template <typename _Tp> 1471 const _Tp* 1472 function<_Rp(_ArgTypes...)>::target() const _NOEXCEPT 1473 { 1474 if (__f_ == 0) 1475 return (const _Tp*)0; 1476 return (const _Tp*)__f_->target(typeid(_Tp)); 1477 } 1478 1479 #endif // _LIBCPP_NO_RTTI 1480 1481 template <class _Rp, class... _ArgTypes> 1482 inline _LIBCPP_INLINE_VISIBILITY 1483 bool 1484 operator==(const function<_Rp(_ArgTypes...)>& __f, nullptr_t) _NOEXCEPT {return !__f;} 1485 1486 template <class _Rp, class... _ArgTypes> 1487 inline _LIBCPP_INLINE_VISIBILITY 1488 bool 1489 operator==(nullptr_t, const function<_Rp(_ArgTypes...)>& __f) _NOEXCEPT {return !__f;} 1490 1491 template <class _Rp, class... _ArgTypes> 1492 inline _LIBCPP_INLINE_VISIBILITY 1493 bool 1494 operator!=(const function<_Rp(_ArgTypes...)>& __f, nullptr_t) _NOEXCEPT {return (bool)__f;} 1495 1496 template <class _Rp, class... _ArgTypes> 1497 inline _LIBCPP_INLINE_VISIBILITY 1498 bool 1499 operator!=(nullptr_t, const function<_Rp(_ArgTypes...)>& __f) _NOEXCEPT {return (bool)__f;} 1500 1501 template <class _Rp, class... _ArgTypes> 1502 inline _LIBCPP_INLINE_VISIBILITY 1503 void 1504 swap(function<_Rp(_ArgTypes...)>& __x, function<_Rp(_ArgTypes...)>& __y) _NOEXCEPT 1505 {return __x.swap(__y);} 1506 1507 template<class _Tp> struct __is_bind_expression : public false_type {}; 1508 template<class _Tp> struct _LIBCPP_TYPE_VIS is_bind_expression 1509 : public __is_bind_expression<typename remove_cv<_Tp>::type> {}; 1510 1511 template<class _Tp> struct __is_placeholder : public integral_constant<int, 0> {}; 1512 template<class _Tp> struct _LIBCPP_TYPE_VIS is_placeholder 1513 : public __is_placeholder<typename remove_cv<_Tp>::type> {}; 1514 1515 namespace placeholders 1516 { 1517 1518 template <int _Np> struct __ph {}; 1519 1520 extern __ph<1> _1; 1521 extern __ph<2> _2; 1522 extern __ph<3> _3; 1523 extern __ph<4> _4; 1524 extern __ph<5> _5; 1525 extern __ph<6> _6; 1526 extern __ph<7> _7; 1527 extern __ph<8> _8; 1528 extern __ph<9> _9; 1529 extern __ph<10> _10; 1530 1531 } // placeholders 1532 1533 template<int _Np> 1534 struct __is_placeholder<placeholders::__ph<_Np> > 1535 : public integral_constant<int, _Np> {}; 1536 1537 template <class _Tp, class _Uj> 1538 inline _LIBCPP_INLINE_VISIBILITY 1539 _Tp& 1540 __mu(reference_wrapper<_Tp> __t, _Uj&) 1541 { 1542 return __t.get(); 1543 } 1544 1545 template <class _Ti, class ..._Uj, size_t ..._Indx> 1546 inline _LIBCPP_INLINE_VISIBILITY 1547 typename __invoke_of<_Ti&, _Uj...>::type 1548 __mu_expand(_Ti& __ti, tuple<_Uj...>& __uj, __tuple_indices<_Indx...>) 1549 { 1550 return __ti(_VSTD::forward<_Uj>(get<_Indx>(__uj))...); 1551 } 1552 1553 template <class _Ti, class ..._Uj> 1554 inline _LIBCPP_INLINE_VISIBILITY 1555 typename enable_if 1556 < 1557 is_bind_expression<_Ti>::value, 1558 typename __invoke_of<_Ti&, _Uj...>::type 1559 >::type 1560 __mu(_Ti& __ti, tuple<_Uj...>& __uj) 1561 { 1562 typedef typename __make_tuple_indices<sizeof...(_Uj)>::type __indices; 1563 return __mu_expand(__ti, __uj, __indices()); 1564 } 1565 1566 template <bool IsPh, class _Ti, class _Uj> 1567 struct __mu_return2 {}; 1568 1569 template <class _Ti, class _Uj> 1570 struct __mu_return2<true, _Ti, _Uj> 1571 { 1572 typedef typename tuple_element<is_placeholder<_Ti>::value - 1, _Uj>::type type; 1573 }; 1574 1575 template <class _Ti, class _Uj> 1576 inline _LIBCPP_INLINE_VISIBILITY 1577 typename enable_if 1578 < 1579 0 < is_placeholder<_Ti>::value, 1580 typename __mu_return2<0 < is_placeholder<_Ti>::value, _Ti, _Uj>::type 1581 >::type 1582 __mu(_Ti&, _Uj& __uj) 1583 { 1584 const size_t _Indx = is_placeholder<_Ti>::value - 1; 1585 return _VSTD::forward<typename tuple_element<_Indx, _Uj>::type>(get<_Indx>(__uj)); 1586 } 1587 1588 template <class _Ti, class _Uj> 1589 inline _LIBCPP_INLINE_VISIBILITY 1590 typename enable_if 1591 < 1592 !is_bind_expression<_Ti>::value && 1593 is_placeholder<_Ti>::value == 0 && 1594 !__is_reference_wrapper<_Ti>::value, 1595 _Ti& 1596 >::type 1597 __mu(_Ti& __ti, _Uj&) 1598 { 1599 return __ti; 1600 } 1601 1602 template <class _Ti, bool IsReferenceWrapper, bool IsBindEx, bool IsPh, 1603 class _TupleUj> 1604 struct ____mu_return; 1605 1606 template <bool _Invokable, class _Ti, class ..._Uj> 1607 struct ____mu_return_invokable // false 1608 { 1609 typedef __nat type; 1610 }; 1611 1612 template <class _Ti, class ..._Uj> 1613 struct ____mu_return_invokable<true, _Ti, _Uj...> 1614 { 1615 typedef typename __invoke_of<_Ti&, _Uj...>::type type; 1616 }; 1617 1618 template <class _Ti, class ..._Uj> 1619 struct ____mu_return<_Ti, false, true, false, tuple<_Uj...> > 1620 : public ____mu_return_invokable<__invokable<_Ti&, _Uj...>::value, _Ti, _Uj...> 1621 { 1622 }; 1623 1624 template <class _Ti, class _TupleUj> 1625 struct ____mu_return<_Ti, false, false, true, _TupleUj> 1626 { 1627 typedef typename tuple_element<is_placeholder<_Ti>::value - 1, 1628 _TupleUj>::type&& type; 1629 }; 1630 1631 template <class _Ti, class _TupleUj> 1632 struct ____mu_return<_Ti, true, false, false, _TupleUj> 1633 { 1634 typedef typename _Ti::type& type; 1635 }; 1636 1637 template <class _Ti, class _TupleUj> 1638 struct ____mu_return<_Ti, false, false, false, _TupleUj> 1639 { 1640 typedef _Ti& type; 1641 }; 1642 1643 template <class _Ti, class _TupleUj> 1644 struct __mu_return 1645 : public ____mu_return<_Ti, 1646 __is_reference_wrapper<_Ti>::value, 1647 is_bind_expression<_Ti>::value, 1648 0 < is_placeholder<_Ti>::value && 1649 is_placeholder<_Ti>::value <= tuple_size<_TupleUj>::value, 1650 _TupleUj> 1651 { 1652 }; 1653 1654 template <class _Fp, class _BoundArgs, class _TupleUj> 1655 struct _is_valid_bind_return 1656 { 1657 static const bool value = false; 1658 }; 1659 1660 template <class _Fp, class ..._BoundArgs, class _TupleUj> 1661 struct _is_valid_bind_return<_Fp, tuple<_BoundArgs...>, _TupleUj> 1662 { 1663 static const bool value = __invokable<_Fp, 1664 typename __mu_return<_BoundArgs, _TupleUj>::type...>::value; 1665 }; 1666 1667 template <class _Fp, class ..._BoundArgs, class _TupleUj> 1668 struct _is_valid_bind_return<_Fp, const tuple<_BoundArgs...>, _TupleUj> 1669 { 1670 static const bool value = __invokable<_Fp, 1671 typename __mu_return<const _BoundArgs, _TupleUj>::type...>::value; 1672 }; 1673 1674 template <class _Fp, class _BoundArgs, class _TupleUj, 1675 bool = _is_valid_bind_return<_Fp, _BoundArgs, _TupleUj>::value> 1676 struct __bind_return; 1677 1678 template <class _Fp, class ..._BoundArgs, class _TupleUj> 1679 struct __bind_return<_Fp, tuple<_BoundArgs...>, _TupleUj, true> 1680 { 1681 typedef typename __invoke_of 1682 < 1683 _Fp&, 1684 typename __mu_return 1685 < 1686 _BoundArgs, 1687 _TupleUj 1688 >::type... 1689 >::type type; 1690 }; 1691 1692 template <class _Fp, class ..._BoundArgs, class _TupleUj> 1693 struct __bind_return<_Fp, const tuple<_BoundArgs...>, _TupleUj, true> 1694 { 1695 typedef typename __invoke_of 1696 < 1697 _Fp&, 1698 typename __mu_return 1699 < 1700 const _BoundArgs, 1701 _TupleUj 1702 >::type... 1703 >::type type; 1704 }; 1705 1706 template <class _Fp, class _BoundArgs, size_t ..._Indx, class _Args> 1707 inline _LIBCPP_INLINE_VISIBILITY 1708 typename __bind_return<_Fp, _BoundArgs, _Args>::type 1709 __apply_functor(_Fp& __f, _BoundArgs& __bound_args, __tuple_indices<_Indx...>, 1710 _Args&& __args) 1711 { 1712 return __invoke(__f, __mu(get<_Indx>(__bound_args), __args)...); 1713 } 1714 1715 template<class _Fp, class ..._BoundArgs> 1716 class __bind 1717 : public __weak_result_type<typename decay<_Fp>::type> 1718 { 1719 protected: 1720 typedef typename decay<_Fp>::type _Fd; 1721 typedef tuple<typename decay<_BoundArgs>::type...> _Td; 1722 private: 1723 _Fd __f_; 1724 _Td __bound_args_; 1725 1726 typedef typename __make_tuple_indices<sizeof...(_BoundArgs)>::type __indices; 1727 public: 1728 #ifdef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS 1729 1730 _LIBCPP_INLINE_VISIBILITY 1731 __bind(const __bind& __b) 1732 : __f_(__b.__f_), 1733 __bound_args_(__b.__bound_args_) {} 1734 1735 _LIBCPP_INLINE_VISIBILITY 1736 __bind& operator=(const __bind& __b) 1737 { 1738 __f_ = __b.__f_; 1739 __bound_args_ = __b.__bound_args_; 1740 return *this; 1741 } 1742 1743 _LIBCPP_INLINE_VISIBILITY 1744 __bind(__bind&& __b) 1745 : __f_(_VSTD::move(__b.__f_)), 1746 __bound_args_(_VSTD::move(__b.__bound_args_)) {} 1747 1748 _LIBCPP_INLINE_VISIBILITY 1749 __bind& operator=(__bind&& __b) 1750 { 1751 __f_ = _VSTD::move(__b.__f_); 1752 __bound_args_ = _VSTD::move(__b.__bound_args_); 1753 return *this; 1754 } 1755 1756 #endif // _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS 1757 1758 template <class _Gp, class ..._BA, 1759 class = typename enable_if 1760 < 1761 is_constructible<_Fd, _Gp>::value && 1762 !is_same<typename remove_reference<_Gp>::type, 1763 __bind>::value 1764 >::type> 1765 _LIBCPP_INLINE_VISIBILITY 1766 explicit __bind(_Gp&& __f, _BA&& ...__bound_args) 1767 : __f_(_VSTD::forward<_Gp>(__f)), 1768 __bound_args_(_VSTD::forward<_BA>(__bound_args)...) {} 1769 1770 template <class ..._Args> 1771 _LIBCPP_INLINE_VISIBILITY 1772 typename __bind_return<_Fd, _Td, tuple<_Args&&...> >::type 1773 operator()(_Args&& ...__args) 1774 { 1775 return __apply_functor(__f_, __bound_args_, __indices(), 1776 tuple<_Args&&...>(_VSTD::forward<_Args>(__args)...)); 1777 } 1778 1779 template <class ..._Args> 1780 _LIBCPP_INLINE_VISIBILITY 1781 typename __bind_return<const _Fd, const _Td, tuple<_Args&&...> >::type 1782 operator()(_Args&& ...__args) const 1783 { 1784 return __apply_functor(__f_, __bound_args_, __indices(), 1785 tuple<_Args&&...>(_VSTD::forward<_Args>(__args)...)); 1786 } 1787 }; 1788 1789 template<class _Fp, class ..._BoundArgs> 1790 struct __is_bind_expression<__bind<_Fp, _BoundArgs...> > : public true_type {}; 1791 1792 template<class _Rp, class _Fp, class ..._BoundArgs> 1793 class __bind_r 1794 : public __bind<_Fp, _BoundArgs...> 1795 { 1796 typedef __bind<_Fp, _BoundArgs...> base; 1797 typedef typename base::_Fd _Fd; 1798 typedef typename base::_Td _Td; 1799 public: 1800 typedef _Rp result_type; 1801 1802 #ifdef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS 1803 1804 _LIBCPP_INLINE_VISIBILITY 1805 __bind_r(const __bind_r& __b) 1806 : base(_VSTD::forward<const base&>(__b)) {} 1807 1808 _LIBCPP_INLINE_VISIBILITY 1809 __bind_r& operator=(const __bind_r& __b) 1810 { 1811 base::operator=(_VSTD::forward<const base&>(__b)); 1812 return *this; 1813 } 1814 1815 _LIBCPP_INLINE_VISIBILITY 1816 __bind_r(__bind_r&& __b) 1817 : base(_VSTD::forward<base>(__b)) {} 1818 1819 _LIBCPP_INLINE_VISIBILITY 1820 __bind_r& operator=(__bind_r&& __b) 1821 { 1822 base::operator=(_VSTD::forward<base>(__b)); 1823 return *this; 1824 } 1825 1826 #endif // _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS 1827 1828 template <class _Gp, class ..._BA, 1829 class = typename enable_if 1830 < 1831 is_constructible<_Fd, _Gp>::value && 1832 !is_same<typename remove_reference<_Gp>::type, 1833 __bind_r>::value 1834 >::type> 1835 _LIBCPP_INLINE_VISIBILITY 1836 explicit __bind_r(_Gp&& __f, _BA&& ...__bound_args) 1837 : base(_VSTD::forward<_Gp>(__f), 1838 _VSTD::forward<_BA>(__bound_args)...) {} 1839 1840 template <class ..._Args> 1841 _LIBCPP_INLINE_VISIBILITY 1842 typename enable_if 1843 < 1844 is_convertible<typename __bind_return<_Fd, _Td, tuple<_Args&&...> >::type, 1845 result_type>::value, 1846 result_type 1847 >::type 1848 operator()(_Args&& ...__args) 1849 { 1850 return base::operator()(_VSTD::forward<_Args>(__args)...); 1851 } 1852 1853 template <class ..._Args> 1854 _LIBCPP_INLINE_VISIBILITY 1855 typename enable_if 1856 < 1857 is_convertible<typename __bind_return<const _Fd, const _Td, tuple<_Args&&...> >::type, 1858 result_type>::value, 1859 result_type 1860 >::type 1861 operator()(_Args&& ...__args) const 1862 { 1863 return base::operator()(_VSTD::forward<_Args>(__args)...); 1864 } 1865 }; 1866 1867 template<class _Rp, class _Fp, class ..._BoundArgs> 1868 struct __is_bind_expression<__bind_r<_Rp, _Fp, _BoundArgs...> > : public true_type {}; 1869 1870 template<class _Fp, class ..._BoundArgs> 1871 inline _LIBCPP_INLINE_VISIBILITY 1872 __bind<_Fp, _BoundArgs...> 1873 bind(_Fp&& __f, _BoundArgs&&... __bound_args) 1874 { 1875 typedef __bind<_Fp, _BoundArgs...> type; 1876 return type(_VSTD::forward<_Fp>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...); 1877 } 1878 1879 template<class _Rp, class _Fp, class ..._BoundArgs> 1880 inline _LIBCPP_INLINE_VISIBILITY 1881 __bind_r<_Rp, _Fp, _BoundArgs...> 1882 bind(_Fp&& __f, _BoundArgs&&... __bound_args) 1883 { 1884 typedef __bind_r<_Rp, _Fp, _BoundArgs...> type; 1885 return type(_VSTD::forward<_Fp>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...); 1886 } 1887 1888 #endif // _LIBCPP_HAS_NO_VARIADICS 1889 1890 template <> 1891 struct _LIBCPP_TYPE_VIS hash<bool> 1892 : public unary_function<bool, size_t> 1893 { 1894 _LIBCPP_INLINE_VISIBILITY 1895 size_t operator()(bool __v) const _NOEXCEPT {return static_cast<size_t>(__v);} 1896 }; 1897 1898 template <> 1899 struct _LIBCPP_TYPE_VIS hash<char> 1900 : public unary_function<char, size_t> 1901 { 1902 _LIBCPP_INLINE_VISIBILITY 1903 size_t operator()(char __v) const _NOEXCEPT {return static_cast<size_t>(__v);} 1904 }; 1905 1906 template <> 1907 struct _LIBCPP_TYPE_VIS hash<signed char> 1908 : public unary_function<signed char, size_t> 1909 { 1910 _LIBCPP_INLINE_VISIBILITY 1911 size_t operator()(signed char __v) const _NOEXCEPT {return static_cast<size_t>(__v);} 1912 }; 1913 1914 template <> 1915 struct _LIBCPP_TYPE_VIS hash<unsigned char> 1916 : public unary_function<unsigned char, size_t> 1917 { 1918 _LIBCPP_INLINE_VISIBILITY 1919 size_t operator()(unsigned char __v) const _NOEXCEPT {return static_cast<size_t>(__v);} 1920 }; 1921 1922 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS 1923 1924 template <> 1925 struct _LIBCPP_TYPE_VIS hash<char16_t> 1926 : public unary_function<char16_t, size_t> 1927 { 1928 _LIBCPP_INLINE_VISIBILITY 1929 size_t operator()(char16_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);} 1930 }; 1931 1932 template <> 1933 struct _LIBCPP_TYPE_VIS hash<char32_t> 1934 : public unary_function<char32_t, size_t> 1935 { 1936 _LIBCPP_INLINE_VISIBILITY 1937 size_t operator()(char32_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);} 1938 }; 1939 1940 #endif // _LIBCPP_HAS_NO_UNICODE_CHARS 1941 1942 template <> 1943 struct _LIBCPP_TYPE_VIS hash<wchar_t> 1944 : public unary_function<wchar_t, size_t> 1945 { 1946 _LIBCPP_INLINE_VISIBILITY 1947 size_t operator()(wchar_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);} 1948 }; 1949 1950 template <> 1951 struct _LIBCPP_TYPE_VIS hash<short> 1952 : public unary_function<short, size_t> 1953 { 1954 _LIBCPP_INLINE_VISIBILITY 1955 size_t operator()(short __v) const _NOEXCEPT {return static_cast<size_t>(__v);} 1956 }; 1957 1958 template <> 1959 struct _LIBCPP_TYPE_VIS hash<unsigned short> 1960 : public unary_function<unsigned short, size_t> 1961 { 1962 _LIBCPP_INLINE_VISIBILITY 1963 size_t operator()(unsigned short __v) const _NOEXCEPT {return static_cast<size_t>(__v);} 1964 }; 1965 1966 template <> 1967 struct _LIBCPP_TYPE_VIS hash<int> 1968 : public unary_function<int, size_t> 1969 { 1970 _LIBCPP_INLINE_VISIBILITY 1971 size_t operator()(int __v) const _NOEXCEPT {return static_cast<size_t>(__v);} 1972 }; 1973 1974 template <> 1975 struct _LIBCPP_TYPE_VIS hash<unsigned int> 1976 : public unary_function<unsigned int, size_t> 1977 { 1978 _LIBCPP_INLINE_VISIBILITY 1979 size_t operator()(unsigned int __v) const _NOEXCEPT {return static_cast<size_t>(__v);} 1980 }; 1981 1982 template <> 1983 struct _LIBCPP_TYPE_VIS hash<long> 1984 : public unary_function<long, size_t> 1985 { 1986 _LIBCPP_INLINE_VISIBILITY 1987 size_t operator()(long __v) const _NOEXCEPT {return static_cast<size_t>(__v);} 1988 }; 1989 1990 template <> 1991 struct _LIBCPP_TYPE_VIS hash<unsigned long> 1992 : public unary_function<unsigned long, size_t> 1993 { 1994 _LIBCPP_INLINE_VISIBILITY 1995 size_t operator()(unsigned long __v) const _NOEXCEPT {return static_cast<size_t>(__v);} 1996 }; 1997 1998 template <> 1999 struct _LIBCPP_TYPE_VIS hash<long long> 2000 : public __scalar_hash<long long> 2001 { 2002 }; 2003 2004 template <> 2005 struct _LIBCPP_TYPE_VIS hash<unsigned long long> 2006 : public __scalar_hash<unsigned long long> 2007 { 2008 }; 2009 2010 template <> 2011 struct _LIBCPP_TYPE_VIS hash<float> 2012 : public __scalar_hash<float> 2013 { 2014 _LIBCPP_INLINE_VISIBILITY 2015 size_t operator()(float __v) const _NOEXCEPT 2016 { 2017 // -0.0 and 0.0 should return same hash 2018 if (__v == 0) 2019 return 0; 2020 return __scalar_hash<float>::operator()(__v); 2021 } 2022 }; 2023 2024 template <> 2025 struct _LIBCPP_TYPE_VIS hash<double> 2026 : public __scalar_hash<double> 2027 { 2028 _LIBCPP_INLINE_VISIBILITY 2029 size_t operator()(double __v) const _NOEXCEPT 2030 { 2031 // -0.0 and 0.0 should return same hash 2032 if (__v == 0) 2033 return 0; 2034 return __scalar_hash<double>::operator()(__v); 2035 } 2036 }; 2037 2038 template <> 2039 struct _LIBCPP_TYPE_VIS hash<long double> 2040 : public __scalar_hash<long double> 2041 { 2042 _LIBCPP_INLINE_VISIBILITY 2043 size_t operator()(long double __v) const _NOEXCEPT 2044 { 2045 // -0.0 and 0.0 should return same hash 2046 if (__v == 0) 2047 return 0; 2048 #if defined(__i386__) 2049 // Zero out padding bits 2050 union 2051 { 2052 long double __t; 2053 struct 2054 { 2055 size_t __a; 2056 size_t __b; 2057 size_t __c; 2058 size_t __d; 2059 }; 2060 } __u; 2061 __u.__a = 0; 2062 __u.__b = 0; 2063 __u.__c = 0; 2064 __u.__d = 0; 2065 __u.__t = __v; 2066 return __u.__a ^ __u.__b ^ __u.__c ^ __u.__d; 2067 #elif defined(__x86_64__) 2068 // Zero out padding bits 2069 union 2070 { 2071 long double __t; 2072 struct 2073 { 2074 size_t __a; 2075 size_t __b; 2076 }; 2077 } __u; 2078 __u.__a = 0; 2079 __u.__b = 0; 2080 __u.__t = __v; 2081 return __u.__a ^ __u.__b; 2082 #else 2083 return __scalar_hash<long double>::operator()(__v); 2084 #endif 2085 } 2086 }; 2087 2088 // struct hash<T*> in <memory> 2089 2090 _LIBCPP_END_NAMESPACE_STD 2091 2092 #endif // _LIBCPP_FUNCTIONAL 2093
