functional File Reference

Go to the source code of this file.

Classes
struct	std::__is_location_invariant< _Tp >
struct	std::_Bind< _Signature >
struct	std::_Bind_result< _Result, _Signature >
class	std::_Function_base
struct	std::_Maybe_get_result_type< _Functor, typename >
struct	std::_Maybe_unary_or_binary_function< _Res, _ArgTypes >
struct	std::_Maybe_unary_or_binary_function< _Res, _T1 >
struct	std::_Maybe_unary_or_binary_function< _Res, _T1, _T2 >
struct	std::_Maybe_wrap_member_pointer< _Tp >
struct	std::_Maybe_wrap_member_pointer< _Tp _Class::* >
class	std::_Mu< _Arg, _IsBindExp, _IsPlaceholder >
class	std::_Mu< _Arg, false, false >
class	std::_Mu< _Arg, false, true >
class	std::_Mu< _Arg, true, false >
class	std::_Mu< reference_wrapper< _Tp >, false, false >
struct	std::_Placeholder< _Num >
struct	std::_Reference_wrapper_base< _Tp >
struct	std::_Reference_wrapper_base_impl< _Unary, _Binary, _Tp >
struct	std::_Safe_tuple_element< __i, _Tuple >
struct	std::_Safe_tuple_element_impl< __i, _Tuple, _IsSafe >
struct	std::_Safe_tuple_element_impl< __i, _Tuple, false >
struct	std::_Weak_result_type< _Functor >
struct	std::_Weak_result_type_impl< _Functor >
struct	std::_Weak_result_type_impl< _Res(&)(_ArgTypes...)>
struct	std::_Weak_result_type_impl< _Res(*)(_ArgTypes...)>
struct	std::_Weak_result_type_impl< _Res(_ArgTypes...)>
struct	std::_Weak_result_type_impl< _Res(_Class::*)(_ArgTypes...) const >
struct	std::_Weak_result_type_impl< _Res(_Class::*)(_ArgTypes...) const volatile >
struct	std::_Weak_result_type_impl< _Res(_Class::*)(_ArgTypes...) volatile >
struct	std::_Weak_result_type_impl< _Res(_Class::*)(_ArgTypes...)>
class	std::bad_function_call
class	std::function< _Res(_ArgTypes...)>
struct	std::is_bind_expression< _Tp >
struct	std::is_bind_expression< _Bind< _Signature > >
struct	std::is_bind_expression< _Bind_result< _Result, _Signature > >
struct	std::is_bind_expression< const _Bind< _Signature > >
struct	std::is_bind_expression< const _Bind_result< _Result, _Signature > >
struct	std::is_bind_expression< const volatile _Bind< _Signature > >
struct	std::is_bind_expression< const volatile _Bind_result< _Result, _Signature > >
struct	std::is_bind_expression< volatile _Bind< _Signature > >
struct	std::is_bind_expression< volatile _Bind_result< _Result, _Signature > >
struct	std::is_placeholder< _Tp >
struct	std::is_placeholder< _Placeholder< _Num > >
class	std::reference_wrapper< _Tp >

Namespaces
	std
	std::placeholders

Macros
#define	_GLIBCXX_FUNCTIONAL
#define	_GLIBCXX_MEM_FN_TRAITS(_REF, _LVAL, _RVAL)
#define	_GLIBCXX_MEM_FN_TRAITS2(_CV, _REF, _LVAL, _RVAL)

Typedefs
template<typename _From , typename _To >
using	std::__check_func_return_type = __or_< is_void< _To >, is_convertible< _From, _To >>
template<typename _Tp , typename _Tp2 = typename decay<_Tp>::type>
using	std::__is_socketlike = __or_< is_integral< _Tp2 >, is_enum< _Tp2 >>
template<typename _Tp1 , typename _Tp2 >
using	std::_NotSame = __not_< is_same< typename std::decay< _Tp1 >::type, typename std::decay< _Tp2 >::type >>

Enumerations
enum	_Manager_operation { __get_type_info, __get_functor_ptr, __clone_functor, __destroy_functor }

