type_traits File Reference

#include <xstddef>

Classes
struct	_Arg_types< _Types >
struct	_Arg_types< _Ty1 >
struct	_Arg_types< _Ty1, _Ty2 >
struct	_Is_function< _Ty >
struct	is_function< _Ty >
struct	_Is_memfunptr< _Ty >
struct	is_void< _Ty >
struct	add_const< _Ty >
struct	add_volatile< _Ty >
struct	add_cv< _Ty >
struct	_Add_reference< _Ty, class >
struct	_Add_reference< _Ty, void_t< _Ty & > >
struct	add_lvalue_reference< _Ty >
struct	add_rvalue_reference< _Ty >
struct	remove_extent< _Ty >
struct	remove_extent< _Ty[_Ix]>
struct	remove_extent< _Ty[]>
struct	remove_all_extents< _Ty >
struct	remove_all_extents< _Ty[_Ix]>
struct	remove_all_extents< _Ty[]>
struct	remove_pointer< _Ty >
struct	_Add_pointer< _Ty, class >
struct	_Add_pointer< _Ty, void_t< typename remove_reference< _Ty >::type * > >
struct	add_pointer< _Ty >
struct	is_array< _Ty >
struct	is_array< _Ty[_Nx]>
struct	is_array< _Ty[]>
struct	is_lvalue_reference< _Ty >
struct	is_lvalue_reference< _Ty & >
struct	is_rvalue_reference< _Ty >
struct	is_rvalue_reference< _Ty && >
struct	is_reference< _Ty >
struct	_Is_member_object_pointer< _Ty, _Pmf >
struct	_Is_member_object_pointer< _Ty1 _Ty2::*, false >
struct	is_member_object_pointer< _Ty >
struct	is_member_function_pointer< _Ty >
struct	_Is_pointer< _Ty >
struct	_Is_pointer< _Ty * >
struct	is_pointer< _Ty >
struct	is_null_pointer< _Ty >
struct	is_union< _Ty >
struct	is_class< _Ty >
struct	is_fundamental< _Ty >
struct	is_object< _Ty >
struct	is_convertible< _From, _To >
struct	is_enum< _Ty >
struct	is_compound< _Ty >
struct	is_member_pointer< _Ty >
struct	is_scalar< _Ty >
struct	is_const< _Ty >
struct	is_const< const _Ty >
struct	is_volatile< _Ty >
struct	is_volatile< volatile _Ty >
struct	is_pod< _Ty >
struct	is_empty< _Ty >
struct	is_polymorphic< _Ty >
struct	is_abstract< _Ty >
struct	is_final< _Ty >
struct	is_standard_layout< _Ty >
struct	is_literal_type< _Ty >
struct	is_trivial< _Ty >
struct	is_trivially_copyable< _Ty >
struct	has_virtual_destructor< _Ty >
struct	is_constructible< _Ty, _Args >
struct	is_copy_constructible< _Ty >
struct	is_default_constructible< _Ty >
struct	is_move_constructible< _Ty >
struct	is_assignable< _To, _From >
struct	is_copy_assignable< _Ty >
struct	is_move_assignable< _Ty >
struct	is_destructible< _Ty >
struct	is_trivially_constructible< _Ty, _Args >
struct	is_trivially_copy_constructible< _Ty >
struct	is_trivially_default_constructible< _Ty >
struct	is_trivially_move_constructible< _Ty >
struct	is_trivially_assignable< _To, _From >
struct	is_trivially_copy_assignable< _Ty >
struct	is_trivially_move_assignable< _Ty >
struct	is_trivially_destructible< _Ty >
struct	is_nothrow_constructible< _Ty, _Args >
struct	is_nothrow_copy_constructible< _Ty >
struct	is_nothrow_default_constructible< _Ty >
struct	is_nothrow_move_constructible< _Ty >
struct	is_nothrow_assignable< _To, _From >
struct	is_nothrow_copy_assignable< _Ty >
struct	is_nothrow_move_assignable< _Ty >
struct	is_nothrow_destructible< _Ty >
struct	_Sign_base< _Ty, bool >
struct	_Sign_base< _Ty, false >
struct	is_signed< _Ty >
struct	is_unsigned< _Ty >
struct	_Change_sign< _Ty >
struct	_Change_sign< const _Ty >
struct	_Change_sign< volatile _Ty >
struct	_Change_sign< const volatile _Ty >
struct	make_signed< _Ty >
struct	make_unsigned< _Ty >
struct	alignment_of< _Ty >
union	_Align_type< _Ty, _Len >
struct	_Aligned< _Len, _Align, _Ty, _Ok >
struct	_Aligned< _Len, _Align, _Ty, true >
struct	_Aligned< _Len, _Align, double, false >
struct	_Aligned< _Len, _Align, int, false >
struct	_Aligned< _Len, _Align, short, false >
struct	_Aligned< _Len, _Align, char, false >
struct	aligned_storage< _Len, _Align >
struct	_Maximum< _Vals >
struct	_Maximum<>
struct	_Maximum< _Val >
struct	_Maximum< _First, _Second, _Rest...>
struct	aligned_union< _Len, _Types >
struct	underlying_type< _Ty >
struct	rank< _Ty >
struct	rank< _Ty[_Ix]>
struct	rank< _Ty[]>
struct	_Extent< _Ty, _Nx >
struct	_Extent< _Ty[_Ix], 0 >
struct	_Extent< _Ty[_Ix], _Nx >
struct	_Extent< _Ty[], _Nx >
struct	extent< _Ty, _Nx >
struct	is_base_of< _Base, _Der >
struct	decay< _Ty >
struct	_Conjunction<>
struct	_Choose_conjunction< bool, _Lhs, _Traits >
struct	_Choose_conjunction< true, _Lhs, _Traits...>
struct	_Conjunction<>
struct	_Conjunction< _Trait >
struct	_Conjunction< _Lhs, _Traits...>
struct	conjunction< _Traits >
struct	_Disjunction<>
struct	_Choose_disjunction< bool, _Lhs, _Traits >
struct	_Choose_disjunction< false, _Lhs, _Traits...>
struct	_Disjunction<>
struct	_Disjunction< _Trait >
struct	_Disjunction< _Lhs, _Traits...>
struct	disjunction< _Traits >
struct	negation< _Trait >
struct	common_type< _Ty >
struct	common_type< _Ty >
struct	common_type< _Ty0, _Ty1 >
struct	common_type< _Ty0, _Ty1, _Ty...>
struct	integer_sequence< _Ty, _Vals >
struct	_Identity< _Ty >
struct	_Is_specialization< _Type, _Template >
struct	_Is_specialization< _Template< _Types...>, _Template >
struct	_Unrefwrap< _Ty >
struct	_Invoker_ret< _Rx, bool >
struct	_Unforced
struct	_Invoker_ret< _Cv_void, true >
struct	_Invoker_ret< _Rx, false >
struct	_Invoker_ret< _Unforced, false >
struct	_Unique_tag_result_of
struct	_Result_of< _Void, _Types >
struct	_Result_of< void_t< _Unique_tag_result_of, decltype(_STD invoke(_STD declval< _Types >()...))>, _Types...>
struct	result_of< _Fty >
struct	_Is_callable2< _Was_void, _Was_convertible, _Rx, _Types >
struct	_Is_callable2< false, true, _Rx, _Types...>
struct	_Is_callable2< false, false, _Rx, _Types...>
struct	_Unique_tag_is_callable
struct	_Is_callable1< _Void, _Rx, _Types >
struct	_Is_callable1< void_t< _Unique_tag_is_callable, decltype(_STD invoke(_STD declval< _Types >()...))>, _Rx, _Types...>
struct	_Weak_result_type< _Ty, class >
struct	_Weak_result_type< _Ty, void_t< typename _Ty::result_type > >
struct	_Weak_argument_type< _Ty, class >
struct	_Weak_argument_type< _Ty, void_t< typename _Ty::argument_type > >
struct	_Weak_binary_args< _Ty, class >
struct	_Weak_binary_args< _Ty, void_t< typename _Ty::first_argument_type, typename _Ty::second_argument_type > >
struct	_Weak_types< _Ty >
class	reference_wrapper< _Ty >
struct	_Unrefwrap_helper< _Ty >
struct	_Unrefwrap_helper< reference_wrapper< _Ty > >
struct	_Unrefwrap< _Ty >
struct	_Is_swappable< _Ty >
struct	_Is_nothrow_swappable< _Ty >
struct	_Swappable_with_helper< _Ty, class >
struct	_Swappable_with_helper_unique_type
struct	_Swappable_with_helper< _Ty1, _Ty2, void_t< _Swappable_with_helper_unique_type, decltype(swap(_STD declval< _Ty1 >(), _STD declval< _Ty2 >()))> >
struct	_Is_swappable_with< _Ty1, _Ty2 >
struct	_Is_swappable< _Ty >
struct	_Swap_cannot_throw< _Ty1, _Ty2 >
struct	_Is_nothrow_swappable_with< _Ty1, _Ty2 >
struct	_Is_nothrow_swappable< _Ty >

