libstdc++
Utilities
Collaboration diagram for Utilities:

Modules

 Function Objects
 
 Memory
 
 Metaprogramming
 
 Rational Arithmetic
 
 Time
 

Classes

struct  std::_Tuple_impl< _Idx, _Elements >
 
class  std::optional< _Tp >
 
class  std::tuple< _Elements >
 
struct  std::tuple_element< __i, tuple< _Head, _Tail... > >
 
struct  std::tuple_size< tuple< _Elements... > >
 
struct  std::uses_allocator< tuple< _Types... >, _Alloc >
 

Macros

#define __cpp_lib_addressof_constexpr
 
#define __cpp_lib_any
 
#define __cpp_lib_apply
 
#define __cpp_lib_make_from_tuple
 
#define __cpp_lib_optional
 
#define __cpp_lib_tuples_by_type
 

Typedefs

template<typename _Tp , typename _Up >
using std::__assigns_from_optional = __or_< is_assignable< _Tp &, const optional< _Up > & >, is_assignable< _Tp &, optional< _Up > & >, is_assignable< _Tp &, const optional< _Up > && >, is_assignable< _Tp &, optional< _Up > && > >
 
template<typename _Tp , typename _Up >
using std::__converts_from_optional = __or_< is_constructible< _Tp, const optional< _Up > & >, is_constructible< _Tp, optional< _Up > & >, is_constructible< _Tp, const optional< _Up > && >, is_constructible< _Tp, optional< _Up > && >, is_convertible< const optional< _Up > &, _Tp >, is_convertible< optional< _Up > &, _Tp >, is_convertible< const optional< _Up > &&, _Tp >, is_convertible< optional< _Up > &&, _Tp > >
 
template<typename _Tp >
using std::__empty_not_final = typename conditional< __is_final(_Tp), false_type, __is_empty_non_tuple< _Tp > >::type
 
template<typename _Tp , typename _Up >
using std::__optional_eq_t = __optional_relop_t< decltype(std::declval< const _Tp & >()==std::declval< const _Up & >()) >
 
template<typename _Tp , typename _Up >
using std::__optional_ge_t = __optional_relop_t< decltype(std::declval< const _Tp & >() >=std::declval< const _Up & >()) >
 
template<typename _Tp , typename _Up >
using std::__optional_gt_t = __optional_relop_t< decltype(std::declval< const _Tp & >() > std::declval< const _Up & >()) >
 
template<typename _Tp , typename _Up >
using std::__optional_le_t = __optional_relop_t< decltype(std::declval< const _Tp & >()<=std::declval< const _Up & >()) >
 
template<typename _Tp , typename _Up >
using std::__optional_lt_t = __optional_relop_t< decltype(std::declval< const _Tp & >()< std::declval< const _Up & >()) >
 
template<typename _Tp , typename _Up >
using std::__optional_ne_t = __optional_relop_t< decltype(std::declval< const _Tp & >() !=std::declval< const _Up & >()) >
 
template<typename _Tp >
using std::__optional_relop_t = enable_if_t< is_convertible< _Tp, bool >::value, bool >
 
typedef _T1 std::pair< _T1, _T2 >::first_type
 
typedef _T2 std::pair< _T1, _T2 >::second_type
 

Functions

 std::any::_Storage::_Storage (const _Storage &)=delete
 
constexpr std::any::any () noexcept
 
template<typename _Tp , typename _VTp = _Decay_if_not_any<_Tp>, typename _Mgr = _Manager<_VTp>, enable_if_t< is_copy_constructible< _VTp >::value &&!__is_in_place_type< _VTp >::value, bool > = true>
 std::any::any (_Tp &&__value)
 
 std::any::any (any &&__other) noexcept
 
 std::any::any (const any &__other)
 
template<typename _Tp , typename... _Args, typename _VTp = decay_t<_Tp>, typename _Mgr = _Manager<_VTp>, __any_constructible_t< _VTp, _Args &&... > = false>
 std::any::any (in_place_type_t< _Tp >, _Args &&... __args)
 
template<typename _Tp , typename _Up , typename... _Args, typename _VTp = decay_t<_Tp>, typename _Mgr = _Manager<_VTp>, __any_constructible_t< _VTp, initializer_list< _Up >, _Args &&... > = false>
 std::any::any (in_place_type_t< _Tp >, initializer_list< _Up > __il, _Args &&... __args)
 
template<typename _U1 = _T1, typename _U2 = _T2, typename enable_if< __and_< __is_implicitly_default_constructible< _U1 >, __is_implicitly_default_constructible< _U2 >> ::value, bool >::type = true>
constexpr std::pair< _T1, _T2 >::pair ()
 
template<typename _U1 , typename _U2 , typename enable_if< _PCCP::template _MoveConstructiblePair< _U1, _U2 >() &&_PCCP::template _ImplicitlyMoveConvertiblePair< _U1, _U2 >(), bool >::type = true>
constexpr std::pair< _T1, _T2 >::pair (_U1 &&__x, _U2 &&__y)
 
template<typename _U1 , typename enable_if< _PCCP::template _MoveCopyPair< true, _U1, _T2 >(), bool >::type = true>
constexpr std::pair< _T1, _T2 >::pair (_U1 &&__x, const _T2 &__y)
 