Functions
template<typename _Callable , typename... _Args>
_Bind_simple_helper< _Callable, _Args... >::__type	std::__bind_simple (_Callable &&__callable, _Args &&...__args)
template<typename _Functor >
_Functor &	std::__callable_functor (_Functor &__f)
template<typename _Member , typename _Class >
_Mem_fn< _Member _Class::* >	std::__callable_functor (_Member _Class::*&__p)
template<typename _Member , typename _Class >
_Mem_fn< _Member _Class::* >	std::__callable_functor (_Member _Class::*const &__p)
template<typename _Member , typename _Class >
_Mem_fn< _Member _Class::* >	std::__callable_functor (_Member _Class::*volatile &__p)
template<typename _Member , typename _Class >
_Mem_fn< _Member _Class::* >	std::__callable_functor (_Member _Class::*const volatile &__p)
template<typename _Functor , typename... _Args>
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	std::__invoke (_Functor &__f, _Args &&...__args)
template<typename _Functor , typename... _Args>
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	std::__invoke (_Functor &__f, _Args &&...__args)
template<typename _Functor , typename... _Args>
enable_if< (is_pointer< _Functor >::value &&is_function< typename remove_pointer< _Functor >::type >::value), typename result_of< _Functor(_Args &&...)>::type >::type	std::__invoke (_Functor __f, _Args &&...__args)
template<std::size_t _Ind, typename... _Tp>
auto	std::__volget (volatile tuple< _Tp... > &__tuple) -> __tuple_element_t< _Ind, tuple< _Tp... >> volatile &
template<std::size_t _Ind, typename... _Tp>
auto	std::__volget (const volatile tuple< _Tp... > &__tuple) -> __tuple_element_t< _Ind, tuple< _Tp... >> const volatile &
template<typename _Func , typename... _BoundArgs>
_Bind_helper< __is_socketlike< _Func >::value, _Func, _BoundArgs... >::type	std::bind (_Func &&__f, _BoundArgs &&...__args)
template<typename _Result , typename _Func , typename... _BoundArgs>
_Bindres_helper< _Result, _Func, _BoundArgs... >::type	std::bind (_Func &&__f, _BoundArgs &&...__args)
template<typename _Tp , typename _Class >
_Mem_fn< _Tp _Class::* >	std::mem_fn (_Tp _Class::*__pm) noexcept
template<typename _Res , typename... _Args>
bool	std::operator!= (const function< _Res(_Args...)> &__f, nullptr_t) noexcept
template<typename _Res , typename... _Args>
bool	std::operator!= (nullptr_t, const function< _Res(_Args...)> &__f) noexcept
template<typename _Res , typename... _Args>
bool	std::operator== (const function< _Res(_Args...)> &__f, nullptr_t) noexcept
template<typename _Res , typename... _Args>
bool	std::operator== (nullptr_t, const function< _Res(_Args...)> &__f) noexcept
template<typename _Res , typename... _Args>
void	std::swap (function< _Res(_Args...)> &__x, function< _Res(_Args...)> &__y)
template<typename _Tp >
reference_wrapper< _Tp >	std::ref (_Tp &__t) noexcept
template<typename _Tp >
reference_wrapper< const _Tp >	std::cref (const _Tp &__t) noexcept
template<typename _Tp >
void	std::ref (const _Tp &&)=delete
template<typename _Tp >
void	std::cref (const _Tp &&)=delete
template<typename _Tp >
reference_wrapper< _Tp >	std::ref (reference_wrapper< _Tp > __t) noexcept
template<typename _Tp >
reference_wrapper< const _Tp >	std::cref (reference_wrapper< _Tp > __t) noexcept

Variables
const _Placeholder< 1 >	std::placeholders::_1
const _Placeholder< 10 >	std::placeholders::_10
const _Placeholder< 11 >	std::placeholders::_11
const _Placeholder< 12 >	std::placeholders::_12
const _Placeholder< 13 >	std::placeholders::_13
const _Placeholder< 14 >	std::placeholders::_14
const _Placeholder< 15 >	std::placeholders::_15
const _Placeholder< 16 >	std::placeholders::_16
const _Placeholder< 17 >	std::placeholders::_17
const _Placeholder< 18 >	std::placeholders::_18
const _Placeholder< 19 >	std::placeholders::_19
const _Placeholder< 2 >	std::placeholders::_2
const _Placeholder< 20 >	std::placeholders::_20
const _Placeholder< 21 >	std::placeholders::_21
const _Placeholder< 22 >	std::placeholders::_22
const _Placeholder< 23 >	std::placeholders::_23
const _Placeholder< 24 >	std::placeholders::_24
const _Placeholder< 25 >	std::placeholders::_25
const _Placeholder< 26 >	std::placeholders::_26
const _Placeholder< 27 >	std::placeholders::_27
const _Placeholder< 28 >	std::placeholders::_28
const _Placeholder< 29 >	std::placeholders::_29
const _Placeholder< 3 >	std::placeholders::_3
const _Placeholder< 4 >	std::placeholders::_4
const _Placeholder< 5 >	std::placeholders::_5
const _Placeholder< 6 >	std::placeholders::_6
const _Placeholder< 7 >	std::placeholders::_7
const _Placeholder< 8 >	std::placeholders::_8
const _Placeholder< 9 >	std::placeholders::_9

Detailed Description

This is a Standard C++ Library header.

Definition in file functional.