functional revision 232924
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 17namespace std 18{ 19 20template <class Arg, class Result> 21struct unary_function 22{ 23 typedef Arg argument_type; 24 typedef Result result_type; 25}; 26 27template <class Arg1, class Arg2, class Result> 28struct binary_function 29{ 30 typedef Arg1 first_argument_type; 31 typedef Arg2 second_argument_type; 32 typedef Result result_type; 33}; 34 35template <class T> 36class 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{ 40public: 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 63template <class T> reference_wrapper<T> ref(T& t) noexcept; 64template <class T> void ref(const T&& t) = delete; 65template <class T> reference_wrapper<T> ref(reference_wrapper<T>t) noexcept; 66 67template <class T> reference_wrapper<const T> cref(const T& t) noexcept; 68template <class T> void cref(const T&& t) = delete; 69template <class T> reference_wrapper<const T> cref(reference_wrapper<T> t) noexcept; 70 71template <class T> 72struct plus : binary_function<T, T, T> 73{ 74 T operator()(const T& x, const T& y) const; 75}; 76 77template <class T> 78struct minus : binary_function<T, T, T> 79{ 80 T operator()(const T& x, const T& y) const; 81}; 82 83template <class T> 84struct multiplies : binary_function<T, T, T> 85{ 86 T operator()(const T& x, const T& y) const; 87}; 88 89template <class T> 90struct divides : binary_function<T, T, T> 91{ 92 T operator()(const T& x, const T& y) const; 93}; 94 95template <class T> 96struct modulus : binary_function<T, T, T> 97{ 98 T operator()(const T& x, const T& y) const; 99}; 100 101template <class T> 102struct negate : unary_function<T, T> 103{ 104 T operator()(const T& x) const; 105}; 106 107template <class T> 108struct equal_to : binary_function<T, T, bool> 109{ 110 bool operator()(const T& x, const T& y) const; 111}; 112 113template <class T> 114struct not_equal_to : binary_function<T, T, bool> 115{ 116 bool operator()(const T& x, const T& y) const; 117}; 118 119template <class T> 120struct greater : binary_function<T, T, bool> 121{ 122 bool operator()(const T& x, const T& y) const; 123}; 124 125template <class T> 126struct less : binary_function<T, T, bool> 127{ 128 bool operator()(const T& x, const T& y) const; 129}; 130 131template <class T> 132struct greater_equal : binary_function<T, T, bool> 133{ 134 bool operator()(const T& x, const T& y) const; 135}; 136 137template <class T> 138struct less_equal : binary_function<T, T, bool> 139{ 140 bool operator()(const T& x, const T& y) const; 141}; 142 143template <class T> 144struct logical_and : binary_function<T, T, bool> 145{ 146 bool operator()(const T& x, const T& y) const; 147}; 148 149template <class T> 150struct logical_or : binary_function<T, T, bool> 151{ 152 bool operator()(const T& x, const T& y) const; 153}; 154 155template <class T> 156struct logical_not : unary_function<T, bool> 157{ 158 bool operator()(const T& x) const; 159}; 160 161template <class Predicate> 162class unary_negate 163 : public unary_function<typename Predicate::argument_type, bool> 164{ 165public: 166 explicit unary_negate(const Predicate& pred); 167 bool operator()(const typename Predicate::argument_type& x) const; 168}; 169 170template <class Predicate> unary_negate<Predicate> not1(const Predicate& pred); 171 172template <class Predicate> 173class binary_negate 174 : public binary_function<typename Predicate::first_argument_type, 175 typename Predicate::second_argument_type, 176 bool> 177{ 178public: 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 184template <class Predicate> binary_negate<Predicate> not2(const Predicate& pred); 185 186template<class T> struct is_bind_expression; 187template<class T> struct is_placeholder; 188 189template<class Fn, class... BoundArgs> 190 unspecified bind(Fn&&, BoundArgs&&...); 191template<class R, class Fn, class... BoundArgs> 192 unspecified bind(Fn&&, BoundArgs&&...); 193 194namespace 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 204template <class Operation> 205class binder1st 206 : public unary_function<typename Operation::second_argument_type, 207 typename Operation::result_type> 208{ 209protected: 210 Operation op; 211 typename Operation::first_argument_type value; 212public: 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 218template <class Operation, class T> 219binder1st<Operation> bind1st(const Operation& op, const T& x); 220 221template <class Operation> 222class binder2nd 223 : public unary_function<typename Operation::first_argument_type, 224 typename Operation::result_type> 225{ 226protected: 227 Operation op; 228 typename Operation::second_argument_type value; 229public: 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 235template <class Operation, class T> 236binder2nd<Operation> bind2nd(const Operation& op, const T& x); 237 238template <class Arg, class Result> 239class pointer_to_unary_function : public unary_function<Arg, Result> 240{ 241public: 242 explicit pointer_to_unary_function(Result (*f)(Arg)); 243 Result operator()(Arg x) const; 244}; 245 246template <class Arg, class Result> 247pointer_to_unary_function<Arg,Result> ptr_fun(Result (*f)(Arg)); 248 249template <class Arg1, class Arg2, class Result> 250class pointer_to_binary_function : public binary_function<Arg1, Arg2, Result> 251{ 252public: 253 explicit pointer_to_binary_function(Result (*f)(Arg1, Arg2)); 254 Result operator()(Arg1 x, Arg2 y) const; 255}; 256 257template <class Arg1, class Arg2, class Result> 258pointer_to_binary_function<Arg1,Arg2,Result> ptr_fun(Result (*f)(Arg1,Arg2)); 259 260template<class S, class T> 261class mem_fun_t : public unary_function<T*, S> 262{ 263public: 264 explicit mem_fun_t(S (T::*p)()); 265 S operator()(T* p) const; 266}; 267 268template<class S, class T, class A> 269class mem_fun1_t : public binary_function<T*, A, S> 270{ 271public: 272 explicit mem_fun1_t(S (T::*p)(A)); 273 S operator()(T* p, A x) const; 274}; 275 276template<class S, class T> mem_fun_t<S,T> mem_fun(S (T::*f)()); 277template<class S, class T, class A> mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A)); 278 279template<class S, class T> 280class mem_fun_ref_t : public unary_function<T, S> 281{ 282public: 283 explicit mem_fun_ref_t(S (T::*p)()); 284 S operator()(T& p) const; 285}; 286 287template<class S, class T, class A> 288class mem_fun1_ref_t : public binary_function<T, A, S> 289{ 290public: 291 explicit mem_fun1_ref_t(S (T::*p)(A)); 292 S operator()(T& p, A x) const; 293}; 294 295template<class S, class T> mem_fun_ref_t<S,T> mem_fun_ref(S (T::*f)()); 296template<class S, class T, class A> mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A)); 297 298template <class S, class T> 299class const_mem_fun_t : public unary_function<const T*, S> 300{ 301public: 302 explicit const_mem_fun_t(S (T::*p)() const); 303 S operator()(const T* p) const; 304}; 305 306template <class S, class T, class A> 307class const_mem_fun1_t : public binary_function<const T*, A, S> 308{ 309public: 310 explicit const_mem_fun1_t(S (T::*p)(A) const); 311 S operator()(const T* p, A x) const; 312}; 313 314template <class S, class T> const_mem_fun_t<S,T> mem_fun(S (T::*f)() const); 315template <class S, class T, class A> const_mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A) const); 316 317template <class S, class T> 318class const_mem_fun_ref_t : public unary_function<T, S> 319{ 320public: 321 explicit const_mem_fun_ref_t(S (T::*p)() const); 322 S operator()(const T& p) const; 323}; 324 325template <class S, class T, class A> 326class const_mem_fun1_ref_t : public binary_function<T, A, S> 327{ 328public: 329 explicit const_mem_fun1_ref_t(S (T::*p)(A) const); 330 S operator()(const T& p, A x) const; 331}; 332 333template <class S, class T> const_mem_fun_ref_t<S,T> mem_fun_ref(S (T::*f)() const); 334template <class S, class T, class A> const_mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A) const); 335 336template<class R, class T> unspecified mem_fn(R T::*); 337template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...)); 338template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) const); 339template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) volatile); 340template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) const volatile); 341template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) &); 342template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) const &); 343template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) volatile &); 344template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) const volatile &); 345template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) &&); 346template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) const &&); 347template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) volatile &&); 348template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) const volatile &&); 349 350class bad_function_call 351 : public exception 352{ 353}; 354 355template<class> class function; // undefined 356 357template<class R, class... ArgTypes> 358class 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{ 364public: 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: 413template <class R, class ... ArgTypes> 414 bool operator==(const function<R(ArgTypes...)>&, nullptr_t) noexcept; 415 416template <class R, class ... ArgTypes> 417 bool operator==(nullptr_t, const function<R(ArgTypes...)>&) noexcept; 418 419template <class R, class ... ArgTypes> 420 bool operator!=(const function<R(ArgTypes...)>&, nullptr_t) noexcept; 421 422template <class R, class ... ArgTypes> 423 bool operator!=(nullptr_t, const function<R(ArgTypes...)>&) noexcept; 424 425// specialized algorithms: 426template <class R, class ... ArgTypes> 427 void swap(function<R(ArgTypes...)>&, function<R(ArgTypes...)>&) noexcept; 428 429template <class T> struct hash; 430 431template <> struct hash<bool>; 432template <> struct hash<char>; 433template <> struct hash<signed char>; 434template <> struct hash<unsigned char>; 435template <> struct hash<char16_t>; 436template <> struct hash<char32_t>; 437template <> struct hash<wchar_t>; 438template <> struct hash<short>; 439template <> struct hash<unsigned short>; 440template <> struct hash<int>; 441template <> struct hash<unsigned int>; 442template <> struct hash<long>; 443template <> struct hash<long long>; 444template <> struct hash<unsigned long>; 445template <> struct hash<unsigned long long>; 446 447template <> struct hash<float>; 448template <> struct hash<double>; 449template <> struct hash<long double>; 450 451template<class T> struct hash<T*>; 452 453} // std 454 455POLICY: 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 476template <class _Tp> 477struct _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 483template <class _Tp> 484struct _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 490template <class _Tp> 491struct _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 497template <class _Tp> 498struct _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 504template <class _Tp> 505struct _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 511template <class _Tp> 512struct _LIBCPP_VISIBLE negate : unary_function<_Tp, _Tp> 513{ 514 _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x) const 515 {return -__x;} 516}; 517 518template <class _Tp> 519struct _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 525template <class _Tp> 526struct _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 532template <class _Tp> 533struct _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 541template <class _Tp> 542struct _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 548template <class _Tp> 549struct _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 555template <class _Tp> 556struct _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 562template <class _Tp> 563struct _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 569template <class _Tp> 570struct _LIBCPP_VISIBLE logical_not : unary_function<_Tp, bool> 571{ 572 _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x) const 573 {return !__x;} 574}; 575 576template <class _Tp> 577struct _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 583template <class _Tp> 584struct _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 590template <class _Tp> 591struct _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 597template <class _Predicate> 598class _LIBCPP_VISIBLE unary_negate 599 : public unary_function<typename _Predicate::argument_type, bool> 600{ 601 _Predicate __pred_; 602public: 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 609template <class _Predicate> 610inline _LIBCPP_INLINE_VISIBILITY 611unary_negate<_Predicate> 612not1(const _Predicate& __pred) {return unary_negate<_Predicate>(__pred);} 613 614template <class _Predicate> 615class _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_; 621public: 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 629template <class _Predicate> 630inline _LIBCPP_INLINE_VISIBILITY 631binary_negate<_Predicate> 632not2(const _Predicate& __pred) {return binary_negate<_Predicate>(__pred);} 633 634template <class __Operation> 635class _LIBCPP_VISIBLE binder1st 636 : public unary_function<typename __Operation::second_argument_type, 637 typename __Operation::result_type> 638{ 639protected: 640 __Operation op; 641 typename __Operation::first_argument_type value; 642public: 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 654template <class __Operation, class _Tp> 655inline _LIBCPP_INLINE_VISIBILITY 656binder1st<__Operation> 657bind1st(const __Operation& __op, const _Tp& __x) 658 {return binder1st<__Operation>(__op, __x);} 659 660template <class __Operation> 661class _LIBCPP_VISIBLE binder2nd 662 : public unary_function<typename __Operation::first_argument_type, 663 typename __Operation::result_type> 664{ 665protected: 666 __Operation op; 667 typename __Operation::second_argument_type value; 668public: 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 680template <class __Operation, class _Tp> 681inline _LIBCPP_INLINE_VISIBILITY 682binder2nd<__Operation> 683bind2nd(const __Operation& __op, const _Tp& __x) 684 {return binder2nd<__Operation>(__op, __x);} 685 686template <class _Arg, class _Result> 687class _LIBCPP_VISIBLE pointer_to_unary_function 688 : public unary_function<_Arg, _Result> 689{ 690 _Result (*__f_)(_Arg); 691public: 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 698template <class _Arg, class _Result> 699inline _LIBCPP_INLINE_VISIBILITY 700pointer_to_unary_function<_Arg,_Result> 701ptr_fun(_Result (*__f)(_Arg)) 702 {return pointer_to_unary_function<_Arg,_Result>(__f);} 703 704template <class _Arg1, class _Arg2, class _Result> 705class _LIBCPP_VISIBLE pointer_to_binary_function 706 : public binary_function<_Arg1, _Arg2, _Result> 707{ 708 _Result (*__f_)(_Arg1, _Arg2); 709public: 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 716template <class _Arg1, class _Arg2, class _Result> 717inline _LIBCPP_INLINE_VISIBILITY 718pointer_to_binary_function<_Arg1,_Arg2,_Result> 719ptr_fun(_Result (*__f)(_Arg1,_Arg2)) 720 {return pointer_to_binary_function<_Arg1,_Arg2,_Result>(__f);} 721 722template<class _Sp, class _Tp> 723class _LIBCPP_VISIBLE mem_fun_t : public unary_function<_Tp*, _Sp> 724{ 725 _Sp (_Tp::*__p_)(); 726public: 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 733template<class _Sp, class _Tp, class _Ap> 734class _LIBCPP_VISIBLE mem_fun1_t : public binary_function<_Tp*, _Ap, _Sp> 735{ 736 _Sp (_Tp::*__p_)(_Ap); 737public: 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 744template<class _Sp, class _Tp> 745inline _LIBCPP_INLINE_VISIBILITY 746mem_fun_t<_Sp,_Tp> 747mem_fun(_Sp (_Tp::*__f)()) 748 {return mem_fun_t<_Sp,_Tp>(__f);} 749 750template<class _Sp, class _Tp, class _Ap> 751inline _LIBCPP_INLINE_VISIBILITY 752mem_fun1_t<_Sp,_Tp,_Ap> 753mem_fun(_Sp (_Tp::*__f)(_Ap)) 754 {return mem_fun1_t<_Sp,_Tp,_Ap>(__f);} 755 756template<class _Sp, class _Tp> 757class _LIBCPP_VISIBLE mem_fun_ref_t : public unary_function<_Tp, _Sp> 758{ 759 _Sp (_Tp::*__p_)(); 760public: 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 767template<class _Sp, class _Tp, class _Ap> 768class _LIBCPP_VISIBLE mem_fun1_ref_t : public binary_function<_Tp, _Ap, _Sp> 769{ 770 _Sp (_Tp::*__p_)(_Ap); 771public: 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 778template<class _Sp, class _Tp> 779inline _LIBCPP_INLINE_VISIBILITY 780mem_fun_ref_t<_Sp,_Tp> 781mem_fun_ref(_Sp (_Tp::*__f)()) 782 {return mem_fun_ref_t<_Sp,_Tp>(__f);} 783 784template<class _Sp, class _Tp, class _Ap> 785inline _LIBCPP_INLINE_VISIBILITY 786mem_fun1_ref_t<_Sp,_Tp,_Ap> 787mem_fun_ref(_Sp (_Tp::*__f)(_Ap)) 788 {return mem_fun1_ref_t<_Sp,_Tp,_Ap>(__f);} 789 790template <class _Sp, class _Tp> 791class _LIBCPP_VISIBLE const_mem_fun_t : public unary_function<const _Tp*, _Sp> 792{ 793 _Sp (_Tp::*__p_)() const; 794public: 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 801template <class _Sp, class _Tp, class _Ap> 802class _LIBCPP_VISIBLE const_mem_fun1_t : public binary_function<const _Tp*, _Ap, _Sp> 803{ 804 _Sp (_Tp::*__p_)(_Ap) const; 805public: 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 812template <class _Sp, class _Tp> 813inline _LIBCPP_INLINE_VISIBILITY 814const_mem_fun_t<_Sp,_Tp> 815mem_fun(_Sp (_Tp::*__f)() const) 816 {return const_mem_fun_t<_Sp,_Tp>(__f);} 817 818template <class _Sp, class _Tp, class _Ap> 819inline _LIBCPP_INLINE_VISIBILITY 820const_mem_fun1_t<_Sp,_Tp,_Ap> 821mem_fun(_Sp (_Tp::*__f)(_Ap) const) 822 {return const_mem_fun1_t<_Sp,_Tp,_Ap>(__f);} 823 824template <class _Sp, class _Tp> 825class _LIBCPP_VISIBLE const_mem_fun_ref_t : public unary_function<_Tp, _Sp> 826{ 827 _Sp (_Tp::*__p_)() const; 828public: 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 835template <class _Sp, class _Tp, class _Ap> 836class _LIBCPP_VISIBLE const_mem_fun1_ref_t 837 : public binary_function<_Tp, _Ap, _Sp> 838{ 839 _Sp (_Tp::*__p_)(_Ap) const; 840public: 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 847template <class _Sp, class _Tp> 848inline _LIBCPP_INLINE_VISIBILITY 849const_mem_fun_ref_t<_Sp,_Tp> 850mem_fun_ref(_Sp (_Tp::*__f)() const) 851 {return const_mem_fun_ref_t<_Sp,_Tp>(__f);} 852 853template <class _Sp, class _Tp, class _Ap> 854inline _LIBCPP_INLINE_VISIBILITY 855const_mem_fun1_ref_t<_Sp,_Tp,_Ap> 856mem_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 865template <class _Tp> 866class __mem_fn 867 : public __weak_result_type<_Tp> 868{ 869public: 870 // types 871 typedef _Tp type; 872private: 873 type __f_; 874 875public: 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 888template<class _Rp, class _Tp> 889inline _LIBCPP_INLINE_VISIBILITY 890__mem_fn<_Rp _Tp::*> 891mem_fn(_Rp _Tp::* __pm) 892{ 893 return __mem_fn<_Rp _Tp::*>(__pm); 894} 895 896template<class _Rp, class _Tp, class ..._Args> 897inline _LIBCPP_INLINE_VISIBILITY 898__mem_fn<_Rp (_Tp::*)(_Args...)> 899mem_fn(_Rp (_Tp::* __pm)(_Args...)) 900{ 901 return __mem_fn<_Rp (_Tp::*)(_Args...)>(__pm); 902} 903 904template<class _Rp, class _Tp, class ..._Args> 905inline _LIBCPP_INLINE_VISIBILITY 906__mem_fn<_Rp (_Tp::*)(_Args...) const> 907mem_fn(_Rp (_Tp::* __pm)(_Args...) const) 908{ 909 return __mem_fn<_Rp (_Tp::*)(_Args...) const>(__pm); 910} 911 912template<class _Rp, class _Tp, class ..._Args> 913inline _LIBCPP_INLINE_VISIBILITY 914__mem_fn<_Rp (_Tp::*)(_Args...) volatile> 915mem_fn(_Rp (_Tp::* __pm)(_Args...) volatile) 916{ 917 return __mem_fn<_Rp (_Tp::*)(_Args...) volatile>(__pm); 918} 919 920template<class _Rp, class _Tp, class ..._Args> 921inline _LIBCPP_INLINE_VISIBILITY 922__mem_fn<_Rp (_Tp::*)(_Args...) const volatile> 923mem_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 930class _LIBCPP_EXCEPTION_ABI bad_function_call 931 : public exception 932{ 933}; 934 935template<class _Fp> class _LIBCPP_VISIBLE function; // undefined 936 937namespace __function 938{ 939 940template<class _Rp, class ..._ArgTypes> 941struct __maybe_derive_from_unary_function 942{ 943}; 944 945template<class _Rp, class _A1> 946struct __maybe_derive_from_unary_function<_Rp(_A1)> 947 : public unary_function<_A1, _Rp> 948{ 949}; 950 951template<class _Rp, class ..._ArgTypes> 952struct __maybe_derive_from_binary_function 953{ 954}; 955 956template<class _Rp, class _A1, class _A2> 957struct __maybe_derive_from_binary_function<_Rp(_A1, _A2)> 958 : public binary_function<_A1, _A2, _Rp> 959{ 960}; 961 962template<class _Fp> class __base; 963 964template<class _Rp, class ..._ArgTypes> 965class __base<_Rp(_ArgTypes...)> 966{ 967 __base(const __base&); 968 __base& operator=(const __base&); 969public: 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 983template<class _FD, class _Alloc, class _FB> class __func; 984 985template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes> 986class __func<_Fp, _Alloc, _Rp(_ArgTypes...)> 987 : public __base<_Rp(_ArgTypes...)> 988{ 989 __compressed_pair<_Fp, _Alloc> __f_; 990public: 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 1020template<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 1032template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes> 1033void 1034__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::__clone(__base<_Rp(_ArgTypes...)>* __p) const 1035{ 1036 ::new (__p) __func(__f_.first(), __f_.second()); 1037} 1038 1039template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes> 1040void 1041__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy() _NOEXCEPT 1042{ 1043 __f_.~__compressed_pair<_Fp, _Alloc>(); 1044} 1045 1046template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes> 1047void 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 1056template<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 1065template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes> 1066const 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 1074template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes> 1075const 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 1085template<class _Rp, class ..._ArgTypes> 1086class _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 }; 1130public: 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; 1187public: 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 1199template<class _Rp, class ..._ArgTypes> 1200function<_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 1213template<class _Rp, class ..._ArgTypes> 1214template <class _Alloc> 1215function<_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 1229template<class _Rp, class ..._ArgTypes> 1230function<_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 1246template<class _Rp, class ..._ArgTypes> 1247template <class _Alloc> 1248function<_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 1265template<class _Rp, class ..._ArgTypes> 1266template <class _Fp> 1267function<_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 1291template<class _Rp, class ..._ArgTypes> 1292template <class _Fp, class _Alloc> 1293function<_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 1324template<class _Rp, class ..._ArgTypes> 1325function<_Rp(_ArgTypes...)>& 1326function<_Rp(_ArgTypes...)>::operator=(const function& __f) 1327{ 1328 function(__f).swap(*this); 1329 return *this; 1330} 1331 1332template<class _Rp, class ..._ArgTypes> 1333function<_Rp(_ArgTypes...)>& 1334function<_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 1355template<class _Rp, class ..._ArgTypes> 1356function<_Rp(_ArgTypes...)>& 1357function<_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 1366template<class _Rp, class ..._ArgTypes> 1367template <class _Fp> 1368typename enable_if 1369< 1370 function<_Rp(_ArgTypes...)>::template __callable<typename decay<_Fp>::type>::value, 1371 function<_Rp(_ArgTypes...)>& 1372>::type 1373function<_Rp(_ArgTypes...)>::operator=(_Fp&& __f) 1374{ 1375 function(_VSTD::forward<_Fp>(__f)).swap(*this); 1376 return *this; 1377} 1378 1379template<class _Rp, class ..._ArgTypes> 1380function<_Rp(_ArgTypes...)>::~function() 1381{ 1382 if (__f_ == (__base*)&__buf_) 1383 __f_->destroy(); 1384 else if (__f_) 1385 __f_->destroy_deallocate(); 1386} 1387 1388template<class _Rp, class ..._ArgTypes> 1389void 1390function<_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 1425template<class _Rp, class ..._ArgTypes> 1426_Rp 1427function<_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 1438template<class _Rp, class ..._ArgTypes> 1439const std::type_info& 1440function<_Rp(_ArgTypes...)>::target_type() const _NOEXCEPT 1441{ 1442 if (__f_ == 0) 1443 return typeid(void); 1444 return __f_->target_type(); 1445} 1446 1447template<class _Rp, class ..._ArgTypes> 1448template <typename _Tp> 1449_Tp* 1450function<_Rp(_ArgTypes...)>::target() _NOEXCEPT 1451{ 1452 if (__f_ == 0) 1453 return (_Tp*)0; 1454 return (_Tp*)__f_->target(typeid(_Tp)); 1455} 1456 1457template<class _Rp, class ..._ArgTypes> 1458template <typename _Tp> 1459const _Tp* 1460function<_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 1469template <class _Rp, class... _ArgTypes> 1470inline _LIBCPP_INLINE_VISIBILITY 1471bool 1472operator==(const function<_Rp(_ArgTypes...)>& __f, nullptr_t) _NOEXCEPT {return !__f;} 1473 1474template <class _Rp, class... _ArgTypes> 1475inline _LIBCPP_INLINE_VISIBILITY 1476bool 1477operator==(nullptr_t, const function<_Rp(_ArgTypes...)>& __f) _NOEXCEPT {return !__f;} 1478 1479template <class _Rp, class... _ArgTypes> 1480inline _LIBCPP_INLINE_VISIBILITY 1481bool 1482operator!=(const function<_Rp(_ArgTypes...)>& __f, nullptr_t) _NOEXCEPT {return (bool)__f;} 1483 1484template <class _Rp, class... _ArgTypes> 1485inline _LIBCPP_INLINE_VISIBILITY 1486bool 1487operator!=(nullptr_t, const function<_Rp(_ArgTypes...)>& __f) _NOEXCEPT {return (bool)__f;} 1488 1489template <class _Rp, class... _ArgTypes> 1490inline _LIBCPP_INLINE_VISIBILITY 1491void 1492swap(function<_Rp(_ArgTypes...)>& __x, function<_Rp(_ArgTypes...)>& __y) _NOEXCEPT 1493{return __x.swap(__y);} 1494 1495template<class _Tp> struct __is_bind_expression : public false_type {}; 1496template<class _Tp> struct _LIBCPP_VISIBLE is_bind_expression 1497 : public __is_bind_expression<typename remove_cv<_Tp>::type> {}; 1498 1499template<class _Tp> struct __is_placeholder : public integral_constant<int, 0> {}; 1500template<class _Tp> struct _LIBCPP_VISIBLE is_placeholder 1501 : public __is_placeholder<typename remove_cv<_Tp>::type> {}; 1502 1503namespace placeholders 1504{ 1505 1506template <int _Np> struct __ph {}; 1507 1508extern __ph<1> _1; 1509extern __ph<2> _2; 1510extern __ph<3> _3; 1511extern __ph<4> _4; 1512extern __ph<5> _5; 1513extern __ph<6> _6; 1514extern __ph<7> _7; 1515extern __ph<8> _8; 1516extern __ph<9> _9; 1517extern __ph<10> _10; 1518 1519} // placeholders 1520 1521template<int _Np> 1522struct __is_placeholder<placeholders::__ph<_Np> > 1523 : public integral_constant<int, _Np> {}; 1524 1525template <class _Tp, class _Uj> 1526inline _LIBCPP_INLINE_VISIBILITY 1527_Tp& 1528__mu(reference_wrapper<_Tp> __t, _Uj&) 1529{ 1530 return __t.get(); 1531} 1532 1533template <class _Ti, class ..._Uj, size_t ..._Indx> 1534inline _LIBCPP_INLINE_VISIBILITY 1535typename __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 1541template <class _Ti, class ..._Uj> 1542inline _LIBCPP_INLINE_VISIBILITY 1543typename 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 1554template <bool IsPh, class _Ti, class _Uj> 1555struct __mu_return2 {}; 1556 1557template <class _Ti, class _Uj> 1558struct __mu_return2<true, _Ti, _Uj> 1559{ 1560 typedef typename tuple_element<is_placeholder<_Ti>::value - 1, _Uj>::type type; 1561}; 1562 1563template <class _Ti, class _Uj> 1564inline _LIBCPP_INLINE_VISIBILITY 1565typename 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 1576template <class _Ti, class _Uj> 1577inline _LIBCPP_INLINE_VISIBILITY 1578typename 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 1590template <class _Ti, bool IsReferenceWrapper, bool IsBindEx, bool IsPh, 1591 class _TupleUj> 1592struct ____mu_return; 1593 1594template <class _Ti, class ..._Uj> 1595struct ____mu_return<_Ti, false, true, false, tuple<_Uj...> > 1596{ 1597 typedef typename __invoke_of<_Ti&, _Uj...>::type type; 1598}; 1599 1600template <class _Ti, class _TupleUj> 1601struct ____mu_return<_Ti, false, false, true, _TupleUj> 1602{ 1603 typedef typename tuple_element<is_placeholder<_Ti>::value - 1, 1604 _TupleUj>::type&& type; 1605}; 1606 1607template <class _Ti, class _TupleUj> 1608struct ____mu_return<_Ti, true, false, false, _TupleUj> 1609{ 1610 typedef typename _Ti::type& type; 1611}; 1612 1613template <class _Ti, class _TupleUj> 1614struct ____mu_return<_Ti, false, false, false, _TupleUj> 1615{ 1616 typedef _Ti& type; 1617}; 1618 1619template <class _Ti, class _TupleUj> 1620struct __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 1629template <class _Fp, class _BoundArgs, class _TupleUj> 1630struct __bind_return; 1631 1632template <class _Fp, class ..._BoundArgs, class _TupleUj> 1633struct __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 1646template <class _Fp, class ..._BoundArgs, class _TupleUj> 1647struct __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 1660template <class _Fp, class _BoundArgs, size_t ..._Indx, class _Args> 1661inline _LIBCPP_INLINE_VISIBILITY 1662typename __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 1669template<class _Fp, class ..._BoundArgs> 1670class __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; 1679public: 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 1735template<class _Fp, class ..._BoundArgs> 1736struct __is_bind_expression<__bind<_Fp, _BoundArgs...> > : public true_type {}; 1737 1738template<class _Rp, class _Fp, class ..._BoundArgs> 1739class __bind_r 1740 : public __bind<_Fp, _BoundArgs...> 1741{ 1742 typedef __bind<_Fp, _BoundArgs...> base; 1743public: 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 1795template<class _Rp, class _Fp, class ..._BoundArgs> 1796struct __is_bind_expression<__bind_r<_Rp, _Fp, _BoundArgs...> > : public true_type {}; 1797 1798template<class _Fp, class ..._BoundArgs> 1799inline _LIBCPP_INLINE_VISIBILITY 1800__bind<_Fp, _BoundArgs...> 1801bind(_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 1807template<class _Rp, class _Fp, class ..._BoundArgs> 1808inline _LIBCPP_INLINE_VISIBILITY 1809__bind_r<_Rp, _Fp, _BoundArgs...> 1810bind(_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 1818template <> 1819struct _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 1826template <> 1827struct _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 1834template <> 1835struct _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 1842template <> 1843struct _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 1852template <> 1853struct _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 1860template <> 1861struct _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 1870template <> 1871struct _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 1878template <> 1879struct _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 1886template <> 1887struct _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 1894template <> 1895struct _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 1902template <> 1903struct _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 1910template <> 1911struct _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 1918template <> 1919struct _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 1926template <> 1927struct _LIBCPP_VISIBLE hash<long long> 1928 : public __scalar_hash<long long> 1929{ 1930}; 1931 1932template <> 1933struct _LIBCPP_VISIBLE hash<unsigned long long> 1934 : public __scalar_hash<unsigned long long> 1935{ 1936}; 1937 1938template <> 1939struct _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 1952template <> 1953struct _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 1966template <> 1967struct _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 2021