template<typename _U1 = _T1, typename _U2 = _T2, typename enable_if< _PCCP::template _ConstructiblePair< _U1, _U2 >() &&_PCCP::template _ImplicitlyConvertiblePair< _U1, _U2 >(), bool >::type = true>
constexpr std::pair< _T1, _T2 >::pair (const _T1 &__a, const _T2 &__b)
 
template<typename _U2 , typename enable_if< _PCCP::template _CopyMovePair< true, _T1, _U2 >(), bool >::type = true>
constexpr std::pair< _T1, _T2 >::pair (const _T1 &__x, _U2 &&__y)
 
constexpr std::pair< _T1, _T2 >::pair (const pair &)=default
 
template<typename _U1 , typename _U2 , typename enable_if< _PCCFP< _U1, _U2 >::template _ConstructiblePair< _U1, _U2 >() &&_PCCFP< _U1, _U2 >::template _ImplicitlyConvertiblePair< _U1, _U2 >(), bool >::type = true>
constexpr std::pair< _T1, _T2 >::pair (const pair< _U1, _U2 > &__p)
 
constexpr std::pair< _T1, _T2 >::pair (pair &&)=default
 
template<typename _U1 , typename _U2 , typename enable_if< _PCCFP< _U1, _U2 >::template _MoveConstructiblePair< _U1, _U2 >() &&_PCCFP< _U1, _U2 >::template _ImplicitlyMoveConvertiblePair< _U1, _U2 >(), bool >::type = true>
constexpr std::pair< _T1, _T2 >::pair (pair< _U1, _U2 > &&__p)
 
template<typename... _Args1, typename... _Args2>
constexpr std::pair< _T1, _T2 >::pair (piecewise_construct_t, tuple< _Args1... >, tuple< _Args2... >)
 
 std::any::~any ()
 
template<typename _Tp >
constexpr _Tp * std::__addressof (_Tp &__r) noexcept
 
template<typename _Fn , typename _Tuple , size_t... _Idx>
constexpr decltype(auto) std::__apply_impl (_Fn &&__f, _Tuple &&__t, index_sequence< _Idx... >)
 
template<typename _Tp , typename _Up = _Tp>
constexpr _Tp std::__exchange (_Tp &__obj, _Up &&__new_val)
 
template<size_t __i, typename _Head , typename... _Tail>
constexpr _Head & std::__get_helper (_Tuple_impl< __i, _Head, _Tail... > &__t) noexcept
 
template<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 _Callable , typename... _Args>
constexpr __invoke_result< _Callable, _Args... >::type std::__invoke (_Callable &&__fn, _Args &&... __args) noexcept(__is_nothrow_invocable< _Callable, _Args... >::value)
 
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 _MemFun , typename _Tp , typename... _Args>
constexpr _Res std::__invoke_impl (__invoke_memfun_ref, _MemFun &&__f, _Tp &&__t, _Args &&... __args)
 
template<typename _Res , typename _MemPtr , typename _Tp >
constexpr _Res std::__invoke_impl (__invoke_memobj_deref, _MemPtr &&__f, _Tp &&__t)
 
template<typename _Res , typename _MemPtr , typename _Tp >
constexpr _Res std::__invoke_impl (__invoke_memobj_ref, _MemPtr &&__f, _Tp &&__t)
 
template<typename _Res , typename _Fn , typename... _Args>
constexpr _Res std::__invoke_impl (__invoke_other, _Fn &&__f, _Args &&... __args)
 
template<typename _Res , typename _Callable , typename... _Args>
constexpr enable_if_t< is_invocable_r_v< _Res, _Callable, _Args... >, _Res > std::__invoke_r (_Callable &&__fn, _Args &&... __args) noexcept(is_nothrow_invocable_r_v< _Res, _Callable, _Args... >)
 
template<typename _Tp >
static constexpr bool std::any::__is_valid_cast ()
 
template<typename _Tp , typename _Tuple , size_t... _Idx>
constexpr _Tp std::__make_from_tuple_impl (_Tuple &&__t, index_sequence< _Idx... >)
 
void std::__throw_bad_any_cast ()
 
void std::__throw_bad_optional_access ()
 
template<typename... _Args>
static void std::any::_Manager_internal< _Tp >::_S_create (_Storage &__storage, _Args &&... __args)
 
template<typename... _Args>
static void std::any::_Manager_external< _Tp >::_S_create (_Storage &__storage, _Args &&... __args)
 
template<typename _Up >
static void std::any::_Manager_internal< _Tp >::_S_create (_Storage &__storage, _Up &&__value)
 
template<typename _Up >
static void std::any::_Manager_external< _Tp >::_S_create (_Storage &__storage, _Up &&__value)
 
template<typename _Tp >
constexpr _Tp * std::addressof (_Tp &__r) noexcept
 
template<typename _Tp >
const _Tp * std::addressof (const _Tp &&)=delete
 
template<typename _ValueType >
_ValueType std::any_cast (const any &__any)
 
template<typename _Fn , typename _Tuple >
constexpr decltype(auto) std::apply (_Fn &&__f, _Tuple &&__t) noexcept(__unpack_std_tuple< is_nothrow_invocable, _Fn, _Tuple >)
 
template<typename _Tp , typename... _Args>
__emplace_t< decay_t< _Tp >, _Args... > std::any::emplace (_Args &&... __args)
 