Macros
#define	_TYPE_TRAITS_
#define	_IS_FUNCTION(CALL_OPT, CV_REF_OPT, X1)
#define	_IS_FUNCTION_ELLIPSIS(CV_REF_OPT)
#define	_IS_MEMFUNPTR(CALL_OPT, CV_OPT, REF_OPT)
#define	_IS_MEMFUNPTR_ELLIPSIS(CV_REF_OPT)
#define	_IS_VOID(CV_OPT)
#define	_REMOVE_POINTER(CV_OPT)
#define	_FITS(_Ty)   _Align <= alignment_of<_Ty>::value
#define	_NEXT_ALIGN(_Ty)   typedef typename _Aligned<_Len, _Align, _Ty, _FITS(_Ty)>::type type
#define	_CONCATX(x, y)   x ## y
#define	_CONCAT(x, y)   _CONCATX(x, y)
#define	_IMPLEMENT_INVOKE(NAME_PREFIX, CONSTEXPR)
#define	_RESULT_OF(CALL_OPT, X1, X2)

Typedefs
template<class... _Types>
using	void_t = void
template<class... _Traits>
using	_Conjunction_t = typename conjunction< _Traits...>::type
template<class... _Traits>
using	_Disjunction_t = typename disjunction< _Traits...>::type
template<class _Ty , _Ty _Size>
using	make_integer_sequence = __make_integer_seq< integer_sequence, _Ty, _Size >
template<size_t... _Vals>
using	index_sequence = integer_sequence< size_t, _Vals...>
template<size_t _Size>
using	make_index_sequence = make_integer_sequence< size_t, _Size >
template<class... _Types>
using	index_sequence_for = make_index_sequence< sizeof...(_Types)>
template<class _Ty >
using	_Identity_t = typename _Identity< _Ty >::type
template<class _Ty >
using	remove_const_t = typename remove_const< _Ty >::type
template<class _Ty >
using	remove_volatile_t = typename remove_volatile< _Ty >::type
template<class _Ty >
using	remove_cv_t = typename remove_cv< _Ty >::type
template<class _Ty >
using	add_const_t = typename add_const< _Ty >::type
template<class _Ty >
using	add_volatile_t = typename add_volatile< _Ty >::type
template<class _Ty >
using	add_cv_t = typename add_cv< _Ty >::type
template<class _Ty >
using	remove_reference_t = typename remove_reference< _Ty >::type
template<class _Ty >
using	add_lvalue_reference_t = typename add_lvalue_reference< _Ty >::type
template<class _Ty >
using	add_rvalue_reference_t = typename add_rvalue_reference< _Ty >::type
template<class _Ty >
using	make_signed_t = typename make_signed< _Ty >::type
template<class _Ty >
using	make_unsigned_t = typename make_unsigned< _Ty >::type
template<class _Ty >
using	remove_extent_t = typename remove_extent< _Ty >::type
template<class _Ty >
using	remove_all_extents_t = typename remove_all_extents< _Ty >::type
template<class _Ty >
using	remove_pointer_t = typename remove_pointer< _Ty >::type
template<class _Ty >
using	add_pointer_t = typename add_pointer< _Ty >::type
template<size_t _Len, size_t _Align = alignment_of<max_align_t>::value>
using	aligned_storage_t = typename aligned_storage< _Len, _Align >::type
template<size_t _Len, class... _Types>
using	aligned_union_t = typename aligned_union< _Len, _Types...>::type
template<class _Ty >
using	decay_t = typename decay< _Ty >::type
template<bool _Test, class _Ty = void>
using	enable_if_t = typename enable_if< _Test, _Ty >::type
template<bool _Test, class _Ty1 , class _Ty2 >
using	conditional_t = typename conditional< _Test, _Ty1, _Ty2 >::type
template<class... _Ty>
using	common_type_t = typename common_type< _Ty...>::type
template<class _Ty >
using	underlying_type_t = typename underlying_type< _Ty >::type
template<class _Ty >
using	result_of_t = typename result_of< _Ty >::type

