generic-library/cxx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Further macro protection by replacing _[A-Z] with _[A-Z]p

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@145410 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Howard Hinnant
2011-11-29 18:15:50 +00:00
parent 66c6f9733b
commit 9996844df0
38 changed files with 2831 additions and 2831 deletions
Download Patch File Download Diff File Expand all files Collapse all files

450
include/functional
View File

@@ -198,7 +198,7 @@ namespace placeholders {
.
.
.
extern unspecified _M;
extern unspecified _Mp;
}
template <class Operation>
@@ -890,44 +890,44 @@ public:
}
};
template<class _R, class _T>
template<class _Rp, class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
__mem_fn<_R _T::*>
mem_fn(_R _T::* __pm)
__mem_fn<_Rp _Tp::*>
mem_fn(_Rp _Tp::* __pm)
{
return __mem_fn<_R _T::*>(__pm);
return __mem_fn<_Rp _Tp::*>(__pm);
}
template<class _R, class _T, class ..._Args>
template<class _Rp, class _Tp, class ..._Args>
inline _LIBCPP_INLINE_VISIBILITY
__mem_fn<_R (_T::*)(_Args...)>
mem_fn(_R (_T::* __pm)(_Args...))
__mem_fn<_Rp (_Tp::*)(_Args...)>
mem_fn(_Rp (_Tp::* __pm)(_Args...))
{
return __mem_fn<_R (_T::*)(_Args...)>(__pm);
return __mem_fn<_Rp (_Tp::*)(_Args...)>(__pm);
}
template<class _R, class _T, class ..._Args>
template<class _Rp, class _Tp, class ..._Args>
inline _LIBCPP_INLINE_VISIBILITY
__mem_fn<_R (_T::*)(_Args...) const>
mem_fn(_R (_T::* __pm)(_Args...) const)
__mem_fn<_Rp (_Tp::*)(_Args...) const>
mem_fn(_Rp (_Tp::* __pm)(_Args...) const)
{
return __mem_fn<_R (_T::*)(_Args...) const>(__pm);
return __mem_fn<_Rp (_Tp::*)(_Args...) const>(__pm);
}
template<class _R, class _T, class ..._Args>
template<class _Rp, class _Tp, class ..._Args>
inline _LIBCPP_INLINE_VISIBILITY
__mem_fn<_R (_T::*)(_Args...) volatile>
mem_fn(_R (_T::* __pm)(_Args...) volatile)
__mem_fn<_Rp (_Tp::*)(_Args...) volatile>
mem_fn(_Rp (_Tp::* __pm)(_Args...) volatile)
{
return __mem_fn<_R (_T::*)(_Args...) volatile>(__pm);
return __mem_fn<_Rp (_Tp::*)(_Args...) volatile>(__pm);
}
template<class _R, class _T, class ..._Args>
template<class _Rp, class _Tp, class ..._Args>
inline _LIBCPP_INLINE_VISIBILITY
__mem_fn<_R (_T::*)(_Args...) const volatile>
mem_fn(_R (_T::* __pm)(_Args...) const volatile)
__mem_fn<_Rp (_Tp::*)(_Args...) const volatile>
mem_fn(_Rp (_Tp::* __pm)(_Args...) const volatile)
{
return __mem_fn<_R (_T::*)(_Args...) const volatile>(__pm);
return __mem_fn<_Rp (_Tp::*)(_Args...) const volatile>(__pm);
}
// bad_function_call
@@ -942,32 +942,32 @@ template<class _Fp> class _LIBCPP_VISIBLE function; // undefined
namespace __function
{
template<class _R, class ..._ArgTypes>
template<class _Rp, class ..._ArgTypes>
struct __maybe_derive_from_unary_function
{
};
template<class _R, class _A1>
struct __maybe_derive_from_unary_function<_R(_A1)>
: public unary_function<_A1, _R>
template<class _Rp, class _A1>
struct __maybe_derive_from_unary_function<_Rp(_A1)>
: public unary_function<_A1, _Rp>
{
};
template<class _R, class ..._ArgTypes>
template<class _Rp, class ..._ArgTypes>
struct __maybe_derive_from_binary_function
{
};
template<class _R, class _A1, class _A2>
struct __maybe_derive_from_binary_function<_R(_A1, _A2)>
: public binary_function<_A1, _A2, _R>
template<class _Rp, class _A1, class _A2>
struct __maybe_derive_from_binary_function<_Rp(_A1, _A2)>
: public binary_function<_A1, _A2, _Rp>
{
};
template<class _Fp> class __base;
template<class _R, class ..._ArgTypes>
class __base<_R(_ArgTypes...)>
template<class _Rp, class ..._ArgTypes>
class __base<_Rp(_ArgTypes...)>
{
__base(const __base&);
__base& operator=(const __base&);
@@ -978,7 +978,7 @@ public:
virtual void __clone(__base*) const = 0;
virtual void destroy() _NOEXCEPT = 0;
virtual void destroy_deallocate() _NOEXCEPT = 0;
virtual _R operator()(_ArgTypes&& ...) = 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;
@@ -987,139 +987,139 @@ public:
template<class _FD, class _Alloc, class _FB> class __func;
template<class _F, class _Alloc, class _R, class ..._ArgTypes>
class __func<_F, _Alloc, _R(_ArgTypes...)>
: public __base<_R(_ArgTypes...)>
template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
class __func<_Fp, _Alloc, _Rp(_ArgTypes...)>
: public __base<_Rp(_ArgTypes...)>
{
__compressed_pair<_F, _Alloc> __f_;
__compressed_pair<_Fp, _Alloc> __f_;
public:
_LIBCPP_INLINE_VISIBILITY
explicit __func(_F __f) : __f_(_VSTD::move(__f)) {}
explicit __func(_Fp __f) : __f_(_VSTD::move(__f)) {}
_LIBCPP_INLINE_VISIBILITY
explicit __func(_F __f, _Alloc __a) : __f_(_VSTD::move(__f), _VSTD::move(__a)) {}
virtual __base<_R(_ArgTypes...)>* __clone() const;
virtual void __clone(__base<_R(_ArgTypes...)>*) const;
explicit __func(_Fp __f, _Alloc __a) : __f_(_VSTD::move(__f), _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 _R operator()(_ArgTypes&& ... __arg);
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<class _F, class _Alloc, class _R, class ..._ArgTypes>
__base<_R(_ArgTypes...)>*
__func<_F, _Alloc, _R(_ArgTypes...)>::__clone() const
template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
__base<_Rp(_ArgTypes...)>*
__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::__clone() const
{
typedef typename _Alloc::template rebind<__func>::other _A;
_A __a(__f_.second());
typedef __allocator_destructor<_A> _D;
unique_ptr<__func, _D> __hold(__a.allocate(1), _D(__a, 1));
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<class _F, class _Alloc, class _R, class ..._ArgTypes>
template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
void
__func<_F, _Alloc, _R(_ArgTypes...)>::__clone(__base<_R(_ArgTypes...)>* __p) const
__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::__clone(__base<_Rp(_ArgTypes...)>* __p) const
{
::new (__p) __func(__f_.first(), __f_.second());
}
template<class _F, class _Alloc, class _R, class ..._ArgTypes>
template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
void
__func<_F, _Alloc, _R(_ArgTypes...)>::destroy() _NOEXCEPT
__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy() _NOEXCEPT
{
__f_.~__compressed_pair<_F, _Alloc>();
__f_.~__compressed_pair<_Fp, _Alloc>();
}
template<class _F, class _Alloc, class _R, class ..._ArgTypes>
template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
void
__func<_F, _Alloc, _R(_ArgTypes...)>::destroy_deallocate() _NOEXCEPT
__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy_deallocate() _NOEXCEPT
{
typedef typename _Alloc::template rebind<__func>::other _A;
_A __a(__f_.second());
__f_.~__compressed_pair<_F, _Alloc>();
typedef typename _Alloc::template rebind<__func>::other _Ap;
_Ap __a(__f_.second());
__f_.~__compressed_pair<_Fp, _Alloc>();
__a.deallocate(this, 1);
}
template<class _F, class _Alloc, class _R, class ..._ArgTypes>
_R
__func<_F, _Alloc, _R(_ArgTypes...)>::operator()(_ArgTypes&& ... __arg)
template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
_Rp
__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::operator()(_ArgTypes&& ... __arg)
{
return __invoke(__f_.first(), _VSTD::forward<_ArgTypes>(__arg)...);
}
#ifndef _LIBCPP_NO_RTTI
template<class _F, class _Alloc, class _R, class ..._ArgTypes>
template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
const void*
__func<_F, _Alloc, _R(_ArgTypes...)>::target(const type_info& __ti) const _NOEXCEPT
__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::target(const type_info& __ti) const _NOEXCEPT
{
if (__ti == typeid(_F))
if (__ti == typeid(_Fp))
return &__f_.first();
return (const void*)0;
}
template<class _F, class _Alloc, class _R, class ..._ArgTypes>
template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
const std::type_info&
__func<_F, _Alloc, _R(_ArgTypes...)>::target_type() const _NOEXCEPT
__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::target_type() const _NOEXCEPT
{
return typeid(_F);
return typeid(_Fp);
}
#endif // _LIBCPP_NO_RTTI
} // __function
template<class _R, class ..._ArgTypes>
class _LIBCPP_VISIBLE function<_R(_ArgTypes...)>
: public __function::__maybe_derive_from_unary_function<_R(_ArgTypes...)>,
public __function::__maybe_derive_from_binary_function<_R(_ArgTypes...)>
template<class _Rp, class ..._ArgTypes>
class _LIBCPP_VISIBLE function<_Rp(_ArgTypes...)>
: public __function::__maybe_derive_from_unary_function<_Rp(_ArgTypes...)>,
public __function::__maybe_derive_from_binary_function<_Rp(_ArgTypes...)>
{
typedef __function::__base<_R(_ArgTypes...)> __base;
typedef __function::__base<_Rp(_ArgTypes...)> __base;
aligned_storage<3*sizeof(void*)>::type __buf_;
__base* __f_;
template <class _F>
template <class _Fp>
_LIBCPP_INLINE_VISIBILITY
static bool __not_null(const _F&) {return true;}
template <class _R2, class ..._A>
static bool __not_null(const _Fp&) {return true;}
template <class _R2, class ..._Ap>
_LIBCPP_INLINE_VISIBILITY
static bool __not_null(_R2 (*__p)(_A...)) {return __p;}
template <class _R2, class _C, class ..._A>
static bool __not_null(_R2 (*__p)(_Ap...)) {return __p;}
template <class _R2, class _Cp, class ..._Ap>
_LIBCPP_INLINE_VISIBILITY
static bool __not_null(_R2 (_C::*__p)(_A...)) {return __p;}
template <class _R2, class _C, class ..._A>
static bool __not_null(_R2 (_Cp::*__p)(_Ap...)) {return __p;}
template <class _R2, class _Cp, class ..._Ap>
_LIBCPP_INLINE_VISIBILITY
static bool __not_null(_R2 (_C::*__p)(_A...) const) {return __p;}
template <class _R2, class _C, class ..._A>
static bool __not_null(_R2 (_Cp::*__p)(_Ap...) const) {return __p;}
template <class _R2, class _Cp, class ..._Ap>
_LIBCPP_INLINE_VISIBILITY
static bool __not_null(_R2 (_C::*__p)(_A...) volatile) {return __p;}
template <class _R2, class _C, class ..._A>
static bool __not_null(_R2 (_Cp::*__p)(_Ap...) volatile) {return __p;}
template <class _R2, class _Cp, class ..._Ap>
_LIBCPP_INLINE_VISIBILITY
static bool __not_null(_R2 (_C::*__p)(_A...) const volatile) {return __p;}
template <class _R2, class ..._A>
static bool __not_null(_R2 (_Cp::*__p)(_Ap...) const volatile) {return __p;}
template <class _R2, class ..._Ap>
_LIBCPP_INLINE_VISIBILITY
static bool __not_null(const function<_R(_A...)>& __p) {return __p;}
static bool __not_null(const function<_Rp(_Ap...)>& __p) {return __p;}
template <class _F, bool = __invokable<_F&, _ArgTypes...>::value>
template <class _Fp, bool = __invokable<_Fp&, _ArgTypes...>::value>
struct __callable;
template <class _F>
struct __callable<_F, true>
template <class _Fp>
struct __callable<_Fp, true>
{
static const bool value =
is_convertible<typename __invoke_of<_F&, _ArgTypes...>::type,
_R>::value;
is_convertible<typename __invoke_of<_Fp&, _ArgTypes...>::type,
_Rp>::value;
};
template <class _F>
struct __callable<_F, false>
template <class _Fp>
struct __callable<_Fp, false>
{
static const bool value = false;
};
public:
typedef _R result_type;
typedef _Rp result_type;
// construct/copy/destroy:
_LIBCPP_INLINE_VISIBILITY
@@ -1128,9 +1128,9 @@ public:
function(nullptr_t) _NOEXCEPT : __f_(0) {}
function(const function&);
function(function&&) _NOEXCEPT;
template<class _F>
function(_F,
typename enable_if<__callable<_F>::value>::type* = 0);
template<class _Fp>
function(_Fp,
typename enable_if<__callable<_Fp>::value>::type* = 0);
template<class _Alloc>
_LIBCPP_INLINE_VISIBILITY
@@ -1142,29 +1142,29 @@ public:
function(allocator_arg_t, const _Alloc&, const function&);
template<class _Alloc>
function(allocator_arg_t, const _Alloc&, function&&);
template<class _F, class _Alloc>
function(allocator_arg_t, const _Alloc& __a, _F __f,
typename enable_if<__callable<_F>::value>::type* = 0);
template<class _Fp, class _Alloc>
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<class _F>
template<class _Fp>
typename enable_if
<
__callable<typename decay<_F>::type>::value,
__callable<typename decay<_Fp>::type>::value,
function&
>::type
operator=(_F&&);
operator=(_Fp&&);
~function();
// function modifiers:
void swap(function&) _NOEXCEPT;
template<class _F, class _Alloc>
template<class _Fp, class _Alloc>
_LIBCPP_INLINE_VISIBILITY
void assign(_F&& __f, const _Alloc& __a)
{function(allocator_arg, __a, _VSTD::forward<_F>(__f)).swap(*this);}
void assign(_Fp&& __f, const _Alloc& __a)
{function(allocator_arg, __a, _VSTD::forward<_Fp>(__f)).swap(*this);}
// function capacity:
_LIBCPP_INLINE_VISIBILITY
@@ -1177,18 +1177,18 @@ public:
bool operator!=(const function<_R2(_ArgTypes2...)>&) const = delete;
public:
// function invocation:
_R operator()(_ArgTypes...) const;
_Rp operator()(_ArgTypes...) const;
#ifndef _LIBCPP_NO_RTTI
// function target access:
const std::type_info& target_type() const _NOEXCEPT;
template <typename _T> _T* target() _NOEXCEPT;
template <typename _T> const _T* target() const _NOEXCEPT;
template <typename _Tp> _Tp* target() _NOEXCEPT;
template <typename _Tp> const _Tp* target() const _NOEXCEPT;
#endif // _LIBCPP_NO_RTTI
};
template<class _R, class ..._ArgTypes>
function<_R(_ArgTypes...)>::function(const function& __f)
template<class _Rp, class ..._ArgTypes>
function<_Rp(_ArgTypes...)>::function(const function& __f)
{
if (__f.__f_ == 0)
__f_ = 0;
@@ -1201,9 +1201,9 @@ function<_R(_ArgTypes...)>::function(const function& __f)
__f_ = __f.__f_->__clone();
}
template<class _R, class ..._ArgTypes>
template<class _Rp, class ..._ArgTypes>
template <class _Alloc>
function<_R(_ArgTypes...)>::function(allocator_arg_t, const _Alloc&,
function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc&,
const function& __f)
{
if (__f.__f_ == 0)
@@ -1217,8 +1217,8 @@ function<_R(_ArgTypes...)>::function(allocator_arg_t, const _Alloc&,
__f_ = __f.__f_->__clone();
}
template<class _R, class ..._ArgTypes>
function<_R(_ArgTypes...)>::function(function&& __f) _NOEXCEPT
template<class _Rp, class ..._ArgTypes>
function<_Rp(_ArgTypes...)>::function(function&& __f) _NOEXCEPT
{
if (__f.__f_ == 0)
__f_ = 0;
@@ -1234,9 +1234,9 @@ function<_R(_ArgTypes...)>::function(function&& __f) _NOEXCEPT
}
}
template<class _R, class ..._ArgTypes>
template<class _Rp, class ..._ArgTypes>
template <class _Alloc>
function<_R(_ArgTypes...)>::function(allocator_arg_t, const _Alloc&,
function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc&,
function&& __f)
{
if (__f.__f_ == 0)
@@ -1253,43 +1253,43 @@ function<_R(_ArgTypes...)>::function(allocator_arg_t, const _Alloc&,
}
}
template<class _R, class ..._ArgTypes>
template <class _F>
function<_R(_ArgTypes...)>::function(_F __f,
typename enable_if<__callable<_F>::value>::type*)
template<class _Rp, class ..._ArgTypes>
template <class _Fp>
function<_Rp(_ArgTypes...)>::function(_Fp __f,
typename enable_if<__callable<_Fp>::value>::type*)
: __f_(0)
{
if (__not_null(__f))
{
typedef __function::__func<_F, allocator<_F>, _R(_ArgTypes...)> _FF;
if (sizeof(_FF) <= sizeof(__buf_) && is_nothrow_copy_constructible<_F>::value)
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> _A;
_A __a;
typedef __allocator_destructor<_A> _D;
unique_ptr<__base, _D> __hold(__a.allocate(1), _D(__a, 1));
::new (__hold.get()) _FF(_VSTD::move(__f), allocator<_F>(__a));
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<class _R, class ..._ArgTypes>
template <class _F, class _Alloc>
function<_R(_ArgTypes...)>::function(allocator_arg_t, const _Alloc& __a0, _F __f,
typename enable_if<__callable<_F>::value>::type*)
template<class _Rp, class ..._ArgTypes>
template <class _Fp, class _Alloc>
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<_F, _Alloc, _R(_ArgTypes...)> _FF;
if (sizeof(_FF) <= sizeof(__buf_) && is_nothrow_copy_constructible<_F>::value)
typedef __function::__func<_Fp, _Alloc, _Rp(_ArgTypes...)> _FF;
if (sizeof(_FF) <= sizeof(__buf_) && is_nothrow_copy_constructible<_Fp>::value)
{
__f_ = (__base*)&__buf_;
::new (__f_) _FF(_VSTD::move(__f));
@@ -1302,27 +1302,27 @@ function<_R(_ArgTypes...)>::function(allocator_arg_t, const _Alloc& __a0, _F __f
#else
rebind_alloc<_FF>::other
#endif
_A;
_A __a(__a0);
typedef __allocator_destructor<_A> _D;
unique_ptr<__base, _D> __hold(__a.allocate(1), _D(__a, 1));
_Ap;
_Ap __a(__a0);
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<class _R, class ..._ArgTypes>
function<_R(_ArgTypes...)>&
function<_R(_ArgTypes...)>::operator=(const function& __f)
template<class _Rp, class ..._ArgTypes>
function<_Rp(_ArgTypes...)>&
function<_Rp(_ArgTypes...)>::operator=(const function& __f)
{
function(__f).swap(*this);
return *this;
}
template<class _R, class ..._ArgTypes>
function<_R(_ArgTypes...)>&
function<_R(_ArgTypes...)>::operator=(function&& __f) _NOEXCEPT
template<class _Rp, class ..._ArgTypes>
function<_Rp(_ArgTypes...)>&
function<_Rp(_ArgTypes...)>::operator=(function&& __f) _NOEXCEPT
{
if (__f_ == (__base*)&__buf_)
__f_->destroy();
@@ -1343,9 +1343,9 @@ function<_R(_ArgTypes...)>::operator=(function&& __f) _NOEXCEPT
}
}
template<class _R, class ..._ArgTypes>
function<_R(_ArgTypes...)>&
function<_R(_ArgTypes...)>::operator=(nullptr_t) _NOEXCEPT
template<class _Rp, class ..._ArgTypes>
function<_Rp(_ArgTypes...)>&
function<_Rp(_ArgTypes...)>::operator=(nullptr_t) _NOEXCEPT
{
if (__f_ == (__base*)&__buf_)
__f_->destroy();
@@ -1354,21 +1354,21 @@ function<_R(_ArgTypes...)>::operator=(nullptr_t) _NOEXCEPT
__f_ = 0;
}
template<class _R, class ..._ArgTypes>
template <class _F>
template<class _Rp, class ..._ArgTypes>
template <class _Fp>
typename enable_if
<
function<_R(_ArgTypes...)>::template __callable<typename decay<_F>::type>::value,
function<_R(_ArgTypes...)>&
function<_Rp(_ArgTypes...)>::template __callable<typename decay<_Fp>::type>::value,
function<_Rp(_ArgTypes...)>&
>::type
function<_R(_ArgTypes...)>::operator=(_F&& __f)
function<_Rp(_ArgTypes...)>::operator=(_Fp&& __f)
{
function(_VSTD::forward<_F>(__f)).swap(*this);
function(_VSTD::forward<_Fp>(__f)).swap(*this);
return *this;
}
template<class _R, class ..._ArgTypes>
function<_R(_ArgTypes...)>::~function()
template<class _Rp, class ..._ArgTypes>
function<_Rp(_ArgTypes...)>::~function()
{
if (__f_ == (__base*)&__buf_)
__f_->destroy();
@@ -1376,9 +1376,9 @@ function<_R(_ArgTypes...)>::~function()
__f_->destroy_deallocate();
}
template<class _R, class ..._ArgTypes>
template<class _Rp, class ..._ArgTypes>
void
function<_R(_ArgTypes...)>::swap(function& __f) _NOEXCEPT
function<_Rp(_ArgTypes...)>::swap(function& __f) _NOEXCEPT
{
if (__f_ == (__base*)&__buf_ && __f.__f_ == (__base*)&__f.__buf_)
{
@@ -1413,9 +1413,9 @@ function<_R(_ArgTypes...)>::swap(function& __f) _NOEXCEPT
_VSTD::swap(__f_, __f.__f_);
}
template<class _R, class ..._ArgTypes>
_R
function<_R(_ArgTypes...)>::operator()(_ArgTypes... __arg) const
template<class _Rp, class ..._ArgTypes>
_Rp
function<_Rp(_ArgTypes...)>::operator()(_ArgTypes... __arg) const
{
#ifndef _LIBCPP_NO_EXCEPTIONS
if (__f_ == 0)
@@ -1426,61 +1426,61 @@ function<_R(_ArgTypes...)>::operator()(_ArgTypes... __arg) const
#ifndef _LIBCPP_NO_RTTI
template<class _R, class ..._ArgTypes>
template<class _Rp, class ..._ArgTypes>
const std::type_info&
function<_R(_ArgTypes...)>::target_type() const _NOEXCEPT
function<_Rp(_ArgTypes...)>::target_type() const _NOEXCEPT
{
if (__f_ == 0)
return typeid(void);
return __f_->target_type();
}
template<class _R, class ..._ArgTypes>
template <typename _T>
_T*
function<_R(_ArgTypes...)>::target() _NOEXCEPT
template<class _Rp, class ..._ArgTypes>
template <typename _Tp>
_Tp*
function<_Rp(_ArgTypes...)>::target() _NOEXCEPT
{
if (__f_ == 0)
return (_T*)0;
return (_T*)__f_->target(typeid(_T));
return (_Tp*)0;
return (_Tp*)__f_->target(typeid(_Tp));
}
template<class _R, class ..._ArgTypes>
template <typename _T>
const _T*
function<_R(_ArgTypes...)>::target() const _NOEXCEPT
template<class _Rp, class ..._ArgTypes>
template <typename _Tp>
const _Tp*
function<_Rp(_ArgTypes...)>::target() const _NOEXCEPT
{
if (__f_ == 0)
return (const _T*)0;
return (const _T*)__f_->target(typeid(_T));
return (const _Tp*)0;
return (const _Tp*)__f_->target(typeid(_Tp));
}
#endif // _LIBCPP_NO_RTTI
template <class _R, class... _ArgTypes>
template <class _Rp, class... _ArgTypes>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator==(const function<_R(_ArgTypes...)>& __f, nullptr_t) _NOEXCEPT {return !__f;}
operator==(const function<_Rp(_ArgTypes...)>& __f, nullptr_t) _NOEXCEPT {return !__f;}
template <class _R, class... _ArgTypes>
template <class _Rp, class... _ArgTypes>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator==(nullptr_t, const function<_R(_ArgTypes...)>& __f) _NOEXCEPT {return !__f;}
operator==(nullptr_t, const function<_Rp(_ArgTypes...)>& __f) _NOEXCEPT {return !__f;}
template <class _R, class... _ArgTypes>
template <class _Rp, class... _ArgTypes>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator!=(const function<_R(_ArgTypes...)>& __f, nullptr_t) _NOEXCEPT {return (bool)__f;}
operator!=(const function<_Rp(_ArgTypes...)>& __f, nullptr_t) _NOEXCEPT {return (bool)__f;}
template <class _R, class... _ArgTypes>
template <class _Rp, class... _ArgTypes>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator!=(nullptr_t, const function<_R(_ArgTypes...)>& __f) _NOEXCEPT {return (bool)__f;}
operator!=(nullptr_t, const function<_Rp(_ArgTypes...)>& __f) _NOEXCEPT {return (bool)__f;}
template <class _R, class... _ArgTypes>
template <class _Rp, class... _ArgTypes>
inline _LIBCPP_INLINE_VISIBILITY
void
swap(function<_R(_ArgTypes...)>& __x, function<_R(_ArgTypes...)>& __y) _NOEXCEPT
swap(function<_Rp(_ArgTypes...)>& __x, function<_Rp(_ArgTypes...)>& __y) _NOEXCEPT
{return __x.swap(__y);}
template<class _Tp> struct __is_bind_expression : public false_type {};
@@ -1494,7 +1494,7 @@ template<class _Tp> struct _LIBCPP_VISIBLE is_placeholder
namespace placeholders
{
template <int _N> struct __ph {};
template <int _Np> struct __ph {};
extern __ph<1> _1;
extern __ph<2> _2;
@@ -1509,9 +1509,9 @@ extern __ph<10> _10;
} // placeholders
template<int _N>
struct __is_placeholder<placeholders::__ph<_N> >
: public integral_constant<int, _N> {};
template<int _Np>
struct __is_placeholder<placeholders::__ph<_Np> >
: public integral_constant<int, _Np> {};
template <class _Tp, class _Uj>
inline _LIBCPP_INLINE_VISIBILITY
@@ -1617,15 +1617,15 @@ struct __mu_return
{
};
template <class _F, class _BoundArgs, class _TupleUj>
template <class _Fp, class _BoundArgs, class _TupleUj>
struct __bind_return;
template <class _F, class ..._BoundArgs, class _TupleUj>
struct __bind_return<_F, tuple<_BoundArgs...>, _TupleUj>
template <class _Fp, class ..._BoundArgs, class _TupleUj>
struct __bind_return<_Fp, tuple<_BoundArgs...>, _TupleUj>
{
typedef typename __invoke_of
<
_F&,
_Fp&,
typename __mu_return
<
_BoundArgs,
@@ -1634,12 +1634,12 @@ struct __bind_return<_F, tuple<_BoundArgs...>, _TupleUj>
>::type type;
};
template <class _F, class ..._BoundArgs, class _TupleUj>
struct __bind_return<_F, const tuple<_BoundArgs...>, _TupleUj>
template <class _Fp, class ..._BoundArgs, class _TupleUj>
struct __bind_return<_Fp, const tuple<_BoundArgs...>, _TupleUj>
{
typedef typename __invoke_of
<
_F&,
_Fp&,
typename __mu_return
<
const _BoundArgs,
@@ -1648,20 +1648,20 @@ struct __bind_return<_F, const tuple<_BoundArgs...>, _TupleUj>
>::type type;
};
template <class _F, class _BoundArgs, size_t ..._Indx, class _Args>
template <class _Fp, class _BoundArgs, size_t ..._Indx, class _Args>
inline _LIBCPP_INLINE_VISIBILITY
typename __bind_return<_F, _BoundArgs, _Args>::type
__apply_functor(_F& __f, _BoundArgs& __bound_args, __tuple_indices<_Indx...>,
typename __bind_return<_Fp, _BoundArgs, _Args>::type
__apply_functor(_Fp& __f, _BoundArgs& __bound_args, __tuple_indices<_Indx...>,
_Args&& __args)
{
return __invoke(__f, __mu(get<_Indx>(__bound_args), __args)...);
}
template<class _F, class ..._BoundArgs>
template<class _Fp, class ..._BoundArgs>
class __bind
: public __weak_result_type<typename decay<_F>::type>
: public __weak_result_type<typename decay<_Fp>::type>
{
typedef typename decay<_F>::type _Fd;
typedef typename decay<_Fp>::type _Fd;
typedef tuple<typename decay<_BoundArgs>::type...> _Td;
_Fd __f_;
_Td __bound_args_;
@@ -1698,10 +1698,10 @@ public:
#endif // _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
template <class _G, class ..._BA>
template <class _Gp, class ..._BA>
_LIBCPP_INLINE_VISIBILITY
explicit __bind(_G&& __f, _BA&& ...__bound_args)
: __f_(_VSTD::forward<_G>(__f)),
explicit __bind(_Gp&& __f, _BA&& ...__bound_args)
: __f_(_VSTD::forward<_Gp>(__f)),
__bound_args_(_VSTD::forward<_BA>(__bound_args)...) {}
template <class ..._Args>
@@ -1723,16 +1723,16 @@ public:
}
};
template<class _F, class ..._BoundArgs>
struct __is_bind_expression<__bind<_F, _BoundArgs...> > : public true_type {};
template<class _Fp, class ..._BoundArgs>
struct __is_bind_expression<__bind<_Fp, _BoundArgs...> > : public true_type {};
template<class _R, class _F, class ..._BoundArgs>
template<class _Rp, class _Fp, class ..._BoundArgs>
class __bind_r
: public __bind<_F, _BoundArgs...>
: public __bind<_Fp, _BoundArgs...>
{
typedef __bind<_F, _BoundArgs...> base;
typedef __bind<_Fp, _BoundArgs...> base;
public:
typedef _R result_type;
typedef _Rp result_type;
#ifdef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
@@ -1760,10 +1760,10 @@ public:
#endif // _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
template <class _G, class ..._BA>
template <class _Gp, class ..._BA>
_LIBCPP_INLINE_VISIBILITY
explicit __bind_r(_G&& __f, _BA&& ...__bound_args)
: base(_VSTD::forward<_G>(__f),
explicit __bind_r(_Gp&& __f, _BA&& ...__bound_args)
: base(_VSTD::forward<_Gp>(__f),
_VSTD::forward<_BA>(__bound_args)...) {}
template <class ..._Args>
@@ -1783,25 +1783,25 @@ public:
}
};
template<class _R, class _F, class ..._BoundArgs>
struct __is_bind_expression<__bind_r<_R, _F, _BoundArgs...> > : public true_type {};
template<class _Rp, class _Fp, class ..._BoundArgs>
struct __is_bind_expression<__bind_r<_Rp, _Fp, _BoundArgs...> > : public true_type {};
template<class _F, class ..._BoundArgs>
template<class _Fp, class ..._BoundArgs>
inline _LIBCPP_INLINE_VISIBILITY
__bind<_F, _BoundArgs...>
bind(_F&& __f, _BoundArgs&&... __bound_args)
__bind<_Fp, _BoundArgs...>
bind(_Fp&& __f, _BoundArgs&&... __bound_args)
{
typedef __bind<_F, _BoundArgs...> type;
return type(_VSTD::forward<_F>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...);
typedef __bind<_Fp, _BoundArgs...> type;
return type(_VSTD::forward<_Fp>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...);
}
template<class _R, class _F, class ..._BoundArgs>
template<class _Rp, class _Fp, class ..._BoundArgs>
inline _LIBCPP_INLINE_VISIBILITY
__bind_r<_R, _F, _BoundArgs...>
bind(_F&& __f, _BoundArgs&&... __bound_args)
__bind_r<_Rp, _Fp, _BoundArgs...>
bind(_Fp&& __f, _BoundArgs&&... __bound_args)
{
typedef __bind_r<_R, _F, _BoundArgs...> type;
return type(_VSTD::forward<_F>(__f), _VSTD::forward<_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