template<typename _Tp , typename _Up , typename... _Args>
__emplace_t< decay_t< _Tp >, initializer_list< _Up >, _Args &&... > std::any::emplace (initializer_list< _Up > __il, _Args &&... __args)
 
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<size_t __i, typename... _Elements>
constexpr const __tuple_element_t< __i, tuple< _Elements... > > && std::get (const tuple< _Elements... > &&__t) noexcept
 
template<size_t __i, typename... _Elements>
constexpr const __tuple_element_t< __i, tuple< _Elements... > > & std::get (const tuple< _Elements... > &__t) noexcept
 
template<typename _Tp , typename... _Types>
constexpr const _Tp && std::get (const tuple< _Types... > &&__t) noexcept
 
template<typename _Tp , typename... _Types>
constexpr const _Tp & std::get (const tuple< _Types... > &__t) noexcept
 
template<size_t __i, typename... _Elements>
constexpr __tuple_element_t< __i, tuple< _Elements... > > && std::get (tuple< _Elements... > &&__t) noexcept
 
template<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
 
bool std::any::has_value () const noexcept
 
template<typename _Tp , typename... _Args>
any std::make_any (_Args &&... __args)
 
template<typename _Tp , typename _Up , typename... _Args>
any std::make_any (initializer_list< _Up > __il, _Args &&... __args)
 
template<typename _Tp , typename _Tuple >
constexpr _Tp std::make_from_tuple (_Tuple &&__t) noexcept(__unpack_std_tuple< is_nothrow_constructible, _Tp, _Tuple >)
 
template<typename _Tp , typename... _Args>
constexpr enable_if_t< is_constructible_v< _Tp, _Args... >, optional< _Tp > > std::make_optional (_Args &&... __args) noexcept(is_nothrow_constructible_v< _Tp, _Args... >)
 
template<typename _Tp >
constexpr enable_if_t< is_constructible_v< decay_t< _Tp >, _Tp >, optional< decay_t< _Tp > > > std::make_optional (_Tp &&__t) noexcept(is_nothrow_constructible_v< optional< decay_t< _Tp >>, _Tp >)
 
template<typename _Tp , typename _Up , typename... _Args>
constexpr enable_if_t< is_constructible_v< _Tp, initializer_list< _Up > &, _Args... >, optional< _Tp > > std::make_optional (initializer_list< _Up > __il, _Args &&... __args) noexcept(is_nothrow_constructible_v< _Tp, initializer_list< _Up > &, _Args... >)
 
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 _Tp , typename _Up >
constexpr auto std::operator!= (const _Up &__lhs, const optional< _Tp > &__rhs) -> __optional_ne_t< _Up, _Tp >
 
template<typename _Tp , typename _Up >
constexpr auto std::operator!= (const optional< _Tp > &__lhs, const _Up &__rhs) -> __optional_ne_t< _Tp, _Up >
 
template<typename _Tp , typename _Up >
constexpr auto std::operator!= (const optional< _Tp > &__lhs, const optional< _Up > &__rhs) -> __optional_ne_t< _Tp, _Up >
 
template<typename _Tp >
constexpr bool std::operator!= (const optional< _Tp > &__lhs, nullopt_t) noexcept
 
template<typename... _TElements, typename... _UElements>
constexpr bool std::operator!= (const tuple< _TElements... > &__t, const tuple< _UElements... > &__u)
 
template<typename _Tp >
constexpr bool std::operator!= (nullopt_t, const optional< _Tp > &__rhs) noexcept
 
template<typename _Tp , typename _Up >
constexpr auto std::operator< (const _Up &__lhs, const optional< _Tp > &__rhs) -> __optional_lt_t< _Up, _Tp >
 
template<typename _Tp >
constexpr bool std::operator< (const optional< _Tp > &, nullopt_t) noexcept
 
template<typename _Tp , typename _Up >
constexpr auto std::operator< (const optional< _Tp > &__lhs, const _Up &__rhs) -> __optional_lt_t< _Tp, _Up >
 
template<typename _Tp , typename _Up >
constexpr auto std::operator< (const optional< _Tp > &__lhs, const optional< _Up > &__rhs) -> __optional_lt_t< _Tp, _Up >
 
template<typename... _TElements, typename... _UElements>
constexpr bool std::operator< (const tuple< _TElements... > &__t, const tuple< _UElements... > &__u)
 
template<typename _Tp >
constexpr bool std::operator< (nullopt_t, const optional< _Tp > &__rhs) noexcept
 
template<typename _Tp , typename _Up >
constexpr auto std::operator<= (const _Up &__lhs, const optional< _Tp > &__rhs) -> __optional_le_t< _Up, _Tp >
 
template<typename _Tp , typename _Up >
constexpr auto std::operator<= (const optional< _Tp > &__lhs, const _Up &__rhs) -> __optional_le_t< _Tp, _Up >
 
template<typename _Tp , typename _Up >
constexpr auto std::operator<= (const optional< _Tp > &__lhs, const optional< _Up > &__rhs) -> __optional_le_t< _Tp, _Up >
 
template<typename _Tp >
constexpr bool std::operator<= (const optional< _Tp > &__lhs, nullopt_t) noexcept
 
template<typename... _TElements, typename... _UElements>
constexpr bool std::operator<= (const tuple< _TElements... > &__t, const tuple< _UElements... > &__u)
 
template<typename _Tp >
constexpr bool std::operator<= (nullopt_t, const optional< _Tp > &) noexcept
 