Functions
template<class _Ty >
add_rvalue_reference< _Ty >::type	declval () _NOEXCEPT
template<class _Ty >
constexpr _Ty &&	forward (typename remove_reference< _Ty >::type &_Arg) _NOEXCEPT
template<class _Ty >
constexpr _Ty &&	forward (typename remove_reference< _Ty >::type &&_Arg) _NOEXCEPT
template<class _Ty >
constexpr remove_reference< _Ty >::type &&	move (_Ty &&_Arg) _NOEXCEPT
template<class _Ty >
constexpr _If<!is_nothrow_move_constructible< _Ty >::value &&is_copy_constructible< _Ty >::value, const _Ty &, _Ty && >::type	move_if_noexcept (_Ty &_Arg) _NOEXCEPT
template<class _To >
void	_Implicitly_convert_to (_To) _NOEXCEPT
template<class _Ty >
reference_wrapper< _Ty >	ref (_Ty &_Val) _NOEXCEPT
template<class _Ty >
void	ref (const _Ty &&)=delete
template<class _Ty >
reference_wrapper< _Ty >	ref (reference_wrapper< _Ty > _Val) _NOEXCEPT
template<class _Ty >
reference_wrapper< const _Ty >	cref (const _Ty &_Val) _NOEXCEPT
template<class _Ty >
void	cref (const _Ty &&)=delete
template<class _Ty >
reference_wrapper< const _Ty >	cref (reference_wrapper< _Ty > _Val) _NOEXCEPT

