libstdc++
Utilities
Collaboration diagram for Utilities:

Modules

 Function Objects
 
 Memory
 
 Metaprogramming
 
 Rational Arithmetic
 
 Time
 

Classes

struct  std::_Tuple_impl< _Idx, _Elements >
 
struct  std::_Tuple_impl< _Idx, _Head, _Tail...>
 
class  std::bitset< _Nb >
 
struct  std::pair< _T1, _T2 >
 
struct  std::piecewise_construct_t
 
class  std::tuple< _Elements >
 
class  std::tuple< _T1, _T2 >
 
struct  std::tuple_element< 0, tuple< _Head, _Tail...> >
 
struct  std::tuple_element< __i, tuple< _Head, _Tail...> >
 
struct  std::tuple_element< __i, tuple<> >
 
struct  std::tuple_size< tuple< _Elements...> >
 
struct  std::type_index
 
struct  std::uses_allocator< tuple< _Types...>, _Alloc >
 

Macros

#define __cpp_lib_tuples_by_type
 

Typedefs

typedef __tuple_concater
< __ret, __idx, _Tpls...> 
std::__concater
 
template<typename _Tp >
using std::__empty_not_final = typename conditional< __is_final(_Tp), false_type, __is_empty_non_tuple< _Tp >>::type
 
typedef __make_1st_indices
< _Tpls...>::__type 
std::__idx
 
typedef __combine_tuples
< typename __make_tuple< _Tpls >
::__type...>::__type 
std::__tuple_cat_result< _Tpls >::__type
 

Functions

template<typename... _Args1, typename... _Args2>
 std::pair< _T1, _T2 >::pair (piecewise_construct_t, tuple< _Args1...>, tuple< _Args2...>)
 
template<typename _Tp >
constexpr _Tp * std::__addressof (_Tp &__r) noexcept
 
template<typename _Tp , typename _Up = _Tp>
_Tp std::__exchange (_Tp &__obj, _Up &&__new_val)
 
template<std::size_t __i, typename _Head , typename... _Tail>
constexpr _Head & std::__get_helper (_Tuple_impl< __i, _Head, _Tail...> &__t) noexcept
 
template<std::size_t __i, typename _Head , typename... _Tail>
constexpr const _Head & std::__get_helper (const _Tuple_impl< __i, _Head, _Tail...> &__t) noexcept
 
template<typename _Head , size_t __i, typename... _Tail>
constexpr _Head & std::__get_helper2 (_Tuple_impl< __i, _Head, _Tail...> &__t) noexcept
 
template<typename _Head , size_t __i, typename... _Tail>
constexpr const _Head & std::__get_helper2 (const _Tuple_impl< __i, _Head, _Tail...> &__t) noexcept
 
template<typename _Tp , typename _Up = typename __inv_unwrap<_Tp>::type>
constexpr _Up && std::__invfwd (typename remove_reference< _Tp >::type &__t) noexcept
 
template<typename _Res , typename _Fn , typename... _Args>
constexpr _Res std::__invoke_impl (__invoke_other, _Fn &&__f, _Args &&...__args)
 
template<typename _Res , typename _MemFun , typename _Tp , typename... _Args>
constexpr _Res std::__invoke_impl (__invoke_memfun_ref, _MemFun &&__f, _Tp &&__t, _Args &&...__args)
 
template<typename _Res , typename _MemFun , typename _Tp , typename... _Args>
constexpr _Res std::__invoke_impl (__invoke_memfun_deref, _MemFun &&__f, _Tp &&__t, _Args &&...__args)
 
template<typename _Res , typename _MemPtr , typename _Tp >
constexpr _Res std::__invoke_impl (__invoke_memobj_ref, _MemPtr &&__f, _Tp &&__t)
 
template<typename _Res , typename _MemPtr , typename _Tp >
constexpr _Res std::__invoke_impl (__invoke_memobj_deref, _MemPtr &&__f, _Tp &&__t)
 
template<typename _Tp >
_GLIBCXX17_CONSTEXPR _Tp * std::addressof (_Tp &__r) noexcept
 
template<typename _Tp >
const _Tp * std::addressof (const _Tp &&)=delete
 
template<typename _Tp >
constexpr _Tp && std::forward (typename std::remove_reference< _Tp >::type &__t) noexcept
 
template<typename _Tp >
constexpr _Tp && std::forward (typename std::remove_reference< _Tp >::type &&__t) noexcept
 
