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	_Tuple_element< _Ty, const _Tuple >
struct	_Tuple_element< _Ty, volatile _Tuple >
struct	_Tuple_element< _Ty, const volatile _Tuple >
struct	_Cat_sequences< _Seq_type1, _Seq_type2 >
struct	_Cat_sequences< integer_sequence< size_t, _Indexes1...>, integer_sequence< size_t, _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, integer_sequence< size_t, _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<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... _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 (integer_sequence< size_t, _Kx...>, integer_sequence< size_t, _Ix...>, _Ty &&_Arg)
template<class _Ret , class _Ty >
constexpr _Ret	_Tuple_cat (integer_sequence< size_t >, integer_sequence< size_t >, _Ty &&)
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, integer_sequence< size_t, _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

    {   // call _Func() on each element in _Tuple
    _For_each_tuple_element_impl(
        _STD forward<_Tpl>(_Tuple),
        _Func,
        make_integer_sequence<size_t,
            tuple_size<remove_reference_t<_Tpl>>::value>()
        );
    }

template<class _Tpl , class _Fx , size_t... _Indices>

void _For_each_tuple_element_impl ( _Tpl &&  _Tuple, _Fx  _Func, integer_sequence< size_t, _Indices...>    )

inline

    {   // call _Func() on the _Indices elements of _Tuple
    int _Ignored[] = { (static_cast<void>(_Func(
        _STD get<_Indices>(_STD forward<_Tpl>(_Tuple))
        )), 0)... };
    (void)_Ignored;
    }

template<class _Ret , size_t... _Kx, size_t... _Ix, class _Ty >

constexpr _Ret _Tuple_cat ( integer_sequence< size_t, _Kx...>  , integer_sequence< size_t, _Ix...>  , _Ty &&  _Arg  )

inline

    {   // concatenate tuples
    return (_Ret(_STD get<_Kx>(_STD get<_Ix>(_STD forward<_Ty>(_Arg)))...));
    }

template<class _Ret , class _Ty >

constexpr _Ret _Tuple_cat ( integer_sequence< size_t >  , integer_sequence< size_t >  , _Ty &&    )

inline

    {   // TRANSITION, VSO#181496
    return (_Ret());
    }

template<class... _Types>

constexpr tuple<_Types&&...> forward_as_tuple ( _Types &&...  _Args )

inline

    {   // forward arguments in a tuple
    return (tuple<_Types&&...>(_STD forward<_Types>(_Args)...));
    }

template<size_t _Index, class... _Types>

constexpr tuple_element<_Index, tuple<_Types...> >::type& get ( tuple< _Types...> &  _Tuple )

inline

    {   // get reference to _Index element of tuple
    typedef typename tuple_element<_Index, tuple<_Types...> >::_Ttype
        _Ttype;
    return (((_Ttype&)_Tuple)._Myfirst._Val);
    }

template<size_t _Index, class... _Types>

constexpr const tuple_element<_Index, tuple<_Types...> >::type& get ( const tuple< _Types...> &  _Tuple )

inline

    {   // get const reference to _Index element of tuple
    typedef typename tuple_element<_Index, tuple<_Types...> >::_Ttype
        _Ttype;
    return (((_Ttype&)_Tuple)._Myfirst._Val);
    }

template<size_t _Index, class... _Types>

constexpr tuple_element<_Index, tuple<_Types...> >::type&& get ( tuple< _Types...> &&  _Tuple )

inline

    {   // get rvalue reference to _Index element of tuple
    typedef typename tuple_element<_Index, tuple<_Types...> >::_Ttype
        _Ttype;
    typedef typename tuple_element<_Index, tuple<_Types...> >::type&&
        _RRtype;
    return (_STD forward<_RRtype>(((_Ttype&)_Tuple)._Myfirst._Val));
    }

template<class _Ty , class... _Types>

constexpr _Ty& get ( tuple< _Types...> &  _Tuple )

inline

    {   // get reference to _Ty element of tuple
    typedef typename _Tuple_element<_Ty, tuple<_Types...> >::_Ttype _Ttype;
    return (((_Ttype&)_Tuple)._Myfirst._Val);
    }

template<class _Ty , class... _Types>

constexpr const _Ty& get ( const tuple< _Types...> &  _Tuple )

inline

    {   // get const reference to _Ty element of tuple
    typedef typename _Tuple_element<_Ty, tuple<_Types...> >::_Ttype _Ttype;
    return (((_Ttype&)_Tuple)._Myfirst._Val);
    }