template<typename _Tp >
enable_if_t< is_copy_constructible< _Decay_if_not_any< _Tp > >::value, any & > std::any::operator= (_Tp &&__rhs)
 
anystd::any::operator= (any &&__rhs) noexcept
 
_Storage & std::any::_Storage::operator= (const _Storage &)=delete
 
anystd::any::operator= (const any &__rhs)
 
template<typename _U1 , typename _U2 >
constexpr enable_if< __and_< is_assignable< _T1 &, const _U1 & >, is_assignable< _T2 &, const _U2 & > >::value, pair & >::type std::pair< _T1, _T2 >::operator= (const pair< _U1, _U2 > &__p)
 
template<typename _U1 , typename _U2 >
constexpr enable_if< __and_< is_assignable< _T1 &, _U1 && >, is_assignable< _T2 &, _U2 && > >::value, pair & >::type std::pair< _T1, _T2 >::operator= (pair< _U1, _U2 > &&__p)
 
constexpr pairstd::pair< _T1, _T2 >::operator= (typename conditional< __and_< is_copy_assignable< _T1 >, is_copy_assignable< _T2 >>::value, const pair &, const __nonesuch & >::type __p)
 
constexpr pairstd::pair< _T1, _T2 >::operator= (typename conditional< __and_< is_move_assignable< _T1 >, is_move_assignable< _T2 >>::value, pair &&, __nonesuch && >::type __p) noexcept(__and_< is_nothrow_move_assignable< _T1 >, is_nothrow_move_assignable< _T2 >>::value)
 
template<typename _Tp , typename _Up >
constexpr auto std::operator== (const _Up &__lhs, const optional< _Tp > &__rhs) -> __optional_eq_t< _Up, _Tp >
 
template<typename _Tp , typename _Up >
constexpr auto std::operator== (const optional< _Tp > &__lhs, const _Up &__rhs) -> __optional_eq_t< _Tp, _Up >
 
template<typename _Tp , typename _Up >
constexpr auto std::operator== (const optional< _Tp > &__lhs, const optional< _Up > &__rhs) -> __optional_eq_t< _Tp, _Up >
 
template<typename _Tp >
constexpr bool std::operator== (const optional< _Tp > &__lhs, nullopt_t) noexcept
 
template<typename... _TElements, typename... _UElements>
constexpr bool std::operator== (const tuple< _TElements... > &__t, const tuple< _UElements... > &__u)
 
template<typename _Tp >
constexpr bool std::operator== (nullopt_t, const optional< _Tp > &__rhs) noexcept
 
template<typename _Tp , typename _Up >
constexpr auto std::operator> (const _Up &__lhs, const optional< _Tp > &__rhs) -> __optional_gt_t< _Up, _Tp >
 
template<typename _Tp , typename _Up >
constexpr auto std::operator> (const optional< _Tp > &__lhs, const _Up &__rhs) -> __optional_gt_t< _Tp, _Up >
 
template<typename _Tp , typename _Up >
constexpr auto std::operator> (const optional< _Tp > &__lhs, const optional< _Up > &__rhs) -> __optional_gt_t< _Tp, _Up >
 
template<typename _Tp >
constexpr bool std::operator> (const optional< _Tp > &__lhs, nullopt_t) noexcept
 
template<typename... _TElements, typename... _UElements>
constexpr bool std::operator> (const tuple< _TElements... > &__t, const tuple< _UElements... > &__u)
 
template<typename _Tp >
constexpr bool std::operator> (nullopt_t, const optional< _Tp > &) noexcept
 
template<typename _Tp , typename _Up >
constexpr auto std::operator>= (const _Up &__lhs, const optional< _Tp > &__rhs) -> __optional_ge_t< _Up, _Tp >
 
template<typename _Tp >
constexpr bool std::operator>= (const optional< _Tp > &, nullopt_t) noexcept
 
template<typename _Tp , typename _Up >
constexpr auto std::operator>= (const optional< _Tp > &__lhs, const _Up &__rhs) -> __optional_ge_t< _Tp, _Up >
 
template<typename _Tp , typename _Up >
constexpr auto std::operator>= (const optional< _Tp > &__lhs, const optional< _Up > &__rhs) -> __optional_ge_t< _Tp, _Up >
 
template<typename... _TElements, typename... _UElements>
constexpr bool std::operator>= (const tuple< _TElements... > &__t, const tuple< _UElements... > &__u)
 
template<typename _Tp >
constexpr bool std::operator>= (nullopt_t, const optional< _Tp > &__rhs) noexcept
 
void std::any::reset () noexcept
 
template<typename _Tp >
constexpr enable_if< __and_< __not_< __is_tuple_like< _Tp > >, is_move_constructible< _Tp >, is_move_assignable< _Tp > >::value >::type std::swap (_Tp &__a, _Tp &__b) noexcept(/*conditional */) is_nothrow_move_assignable< _Tp >>
 
template<typename _Tp , size_t _Nm>
constexpr enable_if< __is_swappable< _Tp >::value >::type std::swap (_Tp(&__a)[_Nm], _Tp(&__b)[_Nm]) noexcept(/*conditional */)
 
void std::any::swap (any &__rhs) noexcept
 
void std::swap (any &__x, any &__y) noexcept
 