Variables
template<class _Ty >
constexpr bool	is_function_v = is_function<_Ty>::value
template<class _Ty >
constexpr bool	is_void_v = is_void<_Ty>::value
template<class _Ty >
constexpr bool	is_null_pointer_v = is_null_pointer<_Ty>::value
template<class _Ty >
constexpr bool	is_array_v = is_array<_Ty>::value
template<class _Ty >
constexpr bool	is_pointer_v = is_pointer<_Ty>::value
template<class _Ty >
constexpr bool	is_lvalue_reference_v = is_lvalue_reference<_Ty>::value
template<class _Ty >
constexpr bool	is_rvalue_reference_v = is_rvalue_reference<_Ty>::value
template<class _Ty >
constexpr bool	is_member_object_pointer_v = is_member_object_pointer<_Ty>::value
template<class _Ty >
constexpr bool	is_member_function_pointer_v = is_member_function_pointer<_Ty>::value
template<class _Ty >
constexpr bool	is_enum_v = is_enum<_Ty>::value
template<class _Ty >
constexpr bool	is_union_v = is_union<_Ty>::value
template<class _Ty >
constexpr bool	is_class_v = is_class<_Ty>::value
template<class _Ty >
constexpr bool	is_reference_v = is_reference<_Ty>::value
template<class _Ty >
constexpr bool	is_fundamental_v = is_fundamental<_Ty>::value
template<class _Ty >
constexpr bool	is_object_v = is_object<_Ty>::value
template<class _Ty >
constexpr bool	is_scalar_v = is_scalar<_Ty>::value
template<class _Ty >
constexpr bool	is_compound_v = is_compound<_Ty>::value
template<class _Ty >
constexpr bool	is_member_pointer_v = is_member_pointer<_Ty>::value
template<class _Ty >
constexpr bool	is_const_v = is_const<_Ty>::value
template<class _Ty >
constexpr bool	is_volatile_v = is_volatile<_Ty>::value
template<class _Ty >
constexpr bool	is_trivial_v = is_trivial<_Ty>::value
template<class _Ty >
constexpr bool	is_trivially_copyable_v = is_trivially_copyable<_Ty>::value
template<class _Ty >
constexpr bool	is_standard_layout_v = is_standard_layout<_Ty>::value
template<class _Ty >
constexpr bool	is_pod_v = is_pod<_Ty>::value
template<class _Ty >
constexpr bool	is_literal_type_v = is_literal_type<_Ty>::value
template<class _Ty >
constexpr bool	is_empty_v = is_empty<_Ty>::value
template<class _Ty >
constexpr bool	is_polymorphic_v = is_polymorphic<_Ty>::value
template<class _Ty >
constexpr bool	is_abstract_v = is_abstract<_Ty>::value
template<class _Ty >
constexpr bool	is_final_v = is_final<_Ty>::value
template<class _Ty >
constexpr bool	is_signed_v = is_signed<_Ty>::value
template<class _Ty >
constexpr bool	is_unsigned_v = is_unsigned<_Ty>::value
template<class _Ty , class... _Args>
constexpr bool	is_constructible_v = is_constructible<_Ty, _Args...>::value
template<class _Ty >
constexpr bool	is_default_constructible_v = is_default_constructible<_Ty>::value
template<class _Ty >
constexpr bool	is_copy_constructible_v = is_copy_constructible<_Ty>::value
template<class _Ty >
constexpr bool	is_move_constructible_v = is_move_constructible<_Ty>::value
template<class _Ty , class _Uty >
constexpr bool	is_assignable_v = is_assignable<_Ty, _Uty>::value
template<class _Ty >
constexpr bool	is_copy_assignable_v = is_copy_assignable<_Ty>::value
template<class _Ty >
constexpr bool	is_move_assignable_v = is_move_assignable<_Ty>::value
template<class _Ty >
constexpr bool	is_destructible_v = is_destructible<_Ty>::value
template<class _Ty , class... _Args>
constexpr bool	is_trivially_constructible_v = is_trivially_constructible<_Ty, _Args...>::value
template<class _Ty >
constexpr bool	is_trivially_default_constructible_v = is_trivially_default_constructible<_Ty>::value
template<class _Ty >
constexpr bool	is_trivially_copy_constructible_v = is_trivially_copy_constructible<_Ty>::value
template<class _Ty >
constexpr bool	is_trivially_move_constructible_v = is_trivially_move_constructible<_Ty>::value
template<class _Ty , class _Uty >
constexpr bool	is_trivially_assignable_v = is_trivially_assignable<_Ty, _Uty>::value
template<class _Ty >
constexpr bool	is_trivially_copy_assignable_v = is_trivially_copy_assignable<_Ty>::value
template<class _Ty >
constexpr bool	is_trivially_move_assignable_v = is_trivially_move_assignable<_Ty>::value
template<class _Ty >
constexpr bool	is_trivially_destructible_v = is_trivially_destructible<_Ty>::value
template<class _Ty , class... _Args>
constexpr bool	is_nothrow_constructible_v = is_nothrow_constructible<_Ty, _Args...>::value
template<class _Ty >
constexpr bool	is_nothrow_default_constructible_v = is_nothrow_default_constructible<_Ty>::value
template<class _Ty >
constexpr bool	is_nothrow_copy_constructible_v = is_nothrow_copy_constructible<_Ty>::value
template<class _Ty >
constexpr bool	is_nothrow_move_constructible_v = is_nothrow_move_constructible<_Ty>::value
template<class _Ty , class _Uty >
constexpr bool	is_nothrow_assignable_v = is_nothrow_assignable<_Ty, _Uty>::value
template<class _Ty >
constexpr bool	is_nothrow_copy_assignable_v = is_nothrow_copy_assignable<_Ty>::value
template<class _Ty >
constexpr bool	is_nothrow_move_assignable_v = is_nothrow_move_assignable<_Ty>::value
template<class _Ty >
constexpr bool	is_nothrow_destructible_v = is_nothrow_destructible<_Ty>::value
template<class _Ty >
constexpr bool	has_virtual_destructor_v = has_virtual_destructor<_Ty>::value
template<class _Ty >
constexpr size_t	alignment_of_v = alignment_of<_Ty>::value
template<class _Ty >
constexpr size_t	rank_v = rank<_Ty>::value
template<class _Ty , unsigned int _Ix = 0>
constexpr size_t	extent_v = extent<_Ty, _Ix>::value
template<class _Base , class _Derived >
constexpr bool	is_base_of_v = is_base_of<_Base, _Derived>::value
template<class _From , class _To >
constexpr bool	is_convertible_v = is_convertible<_From, _To>::value
template<class... _Traits>
constexpr bool	conjunction_v = conjunction<_Traits...>::value
template<class... _Traits>
constexpr bool	disjunction_v = disjunction<_Traits...>::value
template<class _Trait >
constexpr bool	negation_v = negation<_Trait>::value

