Index: stable/10/contrib/libc++/include/__functional_03 =================================================================== --- stable/10/contrib/libc++/include/__functional_03 (revision 308142) +++ stable/10/contrib/libc++/include/__functional_03 (revision 308143) @@ -1,2135 +1,2139 @@ // -*- C++ -*- //===----------------------------------------------------------------------===// // // The LLVM Compiler Infrastructure // // This file is dual licensed under the MIT and the University of Illinois Open // Source Licenses. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// #ifndef _LIBCPP_FUNCTIONAL_03 #define _LIBCPP_FUNCTIONAL_03 // manual variadic expansion for #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #pragma GCC system_header #endif template class __mem_fn : public __weak_result_type<_Tp> { public: // types typedef _Tp type; private: type __f_; public: _LIBCPP_INLINE_VISIBILITY __mem_fn(type __f) : __f_(__f) {} // invoke typename __invoke_return::type operator() () const { return __invoke(__f_); } template typename __invoke_return0::type operator() (_A0& __a0) const { return __invoke(__f_, __a0); } template typename __invoke_return1::type operator() (_A0& __a0, _A1& __a1) const { return __invoke(__f_, __a0, __a1); } template typename __invoke_return2::type operator() (_A0& __a0, _A1& __a1, _A2& __a2) const { return __invoke(__f_, __a0, __a1, __a2); } }; template inline _LIBCPP_INLINE_VISIBILITY __mem_fn<_Rp _Tp::*> mem_fn(_Rp _Tp::* __pm) { return __mem_fn<_Rp _Tp::*>(__pm); } template inline _LIBCPP_INLINE_VISIBILITY __mem_fn<_Rp (_Tp::*)()> mem_fn(_Rp (_Tp::* __pm)()) { return __mem_fn<_Rp (_Tp::*)()>(__pm); } template inline _LIBCPP_INLINE_VISIBILITY __mem_fn<_Rp (_Tp::*)(_A0)> mem_fn(_Rp (_Tp::* __pm)(_A0)) { return __mem_fn<_Rp (_Tp::*)(_A0)>(__pm); } template inline _LIBCPP_INLINE_VISIBILITY __mem_fn<_Rp (_Tp::*)(_A0, _A1)> mem_fn(_Rp (_Tp::* __pm)(_A0, _A1)) { return __mem_fn<_Rp (_Tp::*)(_A0, _A1)>(__pm); } template inline _LIBCPP_INLINE_VISIBILITY __mem_fn<_Rp (_Tp::*)(_A0, _A1, _A2)> mem_fn(_Rp (_Tp::* __pm)(_A0, _A1, _A2)) { return __mem_fn<_Rp (_Tp::*)(_A0, _A1, _A2)>(__pm); } template inline _LIBCPP_INLINE_VISIBILITY __mem_fn<_Rp (_Tp::*)() const> mem_fn(_Rp (_Tp::* __pm)() const) { return __mem_fn<_Rp (_Tp::*)() const>(__pm); } template inline _LIBCPP_INLINE_VISIBILITY __mem_fn<_Rp (_Tp::*)(_A0) const> mem_fn(_Rp (_Tp::* __pm)(_A0) const) { return __mem_fn<_Rp (_Tp::*)(_A0) const>(__pm); } template inline _LIBCPP_INLINE_VISIBILITY __mem_fn<_Rp (_Tp::*)(_A0, _A1) const> mem_fn(_Rp (_Tp::* __pm)(_A0, _A1) const) { return __mem_fn<_Rp (_Tp::*)(_A0, _A1) const>(__pm); } template inline _LIBCPP_INLINE_VISIBILITY __mem_fn<_Rp (_Tp::*)(_A0, _A1, _A2) const> mem_fn(_Rp (_Tp::* __pm)(_A0, _A1, _A2) const) { return __mem_fn<_Rp (_Tp::*)(_A0, _A1, _A2) const>(__pm); } template inline _LIBCPP_INLINE_VISIBILITY __mem_fn<_Rp (_Tp::*)() volatile> mem_fn(_Rp (_Tp::* __pm)() volatile) { return __mem_fn<_Rp (_Tp::*)() volatile>(__pm); } template inline _LIBCPP_INLINE_VISIBILITY __mem_fn<_Rp (_Tp::*)(_A0) volatile> mem_fn(_Rp (_Tp::* __pm)(_A0) volatile) { return __mem_fn<_Rp (_Tp::*)(_A0) volatile>(__pm); } template inline _LIBCPP_INLINE_VISIBILITY __mem_fn<_Rp (_Tp::*)(_A0, _A1) volatile> mem_fn(_Rp (_Tp::* __pm)(_A0, _A1) volatile) { return __mem_fn<_Rp (_Tp::*)(_A0, _A1) volatile>(__pm); } template inline _LIBCPP_INLINE_VISIBILITY __mem_fn<_Rp (_Tp::*)(_A0, _A1, _A2) volatile> mem_fn(_Rp (_Tp::* __pm)(_A0, _A1, _A2) volatile) { return __mem_fn<_Rp (_Tp::*)(_A0, _A1, _A2) volatile>(__pm); } template inline _LIBCPP_INLINE_VISIBILITY __mem_fn<_Rp (_Tp::*)() const volatile> mem_fn(_Rp (_Tp::* __pm)() const volatile) { return __mem_fn<_Rp (_Tp::*)() const volatile>(__pm); } template inline _LIBCPP_INLINE_VISIBILITY __mem_fn<_Rp (_Tp::*)(_A0) const volatile> mem_fn(_Rp (_Tp::* __pm)(_A0) const volatile) { return __mem_fn<_Rp (_Tp::*)(_A0) const volatile>(__pm); } template inline _LIBCPP_INLINE_VISIBILITY __mem_fn<_Rp (_Tp::*)(_A0, _A1) const volatile> mem_fn(_Rp (_Tp::* __pm)(_A0, _A1) const volatile) { return __mem_fn<_Rp (_Tp::*)(_A0, _A1) const volatile>(__pm); } template inline _LIBCPP_INLINE_VISIBILITY __mem_fn<_Rp (_Tp::*)(_A0, _A1, _A2) const volatile> mem_fn(_Rp (_Tp::* __pm)(_A0, _A1, _A2) const volatile) { return __mem_fn<_Rp (_Tp::*)(_A0, _A1, _A2) const volatile>(__pm); } // bad_function_call class _LIBCPP_EXCEPTION_ABI bad_function_call : public exception { }; template class _LIBCPP_TYPE_VIS_ONLY function; // undefined namespace __function { template struct __maybe_derive_from_unary_function { }; template struct __maybe_derive_from_unary_function<_Rp(_A1)> : public unary_function<_A1, _Rp> { }; template struct __maybe_derive_from_binary_function { }; template struct __maybe_derive_from_binary_function<_Rp(_A1, _A2)> : public binary_function<_A1, _A2, _Rp> { }; template class __base; template class __base<_Rp()> { __base(const __base&); __base& operator=(const __base&); public: __base() {} virtual ~__base() {} virtual __base* __clone() const = 0; virtual void __clone(__base*) const = 0; virtual void destroy() = 0; virtual void destroy_deallocate() = 0; virtual _Rp operator()() = 0; #ifndef _LIBCPP_NO_RTTI virtual const void* target(const type_info&) const = 0; virtual const std::type_info& target_type() const = 0; #endif // _LIBCPP_NO_RTTI }; template class __base<_Rp(_A0)> { __base(const __base&); __base& operator=(const __base&); public: __base() {} virtual ~__base() {} virtual __base* __clone() const = 0; virtual void __clone(__base*) const = 0; virtual void destroy() = 0; virtual void destroy_deallocate() = 0; virtual _Rp operator()(_A0) = 0; #ifndef _LIBCPP_NO_RTTI virtual const void* target(const type_info&) const = 0; virtual const std::type_info& target_type() const = 0; #endif // _LIBCPP_NO_RTTI }; template class __base<_Rp(_A0, _A1)> { __base(const __base&); __base& operator=(const __base&); public: __base() {} virtual ~__base() {} virtual __base* __clone() const = 0; virtual void __clone(__base*) const = 0; virtual void destroy() = 0; virtual void destroy_deallocate() = 0; virtual _Rp operator()(_A0, _A1) = 0; #ifndef _LIBCPP_NO_RTTI virtual const void* target(const type_info&) const = 0; virtual const std::type_info& target_type() const = 0; #endif // _LIBCPP_NO_RTTI }; template class __base<_Rp(_A0, _A1, _A2)> { __base(const __base&); __base& operator=(const __base&); public: __base() {} virtual ~__base() {} virtual __base* __clone() const = 0; virtual void __clone(__base*) const = 0; virtual void destroy() = 0; virtual void destroy_deallocate() = 0; virtual _Rp operator()(_A0, _A1, _A2) = 0; #ifndef _LIBCPP_NO_RTTI virtual const void* target(const type_info&) const = 0; virtual const std::type_info& target_type() const = 0; #endif // _LIBCPP_NO_RTTI }; template class __func; template class __func<_Fp, _Alloc, _Rp()> : public __base<_Rp()> { __compressed_pair<_Fp, _Alloc> __f_; public: explicit __func(_Fp __f) : __f_(_VSTD::move(__f)) {} explicit __func(_Fp __f, _Alloc __a) : __f_(_VSTD::move(__f), _VSTD::move(__a)) {} virtual __base<_Rp()>* __clone() const; virtual void __clone(__base<_Rp()>*) const; virtual void destroy(); virtual void destroy_deallocate(); virtual _Rp operator()(); #ifndef _LIBCPP_NO_RTTI virtual const void* target(const type_info&) const; virtual const std::type_info& target_type() const; #endif // _LIBCPP_NO_RTTI }; template __base<_Rp()>* __func<_Fp, _Alloc, _Rp()>::__clone() const { typedef typename _Alloc::template rebind<__func>::other _Ap; _Ap __a(__f_.second()); typedef __allocator_destructor<_Ap> _Dp; unique_ptr<__func, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); ::new (__hold.get()) __func(__f_.first(), _Alloc(__a)); return __hold.release(); } template void __func<_Fp, _Alloc, _Rp()>::__clone(__base<_Rp()>* __p) const { ::new (__p) __func(__f_.first(), __f_.second()); } template void __func<_Fp, _Alloc, _Rp()>::destroy() { __f_.~__compressed_pair<_Fp, _Alloc>(); } template void __func<_Fp, _Alloc, _Rp()>::destroy_deallocate() { typedef typename _Alloc::template rebind<__func>::other _Ap; _Ap __a(__f_.second()); __f_.~__compressed_pair<_Fp, _Alloc>(); __a.deallocate(this, 1); } template _Rp __func<_Fp, _Alloc, _Rp()>::operator()() { - return __invoke(__f_.first()); + typedef __invoke_void_return_wrapper<_Rp> _Invoker; + return _Invoker::__call(__f_.first()); } #ifndef _LIBCPP_NO_RTTI template const void* __func<_Fp, _Alloc, _Rp()>::target(const type_info& __ti) const { if (__ti == typeid(_Fp)) return &__f_.first(); return (const void*)0; } template const std::type_info& __func<_Fp, _Alloc, _Rp()>::target_type() const { return typeid(_Fp); } #endif // _LIBCPP_NO_RTTI template class __func<_Fp, _Alloc, _Rp(_A0)> : public __base<_Rp(_A0)> { __compressed_pair<_Fp, _Alloc> __f_; public: _LIBCPP_INLINE_VISIBILITY explicit __func(_Fp __f) : __f_(_VSTD::move(__f)) {} _LIBCPP_INLINE_VISIBILITY explicit __func(_Fp __f, _Alloc __a) : __f_(_VSTD::move(__f), _VSTD::move(__a)) {} virtual __base<_Rp(_A0)>* __clone() const; virtual void __clone(__base<_Rp(_A0)>*) const; virtual void destroy(); virtual void destroy_deallocate(); virtual _Rp operator()(_A0); #ifndef _LIBCPP_NO_RTTI virtual const void* target(const type_info&) const; virtual const std::type_info& target_type() const; #endif // _LIBCPP_NO_RTTI }; template __base<_Rp(_A0)>* __func<_Fp, _Alloc, _Rp(_A0)>::__clone() const { typedef typename _Alloc::template rebind<__func>::other _Ap; _Ap __a(__f_.second()); typedef __allocator_destructor<_Ap> _Dp; unique_ptr<__func, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); ::new (__hold.get()) __func(__f_.first(), _Alloc(__a)); return __hold.release(); } template void __func<_Fp, _Alloc, _Rp(_A0)>::__clone(__base<_Rp(_A0)>* __p) const { ::new (__p) __func(__f_.first(), __f_.second()); } template void __func<_Fp, _Alloc, _Rp(_A0)>::destroy() { __f_.~__compressed_pair<_Fp, _Alloc>(); } template void __func<_Fp, _Alloc, _Rp(_A0)>::destroy_deallocate() { typedef typename _Alloc::template rebind<__func>::other _Ap; _Ap __a(__f_.second()); __f_.~__compressed_pair<_Fp, _Alloc>(); __a.deallocate(this, 1); } template _Rp __func<_Fp, _Alloc, _Rp(_A0)>::operator()(_A0 __a0) { - return __invoke(__f_.first(), __a0); + typedef __invoke_void_return_wrapper<_Rp> _Invoker; + return _Invoker::__call(__f_.first(), __a0); } #ifndef _LIBCPP_NO_RTTI template const void* __func<_Fp, _Alloc, _Rp(_A0)>::target(const type_info& __ti) const { if (__ti == typeid(_Fp)) return &__f_.first(); return (const void*)0; } template const std::type_info& __func<_Fp, _Alloc, _Rp(_A0)>::target_type() const { return typeid(_Fp); } #endif // _LIBCPP_NO_RTTI template class __func<_Fp, _Alloc, _Rp(_A0, _A1)> : public __base<_Rp(_A0, _A1)> { __compressed_pair<_Fp, _Alloc> __f_; public: _LIBCPP_INLINE_VISIBILITY explicit __func(_Fp __f) : __f_(_VSTD::move(__f)) {} _LIBCPP_INLINE_VISIBILITY explicit __func(_Fp __f, _Alloc __a) : __f_(_VSTD::move(__f), _VSTD::move(__a)) {} virtual __base<_Rp(_A0, _A1)>* __clone() const; virtual void __clone(__base<_Rp(_A0, _A1)>*) const; virtual void destroy(); virtual void destroy_deallocate(); virtual _Rp operator()(_A0, _A1); #ifndef _LIBCPP_NO_RTTI virtual const void* target(const type_info&) const; virtual const std::type_info& target_type() const; #endif // _LIBCPP_NO_RTTI }; template __base<_Rp(_A0, _A1)>* __func<_Fp, _Alloc, _Rp(_A0, _A1)>::__clone() const { typedef typename _Alloc::template rebind<__func>::other _Ap; _Ap __a(__f_.second()); typedef __allocator_destructor<_Ap> _Dp; unique_ptr<__func, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); ::new (__hold.get()) __func(__f_.first(), _Alloc(__a)); return __hold.release(); } template void __func<_Fp, _Alloc, _Rp(_A0, _A1)>::__clone(__base<_Rp(_A0, _A1)>* __p) const { ::new (__p) __func(__f_.first(), __f_.second()); } template void __func<_Fp, _Alloc, _Rp(_A0, _A1)>::destroy() { __f_.~__compressed_pair<_Fp, _Alloc>(); } template void __func<_Fp, _Alloc, _Rp(_A0, _A1)>::destroy_deallocate() { typedef typename _Alloc::template rebind<__func>::other _Ap; _Ap __a(__f_.second()); __f_.~__compressed_pair<_Fp, _Alloc>(); __a.deallocate(this, 1); } template _Rp __func<_Fp, _Alloc, _Rp(_A0, _A1)>::operator()(_A0 __a0, _A1 __a1) { - return __invoke(__f_.first(), __a0, __a1); + typedef __invoke_void_return_wrapper<_Rp> _Invoker; + return _Invoker::__call(__f_.first(), __a0, __a1); } #ifndef _LIBCPP_NO_RTTI template const void* __func<_Fp, _Alloc, _Rp(_A0, _A1)>::target(const type_info& __ti) const { if (__ti == typeid(_Fp)) return &__f_.first(); return (const void*)0; } template const std::type_info& __func<_Fp, _Alloc, _Rp(_A0, _A1)>::target_type() const { return typeid(_Fp); } #endif // _LIBCPP_NO_RTTI template class __func<_Fp, _Alloc, _Rp(_A0, _A1, _A2)> : public __base<_Rp(_A0, _A1, _A2)> { __compressed_pair<_Fp, _Alloc> __f_; public: _LIBCPP_INLINE_VISIBILITY explicit __func(_Fp __f) : __f_(_VSTD::move(__f)) {} _LIBCPP_INLINE_VISIBILITY explicit __func(_Fp __f, _Alloc __a) : __f_(_VSTD::move(__f), _VSTD::move(__a)) {} virtual __base<_Rp(_A0, _A1, _A2)>* __clone() const; virtual void __clone(__base<_Rp(_A0, _A1, _A2)>*) const; virtual void destroy(); virtual void destroy_deallocate(); virtual _Rp operator()(_A0, _A1, _A2); #ifndef _LIBCPP_NO_RTTI virtual const void* target(const type_info&) const; virtual const std::type_info& target_type() const; #endif // _LIBCPP_NO_RTTI }; template __base<_Rp(_A0, _A1, _A2)>* __func<_Fp, _Alloc, _Rp(_A0, _A1, _A2)>::__clone() const { typedef typename _Alloc::template rebind<__func>::other _Ap; _Ap __a(__f_.second()); typedef __allocator_destructor<_Ap> _Dp; unique_ptr<__func, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); ::new (__hold.get()) __func(__f_.first(), _Alloc(__a)); return __hold.release(); } template void __func<_Fp, _Alloc, _Rp(_A0, _A1, _A2)>::__clone(__base<_Rp(_A0, _A1, _A2)>* __p) const { ::new (__p) __func(__f_.first(), __f_.second()); } template void __func<_Fp, _Alloc, _Rp(_A0, _A1, _A2)>::destroy() { __f_.~__compressed_pair<_Fp, _Alloc>(); } template void __func<_Fp, _Alloc, _Rp(_A0, _A1, _A2)>::destroy_deallocate() { typedef typename _Alloc::template rebind<__func>::other _Ap; _Ap __a(__f_.second()); __f_.~__compressed_pair<_Fp, _Alloc>(); __a.deallocate(this, 1); } template _Rp __func<_Fp, _Alloc, _Rp(_A0, _A1, _A2)>::operator()(_A0 __a0, _A1 __a1, _A2 __a2) { - return __invoke(__f_.first(), __a0, __a1, __a2); + typedef __invoke_void_return_wrapper<_Rp> _Invoker; + return _Invoker::__call(__f_.first(), __a0, __a1, __a2); } #ifndef _LIBCPP_NO_RTTI template const void* __func<_Fp, _Alloc, _Rp(_A0, _A1, _A2)>::target(const type_info& __ti) const { if (__ti == typeid(_Fp)) return &__f_.first(); return (const void*)0; } template const std::type_info& __func<_Fp, _Alloc, _Rp(_A0, _A1, _A2)>::target_type() const { return typeid(_Fp); } #endif // _LIBCPP_NO_RTTI } // __function template class _LIBCPP_TYPE_VIS_ONLY function<_Rp()> { typedef __function::__base<_Rp()> __base; aligned_storage<3*sizeof(void*)>::type __buf_; __base* __f_; template _LIBCPP_INLINE_VISIBILITY static bool __not_null(const _Fp&) {return true;} template _LIBCPP_INLINE_VISIBILITY static bool __not_null(_R2 (*__p)()) {return __p;} template _LIBCPP_INLINE_VISIBILITY static bool __not_null(const function<_R2()>& __p) {return __p;} public: typedef _Rp result_type; // 20.7.16.2.1, construct/copy/destroy: _LIBCPP_INLINE_VISIBILITY explicit function() : __f_(0) {} _LIBCPP_INLINE_VISIBILITY function(nullptr_t) : __f_(0) {} function(const function&); template function(_Fp, typename enable_if::value>::type* = 0); template _LIBCPP_INLINE_VISIBILITY function(allocator_arg_t, const _Alloc&) : __f_(0) {} template _LIBCPP_INLINE_VISIBILITY function(allocator_arg_t, const _Alloc&, nullptr_t) : __f_(0) {} template function(allocator_arg_t, const _Alloc&, const function&); template function(allocator_arg_t, const _Alloc& __a, _Fp __f, typename enable_if::value>::type* = 0); function& operator=(const function&); function& operator=(nullptr_t); template typename enable_if < !is_integral<_Fp>::value, function& >::type operator=(_Fp); ~function(); // 20.7.16.2.2, function modifiers: void swap(function&); template _LIBCPP_INLINE_VISIBILITY void assign(_Fp __f, const _Alloc& __a) {function(allocator_arg, __a, __f).swap(*this);} // 20.7.16.2.3, function capacity: _LIBCPP_INLINE_VISIBILITY operator bool() const {return __f_;} private: // deleted overloads close possible hole in the type system template bool operator==(const function<_R2()>&) const;// = delete; template bool operator!=(const function<_R2()>&) const;// = delete; public: // 20.7.16.2.4, function invocation: _Rp operator()() const; #ifndef _LIBCPP_NO_RTTI // 20.7.16.2.5, function target access: const std::type_info& target_type() const; template _Tp* target(); template const _Tp* target() const; #endif // _LIBCPP_NO_RTTI }; template function<_Rp()>::function(const function& __f) { if (__f.__f_ == 0) __f_ = 0; else if (__f.__f_ == (const __base*)&__f.__buf_) { __f_ = (__base*)&__buf_; __f.__f_->__clone(__f_); } else __f_ = __f.__f_->__clone(); } template template function<_Rp()>::function(allocator_arg_t, const _Alloc&, const function& __f) { if (__f.__f_ == 0) __f_ = 0; else if (__f.__f_ == (const __base*)&__f.__buf_) { __f_ = (__base*)&__buf_; __f.__f_->__clone(__f_); } else __f_ = __f.__f_->__clone(); } template template function<_Rp()>::function(_Fp __f, typename enable_if::value>::type*) : __f_(0) { if (__not_null(__f)) { typedef __function::__func<_Fp, allocator<_Fp>, _Rp()> _FF; if (sizeof(_FF) <= sizeof(__buf_)) { __f_ = (__base*)&__buf_; ::new (__f_) _FF(__f); } else { typedef allocator<_FF> _Ap; _Ap __a; typedef __allocator_destructor<_Ap> _Dp; unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); ::new (__hold.get()) _FF(__f, allocator<_Fp>(__a)); __f_ = __hold.release(); } } } template template function<_Rp()>::function(allocator_arg_t, const _Alloc& __a0, _Fp __f, typename enable_if::value>::type*) : __f_(0) { typedef allocator_traits<_Alloc> __alloc_traits; if (__not_null(__f)) { typedef __function::__func<_Fp, _Alloc, _Rp()> _FF; if (sizeof(_FF) <= sizeof(__buf_)) { __f_ = (__base*)&__buf_; ::new (__f_) _FF(__f); } else { typedef typename __alloc_traits::template #ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES rebind_alloc<_FF> #else rebind_alloc<_FF>::other #endif _Ap; _Ap __a(__a0); typedef __allocator_destructor<_Ap> _Dp; unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); ::new (__hold.get()) _FF(__f, _Alloc(__a)); __f_ = __hold.release(); } } } template function<_Rp()>& function<_Rp()>::operator=(const function& __f) { function(__f).swap(*this); return *this; } template function<_Rp()>& function<_Rp()>::operator=(nullptr_t) { if (__f_ == (__base*)&__buf_) __f_->destroy(); else if (__f_) __f_->destroy_deallocate(); __f_ = 0; } template template typename enable_if < !is_integral<_Fp>::value, function<_Rp()>& >::type function<_Rp()>::operator=(_Fp __f) { function(_VSTD::move(__f)).swap(*this); return *this; } template function<_Rp()>::~function() { if (__f_ == (__base*)&__buf_) __f_->destroy(); else if (__f_) __f_->destroy_deallocate(); } template void function<_Rp()>::swap(function& __f) { if (__f_ == (__base*)&__buf_ && __f.__f_ == (__base*)&__f.__buf_) { typename aligned_storage::type __tempbuf; __base* __t = (__base*)&__tempbuf; __f_->__clone(__t); __f_->destroy(); __f_ = 0; __f.__f_->__clone((__base*)&__buf_); __f.__f_->destroy(); __f.__f_ = 0; __f_ = (__base*)&__buf_; __t->__clone((__base*)&__f.__buf_); __t->destroy(); __f.__f_ = (__base*)&__f.__buf_; } else if (__f_ == (__base*)&__buf_) { __f_->__clone((__base*)&__f.__buf_); __f_->destroy(); __f_ = __f.__f_; __f.__f_ = (__base*)&__f.__buf_; } else if (__f.__f_ == (__base*)&__f.__buf_) { __f.__f_->__clone((__base*)&__buf_); __f.__f_->destroy(); __f.__f_ = __f_; __f_ = (__base*)&__buf_; } else _VSTD::swap(__f_, __f.__f_); } template _Rp function<_Rp()>::operator()() const { #ifndef _LIBCPP_NO_EXCEPTIONS if (__f_ == 0) throw bad_function_call(); #endif // _LIBCPP_NO_EXCEPTIONS return (*__f_)(); } #ifndef _LIBCPP_NO_RTTI template const std::type_info& function<_Rp()>::target_type() const { if (__f_ == 0) return typeid(void); return __f_->target_type(); } template template _Tp* function<_Rp()>::target() { if (__f_ == 0) return (_Tp*)0; return (_Tp*)__f_->target(typeid(_Tp)); } template template const _Tp* function<_Rp()>::target() const { if (__f_ == 0) return (const _Tp*)0; return (const _Tp*)__f_->target(typeid(_Tp)); } #endif // _LIBCPP_NO_RTTI template class _LIBCPP_TYPE_VIS_ONLY function<_Rp(_A0)> : public unary_function<_A0, _Rp> { typedef __function::__base<_Rp(_A0)> __base; aligned_storage<3*sizeof(void*)>::type __buf_; __base* __f_; template _LIBCPP_INLINE_VISIBILITY static bool __not_null(const _Fp&) {return true;} template _LIBCPP_INLINE_VISIBILITY static bool __not_null(_R2 (*__p)(_B0)) {return __p;} template _LIBCPP_INLINE_VISIBILITY static bool __not_null(_R2 (_Cp::*__p)()) {return __p;} template _LIBCPP_INLINE_VISIBILITY static bool __not_null(_R2 (_Cp::*__p)() const) {return __p;} template _LIBCPP_INLINE_VISIBILITY static bool __not_null(_R2 (_Cp::*__p)() volatile) {return __p;} template _LIBCPP_INLINE_VISIBILITY static bool __not_null(_R2 (_Cp::*__p)() const volatile) {return __p;} template _LIBCPP_INLINE_VISIBILITY static bool __not_null(const function<_R2(_B0)>& __p) {return __p;} public: typedef _Rp result_type; // 20.7.16.2.1, construct/copy/destroy: _LIBCPP_INLINE_VISIBILITY explicit function() : __f_(0) {} _LIBCPP_INLINE_VISIBILITY function(nullptr_t) : __f_(0) {} function(const function&); template function(_Fp, typename enable_if::value>::type* = 0); template _LIBCPP_INLINE_VISIBILITY function(allocator_arg_t, const _Alloc&) : __f_(0) {} template _LIBCPP_INLINE_VISIBILITY function(allocator_arg_t, const _Alloc&, nullptr_t) : __f_(0) {} template function(allocator_arg_t, const _Alloc&, const function&); template function(allocator_arg_t, const _Alloc& __a, _Fp __f, typename enable_if::value>::type* = 0); function& operator=(const function&); function& operator=(nullptr_t); template typename enable_if < !is_integral<_Fp>::value, function& >::type operator=(_Fp); ~function(); // 20.7.16.2.2, function modifiers: void swap(function&); template _LIBCPP_INLINE_VISIBILITY void assign(_Fp __f, const _Alloc& __a) {function(allocator_arg, __a, __f).swap(*this);} // 20.7.16.2.3, function capacity: _LIBCPP_INLINE_VISIBILITY operator bool() const {return __f_;} private: // deleted overloads close possible hole in the type system template bool operator==(const function<_R2(_B0)>&) const;// = delete; template bool operator!=(const function<_R2(_B0)>&) const;// = delete; public: // 20.7.16.2.4, function invocation: _Rp operator()(_A0) const; #ifndef _LIBCPP_NO_RTTI // 20.7.16.2.5, function target access: const std::type_info& target_type() const; template _Tp* target(); template const _Tp* target() const; #endif // _LIBCPP_NO_RTTI }; template function<_Rp(_A0)>::function(const function& __f) { if (__f.__f_ == 0) __f_ = 0; else if (__f.__f_ == (const __base*)&__f.__buf_) { __f_ = (__base*)&__buf_; __f.__f_->__clone(__f_); } else __f_ = __f.__f_->__clone(); } template template function<_Rp(_A0)>::function(allocator_arg_t, const _Alloc&, const function& __f) { if (__f.__f_ == 0) __f_ = 0; else if (__f.__f_ == (const __base*)&__f.__buf_) { __f_ = (__base*)&__buf_; __f.__f_->__clone(__f_); } else __f_ = __f.__f_->__clone(); } template template function<_Rp(_A0)>::function(_Fp __f, typename enable_if::value>::type*) : __f_(0) { if (__not_null(__f)) { typedef __function::__func<_Fp, allocator<_Fp>, _Rp(_A0)> _FF; if (sizeof(_FF) <= sizeof(__buf_)) { __f_ = (__base*)&__buf_; ::new (__f_) _FF(__f); } else { typedef allocator<_FF> _Ap; _Ap __a; typedef __allocator_destructor<_Ap> _Dp; unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); ::new (__hold.get()) _FF(__f, allocator<_Fp>(__a)); __f_ = __hold.release(); } } } template template function<_Rp(_A0)>::function(allocator_arg_t, const _Alloc& __a0, _Fp __f, typename enable_if::value>::type*) : __f_(0) { typedef allocator_traits<_Alloc> __alloc_traits; if (__not_null(__f)) { typedef __function::__func<_Fp, _Alloc, _Rp(_A0)> _FF; if (sizeof(_FF) <= sizeof(__buf_)) { __f_ = (__base*)&__buf_; ::new (__f_) _FF(__f); } else { typedef typename __alloc_traits::template #ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES rebind_alloc<_FF> #else rebind_alloc<_FF>::other #endif _Ap; _Ap __a(__a0); typedef __allocator_destructor<_Ap> _Dp; unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); ::new (__hold.get()) _FF(__f, _Alloc(__a)); __f_ = __hold.release(); } } } template function<_Rp(_A0)>& function<_Rp(_A0)>::operator=(const function& __f) { function(__f).swap(*this); return *this; } template function<_Rp(_A0)>& function<_Rp(_A0)>::operator=(nullptr_t) { if (__f_ == (__base*)&__buf_) __f_->destroy(); else if (__f_) __f_->destroy_deallocate(); __f_ = 0; } template template typename enable_if < !is_integral<_Fp>::value, function<_Rp(_A0)>& >::type function<_Rp(_A0)>::operator=(_Fp __f) { function(_VSTD::move(__f)).swap(*this); return *this; } template function<_Rp(_A0)>::~function() { if (__f_ == (__base*)&__buf_) __f_->destroy(); else if (__f_) __f_->destroy_deallocate(); } template void function<_Rp(_A0)>::swap(function& __f) { if (__f_ == (__base*)&__buf_ && __f.__f_ == (__base*)&__f.__buf_) { typename aligned_storage::type __tempbuf; __base* __t = (__base*)&__tempbuf; __f_->__clone(__t); __f_->destroy(); __f_ = 0; __f.__f_->__clone((__base*)&__buf_); __f.__f_->destroy(); __f.__f_ = 0; __f_ = (__base*)&__buf_; __t->__clone((__base*)&__f.__buf_); __t->destroy(); __f.__f_ = (__base*)&__f.__buf_; } else if (__f_ == (__base*)&__buf_) { __f_->__clone((__base*)&__f.__buf_); __f_->destroy(); __f_ = __f.__f_; __f.__f_ = (__base*)&__f.__buf_; } else if (__f.__f_ == (__base*)&__f.__buf_) { __f.__f_->__clone((__base*)&__buf_); __f.__f_->destroy(); __f.__f_ = __f_; __f_ = (__base*)&__buf_; } else _VSTD::swap(__f_, __f.__f_); } template _Rp function<_Rp(_A0)>::operator()(_A0 __a0) const { #ifndef _LIBCPP_NO_EXCEPTIONS if (__f_ == 0) throw bad_function_call(); #endif // _LIBCPP_NO_EXCEPTIONS return (*__f_)(__a0); } #ifndef _LIBCPP_NO_RTTI template const std::type_info& function<_Rp(_A0)>::target_type() const { if (__f_ == 0) return typeid(void); return __f_->target_type(); } template template _Tp* function<_Rp(_A0)>::target() { if (__f_ == 0) return (_Tp*)0; return (_Tp*)__f_->target(typeid(_Tp)); } template template const _Tp* function<_Rp(_A0)>::target() const { if (__f_ == 0) return (const _Tp*)0; return (const _Tp*)__f_->target(typeid(_Tp)); } #endif // _LIBCPP_NO_RTTI template class _LIBCPP_TYPE_VIS_ONLY function<_Rp(_A0, _A1)> : public binary_function<_A0, _A1, _Rp> { typedef __function::__base<_Rp(_A0, _A1)> __base; aligned_storage<3*sizeof(void*)>::type __buf_; __base* __f_; template _LIBCPP_INLINE_VISIBILITY static bool __not_null(const _Fp&) {return true;} template _LIBCPP_INLINE_VISIBILITY static bool __not_null(_R2 (*__p)(_B0, _B1)) {return __p;} template _LIBCPP_INLINE_VISIBILITY static bool __not_null(_R2 (_Cp::*__p)(_B1)) {return __p;} template _LIBCPP_INLINE_VISIBILITY static bool __not_null(_R2 (_Cp::*__p)(_B1) const) {return __p;} template _LIBCPP_INLINE_VISIBILITY static bool __not_null(_R2 (_Cp::*__p)(_B1) volatile) {return __p;} template _LIBCPP_INLINE_VISIBILITY static bool __not_null(_R2 (_Cp::*__p)(_B1) const volatile) {return __p;} template _LIBCPP_INLINE_VISIBILITY static bool __not_null(const function<_R2(_B0, _B1)>& __p) {return __p;} public: typedef _Rp result_type; // 20.7.16.2.1, construct/copy/destroy: _LIBCPP_INLINE_VISIBILITY explicit function() : __f_(0) {} _LIBCPP_INLINE_VISIBILITY function(nullptr_t) : __f_(0) {} function(const function&); template function(_Fp, typename enable_if::value>::type* = 0); template _LIBCPP_INLINE_VISIBILITY function(allocator_arg_t, const _Alloc&) : __f_(0) {} template _LIBCPP_INLINE_VISIBILITY function(allocator_arg_t, const _Alloc&, nullptr_t) : __f_(0) {} template function(allocator_arg_t, const _Alloc&, const function&); template function(allocator_arg_t, const _Alloc& __a, _Fp __f, typename enable_if::value>::type* = 0); function& operator=(const function&); function& operator=(nullptr_t); template typename enable_if < !is_integral<_Fp>::value, function& >::type operator=(_Fp); ~function(); // 20.7.16.2.2, function modifiers: void swap(function&); template _LIBCPP_INLINE_VISIBILITY void assign(_Fp __f, const _Alloc& __a) {function(allocator_arg, __a, __f).swap(*this);} // 20.7.16.2.3, function capacity: operator bool() const {return __f_;} private: // deleted overloads close possible hole in the type system template bool operator==(const function<_R2(_B0, _B1)>&) const;// = delete; template bool operator!=(const function<_R2(_B0, _B1)>&) const;// = delete; public: // 20.7.16.2.4, function invocation: _Rp operator()(_A0, _A1) const; #ifndef _LIBCPP_NO_RTTI // 20.7.16.2.5, function target access: const std::type_info& target_type() const; template _Tp* target(); template const _Tp* target() const; #endif // _LIBCPP_NO_RTTI }; template function<_Rp(_A0, _A1)>::function(const function& __f) { if (__f.__f_ == 0) __f_ = 0; else if (__f.__f_ == (const __base*)&__f.__buf_) { __f_ = (__base*)&__buf_; __f.__f_->__clone(__f_); } else __f_ = __f.__f_->__clone(); } template template function<_Rp(_A0, _A1)>::function(allocator_arg_t, const _Alloc&, const function& __f) { if (__f.__f_ == 0) __f_ = 0; else if (__f.__f_ == (const __base*)&__f.__buf_) { __f_ = (__base*)&__buf_; __f.__f_->__clone(__f_); } else __f_ = __f.__f_->__clone(); } template template function<_Rp(_A0, _A1)>::function(_Fp __f, typename enable_if::value>::type*) : __f_(0) { if (__not_null(__f)) { typedef __function::__func<_Fp, allocator<_Fp>, _Rp(_A0, _A1)> _FF; if (sizeof(_FF) <= sizeof(__buf_)) { __f_ = (__base*)&__buf_; ::new (__f_) _FF(__f); } else { typedef allocator<_FF> _Ap; _Ap __a; typedef __allocator_destructor<_Ap> _Dp; unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); ::new (__hold.get()) _FF(__f, allocator<_Fp>(__a)); __f_ = __hold.release(); } } } template template function<_Rp(_A0, _A1)>::function(allocator_arg_t, const _Alloc& __a0, _Fp __f, typename enable_if::value>::type*) : __f_(0) { typedef allocator_traits<_Alloc> __alloc_traits; if (__not_null(__f)) { typedef __function::__func<_Fp, _Alloc, _Rp(_A0, _A1)> _FF; if (sizeof(_FF) <= sizeof(__buf_)) { __f_ = (__base*)&__buf_; ::new (__f_) _FF(__f); } else { typedef typename __alloc_traits::template #ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES rebind_alloc<_FF> #else rebind_alloc<_FF>::other #endif _Ap; _Ap __a(__a0); typedef __allocator_destructor<_Ap> _Dp; unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); ::new (__hold.get()) _FF(__f, _Alloc(__a)); __f_ = __hold.release(); } } } template function<_Rp(_A0, _A1)>& function<_Rp(_A0, _A1)>::operator=(const function& __f) { function(__f).swap(*this); return *this; } template function<_Rp(_A0, _A1)>& function<_Rp(_A0, _A1)>::operator=(nullptr_t) { if (__f_ == (__base*)&__buf_) __f_->destroy(); else if (__f_) __f_->destroy_deallocate(); __f_ = 0; } template template typename enable_if < !is_integral<_Fp>::value, function<_Rp(_A0, _A1)>& >::type function<_Rp(_A0, _A1)>::operator=(_Fp __f) { function(_VSTD::move(__f)).swap(*this); return *this; } template function<_Rp(_A0, _A1)>::~function() { if (__f_ == (__base*)&__buf_) __f_->destroy(); else if (__f_) __f_->destroy_deallocate(); } template void function<_Rp(_A0, _A1)>::swap(function& __f) { if (__f_ == (__base*)&__buf_ && __f.__f_ == (__base*)&__f.__buf_) { typename aligned_storage::type __tempbuf; __base* __t = (__base*)&__tempbuf; __f_->__clone(__t); __f_->destroy(); __f_ = 0; __f.__f_->__clone((__base*)&__buf_); __f.__f_->destroy(); __f.__f_ = 0; __f_ = (__base*)&__buf_; __t->__clone((__base*)&__f.__buf_); __t->destroy(); __f.__f_ = (__base*)&__f.__buf_; } else if (__f_ == (__base*)&__buf_) { __f_->__clone((__base*)&__f.__buf_); __f_->destroy(); __f_ = __f.__f_; __f.__f_ = (__base*)&__f.__buf_; } else if (__f.__f_ == (__base*)&__f.__buf_) { __f.__f_->__clone((__base*)&__buf_); __f.__f_->destroy(); __f.__f_ = __f_; __f_ = (__base*)&__buf_; } else _VSTD::swap(__f_, __f.__f_); } template _Rp function<_Rp(_A0, _A1)>::operator()(_A0 __a0, _A1 __a1) const { #ifndef _LIBCPP_NO_EXCEPTIONS if (__f_ == 0) throw bad_function_call(); #endif // _LIBCPP_NO_EXCEPTIONS return (*__f_)(__a0, __a1); } #ifndef _LIBCPP_NO_RTTI template const std::type_info& function<_Rp(_A0, _A1)>::target_type() const { if (__f_ == 0) return typeid(void); return __f_->target_type(); } template template _Tp* function<_Rp(_A0, _A1)>::target() { if (__f_ == 0) return (_Tp*)0; return (_Tp*)__f_->target(typeid(_Tp)); } template template const _Tp* function<_Rp(_A0, _A1)>::target() const { if (__f_ == 0) return (const _Tp*)0; return (const _Tp*)__f_->target(typeid(_Tp)); } #endif // _LIBCPP_NO_RTTI template class _LIBCPP_TYPE_VIS_ONLY function<_Rp(_A0, _A1, _A2)> { typedef __function::__base<_Rp(_A0, _A1, _A2)> __base; aligned_storage<3*sizeof(void*)>::type __buf_; __base* __f_; template _LIBCPP_INLINE_VISIBILITY static bool __not_null(const _Fp&) {return true;} template _LIBCPP_INLINE_VISIBILITY static bool __not_null(_R2 (*__p)(_B0, _B1, _B2)) {return __p;} template _LIBCPP_INLINE_VISIBILITY static bool __not_null(_R2 (_Cp::*__p)(_B1, _B2)) {return __p;} template _LIBCPP_INLINE_VISIBILITY static bool __not_null(_R2 (_Cp::*__p)(_B1, _B2) const) {return __p;} template _LIBCPP_INLINE_VISIBILITY static bool __not_null(_R2 (_Cp::*__p)(_B1, _B2) volatile) {return __p;} template _LIBCPP_INLINE_VISIBILITY static bool __not_null(_R2 (_Cp::*__p)(_B1, _B2) const volatile) {return __p;} template _LIBCPP_INLINE_VISIBILITY static bool __not_null(const function<_R2(_B0, _B1, _B2)>& __p) {return __p;} public: typedef _Rp result_type; // 20.7.16.2.1, construct/copy/destroy: _LIBCPP_INLINE_VISIBILITY explicit function() : __f_(0) {} _LIBCPP_INLINE_VISIBILITY function(nullptr_t) : __f_(0) {} function(const function&); template function(_Fp, typename enable_if::value>::type* = 0); template _LIBCPP_INLINE_VISIBILITY function(allocator_arg_t, const _Alloc&) : __f_(0) {} template _LIBCPP_INLINE_VISIBILITY function(allocator_arg_t, const _Alloc&, nullptr_t) : __f_(0) {} template function(allocator_arg_t, const _Alloc&, const function&); template function(allocator_arg_t, const _Alloc& __a, _Fp __f, typename enable_if::value>::type* = 0); function& operator=(const function&); function& operator=(nullptr_t); template typename enable_if < !is_integral<_Fp>::value, function& >::type operator=(_Fp); ~function(); // 20.7.16.2.2, function modifiers: void swap(function&); template _LIBCPP_INLINE_VISIBILITY void assign(_Fp __f, const _Alloc& __a) {function(allocator_arg, __a, __f).swap(*this);} // 20.7.16.2.3, function capacity: _LIBCPP_INLINE_VISIBILITY operator bool() const {return __f_;} private: // deleted overloads close possible hole in the type system template bool operator==(const function<_R2(_B0, _B1, _B2)>&) const;// = delete; template bool operator!=(const function<_R2(_B0, _B1, _B2)>&) const;// = delete; public: // 20.7.16.2.4, function invocation: _Rp operator()(_A0, _A1, _A2) const; #ifndef _LIBCPP_NO_RTTI // 20.7.16.2.5, function target access: const std::type_info& target_type() const; template _Tp* target(); template const _Tp* target() const; #endif // _LIBCPP_NO_RTTI }; template function<_Rp(_A0, _A1, _A2)>::function(const function& __f) { if (__f.__f_ == 0) __f_ = 0; else if (__f.__f_ == (const __base*)&__f.__buf_) { __f_ = (__base*)&__buf_; __f.__f_->__clone(__f_); } else __f_ = __f.__f_->__clone(); } template template function<_Rp(_A0, _A1, _A2)>::function(allocator_arg_t, const _Alloc&, const function& __f) { if (__f.__f_ == 0) __f_ = 0; else if (__f.__f_ == (const __base*)&__f.__buf_) { __f_ = (__base*)&__buf_; __f.__f_->__clone(__f_); } else __f_ = __f.__f_->__clone(); } template template function<_Rp(_A0, _A1, _A2)>::function(_Fp __f, typename enable_if::value>::type*) : __f_(0) { if (__not_null(__f)) { typedef __function::__func<_Fp, allocator<_Fp>, _Rp(_A0, _A1, _A2)> _FF; if (sizeof(_FF) <= sizeof(__buf_)) { __f_ = (__base*)&__buf_; ::new (__f_) _FF(__f); } else { typedef allocator<_FF> _Ap; _Ap __a; typedef __allocator_destructor<_Ap> _Dp; unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); ::new (__hold.get()) _FF(__f, allocator<_Fp>(__a)); __f_ = __hold.release(); } } } template template function<_Rp(_A0, _A1, _A2)>::function(allocator_arg_t, const _Alloc& __a0, _Fp __f, typename enable_if::value>::type*) : __f_(0) { typedef allocator_traits<_Alloc> __alloc_traits; if (__not_null(__f)) { typedef __function::__func<_Fp, _Alloc, _Rp(_A0, _A1, _A2)> _FF; if (sizeof(_FF) <= sizeof(__buf_)) { __f_ = (__base*)&__buf_; ::new (__f_) _FF(__f); } else { typedef typename __alloc_traits::template #ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES rebind_alloc<_FF> #else rebind_alloc<_FF>::other #endif _Ap; _Ap __a(__a0); typedef __allocator_destructor<_Ap> _Dp; unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); ::new (__hold.get()) _FF(__f, _Alloc(__a)); __f_ = __hold.release(); } } } template function<_Rp(_A0, _A1, _A2)>& function<_Rp(_A0, _A1, _A2)>::operator=(const function& __f) { function(__f).swap(*this); return *this; } template function<_Rp(_A0, _A1, _A2)>& function<_Rp(_A0, _A1, _A2)>::operator=(nullptr_t) { if (__f_ == (__base*)&__buf_) __f_->destroy(); else if (__f_) __f_->destroy_deallocate(); __f_ = 0; } template template typename enable_if < !is_integral<_Fp>::value, function<_Rp(_A0, _A1, _A2)>& >::type function<_Rp(_A0, _A1, _A2)>::operator=(_Fp __f) { function(_VSTD::move(__f)).swap(*this); return *this; } template function<_Rp(_A0, _A1, _A2)>::~function() { if (__f_ == (__base*)&__buf_) __f_->destroy(); else if (__f_) __f_->destroy_deallocate(); } template void function<_Rp(_A0, _A1, _A2)>::swap(function& __f) { if (__f_ == (__base*)&__buf_ && __f.__f_ == (__base*)&__f.__buf_) { typename aligned_storage::type __tempbuf; __base* __t = (__base*)&__tempbuf; __f_->__clone(__t); __f_->destroy(); __f_ = 0; __f.__f_->__clone((__base*)&__buf_); __f.__f_->destroy(); __f.__f_ = 0; __f_ = (__base*)&__buf_; __t->__clone((__base*)&__f.__buf_); __t->destroy(); __f.__f_ = (__base*)&__f.__buf_; } else if (__f_ == (__base*)&__buf_) { __f_->__clone((__base*)&__f.__buf_); __f_->destroy(); __f_ = __f.__f_; __f.__f_ = (__base*)&__f.__buf_; } else if (__f.__f_ == (__base*)&__f.__buf_) { __f.__f_->__clone((__base*)&__buf_); __f.__f_->destroy(); __f.__f_ = __f_; __f_ = (__base*)&__buf_; } else _VSTD::swap(__f_, __f.__f_); } template _Rp function<_Rp(_A0, _A1, _A2)>::operator()(_A0 __a0, _A1 __a1, _A2 __a2) const { #ifndef _LIBCPP_NO_EXCEPTIONS if (__f_ == 0) throw bad_function_call(); #endif // _LIBCPP_NO_EXCEPTIONS return (*__f_)(__a0, __a1, __a2); } #ifndef _LIBCPP_NO_RTTI template const std::type_info& function<_Rp(_A0, _A1, _A2)>::target_type() const { if (__f_ == 0) return typeid(void); return __f_->target_type(); } template template _Tp* function<_Rp(_A0, _A1, _A2)>::target() { if (__f_ == 0) return (_Tp*)0; return (_Tp*)__f_->target(typeid(_Tp)); } template template const _Tp* function<_Rp(_A0, _A1, _A2)>::target() const { if (__f_ == 0) return (const _Tp*)0; return (const _Tp*)__f_->target(typeid(_Tp)); } #endif // _LIBCPP_NO_RTTI template inline _LIBCPP_INLINE_VISIBILITY bool operator==(const function<_Fp>& __f, nullptr_t) {return !__f;} template inline _LIBCPP_INLINE_VISIBILITY bool operator==(nullptr_t, const function<_Fp>& __f) {return !__f;} template inline _LIBCPP_INLINE_VISIBILITY bool operator!=(const function<_Fp>& __f, nullptr_t) {return (bool)__f;} template inline _LIBCPP_INLINE_VISIBILITY bool operator!=(nullptr_t, const function<_Fp>& __f) {return (bool)__f;} template inline _LIBCPP_INLINE_VISIBILITY void swap(function<_Fp>& __x, function<_Fp>& __y) {return __x.swap(__y);} template struct __is_bind_expression : public false_type {}; template struct _LIBCPP_TYPE_VIS_ONLY is_bind_expression : public __is_bind_expression::type> {}; template struct __is_placeholder : public integral_constant {}; template struct _LIBCPP_TYPE_VIS_ONLY is_placeholder : public __is_placeholder::type> {}; namespace placeholders { template struct __ph {}; extern __ph<1> _1; extern __ph<2> _2; extern __ph<3> _3; extern __ph<4> _4; extern __ph<5> _5; extern __ph<6> _6; extern __ph<7> _7; extern __ph<8> _8; extern __ph<9> _9; extern __ph<10> _10; } // placeholders template struct __is_placeholder > : public integral_constant {}; template inline _LIBCPP_INLINE_VISIBILITY _Tp& __mu(reference_wrapper<_Tp> __t, _Uj&) { return __t.get(); } /* template struct __mu_return1 {}; template struct __mu_return1 { typedef typename result_of<_Ti(_Uj...)>::type type; }; template inline _LIBCPP_INLINE_VISIBILITY typename __mu_return1::type __mu_expand(_Ti& __ti, tuple<_Uj...>&& __uj, __tuple_indices<_Indx...>) { __ti(_VSTD::forward::type>(_VSTD::get<_Indx>(__uj))...); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < is_bind_expression<_Ti>::value, typename __mu_return1::value, _Ti, _Uj...>::type >::type __mu(_Ti& __ti, tuple<_Uj...>& __uj) { typedef typename __make_tuple_indices::type __indices; return __mu_expand(__ti, __uj, __indices()); } template struct __mu_return2 {}; template struct __mu_return2 { typedef typename tuple_element::value - 1, _Uj>::type type; }; template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < 0 < is_placeholder<_Ti>::value, typename __mu_return2<0 < is_placeholder<_Ti>::value, _Ti, _Uj>::type >::type __mu(_Ti&, _Uj& __uj) { const size_t _Indx = is_placeholder<_Ti>::value - 1; // compiler bug workaround typename tuple_element<_Indx, _Uj>::type __t = _VSTD::get<_Indx>(__uj); return __t; // return _VSTD::forward::type>(_VSTD::get<_Indx>(__uj)); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < !is_bind_expression<_Ti>::value && is_placeholder<_Ti>::value == 0 && !__is_reference_wrapper<_Ti>::value, _Ti& >::type __mu(_Ti& __ti, _Uj& __uj) { return __ti; } template struct ____mu_return; template struct ____mu_return<_Ti, true, false, tuple<_Uj...> > { typedef typename result_of<_Ti(_Uj...)>::type type; }; template struct ____mu_return<_Ti, false, true, _TupleUj> { typedef typename tuple_element::value - 1, _TupleUj>::type&& type; }; template struct ____mu_return<_Ti, false, false, _TupleUj> { typedef _Ti& type; }; template struct __mu_return : public ____mu_return<_Ti, is_bind_expression<_Ti>::value, 0 < is_placeholder<_Ti>::value, _TupleUj> { }; template struct __mu_return, _TupleUj> { typedef _Ti& type; }; template struct __bind_return; template struct __bind_return<_Fp, tuple<_BoundArgs...>, _TupleUj> { typedef typename __ref_return < _Fp&, typename __mu_return < _BoundArgs, _TupleUj >::type... >::type type; }; template struct __bind_return<_Fp, const tuple<_BoundArgs...>, _TupleUj> { typedef typename __ref_return < _Fp&, typename __mu_return < const _BoundArgs, _TupleUj >::type... >::type type; }; template inline _LIBCPP_INLINE_VISIBILITY typename __bind_return<_Fp, _BoundArgs, _Args>::type __apply_functor(_Fp& __f, _BoundArgs& __bound_args, __tuple_indices<_Indx...>, _Args&& __args) { return __invoke(__f, __mu(_VSTD::get<_Indx>(__bound_args), __args)...); } template class __bind { _Fp __f_; tuple<_BoundArgs...> __bound_args_; typedef typename __make_tuple_indices::type __indices; public: template explicit __bind(_Gp&& __f, _BA&& ...__bound_args) : __f_(_VSTD::forward<_Gp>(__f)), __bound_args_(_VSTD::forward<_BA>(__bound_args)...) {} template typename __bind_return<_Fp, tuple<_BoundArgs...>, tuple<_Args&&...> >::type operator()(_Args&& ...__args) { // compiler bug workaround return __apply_functor(__f_, __bound_args_, __indices(), tuple<_Args&&...>(__args...)); } template typename __bind_return<_Fp, tuple<_BoundArgs...>, tuple<_Args&&...> >::type operator()(_Args&& ...__args) const { return __apply_functor(__f_, __bound_args_, __indices(), tuple<_Args&&...>(__args...)); } }; template struct __is_bind_expression<__bind<_Fp, _BoundArgs...> > : public true_type {}; template class __bind_r : public __bind<_Fp, _BoundArgs...> { typedef __bind<_Fp, _BoundArgs...> base; public: typedef _Rp result_type; template explicit __bind_r(_Gp&& __f, _BA&& ...__bound_args) : base(_VSTD::forward<_Gp>(__f), _VSTD::forward<_BA>(__bound_args)...) {} template result_type operator()(_Args&& ...__args) { return base::operator()(_VSTD::forward<_Args>(__args)...); } template result_type operator()(_Args&& ...__args) const { return base::operator()(_VSTD::forward<_Args>(__args)...); } }; template struct __is_bind_expression<__bind_r<_Rp, _Fp, _BoundArgs...> > : public true_type {}; template inline _LIBCPP_INLINE_VISIBILITY __bind::type, typename decay<_BoundArgs>::type...> bind(_Fp&& __f, _BoundArgs&&... __bound_args) { typedef __bind::type, typename decay<_BoundArgs>::type...> type; return type(_VSTD::forward<_Fp>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...); } template inline _LIBCPP_INLINE_VISIBILITY __bind_r<_Rp, typename decay<_Fp>::type, typename decay<_BoundArgs>::type...> bind(_Fp&& __f, _BoundArgs&&... __bound_args) { typedef __bind_r<_Rp, typename decay<_Fp>::type, typename decay<_BoundArgs>::type...> type; return type(_VSTD::forward<_Fp>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...); } */ #endif // _LIBCPP_FUNCTIONAL_03 Index: stable/10/contrib/libc++/include/__functional_base =================================================================== --- stable/10/contrib/libc++/include/__functional_base (revision 308142) +++ stable/10/contrib/libc++/include/__functional_base (revision 308143) @@ -1,615 +1,635 @@ // -*- C++ -*- //===----------------------------------------------------------------------===// // // The LLVM Compiler Infrastructure // // This file is dual licensed under the MIT and the University of Illinois Open // Source Licenses. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// #ifndef _LIBCPP_FUNCTIONAL_BASE #define _LIBCPP_FUNCTIONAL_BASE #include <__config> #include #include #include #include #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #pragma GCC system_header #endif _LIBCPP_BEGIN_NAMESPACE_STD template struct _LIBCPP_TYPE_VIS_ONLY unary_function { typedef _Arg argument_type; typedef _Result result_type; }; template struct _LIBCPP_TYPE_VIS_ONLY binary_function { typedef _Arg1 first_argument_type; typedef _Arg2 second_argument_type; typedef _Result result_type; }; template struct _LIBCPP_TYPE_VIS_ONLY hash; template struct __has_result_type { private: struct __two {char __lx; char __lxx;}; template static __two __test(...); template static char __test(typename _Up::result_type* = 0); public: static const bool value = sizeof(__test<_Tp>(0)) == 1; }; #if _LIBCPP_STD_VER > 11 template #else template #endif struct _LIBCPP_TYPE_VIS_ONLY less : binary_function<_Tp, _Tp, bool> { _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const {return __x < __y;} }; #if _LIBCPP_STD_VER > 11 template <> struct _LIBCPP_TYPE_VIS_ONLY less { template _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY auto operator()(_T1&& __t, _T2&& __u) const { return _VSTD::forward<_T1>(__t) < _VSTD::forward<_T2>(__u); } typedef void is_transparent; }; #endif // addressof template inline _LIBCPP_INLINE_VISIBILITY _Tp* addressof(_Tp& __x) _NOEXCEPT { return (_Tp*)&reinterpret_cast(__x); } #if defined(_LIBCPP_HAS_OBJC_ARC) && !defined(_LIBCPP_PREDEFINED_OBJC_ARC_ADDRESSOF) // Objective-C++ Automatic Reference Counting uses qualified pointers // that require special addressof() signatures. When // _LIBCPP_PREDEFINED_OBJC_ARC_ADDRESSOF is defined, the compiler // itself is providing these definitions. Otherwise, we provide them. template inline _LIBCPP_INLINE_VISIBILITY __strong _Tp* addressof(__strong _Tp& __x) _NOEXCEPT { return &__x; } #ifdef _LIBCPP_HAS_OBJC_ARC_WEAK template inline _LIBCPP_INLINE_VISIBILITY __weak _Tp* addressof(__weak _Tp& __x) _NOEXCEPT { return &__x; } #endif template inline _LIBCPP_INLINE_VISIBILITY __autoreleasing _Tp* addressof(__autoreleasing _Tp& __x) _NOEXCEPT { return &__x; } template inline _LIBCPP_INLINE_VISIBILITY __unsafe_unretained _Tp* addressof(__unsafe_unretained _Tp& __x) _NOEXCEPT { return &__x; } #endif #ifdef _LIBCPP_HAS_NO_VARIADICS #include <__functional_base_03> #else // _LIBCPP_HAS_NO_VARIADICS // __weak_result_type template struct __derives_from_unary_function { private: struct __two {char __lx; char __lxx;}; static __two __test(...); template static unary_function<_Ap, _Rp> __test(const volatile unary_function<_Ap, _Rp>*); public: static const bool value = !is_same::value; typedef decltype(__test((_Tp*)0)) type; }; template struct __derives_from_binary_function { private: struct __two {char __lx; char __lxx;}; static __two __test(...); template static binary_function<_A1, _A2, _Rp> __test(const volatile binary_function<_A1, _A2, _Rp>*); public: static const bool value = !is_same::value; typedef decltype(__test((_Tp*)0)) type; }; template ::value> struct __maybe_derive_from_unary_function // bool is true : public __derives_from_unary_function<_Tp>::type { }; template struct __maybe_derive_from_unary_function<_Tp, false> { }; template ::value> struct __maybe_derive_from_binary_function // bool is true : public __derives_from_binary_function<_Tp>::type { }; template struct __maybe_derive_from_binary_function<_Tp, false> { }; template ::value> struct __weak_result_type_imp // bool is true : public __maybe_derive_from_unary_function<_Tp>, public __maybe_derive_from_binary_function<_Tp> { typedef typename _Tp::result_type result_type; }; template struct __weak_result_type_imp<_Tp, false> : public __maybe_derive_from_unary_function<_Tp>, public __maybe_derive_from_binary_function<_Tp> { }; template struct __weak_result_type : public __weak_result_type_imp<_Tp> { }; // 0 argument case template struct __weak_result_type<_Rp ()> { typedef _Rp result_type; }; template struct __weak_result_type<_Rp (&)()> { typedef _Rp result_type; }; template struct __weak_result_type<_Rp (*)()> { typedef _Rp result_type; }; // 1 argument case template struct __weak_result_type<_Rp (_A1)> : public unary_function<_A1, _Rp> { }; template struct __weak_result_type<_Rp (&)(_A1)> : public unary_function<_A1, _Rp> { }; template struct __weak_result_type<_Rp (*)(_A1)> : public unary_function<_A1, _Rp> { }; template struct __weak_result_type<_Rp (_Cp::*)()> : public unary_function<_Cp*, _Rp> { }; template struct __weak_result_type<_Rp (_Cp::*)() const> : public unary_function { }; template struct __weak_result_type<_Rp (_Cp::*)() volatile> : public unary_function { }; template struct __weak_result_type<_Rp (_Cp::*)() const volatile> : public unary_function { }; // 2 argument case template struct __weak_result_type<_Rp (_A1, _A2)> : public binary_function<_A1, _A2, _Rp> { }; template struct __weak_result_type<_Rp (*)(_A1, _A2)> : public binary_function<_A1, _A2, _Rp> { }; template struct __weak_result_type<_Rp (&)(_A1, _A2)> : public binary_function<_A1, _A2, _Rp> { }; template struct __weak_result_type<_Rp (_Cp::*)(_A1)> : public binary_function<_Cp*, _A1, _Rp> { }; template struct __weak_result_type<_Rp (_Cp::*)(_A1) const> : public binary_function { }; template struct __weak_result_type<_Rp (_Cp::*)(_A1) volatile> : public binary_function { }; template struct __weak_result_type<_Rp (_Cp::*)(_A1) const volatile> : public binary_function { }; // 3 or more arguments template struct __weak_result_type<_Rp (_A1, _A2, _A3, _A4...)> { typedef _Rp result_type; }; template struct __weak_result_type<_Rp (&)(_A1, _A2, _A3, _A4...)> { typedef _Rp result_type; }; template struct __weak_result_type<_Rp (*)(_A1, _A2, _A3, _A4...)> { typedef _Rp result_type; }; template struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2, _A3...)> { typedef _Rp result_type; }; template struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2, _A3...) const> { typedef _Rp result_type; }; template struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2, _A3...) volatile> { typedef _Rp result_type; }; template struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2, _A3...) const volatile> { typedef _Rp result_type; }; // __invoke // bullets 1 and 2 template inline _LIBCPP_INLINE_VISIBILITY auto __invoke(_Fp&& __f, _A0&& __a0, _Args&& ...__args) -> decltype((_VSTD::forward<_A0>(__a0).*__f)(_VSTD::forward<_Args>(__args)...)) { return (_VSTD::forward<_A0>(__a0).*__f)(_VSTD::forward<_Args>(__args)...); } template inline _LIBCPP_INLINE_VISIBILITY auto __invoke(_Fp&& __f, _A0&& __a0, _Args&& ...__args) -> decltype(((*_VSTD::forward<_A0>(__a0)).*__f)(_VSTD::forward<_Args>(__args)...)) { return ((*_VSTD::forward<_A0>(__a0)).*__f)(_VSTD::forward<_Args>(__args)...); } // bullets 3 and 4 template inline _LIBCPP_INLINE_VISIBILITY auto __invoke(_Fp&& __f, _A0&& __a0) -> decltype(_VSTD::forward<_A0>(__a0).*__f) { return _VSTD::forward<_A0>(__a0).*__f; } template inline _LIBCPP_INLINE_VISIBILITY auto __invoke(_Fp&& __f, _A0&& __a0) -> decltype((*_VSTD::forward<_A0>(__a0)).*__f) { return (*_VSTD::forward<_A0>(__a0)).*__f; } // bullet 5 template inline _LIBCPP_INLINE_VISIBILITY auto __invoke(_Fp&& __f, _Args&& ...__args) -> decltype(_VSTD::forward<_Fp>(__f)(_VSTD::forward<_Args>(__args)...)) { return _VSTD::forward<_Fp>(__f)(_VSTD::forward<_Args>(__args)...); } template struct __invoke_return { typedef decltype(__invoke(_VSTD::declval<_Tp>(), _VSTD::declval<_Args>()...)) type; }; +template +struct __invoke_void_return_wrapper +{ + template + static _Ret __call(_Args&&... __args) + { + return __invoke(_VSTD::forward<_Args>(__args)...); + } +}; + +template <> +struct __invoke_void_return_wrapper +{ + template + static void __call(_Args&&... __args) + { + __invoke(_VSTD::forward<_Args>(__args)...); + } +}; + template class _LIBCPP_TYPE_VIS_ONLY reference_wrapper : public __weak_result_type<_Tp> { public: // types typedef _Tp type; private: type* __f_; public: // construct/copy/destroy _LIBCPP_INLINE_VISIBILITY reference_wrapper(type& __f) _NOEXCEPT : __f_(_VSTD::addressof(__f)) {} #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES private: reference_wrapper(type&&); public: // = delete; // do not bind to temps #endif // access _LIBCPP_INLINE_VISIBILITY operator type& () const _NOEXCEPT {return *__f_;} _LIBCPP_INLINE_VISIBILITY type& get() const _NOEXCEPT {return *__f_;} // invoke template _LIBCPP_INLINE_VISIBILITY typename __invoke_of::type operator() (_ArgTypes&&... __args) const { return __invoke(get(), _VSTD::forward<_ArgTypes>(__args)...); } }; template struct __is_reference_wrapper_impl : public false_type {}; template struct __is_reference_wrapper_impl > : public true_type {}; template struct __is_reference_wrapper : public __is_reference_wrapper_impl::type> {}; template inline _LIBCPP_INLINE_VISIBILITY reference_wrapper<_Tp> ref(_Tp& __t) _NOEXCEPT { return reference_wrapper<_Tp>(__t); } template inline _LIBCPP_INLINE_VISIBILITY reference_wrapper<_Tp> ref(reference_wrapper<_Tp> __t) _NOEXCEPT { return ref(__t.get()); } template inline _LIBCPP_INLINE_VISIBILITY reference_wrapper cref(const _Tp& __t) _NOEXCEPT { return reference_wrapper(__t); } template inline _LIBCPP_INLINE_VISIBILITY reference_wrapper cref(reference_wrapper<_Tp> __t) _NOEXCEPT { return cref(__t.get()); } #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES #ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS template void ref(const _Tp&&) = delete; template void cref(const _Tp&&) = delete; #else // _LIBCPP_HAS_NO_DELETED_FUNCTIONS template void ref(const _Tp&&);// = delete; template void cref(const _Tp&&);// = delete; #endif // _LIBCPP_HAS_NO_DELETED_FUNCTIONS #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES #endif // _LIBCPP_HAS_NO_VARIADICS #if _LIBCPP_STD_VER > 11 template struct __is_transparent { private: struct __two {char __lx; char __lxx;}; template static __two __test(...); template static char __test(typename _Up::is_transparent* = 0); public: static const bool value = sizeof(__test<_Tp1>(0)) == 1; }; #endif // allocator_arg_t struct _LIBCPP_TYPE_VIS_ONLY allocator_arg_t { }; #if defined(_LIBCPP_HAS_NO_CONSTEXPR) || defined(_LIBCPP_BUILDING_MEMORY) extern const allocator_arg_t allocator_arg; #else constexpr allocator_arg_t allocator_arg = allocator_arg_t(); #endif // uses_allocator template struct __has_allocator_type { private: struct __two {char __lx; char __lxx;}; template static __two __test(...); template static char __test(typename _Up::allocator_type* = 0); public: static const bool value = sizeof(__test<_Tp>(0)) == 1; }; template ::value> struct __uses_allocator : public integral_constant::value> { }; template struct __uses_allocator<_Tp, _Alloc, false> : public false_type { }; template struct _LIBCPP_TYPE_VIS_ONLY uses_allocator : public __uses_allocator<_Tp, _Alloc> { }; #ifndef _LIBCPP_HAS_NO_VARIADICS // allocator construction template struct __uses_alloc_ctor_imp { static const bool __ua = uses_allocator<_Tp, _Alloc>::value; static const bool __ic = is_constructible<_Tp, allocator_arg_t, _Alloc, _Args...>::value; static const int value = __ua ? 2 - __ic : 0; }; template struct __uses_alloc_ctor : integral_constant::value> {}; template inline _LIBCPP_INLINE_VISIBILITY void __user_alloc_construct_impl (integral_constant, _Tp *__storage, const _Allocator &, _Args &&... __args ) { new (__storage) _Tp (_VSTD::forward<_Args>(__args)...); } template inline _LIBCPP_INLINE_VISIBILITY void __user_alloc_construct_impl (integral_constant, _Tp *__storage, const _Allocator &__a, _Args &&... __args ) { new (__storage) _Tp (allocator_arg, __a, _VSTD::forward<_Args>(__args)...); } template inline _LIBCPP_INLINE_VISIBILITY void __user_alloc_construct_impl (integral_constant, _Tp *__storage, const _Allocator &__a, _Args &&... __args ) { new (__storage) _Tp (_VSTD::forward<_Args>(__args)..., __a); } template inline _LIBCPP_INLINE_VISIBILITY void __user_alloc_construct (_Tp *__storage, const _Allocator &__a, _Args &&... __args) { __user_alloc_construct_impl( __uses_alloc_ctor<_Tp, _Allocator>(), __storage, __a, _VSTD::forward<_Args>(__args)... ); } #endif // _LIBCPP_HAS_NO_VARIADICS _LIBCPP_END_NAMESPACE_STD #endif // _LIBCPP_FUNCTIONAL_BASE Index: stable/10/contrib/libc++/include/__functional_base_03 =================================================================== --- stable/10/contrib/libc++/include/__functional_base_03 (revision 308142) +++ stable/10/contrib/libc++/include/__functional_base_03 (revision 308143) @@ -1,1087 +1,1144 @@ // -*- C++ -*- //===----------------------------------------------------------------------===// // // The LLVM Compiler Infrastructure // // This file is dual licensed under the MIT and the University of Illinois Open // Source Licenses. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// #ifndef _LIBCPP_FUNCTIONAL_BASE_03 #define _LIBCPP_FUNCTIONAL_BASE_03 // manual variadic expansion for // __weak_result_type template struct __derives_from_unary_function { private: struct __two {char __lx; char __lxx;}; static __two __test(...); template static unary_function<_Ap, _Rp> __test(const volatile unary_function<_Ap, _Rp>*); public: static const bool value = !is_same::value; typedef decltype(__test((_Tp*)0)) type; }; template struct __derives_from_binary_function { private: struct __two {char __lx; char __lxx;}; static __two __test(...); template static binary_function<_A1, _A2, _Rp> __test(const volatile binary_function<_A1, _A2, _Rp>*); public: static const bool value = !is_same::value; typedef decltype(__test((_Tp*)0)) type; }; template ::value> struct __maybe_derive_from_unary_function // bool is true : public __derives_from_unary_function<_Tp>::type { }; template struct __maybe_derive_from_unary_function<_Tp, false> { }; template ::value> struct __maybe_derive_from_binary_function // bool is true : public __derives_from_binary_function<_Tp>::type { }; template struct __maybe_derive_from_binary_function<_Tp, false> { }; template ::value> struct __weak_result_type_imp // bool is true : public __maybe_derive_from_unary_function<_Tp>, public __maybe_derive_from_binary_function<_Tp> { typedef typename _Tp::result_type result_type; }; template struct __weak_result_type_imp<_Tp, false> : public __maybe_derive_from_unary_function<_Tp>, public __maybe_derive_from_binary_function<_Tp> { }; template struct __weak_result_type : public __weak_result_type_imp::type> { }; // 0 argument case template struct __weak_result_type<_Rp ()> { typedef _Rp result_type; }; template struct __weak_result_type<_Rp (&)()> { typedef _Rp result_type; }; template struct __weak_result_type<_Rp (*)()> { typedef _Rp result_type; }; // 1 argument case template struct __weak_result_type<_Rp (_A1)> : public unary_function<_A1, _Rp> { }; template struct __weak_result_type<_Rp (&)(_A1)> : public unary_function<_A1, _Rp> { }; template struct __weak_result_type<_Rp (*)(_A1)> : public unary_function<_A1, _Rp> { }; template struct __weak_result_type<_Rp (_Cp::*)()> : public unary_function<_Cp*, _Rp> { }; template struct __weak_result_type<_Rp (_Cp::*)() const> : public unary_function { }; template struct __weak_result_type<_Rp (_Cp::*)() volatile> : public unary_function { }; template struct __weak_result_type<_Rp (_Cp::*)() const volatile> : public unary_function { }; // 2 argument case template struct __weak_result_type<_Rp (_A1, _A2)> : public binary_function<_A1, _A2, _Rp> { }; template struct __weak_result_type<_Rp (*)(_A1, _A2)> : public binary_function<_A1, _A2, _Rp> { }; template struct __weak_result_type<_Rp (&)(_A1, _A2)> : public binary_function<_A1, _A2, _Rp> { }; template struct __weak_result_type<_Rp (_Cp::*)(_A1)> : public binary_function<_Cp*, _A1, _Rp> { }; template struct __weak_result_type<_Rp (_Cp::*)(_A1) const> : public binary_function { }; template struct __weak_result_type<_Rp (_Cp::*)(_A1) volatile> : public binary_function { }; template struct __weak_result_type<_Rp (_Cp::*)(_A1) const volatile> : public binary_function { }; // 3 or more arguments template struct __weak_result_type<_Rp (_A1, _A2, _A3)> { typedef _Rp result_type; }; template struct __weak_result_type<_Rp (&)(_A1, _A2, _A3)> { typedef _Rp result_type; }; template struct __weak_result_type<_Rp (*)(_A1, _A2, _A3)> { typedef _Rp result_type; }; template struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2)> { typedef _Rp result_type; }; template struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2) const> { typedef _Rp result_type; }; template struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2) volatile> { typedef _Rp result_type; }; // __invoke // __ref_return0 // // template // struct ________ref_return0 // _HasResultType is true // { // typedef typename _Tp::result_type type; // }; // // template // struct ________ref_return0<_Tp, false> // { // typedef void type; // }; // // template // struct ____ref_return0 // _IsClass is true // : public ________ref_return0<_Tp, __has_result_type::type>::value> // { // }; // // template // struct ______ref_return0 // _HasResultType is true // { // typedef typename __callable_type<_Tp>::result_type type; // }; // // template // struct ______ref_return0<_Tp, false> // pointer to member data // { // typedef void type; // }; // // template // struct ____ref_return0<_Tp, false> // : public ______ref_return0::type, // __has_result_type<__callable_type::type> >::value> // { // }; // // template // struct __ref_return0 // : public ____ref_return0::type, // is_class::type>::value> // { // }; // // __ref_return1 // // template // struct ____ref_return1 // _IsClass is true // { // typedef typename result_of<_Tp(_A0)>::type type; // }; // // template // struct ______ref_return1 // _HasResultType is true // { // typedef typename __callable_type<_Tp>::result_type type; // }; // // template // struct __ref_return1_member_data1; // // template // struct __ref_return1_member_data1<_Rp _Cp::*, _A0, true> // { // typedef typename __apply_cv<_A0, _Rp>::type& type; // }; // // template // struct __ref_return1_member_data1<_Rp _Cp::*, _A0, false> // { // static _A0 __a; // typedef typename __apply_cv::type& type; // }; // // template // struct __ref_return1_member_data; // // template // struct __ref_return1_member_data<_Rp _Cp::*, _A0> // : public __ref_return1_member_data1<_Rp _Cp::*, _A0, // is_same::type, // typename remove_cv::type>::type>::value> // { // }; // // template // struct ______ref_return1<_Tp, false, _A0> // pointer to member data // : public __ref_return1_member_data::type, _A0> // { // }; // // template // struct ____ref_return1<_Tp, false, _A0> // : public ______ref_return1::type, // __has_result_type<__callable_type::type> >::value, _A0> // { // }; // // template // struct __ref_return1 // : public ____ref_return1::type, // is_class::type>::value, _A0> // { // }; // // __ref_return2 // // template // struct ____ref_return2 // _IsClass is true // { // typedef typename result_of<_Tp(_A0, _A1)>::type type; // }; // // template // struct ______ref_return2 // _HasResultType is true // { // typedef typename __callable_type<_Tp>::result_type type; // }; // // template // struct ______ref_return2<_Tp, false, class _A0, class _A1> // pointer to member data // { // static_assert(sizeof(_Tp) == 0, "An attempt has been made to `call` a pointer" // " to member data with too many arguments."); // }; // // template // struct ____ref_return2<_Tp, false, _A0, _A1> // : public ______ref_return2::type, // __has_result_type<__callable_type::type> >::value, _A0, _A1> // { // }; // // template // struct __ref_return2 // : public ____ref_return2::type, // is_class::type>::value, _A0, _A1> // { // }; // // __ref_return3 // // template // struct ____ref_return3 // _IsClass is true // { // typedef typename result_of<_Tp(_A0, _A1, _A2)>::type type; // }; // // template // struct ______ref_return3 // _HasResultType is true // { // typedef typename __callable_type<_Tp>::result_type type; // }; // // template // struct ______ref_return3<_Tp, false, class _A0, class _A1, class _A2> // pointer to member data // { // static_assert(sizeof(_Tp) == 0, "An attempt has been made to `call` a pointer" // " to member data with too many arguments."); // }; // // template // struct ____ref_return3<_Tp, false, _A0, _A1, _A2> // : public ______ref_return3::type, // __has_result_type<__callable_type::type> >::value, _A0, _A1, _A2> // { // }; // // template // struct __ref_return3 // : public ____ref_return3::type, // is_class::type>::value, _A0, _A1, _A2> // { // }; // first bullet template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < is_base_of<_Tp, typename remove_reference<_T1>::type>::value, _Rp >::type __invoke(_Rp (_Tp::*__f)(), _T1& __t1) { return (__t1.*__f)(); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < is_base_of<_Tp, typename remove_reference<_T1>::type>::value, _Rp >::type __invoke(_Rp (_Tp::*__f)(_A0), _T1& __t1, _A0& __a0) { return (__t1.*__f)(__a0); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < is_base_of<_Tp, typename remove_reference<_T1>::type>::value, _Rp >::type __invoke(_Rp (_Tp::*__f)(_A0, _A1), _T1& __t1, _A0& __a0, _A1& __a1) { return (__t1.*__f)(__a0, __a1); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < is_base_of<_Tp, typename remove_reference<_T1>::type>::value, _Rp >::type __invoke(_Rp (_Tp::*__f)(_A0, _A1, _A2), _T1& __t1, _A0& __a0, _A1& __a1, _A2& __a2) { return (__t1.*__f)(__a0, __a1, __a2); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < is_base_of<_Tp, typename remove_reference<_T1>::type>::value, _Rp >::type __invoke(_Rp (_Tp::*__f)() const, _T1& __t1) { return (__t1.*__f)(); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < is_base_of<_Tp, typename remove_reference<_T1>::type>::value, _Rp >::type __invoke(_Rp (_Tp::*__f)(_A0) const, _T1& __t1, _A0& __a0) { return (__t1.*__f)(__a0); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < is_base_of<_Tp, typename remove_reference<_T1>::type>::value, _Rp >::type __invoke(_Rp (_Tp::*__f)(_A0, _A1) const, _T1& __t1, _A0& __a0, _A1& __a1) { return (__t1.*__f)(__a0, __a1); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < is_base_of<_Tp, typename remove_reference<_T1>::type>::value, _Rp >::type __invoke(_Rp (_Tp::*__f)(_A0, _A1, _A2) const, _T1& __t1, _A0& __a0, _A1& __a1, _A2& __a2) { return (__t1.*__f)(__a0, __a1, __a2); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < is_base_of<_Tp, typename remove_reference<_T1>::type>::value, _Rp >::type __invoke(_Rp (_Tp::*__f)() volatile, _T1& __t1) { return (__t1.*__f)(); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < is_base_of<_Tp, typename remove_reference<_T1>::type>::value, _Rp >::type __invoke(_Rp (_Tp::*__f)(_A0) volatile, _T1& __t1, _A0& __a0) { return (__t1.*__f)(__a0); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < is_base_of<_Tp, typename remove_reference<_T1>::type>::value, _Rp >::type __invoke(_Rp (_Tp::*__f)(_A0, _A1) volatile, _T1& __t1, _A0& __a0, _A1& __a1) { return (__t1.*__f)(__a0, __a1); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < is_base_of<_Tp, typename remove_reference<_T1>::type>::value, _Rp >::type __invoke(_Rp (_Tp::*__f)(_A0, _A1, _A2) volatile, _T1& __t1, _A0& __a0, _A1& __a1, _A2& __a2) { return (__t1.*__f)(__a0, __a1, __a2); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < is_base_of<_Tp, typename remove_reference<_T1>::type>::value, _Rp >::type __invoke(_Rp (_Tp::*__f)() const volatile, _T1& __t1) { return (__t1.*__f)(); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < is_base_of<_Tp, typename remove_reference<_T1>::type>::value, _Rp >::type __invoke(_Rp (_Tp::*__f)(_A0) const volatile, _T1& __t1, _A0& __a0) { return (__t1.*__f)(__a0); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < is_base_of<_Tp, typename remove_reference<_T1>::type>::value, _Rp >::type __invoke(_Rp (_Tp::*__f)(_A0, _A1) const volatile, _T1& __t1, _A0& __a0, _A1& __a1) { return (__t1.*__f)(__a0, __a1); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < is_base_of<_Tp, typename remove_reference<_T1>::type>::value, _Rp >::type __invoke(_Rp (_Tp::*__f)(_A0, _A1, _A2) const volatile, _T1& __t1, _A0& __a0, _A1& __a1, _A2& __a2) { return (__t1.*__f)(__a0, __a1, __a2); } // second bullet template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < !is_base_of<_Tp, typename remove_reference<_T1>::type>::value, _Rp >::type __invoke(_Rp (_Tp::*__f)(), _T1 __t1) { return ((*__t1).*__f)(); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < !is_base_of<_Tp, typename remove_reference<_T1>::type>::value, _Rp >::type __invoke(_Rp (_Tp::*__f)(_A0), _T1 __t1, _A0& __a0) { return ((*__t1).*__f)(__a0); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < !is_base_of<_Tp, typename remove_reference<_T1>::type>::value, _Rp >::type __invoke(_Rp (_Tp::*__f)(_A0, _A1), _T1 __t1, _A0& __a0, _A1& __a1) { return ((*__t1).*__f)(__a0, __a1); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < !is_base_of<_Tp, typename remove_reference<_T1>::type>::value, _Rp >::type __invoke(_Rp (_Tp::*__f)(_A0, _A1, _A2), _T1 __t1, _A0& __a0, _A1& __a1, _A2& __a2) { return ((*__t1).*__f)(__a0, __a1, __a2); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < !is_base_of<_Tp, typename remove_reference<_T1>::type>::value, _Rp >::type __invoke(_Rp (_Tp::*__f)() const, _T1 __t1) { return ((*__t1).*__f)(); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < !is_base_of<_Tp, typename remove_reference<_T1>::type>::value, _Rp >::type __invoke(_Rp (_Tp::*__f)(_A0) const, _T1 __t1, _A0& __a0) { return ((*__t1).*__f)(__a0); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < !is_base_of<_Tp, typename remove_reference<_T1>::type>::value, _Rp >::type __invoke(_Rp (_Tp::*__f)(_A0, _A1) const, _T1 __t1, _A0& __a0, _A1& __a1) { return ((*__t1).*__f)(__a0, __a1); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < !is_base_of<_Tp, typename remove_reference<_T1>::type>::value, _Rp >::type __invoke(_Rp (_Tp::*__f)(_A0, _A1, _A2) const, _T1 __t1, _A0& __a0, _A1& __a1, _A2& __a2) { return ((*__t1).*__f)(__a0, __a1, __a2); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < !is_base_of<_Tp, typename remove_reference<_T1>::type>::value, _Rp >::type __invoke(_Rp (_Tp::*__f)() volatile, _T1 __t1) { return ((*__t1).*__f)(); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < !is_base_of<_Tp, typename remove_reference<_T1>::type>::value, _Rp >::type __invoke(_Rp (_Tp::*__f)(_A0) volatile, _T1 __t1, _A0& __a0) { return ((*__t1).*__f)(__a0); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < !is_base_of<_Tp, typename remove_reference<_T1>::type>::value, _Rp >::type __invoke(_Rp (_Tp::*__f)(_A0, _A1) volatile, _T1 __t1, _A0& __a0, _A1& __a1) { return ((*__t1).*__f)(__a0, __a1); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < !is_base_of<_Tp, typename remove_reference<_T1>::type>::value, _Rp >::type __invoke(_Rp (_Tp::*__f)(_A0, _A1, _A2) volatile, _T1 __t1, _A0& __a0, _A1& __a1, _A2& __a2) { return ((*__t1).*__f)(__a0, __a1, __a2); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < !is_base_of<_Tp, typename remove_reference<_T1>::type>::value, _Rp >::type __invoke(_Rp (_Tp::*__f)() const volatile, _T1 __t1) { return ((*__t1).*__f)(); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < !is_base_of<_Tp, typename remove_reference<_T1>::type>::value, _Rp >::type __invoke(_Rp (_Tp::*__f)(_A0) const volatile, _T1 __t1, _A0& __a0) { return ((*__t1).*__f)(__a0); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < !is_base_of<_Tp, typename remove_reference<_T1>::type>::value, _Rp >::type __invoke(_Rp (_Tp::*__f)(_A0, _A1) const volatile, _T1 __t1, _A0& __a0, _A1& __a1) { return ((*__t1).*__f)(__a0, __a1); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < !is_base_of<_Tp, typename remove_reference<_T1>::type>::value, _Rp >::type __invoke(_Rp (_Tp::*__f)(_A0, _A1, _A2) const volatile, _T1 __t1, _A0& __a0, _A1& __a1, _A2& __a2) { return ((*__t1).*__f)(__a0, __a1, __a2); } // third bullet template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < is_base_of<_Tp, typename remove_reference<_T1>::type>::value, typename __apply_cv<_T1, _Rp>::type& >::type __invoke(_Rp _Tp::* __f, _T1& __t1) { return __t1.*__f; } template inline _LIBCPP_INLINE_VISIBILITY void __invoke(_Rp _Tp::*) { } // template // inline _LIBCPP_INLINE_VISIBILITY // typename enable_if // < // is_base_of<_Tp, typename remove_reference<_T1>::type>::value, // typename __ref_return1<_Rp _Tp::*, _T1>::type // >::type // __invoke(_Rp _Tp::* __f, _T1& __t1) // { // return __t1.*__f; // } // forth bullet template struct __4th_helper { }; template struct __4th_helper<_T1, _Rp, true> { typedef typename __apply_cv()), _Rp>::type type; }; template inline _LIBCPP_INLINE_VISIBILITY typename __4th_helper<_T1, _Rp, !is_base_of<_Tp, typename remove_reference<_T1>::type >::value >::type& __invoke(_Rp _Tp::* __f, _T1& __t1) { return (*__t1).*__f; } // template // inline _LIBCPP_INLINE_VISIBILITY // typename enable_if // < // !is_base_of<_Tp, typename remove_reference<_T1>::type>::value, // typename __ref_return1<_Rp _Tp::*, _T1>::type // >::type // __invoke(_Rp _Tp::* __f, _T1 __t1) // { // return (*__t1).*__f; // } // fifth bullet template inline _LIBCPP_INLINE_VISIBILITY decltype(declval<_Fp>()()) __invoke(_Fp __f) { return __f(); } template inline _LIBCPP_INLINE_VISIBILITY decltype(declval<_Fp>()(declval<_A0&>())) __invoke(_Fp __f, _A0& __a0) { return __f(__a0); } template inline _LIBCPP_INLINE_VISIBILITY decltype(declval<_Fp>()(declval<_A0&>(), declval<_A1&>())) __invoke(_Fp __f, _A0& __a0, _A1& __a1) { return __f(__a0, __a1); } template inline _LIBCPP_INLINE_VISIBILITY decltype(declval<_Fp>()(declval<_A0&>(), declval<_A1&>(), declval<_A2&>())) __invoke(_Fp __f, _A0& __a0, _A1& __a1, _A2& __a2) { return __f(__a0, __a1, __a2); } // template // inline _LIBCPP_INLINE_VISIBILITY // _Rp // __invoke(_Fp& __f) // { // return __f(); // } // // template // inline _LIBCPP_INLINE_VISIBILITY // typename enable_if // < // !is_member_pointer<_Fp>::value, // _Rp // >::type // __invoke(_Fp& __f, _A0& __a0) // { // return __f(__a0); // } // // template // inline _LIBCPP_INLINE_VISIBILITY // _Rp // __invoke(_Fp& __f, _A0& __a0, _A1& __a1) // { // return __f(__a0, __a1); // } // // template // inline _LIBCPP_INLINE_VISIBILITY // _Rp // __invoke(_Fp& __f, _A0& __a0, _A1& __a1, _A2& __a2) // { // return __f(__a0, __a1, __a2); // } template struct __has_type { private: struct __two {char __lx; char __lxx;}; template static __two __test(...); template static char __test(typename _Up::type* = 0); public: static const bool value = sizeof(__test<_Tp>(0)) == 1; }; template >::value> struct __invoke_return { typedef typename __weak_result_type<_Fp>::result_type type; }; template struct __invoke_return<_Fp, false> { typedef decltype(__invoke(_VSTD::declval<_Fp>())) type; }; template struct __invoke_return0 { typedef decltype(__invoke(_VSTD::declval<_Tp>(), _VSTD::declval<_A0>())) type; }; template struct __invoke_return0<_Rp _Tp::*, _A0> { typedef typename __apply_cv<_A0, _Rp>::type& type; }; template struct __invoke_return0<_Rp _Tp::*, _A0*> { typedef typename __apply_cv<_A0, _Rp>::type& type; }; template struct __invoke_return1 { typedef decltype(__invoke(_VSTD::declval<_Tp>(), _VSTD::declval<_A0>(), _VSTD::declval<_A1>())) type; }; template struct __invoke_return2 { typedef decltype(__invoke(_VSTD::declval<_Tp>(), _VSTD::declval<_A0>(), _VSTD::declval<_A1>(), _VSTD::declval<_A2>())) type; }; +template +struct __invoke_void_return_wrapper +{ + template + static _Ret __call(_Fn __f) + { + return __invoke(__f); + } + + template + static _Ret __call(_Fn __f, _A0& __a0) + { + return __invoke(__f, __a0); + } + + template + static _Ret __call(_Fn __f, _A0& __a0, _A1& __a1) + { + return __invoke(__f, __a0, __a1); + } + + template + static _Ret __call(_Fn __f, _A0& __a0, _A1& __a1, _A2& __a2) + { + return __invoke(__f, __a0, __a1, __a2); + } +}; + + +template <> +struct __invoke_void_return_wrapper +{ + template + static void __call(_Fn __f) + { + __invoke(__f); + } + + template + static void __call(_Fn __f, _A0& __a0) + { + __invoke(__f, __a0); + } + + template + static void __call(_Fn __f, _A0& __a0, _A1& __a1) + { + __invoke(__f, __a0, __a1); + } + + template + static void __call(_Fn __f, _A0& __a0, _A1& __a1, _A2& __a2) + { + __invoke(__f, __a0, __a1, __a2); + } +}; + template class _LIBCPP_TYPE_VIS_ONLY reference_wrapper : public __weak_result_type<_Tp> { public: // types typedef _Tp type; private: type* __f_; public: // construct/copy/destroy _LIBCPP_INLINE_VISIBILITY reference_wrapper(type& __f) : __f_(&__f) {} // access _LIBCPP_INLINE_VISIBILITY operator type& () const {return *__f_;} _LIBCPP_INLINE_VISIBILITY type& get() const {return *__f_;} // invoke _LIBCPP_INLINE_VISIBILITY typename __invoke_return::type operator() () const { return __invoke(get()); } template _LIBCPP_INLINE_VISIBILITY typename __invoke_return0::type operator() (_A0& __a0) const { return __invoke(get(), __a0); } template _LIBCPP_INLINE_VISIBILITY typename __invoke_return1::type operator() (_A0& __a0, _A1& __a1) const { return __invoke(get(), __a0, __a1); } template _LIBCPP_INLINE_VISIBILITY typename __invoke_return2::type operator() (_A0& __a0, _A1& __a1, _A2& __a2) const { return __invoke(get(), __a0, __a1, __a2); } }; template struct __is_reference_wrapper_impl : public false_type {}; template struct __is_reference_wrapper_impl > : public true_type {}; template struct __is_reference_wrapper : public __is_reference_wrapper_impl::type> {}; template inline _LIBCPP_INLINE_VISIBILITY reference_wrapper<_Tp> ref(_Tp& __t) { return reference_wrapper<_Tp>(__t); } template inline _LIBCPP_INLINE_VISIBILITY reference_wrapper<_Tp> ref(reference_wrapper<_Tp> __t) { return ref(__t.get()); } template inline _LIBCPP_INLINE_VISIBILITY reference_wrapper cref(const _Tp& __t) { return reference_wrapper(__t); } template inline _LIBCPP_INLINE_VISIBILITY reference_wrapper cref(reference_wrapper<_Tp> __t) { return cref(__t.get()); } #endif // _LIBCPP_FUNCTIONAL_BASE_03 Index: stable/10/contrib/libc++/include/functional =================================================================== --- stable/10/contrib/libc++/include/functional (revision 308142) +++ stable/10/contrib/libc++/include/functional (revision 308143) @@ -1,2419 +1,2420 @@ // -*- C++ -*- //===------------------------ functional ----------------------------------===// // // The LLVM Compiler Infrastructure // // This file is dual licensed under the MIT and the University of Illinois Open // Source Licenses. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// #ifndef _LIBCPP_FUNCTIONAL #define _LIBCPP_FUNCTIONAL /* functional synopsis namespace std { template struct unary_function { typedef Arg argument_type; typedef Result result_type; }; template struct binary_function { typedef Arg1 first_argument_type; typedef Arg2 second_argument_type; typedef Result result_type; }; template class reference_wrapper : public unary_function // if wrapping a unary functor : public binary_function // if wraping a binary functor { public: // types typedef T type; typedef see below result_type; // Not always defined // construct/copy/destroy reference_wrapper(T&) noexcept; reference_wrapper(T&&) = delete; // do not bind to temps reference_wrapper(const reference_wrapper& x) noexcept; // assignment reference_wrapper& operator=(const reference_wrapper& x) noexcept; // access operator T& () const noexcept; T& get() const noexcept; // invoke template typename result_of::type operator() (ArgTypes&&...) const; }; template reference_wrapper ref(T& t) noexcept; template void ref(const T&& t) = delete; template reference_wrapper ref(reference_wrappert) noexcept; template reference_wrapper cref(const T& t) noexcept; template void cref(const T&& t) = delete; template reference_wrapper cref(reference_wrapper t) noexcept; template // in C++14 struct plus : binary_function { T operator()(const T& x, const T& y) const; }; template // in C++14 struct minus : binary_function { T operator()(const T& x, const T& y) const; }; template // in C++14 struct multiplies : binary_function { T operator()(const T& x, const T& y) const; }; template // in C++14 struct divides : binary_function { T operator()(const T& x, const T& y) const; }; template // in C++14 struct modulus : binary_function { T operator()(const T& x, const T& y) const; }; template // in C++14 struct negate : unary_function { T operator()(const T& x) const; }; template // in C++14 struct equal_to : binary_function { bool operator()(const T& x, const T& y) const; }; template // in C++14 struct not_equal_to : binary_function { bool operator()(const T& x, const T& y) const; }; template // in C++14 struct greater : binary_function { bool operator()(const T& x, const T& y) const; }; template // in C++14 struct less : binary_function { bool operator()(const T& x, const T& y) const; }; template // in C++14 struct greater_equal : binary_function { bool operator()(const T& x, const T& y) const; }; template // in C++14 struct less_equal : binary_function { bool operator()(const T& x, const T& y) const; }; template // in C++14 struct logical_and : binary_function { bool operator()(const T& x, const T& y) const; }; template // in C++14 struct logical_or : binary_function { bool operator()(const T& x, const T& y) const; }; template // in C++14 struct logical_not : unary_function { bool operator()(const T& x) const; }; template // in C++14 struct bit_and : unary_function { bool operator()(const T& x, const T& y) const; }; template // in C++14 struct bit_or : unary_function { bool operator()(const T& x, const T& y) const; }; template // in C++14 struct bit_xor : unary_function { bool operator()(const T& x, const T& y) const; }; template // C++14 struct bit_xor : unary_function { bool operator()(const T& x) const; }; template class unary_negate : public unary_function { public: explicit unary_negate(const Predicate& pred); bool operator()(const typename Predicate::argument_type& x) const; }; template unary_negate not1(const Predicate& pred); template class binary_negate : public binary_function { public: explicit binary_negate(const Predicate& pred); bool operator()(const typename Predicate::first_argument_type& x, const typename Predicate::second_argument_type& y) const; }; template binary_negate not2(const Predicate& pred); template struct is_bind_expression; template struct is_placeholder; template unspecified bind(Fn&&, BoundArgs&&...); template unspecified bind(Fn&&, BoundArgs&&...); namespace placeholders { // M is the implementation-defined number of placeholders extern unspecified _1; extern unspecified _2; . . . extern unspecified _Mp; } template class binder1st : public unary_function { protected: Operation op; typename Operation::first_argument_type value; public: binder1st(const Operation& x, const typename Operation::first_argument_type y); typename Operation::result_type operator()( typename Operation::second_argument_type& x) const; typename Operation::result_type operator()(const typename Operation::second_argument_type& x) const; }; template binder1st bind1st(const Operation& op, const T& x); template class binder2nd : public unary_function { protected: Operation op; typename Operation::second_argument_type value; public: binder2nd(const Operation& x, const typename Operation::second_argument_type y); typename Operation::result_type operator()( typename Operation::first_argument_type& x) const; typename Operation::result_type operator()(const typename Operation::first_argument_type& x) const; }; template binder2nd bind2nd(const Operation& op, const T& x); template class pointer_to_unary_function : public unary_function { public: explicit pointer_to_unary_function(Result (*f)(Arg)); Result operator()(Arg x) const; }; template pointer_to_unary_function ptr_fun(Result (*f)(Arg)); template class pointer_to_binary_function : public binary_function { public: explicit pointer_to_binary_function(Result (*f)(Arg1, Arg2)); Result operator()(Arg1 x, Arg2 y) const; }; template pointer_to_binary_function ptr_fun(Result (*f)(Arg1,Arg2)); template class mem_fun_t : public unary_function { public: explicit mem_fun_t(S (T::*p)()); S operator()(T* p) const; }; template class mem_fun1_t : public binary_function { public: explicit mem_fun1_t(S (T::*p)(A)); S operator()(T* p, A x) const; }; template mem_fun_t mem_fun(S (T::*f)()); template mem_fun1_t mem_fun(S (T::*f)(A)); template class mem_fun_ref_t : public unary_function { public: explicit mem_fun_ref_t(S (T::*p)()); S operator()(T& p) const; }; template class mem_fun1_ref_t : public binary_function { public: explicit mem_fun1_ref_t(S (T::*p)(A)); S operator()(T& p, A x) const; }; template mem_fun_ref_t mem_fun_ref(S (T::*f)()); template mem_fun1_ref_t mem_fun_ref(S (T::*f)(A)); template class const_mem_fun_t : public unary_function { public: explicit const_mem_fun_t(S (T::*p)() const); S operator()(const T* p) const; }; template class const_mem_fun1_t : public binary_function { public: explicit const_mem_fun1_t(S (T::*p)(A) const); S operator()(const T* p, A x) const; }; template const_mem_fun_t mem_fun(S (T::*f)() const); template const_mem_fun1_t mem_fun(S (T::*f)(A) const); template class const_mem_fun_ref_t : public unary_function { public: explicit const_mem_fun_ref_t(S (T::*p)() const); S operator()(const T& p) const; }; template class const_mem_fun1_ref_t : public binary_function { public: explicit const_mem_fun1_ref_t(S (T::*p)(A) const); S operator()(const T& p, A x) const; }; template const_mem_fun_ref_t mem_fun_ref(S (T::*f)() const); template const_mem_fun1_ref_t mem_fun_ref(S (T::*f)(A) const); template unspecified mem_fn(R T::*); class bad_function_call : public exception { }; template class function; // undefined template class function : public unary_function // iff sizeof...(ArgTypes) == 1 and // ArgTypes contains T1 : public binary_function // iff sizeof...(ArgTypes) == 2 and // ArgTypes contains T1 and T2 { public: typedef R result_type; // construct/copy/destroy: function() noexcept; function(nullptr_t) noexcept; function(const function&); function(function&&) noexcept; template function(F); template function(allocator_arg_t, const Alloc&) noexcept; template function(allocator_arg_t, const Alloc&, nullptr_t) noexcept; template function(allocator_arg_t, const Alloc&, const function&); template function(allocator_arg_t, const Alloc&, function&&); template function(allocator_arg_t, const Alloc&, F); function& operator=(const function&); function& operator=(function&&) noexcept; function& operator=(nullptr_t) noexcept; template function& operator=(F&&); template function& operator=(reference_wrapper) noexcept; ~function(); // function modifiers: void swap(function&) noexcept; template void assign(F&&, const Alloc&); // function capacity: explicit operator bool() const noexcept; // function invocation: R operator()(ArgTypes...) const; // function target access: const std::type_info& target_type() const noexcept; template T* target() noexcept; template const T* target() const noexcept; }; // Null pointer comparisons: template bool operator==(const function&, nullptr_t) noexcept; template bool operator==(nullptr_t, const function&) noexcept; template bool operator!=(const function&, nullptr_t) noexcept; template bool operator!=(nullptr_t, const function&) noexcept; // specialized algorithms: template void swap(function&, function&) noexcept; template struct hash; template <> struct hash; template <> struct hash; template <> struct hash; template <> struct hash; template <> struct hash; template <> struct hash; template <> struct hash; template <> struct hash; template <> struct hash; template <> struct hash; template <> struct hash; template <> struct hash; template <> struct hash; template <> struct hash; template <> struct hash; template <> struct hash; template <> struct hash; template <> struct hash; template struct hash; } // std POLICY: For non-variadic implementations, the number of arguments is limited to 3. It is hoped that the need for non-variadic implementations will be minimal. */ #include <__config> #include #include #include #include #include #include <__functional_base> #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #pragma GCC system_header #endif _LIBCPP_BEGIN_NAMESPACE_STD #if _LIBCPP_STD_VER > 11 template #else template #endif struct _LIBCPP_TYPE_VIS_ONLY plus : binary_function<_Tp, _Tp, _Tp> { _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const {return __x + __y;} }; #if _LIBCPP_STD_VER > 11 template <> struct _LIBCPP_TYPE_VIS_ONLY plus { template _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY auto operator()(_T1&& __t, _T2&& __u) const { return _VSTD::forward<_T1>(__t) + _VSTD::forward<_T2>(__u); } typedef void is_transparent; }; #endif #if _LIBCPP_STD_VER > 11 template #else template #endif struct _LIBCPP_TYPE_VIS_ONLY minus : binary_function<_Tp, _Tp, _Tp> { _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const {return __x - __y;} }; #if _LIBCPP_STD_VER > 11 template <> struct _LIBCPP_TYPE_VIS_ONLY minus { template _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY auto operator()(_T1&& __t, _T2&& __u) const { return _VSTD::forward<_T1>(__t) - _VSTD::forward<_T2>(__u); } typedef void is_transparent; }; #endif #if _LIBCPP_STD_VER > 11 template #else template #endif struct _LIBCPP_TYPE_VIS_ONLY multiplies : binary_function<_Tp, _Tp, _Tp> { _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const {return __x * __y;} }; #if _LIBCPP_STD_VER > 11 template <> struct _LIBCPP_TYPE_VIS_ONLY multiplies { template _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY auto operator()(_T1&& __t, _T2&& __u) const { return _VSTD::forward<_T1>(__t) * _VSTD::forward<_T2>(__u); } typedef void is_transparent; }; #endif #if _LIBCPP_STD_VER > 11 template #else template #endif struct _LIBCPP_TYPE_VIS_ONLY divides : binary_function<_Tp, _Tp, _Tp> { _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const {return __x / __y;} }; #if _LIBCPP_STD_VER > 11 template <> struct _LIBCPP_TYPE_VIS_ONLY divides { template _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY auto operator()(_T1&& __t, _T2&& __u) const { return _VSTD::forward<_T1>(__t) / _VSTD::forward<_T2>(__u); } typedef void is_transparent; }; #endif #if _LIBCPP_STD_VER > 11 template #else template #endif struct _LIBCPP_TYPE_VIS_ONLY modulus : binary_function<_Tp, _Tp, _Tp> { _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const {return __x % __y;} }; #if _LIBCPP_STD_VER > 11 template <> struct _LIBCPP_TYPE_VIS_ONLY modulus { template _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY auto operator()(_T1&& __t, _T2&& __u) const { return _VSTD::forward<_T1>(__t) % _VSTD::forward<_T2>(__u); } typedef void is_transparent; }; #endif #if _LIBCPP_STD_VER > 11 template #else template #endif struct _LIBCPP_TYPE_VIS_ONLY negate : unary_function<_Tp, _Tp> { _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x) const {return -__x;} }; #if _LIBCPP_STD_VER > 11 template <> struct _LIBCPP_TYPE_VIS_ONLY negate { template _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY auto operator()(_Tp&& __x) const { return -_VSTD::forward<_Tp>(__x); } typedef void is_transparent; }; #endif #if _LIBCPP_STD_VER > 11 template #else template #endif struct _LIBCPP_TYPE_VIS_ONLY equal_to : binary_function<_Tp, _Tp, bool> { _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const {return __x == __y;} }; #if _LIBCPP_STD_VER > 11 template <> struct _LIBCPP_TYPE_VIS_ONLY equal_to { template _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY auto operator()(_T1&& __t, _T2&& __u) const { return _VSTD::forward<_T1>(__t) == _VSTD::forward<_T2>(__u); } typedef void is_transparent; }; #endif #if _LIBCPP_STD_VER > 11 template #else template #endif struct _LIBCPP_TYPE_VIS_ONLY not_equal_to : binary_function<_Tp, _Tp, bool> { _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const {return __x != __y;} }; #if _LIBCPP_STD_VER > 11 template <> struct _LIBCPP_TYPE_VIS_ONLY not_equal_to { template _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY auto operator()(_T1&& __t, _T2&& __u) const { return _VSTD::forward<_T1>(__t) != _VSTD::forward<_T2>(__u); } typedef void is_transparent; }; #endif #if _LIBCPP_STD_VER > 11 template #else template #endif struct _LIBCPP_TYPE_VIS_ONLY greater : binary_function<_Tp, _Tp, bool> { _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const {return __x > __y;} }; #if _LIBCPP_STD_VER > 11 template <> struct _LIBCPP_TYPE_VIS_ONLY greater { template _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY auto operator()(_T1&& __t, _T2&& __u) const { return _VSTD::forward<_T1>(__t) > _VSTD::forward<_T2>(__u); } typedef void is_transparent; }; #endif // less in <__functional_base> #if _LIBCPP_STD_VER > 11 template #else template #endif struct _LIBCPP_TYPE_VIS_ONLY greater_equal : binary_function<_Tp, _Tp, bool> { _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const {return __x >= __y;} }; #if _LIBCPP_STD_VER > 11 template <> struct _LIBCPP_TYPE_VIS_ONLY greater_equal { template _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY auto operator()(_T1&& __t, _T2&& __u) const { return _VSTD::forward<_T1>(__t) >= _VSTD::forward<_T2>(__u); } typedef void is_transparent; }; #endif #if _LIBCPP_STD_VER > 11 template #else template #endif struct _LIBCPP_TYPE_VIS_ONLY less_equal : binary_function<_Tp, _Tp, bool> { _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const {return __x <= __y;} }; #if _LIBCPP_STD_VER > 11 template <> struct _LIBCPP_TYPE_VIS_ONLY less_equal { template _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY auto operator()(_T1&& __t, _T2&& __u) const { return _VSTD::forward<_T1>(__t) <= _VSTD::forward<_T2>(__u); } typedef void is_transparent; }; #endif #if _LIBCPP_STD_VER > 11 template #else template #endif struct _LIBCPP_TYPE_VIS_ONLY logical_and : binary_function<_Tp, _Tp, bool> { _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const {return __x && __y;} }; #if _LIBCPP_STD_VER > 11 template <> struct _LIBCPP_TYPE_VIS_ONLY logical_and { template _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY auto operator()(_T1&& __t, _T2&& __u) const { return _VSTD::forward<_T1>(__t) && _VSTD::forward<_T2>(__u); } typedef void is_transparent; }; #endif #if _LIBCPP_STD_VER > 11 template #else template #endif struct _LIBCPP_TYPE_VIS_ONLY logical_or : binary_function<_Tp, _Tp, bool> { _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const {return __x || __y;} }; #if _LIBCPP_STD_VER > 11 template <> struct _LIBCPP_TYPE_VIS_ONLY logical_or { template _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY auto operator()(_T1&& __t, _T2&& __u) const { return _VSTD::forward<_T1>(__t) || _VSTD::forward<_T2>(__u); } typedef void is_transparent; }; #endif #if _LIBCPP_STD_VER > 11 template #else template #endif struct _LIBCPP_TYPE_VIS_ONLY logical_not : unary_function<_Tp, bool> { _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x) const {return !__x;} }; #if _LIBCPP_STD_VER > 11 template <> struct _LIBCPP_TYPE_VIS_ONLY logical_not { template _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY auto operator()(_Tp&& __x) const { return !_VSTD::forward<_Tp>(__x); } typedef void is_transparent; }; #endif #if _LIBCPP_STD_VER > 11 template #else template #endif struct _LIBCPP_TYPE_VIS_ONLY bit_and : binary_function<_Tp, _Tp, _Tp> { _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const {return __x & __y;} }; #if _LIBCPP_STD_VER > 11 template <> struct _LIBCPP_TYPE_VIS_ONLY bit_and { template _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY auto operator()(_T1&& __t, _T2&& __u) const { return _VSTD::forward<_T1>(__t) & _VSTD::forward<_T2>(__u); } typedef void is_transparent; }; #endif #if _LIBCPP_STD_VER > 11 template #else template #endif struct _LIBCPP_TYPE_VIS_ONLY bit_or : binary_function<_Tp, _Tp, _Tp> { _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const {return __x | __y;} }; #if _LIBCPP_STD_VER > 11 template <> struct _LIBCPP_TYPE_VIS_ONLY bit_or { template _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY auto operator()(_T1&& __t, _T2&& __u) const { return _VSTD::forward<_T1>(__t) | _VSTD::forward<_T2>(__u); } typedef void is_transparent; }; #endif #if _LIBCPP_STD_VER > 11 template #else template #endif struct _LIBCPP_TYPE_VIS_ONLY bit_xor : binary_function<_Tp, _Tp, _Tp> { _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const {return __x ^ __y;} }; #if _LIBCPP_STD_VER > 11 template <> struct _LIBCPP_TYPE_VIS_ONLY bit_xor { template _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY auto operator()(_T1&& __t, _T2&& __u) const { return _VSTD::forward<_T1>(__t) ^ _VSTD::forward<_T2>(__u); } typedef void is_transparent; }; #endif #if _LIBCPP_STD_VER > 11 template struct _LIBCPP_TYPE_VIS_ONLY bit_not : unary_function<_Tp, _Tp> { _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x) const {return ~__x;} }; template <> struct _LIBCPP_TYPE_VIS_ONLY bit_not { template _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY auto operator()(_Tp&& __x) const { return ~_VSTD::forward<_Tp>(__x); } typedef void is_transparent; }; #endif template class _LIBCPP_TYPE_VIS_ONLY unary_negate : public unary_function { _Predicate __pred_; public: _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY explicit unary_negate(const _Predicate& __pred) : __pred_(__pred) {} _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY bool operator()(const typename _Predicate::argument_type& __x) const {return !__pred_(__x);} }; template inline _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY unary_negate<_Predicate> not1(const _Predicate& __pred) {return unary_negate<_Predicate>(__pred);} template class _LIBCPP_TYPE_VIS_ONLY binary_negate : public binary_function { _Predicate __pred_; public: _LIBCPP_INLINE_VISIBILITY explicit _LIBCPP_CONSTEXPR_AFTER_CXX11 binary_negate(const _Predicate& __pred) : __pred_(__pred) {} _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY bool operator()(const typename _Predicate::first_argument_type& __x, const typename _Predicate::second_argument_type& __y) const {return !__pred_(__x, __y);} }; template inline _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY binary_negate<_Predicate> not2(const _Predicate& __pred) {return binary_negate<_Predicate>(__pred);} template class _LIBCPP_TYPE_VIS_ONLY binder1st : public unary_function { protected: __Operation op; typename __Operation::first_argument_type value; public: _LIBCPP_INLINE_VISIBILITY binder1st(const __Operation& __x, const typename __Operation::first_argument_type __y) : op(__x), value(__y) {} _LIBCPP_INLINE_VISIBILITY typename __Operation::result_type operator() (typename __Operation::second_argument_type& __x) const {return op(value, __x);} _LIBCPP_INLINE_VISIBILITY typename __Operation::result_type operator() (const typename __Operation::second_argument_type& __x) const {return op(value, __x);} }; template inline _LIBCPP_INLINE_VISIBILITY binder1st<__Operation> bind1st(const __Operation& __op, const _Tp& __x) {return binder1st<__Operation>(__op, __x);} template class _LIBCPP_TYPE_VIS_ONLY binder2nd : public unary_function { protected: __Operation op; typename __Operation::second_argument_type value; public: _LIBCPP_INLINE_VISIBILITY binder2nd(const __Operation& __x, const typename __Operation::second_argument_type __y) : op(__x), value(__y) {} _LIBCPP_INLINE_VISIBILITY typename __Operation::result_type operator() ( typename __Operation::first_argument_type& __x) const {return op(__x, value);} _LIBCPP_INLINE_VISIBILITY typename __Operation::result_type operator() (const typename __Operation::first_argument_type& __x) const {return op(__x, value);} }; template inline _LIBCPP_INLINE_VISIBILITY binder2nd<__Operation> bind2nd(const __Operation& __op, const _Tp& __x) {return binder2nd<__Operation>(__op, __x);} template class _LIBCPP_TYPE_VIS_ONLY pointer_to_unary_function : public unary_function<_Arg, _Result> { _Result (*__f_)(_Arg); public: _LIBCPP_INLINE_VISIBILITY explicit pointer_to_unary_function(_Result (*__f)(_Arg)) : __f_(__f) {} _LIBCPP_INLINE_VISIBILITY _Result operator()(_Arg __x) const {return __f_(__x);} }; template inline _LIBCPP_INLINE_VISIBILITY pointer_to_unary_function<_Arg,_Result> ptr_fun(_Result (*__f)(_Arg)) {return pointer_to_unary_function<_Arg,_Result>(__f);} template class _LIBCPP_TYPE_VIS_ONLY pointer_to_binary_function : public binary_function<_Arg1, _Arg2, _Result> { _Result (*__f_)(_Arg1, _Arg2); public: _LIBCPP_INLINE_VISIBILITY explicit pointer_to_binary_function(_Result (*__f)(_Arg1, _Arg2)) : __f_(__f) {} _LIBCPP_INLINE_VISIBILITY _Result operator()(_Arg1 __x, _Arg2 __y) const {return __f_(__x, __y);} }; template inline _LIBCPP_INLINE_VISIBILITY pointer_to_binary_function<_Arg1,_Arg2,_Result> ptr_fun(_Result (*__f)(_Arg1,_Arg2)) {return pointer_to_binary_function<_Arg1,_Arg2,_Result>(__f);} template class _LIBCPP_TYPE_VIS_ONLY mem_fun_t : public unary_function<_Tp*, _Sp> { _Sp (_Tp::*__p_)(); public: _LIBCPP_INLINE_VISIBILITY explicit mem_fun_t(_Sp (_Tp::*__p)()) : __p_(__p) {} _LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp* __p) const {return (__p->*__p_)();} }; template class _LIBCPP_TYPE_VIS_ONLY mem_fun1_t : public binary_function<_Tp*, _Ap, _Sp> { _Sp (_Tp::*__p_)(_Ap); public: _LIBCPP_INLINE_VISIBILITY explicit mem_fun1_t(_Sp (_Tp::*__p)(_Ap)) : __p_(__p) {} _LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp* __p, _Ap __x) const {return (__p->*__p_)(__x);} }; template inline _LIBCPP_INLINE_VISIBILITY mem_fun_t<_Sp,_Tp> mem_fun(_Sp (_Tp::*__f)()) {return mem_fun_t<_Sp,_Tp>(__f);} template inline _LIBCPP_INLINE_VISIBILITY mem_fun1_t<_Sp,_Tp,_Ap> mem_fun(_Sp (_Tp::*__f)(_Ap)) {return mem_fun1_t<_Sp,_Tp,_Ap>(__f);} template class _LIBCPP_TYPE_VIS_ONLY mem_fun_ref_t : public unary_function<_Tp, _Sp> { _Sp (_Tp::*__p_)(); public: _LIBCPP_INLINE_VISIBILITY explicit mem_fun_ref_t(_Sp (_Tp::*__p)()) : __p_(__p) {} _LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp& __p) const {return (__p.*__p_)();} }; template class _LIBCPP_TYPE_VIS_ONLY mem_fun1_ref_t : public binary_function<_Tp, _Ap, _Sp> { _Sp (_Tp::*__p_)(_Ap); public: _LIBCPP_INLINE_VISIBILITY explicit mem_fun1_ref_t(_Sp (_Tp::*__p)(_Ap)) : __p_(__p) {} _LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp& __p, _Ap __x) const {return (__p.*__p_)(__x);} }; template inline _LIBCPP_INLINE_VISIBILITY mem_fun_ref_t<_Sp,_Tp> mem_fun_ref(_Sp (_Tp::*__f)()) {return mem_fun_ref_t<_Sp,_Tp>(__f);} template inline _LIBCPP_INLINE_VISIBILITY mem_fun1_ref_t<_Sp,_Tp,_Ap> mem_fun_ref(_Sp (_Tp::*__f)(_Ap)) {return mem_fun1_ref_t<_Sp,_Tp,_Ap>(__f);} template class _LIBCPP_TYPE_VIS_ONLY const_mem_fun_t : public unary_function { _Sp (_Tp::*__p_)() const; public: _LIBCPP_INLINE_VISIBILITY explicit const_mem_fun_t(_Sp (_Tp::*__p)() const) : __p_(__p) {} _LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp* __p) const {return (__p->*__p_)();} }; template class _LIBCPP_TYPE_VIS_ONLY const_mem_fun1_t : public binary_function { _Sp (_Tp::*__p_)(_Ap) const; public: _LIBCPP_INLINE_VISIBILITY explicit const_mem_fun1_t(_Sp (_Tp::*__p)(_Ap) const) : __p_(__p) {} _LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp* __p, _Ap __x) const {return (__p->*__p_)(__x);} }; template inline _LIBCPP_INLINE_VISIBILITY const_mem_fun_t<_Sp,_Tp> mem_fun(_Sp (_Tp::*__f)() const) {return const_mem_fun_t<_Sp,_Tp>(__f);} template inline _LIBCPP_INLINE_VISIBILITY const_mem_fun1_t<_Sp,_Tp,_Ap> mem_fun(_Sp (_Tp::*__f)(_Ap) const) {return const_mem_fun1_t<_Sp,_Tp,_Ap>(__f);} template class _LIBCPP_TYPE_VIS_ONLY const_mem_fun_ref_t : public unary_function<_Tp, _Sp> { _Sp (_Tp::*__p_)() const; public: _LIBCPP_INLINE_VISIBILITY explicit const_mem_fun_ref_t(_Sp (_Tp::*__p)() const) : __p_(__p) {} _LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp& __p) const {return (__p.*__p_)();} }; template class _LIBCPP_TYPE_VIS_ONLY const_mem_fun1_ref_t : public binary_function<_Tp, _Ap, _Sp> { _Sp (_Tp::*__p_)(_Ap) const; public: _LIBCPP_INLINE_VISIBILITY explicit const_mem_fun1_ref_t(_Sp (_Tp::*__p)(_Ap) const) : __p_(__p) {} _LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp& __p, _Ap __x) const {return (__p.*__p_)(__x);} }; template inline _LIBCPP_INLINE_VISIBILITY const_mem_fun_ref_t<_Sp,_Tp> mem_fun_ref(_Sp (_Tp::*__f)() const) {return const_mem_fun_ref_t<_Sp,_Tp>(__f);} template inline _LIBCPP_INLINE_VISIBILITY const_mem_fun1_ref_t<_Sp,_Tp,_Ap> mem_fun_ref(_Sp (_Tp::*__f)(_Ap) const) {return const_mem_fun1_ref_t<_Sp,_Tp,_Ap>(__f);} #ifdef _LIBCPP_HAS_NO_VARIADICS #include <__functional_03> #else // _LIBCPP_HAS_NO_VARIADICS template class __mem_fn : public __weak_result_type<_Tp> { public: // types typedef _Tp type; private: type __f_; public: _LIBCPP_INLINE_VISIBILITY __mem_fn(type __f) : __f_(__f) {} // invoke template _LIBCPP_INLINE_VISIBILITY typename __invoke_return::type operator() (_ArgTypes&&... __args) const { return __invoke(__f_, _VSTD::forward<_ArgTypes>(__args)...); } }; template inline _LIBCPP_INLINE_VISIBILITY __mem_fn<_Rp _Tp::*> mem_fn(_Rp _Tp::* __pm) { return __mem_fn<_Rp _Tp::*>(__pm); } // bad_function_call class _LIBCPP_EXCEPTION_ABI bad_function_call : public exception { }; template class _LIBCPP_TYPE_VIS_ONLY function; // undefined namespace __function { template struct __maybe_derive_from_unary_function { }; template struct __maybe_derive_from_unary_function<_Rp(_A1)> : public unary_function<_A1, _Rp> { }; template struct __maybe_derive_from_binary_function { }; template struct __maybe_derive_from_binary_function<_Rp(_A1, _A2)> : public binary_function<_A1, _A2, _Rp> { }; template class __base; template class __base<_Rp(_ArgTypes...)> { __base(const __base&); __base& operator=(const __base&); public: _LIBCPP_INLINE_VISIBILITY __base() {} _LIBCPP_INLINE_VISIBILITY virtual ~__base() {} virtual __base* __clone() const = 0; virtual void __clone(__base*) const = 0; virtual void destroy() _NOEXCEPT = 0; virtual void destroy_deallocate() _NOEXCEPT = 0; virtual _Rp operator()(_ArgTypes&& ...) = 0; #ifndef _LIBCPP_NO_RTTI virtual const void* target(const type_info&) const _NOEXCEPT = 0; virtual const std::type_info& target_type() const _NOEXCEPT = 0; #endif // _LIBCPP_NO_RTTI }; template class __func; template class __func<_Fp, _Alloc, _Rp(_ArgTypes...)> : public __base<_Rp(_ArgTypes...)> { __compressed_pair<_Fp, _Alloc> __f_; public: _LIBCPP_INLINE_VISIBILITY explicit __func(_Fp&& __f) : __f_(piecewise_construct, _VSTD::forward_as_tuple(_VSTD::move(__f)), _VSTD::forward_as_tuple()) {} _LIBCPP_INLINE_VISIBILITY explicit __func(const _Fp& __f, const _Alloc& __a) : __f_(piecewise_construct, _VSTD::forward_as_tuple(__f), _VSTD::forward_as_tuple(__a)) {} _LIBCPP_INLINE_VISIBILITY explicit __func(const _Fp& __f, _Alloc&& __a) : __f_(piecewise_construct, _VSTD::forward_as_tuple(__f), _VSTD::forward_as_tuple(_VSTD::move(__a))) {} _LIBCPP_INLINE_VISIBILITY explicit __func(_Fp&& __f, _Alloc&& __a) : __f_(piecewise_construct, _VSTD::forward_as_tuple(_VSTD::move(__f)), _VSTD::forward_as_tuple(_VSTD::move(__a))) {} virtual __base<_Rp(_ArgTypes...)>* __clone() const; virtual void __clone(__base<_Rp(_ArgTypes...)>*) const; virtual void destroy() _NOEXCEPT; virtual void destroy_deallocate() _NOEXCEPT; virtual _Rp operator()(_ArgTypes&& ... __arg); #ifndef _LIBCPP_NO_RTTI virtual const void* target(const type_info&) const _NOEXCEPT; virtual const std::type_info& target_type() const _NOEXCEPT; #endif // _LIBCPP_NO_RTTI }; template __base<_Rp(_ArgTypes...)>* __func<_Fp, _Alloc, _Rp(_ArgTypes...)>::__clone() const { typedef typename _Alloc::template rebind<__func>::other _Ap; _Ap __a(__f_.second()); typedef __allocator_destructor<_Ap> _Dp; unique_ptr<__func, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); ::new (__hold.get()) __func(__f_.first(), _Alloc(__a)); return __hold.release(); } template void __func<_Fp, _Alloc, _Rp(_ArgTypes...)>::__clone(__base<_Rp(_ArgTypes...)>* __p) const { ::new (__p) __func(__f_.first(), __f_.second()); } template void __func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy() _NOEXCEPT { __f_.~__compressed_pair<_Fp, _Alloc>(); } template void __func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy_deallocate() _NOEXCEPT { typedef typename _Alloc::template rebind<__func>::other _Ap; _Ap __a(__f_.second()); __f_.~__compressed_pair<_Fp, _Alloc>(); __a.deallocate(this, 1); } template _Rp __func<_Fp, _Alloc, _Rp(_ArgTypes...)>::operator()(_ArgTypes&& ... __arg) { - return __invoke(__f_.first(), _VSTD::forward<_ArgTypes>(__arg)...); + typedef __invoke_void_return_wrapper<_Rp> _Invoker; + return _Invoker::__call(__f_.first(), _VSTD::forward<_ArgTypes>(__arg)...); } #ifndef _LIBCPP_NO_RTTI template const void* __func<_Fp, _Alloc, _Rp(_ArgTypes...)>::target(const type_info& __ti) const _NOEXCEPT { if (__ti == typeid(_Fp)) return &__f_.first(); return (const void*)0; } template const std::type_info& __func<_Fp, _Alloc, _Rp(_ArgTypes...)>::target_type() const _NOEXCEPT { return typeid(_Fp); } #endif // _LIBCPP_NO_RTTI } // __function template class _LIBCPP_TYPE_VIS_ONLY function<_Rp(_ArgTypes...)> : public __function::__maybe_derive_from_unary_function<_Rp(_ArgTypes...)>, public __function::__maybe_derive_from_binary_function<_Rp(_ArgTypes...)> { typedef __function::__base<_Rp(_ArgTypes...)> __base; typename aligned_storage<3*sizeof(void*)>::type __buf_; __base* __f_; template _LIBCPP_INLINE_VISIBILITY static bool __not_null(const _Fp&) {return true;} template _LIBCPP_INLINE_VISIBILITY static bool __not_null(_R2 (*__p)(_Ap...)) {return __p;} template _LIBCPP_INLINE_VISIBILITY static bool __not_null(_R2 (_Cp::*__p)(_Ap...)) {return __p;} template _LIBCPP_INLINE_VISIBILITY static bool __not_null(_R2 (_Cp::*__p)(_Ap...) const) {return __p;} template _LIBCPP_INLINE_VISIBILITY static bool __not_null(_R2 (_Cp::*__p)(_Ap...) volatile) {return __p;} template _LIBCPP_INLINE_VISIBILITY static bool __not_null(_R2 (_Cp::*__p)(_Ap...) const volatile) {return __p;} template _LIBCPP_INLINE_VISIBILITY static bool __not_null(const function<_R2(_Ap...)>& __p) {return !!__p;} template ::value && __invokable<_Fp&, _ArgTypes...>::value> struct __callable; template struct __callable<_Fp, true> { - static const bool value = + static const bool value = is_same::value || is_convertible::type, _Rp>::value; }; template struct __callable<_Fp, false> { static const bool value = false; }; public: typedef _Rp result_type; // construct/copy/destroy: _LIBCPP_INLINE_VISIBILITY function() _NOEXCEPT : __f_(0) {} _LIBCPP_INLINE_VISIBILITY function(nullptr_t) _NOEXCEPT : __f_(0) {} function(const function&); function(function&&) _NOEXCEPT; template function(_Fp, typename enable_if < __callable<_Fp>::value && !is_same<_Fp, function>::value >::type* = 0); template _LIBCPP_INLINE_VISIBILITY function(allocator_arg_t, const _Alloc&) _NOEXCEPT : __f_(0) {} template _LIBCPP_INLINE_VISIBILITY function(allocator_arg_t, const _Alloc&, nullptr_t) _NOEXCEPT : __f_(0) {} template function(allocator_arg_t, const _Alloc&, const function&); template function(allocator_arg_t, const _Alloc&, function&&); template function(allocator_arg_t, const _Alloc& __a, _Fp __f, typename enable_if<__callable<_Fp>::value>::type* = 0); function& operator=(const function&); function& operator=(function&&) _NOEXCEPT; function& operator=(nullptr_t) _NOEXCEPT; template typename enable_if < __callable::type>::value && !is_same::type, function>::value, function& >::type operator=(_Fp&&); ~function(); // function modifiers: void swap(function&) _NOEXCEPT; template _LIBCPP_INLINE_VISIBILITY void assign(_Fp&& __f, const _Alloc& __a) {function(allocator_arg, __a, _VSTD::forward<_Fp>(__f)).swap(*this);} // function capacity: _LIBCPP_INLINE_VISIBILITY _LIBCPP_EXPLICIT operator bool() const _NOEXCEPT {return __f_;} // deleted overloads close possible hole in the type system template bool operator==(const function<_R2(_ArgTypes2...)>&) const = delete; template bool operator!=(const function<_R2(_ArgTypes2...)>&) const = delete; public: // function invocation: _Rp operator()(_ArgTypes...) const; #ifndef _LIBCPP_NO_RTTI // function target access: const std::type_info& target_type() const _NOEXCEPT; template _Tp* target() _NOEXCEPT; template const _Tp* target() const _NOEXCEPT; #endif // _LIBCPP_NO_RTTI }; template function<_Rp(_ArgTypes...)>::function(const function& __f) { if (__f.__f_ == 0) __f_ = 0; else if (__f.__f_ == (const __base*)&__f.__buf_) { __f_ = (__base*)&__buf_; __f.__f_->__clone(__f_); } else __f_ = __f.__f_->__clone(); } template template function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc&, const function& __f) { if (__f.__f_ == 0) __f_ = 0; else if (__f.__f_ == (const __base*)&__f.__buf_) { __f_ = (__base*)&__buf_; __f.__f_->__clone(__f_); } else __f_ = __f.__f_->__clone(); } template function<_Rp(_ArgTypes...)>::function(function&& __f) _NOEXCEPT { if (__f.__f_ == 0) __f_ = 0; else if (__f.__f_ == (__base*)&__f.__buf_) { __f_ = (__base*)&__buf_; __f.__f_->__clone(__f_); } else { __f_ = __f.__f_; __f.__f_ = 0; } } template template function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc&, function&& __f) { if (__f.__f_ == 0) __f_ = 0; else if (__f.__f_ == (__base*)&__f.__buf_) { __f_ = (__base*)&__buf_; __f.__f_->__clone(__f_); } else { __f_ = __f.__f_; __f.__f_ = 0; } } template template function<_Rp(_ArgTypes...)>::function(_Fp __f, typename enable_if < __callable<_Fp>::value && !is_same<_Fp, function>::value >::type*) : __f_(0) { if (__not_null(__f)) { typedef __function::__func<_Fp, allocator<_Fp>, _Rp(_ArgTypes...)> _FF; if (sizeof(_FF) <= sizeof(__buf_) && is_nothrow_copy_constructible<_Fp>::value) { __f_ = (__base*)&__buf_; ::new (__f_) _FF(_VSTD::move(__f)); } else { typedef allocator<_FF> _Ap; _Ap __a; typedef __allocator_destructor<_Ap> _Dp; unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); ::new (__hold.get()) _FF(_VSTD::move(__f), allocator<_Fp>(__a)); __f_ = __hold.release(); } } } template template function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc& __a0, _Fp __f, typename enable_if<__callable<_Fp>::value>::type*) : __f_(0) { typedef allocator_traits<_Alloc> __alloc_traits; if (__not_null(__f)) { typedef __function::__func<_Fp, _Alloc, _Rp(_ArgTypes...)> _FF; typedef typename __alloc_traits::template #ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES rebind_alloc<_FF> #else rebind_alloc<_FF>::other #endif _Ap; _Ap __a(__a0); if (sizeof(_FF) <= sizeof(__buf_) && is_nothrow_copy_constructible<_Fp>::value && is_nothrow_copy_constructible<_Ap>::value) { __f_ = (__base*)&__buf_; ::new (__f_) _FF(_VSTD::move(__f), _Alloc(__a)); } else { typedef __allocator_destructor<_Ap> _Dp; unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); ::new (__hold.get()) _FF(_VSTD::move(__f), _Alloc(__a)); __f_ = __hold.release(); } } } template function<_Rp(_ArgTypes...)>& function<_Rp(_ArgTypes...)>::operator=(const function& __f) { function(__f).swap(*this); return *this; } template function<_Rp(_ArgTypes...)>& function<_Rp(_ArgTypes...)>::operator=(function&& __f) _NOEXCEPT { if (__f_ == (__base*)&__buf_) __f_->destroy(); else if (__f_) __f_->destroy_deallocate(); __f_ = 0; if (__f.__f_ == 0) __f_ = 0; else if (__f.__f_ == (__base*)&__f.__buf_) { __f_ = (__base*)&__buf_; __f.__f_->__clone(__f_); } else { __f_ = __f.__f_; __f.__f_ = 0; } return *this; } template function<_Rp(_ArgTypes...)>& function<_Rp(_ArgTypes...)>::operator=(nullptr_t) _NOEXCEPT { if (__f_ == (__base*)&__buf_) __f_->destroy(); else if (__f_) __f_->destroy_deallocate(); __f_ = 0; return *this; } template template typename enable_if < function<_Rp(_ArgTypes...)>::template __callable::type>::value && !is_same::type, function<_Rp(_ArgTypes...)>>::value, function<_Rp(_ArgTypes...)>& >::type function<_Rp(_ArgTypes...)>::operator=(_Fp&& __f) { function(_VSTD::forward<_Fp>(__f)).swap(*this); return *this; } template function<_Rp(_ArgTypes...)>::~function() { if (__f_ == (__base*)&__buf_) __f_->destroy(); else if (__f_) __f_->destroy_deallocate(); } template void function<_Rp(_ArgTypes...)>::swap(function& __f) _NOEXCEPT { if (__f_ == (__base*)&__buf_ && __f.__f_ == (__base*)&__f.__buf_) { typename aligned_storage::type __tempbuf; __base* __t = (__base*)&__tempbuf; __f_->__clone(__t); __f_->destroy(); __f_ = 0; __f.__f_->__clone((__base*)&__buf_); __f.__f_->destroy(); __f.__f_ = 0; __f_ = (__base*)&__buf_; __t->__clone((__base*)&__f.__buf_); __t->destroy(); __f.__f_ = (__base*)&__f.__buf_; } else if (__f_ == (__base*)&__buf_) { __f_->__clone((__base*)&__f.__buf_); __f_->destroy(); __f_ = __f.__f_; __f.__f_ = (__base*)&__f.__buf_; } else if (__f.__f_ == (__base*)&__f.__buf_) { __f.__f_->__clone((__base*)&__buf_); __f.__f_->destroy(); __f.__f_ = __f_; __f_ = (__base*)&__buf_; } else _VSTD::swap(__f_, __f.__f_); } template _Rp function<_Rp(_ArgTypes...)>::operator()(_ArgTypes... __arg) const { #ifndef _LIBCPP_NO_EXCEPTIONS if (__f_ == 0) throw bad_function_call(); #endif // _LIBCPP_NO_EXCEPTIONS return (*__f_)(_VSTD::forward<_ArgTypes>(__arg)...); } #ifndef _LIBCPP_NO_RTTI template const std::type_info& function<_Rp(_ArgTypes...)>::target_type() const _NOEXCEPT { if (__f_ == 0) return typeid(void); return __f_->target_type(); } template template _Tp* function<_Rp(_ArgTypes...)>::target() _NOEXCEPT { if (__f_ == 0) return (_Tp*)0; return (_Tp*)__f_->target(typeid(_Tp)); } template template const _Tp* function<_Rp(_ArgTypes...)>::target() const _NOEXCEPT { if (__f_ == 0) return (const _Tp*)0; return (const _Tp*)__f_->target(typeid(_Tp)); } #endif // _LIBCPP_NO_RTTI template inline _LIBCPP_INLINE_VISIBILITY bool operator==(const function<_Rp(_ArgTypes...)>& __f, nullptr_t) _NOEXCEPT {return !__f;} template inline _LIBCPP_INLINE_VISIBILITY bool operator==(nullptr_t, const function<_Rp(_ArgTypes...)>& __f) _NOEXCEPT {return !__f;} template inline _LIBCPP_INLINE_VISIBILITY bool operator!=(const function<_Rp(_ArgTypes...)>& __f, nullptr_t) _NOEXCEPT {return (bool)__f;} template inline _LIBCPP_INLINE_VISIBILITY bool operator!=(nullptr_t, const function<_Rp(_ArgTypes...)>& __f) _NOEXCEPT {return (bool)__f;} template inline _LIBCPP_INLINE_VISIBILITY void swap(function<_Rp(_ArgTypes...)>& __x, function<_Rp(_ArgTypes...)>& __y) _NOEXCEPT {return __x.swap(__y);} template struct __is_bind_expression : public false_type {}; template struct _LIBCPP_TYPE_VIS_ONLY is_bind_expression : public __is_bind_expression::type> {}; template struct __is_placeholder : public integral_constant {}; template struct _LIBCPP_TYPE_VIS_ONLY is_placeholder : public __is_placeholder::type> {}; namespace placeholders { template struct __ph {}; _LIBCPP_FUNC_VIS extern __ph<1> _1; _LIBCPP_FUNC_VIS extern __ph<2> _2; _LIBCPP_FUNC_VIS extern __ph<3> _3; _LIBCPP_FUNC_VIS extern __ph<4> _4; _LIBCPP_FUNC_VIS extern __ph<5> _5; _LIBCPP_FUNC_VIS extern __ph<6> _6; _LIBCPP_FUNC_VIS extern __ph<7> _7; _LIBCPP_FUNC_VIS extern __ph<8> _8; _LIBCPP_FUNC_VIS extern __ph<9> _9; _LIBCPP_FUNC_VIS extern __ph<10> _10; } // placeholders template struct __is_placeholder > : public integral_constant {}; template inline _LIBCPP_INLINE_VISIBILITY _Tp& __mu(reference_wrapper<_Tp> __t, _Uj&) { return __t.get(); } template inline _LIBCPP_INLINE_VISIBILITY typename __invoke_of<_Ti&, _Uj...>::type __mu_expand(_Ti& __ti, tuple<_Uj...>& __uj, __tuple_indices<_Indx...>) { return __ti(_VSTD::forward<_Uj>(_VSTD::get<_Indx>(__uj))...); } template inline _LIBCPP_INLINE_VISIBILITY typename __lazy_enable_if < is_bind_expression<_Ti>::value, __invoke_of<_Ti&, _Uj...> >::type __mu(_Ti& __ti, tuple<_Uj...>& __uj) { typedef typename __make_tuple_indices::type __indices; return __mu_expand(__ti, __uj, __indices()); } template struct __mu_return2 {}; template struct __mu_return2 { typedef typename tuple_element::value - 1, _Uj>::type type; }; template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < 0 < is_placeholder<_Ti>::value, typename __mu_return2<0 < is_placeholder<_Ti>::value, _Ti, _Uj>::type >::type __mu(_Ti&, _Uj& __uj) { const size_t _Indx = is_placeholder<_Ti>::value - 1; return _VSTD::forward::type>(_VSTD::get<_Indx>(__uj)); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < !is_bind_expression<_Ti>::value && is_placeholder<_Ti>::value == 0 && !__is_reference_wrapper<_Ti>::value, _Ti& >::type __mu(_Ti& __ti, _Uj&) { return __ti; } template struct ____mu_return; template struct ____mu_return_invokable // false { typedef __nat type; }; template struct ____mu_return_invokable { typedef typename __invoke_of<_Ti&, _Uj...>::type type; }; template struct ____mu_return<_Ti, false, true, false, tuple<_Uj...> > : public ____mu_return_invokable<__invokable<_Ti&, _Uj...>::value, _Ti, _Uj...> { }; template struct ____mu_return<_Ti, false, false, true, _TupleUj> { typedef typename tuple_element::value - 1, _TupleUj>::type&& type; }; template struct ____mu_return<_Ti, true, false, false, _TupleUj> { typedef typename _Ti::type& type; }; template struct ____mu_return<_Ti, false, false, false, _TupleUj> { typedef _Ti& type; }; template struct __mu_return : public ____mu_return<_Ti, __is_reference_wrapper<_Ti>::value, is_bind_expression<_Ti>::value, 0 < is_placeholder<_Ti>::value && is_placeholder<_Ti>::value <= tuple_size<_TupleUj>::value, _TupleUj> { }; template struct _is_valid_bind_return { static const bool value = false; }; template struct _is_valid_bind_return<_Fp, tuple<_BoundArgs...>, _TupleUj> { static const bool value = __invokable<_Fp, typename __mu_return<_BoundArgs, _TupleUj>::type...>::value; }; template struct _is_valid_bind_return<_Fp, const tuple<_BoundArgs...>, _TupleUj> { static const bool value = __invokable<_Fp, typename __mu_return::type...>::value; }; template ::value> struct __bind_return; template struct __bind_return<_Fp, tuple<_BoundArgs...>, _TupleUj, true> { typedef typename __invoke_of < _Fp&, typename __mu_return < _BoundArgs, _TupleUj >::type... >::type type; }; template struct __bind_return<_Fp, const tuple<_BoundArgs...>, _TupleUj, true> { typedef typename __invoke_of < _Fp&, typename __mu_return < const _BoundArgs, _TupleUj >::type... >::type type; }; template inline _LIBCPP_INLINE_VISIBILITY typename __bind_return<_Fp, _BoundArgs, _Args>::type __apply_functor(_Fp& __f, _BoundArgs& __bound_args, __tuple_indices<_Indx...>, _Args&& __args) { return __invoke(__f, __mu(_VSTD::get<_Indx>(__bound_args), __args)...); } template class __bind : public __weak_result_type::type> { protected: typedef typename decay<_Fp>::type _Fd; typedef tuple::type...> _Td; private: _Fd __f_; _Td __bound_args_; typedef typename __make_tuple_indices::type __indices; public: #ifdef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS _LIBCPP_INLINE_VISIBILITY __bind(const __bind& __b) : __f_(__b.__f_), __bound_args_(__b.__bound_args_) {} _LIBCPP_INLINE_VISIBILITY __bind& operator=(const __bind& __b) { __f_ = __b.__f_; __bound_args_ = __b.__bound_args_; return *this; } _LIBCPP_INLINE_VISIBILITY __bind(__bind&& __b) : __f_(_VSTD::move(__b.__f_)), __bound_args_(_VSTD::move(__b.__bound_args_)) {} _LIBCPP_INLINE_VISIBILITY __bind& operator=(__bind&& __b) { __f_ = _VSTD::move(__b.__f_); __bound_args_ = _VSTD::move(__b.__bound_args_); return *this; } #endif // _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS template ::value && !is_same::type, __bind>::value >::type> _LIBCPP_INLINE_VISIBILITY explicit __bind(_Gp&& __f, _BA&& ...__bound_args) : __f_(_VSTD::forward<_Gp>(__f)), __bound_args_(_VSTD::forward<_BA>(__bound_args)...) {} template _LIBCPP_INLINE_VISIBILITY typename __bind_return<_Fd, _Td, tuple<_Args&&...> >::type operator()(_Args&& ...__args) { return __apply_functor(__f_, __bound_args_, __indices(), tuple<_Args&&...>(_VSTD::forward<_Args>(__args)...)); } template _LIBCPP_INLINE_VISIBILITY typename __bind_return >::type operator()(_Args&& ...__args) const { return __apply_functor(__f_, __bound_args_, __indices(), tuple<_Args&&...>(_VSTD::forward<_Args>(__args)...)); } }; template struct __is_bind_expression<__bind<_Fp, _BoundArgs...> > : public true_type {}; template class __bind_r : public __bind<_Fp, _BoundArgs...> { typedef __bind<_Fp, _BoundArgs...> base; typedef typename base::_Fd _Fd; typedef typename base::_Td _Td; public: typedef _Rp result_type; #ifdef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS _LIBCPP_INLINE_VISIBILITY __bind_r(const __bind_r& __b) : base(_VSTD::forward(__b)) {} _LIBCPP_INLINE_VISIBILITY __bind_r& operator=(const __bind_r& __b) { base::operator=(_VSTD::forward(__b)); return *this; } _LIBCPP_INLINE_VISIBILITY __bind_r(__bind_r&& __b) : base(_VSTD::forward(__b)) {} _LIBCPP_INLINE_VISIBILITY __bind_r& operator=(__bind_r&& __b) { base::operator=(_VSTD::forward(__b)); return *this; } #endif // _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS template ::value && !is_same::type, __bind_r>::value >::type> _LIBCPP_INLINE_VISIBILITY explicit __bind_r(_Gp&& __f, _BA&& ...__bound_args) : base(_VSTD::forward<_Gp>(__f), _VSTD::forward<_BA>(__bound_args)...) {} template _LIBCPP_INLINE_VISIBILITY typename enable_if < is_convertible >::type, result_type>::value, result_type >::type operator()(_Args&& ...__args) { return base::operator()(_VSTD::forward<_Args>(__args)...); } template _LIBCPP_INLINE_VISIBILITY typename enable_if < is_convertible >::type, result_type>::value, result_type >::type operator()(_Args&& ...__args) const { return base::operator()(_VSTD::forward<_Args>(__args)...); } }; template struct __is_bind_expression<__bind_r<_Rp, _Fp, _BoundArgs...> > : public true_type {}; template inline _LIBCPP_INLINE_VISIBILITY __bind<_Fp, _BoundArgs...> bind(_Fp&& __f, _BoundArgs&&... __bound_args) { typedef __bind<_Fp, _BoundArgs...> type; return type(_VSTD::forward<_Fp>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...); } template inline _LIBCPP_INLINE_VISIBILITY __bind_r<_Rp, _Fp, _BoundArgs...> bind(_Fp&& __f, _BoundArgs&&... __bound_args) { typedef __bind_r<_Rp, _Fp, _BoundArgs...> type; return type(_VSTD::forward<_Fp>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...); } #endif // _LIBCPP_HAS_NO_VARIADICS template <> struct _LIBCPP_TYPE_VIS_ONLY hash : public unary_function { _LIBCPP_INLINE_VISIBILITY size_t operator()(bool __v) const _NOEXCEPT {return static_cast(__v);} }; template <> struct _LIBCPP_TYPE_VIS_ONLY hash : public unary_function { _LIBCPP_INLINE_VISIBILITY size_t operator()(char __v) const _NOEXCEPT {return static_cast(__v);} }; template <> struct _LIBCPP_TYPE_VIS_ONLY hash : public unary_function { _LIBCPP_INLINE_VISIBILITY size_t operator()(signed char __v) const _NOEXCEPT {return static_cast(__v);} }; template <> struct _LIBCPP_TYPE_VIS_ONLY hash : public unary_function { _LIBCPP_INLINE_VISIBILITY size_t operator()(unsigned char __v) const _NOEXCEPT {return static_cast(__v);} }; #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS template <> struct _LIBCPP_TYPE_VIS_ONLY hash : public unary_function { _LIBCPP_INLINE_VISIBILITY size_t operator()(char16_t __v) const _NOEXCEPT {return static_cast(__v);} }; template <> struct _LIBCPP_TYPE_VIS_ONLY hash : public unary_function { _LIBCPP_INLINE_VISIBILITY size_t operator()(char32_t __v) const _NOEXCEPT {return static_cast(__v);} }; #endif // _LIBCPP_HAS_NO_UNICODE_CHARS template <> struct _LIBCPP_TYPE_VIS_ONLY hash : public unary_function { _LIBCPP_INLINE_VISIBILITY size_t operator()(wchar_t __v) const _NOEXCEPT {return static_cast(__v);} }; template <> struct _LIBCPP_TYPE_VIS_ONLY hash : public unary_function { _LIBCPP_INLINE_VISIBILITY size_t operator()(short __v) const _NOEXCEPT {return static_cast(__v);} }; template <> struct _LIBCPP_TYPE_VIS_ONLY hash : public unary_function { _LIBCPP_INLINE_VISIBILITY size_t operator()(unsigned short __v) const _NOEXCEPT {return static_cast(__v);} }; template <> struct _LIBCPP_TYPE_VIS_ONLY hash : public unary_function { _LIBCPP_INLINE_VISIBILITY size_t operator()(int __v) const _NOEXCEPT {return static_cast(__v);} }; template <> struct _LIBCPP_TYPE_VIS_ONLY hash : public unary_function { _LIBCPP_INLINE_VISIBILITY size_t operator()(unsigned int __v) const _NOEXCEPT {return static_cast(__v);} }; template <> struct _LIBCPP_TYPE_VIS_ONLY hash : public unary_function { _LIBCPP_INLINE_VISIBILITY size_t operator()(long __v) const _NOEXCEPT {return static_cast(__v);} }; template <> struct _LIBCPP_TYPE_VIS_ONLY hash : public unary_function { _LIBCPP_INLINE_VISIBILITY size_t operator()(unsigned long __v) const _NOEXCEPT {return static_cast(__v);} }; template <> struct _LIBCPP_TYPE_VIS_ONLY hash : public __scalar_hash { }; template <> struct _LIBCPP_TYPE_VIS_ONLY hash : public __scalar_hash { }; template <> struct _LIBCPP_TYPE_VIS_ONLY hash : public __scalar_hash { _LIBCPP_INLINE_VISIBILITY size_t operator()(float __v) const _NOEXCEPT { // -0.0 and 0.0 should return same hash if (__v == 0) return 0; return __scalar_hash::operator()(__v); } }; template <> struct _LIBCPP_TYPE_VIS_ONLY hash : public __scalar_hash { _LIBCPP_INLINE_VISIBILITY size_t operator()(double __v) const _NOEXCEPT { // -0.0 and 0.0 should return same hash if (__v == 0) return 0; return __scalar_hash::operator()(__v); } }; template <> struct _LIBCPP_TYPE_VIS_ONLY hash : public __scalar_hash { _LIBCPP_INLINE_VISIBILITY size_t operator()(long double __v) const _NOEXCEPT { // -0.0 and 0.0 should return same hash if (__v == 0) return 0; #if defined(__i386__) // Zero out padding bits union { long double __t; struct { size_t __a; size_t __b; size_t __c; size_t __d; }; } __u; __u.__a = 0; __u.__b = 0; __u.__c = 0; __u.__d = 0; __u.__t = __v; return __u.__a ^ __u.__b ^ __u.__c ^ __u.__d; #elif defined(__x86_64__) // Zero out padding bits union { long double __t; struct { size_t __a; size_t __b; }; } __u; __u.__a = 0; __u.__b = 0; __u.__t = __v; return __u.__a ^ __u.__b; #else return __scalar_hash::operator()(__v); #endif } }; #if _LIBCPP_STD_VER > 11 template struct _LIBCPP_TYPE_VIS_ONLY hash : public unary_function<_Tp, size_t> { static_assert(is_enum<_Tp>::value, "This hash only works for enumeration types"); _LIBCPP_INLINE_VISIBILITY size_t operator()(_Tp __v) const _NOEXCEPT { typedef typename underlying_type<_Tp>::type type; return hash{}(static_cast(__v)); } }; #endif // struct hash in _LIBCPP_END_NAMESPACE_STD #endif // _LIBCPP_FUNCTIONAL