template<typename _Tp >
enable_if_t< is_move_constructible_v< _Tp > &&is_swappable_v< _Tp > > std::swap (optional< _Tp > &__lhs, optional< _Tp > &__rhs) noexcept(noexcept(__lhs.swap(__rhs)))
 
constexpr void std::pair< _T1, _T2 >::swap (pair &__p) noexcept(__and_< __is_nothrow_swappable< _T1 >, __is_nothrow_swappable< _T2 >>::value)
 
template<typename... _Elements>
constexpr enable_if< __and_< __is_swappable< _Elements >... >::value >::type std::swap (tuple< _Elements... > &__x, tuple< _Elements... > &__y) noexcept(noexcept(__x.swap(__y)))
 
template<typename... _Elements>
constexpr tuple< _Elements &... > std::tie (_Elements &... __args) noexcept
 
template<typename... _Tpls, typename = typename enable_if<__and_<__is_tuple_like<_Tpls>...>::value>::type>
constexpr auto std::tuple_cat (_Tpls &&... __tpls) -> typename __tuple_cat_result< _Tpls... >::__type
 
const type_infostd::any::type () const noexcept
 
virtual const char * std::bad_any_cast::what () const noexcept
 

Variables

template<template< typename... > class _Trait, typename _Tp , typename _Tuple >
constexpr bool std::__unpack_std_tuple
 
template<template< typename... > class _Trait, typename _Tp , typename... _Up>
constexpr bool std::__unpack_std_tuple< _Trait, _Tp, const tuple< _Up... > & >
 
template<template< typename... > class _Trait, typename _Tp , typename... _Up>
constexpr bool std::__unpack_std_tuple< _Trait, _Tp, const tuple< _Up... > >
 
template<template< typename... > class _Trait, typename _Tp , typename... _Up>
constexpr bool std::__unpack_std_tuple< _Trait, _Tp, tuple< _Up... > & >
 
template<template< typename... > class _Trait, typename _Tp , typename... _Up>
constexpr bool std::__unpack_std_tuple< _Trait, _Tp, tuple< _Up... > >
 
anystd::any::_Arg::_M_any
 
aligned_storage< sizeof(_M_ptr), alignof(void *)>::type std::any::_Storage::_M_buffer
 
void * std::any::_Arg::_M_obj
 
void * std::any::_Storage::_M_ptr
 
const std::type_infostd::any::_Arg::_M_typeinfo
 
_T1 std::pair< _T1, _T2 >::first
 
constexpr _Swallow_assign std::ignore
 
constexpr nullopt_t std::nullopt
 
constexpr piecewise_construct_t std::piecewise_construct
 
_T2 std::pair< _T1, _T2 >::second
 
template<typename _Tp >
constexpr size_t std::tuple_size_v
 

Friends

template<typename _Tp >
void * std::any::__any_caster (const any *__any)
 
static void std::any::_Manager_internal< _Tp >::_S_manage (_Op __which, const any *__anyp, _Arg *__arg)
 
static void std::any::_Manager_external< _Tp >::_S_manage (_Op __which, const any *__anyp, _Arg *__arg)
 
template<typename _ValueType >
_ValueType std::any_cast (any &__any)
 
template<typename _ValueType >
_ValueType std::any_cast (any &&__any)
 
template<typename _ValueType >
const _ValueType * std::any_cast (const any *__any) noexcept
 
template<typename _ValueType >
_ValueType * std::any_cast (any *__any) noexcept
 
template<typename _T1 , typename _T2 >
constexpr bool operator== (const pair< _T1, _T2 > &__x, const pair< _T1, _T2 > &__y)
 
template<typename _T1 , typename _T2 >
constexpr bool operator< (const pair< _T1, _T2 > &__x, const pair< _T1, _T2 > &__y)
 
template<typename _T1 , typename _T2 >
constexpr bool operator!= (const pair< _T1, _T2 > &__x, const pair< _T1, _T2 > &__y)
 
template<typename _T1 , typename _T2 >
constexpr bool operator> (const pair< _T1, _T2 > &__x, const pair< _T1, _T2 > &__y)
 
template<typename _T1 , typename _T2 >
constexpr bool operator<= (const pair< _T1, _T2 > &__x, const pair< _T1, _T2 > &__y)
 
template<typename _T1 , typename _T2 >
constexpr bool operator>= (const pair< _T1, _T2 > &__x, const pair< _T1, _T2 > &__y)
 
template<typename _T1 , typename _T2 >
constexpr enable_if< __and_< __is_swappable< _T1 >, __is_swappable< _T2 > >::value >::type swap (pair< _T1, _T2 > &__x, pair< _T1, _T2 > &__y) noexcept(noexcept(__x.swap(__y)))
 
template<typename _T1 , typename _T2 >
constexpr pair< typename __decay_and_strip< _T1 >::__type, typename __decay_and_strip< _T2 >::__type > make_pair (_T1 &&__x, _T2 &&__y)
 

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

◆ first_type

template<typename _T1 , typename _T2 >
typedef _T1 std::pair< _T1, _T2 >::first_type

The type of the first member.

Definition at line 214 of file stl_pair.h.

◆ second_type

template<typename _T1 , typename _T2 >
typedef _T2 std::pair< _T1, _T2 >::second_type

The type of the second member.

Definition at line 215 of file stl_pair.h.

Function Documentation

◆ any() [1/6]