Macro Definition Documentation

#define _CONCAT	(		x,
			y
	)		_CONCATX(x, y)

#define _CONCATX	(		x,
			y
	)		x ## y

#define _FITS

(

_Ty

)

_Align <= alignment_of<_Ty>::value

#define _IMPLEMENT_INVOKE	(		NAME_PREFIX,
			CONSTEXPR
	)

#define _IS_FUNCTION	(		CALL_OPT,
			CV_REF_OPT,
			X1
	)

Value:

template<class _Ret, \
    class... _Types> \
    struct _Is_function<_Ret CALL_OPT (_Types...) CV_REF_OPT> \
        : _Arg_types<_Types...> \
    {   /* determine whether _Ty is a function */ \
    typedef true_type _Bool_type; \
    typedef _Ret result_type; \
    };

#define _IS_FUNCTION_ELLIPSIS

(

CV_REF_OPT

)

Value:

template<class _Ret, \
    class... _Types> \
    struct _Is_function<_Ret (_Types..., ...) CV_REF_OPT> \
    {   /* no calling conventions for ellipsis */ \
    typedef true_type _Bool_type; \
    typedef _Ret result_type; \
    };

#define _IS_MEMFUNPTR	(		CALL_OPT,
			CV_OPT,
			REF_OPT
	)

Value:

