STLdoc
STLdocumentation
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
Classes | Macros | Typedefs | Functions | Variables
tuple File Reference
#include <new>
#include <type_traits>
#include <xutility>

Classes

struct  _Tuple_implicit_val0< _Same, _Dest, _Srcs >
 
struct  _Tuple_implicit_val0< true, tuple< _Dests...>, _Srcs...>
 
struct  _Tuple_implicit_val< _Dest, _Srcs >
 
struct  _Tuple_explicit_val0< _Same, _Dest, _Srcs >
 
struct  _Tuple_explicit_val0< true, tuple< _Dests...>, _Srcs...>
 
struct  _Tuple_explicit_val< _Dest, _Srcs >
 
struct  _Tuple_convert_copy< _Myt, _Other >
 
struct  _Tuple_convert_copy< tuple< _This >, _Uty >
 
struct  _Tuple_convert_move< _Myt, _Other >
 
struct  _Tuple_convert_move< tuple< _This >, _Uty >
 
struct  _Tuple_perfect_val< _Myt, _This2, _Rest2 >
 
struct  _Tuple_perfect_val< _Myt, _This2 >
 
struct  _Ignore
 
struct  _Tuple_alloc_t
 
struct  _Tuple_val< _Ty >
 
struct  _Exact_args_t
 
struct  _Unpack_tuple_t
 
struct  _Alloc_exact_args_t
 
struct  _Alloc_unpack_tuple_t
 
class  tuple< _Types >
 
class  tuple<>
 
class  tuple< _This, _Rest...>
 
struct  _Tuple_element< _Ty, _Tuple >
 
struct  _Tuple_element< _This, tuple< _This, _Rest...> >
 
struct  _Tuple_element< _Ty, tuple< _This, _Rest...> >
 
struct  _Tuple_element< _Ty, tuple<> >
 
struct  _Cat_sequences< _Seq_type1, _Seq_type2 >
 
struct  _Cat_sequences< index_sequence< _Indexes1...>, index_sequence< _Indexes2...> >
 
class  array< _Ty, _Size >
 
struct  _View_as_tuple< _Ty, _For_array >
 
struct  _View_as_tuple< tuple< _Types...> >
 
struct  _View_as_tuple< pair< _Ty1, _Ty2 > >
 
struct  _View_as_tuple< array< _Ty, 0 >, _Types...>
 
struct  _View_as_tuple< array< _Ty, _Size >, _Types...>
 
struct  _Repeat_for< _Nx, _Ty >
 
struct  _Tuple_cat2< _Ret, _Kx_arg, _Ix_arg, _Ix_next, _Tuples >
 
struct  _Tuple_cat2< tuple< _Types1...>, _Kx_arg, index_sequence< _Ix...>, _Ix_next, tuple< _Types2...>, _Rest...>
 
struct  _Tuple_cat1< _Tuples >
 
struct  std::uses_allocator< tuple< _Types...>, _Alloc >
 

Macros

#define _TUPLE_
 

Typedefs

template<class _Dest , class... _Srcs>
using _Tuple_implicit_t = enable_if_t< _Tuple_implicit_val< _Dest, _Srcs...>::value, int >
 
template<class _Dest , class... _Srcs>
using _Tuple_explicit_t = enable_if_t< _Tuple_explicit_val< _Dest, _Srcs...>::value, int >
 
template<class _Myt , class... _Other>
using _Tuple_convert_copy_t = typename _Tuple_convert_copy< _Myt, _Other...>::type
 
template<class _Myt , class... _Other>
using _Tuple_convert_move_t = typename _Tuple_convert_move< _Myt, _Other...>::type
 

Functions

template<class... _Types1, class... _Types2>
constexpr bool operator== (const tuple< _Types1...> &_Left, const tuple< _Types2...> &_Right)
 
template<class... _Types1, class... _Types2>
constexpr bool operator!= (const tuple< _Types1...> &_Left, const tuple< _Types2...> &_Right)
 