template<typename... _Elements>
constexpr tuple< _Elements &&...> std::forward_as_tuple (_Elements &&...__args) noexcept
 
template<std::size_t __i, typename... _Elements>
constexpr __tuple_element_t
< __i, tuple< _Elements...> > & 
std::get (tuple< _Elements...> &__t) noexcept
 
template<std::size_t __i, typename... _Elements>
constexpr const
__tuple_element_t< __i, tuple
< _Elements...> > & 
std::get (const tuple< _Elements...> &__t) noexcept
 
template<std::size_t __i, typename... _Elements>
constexpr __tuple_element_t
< __i, tuple< _Elements...> > && 
std::get (tuple< _Elements...> &&__t) noexcept
 
template<typename _Tp , typename... _Types>
constexpr _Tp & std::get (tuple< _Types...> &__t) noexcept
 
template<typename _Tp , typename... _Types>
constexpr _Tp && std::get (tuple< _Types...> &&__t) noexcept
 
template<typename _Tp , typename... _Types>
constexpr const _Tp & std::get (const tuple< _Types...> &__t) noexcept
 
template<typename _T1 , typename _T2 >
constexpr pair< typename
__decay_and_strip< _T1 >
::__type, typename
__decay_and_strip< _T2 >
::__type > 
std::make_pair (_T1 &&__x, _T2 &&__y)
 
template<typename... _Elements>
constexpr tuple< typename
__decay_and_strip< _Elements >
::__type...> 
std::make_tuple (_Elements &&...__args)
 
template<typename _Tp >
constexpr
std::remove_reference< _Tp >
::type && 
std::move (_Tp &&__t) noexcept
 
template<typename _Tp >
constexpr conditional
< __move_if_noexcept_cond< _Tp >
::value, const _Tp &, _Tp && >
::type 
std::move_if_noexcept (_Tp &__x) noexcept
 
template<typename _Callable , typename... _Args>
constexpr __invoke_result
< _Callable, _Args...>::type 
std::noexcept (__is_nothrow_invocable< _Callable, _Args...>::value)
 
template<typename _Tp >
enable_if< __and_< __not_
< __is_tuple_like< _Tp >
>, is_move_constructible< _Tp >
, is_move_assignable< _Tp >
>::value >::type 
std::noexcept (__and_< is_nothrow_move_constructible< _Tp >, is_nothrow_move_assignable< _Tp >>::value)
 
template<typename _T1 , typename _T2 >
enable_if< __and_
< __is_swappable< _T1 >
, __is_swappable< _T2 >
>::value >::type 
std::noexcept (noexcept(__x.swap(__y)))
 
template<typename... _Elements>
enable_if< __and_
< __is_swappable< _Elements >
...>::value >::type 
std::noexcept (noexcept(__x.swap(__y)))
 
template<typename _T1 , typename _T2 >
constexpr bool std::operator!= (const pair< _T1, _T2 > &__x, const pair< _T1, _T2 > &__y)
 
template<typename... _TElements, typename... _UElements>
constexpr bool std::operator!= (const tuple< _TElements...> &__t, const tuple< _UElements...> &__u)
 
template<typename _T1 , typename _T2 >
constexpr bool std::operator< (const pair< _T1, _T2 > &__x, const pair< _T1, _T2 > &__y)
 
template<typename... _TElements, typename... _UElements>
constexpr bool std::operator< (const tuple< _TElements...> &__t, const tuple< _UElements...> &__u)
 
template<typename _T1 , typename _T2 >
constexpr bool std::operator<= (const pair< _T1, _T2 > &__x, const pair< _T1, _T2 > &__y)
 
template<typename... _TElements, typename... _UElements>
constexpr bool std::operator<= (const tuple< _TElements...> &__t, const tuple< _UElements...> &__u)
 
template<typename _T1 , typename _T2 >
constexpr bool std::operator== (const pair< _T1, _T2 > &__x, const pair< _T1, _T2 > &__y)
 
template<typename... _TElements, typename... _UElements>
constexpr bool std::operator== (const tuple< _TElements...> &__t, const tuple< _UElements...> &__u)
 
template<typename _T1 , typename _T2 >
constexpr bool std::operator> (const pair< _T1, _T2 > &__x, const pair< _T1, _T2 > &__y)
 
template<typename... _TElements, typename... _UElements>
constexpr bool std::operator> (const tuple< _TElements...> &__t, const tuple< _UElements...> &__u)
 
