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&); 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 { return _VSTD::forward<_T1>(__t) + _VSTD::forward<_T2>(__u); } 508 typedef void is_transparent; 509}; 510#endif 511 512 513#if _LIBCPP_STD_VER > 11 514template <class _Tp = void> 515#else 516template <class _Tp> 517#endif 518struct _LIBCPP_TYPE_VIS_ONLY minus : binary_function<_Tp, _Tp, _Tp> 519{ 520 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 521 _Tp operator()(const _Tp& __x, const _Tp& __y) const 522 {return __x - __y;} 523}; 524 525#if _LIBCPP_STD_VER > 11 526template <> 527struct _LIBCPP_TYPE_VIS_ONLY minus<void> 528{ 529 template <class _T1, class _T2> 530 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 531 auto operator()(_T1&& __t, _T2&& __u) const 532 { return _VSTD::forward<_T1>(__t) - _VSTD::forward<_T2>(__u); } 533 typedef void is_transparent; 534}; 535#endif 536 537 538#if _LIBCPP_STD_VER > 11 539template <class _Tp = void> 540#else 541template <class _Tp> 542#endif 543struct _LIBCPP_TYPE_VIS_ONLY multiplies : binary_function<_Tp, _Tp, _Tp> 544{ 545 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 546 _Tp operator()(const _Tp& __x, const _Tp& __y) const 547 {return __x * __y;} 548}; 549 550#if _LIBCPP_STD_VER > 11 551template <> 552struct _LIBCPP_TYPE_VIS_ONLY multiplies<void> 553{ 554 template <class _T1, class _T2> 555 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 556 auto operator()(_T1&& __t, _T2&& __u) const 557 { return _VSTD::forward<_T1>(__t) * _VSTD::forward<_T2>(__u); } 558 typedef void is_transparent; 559}; 560#endif 561 562 563#if _LIBCPP_STD_VER > 11 564template <class _Tp = void> 565#else 566template <class _Tp> 567#endif 568struct _LIBCPP_TYPE_VIS_ONLY divides : binary_function<_Tp, _Tp, _Tp> 569{ 570 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 571 _Tp operator()(const _Tp& __x, const _Tp& __y) const 572 {return __x / __y;} 573}; 574 575#if _LIBCPP_STD_VER > 11 576template <> 577struct _LIBCPP_TYPE_VIS_ONLY divides<void> 578{ 579 template <class _T1, class _T2> 580 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 581 auto operator()(_T1&& __t, _T2&& __u) const 582 { return _VSTD::forward<_T1>(__t) / _VSTD::forward<_T2>(__u); } 583 typedef void is_transparent; 584}; 585#endif 586 587 588#if _LIBCPP_STD_VER > 11 589template <class _Tp = void> 590#else 591template <class _Tp> 592#endif 593struct _LIBCPP_TYPE_VIS_ONLY modulus : binary_function<_Tp, _Tp, _Tp> 594{ 595 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 596 _Tp operator()(const _Tp& __x, const _Tp& __y) const 597 {return __x % __y;} 598}; 599 600#if _LIBCPP_STD_VER > 11 601template <> 602struct _LIBCPP_TYPE_VIS_ONLY modulus<void> 603{ 604 template <class _T1, class _T2> 605 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 606 auto operator()(_T1&& __t, _T2&& __u) const 607 { return _VSTD::forward<_T1>(__t) % _VSTD::forward<_T2>(__u); } 608 typedef void is_transparent; 609}; 610#endif 611 612 613#if _LIBCPP_STD_VER > 11 614template <class _Tp = void> 615#else 616template <class _Tp> 617#endif 618struct _LIBCPP_TYPE_VIS_ONLY negate : unary_function<_Tp, _Tp> 619{ 620 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 621 _Tp operator()(const _Tp& __x) const 622 {return -__x;} 623}; 624 625#if _LIBCPP_STD_VER > 11 626template <> 627struct _LIBCPP_TYPE_VIS_ONLY negate<void> 628{ 629 template <class _Tp> 630 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 631 auto operator()(_Tp&& __x) const 632 { return -_VSTD::forward<_Tp>(__x); } 633 typedef void is_transparent; 634}; 635#endif 636 637 638#if _LIBCPP_STD_VER > 11 639template <class _Tp = void> 640#else 641template <class _Tp> 642#endif 643struct _LIBCPP_TYPE_VIS_ONLY equal_to : binary_function<_Tp, _Tp, bool> 644{ 645 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 646 bool operator()(const _Tp& __x, const _Tp& __y) const 647 {return __x == __y;} 648}; 649 650#if _LIBCPP_STD_VER > 11 651template <> 652struct _LIBCPP_TYPE_VIS_ONLY equal_to<void> 653{ 654 template <class _T1, class _T2> 655 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 656 auto operator()(_T1&& __t, _T2&& __u) const 657 { return _VSTD::forward<_T1>(__t) == _VSTD::forward<_T2>(__u); } 658 typedef void is_transparent; 659}; 660#endif 661 662 663#if _LIBCPP_STD_VER > 11 664template <class _Tp = void> 665#else 666template <class _Tp> 667#endif 668struct _LIBCPP_TYPE_VIS_ONLY not_equal_to : binary_function<_Tp, _Tp, bool> 669{ 670 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 671 bool operator()(const _Tp& __x, const _Tp& __y) const 672 {return __x != __y;} 673}; 674 675#if _LIBCPP_STD_VER > 11 676template <> 677struct _LIBCPP_TYPE_VIS_ONLY not_equal_to<void> 678{ 679 template <class _T1, class _T2> 680 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 681 auto operator()(_T1&& __t, _T2&& __u) const 682 { return _VSTD::forward<_T1>(__t) != _VSTD::forward<_T2>(__u); } 683 typedef void is_transparent; 684}; 685#endif 686 687 688#if _LIBCPP_STD_VER > 11 689template <class _Tp = void> 690#else 691template <class _Tp> 692#endif 693struct _LIBCPP_TYPE_VIS_ONLY greater : binary_function<_Tp, _Tp, bool> 694{ 695 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 696 bool operator()(const _Tp& __x, const _Tp& __y) const 697 {return __x > __y;} 698}; 699 700#if _LIBCPP_STD_VER > 11 701template <> 702struct _LIBCPP_TYPE_VIS_ONLY greater<void> 703{ 704 template <class _T1, class _T2> 705 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 706 auto operator()(_T1&& __t, _T2&& __u) const 707 { return _VSTD::forward<_T1>(__t) > _VSTD::forward<_T2>(__u); } 708 typedef void is_transparent; 709}; 710#endif 711 712 713// less in <__functional_base> 714 715#if _LIBCPP_STD_VER > 11 716template <class _Tp = void> 717#else 718template <class _Tp> 719#endif 720struct _LIBCPP_TYPE_VIS_ONLY greater_equal : binary_function<_Tp, _Tp, bool> 721{ 722 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 723 bool operator()(const _Tp& __x, const _Tp& __y) const 724 {return __x >= __y;} 725}; 726 727#if _LIBCPP_STD_VER > 11 728template <> 729struct _LIBCPP_TYPE_VIS_ONLY greater_equal<void> 730{ 731 template <class _T1, class _T2> 732 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 733 auto operator()(_T1&& __t, _T2&& __u) const 734 { return _VSTD::forward<_T1>(__t) >= _VSTD::forward<_T2>(__u); } 735 typedef void is_transparent; 736}; 737#endif 738 739 740#if _LIBCPP_STD_VER > 11 741template <class _Tp = void> 742#else 743template <class _Tp> 744#endif 745struct _LIBCPP_TYPE_VIS_ONLY less_equal : binary_function<_Tp, _Tp, bool> 746{ 747 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 748 bool operator()(const _Tp& __x, const _Tp& __y) const 749 {return __x <= __y;} 750}; 751 752#if _LIBCPP_STD_VER > 11 753template <> 754struct _LIBCPP_TYPE_VIS_ONLY less_equal<void> 755{ 756 template <class _T1, class _T2> 757 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 758 auto operator()(_T1&& __t, _T2&& __u) const 759 { return _VSTD::forward<_T1>(__t) <= _VSTD::forward<_T2>(__u); } 760 typedef void is_transparent; 761}; 762#endif 763 764 765#if _LIBCPP_STD_VER > 11 766template <class _Tp = void> 767#else 768template <class _Tp> 769#endif 770struct _LIBCPP_TYPE_VIS_ONLY logical_and : binary_function<_Tp, _Tp, bool> 771{ 772 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 773 bool operator()(const _Tp& __x, const _Tp& __y) const 774 {return __x && __y;} 775}; 776 777#if _LIBCPP_STD_VER > 11 778template <> 779struct _LIBCPP_TYPE_VIS_ONLY logical_and<void> 780{ 781 template <class _T1, class _T2> 782 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 783 auto operator()(_T1&& __t, _T2&& __u) const 784 { return _VSTD::forward<_T1>(__t) && _VSTD::forward<_T2>(__u); } 785 typedef void is_transparent; 786}; 787#endif 788 789 790#if _LIBCPP_STD_VER > 11 791template <class _Tp = void> 792#else 793template <class _Tp> 794#endif 795struct _LIBCPP_TYPE_VIS_ONLY logical_or : binary_function<_Tp, _Tp, bool> 796{ 797 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 798 bool operator()(const _Tp& __x, const _Tp& __y) const 799 {return __x || __y;} 800}; 801 802#if _LIBCPP_STD_VER > 11 803template <> 804struct _LIBCPP_TYPE_VIS_ONLY logical_or<void> 805{ 806 template <class _T1, class _T2> 807 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 808 auto operator()(_T1&& __t, _T2&& __u) const 809 { return _VSTD::forward<_T1>(__t) || _VSTD::forward<_T2>(__u); } 810 typedef void is_transparent; 811}; 812#endif 813 814 815#if _LIBCPP_STD_VER > 11 816template <class _Tp = void> 817#else 818template <class _Tp> 819#endif 820struct _LIBCPP_TYPE_VIS_ONLY logical_not : unary_function<_Tp, bool> 821{ 822 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 823 bool operator()(const _Tp& __x) const 824 {return !__x;} 825}; 826 827#if _LIBCPP_STD_VER > 11 828template <> 829struct _LIBCPP_TYPE_VIS_ONLY logical_not<void> 830{ 831 template <class _Tp> 832 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 833 auto operator()(_Tp&& __x) const 834 { return !_VSTD::forward<_Tp>(__x); } 835 typedef void is_transparent; 836}; 837#endif 838 839 840#if _LIBCPP_STD_VER > 11 841template <class _Tp = void> 842#else 843template <class _Tp> 844#endif 845struct _LIBCPP_TYPE_VIS_ONLY bit_and : binary_function<_Tp, _Tp, _Tp> 846{ 847 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 848 _Tp operator()(const _Tp& __x, const _Tp& __y) const 849 {return __x & __y;} 850}; 851 852#if _LIBCPP_STD_VER > 11 853template <> 854struct _LIBCPP_TYPE_VIS_ONLY bit_and<void> 855{ 856 template <class _T1, class _T2> 857 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 858 auto operator()(_T1&& __t, _T2&& __u) const 859 { return _VSTD::forward<_T1>(__t) & _VSTD::forward<_T2>(__u); } 860 typedef void is_transparent; 861}; 862#endif 863 864 865#if _LIBCPP_STD_VER > 11 866template <class _Tp = void> 867#else 868template <class _Tp> 869#endif 870struct _LIBCPP_TYPE_VIS_ONLY bit_or : binary_function<_Tp, _Tp, _Tp> 871{ 872 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 873 _Tp operator()(const _Tp& __x, const _Tp& __y) const 874 {return __x | __y;} 875}; 876 877#if _LIBCPP_STD_VER > 11 878template <> 879struct _LIBCPP_TYPE_VIS_ONLY bit_or<void> 880{ 881 template <class _T1, class _T2> 882 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 883 auto operator()(_T1&& __t, _T2&& __u) const 884 { return _VSTD::forward<_T1>(__t) | _VSTD::forward<_T2>(__u); } 885 typedef void is_transparent; 886}; 887#endif 888 889 890#if _LIBCPP_STD_VER > 11 891template <class _Tp = void> 892#else 893template <class _Tp> 894#endif 895struct _LIBCPP_TYPE_VIS_ONLY bit_xor : binary_function<_Tp, _Tp, _Tp> 896{ 897 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 898 _Tp operator()(const _Tp& __x, const _Tp& __y) const 899 {return __x ^ __y;} 900}; 901 902#if _LIBCPP_STD_VER > 11 903template <> 904struct _LIBCPP_TYPE_VIS_ONLY bit_xor<void> 905{ 906 template <class _T1, class _T2> 907 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 908 auto operator()(_T1&& __t, _T2&& __u) const 909 { return _VSTD::forward<_T1>(__t) ^ _VSTD::forward<_T2>(__u); } 910 typedef void is_transparent; 911}; 912#endif 913 914 915#if _LIBCPP_STD_VER > 11 916template <class _Tp = void> 917struct _LIBCPP_TYPE_VIS_ONLY bit_not : unary_function<_Tp, _Tp> 918{ 919 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 920 _Tp operator()(const _Tp& __x) const 921 {return ~__x;} 922}; 923 924template <> 925struct _LIBCPP_TYPE_VIS_ONLY bit_not<void> 926{ 927 template <class _Tp> 928 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 929 auto operator()(_Tp&& __x) const 930 { return ~_VSTD::forward<_Tp>(__x); } 931 typedef void is_transparent; 932}; 933#endif 934 935template <class _Predicate> 936class _LIBCPP_TYPE_VIS_ONLY unary_negate 937 : public unary_function<typename _Predicate::argument_type, bool> 938{ 939 _Predicate __pred_; 940public: 941 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 942 explicit unary_negate(const _Predicate& __pred) 943 : __pred_(__pred) {} 944 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 945 bool operator()(const typename _Predicate::argument_type& __x) const 946 {return !__pred_(__x);} 947}; 948 949template <class _Predicate> 950inline _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 951unary_negate<_Predicate> 952not1(const _Predicate& __pred) {return unary_negate<_Predicate>(__pred);} 953 954template <class _Predicate> 955class _LIBCPP_TYPE_VIS_ONLY binary_negate 956 : public binary_function<typename _Predicate::first_argument_type, 957 typename _Predicate::second_argument_type, 958 bool> 959{ 960 _Predicate __pred_; 961public: 962 _LIBCPP_INLINE_VISIBILITY explicit _LIBCPP_CONSTEXPR_AFTER_CXX11 963 binary_negate(const _Predicate& __pred) : __pred_(__pred) {} 964 965 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 966 bool operator()(const typename _Predicate::first_argument_type& __x, 967 const typename _Predicate::second_argument_type& __y) const 968 {return !__pred_(__x, __y);} 969}; 970 971template <class _Predicate> 972inline _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 973binary_negate<_Predicate> 974not2(const _Predicate& __pred) {return binary_negate<_Predicate>(__pred);} 975 976template <class __Operation> 977class _LIBCPP_TYPE_VIS_ONLY binder1st 978 : public unary_function<typename __Operation::second_argument_type, 979 typename __Operation::result_type> 980{ 981protected: 982 __Operation op; 983 typename __Operation::first_argument_type value; 984public: 985 _LIBCPP_INLINE_VISIBILITY binder1st(const __Operation& __x, 986 const typename __Operation::first_argument_type __y) 987 : op(__x), value(__y) {} 988 _LIBCPP_INLINE_VISIBILITY typename __Operation::result_type operator() 989 (typename __Operation::second_argument_type& __x) const 990 {return op(value, __x);} 991 _LIBCPP_INLINE_VISIBILITY typename __Operation::result_type operator() 992 (const typename __Operation::second_argument_type& __x) const 993 {return op(value, __x);} 994}; 995 996template <class __Operation, class _Tp> 997inline _LIBCPP_INLINE_VISIBILITY 998binder1st<__Operation> 999bind1st(const __Operation& __op, const _Tp& __x) 1000 {return binder1st<__Operation>(__op, __x);} 1001 1002template <class __Operation> 1003class _LIBCPP_TYPE_VIS_ONLY binder2nd 1004 : public unary_function<typename __Operation::first_argument_type, 1005 typename __Operation::result_type> 1006{ 1007protected: 1008 __Operation op; 1009 typename __Operation::second_argument_type value; 1010public: 1011 _LIBCPP_INLINE_VISIBILITY 1012 binder2nd(const __Operation& __x, const typename __Operation::second_argument_type __y) 1013 : op(__x), value(__y) {} 1014 _LIBCPP_INLINE_VISIBILITY typename __Operation::result_type operator() 1015 ( typename __Operation::first_argument_type& __x) const 1016 {return op(__x, value);} 1017 _LIBCPP_INLINE_VISIBILITY typename __Operation::result_type operator() 1018 (const typename __Operation::first_argument_type& __x) const 1019 {return op(__x, value);} 1020}; 1021 1022template <class __Operation, class _Tp> 1023inline _LIBCPP_INLINE_VISIBILITY 1024binder2nd<__Operation> 1025bind2nd(const __Operation& __op, const _Tp& __x) 1026 {return binder2nd<__Operation>(__op, __x);} 1027 1028template <class _Arg, class _Result> 1029class _LIBCPP_TYPE_VIS_ONLY pointer_to_unary_function 1030 : public unary_function<_Arg, _Result> 1031{ 1032 _Result (*__f_)(_Arg); 1033public: 1034 _LIBCPP_INLINE_VISIBILITY explicit pointer_to_unary_function(_Result (*__f)(_Arg)) 1035 : __f_(__f) {} 1036 _LIBCPP_INLINE_VISIBILITY _Result operator()(_Arg __x) const 1037 {return __f_(__x);} 1038}; 1039 1040template <class _Arg, class _Result> 1041inline _LIBCPP_INLINE_VISIBILITY 1042pointer_to_unary_function<_Arg,_Result> 1043ptr_fun(_Result (*__f)(_Arg)) 1044 {return pointer_to_unary_function<_Arg,_Result>(__f);} 1045 1046template <class _Arg1, class _Arg2, class _Result> 1047class _LIBCPP_TYPE_VIS_ONLY pointer_to_binary_function 1048 : public binary_function<_Arg1, _Arg2, _Result> 1049{ 1050 _Result (*__f_)(_Arg1, _Arg2); 1051public: 1052 _LIBCPP_INLINE_VISIBILITY explicit pointer_to_binary_function(_Result (*__f)(_Arg1, _Arg2)) 1053 : __f_(__f) {} 1054 _LIBCPP_INLINE_VISIBILITY _Result operator()(_Arg1 __x, _Arg2 __y) const 1055 {return __f_(__x, __y);} 1056}; 1057 1058template <class _Arg1, class _Arg2, class _Result> 1059inline _LIBCPP_INLINE_VISIBILITY 1060pointer_to_binary_function<_Arg1,_Arg2,_Result> 1061ptr_fun(_Result (*__f)(_Arg1,_Arg2)) 1062 {return pointer_to_binary_function<_Arg1,_Arg2,_Result>(__f);} 1063 1064template<class _Sp, class _Tp> 1065class _LIBCPP_TYPE_VIS_ONLY mem_fun_t : public unary_function<_Tp*, _Sp> 1066{ 1067 _Sp (_Tp::*__p_)(); 1068public: 1069 _LIBCPP_INLINE_VISIBILITY explicit mem_fun_t(_Sp (_Tp::*__p)()) 1070 : __p_(__p) {} 1071 _LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp* __p) const 1072 {return (__p->*__p_)();} 1073}; 1074 1075template<class _Sp, class _Tp, class _Ap> 1076class _LIBCPP_TYPE_VIS_ONLY mem_fun1_t : public binary_function<_Tp*, _Ap, _Sp> 1077{ 1078 _Sp (_Tp::*__p_)(_Ap); 1079public: 1080 _LIBCPP_INLINE_VISIBILITY explicit mem_fun1_t(_Sp (_Tp::*__p)(_Ap)) 1081 : __p_(__p) {} 1082 _LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp* __p, _Ap __x) const 1083 {return (__p->*__p_)(__x);} 1084}; 1085 1086template<class _Sp, class _Tp> 1087inline _LIBCPP_INLINE_VISIBILITY 1088mem_fun_t<_Sp,_Tp> 1089mem_fun(_Sp (_Tp::*__f)()) 1090 {return mem_fun_t<_Sp,_Tp>(__f);} 1091 1092template<class _Sp, class _Tp, class _Ap> 1093inline _LIBCPP_INLINE_VISIBILITY 1094mem_fun1_t<_Sp,_Tp,_Ap> 1095mem_fun(_Sp (_Tp::*__f)(_Ap)) 1096 {return mem_fun1_t<_Sp,_Tp,_Ap>(__f);} 1097 1098template<class _Sp, class _Tp> 1099class _LIBCPP_TYPE_VIS_ONLY mem_fun_ref_t : public unary_function<_Tp, _Sp> 1100{ 1101 _Sp (_Tp::*__p_)(); 1102public: 1103 _LIBCPP_INLINE_VISIBILITY explicit mem_fun_ref_t(_Sp (_Tp::*__p)()) 1104 : __p_(__p) {} 1105 _LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp& __p) const 1106 {return (__p.*__p_)();} 1107}; 1108 1109template<class _Sp, class _Tp, class _Ap> 1110class _LIBCPP_TYPE_VIS_ONLY mem_fun1_ref_t : public binary_function<_Tp, _Ap, _Sp> 1111{ 1112 _Sp (_Tp::*__p_)(_Ap); 1113public: 1114 _LIBCPP_INLINE_VISIBILITY explicit mem_fun1_ref_t(_Sp (_Tp::*__p)(_Ap)) 1115 : __p_(__p) {} 1116 _LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp& __p, _Ap __x) const 1117 {return (__p.*__p_)(__x);} 1118}; 1119 1120template<class _Sp, class _Tp> 1121inline _LIBCPP_INLINE_VISIBILITY 1122mem_fun_ref_t<_Sp,_Tp> 1123mem_fun_ref(_Sp (_Tp::*__f)()) 1124 {return mem_fun_ref_t<_Sp,_Tp>(__f);} 1125 1126template<class _Sp, class _Tp, class _Ap> 1127inline _LIBCPP_INLINE_VISIBILITY 1128mem_fun1_ref_t<_Sp,_Tp,_Ap> 1129mem_fun_ref(_Sp (_Tp::*__f)(_Ap)) 1130 {return mem_fun1_ref_t<_Sp,_Tp,_Ap>(__f);} 1131 1132template <class _Sp, class _Tp> 1133class _LIBCPP_TYPE_VIS_ONLY const_mem_fun_t : public unary_function<const _Tp*, _Sp> 1134{ 1135 _Sp (_Tp::*__p_)() const; 1136public: 1137 _LIBCPP_INLINE_VISIBILITY explicit const_mem_fun_t(_Sp (_Tp::*__p)() const) 1138 : __p_(__p) {} 1139 _LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp* __p) const 1140 {return (__p->*__p_)();} 1141}; 1142 1143template <class _Sp, class _Tp, class _Ap> 1144class _LIBCPP_TYPE_VIS_ONLY const_mem_fun1_t : public binary_function<const _Tp*, _Ap, _Sp> 1145{ 1146 _Sp (_Tp::*__p_)(_Ap) const; 1147public: 1148 _LIBCPP_INLINE_VISIBILITY explicit const_mem_fun1_t(_Sp (_Tp::*__p)(_Ap) const) 1149 : __p_(__p) {} 1150 _LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp* __p, _Ap __x) const 1151 {return (__p->*__p_)(__x);} 1152}; 1153 1154template <class _Sp, class _Tp> 1155inline _LIBCPP_INLINE_VISIBILITY 1156const_mem_fun_t<_Sp,_Tp> 1157mem_fun(_Sp (_Tp::*__f)() const) 1158 {return const_mem_fun_t<_Sp,_Tp>(__f);} 1159 1160template <class _Sp, class _Tp, class _Ap> 1161inline _LIBCPP_INLINE_VISIBILITY 1162const_mem_fun1_t<_Sp,_Tp,_Ap> 1163mem_fun(_Sp (_Tp::*__f)(_Ap) const) 1164 {return const_mem_fun1_t<_Sp,_Tp,_Ap>(__f);} 1165 1166template <class _Sp, class _Tp> 1167class _LIBCPP_TYPE_VIS_ONLY const_mem_fun_ref_t : public unary_function<_Tp, _Sp> 1168{ 1169 _Sp (_Tp::*__p_)() const; 1170public: 1171 _LIBCPP_INLINE_VISIBILITY explicit const_mem_fun_ref_t(_Sp (_Tp::*__p)() const) 1172 : __p_(__p) {} 1173 _LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp& __p) const 1174 {return (__p.*__p_)();} 1175}; 1176 1177template <class _Sp, class _Tp, class _Ap> 1178class _LIBCPP_TYPE_VIS_ONLY const_mem_fun1_ref_t 1179 : public binary_function<_Tp, _Ap, _Sp> 1180{ 1181 _Sp (_Tp::*__p_)(_Ap) const; 1182public: 1183 _LIBCPP_INLINE_VISIBILITY explicit const_mem_fun1_ref_t(_Sp (_Tp::*__p)(_Ap) const) 1184 : __p_(__p) {} 1185 _LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp& __p, _Ap __x) const 1186 {return (__p.*__p_)(__x);} 1187}; 1188 1189template <class _Sp, class _Tp> 1190inline _LIBCPP_INLINE_VISIBILITY 1191const_mem_fun_ref_t<_Sp,_Tp> 1192mem_fun_ref(_Sp (_Tp::*__f)() const) 1193 {return const_mem_fun_ref_t<_Sp,_Tp>(__f);} 1194 1195template <class _Sp, class _Tp, class _Ap> 1196inline _LIBCPP_INLINE_VISIBILITY 1197const_mem_fun1_ref_t<_Sp,_Tp,_Ap> 1198mem_fun_ref(_Sp (_Tp::*__f)(_Ap) const) 1199 {return const_mem_fun1_ref_t<_Sp,_Tp,_Ap>(__f);} 1200 1201#ifdef _LIBCPP_HAS_NO_VARIADICS 1202 1203#include <__functional_03> 1204 1205#else // _LIBCPP_HAS_NO_VARIADICS 1206 1207template <class _Tp> 1208class __mem_fn 1209 : public __weak_result_type<_Tp> 1210{ 1211public: 1212 // types 1213 typedef _Tp type; 1214private: 1215 type __f_; 1216 1217public: 1218 _LIBCPP_INLINE_VISIBILITY __mem_fn(type __f) : __f_(__f) {} 1219 1220 // invoke 1221 template <class... _ArgTypes> 1222 _LIBCPP_INLINE_VISIBILITY 1223 typename __invoke_return<type, _ArgTypes...>::type 1224 operator() (_ArgTypes&&... __args) const 1225 { 1226 return __invoke(__f_, _VSTD::forward<_ArgTypes>(__args)...); 1227 } 1228}; 1229 1230template<class _Rp, class _Tp> 1231inline _LIBCPP_INLINE_VISIBILITY 1232__mem_fn<_Rp _Tp::*> 1233mem_fn(_Rp _Tp::* __pm) 1234{ 1235 return __mem_fn<_Rp _Tp::*>(__pm); 1236} 1237 1238// bad_function_call 1239 1240class _LIBCPP_EXCEPTION_ABI bad_function_call 1241 : public exception 1242{ 1243}; 1244 1245template<class _Fp> class _LIBCPP_TYPE_VIS_ONLY function; // undefined 1246 1247namespace __function 1248{ 1249 1250template<class _Rp, class ..._ArgTypes> 1251struct __maybe_derive_from_unary_function 1252{ 1253}; 1254 1255template<class _Rp, class _A1> 1256struct __maybe_derive_from_unary_function<_Rp(_A1)> 1257 : public unary_function<_A1, _Rp> 1258{ 1259}; 1260 1261template<class _Rp, class ..._ArgTypes> 1262struct __maybe_derive_from_binary_function 1263{ 1264}; 1265 1266template<class _Rp, class _A1, class _A2> 1267struct __maybe_derive_from_binary_function<_Rp(_A1, _A2)> 1268 : public binary_function<_A1, _A2, _Rp> 1269{ 1270}; 1271 1272template<class _Fp> class __base; 1273 1274template<class _Rp, class ..._ArgTypes> 1275class __base<_Rp(_ArgTypes...)> 1276{ 1277 __base(const __base&); 1278 __base& operator=(const __base&); 1279public: 1280 _LIBCPP_INLINE_VISIBILITY __base() {} 1281 _LIBCPP_INLINE_VISIBILITY virtual ~__base() {} 1282 virtual __base* __clone() const = 0; 1283 virtual void __clone(__base*) const = 0; 1284 virtual void destroy() _NOEXCEPT = 0; 1285 virtual void destroy_deallocate() _NOEXCEPT = 0; 1286 virtual _Rp operator()(_ArgTypes&& ...) = 0; 1287#ifndef _LIBCPP_NO_RTTI 1288 virtual const void* target(const type_info&) const _NOEXCEPT = 0; 1289 virtual const std::type_info& target_type() const _NOEXCEPT = 0; 1290#endif // _LIBCPP_NO_RTTI 1291}; 1292 1293template<class _FD, class _Alloc, class _FB> class __func; 1294 1295template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes> 1296class __func<_Fp, _Alloc, _Rp(_ArgTypes...)> 1297 : public __base<_Rp(_ArgTypes...)> 1298{ 1299 __compressed_pair<_Fp, _Alloc> __f_; 1300public: 1301 _LIBCPP_INLINE_VISIBILITY 1302 explicit __func(_Fp&& __f) 1303 : __f_(piecewise_construct, _VSTD::forward_as_tuple(_VSTD::move(__f)), 1304 _VSTD::forward_as_tuple()) {} 1305 _LIBCPP_INLINE_VISIBILITY 1306 explicit __func(const _Fp& __f, const _Alloc& __a) 1307 : __f_(piecewise_construct, _VSTD::forward_as_tuple(__f), 1308 _VSTD::forward_as_tuple(__a)) {} 1309 1310 _LIBCPP_INLINE_VISIBILITY 1311 explicit __func(const _Fp& __f, _Alloc&& __a) 1312 : __f_(piecewise_construct, _VSTD::forward_as_tuple(__f), 1313 _VSTD::forward_as_tuple(_VSTD::move(__a))) {} 1314 1315 _LIBCPP_INLINE_VISIBILITY 1316 explicit __func(_Fp&& __f, _Alloc&& __a) 1317 : __f_(piecewise_construct, _VSTD::forward_as_tuple(_VSTD::move(__f)), 1318 _VSTD::forward_as_tuple(_VSTD::move(__a))) {} 1319 virtual __base<_Rp(_ArgTypes...)>* __clone() const; 1320 virtual void __clone(__base<_Rp(_ArgTypes...)>*) const; 1321 virtual void destroy() _NOEXCEPT; 1322 virtual void destroy_deallocate() _NOEXCEPT; 1323 virtual _Rp operator()(_ArgTypes&& ... __arg); 1324#ifndef _LIBCPP_NO_RTTI 1325 virtual const void* target(const type_info&) const _NOEXCEPT; 1326 virtual const std::type_info& target_type() const _NOEXCEPT; 1327#endif // _LIBCPP_NO_RTTI 1328}; 1329 1330template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes> 1331__base<_Rp(_ArgTypes...)>* 1332__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::__clone() const 1333{ 1334 typedef typename _Alloc::template rebind<__func>::other _Ap; 1335 _Ap __a(__f_.second()); 1336 typedef __allocator_destructor<_Ap> _Dp; 1337 unique_ptr<__func, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); 1338 ::new (__hold.get()) __func(__f_.first(), _Alloc(__a)); 1339 return __hold.release(); 1340} 1341 1342template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes> 1343void 1344__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::__clone(__base<_Rp(_ArgTypes...)>* __p) const 1345{ 1346 ::new (__p) __func(__f_.first(), __f_.second()); 1347} 1348 1349template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes> 1350void 1351__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy() _NOEXCEPT 1352{ 1353 __f_.~__compressed_pair<_Fp, _Alloc>(); 1354} 1355 1356template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes> 1357void 1358__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy_deallocate() _NOEXCEPT 1359{ 1360 typedef typename _Alloc::template rebind<__func>::other _Ap; 1361 _Ap __a(__f_.second()); 1362 __f_.~__compressed_pair<_Fp, _Alloc>(); 1363 __a.deallocate(this, 1); 1364} 1365 1366template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes> 1367_Rp 1368__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::operator()(_ArgTypes&& ... __arg) 1369{ 1370 typedef __invoke_void_return_wrapper<_Rp> _Invoker; 1371 return _Invoker::__call(__f_.first(), _VSTD::forward<_ArgTypes>(__arg)...); 1372} 1373 1374#ifndef _LIBCPP_NO_RTTI 1375 1376template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes> 1377const void* 1378__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::target(const type_info& __ti) const _NOEXCEPT 1379{ 1380 if (__ti == typeid(_Fp)) 1381 return &__f_.first(); 1382 return (const void*)0; 1383} 1384 1385template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes> 1386const std::type_info& 1387__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::target_type() const _NOEXCEPT 1388{ 1389 return typeid(_Fp); 1390} 1391 1392#endif // _LIBCPP_NO_RTTI 1393 1394} // __function 1395 1396template<class _Rp, class ..._ArgTypes> 1397class _LIBCPP_TYPE_VIS_ONLY function<_Rp(_ArgTypes...)> 1398 : public __function::__maybe_derive_from_unary_function<_Rp(_ArgTypes...)>, 1399 public __function::__maybe_derive_from_binary_function<_Rp(_ArgTypes...)> 1400{ 1401 typedef __function::__base<_Rp(_ArgTypes...)> __base; 1402 typename aligned_storage<3*sizeof(void*)>::type __buf_; 1403 __base* __f_; 1404 1405 template <class _Fp> 1406 _LIBCPP_INLINE_VISIBILITY 1407 static bool __not_null(const _Fp&) {return true;} 1408 template <class _R2, class ..._Ap> 1409 _LIBCPP_INLINE_VISIBILITY 1410 static bool __not_null(_R2 (*__p)(_Ap...)) {return __p;} 1411 template <class _R2, class _Cp, class ..._Ap> 1412 _LIBCPP_INLINE_VISIBILITY 1413 static bool __not_null(_R2 (_Cp::*__p)(_Ap...)) {return __p;} 1414 template <class _R2, class _Cp, class ..._Ap> 1415 _LIBCPP_INLINE_VISIBILITY 1416 static bool __not_null(_R2 (_Cp::*__p)(_Ap...) const) {return __p;} 1417 template <class _R2, class _Cp, class ..._Ap> 1418 _LIBCPP_INLINE_VISIBILITY 1419 static bool __not_null(_R2 (_Cp::*__p)(_Ap...) volatile) {return __p;} 1420 template <class _R2, class _Cp, class ..._Ap> 1421 _LIBCPP_INLINE_VISIBILITY 1422 static bool __not_null(_R2 (_Cp::*__p)(_Ap...) const volatile) {return __p;} 1423 template <class _R2, class ..._Ap> 1424 _LIBCPP_INLINE_VISIBILITY 1425 static bool __not_null(const function<_R2(_Ap...)>& __p) {return !!__p;} 1426 1427 template <class _Fp, bool = !is_same<_Fp, function>::value && 1428 __invokable<_Fp&, _ArgTypes...>::value> 1429 struct __callable; 1430 template <class _Fp> 1431 struct __callable<_Fp, true> 1432 { 1433 static const bool value = is_same<void, _Rp>::value || 1434 is_convertible<typename __invoke_of<_Fp&, _ArgTypes...>::type, 1435 _Rp>::value; 1436 }; 1437 template <class _Fp> 1438 struct __callable<_Fp, false> 1439 { 1440 static const bool value = false; 1441 }; 1442public: 1443 typedef _Rp result_type; 1444 1445 // construct/copy/destroy: 1446 _LIBCPP_INLINE_VISIBILITY 1447 function() _NOEXCEPT : __f_(0) {} 1448 _LIBCPP_INLINE_VISIBILITY 1449 function(nullptr_t) _NOEXCEPT : __f_(0) {} 1450 function(const function&); 1451 function(function&&) _NOEXCEPT; 1452 template<class _Fp> 1453 function(_Fp, typename enable_if 1454 < 1455 __callable<_Fp>::value && 1456 !is_same<_Fp, function>::value 1457 >::type* = 0); 1458 1459 template<class _Alloc> 1460 _LIBCPP_INLINE_VISIBILITY 1461 function(allocator_arg_t, const _Alloc&) _NOEXCEPT : __f_(0) {} 1462 template<class _Alloc> 1463 _LIBCPP_INLINE_VISIBILITY 1464 function(allocator_arg_t, const _Alloc&, nullptr_t) _NOEXCEPT : __f_(0) {} 1465 template<class _Alloc> 1466 function(allocator_arg_t, const _Alloc&, const function&); 1467 template<class _Alloc> 1468 function(allocator_arg_t, const _Alloc&, function&&); 1469 template<class _Fp, class _Alloc> 1470 function(allocator_arg_t, const _Alloc& __a, _Fp __f, 1471 typename enable_if<__callable<_Fp>::value>::type* = 0); 1472 1473 function& operator=(const function&); 1474 function& operator=(function&&) _NOEXCEPT; 1475 function& operator=(nullptr_t) _NOEXCEPT; 1476 template<class _Fp> 1477 typename enable_if 1478 < 1479 __callable<typename decay<_Fp>::type>::value && 1480 !is_same<typename remove_reference<_Fp>::type, function>::value, 1481 function& 1482 >::type 1483 operator=(_Fp&&); 1484 1485 ~function(); 1486 1487 // function modifiers: 1488 void swap(function&) _NOEXCEPT; 1489 template<class _Fp, class _Alloc> 1490 _LIBCPP_INLINE_VISIBILITY 1491 void assign(_Fp&& __f, const _Alloc& __a) 1492 {function(allocator_arg, __a, _VSTD::forward<_Fp>(__f)).swap(*this);} 1493 1494 // function capacity: 1495 _LIBCPP_INLINE_VISIBILITY 1496 _LIBCPP_EXPLICIT operator bool() const _NOEXCEPT {return __f_;} 1497 1498 // deleted overloads close possible hole in the type system 1499 template<class _R2, class... _ArgTypes2> 1500 bool operator==(const function<_R2(_ArgTypes2...)>&) const = delete; 1501 template<class _R2, class... _ArgTypes2> 1502 bool operator!=(const function<_R2(_ArgTypes2...)>&) const = delete; 1503public: 1504 // function invocation: 1505 _Rp operator()(_ArgTypes...) const; 1506 1507#ifndef _LIBCPP_NO_RTTI 1508 // function target access: 1509 const std::type_info& target_type() const _NOEXCEPT; 1510 template <typename _Tp> _Tp* target() _NOEXCEPT; 1511 template <typename _Tp> const _Tp* target() const _NOEXCEPT; 1512#endif // _LIBCPP_NO_RTTI 1513}; 1514 1515template<class _Rp, class ..._ArgTypes> 1516function<_Rp(_ArgTypes...)>::function(const function& __f) 1517{ 1518 if (__f.__f_ == 0) 1519 __f_ = 0; 1520 else if (__f.__f_ == (const __base*)&__f.__buf_) 1521 { 1522 __f_ = (__base*)&__buf_; 1523 __f.__f_->__clone(__f_); 1524 } 1525 else 1526 __f_ = __f.__f_->__clone(); 1527} 1528 1529template<class _Rp, class ..._ArgTypes> 1530template <class _Alloc> 1531function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc&, 1532 const function& __f) 1533{ 1534 if (__f.__f_ == 0) 1535 __f_ = 0; 1536 else if (__f.__f_ == (const __base*)&__f.__buf_) 1537 { 1538 __f_ = (__base*)&__buf_; 1539 __f.__f_->__clone(__f_); 1540 } 1541 else 1542 __f_ = __f.__f_->__clone(); 1543} 1544 1545template<class _Rp, class ..._ArgTypes> 1546function<_Rp(_ArgTypes...)>::function(function&& __f) _NOEXCEPT 1547{ 1548 if (__f.__f_ == 0) 1549 __f_ = 0; 1550 else if (__f.__f_ == (__base*)&__f.__buf_) 1551 { 1552 __f_ = (__base*)&__buf_; 1553 __f.__f_->__clone(__f_); 1554 } 1555 else 1556 { 1557 __f_ = __f.__f_; 1558 __f.__f_ = 0; 1559 } 1560} 1561 1562template<class _Rp, class ..._ArgTypes> 1563template <class _Alloc> 1564function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc&, 1565 function&& __f) 1566{ 1567 if (__f.__f_ == 0) 1568 __f_ = 0; 1569 else if (__f.__f_ == (__base*)&__f.__buf_) 1570 { 1571 __f_ = (__base*)&__buf_; 1572 __f.__f_->__clone(__f_); 1573 } 1574 else 1575 { 1576 __f_ = __f.__f_; 1577 __f.__f_ = 0; 1578 } 1579} 1580 1581template<class _Rp, class ..._ArgTypes> 1582template <class _Fp> 1583function<_Rp(_ArgTypes...)>::function(_Fp __f, 1584 typename enable_if 1585 < 1586 __callable<_Fp>::value && 1587 !is_same<_Fp, function>::value 1588 >::type*) 1589 : __f_(0) 1590{ 1591 if (__not_null(__f)) 1592 { 1593 typedef __function::__func<_Fp, allocator<_Fp>, _Rp(_ArgTypes...)> _FF; 1594 if (sizeof(_FF) <= sizeof(__buf_) && is_nothrow_copy_constructible<_Fp>::value) 1595 { 1596 __f_ = (__base*)&__buf_; 1597 ::new (__f_) _FF(_VSTD::move(__f)); 1598 } 1599 else 1600 { 1601 typedef allocator<_FF> _Ap; 1602 _Ap __a; 1603 typedef __allocator_destructor<_Ap> _Dp; 1604 unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); 1605 ::new (__hold.get()) _FF(_VSTD::move(__f), allocator<_Fp>(__a)); 1606 __f_ = __hold.release(); 1607 } 1608 } 1609} 1610 1611template<class _Rp, class ..._ArgTypes> 1612template <class _Fp, class _Alloc> 1613function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc& __a0, _Fp __f, 1614 typename enable_if<__callable<_Fp>::value>::type*) 1615 : __f_(0) 1616{ 1617 typedef allocator_traits<_Alloc> __alloc_traits; 1618 if (__not_null(__f)) 1619 { 1620 typedef __function::__func<_Fp, _Alloc, _Rp(_ArgTypes...)> _FF; 1621 typedef typename __alloc_traits::template 1622#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES 1623 rebind_alloc<_FF> 1624#else 1625 rebind_alloc<_FF>::other 1626#endif 1627 _Ap; 1628 _Ap __a(__a0); 1629 if (sizeof(_FF) <= sizeof(__buf_) && 1630 is_nothrow_copy_constructible<_Fp>::value && is_nothrow_copy_constructible<_Ap>::value) 1631 { 1632 __f_ = (__base*)&__buf_; 1633 ::new (__f_) _FF(_VSTD::move(__f), _Alloc(__a)); 1634 } 1635 else 1636 { 1637 typedef __allocator_destructor<_Ap> _Dp; 1638 unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); 1639 ::new (__hold.get()) _FF(_VSTD::move(__f), _Alloc(__a)); 1640 __f_ = __hold.release(); 1641 } 1642 } 1643} 1644 1645template<class _Rp, class ..._ArgTypes> 1646function<_Rp(_ArgTypes...)>& 1647function<_Rp(_ArgTypes...)>::operator=(const function& __f) 1648{ 1649 function(__f).swap(*this); 1650 return *this; 1651} 1652 1653template<class _Rp, class ..._ArgTypes> 1654function<_Rp(_ArgTypes...)>& 1655function<_Rp(_ArgTypes...)>::operator=(function&& __f) _NOEXCEPT 1656{ 1657 if (__f_ == (__base*)&__buf_) 1658 __f_->destroy(); 1659 else if (__f_) 1660 __f_->destroy_deallocate(); 1661 __f_ = 0; 1662 if (__f.__f_ == 0) 1663 __f_ = 0; 1664 else if (__f.__f_ == (__base*)&__f.__buf_) 1665 { 1666 __f_ = (__base*)&__buf_; 1667 __f.__f_->__clone(__f_); 1668 } 1669 else 1670 { 1671 __f_ = __f.__f_; 1672 __f.__f_ = 0; 1673 } 1674 return *this; 1675} 1676 1677template<class _Rp, class ..._ArgTypes> 1678function<_Rp(_ArgTypes...)>& 1679function<_Rp(_ArgTypes...)>::operator=(nullptr_t) _NOEXCEPT 1680{ 1681 if (__f_ == (__base*)&__buf_) 1682 __f_->destroy(); 1683 else if (__f_) 1684 __f_->destroy_deallocate(); 1685 __f_ = 0; 1686 return *this; 1687} 1688 1689template<class _Rp, class ..._ArgTypes> 1690template <class _Fp> 1691typename enable_if 1692< 1693 function<_Rp(_ArgTypes...)>::template __callable<typename decay<_Fp>::type>::value && 1694 !is_same<typename remove_reference<_Fp>::type, function<_Rp(_ArgTypes...)>>::value, 1695 function<_Rp(_ArgTypes...)>& 1696>::type 1697function<_Rp(_ArgTypes...)>::operator=(_Fp&& __f) 1698{ 1699 function(_VSTD::forward<_Fp>(__f)).swap(*this); 1700 return *this; 1701} 1702 1703template<class _Rp, class ..._ArgTypes> 1704function<_Rp(_ArgTypes...)>::~function() 1705{ 1706 if (__f_ == (__base*)&__buf_) 1707 __f_->destroy(); 1708 else if (__f_) 1709 __f_->destroy_deallocate(); 1710} 1711 1712template<class _Rp, class ..._ArgTypes> 1713void 1714function<_Rp(_ArgTypes...)>::swap(function& __f) _NOEXCEPT 1715{ 1716 if (__f_ == (__base*)&__buf_ && __f.__f_ == (__base*)&__f.__buf_) 1717 { 1718 typename aligned_storage<sizeof(__buf_)>::type __tempbuf; 1719 __base* __t = (__base*)&__tempbuf; 1720 __f_->__clone(__t); 1721 __f_->destroy(); 1722 __f_ = 0; 1723 __f.__f_->__clone((__base*)&__buf_); 1724 __f.__f_->destroy(); 1725 __f.__f_ = 0; 1726 __f_ = (__base*)&__buf_; 1727 __t->__clone((__base*)&__f.__buf_); 1728 __t->destroy(); 1729 __f.__f_ = (__base*)&__f.__buf_; 1730 } 1731 else if (__f_ == (__base*)&__buf_) 1732 { 1733 __f_->__clone((__base*)&__f.__buf_); 1734 __f_->destroy(); 1735 __f_ = __f.__f_; 1736 __f.__f_ = (__base*)&__f.__buf_; 1737 } 1738 else if (__f.__f_ == (__base*)&__f.__buf_) 1739 { 1740 __f.__f_->__clone((__base*)&__buf_); 1741 __f.__f_->destroy(); 1742 __f.__f_ = __f_; 1743 __f_ = (__base*)&__buf_; 1744 } 1745 else 1746 _VSTD::swap(__f_, __f.__f_); 1747} 1748 1749template<class _Rp, class ..._ArgTypes> 1750_Rp 1751function<_Rp(_ArgTypes...)>::operator()(_ArgTypes... __arg) const 1752{ 1753#ifndef _LIBCPP_NO_EXCEPTIONS 1754 if (__f_ == 0) 1755 throw bad_function_call(); 1756#endif // _LIBCPP_NO_EXCEPTIONS 1757 return (*__f_)(_VSTD::forward<_ArgTypes>(__arg)...); 1758} 1759 1760#ifndef _LIBCPP_NO_RTTI 1761 1762template<class _Rp, class ..._ArgTypes> 1763const std::type_info& 1764function<_Rp(_ArgTypes...)>::target_type() const _NOEXCEPT 1765{ 1766 if (__f_ == 0) 1767 return typeid(void); 1768 return __f_->target_type(); 1769} 1770 1771template<class _Rp, class ..._ArgTypes> 1772template <typename _Tp> 1773_Tp* 1774function<_Rp(_ArgTypes...)>::target() _NOEXCEPT 1775{ 1776 if (__f_ == 0) 1777 return (_Tp*)0; 1778 return (_Tp*)__f_->target(typeid(_Tp)); 1779} 1780 1781template<class _Rp, class ..._ArgTypes> 1782template <typename _Tp> 1783const _Tp* 1784function<_Rp(_ArgTypes...)>::target() const _NOEXCEPT 1785{ 1786 if (__f_ == 0) 1787 return (const _Tp*)0; 1788 return (const _Tp*)__f_->target(typeid(_Tp)); 1789} 1790 1791#endif // _LIBCPP_NO_RTTI 1792 1793template <class _Rp, class... _ArgTypes> 1794inline _LIBCPP_INLINE_VISIBILITY 1795bool 1796operator==(const function<_Rp(_ArgTypes...)>& __f, nullptr_t) _NOEXCEPT {return !__f;} 1797 1798template <class _Rp, class... _ArgTypes> 1799inline _LIBCPP_INLINE_VISIBILITY 1800bool 1801operator==(nullptr_t, const function<_Rp(_ArgTypes...)>& __f) _NOEXCEPT {return !__f;} 1802 1803template <class _Rp, class... _ArgTypes> 1804inline _LIBCPP_INLINE_VISIBILITY 1805bool 1806operator!=(const function<_Rp(_ArgTypes...)>& __f, nullptr_t) _NOEXCEPT {return (bool)__f;} 1807 1808template <class _Rp, class... _ArgTypes> 1809inline _LIBCPP_INLINE_VISIBILITY 1810bool 1811operator!=(nullptr_t, const function<_Rp(_ArgTypes...)>& __f) _NOEXCEPT {return (bool)__f;} 1812 1813template <class _Rp, class... _ArgTypes> 1814inline _LIBCPP_INLINE_VISIBILITY 1815void 1816swap(function<_Rp(_ArgTypes...)>& __x, function<_Rp(_ArgTypes...)>& __y) _NOEXCEPT 1817{return __x.swap(__y);} 1818 1819template<class _Tp> struct __is_bind_expression : public false_type {}; 1820template<class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_bind_expression 1821 : public __is_bind_expression<typename remove_cv<_Tp>::type> {}; 1822 1823template<class _Tp> struct __is_placeholder : public integral_constant<int, 0> {}; 1824template<class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_placeholder 1825 : public __is_placeholder<typename remove_cv<_Tp>::type> {}; 1826 1827namespace placeholders 1828{ 1829 1830template <int _Np> struct __ph {}; 1831 1832_LIBCPP_FUNC_VIS extern __ph<1> _1; 1833_LIBCPP_FUNC_VIS extern __ph<2> _2; 1834_LIBCPP_FUNC_VIS extern __ph<3> _3; 1835_LIBCPP_FUNC_VIS extern __ph<4> _4; 1836_LIBCPP_FUNC_VIS extern __ph<5> _5; 1837_LIBCPP_FUNC_VIS extern __ph<6> _6; 1838_LIBCPP_FUNC_VIS extern __ph<7> _7; 1839_LIBCPP_FUNC_VIS extern __ph<8> _8; 1840_LIBCPP_FUNC_VIS extern __ph<9> _9; 1841_LIBCPP_FUNC_VIS extern __ph<10> _10; 1842 1843} // placeholders 1844 1845template<int _Np> 1846struct __is_placeholder<placeholders::__ph<_Np> > 1847 : public integral_constant<int, _Np> {}; 1848 1849template <class _Tp, class _Uj> 1850inline _LIBCPP_INLINE_VISIBILITY 1851_Tp& 1852__mu(reference_wrapper<_Tp> __t, _Uj&) 1853{ 1854 return __t.get(); 1855} 1856 1857template <class _Ti, class ..._Uj, size_t ..._Indx> 1858inline _LIBCPP_INLINE_VISIBILITY 1859typename __invoke_of<_Ti&, _Uj...>::type 1860__mu_expand(_Ti& __ti, tuple<_Uj...>& __uj, __tuple_indices<_Indx...>) 1861{ 1862 return __ti(_VSTD::forward<_Uj>(_VSTD::get<_Indx>(__uj))...); 1863} 1864 1865template <class _Ti, class ..._Uj> 1866inline _LIBCPP_INLINE_VISIBILITY 1867typename __lazy_enable_if 1868< 1869 is_bind_expression<_Ti>::value, 1870 __invoke_of<_Ti&, _Uj...> 1871>::type 1872__mu(_Ti& __ti, tuple<_Uj...>& __uj) 1873{ 1874 typedef typename __make_tuple_indices<sizeof...(_Uj)>::type __indices; 1875 return __mu_expand(__ti, __uj, __indices()); 1876} 1877 1878template <bool IsPh, class _Ti, class _Uj> 1879struct __mu_return2 {}; 1880 1881template <class _Ti, class _Uj> 1882struct __mu_return2<true, _Ti, _Uj> 1883{ 1884 typedef typename tuple_element<is_placeholder<_Ti>::value - 1, _Uj>::type type; 1885}; 1886 1887template <class _Ti, class _Uj> 1888inline _LIBCPP_INLINE_VISIBILITY 1889typename enable_if 1890< 1891 0 < is_placeholder<_Ti>::value, 1892 typename __mu_return2<0 < is_placeholder<_Ti>::value, _Ti, _Uj>::type 1893>::type 1894__mu(_Ti&, _Uj& __uj) 1895{ 1896 const size_t _Indx = is_placeholder<_Ti>::value - 1; 1897 return _VSTD::forward<typename tuple_element<_Indx, _Uj>::type>(_VSTD::get<_Indx>(__uj)); 1898} 1899 1900template <class _Ti, class _Uj> 1901inline _LIBCPP_INLINE_VISIBILITY 1902typename enable_if 1903< 1904 !is_bind_expression<_Ti>::value && 1905 is_placeholder<_Ti>::value == 0 && 1906 !__is_reference_wrapper<_Ti>::value, 1907 _Ti& 1908>::type 1909__mu(_Ti& __ti, _Uj&) 1910{ 1911 return __ti; 1912} 1913 1914template <class _Ti, bool IsReferenceWrapper, bool IsBindEx, bool IsPh, 1915 class _TupleUj> 1916struct ____mu_return; 1917 1918template <bool _Invokable, class _Ti, class ..._Uj> 1919struct ____mu_return_invokable // false 1920{ 1921 typedef __nat type; 1922}; 1923 1924template <class _Ti, class ..._Uj> 1925struct ____mu_return_invokable<true, _Ti, _Uj...> 1926{ 1927 typedef typename __invoke_of<_Ti&, _Uj...>::type type; 1928}; 1929 1930template <class _Ti, class ..._Uj> 1931struct ____mu_return<_Ti, false, true, false, tuple<_Uj...> > 1932 : public ____mu_return_invokable<__invokable<_Ti&, _Uj...>::value, _Ti, _Uj...> 1933{ 1934}; 1935 1936template <class _Ti, class _TupleUj> 1937struct ____mu_return<_Ti, false, false, true, _TupleUj> 1938{ 1939 typedef typename tuple_element<is_placeholder<_Ti>::value - 1, 1940 _TupleUj>::type&& type; 1941}; 1942 1943template <class _Ti, class _TupleUj> 1944struct ____mu_return<_Ti, true, false, false, _TupleUj> 1945{ 1946 typedef typename _Ti::type& type; 1947}; 1948 1949template <class _Ti, class _TupleUj> 1950struct ____mu_return<_Ti, false, false, false, _TupleUj> 1951{ 1952 typedef _Ti& type; 1953}; 1954 1955template <class _Ti, class _TupleUj> 1956struct __mu_return 1957 : public ____mu_return<_Ti, 1958 __is_reference_wrapper<_Ti>::value, 1959 is_bind_expression<_Ti>::value, 1960 0 < is_placeholder<_Ti>::value && 1961 is_placeholder<_Ti>::value <= tuple_size<_TupleUj>::value, 1962 _TupleUj> 1963{ 1964}; 1965 1966template <class _Fp, class _BoundArgs, class _TupleUj> 1967struct _is_valid_bind_return 1968{ 1969 static const bool value = false; 1970}; 1971 1972template <class _Fp, class ..._BoundArgs, class _TupleUj> 1973struct _is_valid_bind_return<_Fp, tuple<_BoundArgs...>, _TupleUj> 1974{ 1975 static const bool value = __invokable<_Fp, 1976 typename __mu_return<_BoundArgs, _TupleUj>::type...>::value; 1977}; 1978 1979template <class _Fp, class ..._BoundArgs, class _TupleUj> 1980struct _is_valid_bind_return<_Fp, const tuple<_BoundArgs...>, _TupleUj> 1981{ 1982 static const bool value = __invokable<_Fp, 1983 typename __mu_return<const _BoundArgs, _TupleUj>::type...>::value; 1984}; 1985 1986template <class _Fp, class _BoundArgs, class _TupleUj, 1987 bool = _is_valid_bind_return<_Fp, _BoundArgs, _TupleUj>::value> 1988struct __bind_return; 1989 1990template <class _Fp, class ..._BoundArgs, class _TupleUj> 1991struct __bind_return<_Fp, tuple<_BoundArgs...>, _TupleUj, true> 1992{ 1993 typedef typename __invoke_of 1994 < 1995 _Fp&, 1996 typename __mu_return 1997 < 1998 _BoundArgs, 1999 _TupleUj 2000 >::type... 2001 >::type type; 2002}; 2003 2004template <class _Fp, class ..._BoundArgs, class _TupleUj> 2005struct __bind_return<_Fp, const tuple<_BoundArgs...>, _TupleUj, true> 2006{ 2007 typedef typename __invoke_of 2008 < 2009 _Fp&, 2010 typename __mu_return 2011 < 2012 const _BoundArgs, 2013 _TupleUj 2014 >::type... 2015 >::type type; 2016}; 2017 2018template <class _Fp, class _BoundArgs, size_t ..._Indx, class _Args> 2019inline _LIBCPP_INLINE_VISIBILITY 2020typename __bind_return<_Fp, _BoundArgs, _Args>::type 2021__apply_functor(_Fp& __f, _BoundArgs& __bound_args, __tuple_indices<_Indx...>, 2022 _Args&& __args) 2023{ 2024 return __invoke(__f, __mu(_VSTD::get<_Indx>(__bound_args), __args)...); 2025} 2026 2027template<class _Fp, class ..._BoundArgs> 2028class __bind 2029 : public __weak_result_type<typename decay<_Fp>::type> 2030{ 2031protected: 2032 typedef typename decay<_Fp>::type _Fd; 2033 typedef tuple<typename decay<_BoundArgs>::type...> _Td; 2034private: 2035 _Fd __f_; 2036 _Td __bound_args_; 2037 2038 typedef typename __make_tuple_indices<sizeof...(_BoundArgs)>::type __indices; 2039public: 2040#ifdef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS 2041 2042 _LIBCPP_INLINE_VISIBILITY 2043 __bind(const __bind& __b) 2044 : __f_(__b.__f_), 2045 __bound_args_(__b.__bound_args_) {} 2046 2047 _LIBCPP_INLINE_VISIBILITY 2048 __bind& operator=(const __bind& __b) 2049 { 2050 __f_ = __b.__f_; 2051 __bound_args_ = __b.__bound_args_; 2052 return *this; 2053 } 2054 2055 _LIBCPP_INLINE_VISIBILITY 2056 __bind(__bind&& __b) 2057 : __f_(_VSTD::move(__b.__f_)), 2058 __bound_args_(_VSTD::move(__b.__bound_args_)) {} 2059 2060 _LIBCPP_INLINE_VISIBILITY 2061 __bind& operator=(__bind&& __b) 2062 { 2063 __f_ = _VSTD::move(__b.__f_); 2064 __bound_args_ = _VSTD::move(__b.__bound_args_); 2065 return *this; 2066 } 2067 2068#endif // _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS 2069 2070 template <class _Gp, class ..._BA, 2071 class = typename enable_if 2072 < 2073 is_constructible<_Fd, _Gp>::value && 2074 !is_same<typename remove_reference<_Gp>::type, 2075 __bind>::value 2076 >::type> 2077 _LIBCPP_INLINE_VISIBILITY 2078 explicit __bind(_Gp&& __f, _BA&& ...__bound_args) 2079 : __f_(_VSTD::forward<_Gp>(__f)), 2080 __bound_args_(_VSTD::forward<_BA>(__bound_args)...) {} 2081 2082 template <class ..._Args> 2083 _LIBCPP_INLINE_VISIBILITY 2084 typename __bind_return<_Fd, _Td, tuple<_Args&&...> >::type 2085 operator()(_Args&& ...__args) 2086 { 2087 return __apply_functor(__f_, __bound_args_, __indices(), 2088 tuple<_Args&&...>(_VSTD::forward<_Args>(__args)...)); 2089 } 2090 2091 template <class ..._Args> 2092 _LIBCPP_INLINE_VISIBILITY 2093 typename __bind_return<const _Fd, const _Td, tuple<_Args&&...> >::type 2094 operator()(_Args&& ...__args) const 2095 { 2096 return __apply_functor(__f_, __bound_args_, __indices(), 2097 tuple<_Args&&...>(_VSTD::forward<_Args>(__args)...)); 2098 } 2099}; 2100 2101template<class _Fp, class ..._BoundArgs> 2102struct __is_bind_expression<__bind<_Fp, _BoundArgs...> > : public true_type {}; 2103 2104template<class _Rp, class _Fp, class ..._BoundArgs> 2105class __bind_r 2106 : public __bind<_Fp, _BoundArgs...> 2107{ 2108 typedef __bind<_Fp, _BoundArgs...> base; 2109 typedef typename base::_Fd _Fd; 2110 typedef typename base::_Td _Td; 2111public: 2112 typedef _Rp result_type; 2113 2114#ifdef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS 2115 2116 _LIBCPP_INLINE_VISIBILITY 2117 __bind_r(const __bind_r& __b) 2118 : base(_VSTD::forward<const base&>(__b)) {} 2119 2120 _LIBCPP_INLINE_VISIBILITY 2121 __bind_r& operator=(const __bind_r& __b) 2122 { 2123 base::operator=(_VSTD::forward<const base&>(__b)); 2124 return *this; 2125 } 2126 2127 _LIBCPP_INLINE_VISIBILITY 2128 __bind_r(__bind_r&& __b) 2129 : base(_VSTD::forward<base>(__b)) {} 2130 2131 _LIBCPP_INLINE_VISIBILITY 2132 __bind_r& operator=(__bind_r&& __b) 2133 { 2134 base::operator=(_VSTD::forward<base>(__b)); 2135 return *this; 2136 } 2137 2138#endif // _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS 2139 2140 template <class _Gp, class ..._BA, 2141 class = typename enable_if 2142 < 2143 is_constructible<_Fd, _Gp>::value && 2144 !is_same<typename remove_reference<_Gp>::type, 2145 __bind_r>::value 2146 >::type> 2147 _LIBCPP_INLINE_VISIBILITY 2148 explicit __bind_r(_Gp&& __f, _BA&& ...__bound_args) 2149 : base(_VSTD::forward<_Gp>(__f), 2150 _VSTD::forward<_BA>(__bound_args)...) {} 2151 2152 template <class ..._Args> 2153 _LIBCPP_INLINE_VISIBILITY 2154 typename enable_if 2155 < 2156 is_convertible<typename __bind_return<_Fd, _Td, tuple<_Args&&...> >::type, 2157 result_type>::value, 2158 result_type 2159 >::type 2160 operator()(_Args&& ...__args) 2161 { 2162 return base::operator()(_VSTD::forward<_Args>(__args)...); 2163 } 2164 2165 template <class ..._Args> 2166 _LIBCPP_INLINE_VISIBILITY 2167 typename enable_if 2168 < 2169 is_convertible<typename __bind_return<const _Fd, const _Td, tuple<_Args&&...> >::type, 2170 result_type>::value, 2171 result_type 2172 >::type 2173 operator()(_Args&& ...__args) const 2174 { 2175 return base::operator()(_VSTD::forward<_Args>(__args)...); 2176 } 2177}; 2178 2179template<class _Rp, class _Fp, class ..._BoundArgs> 2180struct __is_bind_expression<__bind_r<_Rp, _Fp, _BoundArgs...> > : public true_type {}; 2181 2182template<class _Fp, class ..._BoundArgs> 2183inline _LIBCPP_INLINE_VISIBILITY 2184__bind<_Fp, _BoundArgs...> 2185bind(_Fp&& __f, _BoundArgs&&... __bound_args) 2186{ 2187 typedef __bind<_Fp, _BoundArgs...> type; 2188 return type(_VSTD::forward<_Fp>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...); 2189} 2190 2191template<class _Rp, class _Fp, class ..._BoundArgs> 2192inline _LIBCPP_INLINE_VISIBILITY 2193__bind_r<_Rp, _Fp, _BoundArgs...> 2194bind(_Fp&& __f, _BoundArgs&&... __bound_args) 2195{ 2196 typedef __bind_r<_Rp, _Fp, _BoundArgs...> type; 2197 return type(_VSTD::forward<_Fp>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...); 2198} 2199 2200#endif // _LIBCPP_HAS_NO_VARIADICS 2201 2202template <> 2203struct _LIBCPP_TYPE_VIS_ONLY hash<bool> 2204 : public unary_function<bool, size_t> 2205{ 2206 _LIBCPP_INLINE_VISIBILITY 2207 size_t operator()(bool __v) const _NOEXCEPT {return static_cast<size_t>(__v);} 2208}; 2209 2210template <> 2211struct _LIBCPP_TYPE_VIS_ONLY hash<char> 2212 : public unary_function<char, size_t> 2213{ 2214 _LIBCPP_INLINE_VISIBILITY 2215 size_t operator()(char __v) const _NOEXCEPT {return static_cast<size_t>(__v);} 2216}; 2217 2218template <> 2219struct _LIBCPP_TYPE_VIS_ONLY hash<signed char> 2220 : public unary_function<signed char, size_t> 2221{ 2222 _LIBCPP_INLINE_VISIBILITY 2223 size_t operator()(signed char __v) const _NOEXCEPT {return static_cast<size_t>(__v);} 2224}; 2225 2226template <> 2227struct _LIBCPP_TYPE_VIS_ONLY hash<unsigned char> 2228 : public unary_function<unsigned char, size_t> 2229{ 2230 _LIBCPP_INLINE_VISIBILITY 2231 size_t operator()(unsigned char __v) const _NOEXCEPT {return static_cast<size_t>(__v);} 2232}; 2233 2234#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS 2235 2236template <> 2237struct _LIBCPP_TYPE_VIS_ONLY hash<char16_t> 2238 : public unary_function<char16_t, size_t> 2239{ 2240 _LIBCPP_INLINE_VISIBILITY 2241 size_t operator()(char16_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);} 2242}; 2243 2244template <> 2245struct _LIBCPP_TYPE_VIS_ONLY hash<char32_t> 2246 : public unary_function<char32_t, size_t> 2247{ 2248 _LIBCPP_INLINE_VISIBILITY 2249 size_t operator()(char32_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);} 2250}; 2251 2252#endif // _LIBCPP_HAS_NO_UNICODE_CHARS 2253 2254template <> 2255struct _LIBCPP_TYPE_VIS_ONLY hash<wchar_t> 2256 : public unary_function<wchar_t, size_t> 2257{ 2258 _LIBCPP_INLINE_VISIBILITY 2259 size_t operator()(wchar_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);} 2260}; 2261 2262template <> 2263struct _LIBCPP_TYPE_VIS_ONLY hash<short> 2264 : public unary_function<short, size_t> 2265{ 2266 _LIBCPP_INLINE_VISIBILITY 2267 size_t operator()(short __v) const _NOEXCEPT {return static_cast<size_t>(__v);} 2268}; 2269 2270template <> 2271struct _LIBCPP_TYPE_VIS_ONLY hash<unsigned short> 2272 : public unary_function<unsigned short, size_t> 2273{ 2274 _LIBCPP_INLINE_VISIBILITY 2275 size_t operator()(unsigned short __v) const _NOEXCEPT {return static_cast<size_t>(__v);} 2276}; 2277 2278template <> 2279struct _LIBCPP_TYPE_VIS_ONLY hash<int> 2280 : public unary_function<int, size_t> 2281{ 2282 _LIBCPP_INLINE_VISIBILITY 2283 size_t operator()(int __v) const _NOEXCEPT {return static_cast<size_t>(__v);} 2284}; 2285 2286template <> 2287struct _LIBCPP_TYPE_VIS_ONLY hash<unsigned int> 2288 : public unary_function<unsigned int, size_t> 2289{ 2290 _LIBCPP_INLINE_VISIBILITY 2291 size_t operator()(unsigned int __v) const _NOEXCEPT {return static_cast<size_t>(__v);} 2292}; 2293 2294template <> 2295struct _LIBCPP_TYPE_VIS_ONLY hash<long> 2296 : public unary_function<long, size_t> 2297{ 2298 _LIBCPP_INLINE_VISIBILITY 2299 size_t operator()(long __v) const _NOEXCEPT {return static_cast<size_t>(__v);} 2300}; 2301 2302template <> 2303struct _LIBCPP_TYPE_VIS_ONLY hash<unsigned long> 2304 : public unary_function<unsigned long, size_t> 2305{ 2306 _LIBCPP_INLINE_VISIBILITY 2307 size_t operator()(unsigned long __v) const _NOEXCEPT {return static_cast<size_t>(__v);} 2308}; 2309 2310template <> 2311struct _LIBCPP_TYPE_VIS_ONLY hash<long long> 2312 : public __scalar_hash<long long> 2313{ 2314}; 2315 2316template <> 2317struct _LIBCPP_TYPE_VIS_ONLY hash<unsigned long long> 2318 : public __scalar_hash<unsigned long long> 2319{ 2320}; 2321 2322template <> 2323struct _LIBCPP_TYPE_VIS_ONLY hash<float> 2324 : public __scalar_hash<float> 2325{ 2326 _LIBCPP_INLINE_VISIBILITY 2327 size_t operator()(float __v) const _NOEXCEPT 2328 { 2329 // -0.0 and 0.0 should return same hash 2330 if (__v == 0) 2331 return 0; 2332 return __scalar_hash<float>::operator()(__v); 2333 } 2334}; 2335 2336template <> 2337struct _LIBCPP_TYPE_VIS_ONLY hash<double> 2338 : public __scalar_hash<double> 2339{ 2340 _LIBCPP_INLINE_VISIBILITY 2341 size_t operator()(double __v) const _NOEXCEPT 2342 { 2343 // -0.0 and 0.0 should return same hash 2344 if (__v == 0) 2345 return 0; 2346 return __scalar_hash<double>::operator()(__v); 2347 } 2348}; 2349 2350template <> 2351struct _LIBCPP_TYPE_VIS_ONLY hash<long double> 2352 : public __scalar_hash<long double> 2353{ 2354 _LIBCPP_INLINE_VISIBILITY 2355 size_t operator()(long double __v) const _NOEXCEPT 2356 { 2357 // -0.0 and 0.0 should return same hash 2358 if (__v == 0) 2359 return 0; 2360#if defined(__i386__) 2361 // Zero out padding bits 2362 union 2363 { 2364 long double __t; 2365 struct 2366 { 2367 size_t __a; 2368 size_t __b; 2369 size_t __c; 2370 size_t __d; 2371 }; 2372 } __u; 2373 __u.__a = 0; 2374 __u.__b = 0; 2375 __u.__c = 0; 2376 __u.__d = 0; 2377 __u.__t = __v; 2378 return __u.__a ^ __u.__b ^ __u.__c ^ __u.__d; 2379#elif defined(__x86_64__) 2380 // Zero out padding bits 2381 union 2382 { 2383 long double __t; 2384 struct 2385 { 2386 size_t __a; 2387 size_t __b; 2388 }; 2389 } __u; 2390 __u.__a = 0; 2391 __u.__b = 0; 2392 __u.__t = __v; 2393 return __u.__a ^ __u.__b; 2394#else 2395 return __scalar_hash<long double>::operator()(__v); 2396#endif 2397 } 2398}; 2399 2400#if _LIBCPP_STD_VER > 11 2401template <class _Tp> 2402struct _LIBCPP_TYPE_VIS_ONLY hash 2403 : public unary_function<_Tp, size_t> 2404{ 2405 static_assert(is_enum<_Tp>::value, "This hash only works for enumeration types"); 2406 2407 _LIBCPP_INLINE_VISIBILITY 2408 size_t operator()(_Tp __v) const _NOEXCEPT 2409 { 2410 typedef typename underlying_type<_Tp>::type type; 2411 return hash<type>{}(static_cast<type>(__v)); 2412 } 2413}; 2414#endif 2415 2416// struct hash<T*> in <memory> 2417 2418_LIBCPP_END_NAMESPACE_STD 2419 2420#endif // _LIBCPP_FUNCTIONAL 2421