tuple File Reference

#include <type_traits>
#include <xutility>
#include <new>

Classes
struct	_Tuple_enable< _Src, _Dest >
struct	_Tuple_enable< tuple<>, tuple<> >
struct	_Tuple_enable< tuple< _Src0, _Types1...>, tuple< _Dest0, _Types2...> >
class	_Ignore
struct	_Tuple_alloc_t
struct	_Tuple_val< _Ty >
class	tuple< _Types >
class	tuple<>
class	tuple< _This, _Rest...>
struct	tuple_element< _Index, _Tuple >
struct	tuple_element< 0, tuple< _This, _Rest...> >
struct	tuple_element< _Index, tuple< _This, _Rest...> >
struct	tuple_element< _Index, const _Tuple >
struct	tuple_element< _Index, volatile _Tuple >
struct	tuple_element< _Index, const volatile _Tuple >
struct	_Make_arg_idx1< _Arg_idx_type, _Types >
struct	_Make_arg_idx1< _Arg_idx< _Indexes...>, _Ty, _Types...>
struct	_Make_arg_idx< _Types >
struct	_Cat_arg_idx< _Arg_idx_type1, _Arg_idx_type2 >
struct	_Cat_arg_idx< _Arg_idx< _Indexes1...>, _Arg_idx< _Indexes2...> >
struct	_Repeat_for< _Nx, _Ty >
struct	_Tuple_cat2< _Ret, _Kx_arg, _Ix_arg, _Ix_next, _Tuples >
struct	_Tuple_cat2< tuple< _Types1...>, _Kx_arg, _Arg_idx< _Ix...>, _Ix_next, tuple< _Types2...>, _Rest...>
struct	_Tuple_cat1< _Tuples >
struct	std::uses_allocator< tuple< _Types...>, _Alloc >

Namespaces
	tr1

Macros
#define	_TUPLE_

Functions
template<class... _Types1, class... _Types2>
bool	operator== (const tuple< _Types1...> &_Left, const tuple< _Types2...> &_Right)
template<class... _Types1, class... _Types2>
bool	operator!= (const tuple< _Types1...> &_Left, const tuple< _Types2...> &_Right)
template<class... _Types1, class... _Types2>
bool	operator< (const tuple< _Types1...> &_Left, const tuple< _Types2...> &_Right)
template<class... _Types1, class... _Types2>
bool	operator>= (const tuple< _Types1...> &_Left, const tuple< _Types2...> &_Right)
template<class... _Types1, class... _Types2>
bool	operator> (const tuple< _Types1...> &_Left, const tuple< _Types2...> &_Right)
template<class... _Types1, class... _Types2>
bool	operator<= (const tuple< _Types1...> &_Left, const tuple< _Types2...> &_Right)
template<class... _Types>
void	swap (tuple< _Types...> &_Left, tuple< _Types...> &_Right) _NOEXCEPT_OP(_NOEXCEPT_OP(_Left.swap(_Right)))
template<size_t _Index, class... _Types>
tuple_element< _Index, tuple< _Types...> >::_Rtype	get (tuple< _Types...> &_Tuple)
template<size_t _Index, class... _Types>
tuple_element< _Index, tuple< _Types...> >::_Ctype	get (const tuple< _Types...> &_Tuple)
template<size_t _Index, class... _Types>
tuple_element< _Index, tuple< _Types...> >::_RRtype	get (tuple< _Types...> &&_Tuple)
template<class... _Types>
tuple< typename _Unrefwrap< _Types >::type...>	make_tuple (_Types &&..._Args)
template<class... _Types>
tuple< _Types &...>	tie (_Types &..._Args) _NOEXCEPT
template<class... _Types>
tuple< _Types &&...>	forward_as_tuple (_Types &&..._Args) _NOEXCEPT
template<class _Ret , size_t... _Kx, size_t... _Ix, class _Ty >
_Ret	_Tuple_cat (_Arg_idx< _Kx...>, _Arg_idx< _Ix...>, _Ty &&_Arg)
template<class... _Tuples>
_Tuple_cat1< _Tuples...>::type	tuple_cat (_Tuples &&..._Tpls)

Variables
const _Ignore	ignore
const _Tuple_alloc_t	_Tuple_alloc = _Tuple_alloc_t()
_Types1 &&::value	_Val2

Macro Definition Documentation

#define _TUPLE_

Function Documentation

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

_Ret _Tuple_cat ( _Arg_idx< _Kx...>  , _Arg_idx< _Ix...>  , _Ty &&  _Arg  )

inline

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

template<class... _Types>

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>

tuple_element<_Index, tuple<_Types...> >::_Rtype 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>

tuple_element<_Index, tuple<_Types...> >::_Ctype 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>

tuple_element<_Index, tuple<_Types...> >::_RRtype 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...> >::_RRtype
        _RRtype;
    return (_STD forward<_RRtype>(((_Ttype&)_Tuple)._Myfirst._Val));
    }

template<class... _Types>

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>

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

inline

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

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

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

inline

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

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

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

inline

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

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

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

inline

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

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

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

inline

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

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

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

inline

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

template<class... _Types>

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

inline

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

template<class... _Types>

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

inline

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

template<class... _Tuples>

_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_idx(), typename _Cat1::_Ix_arg_idx(),
        _STD forward_as_tuple(_STD forward<_Tuples>(_Tpls)...)));
    }

Variable Documentation

const _Tuple_alloc_t _Tuple_alloc = _Tuple_alloc_t()

_Types1&& ::value _Val2

const _Ignore ignore