template<class _Ret, \
    class _Arg0, \
    class... _Types> \
    struct _Is_memfunptr<_Ret (CALL_OPT _Arg0::*)(_Types...) CV_OPT REF_OPT> \
        : _Arg_types<CV_OPT _Arg0 *, _Types...> \
    {   /* base class for member function pointer predicates */ \
    typedef true_type _Bool_type; \
    typedef _Ret result_type; \
    typedef _Arg0 _Class_type; \
    };

#define _IS_MEMFUNPTR_ELLIPSIS

(

CV_REF_OPT

)

Value:

template<class _Ret, \
    class _Arg0, \
    class... _Types> \
    struct _Is_memfunptr<_Ret (_Arg0::*)(_Types..., ...) CV_REF_OPT> \
    {   /* no calling conventions for ellipsis */ \
    typedef true_type _Bool_type; \
    typedef _Ret result_type; \
    typedef _Arg0 _Class_type; \
    };

#define _IS_VOID

(

CV_OPT

)

Value:

template<> \
    struct is_void<CV_OPT void> \
        : true_type \
    {   /* determine whether _Ty is void */ \
    };

#define _NEXT_ALIGN

(

_Ty

)

typedef typename _Aligned<_Len, _Align, _Ty, _FITS(_Ty)>::type type

#define _REMOVE_POINTER

(

CV_OPT

)

Value:

template<class _Ty> \
    struct remove_pointer<_Ty *CV_OPT> \
    {   /* remove pointer */ \
    typedef _Ty type; \
    };

#define _RESULT_OF	(		CALL_OPT,
			X1,
			X2
	)

Value:

template<class _Callable, \
    class... _Args> \
    struct result_of<_Callable CALL_OPT (_Args...)> \
        : _Result_of<void, _Callable, _Args...> \
    {   /* template to determine result of call operation */ \
    };

#define _TYPE_TRAITS_

Typedef Documentation

template<class... _Traits>

using _Conjunction_t = typename conjunction<_Traits...>::type

template<class... _Traits>

using _Disjunction_t = typename disjunction<_Traits...>::type

template<class _Ty >

using _Identity_t = typename _Identity<_Ty>::type

template<class _Ty >

using add_const_t = typename add_const<_Ty>::type

template<class _Ty >

using add_cv_t = typename add_cv<_Ty>::type

template<class _Ty >

using add_lvalue_reference_t = typename add_lvalue_reference<_Ty>::type

template<class _Ty >

using add_pointer_t = typename add_pointer<_Ty>::type

template<class _Ty >

using add_rvalue_reference_t = typename add_rvalue_reference<_Ty>::type

template<class _Ty >

using add_volatile_t = typename add_volatile<_Ty>::type

template<size_t _Len, size_t _Align = alignment_of<max_align_t>::value>

using aligned_storage_t = typename aligned_storage<_Len, _Align>::type

template<size_t _Len, class... _Types>

using aligned_union_t = typename aligned_union<_Len, _Types...>::type

template<class... _Ty>

using common_type_t = typename common_type<_Ty...>::type

template<bool _Test, class _Ty1 , class _Ty2 >

using conditional_t = typename conditional<_Test, _Ty1, _Ty2>::type

template<class _Ty >

using decay_t = typename decay<_Ty>::type

template<bool _Test, class _Ty = void>

using enable_if_t = typename enable_if<_Test, _Ty>::type

template<size_t... _Vals>

using index_sequence = integer_sequence<size_t, _Vals...>

template<class... _Types>

using index_sequence_for = make_index_sequence<sizeof...(_Types)>

template<size_t _Size>

using make_index_sequence = make_integer_sequence<size_t, _Size>

template<class _Ty , _Ty _Size>

using make_integer_sequence = __make_integer_seq<integer_sequence, _Ty, _Size>

template<class _Ty >

using make_signed_t = typename make_signed<_Ty>::type

template<class _Ty >

using make_unsigned_t = typename make_unsigned<_Ty>::type

template<class _Ty >

using remove_all_extents_t = typename remove_all_extents<_Ty>::type

template<class _Ty >

using remove_const_t = typename remove_const<_Ty>::type

template<class _Ty >

using remove_cv_t = typename remove_cv<_Ty>::type

template<class _Ty >

using remove_extent_t = typename remove_extent<_Ty>::type

template<class _Ty >

using remove_pointer_t = typename remove_pointer<_Ty>::type

template<class _Ty >

using remove_reference_t = typename remove_reference<_Ty>::type

template<class _Ty >

using remove_volatile_t = typename remove_volatile<_Ty>::type

template<class _Ty >

using result_of_t = typename result_of<_Ty>::type

template<class _Ty >