constexpr std::any::any ( )
inlineconstexprnoexcept

Default constructor, creates an empty object.

Definition at line 150 of file any.

◆ any() [2/6]

template<typename _Tp , typename _VTp = _Decay_if_not_any<_Tp>, typename _Mgr = _Manager<_VTp>, enable_if_t< is_copy_constructible< _VTp >::value &&!__is_in_place_type< _VTp >::value, bool > = true>
std::any::any ( _Tp &&  __value)
inline

Construct with a copy of __value as the contained object.

Definition at line 187 of file any.

◆ any() [3/6]

std::any::any ( any &&  __other)
inlinenoexcept

Move constructor, transfer the state from __other.

Postcondition
!__other.has_value() (this postcondition is a GNU extension)

Definition at line 170 of file any.

◆ any() [4/6]

std::any::any ( const any __other)
inline

Copy constructor, copies the state of __other.

Definition at line 153 of file any.

◆ any() [5/6]

template<typename _Tp , typename... _Args, typename _VTp = decay_t<_Tp>, typename _Mgr = _Manager<_VTp>, __any_constructible_t< _VTp, _Args &&... > = false>
std::any::any ( in_place_type_t< _Tp >  ,
_Args &&...  __args 
)
inlineexplicit

Construct with an object created from __args as the contained object.

Definition at line 198 of file any.

◆ any() [6/6]

template<typename _Tp , typename _Up , typename... _Args, typename _VTp = decay_t<_Tp>, typename _Mgr = _Manager<_VTp>, __any_constructible_t< _VTp, initializer_list< _Up >, _Args &&... > = false>
std::any::any ( in_place_type_t< _Tp >  ,
initializer_list< _Up >  __il,
_Args &&...  __args 
)
inlineexplicit

Construct with an object created from __il and __args as the contained object.

Definition at line 211 of file any.

◆ pair() [1/5]

template<typename _T1 , typename _T2 >
template<typename _U1 = _T1, typename _U2 = _T2, typename enable_if< __and_< __is_implicitly_default_constructible< _U1 >, __is_implicitly_default_constructible< _U2 >> ::value, bool >::type = true>
constexpr std::pair< _T1, _T2 >::pair ( )
inlineconstexpr

The default constructor creates first and second using their respective default constructors.

Definition at line 232 of file stl_pair.h.

◆ pair() [2/5]

template<typename _T1 , typename _T2 >
template<typename _U1 = _T1, typename _U2 = _T2, typename enable_if< _PCCP::template _ConstructiblePair< _U1, _U2 >() &&_PCCP::template _ImplicitlyConvertiblePair< _U1, _U2 >(), bool >::type = true>
constexpr std::pair< _T1, _T2 >::pair ( const _T1 &  __a,
const _T2 &  __b 
)
inlineconstexpr

Construct from two const lvalues, allowing implicit conversions.

Definition at line 266 of file stl_pair.h.

◆ pair() [3/5]

template<typename _T1 , typename _T2 >
constexpr std::pair< _T1, _T2 >::pair ( const pair< _T1, _T2 > &  )
constexprdefault

Copy constructor.

◆ pair() [4/5]

template<typename _T1 , typename _T2 >
constexpr std::pair< _T1, _T2 >::pair ( pair< _T1, _T2 > &&  )
constexprdefault

Move constructor.

◆ pair() [5/5]

template<class _T1 , class _T2 >
template<typename... _Args1, typename... _Args2>
constexpr std::pair< _T1, _T2 >::pair ( piecewise_construct_t  ,
tuple< _Args1... >  __first,
tuple< _Args2... >  __second 
)
inlineconstexpr

"piecewise construction" using a tuple of arguments for each member.

Parameters
__firstArguments for the first member of the pair.
__secondArguments for the second member of the pair.

The elements of each tuple will be used as the constructor arguments for the data members of the pair.

Definition at line 1756 of file tuple.

◆ ~any()

std::any::~any ( )
inline

Destructor, calls reset()

Definition at line 218 of file any.

◆ __addressof()

◆ __invoke()

template<typename _Callable , typename... _Args>
constexpr __invoke_result<_Callable, _Args...>::type std::__invoke ( _Callable &&  __fn,
_Args &&...  __args 
)
constexprnoexcept

Invoke a callable object.

Definition at line 90 of file invoke.h.

◆ _S_manage() [1/2]

template<typename _Tp >
void std::any::_Manager_internal< _Tp >::_S_manage ( _Op  __which,
const any __anyp,
_Arg *  __arg 
)
static

Access the contained object.

Template Parameters
_ValueTypeA reference or CopyConstructible type.
Parameters
__anyThe object to access.
Returns
The contained object.
Exceptions
bad_any_castIf __any.type() != typeid(remove_reference_t<_ValueType>)

Definition at line 554 of file any.

◆ _S_manage() [2/2]

template<typename _Tp >
void std::any::_Manager_external< _Tp >::_S_manage ( _Op  __which,
const any __anyp,
_Arg *  __arg 
)
static

Access the contained object.

Template Parameters
_ValueTypeA reference or CopyConstructible type.
Parameters
__anyThe object to access.
Returns
The contained object.
Exceptions
bad_any_castIf __any.type() != typeid(remove_reference_t<_ValueType>)

Definition at line 588 of file any.

◆ addressof()

