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> // <class T=void> in C++14 72struct plus : binary_function<T, T, T> 73{ 74 T operator()(const T& x, const T& y) const; 75}; 76 77template <class T> // <class T=void> in C++14 78struct minus : binary_function<T, T, T> 79{ 80 T operator()(const T& x, const T& y) const; 81}; 82 83template <class T> // <class T=void> in C++14 84struct multiplies : binary_function<T, T, T> 85{ 86 T operator()(const T& x, const T& y) const; 87}; 88 89template <class T> // <class T=void> in C++14 90struct divides : binary_function<T, T, T> 91{ 92 T operator()(const T& x, const T& y) const; 93}; 94 95template <class T> // <class T=void> in C++14 96struct modulus : binary_function<T, T, T> 97{ 98 T operator()(const T& x, const T& y) const; 99}; 100 101template <class T> // <class T=void> in C++14 102struct negate : unary_function<T, T> 103{ 104 T operator()(const T& x) const; 105}; 106 107template <class T> // <class T=void> in C++14 108struct equal_to : binary_function<T, T, bool> 109{ 110 bool operator()(const T& x, const T& y) const; 111}; 112 113template <class T> // <class T=void> in C++14 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> // <class T=void> in C++14 120struct greater : binary_function<T, T, bool> 121{ 122 bool operator()(const T& x, const T& y) const; 123}; 124 125template <class T> // <class T=void> in C++14 126struct less : binary_function<T, T, bool> 127{ 128 bool operator()(const T& x, const T& y) const; 129}; 130 131template <class T> // <class T=void> in C++14 132struct greater_equal : binary_function<T, T, bool> 133{ 134 bool operator()(const T& x, const T& y) const; 135}; 136 137template <class T> // <class T=void> in C++14 138struct less_equal : binary_function<T, T, bool> 139{ 140 bool operator()(const T& x, const T& y) const; 141}; 142 143template <class T> // <class T=void> in C++14 144struct logical_and : binary_function<T, T, bool> 145{ 146 bool operator()(const T& x, const T& y) const; 147}; 148 149template <class T> // <class T=void> in C++14 150struct logical_or : binary_function<T, T, bool> 151{ 152 bool operator()(const T& x, const T& y) const; 153}; 154 155template <class T> // <class T=void> in C++14 156struct logical_not : unary_function<T, bool> 157{ 158 bool operator()(const T& x) const; 159}; 160 161template <class T> // <class T=void> in C++14 162struct bit_and : unary_function<T, bool> 163{ 164 bool operator()(const T& x, const T& y) const; 165}; 166 167template <class T> // <class T=void> in C++14 168struct bit_or : unary_function<T, bool> 169{ 170 bool operator()(const T& x, const T& y) const; 171}; 172 173template <class T> // <class T=void> in C++14 174struct bit_xor : unary_function<T, bool> 175{ 176 bool operator()(const T& x, const T& y) const; 177}; 178 179template <class T=void> // C++14 180struct bit_xor : unary_function<T, bool> 181{ 182 bool operator()(const T& x) const; 183}; 184 185template <class Predicate> 186class unary_negate 187 : public unary_function<typename Predicate::argument_type, bool> 188{ 189public: 190 explicit unary_negate(const Predicate& pred); 191 bool operator()(const typename Predicate::argument_type& x) const; 192}; 193 194template <class Predicate> unary_negate<Predicate> not1(const Predicate& pred); 195 196template <class Predicate> 197class binary_negate 198 : public binary_function<typename Predicate::first_argument_type, 199 typename Predicate::second_argument_type, 200 bool> 201{ 202public: 203 explicit binary_negate(const Predicate& pred); 204 bool operator()(const typename Predicate::first_argument_type& x, 205 const typename Predicate::second_argument_type& y) const; 206}; 207 208template <class Predicate> binary_negate<Predicate> not2(const Predicate& pred); 209 210template<class T> struct is_bind_expression; 211template<class T> struct is_placeholder; 212 213template<class Fn, class... BoundArgs> 214 unspecified bind(Fn&&, BoundArgs&&...); 215template<class R, class Fn, class... BoundArgs> 216 unspecified bind(Fn&&, BoundArgs&&...); 217 218namespace placeholders { 219 // M is the implementation-defined number of placeholders 220 extern unspecified _1; 221 extern unspecified _2; 222 . 223 . 224 . 225 extern unspecified _Mp; 226} 227 228template <class Operation> 229class binder1st 230 : public unary_function<typename Operation::second_argument_type, 231 typename Operation::result_type> 232{ 233protected: 234 Operation op; 235 typename Operation::first_argument_type value; 236public: 237 binder1st(const Operation& x, const typename Operation::first_argument_type y); 238 typename Operation::result_type operator()( typename Operation::second_argument_type& x) const; 239 typename Operation::result_type operator()(const typename Operation::second_argument_type& x) const; 240}; 241 242template <class Operation, class T> 243binder1st<Operation> bind1st(const Operation& op, const T& x); 244 245template <class Operation> 246class binder2nd 247 : public unary_function<typename Operation::first_argument_type, 248 typename Operation::result_type> 249{ 250protected: 251 Operation op; 252 typename Operation::second_argument_type value; 253public: 254 binder2nd(const Operation& x, const typename Operation::second_argument_type y); 255 typename Operation::result_type operator()( typename Operation::first_argument_type& x) const; 256 typename Operation::result_type operator()(const typename Operation::first_argument_type& x) const; 257}; 258 259template <class Operation, class T> 260binder2nd<Operation> bind2nd(const Operation& op, const T& x); 261 262template <class Arg, class Result> 263class pointer_to_unary_function : public unary_function<Arg, Result> 264{ 265public: 266 explicit pointer_to_unary_function(Result (*f)(Arg)); 267 Result operator()(Arg x) const; 268}; 269 270template <class Arg, class Result> 271pointer_to_unary_function<Arg,Result> ptr_fun(Result (*f)(Arg)); 272 273template <class Arg1, class Arg2, class Result> 274class pointer_to_binary_function : public binary_function<Arg1, Arg2, Result> 275{ 276public: 277 explicit pointer_to_binary_function(Result (*f)(Arg1, Arg2)); 278 Result operator()(Arg1 x, Arg2 y) const; 279}; 280 281template <class Arg1, class Arg2, class Result> 282pointer_to_binary_function<Arg1,Arg2,Result> ptr_fun(Result (*f)(Arg1,Arg2)); 283 284template<class S, class T> 285class mem_fun_t : public unary_function<T*, S> 286{ 287public: 288 explicit mem_fun_t(S (T::*p)()); 289 S operator()(T* p) const; 290}; 291 292template<class S, class T, class A> 293class mem_fun1_t : public binary_function<T*, A, S> 294{ 295public: 296 explicit mem_fun1_t(S (T::*p)(A)); 297 S operator()(T* p, A x) const; 298}; 299 300template<class S, class T> mem_fun_t<S,T> mem_fun(S (T::*f)()); 301template<class S, class T, class A> mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A)); 302 303template<class S, class T> 304class mem_fun_ref_t : public unary_function<T, S> 305{ 306public: 307 explicit mem_fun_ref_t(S (T::*p)()); 308 S operator()(T& p) const; 309}; 310 311template<class S, class T, class A> 312class mem_fun1_ref_t : public binary_function<T, A, S> 313{ 314public: 315 explicit mem_fun1_ref_t(S (T::*p)(A)); 316 S operator()(T& p, A x) const; 317}; 318 319template<class S, class T> mem_fun_ref_t<S,T> mem_fun_ref(S (T::*f)()); 320template<class S, class T, class A> mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A)); 321 322template <class S, class T> 323class const_mem_fun_t : public unary_function<const T*, S> 324{ 325public: 326 explicit const_mem_fun_t(S (T::*p)() const); 327 S operator()(const T* p) const; 328}; 329 330template <class S, class T, class A> 331class const_mem_fun1_t : public binary_function<const T*, A, S> 332{ 333public: 334 explicit const_mem_fun1_t(S (T::*p)(A) const); 335 S operator()(const T* p, A x) const; 336}; 337 338template <class S, class T> const_mem_fun_t<S,T> mem_fun(S (T::*f)() const); 339template <class S, class T, class A> const_mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A) const); 340 341template <class S, class T> 342class const_mem_fun_ref_t : public unary_function<T, S> 343{ 344public: 345 explicit const_mem_fun_ref_t(S (T::*p)() const); 346 S operator()(const T& p) const; 347}; 348 349template <class S, class T, class A> 350class const_mem_fun1_ref_t : public binary_function<T, A, S> 351{ 352public: 353 explicit const_mem_fun1_ref_t(S (T::*p)(A) const); 354 S operator()(const T& p, A x) const; 355}; 356 357template <class S, class T> const_mem_fun_ref_t<S,T> mem_fun_ref(S (T::*f)() const); 358template <class S, class T, class A> const_mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A) const); 359 360template<class R, class T> unspecified mem_fn(R T::*); 361 362class bad_function_call 363 : public exception 364{ 365}; 366 367template<class> class function; // undefined 368 369template<class R, class... ArgTypes> 370class function<R(ArgTypes...)> 371 : public unary_function<T1, R> // iff sizeof...(ArgTypes) == 1 and 372 // ArgTypes contains T1 373 : public binary_function<T1, T2, R> // iff sizeof...(ArgTypes) == 2 and 374 // ArgTypes contains T1 and T2 375{ 376public: 377 typedef R result_type; 378 379 // construct/copy/destroy: 380 function() noexcept; 381 function(nullptr_t) noexcept; 382 function(const function&); 383 function(function&&) noexcept; 384 template<class F> 385 function(F); 386 template<Allocator Alloc> 387 function(allocator_arg_t, const Alloc&) noexcept; 388 template<Allocator Alloc> 389 function(allocator_arg_t, const Alloc&, nullptr_t) noexcept; 390 template<Allocator Alloc> 391 function(allocator_arg_t, const Alloc&, const function&); 392 template<Allocator Alloc> 393 function(allocator_arg_t, const Alloc&, function&&); 394 template<class F, Allocator Alloc> 395 function(allocator_arg_t, const Alloc&, F); 396 397 function& operator=(const function&); 398 function& operator=(function&&) noexcept; 399 function& operator=(nullptr_t) noexcept; 400 template<class F> 401 function& operator=(F&&); 402 template<class F> 403 function& operator=(reference_wrapper<F>) noexcept; 404 405 ~function(); 406 407 // function modifiers: 408 void swap(function&) noexcept; 409 template<class F, class Alloc> 410 void assign(F&&, const Alloc&); // Removed in C++17 411 412 // function capacity: 413 explicit operator bool() const noexcept; 414 415 // function invocation: 416 R operator()(ArgTypes...) const; 417 418 // function target access: 419 const std::type_info& target_type() const noexcept; 420 template <typename T> T* target() noexcept; 421 template <typename T> const T* target() const noexcept; 422}; 423 424// Null pointer comparisons: 425template <class R, class ... ArgTypes> 426 bool operator==(const function<R(ArgTypes...)>&, nullptr_t) noexcept; 427 428template <class R, class ... ArgTypes> 429 bool operator==(nullptr_t, const function<R(ArgTypes...)>&) noexcept; 430 431template <class R, class ... ArgTypes> 432 bool operator!=(const function<R(ArgTypes...)>&, nullptr_t) noexcept; 433 434template <class R, class ... ArgTypes> 435 bool operator!=(nullptr_t, const function<R(ArgTypes...)>&) noexcept; 436 437// specialized algorithms: 438template <class R, class ... ArgTypes> 439 void swap(function<R(ArgTypes...)>&, function<R(ArgTypes...)>&) noexcept; 440 441template <class T> struct hash; 442 443template <> struct hash<bool>; 444template <> struct hash<char>; 445template <> struct hash<signed char>; 446template <> struct hash<unsigned char>; 447template <> struct hash<char16_t>; 448template <> struct hash<char32_t>; 449template <> struct hash<wchar_t>; 450template <> struct hash<short>; 451template <> struct hash<unsigned short>; 452template <> struct hash<int>; 453template <> struct hash<unsigned int>; 454template <> struct hash<long>; 455template <> struct hash<long long>; 456template <> struct hash<unsigned long>; 457template <> struct hash<unsigned long long>; 458 459template <> struct hash<float>; 460template <> struct hash<double>; 461template <> struct hash<long double>; 462 463template<class T> struct hash<T*>; 464 465} // std 466 467POLICY: For non-variadic implementations, the number of arguments is limited 468 to 3. It is hoped that the need for non-variadic implementations 469 will be minimal. 470 471*/ 472 473#include <__config> 474#include <type_traits> 475#include <typeinfo> 476#include <exception> 477#include <memory> 478#include <tuple> 479 480#include <__functional_base> 481 482#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 483#pragma GCC system_header 484#endif 485 486_LIBCPP_BEGIN_NAMESPACE_STD 487 488#if _LIBCPP_STD_VER > 11 489template <class _Tp = void> 490#else 491template <class _Tp> 492#endif 493struct _LIBCPP_TYPE_VIS_ONLY plus : binary_function<_Tp, _Tp, _Tp> 494{ 495 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 496 _Tp operator()(const _Tp& __x, const _Tp& __y) const 497 {return __x + __y;} 498}; 499 500#if _LIBCPP_STD_VER > 11 501template <> 502struct _LIBCPP_TYPE_VIS_ONLY plus<void> 503{ 504 template <class _T1, class _T2> 505 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 506 auto operator()(_T1&& __t, _T2&& __u) const 507 _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) + _VSTD::forward<_T2>(__u))) 508 -> decltype (_VSTD::forward<_T1>(__t) + _VSTD::forward<_T2>(__u)) 509 { return _VSTD::forward<_T1>(__t) + _VSTD::forward<_T2>(__u); } 510 typedef void is_transparent; 511}; 512#endif 513 514 515#if _LIBCPP_STD_VER > 11 516template <class _Tp = void> 517#else 518template <class _Tp> 519#endif 520struct _LIBCPP_TYPE_VIS_ONLY minus : binary_function<_Tp, _Tp, _Tp> 521{ 522 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 523 _Tp operator()(const _Tp& __x, const _Tp& __y) const 524 {return __x - __y;} 525}; 526 527#if _LIBCPP_STD_VER > 11 528template <> 529struct _LIBCPP_TYPE_VIS_ONLY minus<void> 530{ 531 template <class _T1, class _T2> 532 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 533 auto operator()(_T1&& __t, _T2&& __u) const 534 _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) - _VSTD::forward<_T2>(__u))) 535 -> decltype (_VSTD::forward<_T1>(__t) - _VSTD::forward<_T2>(__u)) 536 { return _VSTD::forward<_T1>(__t) - _VSTD::forward<_T2>(__u); } 537 typedef void is_transparent; 538}; 539#endif 540 541 542#if _LIBCPP_STD_VER > 11 543template <class _Tp = void> 544#else 545template <class _Tp> 546#endif 547struct _LIBCPP_TYPE_VIS_ONLY multiplies : binary_function<_Tp, _Tp, _Tp> 548{ 549 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 550 _Tp operator()(const _Tp& __x, const _Tp& __y) const 551 {return __x * __y;} 552}; 553 554#if _LIBCPP_STD_VER > 11 555template <> 556struct _LIBCPP_TYPE_VIS_ONLY multiplies<void> 557{ 558 template <class _T1, class _T2> 559 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 560 auto operator()(_T1&& __t, _T2&& __u) const 561 _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) * _VSTD::forward<_T2>(__u))) 562 -> decltype (_VSTD::forward<_T1>(__t) * _VSTD::forward<_T2>(__u)) 563 { return _VSTD::forward<_T1>(__t) * _VSTD::forward<_T2>(__u); } 564 typedef void is_transparent; 565}; 566#endif 567 568 569#if _LIBCPP_STD_VER > 11 570template <class _Tp = void> 571#else 572template <class _Tp> 573#endif 574struct _LIBCPP_TYPE_VIS_ONLY divides : binary_function<_Tp, _Tp, _Tp> 575{ 576 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 577 _Tp operator()(const _Tp& __x, const _Tp& __y) const 578 {return __x / __y;} 579}; 580 581#if _LIBCPP_STD_VER > 11 582template <> 583struct _LIBCPP_TYPE_VIS_ONLY divides<void> 584{ 585 template <class _T1, class _T2> 586 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 587 auto operator()(_T1&& __t, _T2&& __u) const 588 _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) / _VSTD::forward<_T2>(__u))) 589 -> decltype (_VSTD::forward<_T1>(__t) / _VSTD::forward<_T2>(__u)) 590 { return _VSTD::forward<_T1>(__t) / _VSTD::forward<_T2>(__u); } 591 typedef void is_transparent; 592}; 593#endif 594 595 596#if _LIBCPP_STD_VER > 11 597template <class _Tp = void> 598#else 599template <class _Tp> 600#endif 601struct _LIBCPP_TYPE_VIS_ONLY modulus : binary_function<_Tp, _Tp, _Tp> 602{ 603 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 604 _Tp operator()(const _Tp& __x, const _Tp& __y) const 605 {return __x % __y;} 606}; 607 608#if _LIBCPP_STD_VER > 11 609template <> 610struct _LIBCPP_TYPE_VIS_ONLY modulus<void> 611{ 612 template <class _T1, class _T2> 613 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 614 auto operator()(_T1&& __t, _T2&& __u) const 615 _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) % _VSTD::forward<_T2>(__u))) 616 -> decltype (_VSTD::forward<_T1>(__t) % _VSTD::forward<_T2>(__u)) 617 { return _VSTD::forward<_T1>(__t) % _VSTD::forward<_T2>(__u); } 618 typedef void is_transparent; 619}; 620#endif 621 622 623#if _LIBCPP_STD_VER > 11 624template <class _Tp = void> 625#else 626template <class _Tp> 627#endif 628struct _LIBCPP_TYPE_VIS_ONLY negate : unary_function<_Tp, _Tp> 629{ 630 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 631 _Tp operator()(const _Tp& __x) const 632 {return -__x;} 633}; 634 635#if _LIBCPP_STD_VER > 11 636template <> 637struct _LIBCPP_TYPE_VIS_ONLY negate<void> 638{ 639 template <class _Tp> 640 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 641 auto operator()(_Tp&& __x) const 642 _NOEXCEPT_(noexcept(- _VSTD::forward<_Tp>(__x))) 643 -> decltype (- _VSTD::forward<_Tp>(__x)) 644 { return - _VSTD::forward<_Tp>(__x); } 645 typedef void is_transparent; 646}; 647#endif 648 649 650#if _LIBCPP_STD_VER > 11 651template <class _Tp = void> 652#else 653template <class _Tp> 654#endif 655struct _LIBCPP_TYPE_VIS_ONLY equal_to : binary_function<_Tp, _Tp, bool> 656{ 657 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 658 bool operator()(const _Tp& __x, const _Tp& __y) const 659 {return __x == __y;} 660}; 661 662#if _LIBCPP_STD_VER > 11 663template <> 664struct _LIBCPP_TYPE_VIS_ONLY equal_to<void> 665{ 666 template <class _T1, class _T2> 667 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 668 auto operator()(_T1&& __t, _T2&& __u) const 669 _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) == _VSTD::forward<_T2>(__u))) 670 -> decltype (_VSTD::forward<_T1>(__t) == _VSTD::forward<_T2>(__u)) 671 { return _VSTD::forward<_T1>(__t) == _VSTD::forward<_T2>(__u); } 672 typedef void is_transparent; 673}; 674#endif 675 676 677#if _LIBCPP_STD_VER > 11 678template <class _Tp = void> 679#else 680template <class _Tp> 681#endif 682struct _LIBCPP_TYPE_VIS_ONLY not_equal_to : binary_function<_Tp, _Tp, bool> 683{ 684 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 685 bool operator()(const _Tp& __x, const _Tp& __y) const 686 {return __x != __y;} 687}; 688 689#if _LIBCPP_STD_VER > 11 690template <> 691struct _LIBCPP_TYPE_VIS_ONLY not_equal_to<void> 692{ 693 template <class _T1, class _T2> 694 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 695 auto operator()(_T1&& __t, _T2&& __u) const 696 _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) != _VSTD::forward<_T2>(__u))) 697 -> decltype (_VSTD::forward<_T1>(__t) != _VSTD::forward<_T2>(__u)) 698 { return _VSTD::forward<_T1>(__t) != _VSTD::forward<_T2>(__u); } 699 typedef void is_transparent; 700}; 701#endif 702 703 704#if _LIBCPP_STD_VER > 11 705template <class _Tp = void> 706#else 707template <class _Tp> 708#endif 709struct _LIBCPP_TYPE_VIS_ONLY greater : binary_function<_Tp, _Tp, bool> 710{ 711 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 712 bool operator()(const _Tp& __x, const _Tp& __y) const 713 {return __x > __y;} 714}; 715 716#if _LIBCPP_STD_VER > 11 717template <> 718struct _LIBCPP_TYPE_VIS_ONLY greater<void> 719{ 720 template <class _T1, class _T2> 721 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 722 auto operator()(_T1&& __t, _T2&& __u) const 723 _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) > _VSTD::forward<_T2>(__u))) 724 -> decltype (_VSTD::forward<_T1>(__t) > _VSTD::forward<_T2>(__u)) 725 { return _VSTD::forward<_T1>(__t) > _VSTD::forward<_T2>(__u); } 726 typedef void is_transparent; 727}; 728#endif 729 730 731// less in <__functional_base> 732 733#if _LIBCPP_STD_VER > 11 734template <class _Tp = void> 735#else 736template <class _Tp> 737#endif 738struct _LIBCPP_TYPE_VIS_ONLY greater_equal : binary_function<_Tp, _Tp, bool> 739{ 740 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 741 bool operator()(const _Tp& __x, const _Tp& __y) const 742 {return __x >= __y;} 743}; 744 745#if _LIBCPP_STD_VER > 11 746template <> 747struct _LIBCPP_TYPE_VIS_ONLY greater_equal<void> 748{ 749 template <class _T1, class _T2> 750 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 751 auto operator()(_T1&& __t, _T2&& __u) const 752 _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) >= _VSTD::forward<_T2>(__u))) 753 -> decltype (_VSTD::forward<_T1>(__t) >= _VSTD::forward<_T2>(__u)) 754 { return _VSTD::forward<_T1>(__t) >= _VSTD::forward<_T2>(__u); } 755 typedef void is_transparent; 756}; 757#endif 758 759 760#if _LIBCPP_STD_VER > 11 761template <class _Tp = void> 762#else 763template <class _Tp> 764#endif 765struct _LIBCPP_TYPE_VIS_ONLY less_equal : binary_function<_Tp, _Tp, bool> 766{ 767 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 768 bool operator()(const _Tp& __x, const _Tp& __y) const 769 {return __x <= __y;} 770}; 771 772#if _LIBCPP_STD_VER > 11 773template <> 774struct _LIBCPP_TYPE_VIS_ONLY less_equal<void> 775{ 776 template <class _T1, class _T2> 777 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 778 auto operator()(_T1&& __t, _T2&& __u) const 779 _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) <= _VSTD::forward<_T2>(__u))) 780 -> decltype (_VSTD::forward<_T1>(__t) <= _VSTD::forward<_T2>(__u)) 781 { return _VSTD::forward<_T1>(__t) <= _VSTD::forward<_T2>(__u); } 782 typedef void is_transparent; 783}; 784#endif 785 786 787#if _LIBCPP_STD_VER > 11 788template <class _Tp = void> 789#else 790template <class _Tp> 791#endif 792struct _LIBCPP_TYPE_VIS_ONLY logical_and : binary_function<_Tp, _Tp, bool> 793{ 794 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 795 bool operator()(const _Tp& __x, const _Tp& __y) const 796 {return __x && __y;} 797}; 798 799#if _LIBCPP_STD_VER > 11 800template <> 801struct _LIBCPP_TYPE_VIS_ONLY logical_and<void> 802{ 803 template <class _T1, class _T2> 804 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 805 auto operator()(_T1&& __t, _T2&& __u) const 806 _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) && _VSTD::forward<_T2>(__u))) 807 -> decltype (_VSTD::forward<_T1>(__t) && _VSTD::forward<_T2>(__u)) 808 { return _VSTD::forward<_T1>(__t) && _VSTD::forward<_T2>(__u); } 809 typedef void is_transparent; 810}; 811#endif 812 813 814#if _LIBCPP_STD_VER > 11 815template <class _Tp = void> 816#else 817template <class _Tp> 818#endif 819struct _LIBCPP_TYPE_VIS_ONLY logical_or : binary_function<_Tp, _Tp, bool> 820{ 821 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 822 bool operator()(const _Tp& __x, const _Tp& __y) const 823 {return __x || __y;} 824}; 825 826#if _LIBCPP_STD_VER > 11 827template <> 828struct _LIBCPP_TYPE_VIS_ONLY logical_or<void> 829{ 830 template <class _T1, class _T2> 831 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 832 auto operator()(_T1&& __t, _T2&& __u) const 833 _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) || _VSTD::forward<_T2>(__u))) 834 -> decltype (_VSTD::forward<_T1>(__t) || _VSTD::forward<_T2>(__u)) 835 { return _VSTD::forward<_T1>(__t) || _VSTD::forward<_T2>(__u); } 836 typedef void is_transparent; 837}; 838#endif 839 840 841#if _LIBCPP_STD_VER > 11 842template <class _Tp = void> 843#else 844template <class _Tp> 845#endif 846struct _LIBCPP_TYPE_VIS_ONLY logical_not : unary_function<_Tp, bool> 847{ 848 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 849 bool operator()(const _Tp& __x) const 850 {return !__x;} 851}; 852 853#if _LIBCPP_STD_VER > 11 854template <> 855struct _LIBCPP_TYPE_VIS_ONLY logical_not<void> 856{ 857 template <class _Tp> 858 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 859 auto operator()(_Tp&& __x) const 860 _NOEXCEPT_(noexcept(!_VSTD::forward<_Tp>(__x))) 861 -> decltype (!_VSTD::forward<_Tp>(__x)) 862 { return !_VSTD::forward<_Tp>(__x); } 863 typedef void is_transparent; 864}; 865#endif 866 867 868#if _LIBCPP_STD_VER > 11 869template <class _Tp = void> 870#else 871template <class _Tp> 872#endif 873struct _LIBCPP_TYPE_VIS_ONLY bit_and : binary_function<_Tp, _Tp, _Tp> 874{ 875 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 876 _Tp operator()(const _Tp& __x, const _Tp& __y) const 877 {return __x & __y;} 878}; 879 880#if _LIBCPP_STD_VER > 11 881template <> 882struct _LIBCPP_TYPE_VIS_ONLY bit_and<void> 883{ 884 template <class _T1, class _T2> 885 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 886 auto operator()(_T1&& __t, _T2&& __u) const 887 _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) & _VSTD::forward<_T2>(__u))) 888 -> decltype (_VSTD::forward<_T1>(__t) & _VSTD::forward<_T2>(__u)) 889 { return _VSTD::forward<_T1>(__t) & _VSTD::forward<_T2>(__u); } 890 typedef void is_transparent; 891}; 892#endif 893 894 895#if _LIBCPP_STD_VER > 11 896template <class _Tp = void> 897#else 898template <class _Tp> 899#endif 900struct _LIBCPP_TYPE_VIS_ONLY bit_or : binary_function<_Tp, _Tp, _Tp> 901{ 902 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 903 _Tp operator()(const _Tp& __x, const _Tp& __y) const 904 {return __x | __y;} 905}; 906 907#if _LIBCPP_STD_VER > 11 908template <> 909struct _LIBCPP_TYPE_VIS_ONLY bit_or<void> 910{ 911 template <class _T1, class _T2> 912 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 913 auto operator()(_T1&& __t, _T2&& __u) const 914 _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) | _VSTD::forward<_T2>(__u))) 915 -> decltype (_VSTD::forward<_T1>(__t) | _VSTD::forward<_T2>(__u)) 916 { return _VSTD::forward<_T1>(__t) | _VSTD::forward<_T2>(__u); } 917 typedef void is_transparent; 918}; 919#endif 920 921 922#if _LIBCPP_STD_VER > 11 923template <class _Tp = void> 924#else 925template <class _Tp> 926#endif 927struct _LIBCPP_TYPE_VIS_ONLY bit_xor : binary_function<_Tp, _Tp, _Tp> 928{ 929 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 930 _Tp operator()(const _Tp& __x, const _Tp& __y) const 931 {return __x ^ __y;} 932}; 933 934#if _LIBCPP_STD_VER > 11 935template <> 936struct _LIBCPP_TYPE_VIS_ONLY bit_xor<void> 937{ 938 template <class _T1, class _T2> 939 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 940 auto operator()(_T1&& __t, _T2&& __u) const 941 _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) ^ _VSTD::forward<_T2>(__u))) 942 -> decltype (_VSTD::forward<_T1>(__t) ^ _VSTD::forward<_T2>(__u)) 943 { return _VSTD::forward<_T1>(__t) ^ _VSTD::forward<_T2>(__u); } 944 typedef void is_transparent; 945}; 946#endif 947 948 949#if _LIBCPP_STD_VER > 11 950template <class _Tp = void> 951struct _LIBCPP_TYPE_VIS_ONLY bit_not : unary_function<_Tp, _Tp> 952{ 953 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 954 _Tp operator()(const _Tp& __x) const 955 {return ~__x;} 956}; 957 958template <> 959struct _LIBCPP_TYPE_VIS_ONLY bit_not<void> 960{ 961 template <class _Tp> 962 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 963 auto operator()(_Tp&& __x) const 964 _NOEXCEPT_(noexcept(~_VSTD::forward<_Tp>(__x))) 965 -> decltype (~_VSTD::forward<_Tp>(__x)) 966 { return ~_VSTD::forward<_Tp>(__x); } 967 typedef void is_transparent; 968}; 969#endif 970 971template <class _Predicate> 972class _LIBCPP_TYPE_VIS_ONLY unary_negate 973 : public unary_function<typename _Predicate::argument_type, bool> 974{ 975 _Predicate __pred_; 976public: 977 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 978 explicit unary_negate(const _Predicate& __pred) 979 : __pred_(__pred) {} 980 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 981 bool operator()(const typename _Predicate::argument_type& __x) const 982 {return !__pred_(__x);} 983}; 984 985template <class _Predicate> 986inline _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 987unary_negate<_Predicate> 988not1(const _Predicate& __pred) {return unary_negate<_Predicate>(__pred);} 989 990template <class _Predicate> 991class _LIBCPP_TYPE_VIS_ONLY binary_negate 992 : public binary_function<typename _Predicate::first_argument_type, 993 typename _Predicate::second_argument_type, 994 bool> 995{ 996 _Predicate __pred_; 997public: 998 _LIBCPP_INLINE_VISIBILITY explicit _LIBCPP_CONSTEXPR_AFTER_CXX11 999 binary_negate(const _Predicate& __pred) : __pred_(__pred) {} 1000 1001 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 1002 bool operator()(const typename _Predicate::first_argument_type& __x, 1003 const typename _Predicate::second_argument_type& __y) const 1004 {return !__pred_(__x, __y);} 1005}; 1006 1007template <class _Predicate> 1008inline _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 1009binary_negate<_Predicate> 1010not2(const _Predicate& __pred) {return binary_negate<_Predicate>(__pred);} 1011 1012template <class __Operation> 1013class _LIBCPP_TYPE_VIS_ONLY binder1st 1014 : public unary_function<typename __Operation::second_argument_type, 1015 typename __Operation::result_type> 1016{ 1017protected: 1018 __Operation op; 1019 typename __Operation::first_argument_type value; 1020public: 1021 _LIBCPP_INLINE_VISIBILITY binder1st(const __Operation& __x, 1022 const typename __Operation::first_argument_type __y) 1023 : op(__x), value(__y) {} 1024 _LIBCPP_INLINE_VISIBILITY typename __Operation::result_type operator() 1025 (typename __Operation::second_argument_type& __x) const 1026 {return op(value, __x);} 1027 _LIBCPP_INLINE_VISIBILITY typename __Operation::result_type operator() 1028 (const typename __Operation::second_argument_type& __x) const 1029 {return op(value, __x);} 1030}; 1031 1032template <class __Operation, class _Tp> 1033inline _LIBCPP_INLINE_VISIBILITY 1034binder1st<__Operation> 1035bind1st(const __Operation& __op, const _Tp& __x) 1036 {return binder1st<__Operation>(__op, __x);} 1037 1038template <class __Operation> 1039class _LIBCPP_TYPE_VIS_ONLY binder2nd 1040 : public unary_function<typename __Operation::first_argument_type, 1041 typename __Operation::result_type> 1042{ 1043protected: 1044 __Operation op; 1045 typename __Operation::second_argument_type value; 1046public: 1047 _LIBCPP_INLINE_VISIBILITY 1048 binder2nd(const __Operation& __x, const typename __Operation::second_argument_type __y) 1049 : op(__x), value(__y) {} 1050 _LIBCPP_INLINE_VISIBILITY typename __Operation::result_type operator() 1051 ( typename __Operation::first_argument_type& __x) const 1052 {return op(__x, value);} 1053 _LIBCPP_INLINE_VISIBILITY typename __Operation::result_type operator() 1054 (const typename __Operation::first_argument_type& __x) const 1055 {return op(__x, value);} 1056}; 1057 1058template <class __Operation, class _Tp> 1059inline _LIBCPP_INLINE_VISIBILITY 1060binder2nd<__Operation> 1061bind2nd(const __Operation& __op, const _Tp& __x) 1062 {return binder2nd<__Operation>(__op, __x);} 1063 1064template <class _Arg, class _Result> 1065class _LIBCPP_TYPE_VIS_ONLY pointer_to_unary_function 1066 : public unary_function<_Arg, _Result> 1067{ 1068 _Result (*__f_)(_Arg); 1069public: 1070 _LIBCPP_INLINE_VISIBILITY explicit pointer_to_unary_function(_Result (*__f)(_Arg)) 1071 : __f_(__f) {} 1072 _LIBCPP_INLINE_VISIBILITY _Result operator()(_Arg __x) const 1073 {return __f_(__x);} 1074}; 1075 1076template <class _Arg, class _Result> 1077inline _LIBCPP_INLINE_VISIBILITY 1078pointer_to_unary_function<_Arg,_Result> 1079ptr_fun(_Result (*__f)(_Arg)) 1080 {return pointer_to_unary_function<_Arg,_Result>(__f);} 1081 1082template <class _Arg1, class _Arg2, class _Result> 1083class _LIBCPP_TYPE_VIS_ONLY pointer_to_binary_function 1084 : public binary_function<_Arg1, _Arg2, _Result> 1085{ 1086 _Result (*__f_)(_Arg1, _Arg2); 1087public: 1088 _LIBCPP_INLINE_VISIBILITY explicit pointer_to_binary_function(_Result (*__f)(_Arg1, _Arg2)) 1089 : __f_(__f) {} 1090 _LIBCPP_INLINE_VISIBILITY _Result operator()(_Arg1 __x, _Arg2 __y) const 1091 {return __f_(__x, __y);} 1092}; 1093 1094template <class _Arg1, class _Arg2, class _Result> 1095inline _LIBCPP_INLINE_VISIBILITY 1096pointer_to_binary_function<_Arg1,_Arg2,_Result> 1097ptr_fun(_Result (*__f)(_Arg1,_Arg2)) 1098 {return pointer_to_binary_function<_Arg1,_Arg2,_Result>(__f);} 1099 1100template<class _Sp, class _Tp> 1101class _LIBCPP_TYPE_VIS_ONLY mem_fun_t : public unary_function<_Tp*, _Sp> 1102{ 1103 _Sp (_Tp::*__p_)(); 1104public: 1105 _LIBCPP_INLINE_VISIBILITY explicit mem_fun_t(_Sp (_Tp::*__p)()) 1106 : __p_(__p) {} 1107 _LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp* __p) const 1108 {return (__p->*__p_)();} 1109}; 1110 1111template<class _Sp, class _Tp, class _Ap> 1112class _LIBCPP_TYPE_VIS_ONLY mem_fun1_t : public binary_function<_Tp*, _Ap, _Sp> 1113{ 1114 _Sp (_Tp::*__p_)(_Ap); 1115public: 1116 _LIBCPP_INLINE_VISIBILITY explicit mem_fun1_t(_Sp (_Tp::*__p)(_Ap)) 1117 : __p_(__p) {} 1118 _LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp* __p, _Ap __x) const 1119 {return (__p->*__p_)(__x);} 1120}; 1121 1122template<class _Sp, class _Tp> 1123inline _LIBCPP_INLINE_VISIBILITY 1124mem_fun_t<_Sp,_Tp> 1125mem_fun(_Sp (_Tp::*__f)()) 1126 {return mem_fun_t<_Sp,_Tp>(__f);} 1127 1128template<class _Sp, class _Tp, class _Ap> 1129inline _LIBCPP_INLINE_VISIBILITY 1130mem_fun1_t<_Sp,_Tp,_Ap> 1131mem_fun(_Sp (_Tp::*__f)(_Ap)) 1132 {return mem_fun1_t<_Sp,_Tp,_Ap>(__f);} 1133 1134template<class _Sp, class _Tp> 1135class _LIBCPP_TYPE_VIS_ONLY mem_fun_ref_t : public unary_function<_Tp, _Sp> 1136{ 1137 _Sp (_Tp::*__p_)(); 1138public: 1139 _LIBCPP_INLINE_VISIBILITY explicit mem_fun_ref_t(_Sp (_Tp::*__p)()) 1140 : __p_(__p) {} 1141 _LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp& __p) const 1142 {return (__p.*__p_)();} 1143}; 1144 1145template<class _Sp, class _Tp, class _Ap> 1146class _LIBCPP_TYPE_VIS_ONLY mem_fun1_ref_t : public binary_function<_Tp, _Ap, _Sp> 1147{ 1148 _Sp (_Tp::*__p_)(_Ap); 1149public: 1150 _LIBCPP_INLINE_VISIBILITY explicit mem_fun1_ref_t(_Sp (_Tp::*__p)(_Ap)) 1151 : __p_(__p) {} 1152 _LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp& __p, _Ap __x) const 1153 {return (__p.*__p_)(__x);} 1154}; 1155 1156template<class _Sp, class _Tp> 1157inline _LIBCPP_INLINE_VISIBILITY 1158mem_fun_ref_t<_Sp,_Tp> 1159mem_fun_ref(_Sp (_Tp::*__f)()) 1160 {return mem_fun_ref_t<_Sp,_Tp>(__f);} 1161 1162template<class _Sp, class _Tp, class _Ap> 1163inline _LIBCPP_INLINE_VISIBILITY 1164mem_fun1_ref_t<_Sp,_Tp,_Ap> 1165mem_fun_ref(_Sp (_Tp::*__f)(_Ap)) 1166 {return mem_fun1_ref_t<_Sp,_Tp,_Ap>(__f);} 1167 1168template <class _Sp, class _Tp> 1169class _LIBCPP_TYPE_VIS_ONLY const_mem_fun_t : public unary_function<const _Tp*, _Sp> 1170{ 1171 _Sp (_Tp::*__p_)() const; 1172public: 1173 _LIBCPP_INLINE_VISIBILITY explicit const_mem_fun_t(_Sp (_Tp::*__p)() const) 1174 : __p_(__p) {} 1175 _LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp* __p) const 1176 {return (__p->*__p_)();} 1177}; 1178 1179template <class _Sp, class _Tp, class _Ap> 1180class _LIBCPP_TYPE_VIS_ONLY const_mem_fun1_t : public binary_function<const _Tp*, _Ap, _Sp> 1181{ 1182 _Sp (_Tp::*__p_)(_Ap) const; 1183public: 1184 _LIBCPP_INLINE_VISIBILITY explicit const_mem_fun1_t(_Sp (_Tp::*__p)(_Ap) const) 1185 : __p_(__p) {} 1186 _LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp* __p, _Ap __x) const 1187 {return (__p->*__p_)(__x);} 1188}; 1189 1190template <class _Sp, class _Tp> 1191inline _LIBCPP_INLINE_VISIBILITY 1192const_mem_fun_t<_Sp,_Tp> 1193mem_fun(_Sp (_Tp::*__f)() const) 1194 {return const_mem_fun_t<_Sp,_Tp>(__f);} 1195 1196template <class _Sp, class _Tp, class _Ap> 1197inline _LIBCPP_INLINE_VISIBILITY 1198const_mem_fun1_t<_Sp,_Tp,_Ap> 1199mem_fun(_Sp (_Tp::*__f)(_Ap) const) 1200 {return const_mem_fun1_t<_Sp,_Tp,_Ap>(__f);} 1201 1202template <class _Sp, class _Tp> 1203class _LIBCPP_TYPE_VIS_ONLY const_mem_fun_ref_t : public unary_function<_Tp, _Sp> 1204{ 1205 _Sp (_Tp::*__p_)() const; 1206public: 1207 _LIBCPP_INLINE_VISIBILITY explicit const_mem_fun_ref_t(_Sp (_Tp::*__p)() const) 1208 : __p_(__p) {} 1209 _LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp& __p) const 1210 {return (__p.*__p_)();} 1211}; 1212 1213template <class _Sp, class _Tp, class _Ap> 1214class _LIBCPP_TYPE_VIS_ONLY const_mem_fun1_ref_t 1215 : public binary_function<_Tp, _Ap, _Sp> 1216{ 1217 _Sp (_Tp::*__p_)(_Ap) const; 1218public: 1219 _LIBCPP_INLINE_VISIBILITY explicit const_mem_fun1_ref_t(_Sp (_Tp::*__p)(_Ap) const) 1220 : __p_(__p) {} 1221 _LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp& __p, _Ap __x) const 1222 {return (__p.*__p_)(__x);} 1223}; 1224 1225template <class _Sp, class _Tp> 1226inline _LIBCPP_INLINE_VISIBILITY 1227const_mem_fun_ref_t<_Sp,_Tp> 1228mem_fun_ref(_Sp (_Tp::*__f)() const) 1229 {return const_mem_fun_ref_t<_Sp,_Tp>(__f);} 1230 1231template <class _Sp, class _Tp, class _Ap> 1232inline _LIBCPP_INLINE_VISIBILITY 1233const_mem_fun1_ref_t<_Sp,_Tp,_Ap> 1234mem_fun_ref(_Sp (_Tp::*__f)(_Ap) const) 1235 {return const_mem_fun1_ref_t<_Sp,_Tp,_Ap>(__f);} 1236 1237//////////////////////////////////////////////////////////////////////////////// 1238// MEMFUN 1239//============================================================================== 1240 1241template <class _Tp> 1242class __mem_fn 1243 : public __weak_result_type<_Tp> 1244{ 1245public: 1246 // types 1247 typedef _Tp type; 1248private: 1249 type __f_; 1250 1251public: 1252 _LIBCPP_INLINE_VISIBILITY __mem_fn(type __f) _NOEXCEPT : __f_(__f) {} 1253 1254#ifndef _LIBCPP_HAS_NO_VARIADICS 1255 // invoke 1256 template <class... _ArgTypes> 1257 _LIBCPP_INLINE_VISIBILITY 1258 typename __invoke_return<type, _ArgTypes...>::type 1259 operator() (_ArgTypes&&... __args) const { 1260 return __invoke(__f_, _VSTD::forward<_ArgTypes>(__args)...); 1261 } 1262#else 1263 1264 template <class _A0> 1265 _LIBCPP_INLINE_VISIBILITY 1266 typename __invoke_return0<type, _A0>::type 1267 operator() (_A0& __a0) const { 1268 return __invoke(__f_, __a0); 1269 } 1270 1271 template <class _A0> 1272 _LIBCPP_INLINE_VISIBILITY 1273 typename __invoke_return0<type, _A0 const>::type 1274 operator() (_A0 const& __a0) const { 1275 return __invoke(__f_, __a0); 1276 } 1277 1278 template <class _A0, class _A1> 1279 _LIBCPP_INLINE_VISIBILITY 1280 typename __invoke_return1<type, _A0, _A1>::type 1281 operator() (_A0& __a0, _A1& __a1) const { 1282 return __invoke(__f_, __a0, __a1); 1283 } 1284 1285 template <class _A0, class _A1> 1286 _LIBCPP_INLINE_VISIBILITY 1287 typename __invoke_return1<type, _A0 const, _A1>::type 1288 operator() (_A0 const& __a0, _A1& __a1) const { 1289 return __invoke(__f_, __a0, __a1); 1290 } 1291 1292 template <class _A0, class _A1> 1293 _LIBCPP_INLINE_VISIBILITY 1294 typename __invoke_return1<type, _A0, _A1 const>::type 1295 operator() (_A0& __a0, _A1 const& __a1) const { 1296 return __invoke(__f_, __a0, __a1); 1297 } 1298 1299 template <class _A0, class _A1> 1300 _LIBCPP_INLINE_VISIBILITY 1301 typename __invoke_return1<type, _A0 const, _A1 const>::type 1302 operator() (_A0 const& __a0, _A1 const& __a1) const { 1303 return __invoke(__f_, __a0, __a1); 1304 } 1305 1306 template <class _A0, class _A1, class _A2> 1307 _LIBCPP_INLINE_VISIBILITY 1308 typename __invoke_return2<type, _A0, _A1, _A2>::type 1309 operator() (_A0& __a0, _A1& __a1, _A2& __a2) const { 1310 return __invoke(__f_, __a0, __a1, __a2); 1311 } 1312 1313 template <class _A0, class _A1, class _A2> 1314 _LIBCPP_INLINE_VISIBILITY 1315 typename __invoke_return2<type, _A0 const, _A1, _A2>::type 1316 operator() (_A0 const& __a0, _A1& __a1, _A2& __a2) const { 1317 return __invoke(__f_, __a0, __a1, __a2); 1318 } 1319 1320 template <class _A0, class _A1, class _A2> 1321 _LIBCPP_INLINE_VISIBILITY 1322 typename __invoke_return2<type, _A0, _A1 const, _A2>::type 1323 operator() (_A0& __a0, _A1 const& __a1, _A2& __a2) const { 1324 return __invoke(__f_, __a0, __a1, __a2); 1325 } 1326 1327 template <class _A0, class _A1, class _A2> 1328 _LIBCPP_INLINE_VISIBILITY 1329 typename __invoke_return2<type, _A0, _A1, _A2 const>::type 1330 operator() (_A0& __a0, _A1& __a1, _A2 const& __a2) const { 1331 return __invoke(__f_, __a0, __a1, __a2); 1332 } 1333 1334 template <class _A0, class _A1, class _A2> 1335 _LIBCPP_INLINE_VISIBILITY 1336 typename __invoke_return2<type, _A0 const, _A1 const, _A2>::type 1337 operator() (_A0 const& __a0, _A1 const& __a1, _A2& __a2) const { 1338 return __invoke(__f_, __a0, __a1, __a2); 1339 } 1340 1341 template <class _A0, class _A1, class _A2> 1342 _LIBCPP_INLINE_VISIBILITY 1343 typename __invoke_return2<type, _A0 const, _A1, _A2 const>::type 1344 operator() (_A0 const& __a0, _A1& __a1, _A2 const& __a2) const { 1345 return __invoke(__f_, __a0, __a1, __a2); 1346 } 1347 1348 template <class _A0, class _A1, class _A2> 1349 _LIBCPP_INLINE_VISIBILITY 1350 typename __invoke_return2<type, _A0, _A1 const, _A2 const>::type 1351 operator() (_A0& __a0, _A1 const& __a1, _A2 const& __a2) const { 1352 return __invoke(__f_, __a0, __a1, __a2); 1353 } 1354 1355 template <class _A0, class _A1, class _A2> 1356 _LIBCPP_INLINE_VISIBILITY 1357 typename __invoke_return2<type, _A0 const, _A1 const, _A2 const>::type 1358 operator() (_A0 const& __a0, _A1 const& __a1, _A2 const& __a2) const { 1359 return __invoke(__f_, __a0, __a1, __a2); 1360 } 1361#endif 1362}; 1363 1364template<class _Rp, class _Tp> 1365inline _LIBCPP_INLINE_VISIBILITY 1366__mem_fn<_Rp _Tp::*> 1367mem_fn(_Rp _Tp::* __pm) _NOEXCEPT 1368{ 1369 return __mem_fn<_Rp _Tp::*>(__pm); 1370} 1371 1372//////////////////////////////////////////////////////////////////////////////// 1373// FUNCTION 1374//============================================================================== 1375 1376// bad_function_call 1377 1378class _LIBCPP_EXCEPTION_ABI bad_function_call 1379 : public exception 1380{ 1381}; 1382 1383template<class _Fp> class _LIBCPP_TYPE_VIS_ONLY function; // undefined 1384 1385namespace __function 1386{ 1387 1388template<class _Rp> 1389struct __maybe_derive_from_unary_function 1390{ 1391}; 1392 1393template<class _Rp, class _A1> 1394struct __maybe_derive_from_unary_function<_Rp(_A1)> 1395 : public unary_function<_A1, _Rp> 1396{ 1397}; 1398 1399template<class _Rp> 1400struct __maybe_derive_from_binary_function 1401{ 1402}; 1403 1404template<class _Rp, class _A1, class _A2> 1405struct __maybe_derive_from_binary_function<_Rp(_A1, _A2)> 1406 : public binary_function<_A1, _A2, _Rp> 1407{ 1408}; 1409 1410template <class _Fp> 1411_LIBCPP_INLINE_VISIBILITY 1412bool __not_null(_Fp const&) { return true; } 1413 1414template <class _Fp> 1415_LIBCPP_INLINE_VISIBILITY 1416bool __not_null(_Fp* __ptr) { return __ptr; } 1417 1418template <class _Ret, class _Class> 1419_LIBCPP_INLINE_VISIBILITY 1420bool __not_null(_Ret _Class::*__ptr) { return __ptr; } 1421 1422template <class _Fp> 1423_LIBCPP_INLINE_VISIBILITY 1424bool __not_null(function<_Fp> const& __f) { return !!__f; } 1425 1426} // namespace __function 1427 1428#ifndef _LIBCPP_HAS_NO_VARIADICS 1429 1430namespace __function { 1431 1432template<class _Fp> class __base; 1433 1434template<class _Rp, class ..._ArgTypes> 1435class __base<_Rp(_ArgTypes...)> 1436{ 1437 __base(const __base&); 1438 __base& operator=(const __base&); 1439public: 1440 _LIBCPP_INLINE_VISIBILITY __base() {} 1441 _LIBCPP_INLINE_VISIBILITY virtual ~__base() {} 1442 virtual __base* __clone() const = 0; 1443 virtual void __clone(__base*) const = 0; 1444 virtual void destroy() _NOEXCEPT = 0; 1445 virtual void destroy_deallocate() _NOEXCEPT = 0; 1446 virtual _Rp operator()(_ArgTypes&& ...) = 0; 1447#ifndef _LIBCPP_NO_RTTI 1448 virtual const void* target(const type_info&) const _NOEXCEPT = 0; 1449 virtual const std::type_info& target_type() const _NOEXCEPT = 0; 1450#endif // _LIBCPP_NO_RTTI 1451}; 1452 1453template<class _FD, class _Alloc, class _FB> class __func; 1454 1455template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes> 1456class __func<_Fp, _Alloc, _Rp(_ArgTypes...)> 1457 : public __base<_Rp(_ArgTypes...)> 1458{ 1459 __compressed_pair<_Fp, _Alloc> __f_; 1460public: 1461 _LIBCPP_INLINE_VISIBILITY 1462 explicit __func(_Fp&& __f) 1463 : __f_(piecewise_construct, _VSTD::forward_as_tuple(_VSTD::move(__f)), 1464 _VSTD::forward_as_tuple()) {} 1465 _LIBCPP_INLINE_VISIBILITY 1466 explicit __func(const _Fp& __f, const _Alloc& __a) 1467 : __f_(piecewise_construct, _VSTD::forward_as_tuple(__f), 1468 _VSTD::forward_as_tuple(__a)) {} 1469 1470 _LIBCPP_INLINE_VISIBILITY 1471 explicit __func(const _Fp& __f, _Alloc&& __a) 1472 : __f_(piecewise_construct, _VSTD::forward_as_tuple(__f), 1473 _VSTD::forward_as_tuple(_VSTD::move(__a))) {} 1474 1475 _LIBCPP_INLINE_VISIBILITY 1476 explicit __func(_Fp&& __f, _Alloc&& __a) 1477 : __f_(piecewise_construct, _VSTD::forward_as_tuple(_VSTD::move(__f)), 1478 _VSTD::forward_as_tuple(_VSTD::move(__a))) {} 1479 virtual __base<_Rp(_ArgTypes...)>* __clone() const; 1480 virtual void __clone(__base<_Rp(_ArgTypes...)>*) const; 1481 virtual void destroy() _NOEXCEPT; 1482 virtual void destroy_deallocate() _NOEXCEPT; 1483 virtual _Rp operator()(_ArgTypes&& ... __arg); 1484#ifndef _LIBCPP_NO_RTTI 1485 virtual const void* target(const type_info&) const _NOEXCEPT; 1486 virtual const std::type_info& target_type() const _NOEXCEPT; 1487#endif // _LIBCPP_NO_RTTI 1488}; 1489 1490template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes> 1491__base<_Rp(_ArgTypes...)>* 1492__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::__clone() const 1493{ 1494 typedef allocator_traits<_Alloc> __alloc_traits; 1495 typedef typename __rebind_alloc_helper<__alloc_traits, __func>::type _Ap; 1496 _Ap __a(__f_.second()); 1497 typedef __allocator_destructor<_Ap> _Dp; 1498 unique_ptr<__func, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); 1499 ::new (__hold.get()) __func(__f_.first(), _Alloc(__a)); 1500 return __hold.release(); 1501} 1502 1503template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes> 1504void 1505__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::__clone(__base<_Rp(_ArgTypes...)>* __p) const 1506{ 1507 ::new (__p) __func(__f_.first(), __f_.second()); 1508} 1509 1510template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes> 1511void 1512__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy() _NOEXCEPT 1513{ 1514 __f_.~__compressed_pair<_Fp, _Alloc>(); 1515} 1516 1517template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes> 1518void 1519__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy_deallocate() _NOEXCEPT 1520{ 1521 typedef allocator_traits<_Alloc> __alloc_traits; 1522 typedef typename __rebind_alloc_helper<__alloc_traits, __func>::type _Ap; 1523 _Ap __a(__f_.second()); 1524 __f_.~__compressed_pair<_Fp, _Alloc>(); 1525 __a.deallocate(this, 1); 1526} 1527 1528template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes> 1529_Rp 1530__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::operator()(_ArgTypes&& ... __arg) 1531{ 1532 typedef __invoke_void_return_wrapper<_Rp> _Invoker; 1533 return _Invoker::__call(__f_.first(), _VSTD::forward<_ArgTypes>(__arg)...); 1534} 1535 1536#ifndef _LIBCPP_NO_RTTI 1537 1538template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes> 1539const void* 1540__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::target(const type_info& __ti) const _NOEXCEPT 1541{ 1542 if (__ti == typeid(_Fp)) 1543 return &__f_.first(); 1544 return (const void*)0; 1545} 1546 1547template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes> 1548const std::type_info& 1549__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::target_type() const _NOEXCEPT 1550{ 1551 return typeid(_Fp); 1552} 1553 1554#endif // _LIBCPP_NO_RTTI 1555 1556} // __function 1557 1558template<class _Rp, class ..._ArgTypes> 1559class _LIBCPP_TYPE_VIS_ONLY function<_Rp(_ArgTypes...)> 1560 : public __function::__maybe_derive_from_unary_function<_Rp(_ArgTypes...)>, 1561 public __function::__maybe_derive_from_binary_function<_Rp(_ArgTypes...)> 1562{ 1563 typedef __function::__base<_Rp(_ArgTypes...)> __base; 1564 typename aligned_storage<3*sizeof(void*)>::type __buf_; 1565 __base* __f_; 1566 1567 template <class _Fp, bool = !is_same<_Fp, function>::value && 1568 __invokable<_Fp&, _ArgTypes...>::value> 1569 struct __callable; 1570 template <class _Fp> 1571 struct __callable<_Fp, true> 1572 { 1573 static const bool value = is_same<void, _Rp>::value || 1574 is_convertible<typename __invoke_of<_Fp&, _ArgTypes...>::type, 1575 _Rp>::value; 1576 }; 1577 template <class _Fp> 1578 struct __callable<_Fp, false> 1579 { 1580 static const bool value = false; 1581 }; 1582public: 1583 typedef _Rp result_type; 1584 1585 // construct/copy/destroy: 1586 _LIBCPP_INLINE_VISIBILITY 1587 function() _NOEXCEPT : __f_(0) {} 1588 _LIBCPP_INLINE_VISIBILITY 1589 function(nullptr_t) _NOEXCEPT : __f_(0) {} 1590 function(const function&); 1591 function(function&&) _NOEXCEPT; 1592 template<class _Fp> 1593 function(_Fp, typename enable_if 1594 < 1595 __callable<_Fp>::value && 1596 !is_same<_Fp, function>::value 1597 >::type* = 0); 1598 1599 template<class _Alloc> 1600 _LIBCPP_INLINE_VISIBILITY 1601 function(allocator_arg_t, const _Alloc&) _NOEXCEPT : __f_(0) {} 1602 template<class _Alloc> 1603 _LIBCPP_INLINE_VISIBILITY 1604 function(allocator_arg_t, const _Alloc&, nullptr_t) _NOEXCEPT : __f_(0) {} 1605 template<class _Alloc> 1606 function(allocator_arg_t, const _Alloc&, const function&); 1607 template<class _Alloc> 1608 function(allocator_arg_t, const _Alloc&, function&&); 1609 template<class _Fp, class _Alloc> 1610 function(allocator_arg_t, const _Alloc& __a, _Fp __f, 1611 typename enable_if<__callable<_Fp>::value>::type* = 0); 1612 1613 function& operator=(const function&); 1614 function& operator=(function&&) _NOEXCEPT; 1615 function& operator=(nullptr_t) _NOEXCEPT; 1616 template<class _Fp> 1617 typename enable_if 1618 < 1619 __callable<typename decay<_Fp>::type>::value && 1620 !is_same<typename remove_reference<_Fp>::type, function>::value, 1621 function& 1622 >::type 1623 operator=(_Fp&&); 1624 1625 ~function(); 1626 1627 // function modifiers: 1628 void swap(function&) _NOEXCEPT; 1629 1630#if _LIBCPP_STD_VER <= 14 1631 template<class _Fp, class _Alloc> 1632 _LIBCPP_INLINE_VISIBILITY 1633 void assign(_Fp&& __f, const _Alloc& __a) 1634 {function(allocator_arg, __a, _VSTD::forward<_Fp>(__f)).swap(*this);} 1635#endif 1636 1637 // function capacity: 1638 _LIBCPP_INLINE_VISIBILITY 1639 _LIBCPP_EXPLICIT operator bool() const _NOEXCEPT {return __f_;} 1640 1641 // deleted overloads close possible hole in the type system 1642 template<class _R2, class... _ArgTypes2> 1643 bool operator==(const function<_R2(_ArgTypes2...)>&) const = delete; 1644 template<class _R2, class... _ArgTypes2> 1645 bool operator!=(const function<_R2(_ArgTypes2...)>&) const = delete; 1646public: 1647 // function invocation: 1648 _Rp operator()(_ArgTypes...) const; 1649 1650#ifndef _LIBCPP_NO_RTTI 1651 // function target access: 1652 const std::type_info& target_type() const _NOEXCEPT; 1653 template <typename _Tp> _Tp* target() _NOEXCEPT; 1654 template <typename _Tp> const _Tp* target() const _NOEXCEPT; 1655#endif // _LIBCPP_NO_RTTI 1656}; 1657 1658template<class _Rp, class ..._ArgTypes> 1659function<_Rp(_ArgTypes...)>::function(const function& __f) 1660{ 1661 if (__f.__f_ == 0) 1662 __f_ = 0; 1663 else if (__f.__f_ == (const __base*)&__f.__buf_) 1664 { 1665 __f_ = (__base*)&__buf_; 1666 __f.__f_->__clone(__f_); 1667 } 1668 else 1669 __f_ = __f.__f_->__clone(); 1670} 1671 1672template<class _Rp, class ..._ArgTypes> 1673template <class _Alloc> 1674function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc&, 1675 const function& __f) 1676{ 1677 if (__f.__f_ == 0) 1678 __f_ = 0; 1679 else if (__f.__f_ == (const __base*)&__f.__buf_) 1680 { 1681 __f_ = (__base*)&__buf_; 1682 __f.__f_->__clone(__f_); 1683 } 1684 else 1685 __f_ = __f.__f_->__clone(); 1686} 1687 1688template<class _Rp, class ..._ArgTypes> 1689function<_Rp(_ArgTypes...)>::function(function&& __f) _NOEXCEPT 1690{ 1691 if (__f.__f_ == 0) 1692 __f_ = 0; 1693 else if (__f.__f_ == (__base*)&__f.__buf_) 1694 { 1695 __f_ = (__base*)&__buf_; 1696 __f.__f_->__clone(__f_); 1697 } 1698 else 1699 { 1700 __f_ = __f.__f_; 1701 __f.__f_ = 0; 1702 } 1703} 1704 1705template<class _Rp, class ..._ArgTypes> 1706template <class _Alloc> 1707function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc&, 1708 function&& __f) 1709{ 1710 if (__f.__f_ == 0) 1711 __f_ = 0; 1712 else if (__f.__f_ == (__base*)&__f.__buf_) 1713 { 1714 __f_ = (__base*)&__buf_; 1715 __f.__f_->__clone(__f_); 1716 } 1717 else 1718 { 1719 __f_ = __f.__f_; 1720 __f.__f_ = 0; 1721 } 1722} 1723 1724template<class _Rp, class ..._ArgTypes> 1725template <class _Fp> 1726function<_Rp(_ArgTypes...)>::function(_Fp __f, 1727 typename enable_if 1728 < 1729 __callable<_Fp>::value && 1730 !is_same<_Fp, function>::value 1731 >::type*) 1732 : __f_(0) 1733{ 1734 if (__function::__not_null(__f)) 1735 { 1736 typedef __function::__func<_Fp, allocator<_Fp>, _Rp(_ArgTypes...)> _FF; 1737 if (sizeof(_FF) <= sizeof(__buf_) && is_nothrow_copy_constructible<_Fp>::value) 1738 { 1739 __f_ = (__base*)&__buf_; 1740 ::new (__f_) _FF(_VSTD::move(__f)); 1741 } 1742 else 1743 { 1744 typedef allocator<_FF> _Ap; 1745 _Ap __a; 1746 typedef __allocator_destructor<_Ap> _Dp; 1747 unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); 1748 ::new (__hold.get()) _FF(_VSTD::move(__f), allocator<_Fp>(__a)); 1749 __f_ = __hold.release(); 1750 } 1751 } 1752} 1753 1754template<class _Rp, class ..._ArgTypes> 1755template <class _Fp, class _Alloc> 1756function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc& __a0, _Fp __f, 1757 typename enable_if<__callable<_Fp>::value>::type*) 1758 : __f_(0) 1759{ 1760 typedef allocator_traits<_Alloc> __alloc_traits; 1761 if (__function::__not_null(__f)) 1762 { 1763 typedef __function::__func<_Fp, _Alloc, _Rp(_ArgTypes...)> _FF; 1764 typedef typename __rebind_alloc_helper<__alloc_traits, _FF>::type _Ap; 1765 _Ap __a(__a0); 1766 if (sizeof(_FF) <= sizeof(__buf_) && 1767 is_nothrow_copy_constructible<_Fp>::value && is_nothrow_copy_constructible<_Ap>::value) 1768 { 1769 __f_ = (__base*)&__buf_; 1770 ::new (__f_) _FF(_VSTD::move(__f), _Alloc(__a)); 1771 } 1772 else 1773 { 1774 typedef __allocator_destructor<_Ap> _Dp; 1775 unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); 1776 ::new (__hold.get()) _FF(_VSTD::move(__f), _Alloc(__a)); 1777 __f_ = __hold.release(); 1778 } 1779 } 1780} 1781 1782template<class _Rp, class ..._ArgTypes> 1783function<_Rp(_ArgTypes...)>& 1784function<_Rp(_ArgTypes...)>::operator=(const function& __f) 1785{ 1786 function(__f).swap(*this); 1787 return *this; 1788} 1789 1790template<class _Rp, class ..._ArgTypes> 1791function<_Rp(_ArgTypes...)>& 1792function<_Rp(_ArgTypes...)>::operator=(function&& __f) _NOEXCEPT 1793{ 1794 if (__f_ == (__base*)&__buf_) 1795 __f_->destroy(); 1796 else if (__f_) 1797 __f_->destroy_deallocate(); 1798 __f_ = 0; 1799 if (__f.__f_ == 0) 1800 __f_ = 0; 1801 else if (__f.__f_ == (__base*)&__f.__buf_) 1802 { 1803 __f_ = (__base*)&__buf_; 1804 __f.__f_->__clone(__f_); 1805 } 1806 else 1807 { 1808 __f_ = __f.__f_; 1809 __f.__f_ = 0; 1810 } 1811 return *this; 1812} 1813 1814template<class _Rp, class ..._ArgTypes> 1815function<_Rp(_ArgTypes...)>& 1816function<_Rp(_ArgTypes...)>::operator=(nullptr_t) _NOEXCEPT 1817{ 1818 if (__f_ == (__base*)&__buf_) 1819 __f_->destroy(); 1820 else if (__f_) 1821 __f_->destroy_deallocate(); 1822 __f_ = 0; 1823 return *this; 1824} 1825 1826template<class _Rp, class ..._ArgTypes> 1827template <class _Fp> 1828typename enable_if 1829< 1830 function<_Rp(_ArgTypes...)>::template __callable<typename decay<_Fp>::type>::value && 1831 !is_same<typename remove_reference<_Fp>::type, function<_Rp(_ArgTypes...)>>::value, 1832 function<_Rp(_ArgTypes...)>& 1833>::type 1834function<_Rp(_ArgTypes...)>::operator=(_Fp&& __f) 1835{ 1836 function(_VSTD::forward<_Fp>(__f)).swap(*this); 1837 return *this; 1838} 1839 1840template<class _Rp, class ..._ArgTypes> 1841function<_Rp(_ArgTypes...)>::~function() 1842{ 1843 if (__f_ == (__base*)&__buf_) 1844 __f_->destroy(); 1845 else if (__f_) 1846 __f_->destroy_deallocate(); 1847} 1848 1849template<class _Rp, class ..._ArgTypes> 1850void 1851function<_Rp(_ArgTypes...)>::swap(function& __f) _NOEXCEPT 1852{ 1853 if (__f_ == (__base*)&__buf_ && __f.__f_ == (__base*)&__f.__buf_) 1854 { 1855 typename aligned_storage<sizeof(__buf_)>::type __tempbuf; 1856 __base* __t = (__base*)&__tempbuf; 1857 __f_->__clone(__t); 1858 __f_->destroy(); 1859 __f_ = 0; 1860 __f.__f_->__clone((__base*)&__buf_); 1861 __f.__f_->destroy(); 1862 __f.__f_ = 0; 1863 __f_ = (__base*)&__buf_; 1864 __t->__clone((__base*)&__f.__buf_); 1865 __t->destroy(); 1866 __f.__f_ = (__base*)&__f.__buf_; 1867 } 1868 else if (__f_ == (__base*)&__buf_) 1869 { 1870 __f_->__clone((__base*)&__f.__buf_); 1871 __f_->destroy(); 1872 __f_ = __f.__f_; 1873 __f.__f_ = (__base*)&__f.__buf_; 1874 } 1875 else if (__f.__f_ == (__base*)&__f.__buf_) 1876 { 1877 __f.__f_->__clone((__base*)&__buf_); 1878 __f.__f_->destroy(); 1879 __f.__f_ = __f_; 1880 __f_ = (__base*)&__buf_; 1881 } 1882 else 1883 _VSTD::swap(__f_, __f.__f_); 1884} 1885 1886template<class _Rp, class ..._ArgTypes> 1887_Rp 1888function<_Rp(_ArgTypes...)>::operator()(_ArgTypes... __arg) const 1889{ 1890#ifndef _LIBCPP_NO_EXCEPTIONS 1891 if (__f_ == 0) 1892 throw bad_function_call(); 1893#endif // _LIBCPP_NO_EXCEPTIONS 1894 return (*__f_)(_VSTD::forward<_ArgTypes>(__arg)...); 1895} 1896 1897#ifndef _LIBCPP_NO_RTTI 1898 1899template<class _Rp, class ..._ArgTypes> 1900const std::type_info& 1901function<_Rp(_ArgTypes...)>::target_type() const _NOEXCEPT 1902{ 1903 if (__f_ == 0) 1904 return typeid(void); 1905 return __f_->target_type(); 1906} 1907 1908template<class _Rp, class ..._ArgTypes> 1909template <typename _Tp> 1910_Tp* 1911function<_Rp(_ArgTypes...)>::target() _NOEXCEPT 1912{ 1913 if (__f_ == 0) 1914 return (_Tp*)0; 1915 return (_Tp*)__f_->target(typeid(_Tp)); 1916} 1917 1918template<class _Rp, class ..._ArgTypes> 1919template <typename _Tp> 1920const _Tp* 1921function<_Rp(_ArgTypes...)>::target() const _NOEXCEPT 1922{ 1923 if (__f_ == 0) 1924 return (const _Tp*)0; 1925 return (const _Tp*)__f_->target(typeid(_Tp)); 1926} 1927 1928#endif // _LIBCPP_NO_RTTI 1929 1930template <class _Rp, class... _ArgTypes> 1931inline _LIBCPP_INLINE_VISIBILITY 1932bool 1933operator==(const function<_Rp(_ArgTypes...)>& __f, nullptr_t) _NOEXCEPT {return !__f;} 1934 1935template <class _Rp, class... _ArgTypes> 1936inline _LIBCPP_INLINE_VISIBILITY 1937bool 1938operator==(nullptr_t, const function<_Rp(_ArgTypes...)>& __f) _NOEXCEPT {return !__f;} 1939 1940template <class _Rp, class... _ArgTypes> 1941inline _LIBCPP_INLINE_VISIBILITY 1942bool 1943operator!=(const function<_Rp(_ArgTypes...)>& __f, nullptr_t) _NOEXCEPT {return (bool)__f;} 1944 1945template <class _Rp, class... _ArgTypes> 1946inline _LIBCPP_INLINE_VISIBILITY 1947bool 1948operator!=(nullptr_t, const function<_Rp(_ArgTypes...)>& __f) _NOEXCEPT {return (bool)__f;} 1949 1950template <class _Rp, class... _ArgTypes> 1951inline _LIBCPP_INLINE_VISIBILITY 1952void 1953swap(function<_Rp(_ArgTypes...)>& __x, function<_Rp(_ArgTypes...)>& __y) _NOEXCEPT 1954{return __x.swap(__y);} 1955 1956#else // _LIBCPP_HAS_NO_VARIADICS 1957 1958#include <__functional_03> 1959 1960#endif 1961 1962//////////////////////////////////////////////////////////////////////////////// 1963// BIND 1964//============================================================================== 1965 1966template<class _Tp> struct __is_bind_expression : public false_type {}; 1967template<class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_bind_expression 1968 : public __is_bind_expression<typename remove_cv<_Tp>::type> {}; 1969 1970template<class _Tp> struct __is_placeholder : public integral_constant<int, 0> {}; 1971template<class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_placeholder 1972 : public __is_placeholder<typename remove_cv<_Tp>::type> {}; 1973 1974namespace placeholders 1975{ 1976 1977template <int _Np> struct __ph {}; 1978 1979_LIBCPP_FUNC_VIS extern __ph<1> _1; 1980_LIBCPP_FUNC_VIS extern __ph<2> _2; 1981_LIBCPP_FUNC_VIS extern __ph<3> _3; 1982_LIBCPP_FUNC_VIS extern __ph<4> _4; 1983_LIBCPP_FUNC_VIS extern __ph<5> _5; 1984_LIBCPP_FUNC_VIS extern __ph<6> _6; 1985_LIBCPP_FUNC_VIS extern __ph<7> _7; 1986_LIBCPP_FUNC_VIS extern __ph<8> _8; 1987_LIBCPP_FUNC_VIS extern __ph<9> _9; 1988_LIBCPP_FUNC_VIS extern __ph<10> _10; 1989 1990} // placeholders 1991 1992template<int _Np> 1993struct __is_placeholder<placeholders::__ph<_Np> > 1994 : public integral_constant<int, _Np> {}; 1995 1996 1997#ifndef _LIBCPP_HAS_NO_VARIADICS 1998 1999template <class _Tp, class _Uj> 2000inline _LIBCPP_INLINE_VISIBILITY 2001_Tp& 2002__mu(reference_wrapper<_Tp> __t, _Uj&) 2003{ 2004 return __t.get(); 2005} 2006 2007template <class _Ti, class ..._Uj, size_t ..._Indx> 2008inline _LIBCPP_INLINE_VISIBILITY 2009typename __invoke_of<_Ti&, _Uj...>::type 2010__mu_expand(_Ti& __ti, tuple<_Uj...>& __uj, __tuple_indices<_Indx...>) 2011{ 2012 return __ti(_VSTD::forward<_Uj>(_VSTD::get<_Indx>(__uj))...); 2013} 2014 2015template <class _Ti, class ..._Uj> 2016inline _LIBCPP_INLINE_VISIBILITY 2017typename __lazy_enable_if 2018< 2019 is_bind_expression<_Ti>::value, 2020 __invoke_of<_Ti&, _Uj...> 2021>::type 2022__mu(_Ti& __ti, tuple<_Uj...>& __uj) 2023{ 2024 typedef typename __make_tuple_indices<sizeof...(_Uj)>::type __indices; 2025 return __mu_expand(__ti, __uj, __indices()); 2026} 2027 2028template <bool IsPh, class _Ti, class _Uj> 2029struct __mu_return2 {}; 2030 2031template <class _Ti, class _Uj> 2032struct __mu_return2<true, _Ti, _Uj> 2033{ 2034 typedef typename tuple_element<is_placeholder<_Ti>::value - 1, _Uj>::type type; 2035}; 2036 2037template <class _Ti, class _Uj> 2038inline _LIBCPP_INLINE_VISIBILITY 2039typename enable_if 2040< 2041 0 < is_placeholder<_Ti>::value, 2042 typename __mu_return2<0 < is_placeholder<_Ti>::value, _Ti, _Uj>::type 2043>::type 2044__mu(_Ti&, _Uj& __uj) 2045{ 2046 const size_t _Indx = is_placeholder<_Ti>::value - 1; 2047 return _VSTD::forward<typename tuple_element<_Indx, _Uj>::type>(_VSTD::get<_Indx>(__uj)); 2048} 2049 2050template <class _Ti, class _Uj> 2051inline _LIBCPP_INLINE_VISIBILITY 2052typename enable_if 2053< 2054 !is_bind_expression<_Ti>::value && 2055 is_placeholder<_Ti>::value == 0 && 2056 !__is_reference_wrapper<_Ti>::value, 2057 _Ti& 2058>::type 2059__mu(_Ti& __ti, _Uj&) 2060{ 2061 return __ti; 2062} 2063 2064template <class _Ti, bool IsReferenceWrapper, bool IsBindEx, bool IsPh, 2065 class _TupleUj> 2066struct ____mu_return; 2067 2068template <bool _Invokable, class _Ti, class ..._Uj> 2069struct ____mu_return_invokable // false 2070{ 2071 typedef __nat type; 2072}; 2073 2074template <class _Ti, class ..._Uj> 2075struct ____mu_return_invokable<true, _Ti, _Uj...> 2076{ 2077 typedef typename __invoke_of<_Ti&, _Uj...>::type type; 2078}; 2079 2080template <class _Ti, class ..._Uj> 2081struct ____mu_return<_Ti, false, true, false, tuple<_Uj...> > 2082 : public ____mu_return_invokable<__invokable<_Ti&, _Uj...>::value, _Ti, _Uj...> 2083{ 2084}; 2085 2086template <class _Ti, class _TupleUj> 2087struct ____mu_return<_Ti, false, false, true, _TupleUj> 2088{ 2089 typedef typename tuple_element<is_placeholder<_Ti>::value - 1, 2090 _TupleUj>::type&& type; 2091}; 2092 2093template <class _Ti, class _TupleUj> 2094struct ____mu_return<_Ti, true, false, false, _TupleUj> 2095{ 2096 typedef typename _Ti::type& type; 2097}; 2098 2099template <class _Ti, class _TupleUj> 2100struct ____mu_return<_Ti, false, false, false, _TupleUj> 2101{ 2102 typedef _Ti& type; 2103}; 2104 2105template <class _Ti, class _TupleUj> 2106struct __mu_return 2107 : public ____mu_return<_Ti, 2108 __is_reference_wrapper<_Ti>::value, 2109 is_bind_expression<_Ti>::value, 2110 0 < is_placeholder<_Ti>::value && 2111 is_placeholder<_Ti>::value <= tuple_size<_TupleUj>::value, 2112 _TupleUj> 2113{ 2114}; 2115 2116template <class _Fp, class _BoundArgs, class _TupleUj> 2117struct __is_valid_bind_return 2118{ 2119 static const bool value = false; 2120}; 2121 2122template <class _Fp, class ..._BoundArgs, class _TupleUj> 2123struct __is_valid_bind_return<_Fp, tuple<_BoundArgs...>, _TupleUj> 2124{ 2125 static const bool value = __invokable<_Fp, 2126 typename __mu_return<_BoundArgs, _TupleUj>::type...>::value; 2127}; 2128 2129template <class _Fp, class ..._BoundArgs, class _TupleUj> 2130struct __is_valid_bind_return<_Fp, const tuple<_BoundArgs...>, _TupleUj> 2131{ 2132 static const bool value = __invokable<_Fp, 2133 typename __mu_return<const _BoundArgs, _TupleUj>::type...>::value; 2134}; 2135 2136template <class _Fp, class _BoundArgs, class _TupleUj, 2137 bool = __is_valid_bind_return<_Fp, _BoundArgs, _TupleUj>::value> 2138struct __bind_return; 2139 2140template <class _Fp, class ..._BoundArgs, class _TupleUj> 2141struct __bind_return<_Fp, tuple<_BoundArgs...>, _TupleUj, true> 2142{ 2143 typedef typename __invoke_of 2144 < 2145 _Fp&, 2146 typename __mu_return 2147 < 2148 _BoundArgs, 2149 _TupleUj 2150 >::type... 2151 >::type type; 2152}; 2153 2154template <class _Fp, class ..._BoundArgs, class _TupleUj> 2155struct __bind_return<_Fp, const tuple<_BoundArgs...>, _TupleUj, true> 2156{ 2157 typedef typename __invoke_of 2158 < 2159 _Fp&, 2160 typename __mu_return 2161 < 2162 const _BoundArgs, 2163 _TupleUj 2164 >::type... 2165 >::type type; 2166}; 2167 2168template <class _Fp, class _BoundArgs, size_t ..._Indx, class _Args> 2169inline _LIBCPP_INLINE_VISIBILITY 2170typename __bind_return<_Fp, _BoundArgs, _Args>::type 2171__apply_functor(_Fp& __f, _BoundArgs& __bound_args, __tuple_indices<_Indx...>, 2172 _Args&& __args) 2173{ 2174 return __invoke(__f, __mu(_VSTD::get<_Indx>(__bound_args), __args)...); 2175} 2176 2177template<class _Fp, class ..._BoundArgs> 2178class __bind 2179 : public __weak_result_type<typename decay<_Fp>::type> 2180{ 2181protected: 2182 typedef typename decay<_Fp>::type _Fd; 2183 typedef tuple<typename decay<_BoundArgs>::type...> _Td; 2184private: 2185 _Fd __f_; 2186 _Td __bound_args_; 2187 2188 typedef typename __make_tuple_indices<sizeof...(_BoundArgs)>::type __indices; 2189public: 2190#ifdef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS 2191 2192 _LIBCPP_INLINE_VISIBILITY 2193 __bind(const __bind& __b) 2194 : __f_(__b.__f_), 2195 __bound_args_(__b.__bound_args_) {} 2196 2197 _LIBCPP_INLINE_VISIBILITY 2198 __bind& operator=(const __bind& __b) 2199 { 2200 __f_ = __b.__f_; 2201 __bound_args_ = __b.__bound_args_; 2202 return *this; 2203 } 2204 2205 _LIBCPP_INLINE_VISIBILITY 2206 __bind(__bind&& __b) 2207 : __f_(_VSTD::move(__b.__f_)), 2208 __bound_args_(_VSTD::move(__b.__bound_args_)) {} 2209 2210 _LIBCPP_INLINE_VISIBILITY 2211 __bind& operator=(__bind&& __b) 2212 { 2213 __f_ = _VSTD::move(__b.__f_); 2214 __bound_args_ = _VSTD::move(__b.__bound_args_); 2215 return *this; 2216 } 2217 2218#endif // _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS 2219 2220 template <class _Gp, class ..._BA, 2221 class = typename enable_if 2222 < 2223 is_constructible<_Fd, _Gp>::value && 2224 !is_same<typename remove_reference<_Gp>::type, 2225 __bind>::value 2226 >::type> 2227 _LIBCPP_INLINE_VISIBILITY 2228 explicit __bind(_Gp&& __f, _BA&& ...__bound_args) 2229 : __f_(_VSTD::forward<_Gp>(__f)), 2230 __bound_args_(_VSTD::forward<_BA>(__bound_args)...) {} 2231 2232 template <class ..._Args> 2233 _LIBCPP_INLINE_VISIBILITY 2234 typename __bind_return<_Fd, _Td, tuple<_Args&&...> >::type 2235 operator()(_Args&& ...__args) 2236 { 2237 return __apply_functor(__f_, __bound_args_, __indices(), 2238 tuple<_Args&&...>(_VSTD::forward<_Args>(__args)...)); 2239 } 2240 2241 template <class ..._Args> 2242 _LIBCPP_INLINE_VISIBILITY 2243 typename __bind_return<const _Fd, const _Td, tuple<_Args&&...> >::type 2244 operator()(_Args&& ...__args) const 2245 { 2246 return __apply_functor(__f_, __bound_args_, __indices(), 2247 tuple<_Args&&...>(_VSTD::forward<_Args>(__args)...)); 2248 } 2249}; 2250 2251template<class _Fp, class ..._BoundArgs> 2252struct __is_bind_expression<__bind<_Fp, _BoundArgs...> > : public true_type {}; 2253 2254template<class _Rp, class _Fp, class ..._BoundArgs> 2255class __bind_r 2256 : public __bind<_Fp, _BoundArgs...> 2257{ 2258 typedef __bind<_Fp, _BoundArgs...> base; 2259 typedef typename base::_Fd _Fd; 2260 typedef typename base::_Td _Td; 2261public: 2262 typedef _Rp result_type; 2263 2264#ifdef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS 2265 2266 _LIBCPP_INLINE_VISIBILITY 2267 __bind_r(const __bind_r& __b) 2268 : base(_VSTD::forward<const base&>(__b)) {} 2269 2270 _LIBCPP_INLINE_VISIBILITY 2271 __bind_r& operator=(const __bind_r& __b) 2272 { 2273 base::operator=(_VSTD::forward<const base&>(__b)); 2274 return *this; 2275 } 2276 2277 _LIBCPP_INLINE_VISIBILITY 2278 __bind_r(__bind_r&& __b) 2279 : base(_VSTD::forward<base>(__b)) {} 2280 2281 _LIBCPP_INLINE_VISIBILITY 2282 __bind_r& operator=(__bind_r&& __b) 2283 { 2284 base::operator=(_VSTD::forward<base>(__b)); 2285 return *this; 2286 } 2287 2288#endif // _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS 2289 2290 template <class _Gp, class ..._BA, 2291 class = typename enable_if 2292 < 2293 is_constructible<_Fd, _Gp>::value && 2294 !is_same<typename remove_reference<_Gp>::type, 2295 __bind_r>::value 2296 >::type> 2297 _LIBCPP_INLINE_VISIBILITY 2298 explicit __bind_r(_Gp&& __f, _BA&& ...__bound_args) 2299 : base(_VSTD::forward<_Gp>(__f), 2300 _VSTD::forward<_BA>(__bound_args)...) {} 2301 2302 template <class ..._Args> 2303 _LIBCPP_INLINE_VISIBILITY 2304 typename enable_if 2305 < 2306 is_convertible<typename __bind_return<_Fd, _Td, tuple<_Args&&...> >::type, 2307 result_type>::value || is_void<_Rp>::value, 2308 result_type 2309 >::type 2310 operator()(_Args&& ...__args) 2311 { 2312 typedef __invoke_void_return_wrapper<_Rp> _Invoker; 2313 return _Invoker::__call(static_cast<base&>(*this), _VSTD::forward<_Args>(__args)...); 2314 } 2315 2316 template <class ..._Args> 2317 _LIBCPP_INLINE_VISIBILITY 2318 typename enable_if 2319 < 2320 is_convertible<typename __bind_return<const _Fd, const _Td, tuple<_Args&&...> >::type, 2321 result_type>::value || is_void<_Rp>::value, 2322 result_type 2323 >::type 2324 operator()(_Args&& ...__args) const 2325 { 2326 typedef __invoke_void_return_wrapper<_Rp> _Invoker; 2327 return _Invoker::__call(static_cast<base const&>(*this), _VSTD::forward<_Args>(__args)...); 2328 } 2329}; 2330 2331template<class _Rp, class _Fp, class ..._BoundArgs> 2332struct __is_bind_expression<__bind_r<_Rp, _Fp, _BoundArgs...> > : public true_type {}; 2333 2334template<class _Fp, class ..._BoundArgs> 2335inline _LIBCPP_INLINE_VISIBILITY 2336__bind<_Fp, _BoundArgs...> 2337bind(_Fp&& __f, _BoundArgs&&... __bound_args) 2338{ 2339 typedef __bind<_Fp, _BoundArgs...> type; 2340 return type(_VSTD::forward<_Fp>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...); 2341} 2342 2343template<class _Rp, class _Fp, class ..._BoundArgs> 2344inline _LIBCPP_INLINE_VISIBILITY 2345__bind_r<_Rp, _Fp, _BoundArgs...> 2346bind(_Fp&& __f, _BoundArgs&&... __bound_args) 2347{ 2348 typedef __bind_r<_Rp, _Fp, _BoundArgs...> type; 2349 return type(_VSTD::forward<_Fp>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...); 2350} 2351 2352#endif // _LIBCPP_HAS_NO_VARIADICS 2353 2354template <> 2355struct _LIBCPP_TYPE_VIS_ONLY hash<bool> 2356 : public unary_function<bool, size_t> 2357{ 2358 _LIBCPP_INLINE_VISIBILITY 2359 size_t operator()(bool __v) const _NOEXCEPT {return static_cast<size_t>(__v);} 2360}; 2361 2362template <> 2363struct _LIBCPP_TYPE_VIS_ONLY hash<char> 2364 : public unary_function<char, size_t> 2365{ 2366 _LIBCPP_INLINE_VISIBILITY 2367 size_t operator()(char __v) const _NOEXCEPT {return static_cast<size_t>(__v);} 2368}; 2369 2370template <> 2371struct _LIBCPP_TYPE_VIS_ONLY hash<signed char> 2372 : public unary_function<signed char, size_t> 2373{ 2374 _LIBCPP_INLINE_VISIBILITY 2375 size_t operator()(signed char __v) const _NOEXCEPT {return static_cast<size_t>(__v);} 2376}; 2377 2378template <> 2379struct _LIBCPP_TYPE_VIS_ONLY hash<unsigned char> 2380 : public unary_function<unsigned char, size_t> 2381{ 2382 _LIBCPP_INLINE_VISIBILITY 2383 size_t operator()(unsigned char __v) const _NOEXCEPT {return static_cast<size_t>(__v);} 2384}; 2385 2386#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS 2387 2388template <> 2389struct _LIBCPP_TYPE_VIS_ONLY hash<char16_t> 2390 : public unary_function<char16_t, size_t> 2391{ 2392 _LIBCPP_INLINE_VISIBILITY 2393 size_t operator()(char16_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);} 2394}; 2395 2396template <> 2397struct _LIBCPP_TYPE_VIS_ONLY hash<char32_t> 2398 : public unary_function<char32_t, size_t> 2399{ 2400 _LIBCPP_INLINE_VISIBILITY 2401 size_t operator()(char32_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);} 2402}; 2403 2404#endif // _LIBCPP_HAS_NO_UNICODE_CHARS 2405 2406template <> 2407struct _LIBCPP_TYPE_VIS_ONLY hash<wchar_t> 2408 : public unary_function<wchar_t, size_t> 2409{ 2410 _LIBCPP_INLINE_VISIBILITY 2411 size_t operator()(wchar_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);} 2412}; 2413 2414template <> 2415struct _LIBCPP_TYPE_VIS_ONLY hash<short> 2416 : public unary_function<short, size_t> 2417{ 2418 _LIBCPP_INLINE_VISIBILITY 2419 size_t operator()(short __v) const _NOEXCEPT {return static_cast<size_t>(__v);} 2420}; 2421 2422template <> 2423struct _LIBCPP_TYPE_VIS_ONLY hash<unsigned short> 2424 : public unary_function<unsigned short, size_t> 2425{ 2426 _LIBCPP_INLINE_VISIBILITY 2427 size_t operator()(unsigned short __v) const _NOEXCEPT {return static_cast<size_t>(__v);} 2428}; 2429 2430template <> 2431struct _LIBCPP_TYPE_VIS_ONLY hash<int> 2432 : public unary_function<int, size_t> 2433{ 2434 _LIBCPP_INLINE_VISIBILITY 2435 size_t operator()(int __v) const _NOEXCEPT {return static_cast<size_t>(__v);} 2436}; 2437 2438template <> 2439struct _LIBCPP_TYPE_VIS_ONLY hash<unsigned int> 2440 : public unary_function<unsigned int, size_t> 2441{ 2442 _LIBCPP_INLINE_VISIBILITY 2443 size_t operator()(unsigned int __v) const _NOEXCEPT {return static_cast<size_t>(__v);} 2444}; 2445 2446template <> 2447struct _LIBCPP_TYPE_VIS_ONLY hash<long> 2448 : public unary_function<long, size_t> 2449{ 2450 _LIBCPP_INLINE_VISIBILITY 2451 size_t operator()(long __v) const _NOEXCEPT {return static_cast<size_t>(__v);} 2452}; 2453 2454template <> 2455struct _LIBCPP_TYPE_VIS_ONLY hash<unsigned long> 2456 : public unary_function<unsigned long, size_t> 2457{ 2458 _LIBCPP_INLINE_VISIBILITY 2459 size_t operator()(unsigned long __v) const _NOEXCEPT {return static_cast<size_t>(__v);} 2460}; 2461 2462template <> 2463struct _LIBCPP_TYPE_VIS_ONLY hash<long long> 2464 : public __scalar_hash<long long> 2465{ 2466}; 2467 2468template <> 2469struct _LIBCPP_TYPE_VIS_ONLY hash<unsigned long long> 2470 : public __scalar_hash<unsigned long long> 2471{ 2472}; 2473 2474template <> 2475struct _LIBCPP_TYPE_VIS_ONLY hash<float> 2476 : public __scalar_hash<float> 2477{ 2478 _LIBCPP_INLINE_VISIBILITY 2479 size_t operator()(float __v) const _NOEXCEPT 2480 { 2481 // -0.0 and 0.0 should return same hash 2482 if (__v == 0) 2483 return 0; 2484 return __scalar_hash<float>::operator()(__v); 2485 } 2486}; 2487 2488template <> 2489struct _LIBCPP_TYPE_VIS_ONLY hash<double> 2490 : public __scalar_hash<double> 2491{ 2492 _LIBCPP_INLINE_VISIBILITY 2493 size_t operator()(double __v) const _NOEXCEPT 2494 { 2495 // -0.0 and 0.0 should return same hash 2496 if (__v == 0) 2497 return 0; 2498 return __scalar_hash<double>::operator()(__v); 2499 } 2500}; 2501 2502template <> 2503struct _LIBCPP_TYPE_VIS_ONLY hash<long double> 2504 : public __scalar_hash<long double> 2505{ 2506 _LIBCPP_INLINE_VISIBILITY 2507 size_t operator()(long double __v) const _NOEXCEPT 2508 { 2509 // -0.0 and 0.0 should return same hash 2510 if (__v == 0) 2511 return 0; 2512#if defined(__i386__) 2513 // Zero out padding bits 2514 union 2515 { 2516 long double __t; 2517 struct 2518 { 2519 size_t __a; 2520 size_t __b; 2521 size_t __c; 2522 size_t __d; 2523 } __s; 2524 } __u; 2525 __u.__s.__a = 0; 2526 __u.__s.__b = 0; 2527 __u.__s.__c = 0; 2528 __u.__s.__d = 0; 2529 __u.__t = __v; 2530 return __u.__s.__a ^ __u.__s.__b ^ __u.__s.__c ^ __u.__s.__d; 2531#elif defined(__x86_64__) 2532 // Zero out padding bits 2533 union 2534 { 2535 long double __t; 2536 struct 2537 { 2538 size_t __a; 2539 size_t __b; 2540 } __s; 2541 } __u; 2542 __u.__s.__a = 0; 2543 __u.__s.__b = 0; 2544 __u.__t = __v; 2545 return __u.__s.__a ^ __u.__s.__b; 2546#else 2547 return __scalar_hash<long double>::operator()(__v); 2548#endif 2549 } 2550}; 2551 2552#if _LIBCPP_STD_VER > 11 2553template <class _Tp> 2554struct _LIBCPP_TYPE_VIS_ONLY hash 2555 : public unary_function<_Tp, size_t> 2556{ 2557 static_assert(is_enum<_Tp>::value, "This hash only works for enumeration types"); 2558 2559 _LIBCPP_INLINE_VISIBILITY 2560 size_t operator()(_Tp __v) const _NOEXCEPT 2561 { 2562 typedef typename underlying_type<_Tp>::type type; 2563 return hash<type>{}(static_cast<type>(__v)); 2564 } 2565}; 2566#endif 2567 2568 2569#if _LIBCPP_STD_VER > 14 2570template <class _Fn, class ..._Args> 2571result_of_t<_Fn&&(_Args&&...)> 2572invoke(_Fn&& __f, _Args&&... __args) { 2573 return __invoke(_VSTD::forward<_Fn>(__f), _VSTD::forward<_Args>(__args)...); 2574} 2575#endif 2576 2577// struct hash<T*> in <memory> 2578 2579_LIBCPP_END_NAMESPACE_STD 2580 2581#endif // _LIBCPP_FUNCTIONAL 2582