template<typename _T1 , typename _T2 >
constexpr bool std::operator>= (const pair< _T1, _T2 > &__x, const pair< _T1, _T2 > &__y)
 
template<typename... _TElements, typename... _UElements>
constexpr bool std::operator>= (const tuple< _TElements...> &__t, const tuple< _UElements...> &__u)
 
template<typename _Tp , size_t _Nm>
enable_if< __is_swappable< _Tp >
::value >::type 
std::swap (_Tp(&__a)[_Nm], _Tp(&__b)[_Nm])
 
template<typename _T1 , typename _T2 >
enable_if<!__and_
< __is_swappable< _T1 >
, __is_swappable< _T2 >
>::value >::type 
std::swap (pair< _T1, _T2 > &, pair< _T1, _T2 > &)=delete
 
template<typename... _Elements>
enable_if<!__and_
< __is_swappable< _Elements >
...>::value >::type 
std::swap (tuple< _Elements...> &, tuple< _Elements...> &)=delete
 
template<typename... _Elements>
constexpr tuple< _Elements &...> std::tie (_Elements &...__args) noexcept
 

Variables

_GLIBCXX17_INLINE constexpr
_Swallow_assign 
std::ignore
 
_GLIBCXX17_INLINE constexpr
piecewise_construct_t 
std::piecewise_construct
 

Detailed Description

Components deemed generally useful. Includes pair, tuple, forward/move helpers, ratio, function object, metaprogramming and type traits, time, date, and memory functions.

Typedef Documentation

template<typename... _Tpls>
constexpr auto std::__tuple_cat_result< _Tpls, typename >::__type

tuple_cat

Definition at line 1518 of file tuple.

Function Documentation

template<typename _Tp >
_GLIBCXX17_CONSTEXPR _Tp* std::addressof ( _Tp &  __r)
inlinenoexcept

Returns the actual address of the object or function referenced by r, even in the presence of an overloaded operator&.

Parameters
__rReference to an object or function.
Returns
The actual address.

Definition at line 137 of file move.h.

References std::__addressof().

Referenced by std::pointer_traits< _Tp * >::pointer_to().

template<typename _Tp >
constexpr _Tp&& std::forward ( typename std::remove_reference< _Tp >::type &  __t)
noexcept

Forward an lvalue.

Returns
The parameter cast to the specified type.

This function is used to implement "perfect forwarding".

Definition at line 73 of file move.h.

template<typename _Tp >
constexpr _Tp&& std::forward ( typename std::remove_reference< _Tp >::type &&  __t)
noexcept

Forward an rvalue.

Returns
The parameter cast to the specified type.

This function is used to implement "perfect forwarding".

Definition at line 84 of file move.h.

template<std::size_t __i, typename... _Elements>
constexpr __tuple_element_t<__i, tuple<_Elements...> >& std::get ( tuple< _Elements...> &  __t)
noexcept

Return a reference to the ith element of a tuple.

Definition at line 1314 of file tuple.

template<std::size_t __i, typename... _Elements>
constexpr const __tuple_element_t<__i, tuple<_Elements...> >& std::get ( const tuple< _Elements...> &  __t)
noexcept

Return a const reference to the ith element of a const tuple.

Definition at line 1320 of file tuple.

template<std::size_t __i, typename... _Elements>
constexpr __tuple_element_t<__i, tuple<_Elements...> >&& std::get ( tuple< _Elements...> &&  __t)
noexcept

Return an rvalue reference to the ith element of a tuple rvalue.

Definition at line 1326 of file tuple.

template<typename _Tp , typename... _Types>
constexpr _Tp& std::get ( tuple< _Types...> &  __t)
noexcept

Return a reference to the unique element of type _Tp of a tuple.

Definition at line 1349 of file tuple.

template<typename _Tp , typename... _Types>
constexpr _Tp&& std::get ( tuple< _Types...> &&  __t)
noexcept

Return a reference to the unique element of type _Tp of a tuple rvalue.

Definition at line 1355 of file tuple.

template<typename _Tp , typename... _Types>
constexpr const _Tp& std::get ( const tuple< _Types...> &  __t)
noexcept

Return a const reference to the unique element of type _Tp of a tuple.

Definition at line 1361 of file tuple.

template<typename _T1 , typename _T2 >
constexpr pair<typename __decay_and_strip<_T1>::__type, typename __decay_and_strip<_T2>::__type> std::make_pair ( _T1 &&  __x,
_T2 &&  __y 
)
template<typename _Tp >
constexpr std::remove_reference<_Tp>::type&& std::move ( _Tp &&  __t)
noexcept