template<typename _Tp >
constexpr _Tp* std::addressof ( _Tp &  __r)
inlineconstexprnoexcept

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 140 of file move.h.

References std::__addressof().

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

◆ any_cast() [1/5]

template<typename _ValueType >
_ValueType std::any_cast ( any &&  __any)
inline

Access the contained object.

Template Parameters
_ValueTypeA reference or CopyConstructible type.
Parameters
__anyThe object to access.
Returns
The contained object.
Exceptions
bad_any_castIf __any.type() != typeid(remove_reference_t<_ValueType>)

Definition at line 479 of file any.

◆ any_cast() [2/5]

template<typename _ValueType >
_ValueType std::any_cast ( any __any)
inline

Access the contained object.

Template Parameters
_ValueTypeA reference or CopyConstructible type.
Parameters
__anyThe object to access.
Returns
The contained object.
Exceptions
bad_any_castIf __any.type() != typeid(remove_reference_t<_ValueType>)

Definition at line 465 of file any.

◆ any_cast() [3/5]

template<typename _ValueType >
_ValueType* std::any_cast ( any __any)
inlinenoexcept

Access the contained object.

Template Parameters
_ValueTypeA reference or CopyConstructible type.
Parameters
__anyThe object to access.
Returns
The contained object.
Exceptions
bad_any_castIf __any.type() != typeid(remove_reference_t<_ValueType>)

Definition at line 543 of file any.

◆ any_cast() [4/5]

template<typename _ValueType >
_ValueType std::any_cast ( const any __any)
inline

Access the contained object.

Template Parameters
_ValueTypeA const-reference or CopyConstructible type.
Parameters
__anyThe object to access.
Returns
The contained object.
Exceptions
bad_any_castIf __any.type() != typeid(remove_reference_t<_ValueType>)

Definition at line 439 of file any.

◆ any_cast() [5/5]

template<typename _ValueType >
const _ValueType* std::any_cast ( const any __any)
inlinenoexcept

Access the contained object.

Template Parameters
_ValueTypeThe type of the contained object.
Parameters
__anyA pointer to the object to access.
Returns
The address of the contained object if __any != nullptr && __any.type() == typeid(_ValueType) , otherwise a null pointer.

Definition at line 534 of file any.

◆ emplace() [1/2]

template<typename _Tp , typename... _Args>
__emplace_t<decay_t<_Tp>, _Args...> std::any::emplace ( _Args &&...  __args)
inline

Emplace with an object created from __args as the contained object.

Definition at line 262 of file any.

◆ emplace() [2/2]

template<typename _Tp , typename _Up , typename... _Args>
__emplace_t<decay_t<_Tp>, initializer_list<_Up>, _Args&&...> std::any::emplace ( initializer_list< _Up >  __il,
_Args &&...  __args 
)
inline

Emplace with an object created from __il and __args as the contained object.

Definition at line 275 of file any.

◆ forward() [1/2]

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

Forward an rvalue.

Returns
The parameter cast to the specified type.

This function is used to implement "perfect forwarding".

Definition at line 87 of file move.h.

◆ forward() [2/2]

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

Forward an lvalue.

Returns
The parameter cast to the specified type.

This function is used to implement "perfect forwarding".

Definition at line 76 of file move.h.

◆ forward_as_tuple()

template<typename... _Elements>
constexpr tuple<_Elements&&...> std::forward_as_tuple ( _Elements &&...  __args)
constexprnoexcept

◆ get() [1/8]

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

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

Definition at line 1398 of file tuple.

◆ get() [2/8]

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

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

Definition at line 1383 of file tuple.

◆ get() [3/8]

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

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

Definition at line 1440 of file tuple.

◆ get() [4/8]

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

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

Definition at line 1433 of file tuple.

◆ get() [5/8]

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

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

Definition at line 1389 of file tuple.

◆ get() [6/8]

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

Return a reference to the ith element of a tuple.

Definition at line 1377 of file tuple.

◆ get() [7/8]

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

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

Definition at line 1427 of file tuple.

◆ get() [8/8]

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

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

Definition at line 1421 of file tuple.

◆ has_value()

bool std::any::has_value ( ) const
inlinenoexcept

Reports whether there is a contained object or not.

Definition at line 329 of file any.

◆ make_any() [1/2]

template<typename _Tp , typename... _Args>
any std::make_any ( _Args &&...  __args)

Create an any holding a _Tp constructed from __args.

Definition at line 416 of file any.

◆ make_any() [2/2]

template<typename _Tp , typename _Up , typename... _Args>
any std::make_any ( initializer_list< _Up >  __il,
_Args &&...  __args 
)

Create an any holding a _Tp constructed from __il and __args.

Definition at line 423 of file any.

◆ make_pair()

template<typename _T1 , typename _T2 >
constexpr pair< typename __decay_and_strip< _T1 >::__type, typename __decay_and_strip< _T2 >::__type > make_pair ( _T1 &&  __x,
_T2 &&  __y 
)
related

A convenience wrapper for creating a pair from two objects.

Parameters
__xThe first object.
__yThe second object.
Returns
A newly-constructed pair<> object of the appropriate type.

