utility File Reference

#include <xstddef>
#include <iosfwd>
#include <type_traits>

Classes
class	tuple< _Types >
struct	pair< _Ty1, _Ty2 >
struct	tuple_size< _Tuple >
struct	tuple_size< pair< _Ty1, _Ty2 > >
struct	tuple_size< tuple< _Types...> >
struct	tuple_size< const _Tuple >
struct	tuple_size< volatile _Tuple >
struct	tuple_size< const volatile _Tuple >
struct	tuple_element< _Index, _Tuple >
struct	_Pair_data< _Idx, _Ty >
struct	_Pair_data< 0, pair< _Ty1, _Ty2 > >
struct	_Pair_data< 1, pair< _Ty1, _Ty2 > >
struct	tuple_element< 0, pair< _Ty1, _Ty2 > >
struct	tuple_element< 1, pair< _Ty1, _Ty2 > >

Namespaces
	rel_ops
	tr1

Macros
#define	_UTILITY_

Functions
template<class _Ty , size_t _Size>
void	swap (_Ty(&_Left)[_Size], _Ty(&_Right)[_Size]) _NOEXCEPT_OP(_NOEXCEPT_OP(swap(*_Left
template<class _Ty1 , class _Ty2 >
void	swap (pair< _Ty1, _Ty2 > &_Left, pair< _Ty1, _Ty2 > &_Right) _NOEXCEPT_OP(_NOEXCEPT_OP(_Left.swap(_Right)))
template<class _Ty1 , class _Ty2 >
bool	operator== (const pair< _Ty1, _Ty2 > &_Left, const pair< _Ty1, _Ty2 > &_Right)
template<class _Ty1 , class _Ty2 >
bool	operator!= (const pair< _Ty1, _Ty2 > &_Left, const pair< _Ty1, _Ty2 > &_Right)
template<class _Ty1 , class _Ty2 >
bool	operator< (const pair< _Ty1, _Ty2 > &_Left, const pair< _Ty1, _Ty2 > &_Right)
template<class _Ty1 , class _Ty2 >
bool	operator> (const pair< _Ty1, _Ty2 > &_Left, const pair< _Ty1, _Ty2 > &_Right)
template<class _Ty1 , class _Ty2 >
bool	operator<= (const pair< _Ty1, _Ty2 > &_Left, const pair< _Ty1, _Ty2 > &_Right)
template<class _Ty1 , class _Ty2 >
bool	operator>= (const pair< _Ty1, _Ty2 > &_Left, const pair< _Ty1, _Ty2 > &_Right)
template<class _Ty1 , class _Ty2 >
pair< typename _Unrefwrap< _Ty1 >::type, typename _Unrefwrap< _Ty2 >::type >	make_pair (_Ty1 &&_Val1, _Ty2 &&_Val2)
template<class _Ty >
bool	rel_ops::operator!= (const _Ty &_Left, const _Ty &_Right)
template<class _Ty >
bool	rel_ops::operator> (const _Ty &_Left, const _Ty &_Right)
template<class _Ty >
bool	rel_ops::operator<= (const _Ty &_Left, const _Ty &_Right)
template<class _Ty >
bool	rel_ops::operator>= (const _Ty &_Left, const _Ty &_Right)
template<int _Idx, class _Ty1 , class _Ty2 >
_Pair_data< _Idx, pair< _Ty1, _Ty2 > >::_Rtype	get (pair< _Ty1, _Ty2 > &_Pr) _NOEXCEPT
template<int _Idx, class _Ty1 , class _Ty2 >
_Pair_data< _Idx, pair< _Ty1, _Ty2 > >::_Ctype	get (const pair< _Ty1, _Ty2 > &_Pr) _NOEXCEPT
template<int _Idx, class _Ty1 , class _Ty2 >
_Pair_data< _Idx, pair< _Ty1, _Ty2 > >::_RRtype	get (pair< _Ty1, _Ty2 > &&_Pr) _NOEXCEPT

Variables
template<class _FwdIt1 , class _FwdIt2 >
_STD_BEGIN void swap(_Ty &, _Ty &) _NOEXCEPT_OP(is_nothrow_move_constructible< _Ty > void	iter_swap (_FwdIt1 _Left, _FwdIt2 _Right)
void *	_Right
const piecewise_construct_t	piecewise_construct

Macro Definition Documentation

#define _UTILITY_

Function Documentation

template<int _Idx, class _Ty1 , class _Ty2 >

_Pair_data<_Idx, pair<_Ty1, _Ty2> >::_Rtype get ( pair< _Ty1, _Ty2 > &  _Pr )

inline

    {   // get reference to element at _Idx in pair _Pr
    return (_Pair_data<_Idx, pair<_Ty1, _Ty2> >::_Val(_Pr));
    }

template<int _Idx, class _Ty1 , class _Ty2 >

_Pair_data<_Idx, pair<_Ty1, _Ty2> >::_Ctype get ( const pair< _Ty1, _Ty2 > &  _Pr )

inline

    {   // get const reference to element at _Idx in pair _Pr
    return (_Pair_data<_Idx, pair<_Ty1, _Ty2> >::_Val(_Pr));
    }

template<int _Idx, class _Ty1 , class _Ty2 >

_Pair_data<_Idx, pair<_Ty1, _Ty2> >::_RRtype get ( pair< _Ty1, _Ty2 > &&  _Pr )

inline

    {   // get rvalue reference to element at _Idx in pair _Pr
    typedef typename _Pair_data<_Idx, pair<_Ty1, _Ty2> >::_RRtype
        _RRtype;
    return (_STD forward<_RRtype>(
        _Pair_data<_Idx, pair<_Ty1, _Ty2> >::_Val(_Pr)));
    }

template<class _Ty1 , class _Ty2 >

pair<typename _Unrefwrap<_Ty1>::type, typename _Unrefwrap<_Ty2>::type> make_pair ( _Ty1 &&  _Val1, _Ty2 &&  _Val2  )

inline

    {   // return pair composed from arguments
    typedef pair<typename _Unrefwrap<_Ty1>::type,
        typename _Unrefwrap<_Ty2>::type> _Mypair;
    return (_Mypair(_STD forward<_Ty1>(_Val1),
        _STD forward<_Ty2>(_Val2)));
    }

template<class _Ty1 , class _Ty2 >

bool operator!= ( const pair< _Ty1, _Ty2 > &  _Left, const pair< _Ty1, _Ty2 > &  _Right  )

inline

    {   // test for pair inequality
    return (!(_Left == _Right));
    }

template<class _Ty1 , class _Ty2 >

bool operator< ( const pair< _Ty1, _Ty2 > &  _Left, const pair< _Ty1, _Ty2 > &  _Right  )

inline

    {   // test if _Left < _Right for pairs
    return (_Left.first < _Right.first ||
        (!(_Right.first < _Left.first) && _Left.second < _Right.second));
    }

template<class _Ty1 , class _Ty2 >

bool operator<= ( const pair< _Ty1, _Ty2 > &  _Left, const pair< _Ty1, _Ty2 > &  _Right  )

inline

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

template<class _Ty1 , class _Ty2 >

bool operator== ( const pair< _Ty1, _Ty2 > &  _Left, const pair< _Ty1, _Ty2 > &  _Right  )

inline

    {   // test for pair equality
    return (_Left.first == _Right.first && _Left.second == _Right.second);
    }

template<class _Ty1 , class _Ty2 >

bool operator> ( const pair< _Ty1, _Ty2 > &  _Left, const pair< _Ty1, _Ty2 > &  _Right  )

inline

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

template<class _Ty1 , class _Ty2 >

bool operator>= ( const pair< _Ty1, _Ty2 > &  _Left, const pair< _Ty1, _Ty2 > &  _Right  )

inline

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

template<class _Ty , size_t _Size>

void swap ( _Ty(&)  _Left[_Size], _Ty(&)  _Right[_Size]  )

inline

template<class _Ty1 , class _Ty2 >

void swap ( pair< _Ty1, _Ty2 > &  _Left, pair< _Ty1, _Ty2 > &  _Right  )

inline

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

Variable Documentation

void * _Right

template<class _FwdIt1 , class _FwdIt2 >

_STD_BEGIN void swap (_Ty&, _Ty&) _NOEXCEPT_OP(is_nothrow_move_constructible<_Ty> void iter_swap(_FwdIt1 _Left, _FwdIt2 _Right)

inline

    {   // swap *_Left and *_Right
    swap(*_Left, *_Right);
    }

const piecewise_construct_t piecewise_construct

Initial value:

=
    piecewise_construct_t()