utility File Reference

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

Classes
struct	piecewise_construct_t
class	tuple< _Types >
struct	pair< _Ty1, _Ty2 >
class	array< _Ty, _Size >
struct	tuple_size< _Tuple >
struct	tuple_size< array< _Ty, _Size > >
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	tuple_element< _Idx, array< _Ty, _Size > >
struct	tuple_element< 0, pair< _Ty1, _Ty2 > >
struct	tuple_element< 1, pair< _Ty1, _Ty2 > >
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 >

Namespaces
	rel_ops

Macros
#define	_UTILITY_

Typedefs
template<size_t _Index, class _Tuple >
using	tuple_element_t = typename tuple_element< _Index, _Tuple >::type

Functions
template<class _Ty >
_STD_BEGIN	_Post_equal_to_ (_Right< _Left?_Right:_Left) const expr const _Ty &_Min_value(const _Ty &_Left
template<class _Ty >
	_Post_equal_to_ (_Left< _Right?_Right:_Left) const expr const _Ty &_Max_value(const _Ty &_Left
template<class _FwdIt1 , class _FwdIt2 >
void	iter_swap (_FwdIt1 _Left, _FwdIt2 _Right)
template<class _Ty , size_t _Size, class >
void	swap (_Ty(&_Left)[_Size], _Ty(&_Right)[_Size]) _NOEXCEPT_OP(_Is_nothrow_swappable< _Ty >
template<class _Ty , class >
void	swap (_Ty &_Left, _Ty &_Right) _NOEXCEPT_OP(is_nothrow_move_constructible< _Ty >
template<class _Ty >
void	_Swap_adl (_Ty &_Left, _Ty &_Right) _NOEXCEPT_OP(_Is_nothrow_swappable< _Ty >
template<class _Ty1 , class _Ty2 , class = enable_if_t<_Is_swappable<_Ty1>::value && _Is_swappable<_Ty2>::value>>
void	swap (pair< _Ty1, _Ty2 > &_Left, pair< _Ty1, _Ty2 > &_Right) _NOEXCEPT_OP(_NOEXCEPT_OP(_Left.swap(_Right)))
template<class _Ty1 , class _Ty2 >
constexpr bool	operator== (const pair< _Ty1, _Ty2 > &_Left, const pair< _Ty1, _Ty2 > &_Right)
template<class _Ty1 , class _Ty2 >
constexpr bool	operator!= (const pair< _Ty1, _Ty2 > &_Left, const pair< _Ty1, _Ty2 > &_Right)
template<class _Ty1 , class _Ty2 >
constexpr bool	operator< (const pair< _Ty1, _Ty2 > &_Left, const pair< _Ty1, _Ty2 > &_Right)
template<class _Ty1 , class _Ty2 >
constexpr bool	operator> (const pair< _Ty1, _Ty2 > &_Left, const pair< _Ty1, _Ty2 > &_Right)
template<class _Ty1 , class _Ty2 >
constexpr bool	operator<= (const pair< _Ty1, _Ty2 > &_Left, const pair< _Ty1, _Ty2 > &_Right)
template<class _Ty1 , class _Ty2 >
constexpr bool	operator>= (const pair< _Ty1, _Ty2 > &_Left, const pair< _Ty1, _Ty2 > &_Right)
template<class _Ty1 , class _Ty2 >
constexpr 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<class _Ret , class _Pair >
constexpr _Ret	_Pair_get (_Pair &_Pr, integral_constant< size_t, 0 >) _NOEXCEPT
template<class _Ret , class _Pair >
constexpr _Ret	_Pair_get (_Pair &_Pr, integral_constant< size_t, 1 >) _NOEXCEPT
template<size_t _Idx, class _Ty1 , class _Ty2 >
constexpr tuple_element< _Idx, pair< _Ty1, _Ty2 > >::type &	get (pair< _Ty1, _Ty2 > &_Pr) _NOEXCEPT
template<class _Ty1 , class _Ty2 >
constexpr _Ty1 &	get (pair< _Ty1, _Ty2 > &_Pr) _NOEXCEPT
template<class _Ty2 , class _Ty1 >
constexpr _Ty2 &	get (pair< _Ty1, _Ty2 > &_Pr) _NOEXCEPT
template<size_t _Idx, class _Ty1 , class _Ty2 >
constexpr const tuple_element< _Idx, pair< _Ty1, _Ty2 > >::type &	get (const pair< _Ty1, _Ty2 > &_Pr) _NOEXCEPT
template<class _Ty1 , class _Ty2 >
constexpr const _Ty1 &	get (const pair< _Ty1, _Ty2 > &_Pr) _NOEXCEPT
template<class _Ty2 , class _Ty1 >
constexpr const _Ty2 &	get (const pair< _Ty1, _Ty2 > &_Pr) _NOEXCEPT
template<size_t _Idx, class _Ty1 , class _Ty2 >
constexpr tuple_element< _Idx, pair< _Ty1, _Ty2 > >::type &&	get (pair< _Ty1, _Ty2 > &&_Pr) _NOEXCEPT
template<class _Ty1 , class _Ty2 >
constexpr _Ty1 &&	get (pair< _Ty1, _Ty2 > &&_Pr) _NOEXCEPT
template<class _Ty2 , class _Ty1 >
constexpr _Ty2 &&	get (pair< _Ty1, _Ty2 > &&_Pr) _NOEXCEPT
template<size_t _Idx, class _Ty1 , class _Ty2 >
constexpr const tuple_element< _Idx, pair< _Ty1, _Ty2 > >::type &&	get (const pair< _Ty1, _Ty2 > &&_Pr) _NOEXCEPT
template<class _Ty1 , class _Ty2 >
constexpr const _Ty1 &&	get (const pair< _Ty1, _Ty2 > &&_Pr) _NOEXCEPT
template<class _Ty2 , class _Ty1 >
constexpr const _Ty2 &&	get (const pair< _Ty1, _Ty2 > &&_Pr) _NOEXCEPT
template<class _Ty , class _Other = _Ty>
_Ty	exchange (_Ty &_Val, _Other &&_New_val)
template<class _Ty >
constexpr add_const_t< _Ty > &	as_const (_Ty &_Val) _NOEXCEPT
template<class _Ty >
void	as_const (const _Ty &&)=delete

Variables
_STD_BEGIN const _Ty &	_Right
constexpr piecewise_construct_t	piecewise_construct {}
template<class _Ty >
constexpr size_t	tuple_size_v = tuple_size<_Ty>::value

Macro Definition Documentation

#define _UTILITY_

Typedef Documentation

template<size_t _Index, class _Tuple >

using tuple_element_t = typename tuple_element<_Index, _Tuple>::type

Function Documentation

template<class _Ret , class _Pair >

constexpr _Ret _Pair_get ( _Pair &  _Pr, integral_constant< size_t, 0 >    )

inline

    {   // get reference to element 0 in pair _Pr
    return (_Pr.first);
    }

template<class _Ret , class _Pair >

constexpr _Ret _Pair_get ( _Pair &  _Pr, integral_constant< size_t, 1 >    )

inline

    {   // get reference to element 1 in pair _Pr
    return (_Pr.second);
    }

template<class _Ty >

_STD_BEGIN _Post_equal_to_

(

)

const

template<class _Ty >

_Post_equal_to_

(

)

const

template<class _Ty >

void _Swap_adl ( _Ty &  _Left, _Ty &  _Right  )

inline

    {   // exchange values stored at _Left and _Right, using ADL
    swap(_Left, _Right);
    }

template<class _Ty >

constexpr add_const_t<_Ty>& as_const ( _Ty &  _Val )

inline

    {   // view _Val through const lenses
    return (_Val);
    }

template<class _Ty >

void as_const ( const _Ty &&  )

delete

template<class _Ty , class _Other = _Ty>

_Ty exchange ( _Ty &  _Val, _Other &&  _New_val  )

inline

    {   // assign _New_val to _Val, return previous _Val
    _Ty _Old_val = _STD move(_Val);
    _Val = _STD forward<_Other>(_New_val);
    return (_Old_val);
    }

template<size_t _Idx, class _Ty1 , class _Ty2 >

constexpr tuple_element<_Idx, pair<_Ty1, _Ty2> >::type& get ( pair< _Ty1, _Ty2 > &  _Pr )

inline

    {   // get reference to element at _Idx in pair _Pr
    typedef typename tuple_element<_Idx, pair<_Ty1, _Ty2> >::type& _Rtype;
    return (_Pair_get<_Rtype>(_Pr, integral_constant<size_t, _Idx>()));
    }

template<class _Ty1 , class _Ty2 >

constexpr _Ty1& get ( pair< _Ty1, _Ty2 > &  _Pr )

inline

    {   // get reference to element _Ty1 in pair _Pr
    return (_STD get<0>(_Pr));
    }

template<class _Ty2 , class _Ty1 >

constexpr _Ty2& get ( pair< _Ty1, _Ty2 > &  _Pr )

inline

    {   // get reference to element _Ty2 in pair _Pr
    return (_STD get<1>(_Pr));
    }

template<size_t _Idx, class _Ty1 , class _Ty2 >

constexpr const tuple_element<_Idx, pair<_Ty1, _Ty2> >::type& get ( const pair< _Ty1, _Ty2 > &  _Pr )

inline

    {   // get const reference to element at _Idx in pair _Pr
    typedef const typename tuple_element<_Idx, pair<_Ty1, _Ty2> >::type&
        _Ctype;
    return (_Pair_get<_Ctype>(_Pr, integral_constant<size_t, _Idx>()));
    }

template<class _Ty1 , class _Ty2 >

constexpr const _Ty1& get ( const pair< _Ty1, _Ty2 > &  _Pr )

inline

    {   // get const reference to element _Ty1 in pair _Pr
    return (_STD get<0>(_Pr));
    }

template<class _Ty2 , class _Ty1 >

constexpr const _Ty2& get ( const pair< _Ty1, _Ty2 > &  _Pr )

inline

    {   // get const reference to element _Ty2 in pair _Pr
    return (_STD get<1>(_Pr));
    }

template<size_t _Idx, class _Ty1 , class _Ty2 >

constexpr tuple_element<_Idx, pair<_Ty1, _Ty2> >::type&& get ( pair< _Ty1, _Ty2 > &&  _Pr )

inline

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

template<class _Ty1 , class _Ty2 >

constexpr _Ty1&& get ( pair< _Ty1, _Ty2 > &&  _Pr )

inline

    {   // get rvalue reference to element _Ty1 in pair _Pr
    return (_STD get<0>(_STD move(_Pr)));
    }

template<class _Ty2 , class _Ty1 >

constexpr _Ty2&& get ( pair< _Ty1, _Ty2 > &&  _Pr )

inline

    {   // get rvalue reference to element _Ty2 in pair _Pr
    return (_STD get<1>(_STD move(_Pr)));
    }

template<size_t _Idx, class _Ty1 , class _Ty2 >

constexpr const tuple_element<_Idx, pair<_Ty1, _Ty2> >::type&& get ( const pair< _Ty1, _Ty2 > &&  _Pr )

inline

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

template<class _Ty1 , class _Ty2 >

constexpr const _Ty1&& get ( const pair< _Ty1, _Ty2 > &&  _Pr )

inline

    {   // get const rvalue reference to element _Ty1 in pair _Pr
    return (_STD get<0>(_STD move(_Pr)));
    }

template<class _Ty2 , class _Ty1 >

constexpr const _Ty2&& get ( const pair< _Ty1, _Ty2 > &&  _Pr )

inline

    {   // get const rvalue reference to element _Ty2 in pair _Pr
    return (_STD get<1>(_STD move(_Pr)));
    }

template<class _FwdIt1 , class _FwdIt2 >

void iter_swap ( _FwdIt1  _Left, _FwdIt2  _Right  )

inline

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

template<class _Ty1 , class _Ty2 >

constexpr 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 >

constexpr 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 >

constexpr 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 >

constexpr 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 >

constexpr 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 >

constexpr 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 >

constexpr 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, class >

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

inline

    {   // exchange arrays stored at _Left and _Right
    if (&_Left != &_Right)
        {   // worth swapping, swap ranges
        _Ty *_First1 = _Left;
        _Ty *_Last1 = _First1 + _Size;
        _Ty *_First2 = _Right;
        for (; _First1 != _Last1; ++_First1, ++_First2)
            _STD iter_swap(_First1, _First2);
        }
    }

template<class _Ty , class >

void swap ( _Ty &  _Left, _Ty &  _Right  )

inline

    {   // exchange values stored at _Left and _Right
    _Ty _Tmp = _STD move(_Left);
    _Left = _STD move(_Right);
    _Right = _STD move(_Tmp);
    }

template<class _Ty1 , class _Ty2 , class = enable_if_t<_Is_swappable<_Ty1>::value && _Is_swappable<_Ty2>::value>>

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

inline

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

Variable Documentation

const _Ty& _Right

Initial value:

{   
    return (_Right < _Left ? _Right : _Left)

constexpr piecewise_construct_t piecewise_construct {}

template<class _Ty >

constexpr size_t tuple_size_v = tuple_size<_Ty>::value