The C++98 standard says the objects are passed by reference-to-const, but C++03 says they are passed by value (this was LWG issue #181).

Since C++11 they have been passed by forwarding reference and then forwarded to the new members of the pair. To create a pair with a member of reference type, pass a reference_wrapper to this function.

Definition at line 567 of file stl_pair.h.

◆ move()

template<typename _Tp >
constexpr std::remove_reference<_Tp>::type&& std::move ( _Tp &&  __t)
constexprnoexcept

◆ move_if_noexcept()

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

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 121 of file move.h.

References std::move().

◆ operator!=()

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

Uses operator== to find the result.

Definition at line 496 of file stl_pair.h.

◆ operator<()

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

Defines a lexicographical order for pairs.

For two pairs of the same type, P is ordered before Q if P.first is less than Q.first, or if P.first and Q.first are equivalent (neither is less than the other) and P.second is less than Q.second.

Definition at line 488 of file stl_pair.h.

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

◆ operator<=()

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

Uses operator< to find the result.

Definition at line 507 of file stl_pair.h.

◆ operator=() [1/3]

template<typename _Tp >
enable_if_t<is_copy_constructible<_Decay_if_not_any<_Tp> >::value, any&> std::any::operator= ( _Tp &&  __rhs)
inline

Store a copy of __rhs as the contained object.

Definition at line 253 of file any.

◆ operator=() [2/3]

any& std::any::operator= ( any &&  __rhs)
inlinenoexcept

Move assignment operator.

Postcondition
!__rhs.has_value() (not guaranteed for other implementations)

Definition at line 236 of file any.

◆ operator=() [3/3]

any& std::any::operator= ( const any __rhs)
inline

Copy the state of another object.

Definition at line 224 of file any.

◆ operator==()

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

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

Definition at line 466 of file stl_pair.h.

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

◆ operator>()

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

Uses operator< to find the result.

Definition at line 502 of file stl_pair.h.

◆ operator>=()

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

Uses operator< to find the result.

Definition at line 514 of file stl_pair.h.

◆ reset()

void std::any::reset ( )
inlinenoexcept

If not empty, destroy the contained object.

Definition at line 287 of file any.

◆ swap() [1/7]

template<typename _Tp >
constexpr enable_if<__and_<__not_<__is_tuple_like<_Tp> >, is_move_constructible<_Tp>, is_move_assignable<_Tp> >::value>::type std::swap ( _Tp &  __a,
_Tp &  __b 
)
inlineconstexprnoexcept

Swaps two values.

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

Definition at line 191 of file move.h.

◆ swap() [2/7]

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

Swap the contents of two arrays.

Definition at line 215 of file move.h.

◆ swap() [3/7]

void std::any::swap ( any __rhs)
inlinenoexcept

Exchange state with another object.

Definition at line 297 of file any.

◆ swap() [4/7]

◆ swap() [5/7]

template<typename _T1 , typename _T2 >
constexpr void std::pair< _T1, _T2 >::swap ( pair< _T1, _T2 > &  __p)
inlineconstexprnoexcept

Swap the first members and then the second members.

Definition at line 439 of file stl_pair.h.

Referenced by std::pair< _T1, _T2 >::swap().

◆ swap() [6/7]

template<typename _T1 , typename _T2 >
constexpr enable_if< __and_< __is_swappable< _T1 >, __is_swappable< _T2 > >::value >::type swap ( pair< _T1, _T2 > &  __x,
pair< _T1, _T2 > &  __y 
)
related

Swap overload for pairs. Calls std::pair::swap().

Note
This std::swap overload is not declared in C++03 mode, which has performance implications, e.g. see https://gcc.gnu.org/PR38466

Definition at line 533 of file stl_pair.h.

References std::pair< _T1, _T2 >::swap().

◆ swap() [7/7]

template<typename... _Elements>
constexpr enable_if<__and_<__is_swappable<_Elements>...>::value >::type std::swap ( tuple< _Elements... > &  __x,
tuple< _Elements... > &  __y 
)
inlineconstexprdeletenoexcept

swap

Definition at line 1712 of file tuple.

◆ tie()

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

tie

Definition at line 1698 of file tuple.

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

◆ tuple_cat()

template<typename... _Tpls, typename = typename enable_if<__and_<__is_tuple_like<_Tpls>...>::value>::type>
constexpr auto std::tuple_cat ( _Tpls &&...  __tpls) -> typename __tuple_cat_result<_Tpls...>::__type
constexpr

tuple_cat

Definition at line 1684 of file tuple.

◆ type()

const type_info& std::any::type ( ) const
inlinenoexcept

The typeid of the contained object, or typeid(void) if empty.

Definition at line 333 of file any.

◆ what()

virtual const char* std::bad_any_cast::what ( ) const
inlinevirtualnoexcept

Returns a C-style character string describing the general cause of the current error.

Reimplemented from std::bad_cast.

Definition at line 57 of file any.

Variable Documentation

◆ first

◆ nullopt

constexpr nullopt_t std::nullopt
inlineconstexpr

Tag to disengage optional objects.

Definition at line 77 of file optional.

◆ piecewise_construct

constexpr piecewise_construct_t std::piecewise_construct
inlineconstexpr

Tag for piecewise construction of std::pair objects.

Definition at line 83 of file stl_pair.h.

Referenced by std::map< _Key, _Tp, _Compare, _Alloc >::insert_or_assign(), and std::map< _Key, _Tp, _Compare, _Alloc >::try_emplace().

◆ second

template<typename _T1 , typename _T2 >
_T2 std::pair< _T1, _T2 >::second