template<class... _Types1, class... _Types2>
constexpr bool operator< (const tuple< _Types1...> &_Left, const tuple< _Types2...> &_Right)
 
template<class... _Types1, class... _Types2>
constexpr bool operator>= (const tuple< _Types1...> &_Left, const tuple< _Types2...> &_Right)
 
template<class... _Types1, class... _Types2>
constexpr bool operator> (const tuple< _Types1...> &_Left, const tuple< _Types2...> &_Right)
 
template<class... _Types1, class... _Types2>
constexpr bool operator<= (const tuple< _Types1...> &_Left, const tuple< _Types2...> &_Right)
 
template<class... _Types, class = enable_if_t<conjunction<_Is_swappable<_Types>...>::value>>
void swap (tuple< _Types...> &_Left, tuple< _Types...> &_Right) _NOEXCEPT_OP(_NOEXCEPT_OP(_Left.swap(_Right)))
 
template<size_t _Index, class... _Types>
constexpr tuple_element< _Index, tuple< _Types...> >::type & get (tuple< _Types...> &_Tuple) _NOEXCEPT
 
template<size_t _Index, class... _Types>
constexpr const tuple_element< _Index, tuple< _Types...> >::type & get (const tuple< _Types...> &_Tuple) _NOEXCEPT
 
template<size_t _Index, class... _Types>
constexpr tuple_element< _Index, tuple< _Types...> >::type && get (tuple< _Types...> &&_Tuple) _NOEXCEPT
 
template<size_t _Index, class... _Types>
constexpr const tuple_element< _Index, tuple< _Types...> >::type && get (const tuple< _Types...> &&_Tuple) _NOEXCEPT
 
template<class _Ty , class... _Types>
constexpr _Ty & get (tuple< _Types...> &_Tuple) _NOEXCEPT
 
template<class _Ty , class... _Types>
constexpr const _Ty & get (const tuple< _Types...> &_Tuple) _NOEXCEPT
 
template<class _Ty , class... _Types>
constexpr _Ty && get (tuple< _Types...> &&_Tuple) _NOEXCEPT
 
template<class _Ty , class... _Types>
constexpr const _Ty && get (const tuple< _Types...> &&_Tuple) _NOEXCEPT
 
template<class... _Types>
constexpr tuple< typename _Unrefwrap< _Types >::type...> make_tuple (_Types &&..._Args)
 
template<class... _Types>
constexpr tuple< _Types &...> tie (_Types &..._Args) _NOEXCEPT
 
template<class... _Types>
constexpr tuple< _Types &&...> forward_as_tuple (_Types &&..._Args) _NOEXCEPT
 
template<size_t _Idx, class _Ty , size_t _Size>
constexpr _Ty & get (array< _Ty, _Size > &_Arr) _NOEXCEPT
 
template<size_t _Idx, class _Ty , size_t _Size>
constexpr const _Ty & get (const array< _Ty, _Size > &_Arr) _NOEXCEPT
 
template<size_t _Idx, class _Ty , size_t _Size>
constexpr _Ty && get (array< _Ty, _Size > &&_Arr) _NOEXCEPT
 
template<class _Ret , size_t... _Kx, size_t... _Ix, class _Ty >
constexpr _Ret _Tuple_cat (index_sequence< _Kx...>, index_sequence< _Ix...>, _Ty &&_Arg)
 
template<class... _Tuples>
constexpr _Tuple_cat1< _Tuples...>::type tuple_cat (_Tuples &&..._Tpls)
 
template<class _Tpl , class _Fx , size_t... _Indices>
void _For_each_tuple_element_impl (_Tpl &&_Tuple, _Fx _Func, index_sequence< _Indices...>)
 
template<class _Tpl , class _Fx >
void _For_each_tuple_element (_Tpl &&_Tuple, _Fx _Func)
 

Variables

constexpr _Ignore ignore {}
 
constexpr _Tuple_alloc_t _Tuple_alloc {}
 

Macro Definition Documentation