template<class _Ty , class... _Types>

constexpr _Ty&& get ( tuple< _Types...> &&  _Tuple )

inline

    {   // get rvalue reference to _Ty element of tuple
    typedef typename _Tuple_element<_Ty, tuple<_Types...> >::_Ttype _Ttype;
    return (_STD forward<_Ty&&>(((_Ttype&)_Tuple)._Myfirst._Val));
    }

template<size_t _Idx, class _Ty , size_t _Size>

constexpr _Ty& get

(

array< _Ty, _Size > &

_Arr

)

    {   // return element at _Idx in array _Arr
    static_assert(_Idx < _Size, "array index out of bounds");
    return (_Arr._Elems[_Idx]);
    }

template<size_t _Idx, class _Ty , size_t _Size>

constexpr const _Ty& get

(

const array< _Ty, _Size > &

_Arr

)

    {   // return element at _Idx in array _Arr
    static_assert(_Idx < _Size, "array index out of bounds");
    return (_Arr._Elems[_Idx]);
    }

template<size_t _Idx, class _Ty , size_t _Size>

constexpr _Ty&& get

(

array< _Ty, _Size > &&

_Arr

)

    {   // return element at _Idx in array _Arr
    static_assert(_Idx < _Size, "array index out of bounds");
    return (_STD move(_Arr._Elems[_Idx]));
    }

template<class... _Types>

constexpr tuple<typename _Unrefwrap<_Types>::type...> make_tuple ( _Types &&...  _Args )

inline

    {   // make tuple from elements
    typedef tuple<typename _Unrefwrap<_Types>::type...> _Ttype;
    return (_Ttype(_STD forward<_Types>(_Args)...));
    }

template<class... _Types1, class... _Types2>

constexpr bool operator!= ( const tuple< _Types1...> &  _Left, const tuple< _Types2...> &  _Right  )

inline

    {   // test if _Left != _Right
    return (!(_Left == _Right));
    }

template<class... _Types1, class... _Types2>

constexpr bool operator< ( const tuple< _Types1...> &  _Left, const tuple< _Types2...> &  _Right  )

inline

    {   // test if _Left < _Right
    return (_Left._Less(_Right));
    }

template<class... _Types1, class... _Types2>

constexpr bool operator<= ( const tuple< _Types1...> &  _Left, const tuple< _Types2...> &  _Right  )

inline

    {   // test if _Left <= _Right
    return (!(_Right < _Left));
    }

template<class... _Types1, class... _Types2>

constexpr bool operator== ( const tuple< _Types1...> &  _Left, const tuple< _Types2...> &  _Right  )

inline

    {   // test if _Left == _Right
    return (_Left._Equals(_Right));
    }

template<class... _Types1, class... _Types2>

constexpr bool operator> ( const tuple< _Types1...> &  _Left, const tuple< _Types2...> &  _Right  )

inline

    {   // test if _Left > _Right
    return (_Right < _Left);
    }

template<class... _Types1, class... _Types2>

constexpr bool operator>= ( const tuple< _Types1...> &  _Left, const tuple< _Types2...> &  _Right  )

inline

    {   // test if _Left >= _Right
    return (!(_Left < _Right));
    }

template<class... _Types, class = enable_if_t<conjunction<_Is_swappable<_Types>...>::value>>

void swap ( tuple< _Types...> &  _Left, tuple< _Types...> &  _Right  )

inline

    {   // swap _Left and _Right
    return (_Left.swap(_Right));
    }

template<class... _Types>

constexpr tuple<_Types&...> tie ( _Types &...  _Args )

inline

    {   // make tuple from elements
    typedef tuple<_Types&...> _Ttype;
    return (_Ttype(_Args...));
    }

template<class... _Tuples>

constexpr _Tuple_cat1<_Tuples...>::type tuple_cat ( _Tuples &&...  _Tpls )

inline

    {   // concatenate tuples
    typedef _Tuple_cat1<_Tuples...> _Cat1;
    return (_Tuple_cat<typename _Cat1::type>(
        typename _Cat1::_Kx_arg_seq(), typename _Cat1::_Ix_arg_seq(),
        _STD forward_as_tuple(_STD forward<_Tuples>(_Tpls)...)));
    }

Variable Documentation

constexpr _Tuple_alloc_t _Tuple_alloc {}

constexpr _Ignore ignore {}