// <functional> -*- C++ -*-
-// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009
+// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009, 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
template<typename _Signature>
class result_of;
- /**
- * Actual implementation of result_of. When _Has_result_type is
- * true, gets its result from _Weak_result_type. Otherwise, uses
- * the function object's member template result to extract the
- * result type.
- */
- template<bool _Has_result_type, typename _Signature>
- struct _Result_of_impl;
-
- // Handle member data pointers using _Mem_fn's logic
- template<typename _Res, typename _Class, typename _T1>
- struct _Result_of_impl<false, _Res _Class::*(_T1)>
- {
- typedef typename _Mem_fn<_Res _Class::*>
- ::template _Result_type<_T1>::type type;
- };
-
- /**
- * Determine whether we can determine a result type from @c Functor
- * alone.
- */
- template<typename _Functor, typename... _ArgTypes>
- class result_of<_Functor(_ArgTypes...)>
- : public _Result_of_impl<
- _Has_result_type<_Weak_result_type<_Functor> >::value,
- _Functor(_ArgTypes...)>
- {
- };
-
- /// We already know the result type for @c Functor; use it.
template<typename _Functor, typename... _ArgTypes>
- struct _Result_of_impl<true, _Functor(_ArgTypes...)>
+ struct result_of<_Functor(_ArgTypes...)>
{
- typedef typename _Weak_result_type<_Functor>::result_type type;
- };
-
- /**
- * We need to compute the result type for this invocation the hard
- * way.
- */
- template<typename _Functor, typename... _ArgTypes>
- struct _Result_of_impl<false, _Functor(_ArgTypes...)>
- {
- typedef typename _Functor
- ::template result<_Functor(_ArgTypes...)>::type type;
- };
-
- /**
- * It is unsafe to access ::result when there are zero arguments, so we
- * return @c void instead.
- */
- template<typename _Functor>
- struct _Result_of_impl<false, _Functor()>
- {
- typedef void type;
+ typedef
+ decltype( std::declval<_Functor>()(std::declval<_ArgTypes>()...) )
+ type;
};
/// Determines if the type _Tp derives from unary_function.
&& !is_function<typename remove_pointer<_Functor>::type>::value),
typename result_of<_Functor(_Args...)>::type
>::__type
- __invoke(_Functor& __f, _Args&... __args)
- {
- return __f(__args...);
- }
-
- template<typename _Functor, typename... _Args>
- inline
- typename __gnu_cxx::__enable_if<
- (is_member_pointer<_Functor>::value
- && !is_function<_Functor>::value
- && !is_function<typename remove_pointer<_Functor>::type>::value),
- typename result_of<_Functor(_Args...)>::type
- >::__type
- __invoke(_Functor& __f, _Args&... __args)
+ __invoke(_Functor& __f, _Args&&... __args)
{
- return mem_fn(__f)(__args...);
+ return __f(std::forward<_Args>(__args)...);
}
// To pick up function references (that will become function pointers)
&& is_function<typename remove_pointer<_Functor>::type>::value),
typename result_of<_Functor(_Args...)>::type
>::__type
- __invoke(_Functor __f, _Args&... __args)
+ __invoke(_Functor __f, _Args&&... __args)
{
- return __f(__args...);
+ return __f(std::forward<_Args>(__args)...);
}
/**
public:
typedef _Tp type;
- explicit
reference_wrapper(_Tp& __indata): _M_data(&__indata)
{ }
+ reference_wrapper(_Tp&&) = delete;
+
reference_wrapper(const reference_wrapper<_Tp>& __inref):
_M_data(__inref._M_data)
{ }
template<typename... _Args>
typename result_of<_M_func_type(_Args...)>::type
- operator()(_Args&... __args) const
+ operator()(_Args&&... __args) const
{
- return __invoke(get(), __args...);
+ return __invoke(get(), std::forward<_Args>(__args)...);
}
};
template<typename _CVArg, typename... _Args>
typename result_of<_CVArg(_Args...)>::type
operator()(_CVArg& __arg,
- const tuple<_Args...>& __tuple) const volatile
+ tuple<_Args...>& __tuple) const volatile
{
// Construct an index tuple and forward to __call
typedef typename _Build_index_tuple<sizeof...(_Args)>::__type
// of the arguments in the tuple.
template<typename _CVArg, typename... _Args, int... _Indexes>
typename result_of<_CVArg(_Args...)>::type
- __call(_CVArg& __arg, const tuple<_Args...>& __tuple,
+ __call(_CVArg& __arg, tuple<_Args...>& __tuple,
const _Index_tuple<_Indexes...>&) const volatile
{
- return __arg(get<_Indexes>(__tuple)...);
+ return __arg(std::forward<_Args>(get<_Indexes>(__tuple))...);
}
};
__base_type;
public:
- typedef typename add_lvalue_reference<__base_type>::type type;
+ typedef typename add_rvalue_reference<__base_type>::type type;
};
template<typename _Tuple>
typename result<_Mu(_Arg, _Tuple)>::type
- operator()(const volatile _Arg&, const _Tuple& __tuple) const volatile
+ operator()(const volatile _Arg&, _Tuple& __tuple) const volatile
{
- return ::std::get<(is_placeholder<_Arg>::value - 1)>(__tuple);
+ return std::forward<typename result<_Mu(_Arg, _Tuple)>::type>(
+ ::std::get<(is_placeholder<_Arg>::value - 1)>(__tuple));
}
};
// Pick up the cv-qualifiers of the argument
template<typename _CVArg, typename _Tuple>
- _CVArg&
- operator()(_CVArg& __arg, const _Tuple&) const volatile
- { return __arg; }
+ _CVArg&&
+ operator()(_CVArg&& __arg, const _Tuple&) const volatile
+ { return std::forward<_CVArg>(__arg); }
};
/**
tuple<_Bound_args...> _M_bound_args;
// Call unqualified
- template<typename... _Args, int... _Indexes>
+ template<typename... _Args, int... _Indexes, typename _Sfinae
+ = decltype( std::declval<_Functor>()(
+ _Mu<_Bound_args>()( std::declval<_Bound_args&>(),
+ std::declval<tuple<_Args...>&>() )... ) )>
typename result_of<
_Functor(typename result_of<_Mu<_Bound_args>
- (_Bound_args, tuple<_Args...>)>::type...)
+ (_Bound_args&, tuple<_Args...>&)>::type...)
>::type
- __call(const tuple<_Args...>& __args, _Index_tuple<_Indexes...>)
+ __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>)
{
return _M_f(_Mu<_Bound_args>()
(get<_Indexes>(_M_bound_args), __args)...);
}
// Call as const
- template<typename... _Args, int... _Indexes>
+ template<typename... _Args, int... _Indexes, typename _Sfinae
+ = decltype( std::declval<const _Functor>()(
+ _Mu<_Bound_args>()( std::declval<const _Bound_args&>(),
+ std::declval<tuple<_Args...>&>() )... ) )>
typename result_of<
const _Functor(typename result_of<_Mu<_Bound_args>
- (const _Bound_args, tuple<_Args...>)
+ (const _Bound_args&, tuple<_Args...>&)
>::type...)>::type
- __call(const tuple<_Args...>& __args, _Index_tuple<_Indexes...>) const
+ __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) const
{
return _M_f(_Mu<_Bound_args>()
(get<_Indexes>(_M_bound_args), __args)...);
}
+#if 0
// Call as volatile
- template<typename... _Args, int... _Indexes>
+ template<typename... _Args, int... _Indexes, typename _Sfinae
+ = decltype( std::declval<volatile _Functor>()(
+ _Mu<_Bound_args>()( std::declval<volatile _Bound_args&>(),
+ std::declval<tuple<_Args...>&>() )... ) )>
typename result_of<
volatile _Functor(typename result_of<_Mu<_Bound_args>
- (volatile _Bound_args, tuple<_Args...>)
+ (volatile _Bound_args&, tuple<_Args...>&)
>::type...)>::type
- __call(const tuple<_Args...>& __args,
+ __call(tuple<_Args...>&& __args,
_Index_tuple<_Indexes...>) volatile
{
return _M_f(_Mu<_Bound_args>()
}
// Call as const volatile
- template<typename... _Args, int... _Indexes>
+ template<typename... _Args, int... _Indexes, typename _Sfinae
+ = decltype( std::declval<const volatile _Functor>()(
+ _Mu<_Bound_args>()( std::declval<const volatile _Bound_args&>(),
+ std::declval<tuple<_Args...>&>() )... ) )>
typename result_of<
const volatile _Functor(typename result_of<_Mu<_Bound_args>
- (const volatile _Bound_args,
- tuple<_Args...>)
+ (const volatile _Bound_args&,
+ tuple<_Args...>&)
>::type...)>::type
- __call(const tuple<_Args...>& __args,
+ __call(tuple<_Args...>&& __args,
_Index_tuple<_Indexes...>) const volatile
{
return _M_f(_Mu<_Bound_args>()
(get<_Indexes>(_M_bound_args), __args)...);
}
+#endif
public:
explicit _Bind(_Functor __f, _Bound_args... __bound_args)
- : _M_f(__f), _M_bound_args(__bound_args...) { }
+ : _M_f(std::forward<_Functor>(__f)),
+ _M_bound_args(std::forward<_Bound_args>(__bound_args)...)
+ { }
// Call unqualified
- template<typename... _Args>
+ template<typename... _Args, typename _Sfinae
+ = decltype( std::declval<_Functor>()(
+ _Mu<_Bound_args>()( std::declval<_Bound_args&>(),
+ std::declval<tuple<_Args...>&>() )... ) )>
typename result_of<
_Functor(typename result_of<_Mu<_Bound_args>
- (_Bound_args, tuple<_Args...>)>::type...)
+ (_Bound_args&, tuple<_Args...>&)>::type...)
>::type
- operator()(_Args&... __args)
+ operator()(_Args&&... __args)
{
- return this->__call(tie(__args...), _Bound_indexes());
+ return this->__call(tuple<_Args...>(std::forward<_Args>(__args)...),
+ _Bound_indexes());
}
// Call as const
- template<typename... _Args>
+ template<typename... _Args, typename _Sfinae
+ = decltype( std::declval<const _Functor>()(
+ _Mu<_Bound_args>()( std::declval<const _Bound_args&>(),
+ std::declval<tuple<_Args...>&>() )... ) )>
typename result_of<
const _Functor(typename result_of<_Mu<_Bound_args>
- (const _Bound_args, tuple<_Args...>)>::type...)
+ (const _Bound_args&, tuple<_Args...>&)>::type...)
>::type
- operator()(_Args&... __args) const
+ operator()(_Args&&... __args) const
{
- return this->__call(tie(__args...), _Bound_indexes());
+ return this->__call(tuple<_Args...>(std::forward<_Args>(__args)...),
+ _Bound_indexes());
}
-
+#if 0
// Call as volatile
- template<typename... _Args>
+ template<typename... _Args, typename _Sfinae
+ = decltype( std::declval<volatile _Functor>()(
+ _Mu<_Bound_args>()( std::declval<volatile _Bound_args&>(),
+ std::declval<tuple<_Args...>&>() )... ) )>
typename result_of<
volatile _Functor(typename result_of<_Mu<_Bound_args>
- (volatile _Bound_args, tuple<_Args...>)>::type...)
+ (volatile _Bound_args&, tuple<_Args...>&)>::type...)
>::type
- operator()(_Args&... __args) volatile
+ operator()(_Args&&... __args) volatile
{
- return this->__call(tie(__args...), _Bound_indexes());
+ return this->__call(tuple<_Args...>(std::forward<_Args>(__args)...),
+ _Bound_indexes());
}
// Call as const volatile
- template<typename... _Args>
+ template<typename... _Args, typename _Sfinae
+ = decltype( std::declval<const volatile _Functor>()(
+ _Mu<_Bound_args>()( std::declval<const volatile _Bound_args&>(),
+ std::declval<tuple<_Args...>&>() )... ) )>
typename result_of<
const volatile _Functor(typename result_of<_Mu<_Bound_args>
- (const volatile _Bound_args,
- tuple<_Args...>)>::type...)
+ (const volatile _Bound_args&,
+ tuple<_Args...>&)>::type...)
>::type
- operator()(_Args&... __args) const volatile
+ operator()(_Args&&... __args) const volatile
{
- return this->__call(tie(__args...), _Bound_indexes());
+ return this->__call(tuple<_Args...>(std::forward<_Args>(__args)...),
+ _Bound_indexes());
}
+#endif
};
/// Type of the function object returned from bind<R>().
// Call unqualified
template<typename _Res, typename... _Args, int... _Indexes>
_Result
- __call(const tuple<_Args...>& __args, _Index_tuple<_Indexes...>,
+ __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
typename __disable_if_void<_Res>::type = 0)
{
return _M_f(_Mu<_Bound_args>()
// Call unqualified, return void
template<typename _Res, typename... _Args, int... _Indexes>
void
- __call(const tuple<_Args...>& __args, _Index_tuple<_Indexes...>,
+ __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
typename __enable_if_void<_Res>::type = 0)
{
_M_f(_Mu<_Bound_args>()
// Call as const
template<typename _Res, typename... _Args, int... _Indexes>
_Result
- __call(const tuple<_Args...>& __args, _Index_tuple<_Indexes...>,
+ __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
typename __disable_if_void<_Res>::type = 0) const
{
return _M_f(_Mu<_Bound_args>()
// Call as const, return void
template<typename _Res, typename... _Args, int... _Indexes>
void
- __call(const tuple<_Args...>& __args, _Index_tuple<_Indexes...>,
+ __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
typename __enable_if_void<_Res>::type = 0) const
{
_M_f(_Mu<_Bound_args>()
// Call as volatile
template<typename _Res, typename... _Args, int... _Indexes>
_Result
- __call(const tuple<_Args...>& __args, _Index_tuple<_Indexes...>,
+ __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
typename __disable_if_void<_Res>::type = 0) volatile
{
return _M_f(_Mu<_Bound_args>()
// Call as volatile, return void
template<typename _Res, typename... _Args, int... _Indexes>
void
- __call(const tuple<_Args...>& __args, _Index_tuple<_Indexes...>,
+ __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
typename __enable_if_void<_Res>::type = 0) volatile
{
_M_f(_Mu<_Bound_args>()
// Call as const volatile
template<typename _Res, typename... _Args, int... _Indexes>
_Result
- __call(const tuple<_Args...>& __args, _Index_tuple<_Indexes...>,
+ __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
typename __disable_if_void<_Res>::type = 0) const volatile
{
return _M_f(_Mu<_Bound_args>()
// Call as const volatile, return void
template<typename _Res, typename... _Args, int... _Indexes>
void
- __call(const tuple<_Args...>& __args,
+ __call(tuple<_Args...>&& __args,
_Index_tuple<_Indexes...>,
typename __enable_if_void<_Res>::type = 0) const volatile
{
explicit
_Bind_result(_Functor __f, _Bound_args... __bound_args)
- : _M_f(__f), _M_bound_args(__bound_args...) { }
+ : _M_f(std::forward<_Functor>(__f)),
+ _M_bound_args(std::forward<_Bound_args>(__bound_args)...)
+ { }
// Call unqualified
template<typename... _Args>
result_type
- operator()(_Args&... __args)
+ operator()(_Args&&... __args)
{
- return this->__call<_Result>(tie(__args...), _Bound_indexes());
+ return this->__call<_Result>(
+ tuple<_Args...>(std::forward<_Args...>(__args)...),
+ _Bound_indexes());
}
// Call as const
template<typename... _Args>
result_type
- operator()(_Args&... __args) const
+ operator()(_Args&&... __args) const
{
- return this->__call<_Result>(tie(__args...), _Bound_indexes());
+ return this->__call<_Result>(
+ tuple<_Args...>(std::forward<_Args...>(__args)...),
+ _Bound_indexes());
}
// Call as volatile
template<typename... _Args>
result_type
- operator()(_Args&... __args) volatile
+ operator()(_Args&&... __args) volatile
{
- return this->__call<_Result>(tie(__args...), _Bound_indexes());
+ return this->__call<_Result>(
+ tuple<_Args...>(std::forward<_Args...>(__args)...),
+ _Bound_indexes());
}
// Call as const volatile
template<typename... _Args>
result_type
- operator()(_Args&... __args) const volatile
+ operator()(_Args&&... __args) const volatile
{
- return this->__call<_Result>(tie(__args...), _Bound_indexes());
+ return this->__call<_Result>(
+ tuple<_Args...>(std::forward<_Args...>(__args)...),
+ _Bound_indexes());
}
};
typedef _Maybe_wrap_member_pointer<_Functor> __maybe_type;
typedef typename __maybe_type::type __functor_type;
typedef _Bind<__functor_type(_ArgTypes...)> __result_type;
- return __result_type(__maybe_type::__do_wrap(__f), __args...);
+ return __result_type(__maybe_type::__do_wrap(__f),
+ std::forward<_ArgTypes>(__args)...);
}
template<typename _Result, typename _Functor, typename... _ArgTypes>
typedef typename __maybe_type::type __functor_type;
typedef _Bind_result<_Result, __functor_type(_ArgTypes...)>
__result_type;
- return __result_type(__maybe_type::__do_wrap(__f), __args...);
+ return __result_type(__maybe_type::__do_wrap(__f),
+ std::forward<_ArgTypes>(__args)...);
}
/**