Convert a value to an rvalue.

Parameters
__tA thing of arbitrary type.
Returns
The parameter cast to an rvalue-reference to allow moving it.

Definition at line 98 of file move.h.

template<typename _Tp >
constexpr conditional<__move_if_noexcept_cond<_Tp>::value, const _Tp&, _Tp&&>::type std::move_if_noexcept ( _Tp &  __x)
noexcept

Conditionally convert a value to an rvalue.

Parameters
__xA thing of arbitrary type.
Returns
The parameter, possibly cast to an rvalue-reference.

Same as std::move unless the type's move constructor could throw and the type is copyable, in which case an lvalue-reference is returned instead.

Definition at line 118 of file move.h.

template<typename _Callable , typename... _Args>
constexpr __invoke_result<_Callable, _Args...>::type std::noexcept ( __is_nothrow_invocable< _Callable, _Args...>::value  )

Invoke a callable object.

Definition at line 90 of file invoke.h.

template<typename _Tp >
enable_if<__and_<__not_<__is_tuple_like<_Tp> >, is_move_constructible<_Tp>, is_move_assignable<_Tp> >::value>::type std::noexcept ( __and_< is_nothrow_move_constructible< _Tp >, is_nothrow_move_assignable< _Tp >>::value  )
inline

Swaps two values.

Parameters
__aA thing of arbitrary type.
__bAnother thing of arbitrary type.
Returns
Nothing.

Definition at line 188 of file move.h.

template<typename _T1 , typename _T2 >
enable_if<__and_<__is_swappable<_T1>, __is_swappable<_T2> >::value>::type std::noexcept ( noexcept(__x.swap(__y))  )
inline

See std::pair::swap().

Definition at line 491 of file stl_pair.h.

template<typename... _Elements>
enable_if<__and_<__is_swappable<_Elements>...>::value >::type std::noexcept ( noexcept(__x.swap(__y))  )
inline

swap

Definition at line 1603 of file tuple.

template<typename _T1 , typename _T2 >
constexpr bool std::operator!= ( const pair< _T1, _T2 > &  __x,
const pair< _T1, _T2 > &  __y 
)
inline

Uses operator== to find the result.

Definition at line 456 of file stl_pair.h.

template<typename _T1 , typename _T2 >
constexpr bool std::operator< ( const pair< _T1, _T2 > &  __x,
const pair< _T1, _T2 > &  __y 
)
inline
template<typename _T1 , typename _T2 >
constexpr bool std::operator<= ( const pair< _T1, _T2 > &  __x,
const pair< _T1, _T2 > &  __y 
)
inline

Uses operator< to find the result.

Definition at line 468 of file stl_pair.h.

template<typename _T1 , typename _T2 >
constexpr bool std::operator== ( const pair< _T1, _T2 > &  __x,
const pair< _T1, _T2 > &  __y 
)
inline

Two pairs of the same type are equal iff their members are equal.

Definition at line 443 of file stl_pair.h.

References std::pair< _T1, _T2 >::first, and std::pair< _T1, _T2 >::second.

template<typename _T1 , typename _T2 >
constexpr bool std::operator> ( const pair< _T1, _T2 > &  __x,
const pair< _T1, _T2 > &  __y 
)
inline

Uses operator< to find the result.

Definition at line 462 of file stl_pair.h.

template<typename _T1 , typename _T2 >
constexpr bool std::operator>= ( const pair< _T1, _T2 > &  __x,
const pair< _T1, _T2 > &  __y 
)
inline

Uses operator< to find the result.

Definition at line 474 of file stl_pair.h.

template<typename _Tp , size_t _Nm>
enable_if<__is_swappable<_Tp>::value>::type std::swap ( _Tp(&)  __a[_Nm],
_Tp(&)  __b[_Nm] 
)
inline

Swap the contents of two arrays.

Definition at line 210 of file move.h.

template<typename... _Elements>
constexpr tuple<_Elements&...> std::tie ( _Elements &...  __args)
noexcept

tie

Definition at line 1589 of file tuple.

Referenced by std::basic_ios< _CharT, _Traits >::copyfmt(), std::lock(), and std::try_lock().

Variable Documentation

_GLIBCXX17_INLINE constexpr piecewise_construct_t std::piecewise_construct

piecewise_construct

Definition at line 79 of file stl_pair.h.

Referenced by std::map< _Key, _Tp, _Compare, _Alloc >::operator[]().