using underlying_type_t = typename underlying_type<_Ty>::type

template<class... _Types>

using void_t = void

Function Documentation

template<class _To >

void _Implicitly_convert_to

(

_To

)

template<class _Ty >

reference_wrapper<const _Ty> cref ( const _Ty &  _Val )

inline

    {   // create reference_wrapper<const _Ty> object
    return (reference_wrapper<const _Ty>(_Val));
    }

template<class _Ty >

void cref ( const _Ty &&  )

delete

template<class _Ty >

reference_wrapper<const _Ty> cref ( reference_wrapper< _Ty >  _Val )

inline

    {   // create reference_wrapper<const _Ty> object
    return (_STD cref(_Val.get()));
    }

template<class _Ty >

add_rvalue_reference<_Ty>::type declval

(

)

template<class _Ty >

constexpr _Ty&& forward ( typename remove_reference< _Ty >::type &  _Arg )

inline

    {   // forward an lvalue as either an lvalue or an rvalue
    return (static_cast<_Ty&&>(_Arg));
    }

template<class _Ty >

constexpr _Ty&& forward ( typename remove_reference< _Ty >::type &&  _Arg )

inline

    {   // forward an rvalue as an rvalue
    static_assert(!is_lvalue_reference<_Ty>::value, "bad forward call");
    return (static_cast<_Ty&&>(_Arg));
    }

template<class _Ty >

constexpr remove_reference<_Ty>::type&& move ( _Ty &&  _Arg )

inline

    {   // forward _Arg as movable
    return (static_cast<typename remove_reference<_Ty>::type&&>(_Arg));
    }

template<class _Ty >

constexpr _If<!is_nothrow_move_constructible<_Ty>::value && is_copy_constructible<_Ty>::value, const _Ty&, _Ty&&>::type move_if_noexcept ( _Ty &  _Arg )

inline

    {   // forward _Arg as movable, sometimes
    return (_STD move(_Arg));
    }

template<class _Ty >

reference_wrapper<_Ty> ref ( _Ty &  _Val )

inline

    {   // create reference_wrapper<_Ty> object
    return (reference_wrapper<_Ty>(_Val));
    }

template<class _Ty >

void ref ( const _Ty &&  )

delete

template<class _Ty >

reference_wrapper<_Ty> ref ( reference_wrapper< _Ty >  _Val )

inline

    {   // create reference_wrapper<_Ty> object
    return (_STD ref(_Val.get()));
    }

Variable Documentation

template<class _Ty >

constexpr size_t alignment_of_v = alignment_of<_Ty>::value

template<class... _Traits>

constexpr bool conjunction_v = conjunction<_Traits...>::value

template<class... _Traits>

constexpr bool disjunction_v = disjunction<_Traits...>::value

template<class _Ty , unsigned int _Ix = 0>

constexpr size_t extent_v = extent<_Ty, _Ix>::value

template<class _Ty >

constexpr bool has_virtual_destructor_v = has_virtual_destructor<_Ty>::value

template<class _Ty >

constexpr bool is_abstract_v = is_abstract<_Ty>::value

template<class _Ty >

constexpr bool is_array_v = is_array<_Ty>::value

template<class _Ty , class _Uty >

constexpr bool is_assignable_v = is_assignable<_Ty, _Uty>::value

template<class _Base , class _Derived >

constexpr bool is_base_of_v = is_base_of<_Base, _Derived>::value

template<class _Ty >

constexpr bool is_class_v = is_class<_Ty>::value

template<class _Ty >

constexpr bool is_compound_v = is_compound<_Ty>::value

template<class _Ty >

constexpr bool is_const_v = is_const<_Ty>::value

template<class _Ty , class... _Args>

constexpr bool is_constructible_v = is_constructible<_Ty, _Args...>::value

template<class _From , class _To >

constexpr bool is_convertible_v = is_convertible<_From, _To>::value

template<class _Ty >

constexpr bool is_copy_assignable_v = is_copy_assignable<_Ty>::value

template<class _Ty >

constexpr bool is_copy_constructible_v = is_copy_constructible<_Ty>::value

template<class _Ty >

constexpr bool is_default_constructible_v = is_default_constructible<_Ty>::value

template<class _Ty >

constexpr bool is_destructible_v = is_destructible<_Ty>::value

template<class _Ty >

constexpr bool is_empty_v = is_empty<_Ty>::value

template<class _Ty >

constexpr bool is_enum_v = is_enum<_Ty>::value

template<class _Ty >

constexpr bool is_final_v = is_final<_Ty>::value

template<class _Ty >

constexpr bool is_function_v = is_function<_Ty>::value

