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