#define _TUPLE_

Typedef Documentation

template<class _Myt , class... _Other>
using _Tuple_convert_copy_t = typename _Tuple_convert_copy<_Myt, _Other...>::type
template<class _Myt , class... _Other>
using _Tuple_convert_move_t = typename _Tuple_convert_move<_Myt, _Other...>::type
template<class _Dest , class... _Srcs>
using _Tuple_explicit_t = enable_if_t<_Tuple_explicit_val<_Dest, _Srcs...>::value, int>
template<class _Dest , class... _Srcs>
using _Tuple_implicit_t = enable_if_t<_Tuple_implicit_val<_Dest, _Srcs...>::value, int>

Function Documentation

template<class _Tpl , class _Fx >
void _For_each_tuple_element ( _Tpl &&  _Tuple,
_Fx  _Func 
)
inline
1116  { // call _Func() on each element in _Tuple
1118  _STD forward<_Tpl>(_Tuple),
1119  _Func,
1121  );
1122  }
void _For_each_tuple_element_impl(_Tpl &&_Tuple, _Fx _Func, index_sequence< _Indices...>)
Definition: tuple:1104
make_integer_sequence< size_t, _Size > make_index_sequence
Definition: type_traits:1290
Definition: utility:384
typename remove_reference< _Ty >::type remove_reference_t
Definition: type_traits:2060
template<class _Tpl , class _Fx , size_t... _Indices>
void _For_each_tuple_element_impl ( _Tpl &&  _Tuple,
_Fx  _Func,
index_sequence< _Indices...>   
)
inline
1106  { // call _Func() on the _Indices elements of _Tuple
1107  int _Ignored[] = { (static_cast<void>(_Func(
1108  _STD get<_Indices>(_STD forward<_Tpl>(_Tuple))
1109  )), 0)... };
1110  (void)_Ignored;
1111  }
_CRT_BEGIN_C_HEADER typedef void(__CRTDECL *terminate_handler)()
template<class _Ret , size_t... _Kx, size_t... _Ix, class _Ty >
constexpr _Ret _Tuple_cat ( index_sequence< _Kx...>  ,
index_sequence< _Ix...>  ,
_Ty &&  _Arg 
)
inline
1043  { // concatenate tuples
1044  return (_Ret(_STD get<_Kx>(_STD get<_Ix>(_STD forward<_Ty>(_Arg)))...));
1045  }
template<class... _Types>
constexpr tuple<_Types&&...> forward_as_tuple ( _Types &&...  _Args)
inline
911  { // forward arguments in a tuple
912  return (tuple<_Types&&...>(_STD forward<_Types>(_Args)...));
913  }
Definition: tuple:220
template<size_t _Index, class... _Types>
constexpr tuple_element<_Index, tuple<_Types...> >::type& get ( tuple< _Types...> &  _Tuple)
inline
790  { // get reference to _Index element of tuple
791  typedef typename tuple_element<_Index, tuple<_Types...> >::_Ttype
792  _Ttype;
793  return (((_Ttype&)_Tuple)._Myfirst._Val);
794  }
_In_ size_t _In_ int _Index
Definition: time.h:102
Definition: utility:431
Definition: tuple:220
template<size_t _Index, class... _Types>
constexpr const tuple_element<_Index, tuple<_Types...> >::type& get ( const tuple< _Types...> &  _Tuple)
inline
800  { // get const reference to _Index element of tuple
801  typedef typename tuple_element<_Index, tuple<_Types...> >::_Ttype
802  _Ttype;
803  return (((_Ttype&)_Tuple)._Myfirst._Val);
804  }
_In_ size_t _In_ int _Index
Definition: time.h:102
Definition: utility:431
Definition: tuple:220
template<size_t _Index, class... _Types>
constexpr tuple_element<_Index, tuple<_Types...> >::type&& get ( tuple< _Types...> &&  _Tuple)
inline
810  { // get rvalue reference to _Index element of tuple
811  typedef typename tuple_element<_Index, tuple<_Types...> >::_Ttype
812  _Ttype;
813  typedef typename tuple_element<_Index, tuple<_Types...> >::type&&
814  _RRtype;
815  return (_STD forward<_RRtype>(((_Ttype&)_Tuple)._Myfirst._Val));
816  }
_In_ size_t _In_ int _Index
Definition: time.h:102
Definition: utility:431
Definition: tuple:220
template<size_t _Index, class... _Types>
constexpr const tuple_element<_Index, tuple<_Types...> >::type&& get ( const tuple< _Types...> &&  _Tuple)
inline
822  { // get const rvalue reference to _Index element of tuple
823  typedef typename tuple_element<_Index, tuple<_Types...> >::_Ttype
824  _Ttype;
825  typedef const typename tuple_element<_Index, tuple<_Types...> >::type&&
826  _RRtype;
827  return (_STD forward<_RRtype>(((_Ttype&)_Tuple)._Myfirst._Val));
828  }
_In_ size_t _In_ int _Index
Definition: time.h:102
Definition: utility:431
Definition: tuple:220
template<class _Ty , class... _Types>
constexpr _Ty& get ( tuple< _Types...> &  _Tuple)
inline
834  { // get reference to _Ty element of tuple
835  typedef typename _Tuple_element<_Ty, tuple<_Types...> >::_Ttype _Ttype;
836  return (((_Ttype&)_Tuple)._Myfirst._Val);
837  }
Definition: tuple:756
Definition: tuple:220
template<class _Ty , class... _Types>
constexpr const _Ty& get ( const tuple< _Types...> &  _Tuple)
inline
842  { // get const reference to _Ty element of tuple
843  typedef typename _Tuple_element<_Ty, tuple<_Types...> >::_Ttype _Ttype;
844  return (((_Ttype&)_Tuple)._Myfirst._Val);
845  }
Definition: tuple:756
Definition: tuple:220
template<class _Ty , class... _Types>
constexpr _Ty&& get ( tuple< _Types...> &&  _Tuple)
inline
850  { // get rvalue reference to _Ty element of tuple
851  typedef typename _Tuple_element<_Ty, tuple<_Types...> >::_Ttype _Ttype;
852  return (_STD forward<_Ty&&>(((_Ttype&)_Tuple)._Myfirst._Val));
853  }
Definition: tuple:756
Definition: tuple:220
template<class _Ty , class... _Types>
constexpr const _Ty&& get ( const tuple< _Types...> &&  _Tuple)
inline
858  { // get const rvalue reference to _Ty element of tuple
859  typedef typename _Tuple_element<_Ty, tuple<_Types...> >::_Ttype _Ttype;
860  return (_STD forward<const _Ty&&>(((_Ttype&)_Tuple)._Myfirst._Val));
861  }
Definition: tuple:756
Definition: tuple:220
template<size_t _Idx, class _Ty , size_t _Size>
constexpr _Ty& get ( array< _Ty, _Size > &  _Arr)
488  { // return element at _Idx in array _Arr
489  static_assert(_Idx < _Size, "array index out of bounds");
490  return (_Arr._Elems[_Idx]);
491  }
_CRT_BEGIN_C_HEADER _Check_return_ _Ret_maybenull_ _In_ size_t _Size
Definition: corecrt_malloc.h:58
_Ty _Elems[_Size]
Definition: array:220
template<size_t _Idx, class _Ty , size_t _Size>
constexpr const _Ty& get ( const array< _Ty, _Size > &  _Arr)
497  { // return element at _Idx in array _Arr
498  static_assert(_Idx < _Size, "array index out of bounds");
499  return (_Arr._Elems[_Idx]);
500  }
_CRT_BEGIN_C_HEADER _Check_return_ _Ret_maybenull_ _In_ size_t _Size
Definition: corecrt_malloc.h:58
_Ty _Elems[_Size]
Definition: array:220
template<size_t _Idx, class _Ty , size_t _Size>
constexpr _Ty&& get ( array< _Ty, _Size > &&  _Arr)
506  { // return element at _Idx in array _Arr
507  static_assert(_Idx < _Size, "array index out of bounds");
508  return (_STD move(_Arr._Elems[_Idx]));
509  }
_CRT_BEGIN_C_HEADER _Check_return_ _Ret_maybenull_ _In_ size_t _Size
Definition: corecrt_malloc.h:58
_Ty _Elems[_Size]
Definition: array:220
constexpr remove_reference< _Ty >::type && move(_Ty &&_Arg) _NOEXCEPT
Definition: type_traits:1349
template<class... _Types>
constexpr tuple<typename _Unrefwrap<_Types>::type...> make_tuple ( _Types &&...  _Args)
inline
891  { // make tuple from elements
892  typedef tuple<typename _Unrefwrap<_Types>::type...> _Ttype;
893  return (_Ttype(_STD forward<_Types>(_Args)...));
894  }
Definition: tuple:220
template<class... _Types1, class... _Types2>
constexpr bool operator!= ( const tuple< _Types1...> &  _Left,
const tuple< _Types2...> &  _Right 
)
inline
707  { // test if _Left != _Right
708  return (!(_Left == _Right));
709  }
template<class... _Types1, class... _Types2>
constexpr bool operator< ( const tuple< _Types1...> &  _Left,
const tuple< _Types2...> &  _Right 
)
inline
715  { // test if _Left < _Right
716  return (_Left._Less(_Right));
717  }
template<class... _Types1, class... _Types2>
constexpr bool operator<= ( const tuple< _Types1...> &  _Left,
const tuple< _Types2...> &  _Right 
)
inline
739  { // test if _Left <= _Right
740  return (!(_Right < _Left));
741  }
template<class... _Types1, class... _Types2>
constexpr bool operator== ( const tuple< _Types1...> &  _Left,
const tuple< _Types2...> &  _Right 
)
inline
699  { // test if _Left == _Right
700  return (_Left._Equals(_Right));
701  }
template<class... _Types1, class... _Types2>
constexpr bool operator> ( const tuple< _Types1...> &  _Left,
const tuple< _Types2...> &  _Right 
)
inline
731  { // test if _Left > _Right
732  return (_Right < _Left);
733  }
template<class... _Types1, class... _Types2>
constexpr bool operator>= ( const tuple< _Types1...> &  _Left,
const tuple< _Types2...> &  _Right 
)
inline
723  { // test if _Left >= _Right
724  return (!(_Left < _Right));
725  }
template<class... _Types, class = enable_if_t<conjunction<_Is_swappable<_Types>...>::value>>
void swap ( tuple< _Types...> &  _Left,
tuple< _Types...> &  _Right 
)
inline
748  { // swap _Left and _Right
749  return (_Left.swap(_Right));
750  }
template<class... _Types>
constexpr tuple<_Types&...> tie ( _Types &...  _Args)
inline
900  { // make tuple from elements
901  typedef tuple<_Types&...> _Ttype;
902  return (_Ttype(_Args...));
903  }
Definition: tuple:220
template<class... _Tuples>
constexpr _Tuple_cat1<_Tuples...>::type tuple_cat ( _Tuples &&...  _Tpls)
inline
1051  { // concatenate tuples
1052  typedef _Tuple_cat1<_Tuples...> _Cat1;
1053  return (_Tuple_cat<typename _Cat1::type>(
1054  typename _Cat1::_Kx_arg_seq(), typename _Cat1::_Ix_arg_seq(),
1055  _STD forward_as_tuple(_STD forward<_Tuples>(_Tpls)...)));
1056  }
constexpr tuple< _Types &&...> forward_as_tuple(_Types &&..._Args) _NOEXCEPT
Definition: tuple:910
Definition: tuple:1028

Variable Documentation

constexpr _Tuple_alloc_t _Tuple_alloc {}
constexpr _Ignore ignore {}