template<class _Ty >

constexpr bool is_fundamental_v = is_fundamental<_Ty>::value

template<class _Ty >

constexpr bool is_literal_type_v = is_literal_type<_Ty>::value

template<class _Ty >

constexpr bool is_lvalue_reference_v = is_lvalue_reference<_Ty>::value

template<class _Ty >

constexpr bool is_member_function_pointer_v = is_member_function_pointer<_Ty>::value

template<class _Ty >

constexpr bool is_member_object_pointer_v = is_member_object_pointer<_Ty>::value

template<class _Ty >

constexpr bool is_member_pointer_v = is_member_pointer<_Ty>::value

template<class _Ty >

constexpr bool is_move_assignable_v = is_move_assignable<_Ty>::value

template<class _Ty >

constexpr bool is_move_constructible_v = is_move_constructible<_Ty>::value

template<class _Ty , class _Uty >

constexpr bool is_nothrow_assignable_v = is_nothrow_assignable<_Ty, _Uty>::value

template<class _Ty , class... _Args>

constexpr bool is_nothrow_constructible_v = is_nothrow_constructible<_Ty, _Args...>::value

template<class _Ty >

constexpr bool is_nothrow_copy_assignable_v = is_nothrow_copy_assignable<_Ty>::value

template<class _Ty >

constexpr bool is_nothrow_copy_constructible_v = is_nothrow_copy_constructible<_Ty>::value

template<class _Ty >

constexpr bool is_nothrow_default_constructible_v = is_nothrow_default_constructible<_Ty>::value

template<class _Ty >

constexpr bool is_nothrow_destructible_v = is_nothrow_destructible<_Ty>::value

template<class _Ty >

constexpr bool is_nothrow_move_assignable_v = is_nothrow_move_assignable<_Ty>::value

template<class _Ty >

constexpr bool is_nothrow_move_constructible_v = is_nothrow_move_constructible<_Ty>::value

template<class _Ty >

constexpr bool is_null_pointer_v = is_null_pointer<_Ty>::value

template<class _Ty >

constexpr bool is_object_v = is_object<_Ty>::value

template<class _Ty >

constexpr bool is_pod_v = is_pod<_Ty>::value

template<class _Ty >

constexpr bool is_pointer_v = is_pointer<_Ty>::value

template<class _Ty >

constexpr bool is_polymorphic_v = is_polymorphic<_Ty>::value

template<class _Ty >

constexpr bool is_reference_v = is_reference<_Ty>::value

template<class _Ty >

constexpr bool is_rvalue_reference_v = is_rvalue_reference<_Ty>::value

template<class _Ty >

constexpr bool is_scalar_v = is_scalar<_Ty>::value

template<class _Ty >

constexpr bool is_signed_v = is_signed<_Ty>::value

template<class _Ty >

constexpr bool is_standard_layout_v = is_standard_layout<_Ty>::value

template<class _Ty >

constexpr bool is_trivial_v = is_trivial<_Ty>::value

template<class _Ty , class _Uty >

constexpr bool is_trivially_assignable_v = is_trivially_assignable<_Ty, _Uty>::value

template<class _Ty , class... _Args>

constexpr bool is_trivially_constructible_v = is_trivially_constructible<_Ty, _Args...>::value

template<class _Ty >

constexpr bool is_trivially_copy_assignable_v = is_trivially_copy_assignable<_Ty>::value

template<class _Ty >

constexpr bool is_trivially_copy_constructible_v = is_trivially_copy_constructible<_Ty>::value

template<class _Ty >

constexpr bool is_trivially_copyable_v = is_trivially_copyable<_Ty>::value

template<class _Ty >

constexpr bool is_trivially_default_constructible_v = is_trivially_default_constructible<_Ty>::value

template<class _Ty >

constexpr bool is_trivially_destructible_v = is_trivially_destructible<_Ty>::value

template<class _Ty >

constexpr bool is_trivially_move_assignable_v = is_trivially_move_assignable<_Ty>::value

template<class _Ty >

constexpr bool is_trivially_move_constructible_v = is_trivially_move_constructible<_Ty>::value

template<class _Ty >

constexpr bool is_union_v = is_union<_Ty>::value

template<class _Ty >

constexpr bool is_unsigned_v = is_unsigned<_Ty>::value

template<class _Ty >

constexpr bool is_void_v = is_void<_Ty>::value

template<class _Ty >

constexpr bool is_volatile_v = is_volatile<_Ty>::value

template<class _Trait >

constexpr bool negation_v = negation<_Trait>::value

template<class _Ty >

constexpr size_t rank_v = rank<_Ty>::value