xutility File Reference

#include <climits>
#include <cstdlib>
#include <utility>

Classes
struct	_Container_base0
struct	_Iterator_base0
struct	_Container_proxy
struct	_Container_base12
struct	_Iterator_base12
struct	input_iterator_tag
struct	_Mutable_iterator_tag
struct	output_iterator_tag
struct	forward_iterator_tag
struct	bidirectional_iterator_tag
struct	random_access_iterator_tag
struct	_Nonscalar_ptr_iterator_tag
struct	_Scalar_ptr_iterator_tag
struct	iterator< _Category, _Ty, _Diff, _Pointer, _Reference >
struct	_Iterator012< _Category, _Ty, _Diff, _Pointer, _Reference, _Base >
struct	iterator_traits< _Iter >
struct	iterator_traits< _Ty * >
struct	iterator_traits< const _Ty * >
struct	_Ptr_cat_helper< _Elem1, _Elem2 >
struct	_Ptr_cat_helper< _Elem, _Elem >
struct	_Ptr_cat_helper< _Anything *, const _Anything * >
struct	pointer_traits< _Ty >
class	_Revranit< _RanIt, _Base >
class	reverse_iterator< _RanIt >
struct	_Is_checked_helper< reverse_iterator< _RanIt > >
class	_Array_const_iterator< _Ty, _Size >
class	_Array_iterator< _Ty, _Size >
class	move_iterator< _RanIt >
struct	_Is_checked_helper< move_iterator< _RanIt > >
class	_Rng_from_urng< _Diff, _Urng >
class	_Yarn< _Elem >
struct	_Has_allocator_type< _Ty, _Alloc >
struct	allocator_arg_t
struct	std::uses_allocator< _Ty, _Alloc >

Macros
#define	_XUTILITY_
#define	_DEBUG_ERROR(mesg)
#define	_UNCHECKED_TYPE(_Iter)   typename _Get_unchecked_type<_Iter>::type
#define	_DEBUG_LT(x, y)   ((x) < (y))
#define	_DEBUG_LT_PRED(pred, x, y)   pred(x, y)
#define	_DEBUG_ORDER(first, last)
#define	_DEBUG_ORDER_PRED(first, last, pred)
#define	_DEBUG_POINTER(first)
#define	_DEBUG_POINTER2(first, file, line)
#define	_DEBUG_RANGE(first, last)
#define	_DEBUG_RANGE2(first, last, file, line)

Typedefs
typedef _Container_base0	_Container_base
typedef _Iterator_base0	_Iterator_base
typedef iterator< output_iterator_tag, void, void, void, void >	_Outit

Functions
template<class _Ty >
struct _Get_unchecked_type	_GET_TYPE_OR_DEFAULT (_Unchecked_type, _Ty)
template<class _Ty >
struct _Is_checked_helper	_HAS_ONE_TYPE (_Unchecked_type)
template<class _Iter >
_Is_checked_helper< _Iter >::type	_Is_checked (_Iter)
template<class _Iter >
_Iter	_Unchecked (_Iter _Src)
template<class _Iter , class _UIter >
_Iter &	_Rechecked (_Iter &_Dest, _UIter _Src)
template<class _Iter >
iterator_traits< _Iter >::iterator_category	_Iter_cat (const _Iter &)
template<class _Iter1 , class _Iter2 >
_Nonscalar_ptr_iterator_tag	_Ptr_cat (_Iter1 &, _Iter2 &)
template<class _Elem1 , class _Elem2 >
_Ptr_cat_helper< _Elem1, _Elem2 >::type	_Ptr_cat (_Elem1 *, _Elem2 *)
template<class _Elem1 , class _Elem2 >
_Ptr_cat_helper< _Elem1, _Elem2 >::type	_Ptr_cat (const _Elem1 *, _Elem2 *)
template<class _InIt , class _Diff >
void	_Advance (_InIt &_Where, _Diff _Off, input_iterator_tag)
template<class _FwdIt , class _Diff >
void	_Advance (_FwdIt &_Where, _Diff _Off, forward_iterator_tag)
template<class _BidIt , class _Diff >
void	_Advance (_BidIt &_Where, _Diff _Off, bidirectional_iterator_tag)
template<class _RanIt , class _Diff >
void	_Advance (_RanIt &_Where, _Diff _Off, random_access_iterator_tag)
template<class _InIt , class _Diff >
void	advance (_InIt &_Where, _Diff _Off)
template<class _InIt , class _Diff >
void	_Distance2 (_InIt _First, _InIt _Last, _Diff &_Off, input_iterator_tag)
template<class _FwdIt , class _Diff >
void	_Distance2 (_FwdIt _First, _FwdIt _Last, _Diff &_Off, forward_iterator_tag)
template<class _BidIt , class _Diff >
void	_Distance2 (_BidIt _First, _BidIt _Last, _Diff &_Off, bidirectional_iterator_tag)
template<class _RanIt , class _Diff >
void	_Distance2 (_RanIt _First, _RanIt _Last, _Diff &_Off, random_access_iterator_tag)
template<class _InIt >
iterator_traits< _InIt >::difference_type	distance (_InIt _First, _InIt _Last)
template<class _InIt , class _Diff >
void	_Distance (_InIt _First, _InIt _Last, _Diff &_Off)
template<class _FwdIt >
_FwdIt	next (_FwdIt _First, typename iterator_traits< _FwdIt >::difference_type _Off=1)
template<class _BidIt >
_BidIt	prev (_BidIt _First, typename iterator_traits< _BidIt >::difference_type _Off=1)
template<class _RanIt , class _Base , class _Diff >
_Revranit< _RanIt, _Base >	operator+ (_Diff _Off, const _Revranit< _RanIt, _Base > &_Right)
template<class _RanIt1 , class _Base1 , class _RanIt2 , class _Base2 >
auto	operator- (const _Revranit< _RanIt1, _Base1 > &_Left, const _Revranit< _RanIt2, _Base2 > &_Right) -> decltype(_Right.base()-_Left.base())
template<class _RanIt1 , class _Base1 , class _RanIt2 , class _Base2 >
bool	operator== (const _Revranit< _RanIt1, _Base1 > &_Left, const _Revranit< _RanIt2, _Base2 > &_Right)
template<class _RanIt1 , class _Base1 , class _RanIt2 , class _Base2 >
bool	operator!= (const _Revranit< _RanIt1, _Base1 > &_Left, const _Revranit< _RanIt2, _Base2 > &_Right)
template<class _RanIt1 , class _Base1 , class _RanIt2 , class _Base2 >
bool	operator< (const _Revranit< _RanIt1, _Base1 > &_Left, const _Revranit< _RanIt2, _Base2 > &_Right)
template<class _RanIt1 , class _Base1 , class _RanIt2 , class _Base2 >
bool	operator> (const _Revranit< _RanIt1, _Base1 > &_Left, const _Revranit< _RanIt2, _Base2 > &_Right)
template<class _RanIt1 , class _Base1 , class _RanIt2 , class _Base2 >
bool	operator<= (const _Revranit< _RanIt1, _Base1 > &_Left, const _Revranit< _RanIt2, _Base2 > &_Right)
template<class _RanIt1 , class _Base1 , class _RanIt2 , class _Base2 >
bool	operator>= (const _Revranit< _RanIt1, _Base1 > &_Left, const _Revranit< _RanIt2, _Base2 > &_Right)
template<class _RanIt , class _Diff >
reverse_iterator< _RanIt >	operator+ (_Diff _Off, const reverse_iterator< _RanIt > &_Right)
template<class _RanIt1 , class _RanIt2 >
auto	operator- (const reverse_iterator< _RanIt1 > &_Left, const reverse_iterator< _RanIt2 > &_Right) -> decltype(_Right.base()-_Left.base())
template<class _RanIt1 , class _RanIt2 >
bool	operator== (const reverse_iterator< _RanIt1 > &_Left, const reverse_iterator< _RanIt2 > &_Right)
template<class _RanIt1 , class _RanIt2 >
bool	operator!= (const reverse_iterator< _RanIt1 > &_Left, const reverse_iterator< _RanIt2 > &_Right)
template<class _RanIt1 , class _RanIt2 >
bool	operator< (const reverse_iterator< _RanIt1 > &_Left, const reverse_iterator< _RanIt2 > &_Right)
template<class _RanIt1 , class _RanIt2 >
bool	operator> (const reverse_iterator< _RanIt1 > &_Left, const reverse_iterator< _RanIt2 > &_Right)
template<class _RanIt1 , class _RanIt2 >
bool	operator<= (const reverse_iterator< _RanIt1 > &_Left, const reverse_iterator< _RanIt2 > &_Right)
template<class _RanIt1 , class _RanIt2 >
bool	operator>= (const reverse_iterator< _RanIt1 > &_Left, const reverse_iterator< _RanIt2 > &_Right)
template<class _Container >
auto	begin (_Container &_Cont) -> decltype(_Cont.begin())
template<class _Container >
auto	begin (const _Container &_Cont) -> decltype(_Cont.begin())
template<class _Container >
auto	end (_Container &_Cont) -> decltype(_Cont.end())
template<class _Container >
auto	end (const _Container &_Cont) -> decltype(_Cont.end())
template<class _Ty , size_t _Size>
_Ty *	begin (_Ty(&_Array)[_Size])
template<class _Ty , size_t _Size>
_Ty *	end (_Ty(&_Array)[_Size])
template<class _Container >
auto	cbegin (const _Container &_Cont) -> decltype(_STD begin(_Cont))
template<class _Container >
auto	cend (const _Container &_Cont) -> decltype(_STD end(_Cont))
template<class _Container >
auto	rbegin (_Container &_Cont) -> decltype(_Cont.rbegin())
template<class _Container >
auto	rbegin (const _Container &_Cont) -> decltype(_Cont.rbegin())
template<class _Container >
auto	rend (_Container &_Cont) -> decltype(_Cont.rend())
template<class _Container >
auto	rend (const _Container &_Cont) -> decltype(_Cont.rend())
template<class _Ty , size_t _Size>
reverse_iterator< _Ty * >	rbegin (_Ty(&_Array)[_Size])
template<class _Ty , size_t _Size>
reverse_iterator< _Ty * >	rend (_Ty(&_Array)[_Size])
template<class _Elem >
reverse_iterator< const _Elem * >	rbegin (initializer_list< _Elem > _Ilist)
template<class _Elem >
reverse_iterator< const _Elem * >	rend (initializer_list< _Elem > _Ilist)
template<class _Container >
auto	crbegin (const _Container &_Cont) -> decltype(_STD rbegin(_Cont))
template<class _Container >
auto	crend (const _Container &_Cont) -> decltype(_STD rend(_Cont))
template<class _Ty , size_t _Size>
_Array_const_iterator< _Ty, _Size >::_Unchecked_type	_Unchecked (_Array_const_iterator< _Ty, _Size > _Iter)
template<class _Ty , size_t _Size>
_Array_const_iterator< _Ty, _Size > &	_Rechecked (_Array_const_iterator< _Ty, _Size > &_Iter, typename _Array_const_iterator< _Ty, _Size >::_Unchecked_type _Right)
template<class _Ty , size_t _Size>
_Array_const_iterator< _Ty, _Size >	operator+ (typename _Array_const_iterator< _Ty, _Size >::difference_type _Off, _Array_const_iterator< _Ty, _Size > _Next)
template<class _Ty , size_t _Size>
_Array_iterator< _Ty, _Size >::_Unchecked_type	_Unchecked (_Array_iterator< _Ty, _Size > _Iter)
template<class _Ty , size_t _Size>
_Array_iterator< _Ty, _Size > &	_Rechecked (_Array_iterator< _Ty, _Size > &_Iter, typename _Array_iterator< _Ty, _Size >::_Unchecked_type _Right)
template<class _Ty , size_t _Size>
_Array_iterator< _Ty, _Size >	operator+ (typename _Array_iterator< _Ty, _Size >::difference_type _Off, _Array_iterator< _Ty, _Size > _Next)
template<class _RanIt , class _Diff >
move_iterator< _RanIt >	operator+ (_Diff _Off, const move_iterator< _RanIt > &_Right)
template<class _RanIt1 , class _RanIt2 >
auto	operator- (move_iterator< _RanIt1 > &_Left, const move_iterator< _RanIt2 > &_Right) -> decltype(_Left.base()-_Right.base())
template<class _RanIt1 , class _RanIt2 >
bool	operator== (const move_iterator< _RanIt1 > &_Left, const move_iterator< _RanIt2 > &_Right)
template<class _RanIt1 , class _RanIt2 >
bool	operator!= (const move_iterator< _RanIt1 > &_Left, const move_iterator< _RanIt2 > &_Right)
template<class _RanIt1 , class _RanIt2 >
bool	operator< (const move_iterator< _RanIt1 > &_Left, const move_iterator< _RanIt2 > &_Right)
template<class _RanIt1 , class _RanIt2 >
bool	operator> (const move_iterator< _RanIt1 > &_Left, const move_iterator< _RanIt2 > &_Right)
template<class _RanIt1 , class _RanIt2 >
bool	operator<= (const move_iterator< _RanIt1 > &_Left, const move_iterator< _RanIt2 > &_Right)
template<class _RanIt1 , class _RanIt2 >
bool	operator>= (const move_iterator< _RanIt1 > &_Left, const move_iterator< _RanIt2 > &_Right)
template<class _RanIt >
move_iterator< _RanIt >	make_move_iterator (_RanIt _Iter)
template<class _InIt , class _OutIt >
_OutIt	_Copy_impl (_InIt _First, _InIt _Last, _OutIt _Dest, _Nonscalar_ptr_iterator_tag)
template<class _InIt , class _OutIt >
_OutIt	_Copy_impl (_InIt _First, _InIt _Last, _OutIt _Dest, _Scalar_ptr_iterator_tag)
template<class _InIt , class _OutIt >
_OutIt	_Copy_impl (_InIt _First, _InIt _Last, _OutIt _Dest)
template<class _InIt , class _OutIt >
_OutIt	copy (_InIt _First, _InIt _Last, _OutIt _Dest)
template<class _InIt , class _Diff , class _OutIt >
_OutIt	_Copy_n (_InIt _First, _Diff _Count, _OutIt _Dest, input_iterator_tag)
template<class _InIt , class _Diff , class _OutIt >
_OutIt	_Copy_n (_InIt _First, _Diff _Count, _OutIt _Dest, forward_iterator_tag)
template<class _InIt , class _Diff , class _OutIt >
_OutIt	_Copy_n (_InIt _First, _Diff _Count, _OutIt _Dest, _Nonscalar_ptr_iterator_tag)
template<class _InIt , class _Diff , class _OutIt >
_OutIt	_Copy_n (_InIt _First, _Diff _Count, _OutIt _Dest, _Scalar_ptr_iterator_tag)
template<class _InIt , class _Diff , class _OutIt >
_OutIt	_Copy_n (_InIt _First, _Diff _Count, _OutIt _Dest)
template<class _InIt , class _Diff , class _OutIt >
_OutIt	copy_n (_InIt _First, _Diff _Count, _OutIt _Dest)
template<class _BidIt1 , class _BidIt2 >
_BidIt2	_Copy_backward (_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest, _Nonscalar_ptr_iterator_tag)
template<class _InIt , class _OutIt >
_OutIt	_Copy_backward (_InIt _First, _InIt _Last, _OutIt _Dest, _Scalar_ptr_iterator_tag)
template<class _BidIt1 , class _BidIt2 >
_BidIt2	_Copy_backward (_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest)
template<class _BidIt1 , class _BidIt2 >
_BidIt2	copy_backward (_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest)
template<class _InIt , class _OutIt >
_OutIt	_Move (_InIt _First, _InIt _Last, _OutIt _Dest, _Nonscalar_ptr_iterator_tag)
template<class _InIt , class _OutIt >
_OutIt	_Move (_InIt _First, _InIt _Last, _OutIt _Dest, _Scalar_ptr_iterator_tag)
template<class _InIt , class _OutIt >
_OutIt	_Move (_InIt _First, _InIt _Last, _OutIt _Dest)
template<class _InIt , class _OutIt >
_OutIt	move (_InIt _First, _InIt _Last, _OutIt _Dest)
template<class _BidIt1 , class _BidIt2 >
_BidIt2	_Move_backward (_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest, _Nonscalar_ptr_iterator_tag)
template<class _InIt , class _OutIt >
_OutIt	_Move_backward (_InIt _First, _InIt _Last, _OutIt _Dest, _Scalar_ptr_iterator_tag)
template<class _BidIt1 , class _BidIt2 >
_BidIt2	_Move_backward (_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest)
template<class _BidIt1 , class _BidIt2 >
_BidIt2	move_backward (_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest)
template<class _FwdIt , class _Ty >
void	_Fill (_FwdIt _First, _FwdIt _Last, const _Ty &_Val)
void	_Fill (char *_First, char *_Last, char _Val)
void	_Fill (signed char *_First, signed char *_Last, signed char _Val)
void	_Fill (unsigned char *_First, unsigned char *_Last, unsigned char _Val)
template<class _FwdIt , class _Ty >
void	fill (_FwdIt _First, _FwdIt _Last, const _Ty &_Val)
template<class _OutIt , class _Diff , class _Ty >
_OutIt	_Fill_n (_OutIt _Dest, _Diff _Count, const _Ty &_Val)
char *	_Fill_n (char *_Dest, size_t _Count, char _Val)
signed char *	_Fill_n (signed char *_Dest, size_t _Count, signed char _Val)
unsigned char *	_Fill_n (unsigned char *_Dest, size_t _Count, unsigned char _Val)
template<class _OutIt , class _Diff , class _Ty >
_OutIt	fill_n (_OutIt _Dest, _Diff _Count, const _Ty &_Val)
template<class _InIt1 , class _InIt2 >
bool	_Equal (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2)
bool	_Equal (const char *_First1, const char *_Last1, const char *_First2)
bool	_Equal (const signed char *_First1, const signed char *_Last1, const signed char *_First2)
bool	_Equal (const unsigned char *_First1, const unsigned char *_Last1, const unsigned char *_First2)
template<class _InIt1 , class _InIt2 >
bool	equal (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2)
template<class _InIt1 , class _InIt2 , class _Pr >
bool	_Equal (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Pr _Pred)
template<class _InIt1 , class _InIt2 , class _Pr >
bool	equal (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Pr _Pred)
template<class _InIt1 , class _InIt2 >
bool	_Lexicographical_compare (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2)
bool	_Lexicographical_compare (const unsigned char *_First1, const unsigned char *_Last1, const unsigned char *_First2, const unsigned char *_Last2)
template<class _InIt1 , class _InIt2 >
bool	lexicographical_compare (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2)
template<class _InIt1 , class _InIt2 , class _Pr >
bool	_Lexicographical_compare (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _Pr _Pred)
template<class _InIt1 , class _InIt2 , class _Pr >
bool	lexicographical_compare (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _Pr _Pred)
template<class _Ty , class _Ignored >
bool	_Within_limits (const _Ty &_Val, true_type, true_type, _Ignored)
template<class _Ty >
bool	_Within_limits (const _Ty &_Val, true_type, false_type, true_type)
template<class _Ty >
bool	_Within_limits (const _Ty &_Val, true_type, false_type, false_type)
template<class _Ty , class _Ignored >
bool	_Within_limits (const _Ty &_Val, false_type, true_type, _Ignored)
template<class _Ty , class _Ignored >
bool	_Within_limits (const _Ty &_Val, false_type, false_type, _Ignored)
template<class _InIt , class _Ty >
bool	_Within_limits (_InIt, const _Ty &_Val)
template<class _InIt >
bool	_Within_limits (_InIt, const bool &)
template<class _InIt , class _Ty >
_InIt	_Find (_InIt _First, _InIt _Last, const _Ty &_Val, true_type)
template<class _InIt , class _Ty >
_InIt	_Find (_InIt _First, _InIt _Last, const _Ty &_Val, false_type)
template<class _InIt , class _Ty >
_InIt	_Find (_InIt _First, _InIt _Last, const _Ty &_Val)
template<class _InIt , class _Ty >
_InIt	find (_InIt _First, _InIt _Last, const _Ty &_Val)
template<class _InIt , class _Ty , class _Pr >
_InIt	_Find_pr (_InIt _First, _InIt _Last, const _Ty &_Val, _Pr _Pred)
template<class _InIt , class _Ty >
iterator_traits< _InIt >::difference_type	_Count_np (_InIt _First, _InIt _Last, const _Ty &_Val)
template<class _InIt , class _Ty >
iterator_traits< _InIt >::difference_type	count (_InIt _First, _InIt _Last, const _Ty &_Val)
template<class _InIt , class _Ty , class _Pr >
iterator_traits< _InIt >::difference_type	_Count_pr (_InIt _First, _InIt _Last, const _Ty &_Val, _Pr _Pred)
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
bool	_Is_permutation (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _Pr _Pred)
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
bool	is_permutation (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _Pr _Pred)
template<class _FwdIt1 , class _FwdIt2 >
bool	is_permutation (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2)
template<class _BidIt >
void	_Reverse (_BidIt _First, _BidIt _Last, bidirectional_iterator_tag)
template<class _BidIt >
void	reverse (_BidIt _First, _BidIt _Last)
template<class _FwdIt >
void	_Rotate (_FwdIt _First, _FwdIt _Mid, _FwdIt _Last, forward_iterator_tag)
template<class _BidIt >
void	_Rotate (_BidIt _First, _BidIt _Mid, _BidIt _Last, bidirectional_iterator_tag)
template<class _RanIt , class _Diff , class _Ty >
void	_Rotate (_RanIt _First, _RanIt _Mid, _RanIt _Last, _Diff *, _Ty *)
template<class _RanIt >
void	_Rotate (_RanIt _First, _RanIt _Mid, _RanIt _Last, random_access_iterator_tag)
template<class _FwdIt >
_FwdIt	rotate (_FwdIt _First, _FwdIt _Mid, _FwdIt _Last)
_CRTIMP2_PURE	_NO_RETURN (__CLRCALL_PURE_OR_CDECL _Xbad_alloc())
_CRTIMP2_PURE	_NO_RETURN (__CLRCALL_PURE_OR_CDECL _Xinvalid_argument(_In_z_ const char *))

Variables
template<class _Iter >
iterator_traits< _Iter >::value_type *	_Val_type (_Iter)
template<class _Iter >
iterator_traits< _Iter >::difference_type *	_Dist_type (_Iter)
const allocator_arg_t	allocator_arg = allocator_arg_t()

Macro Definition Documentation

#define _DEBUG_ERROR

(

mesg

)

#define _DEBUG_LT	(		x,
			y
	)		((x) < (y))

#define _DEBUG_LT_PRED	(		pred,
			x,
			y
	)		pred(x, y)

#define _DEBUG_ORDER	(		first,
			last
	)

#define _DEBUG_ORDER_PRED	(		first,
			last,
			pred
	)

#define _DEBUG_POINTER

(

first

)

#define _DEBUG_POINTER2	(		first,
			file,
			line
	)

#define _DEBUG_RANGE	(		first,
			last
	)

#define _DEBUG_RANGE2	(		first,
			last,
			file,
			line
	)

#define _UNCHECKED_TYPE

(

_Iter

)

typename _Get_unchecked_type<_Iter>::type

#define _XUTILITY_

Typedef Documentation

typedef _Container_base0 _Container_base

typedef _Iterator_base0 _Iterator_base

typedef iterator<output_iterator_tag, void, void, void, void> _Outit

Function Documentation

template<class _InIt , class _Diff >

void _Advance ( _InIt &  _Where, _Diff  _Off, input_iterator_tag    )

inline

    {   // increment iterator by offset, input iterators
 #if _ITERATOR_DEBUG_LEVEL == 2
    if (_Off < 0)
        _DEBUG_ERROR("negative offset in advance");
 #endif /* _ITERATOR_DEBUG_LEVEL == 2 */

    for (; 0 < _Off; --_Off)
        ++_Where;
    }

template<class _FwdIt , class _Diff >

void _Advance ( _FwdIt &  _Where, _Diff  _Off, forward_iterator_tag    )

inline

    {   // increment iterator by offset, forward iterators
 #if _ITERATOR_DEBUG_LEVEL == 2
    if (_Off < 0)
        _DEBUG_ERROR("negative offset in advance");
 #endif /* _ITERATOR_DEBUG_LEVEL == 2 */

    for (; 0 < _Off; --_Off)
        ++_Where;
    }

template<class _BidIt , class _Diff >

void _Advance ( _BidIt &  _Where, _Diff  _Off, bidirectional_iterator_tag    )

inline

    {   // increment iterator by offset, bidirectional iterators
    for (; 0 < _Off; --_Off)
        ++_Where;
    for (; _Off < 0; ++_Off)
        --_Where;
    }

template<class _RanIt , class _Diff >

void _Advance ( _RanIt &  _Where, _Diff  _Off, random_access_iterator_tag    )

inline

    {   // increment iterator by offset, random-access iterators
    _Where += _Off;
    }

template<class _BidIt1 , class _BidIt2 >

_BidIt2 _Copy_backward ( _BidIt1  _First, _BidIt1  _Last, _BidIt2  _Dest, _Nonscalar_ptr_iterator_tag    )

inline

    {   // copy [_First, _Last) backwards to [..., _Dest), arbitrary iterators
    while (_First != _Last)
        *--_Dest = *--_Last;
    return (_Dest);
    }

template<class _InIt , class _OutIt >

_OutIt _Copy_backward ( _InIt  _First, _InIt  _Last, _OutIt  _Dest, _Scalar_ptr_iterator_tag    )

inline

    {   // copy [_First, _Last) backwards to [..., _Dest), pointers to scalars
    ptrdiff_t _Count = _Last - _First;
    _CSTD memmove(&*_Dest - _Count, &*_First,
        _Count * sizeof (*_First));
    return (_Dest - _Count);
    }

template<class _BidIt1 , class _BidIt2 >

_BidIt2 _Copy_backward ( _BidIt1  _First, _BidIt1  _Last, _BidIt2  _Dest  )

inline

    {   // copy [_First, _Last) backwards to [..., _Dest), unchecked
    return (_Copy_backward(_First, _Last,
        _Dest, _Ptr_cat(_First, _Dest)));
    }

template<class _InIt , class _OutIt >

_OutIt _Copy_impl ( _InIt  _First, _InIt  _Last, _OutIt  _Dest, _Nonscalar_ptr_iterator_tag    )

inline

    {   // copy [_First, _Last) to [_Dest, ...), arbitrary iterators
    for (; _First != _Last; ++_Dest, ++_First)
        *_Dest = *_First;
    return (_Dest);
    }

template<class _InIt , class _OutIt >

_OutIt _Copy_impl ( _InIt  _First, _InIt  _Last, _OutIt  _Dest, _Scalar_ptr_iterator_tag    )

inline

    {   // copy [_First, _Last) to [_Dest, ...), pointers to scalars
    ptrdiff_t _Count = _Last - _First;
    _CSTD memmove(&*_Dest, &*_First,
        _Count * sizeof (*_First));
    return (_Dest + _Count);
    }

template<class _InIt , class _OutIt >

_OutIt _Copy_impl ( _InIt  _First, _InIt  _Last, _OutIt  _Dest  )

inline

    {   // copy [_First, _Last) to [_Dest, ...)
    return (_Copy_impl(_First, _Last,
        _Dest, _Ptr_cat(_First, _Dest)));
    }

template<class _InIt , class _Diff , class _OutIt >

_OutIt _Copy_n ( _InIt  _First, _Diff  _Count, _OutIt  _Dest, input_iterator_tag    )

inline

    {   // copy [_First, _First + _Count) to [_Dest, ...), input iterators
    *_Dest = *_First;   // 0 < _Count has been guaranteed
    while (0 < --_Count)
        *++_Dest = *++_First;
    return (++_Dest);
    }

template<class _InIt , class _Diff , class _OutIt >

_OutIt _Copy_n ( _InIt  _First, _Diff  _Count, _OutIt  _Dest, forward_iterator_tag    )

inline

    {   // copy [_First, _First + _Count) to [_Dest, ...), forward iterators
    for (; 0 < _Count; --_Count, ++_Dest, ++_First)
        *_Dest = *_First;
    return (_Dest);
    }

template<class _InIt , class _Diff , class _OutIt >

_OutIt _Copy_n ( _InIt  _First, _Diff  _Count, _OutIt  _Dest, _Nonscalar_ptr_iterator_tag    )

inline

    {   // copy [_First, _First + _Count) to [_Dest, ...), arbitrary iterators
    return (_Copy_n(_First, _Count,
        _Dest, _Iter_cat(_First)));
    }

template<class _InIt , class _Diff , class _OutIt >

_OutIt _Copy_n ( _InIt  _First, _Diff  _Count, _OutIt  _Dest, _Scalar_ptr_iterator_tag    )

inline

    {   // copy [_First, _First + _Count) to [_Dest, ...), pointers to scalars
    _CSTD memmove(&*_Dest, &*_First,
        _Count * sizeof (*_First));
    return (_Dest + _Count);
    }

template<class _InIt , class _Diff , class _OutIt >

_OutIt _Copy_n ( _InIt  _First, _Diff  _Count, _OutIt  _Dest  )

inline

    {   // copy [_First, _First + _Count) to [_Dest, ...), unchecked
    return (_Copy_n(_First, _Count,
        _Dest, _Ptr_cat(_First, _Dest)));
    }

template<class _InIt , class _Ty >

iterator_traits<_InIt>::difference_type _Count_np ( _InIt  _First, _InIt  _Last, const _Ty &  _Val  )

inline

    {   // count elements that match _Val
    typename iterator_traits<_InIt>::difference_type _Count = 0;

    for (; _First != _Last; ++_First)
        if (*_First == _Val)
            ++_Count;
    return (_Count);
    }

template<class _InIt , class _Ty , class _Pr >

iterator_traits<_InIt>::difference_type _Count_pr ( _InIt  _First, _InIt  _Last, const _Ty &  _Val, _Pr  _Pred  )

inline

    {   // count elements that match _Val, using _Pred
    typename iterator_traits<_InIt>::difference_type _Count = 0;

    for (; _First != _Last; ++_First)
        if (_Pred(*_First, _Val))
            ++_Count;
    return (_Count);
    }

template<class _InIt , class _Diff >

void _Distance ( _InIt  _First, _InIt  _Last, _Diff &  _Off  )

inline

    {   // add to _Off distance between iterators
    _Distance2(_First, _Last, _Off, _Iter_cat(_First));
    }

template<class _InIt , class _Diff >

void _Distance2 ( _InIt  _First, _InIt  _Last, _Diff &  _Off, input_iterator_tag    )

inline

    {   // add to _Off distance between input iterators
    for (; _First != _Last; ++_First)
        ++_Off;
    }

template<class _FwdIt , class _Diff >

void _Distance2 ( _FwdIt  _First, _FwdIt  _Last, _Diff &  _Off, forward_iterator_tag    )

inline

    {   // add to _Off distance between forward iterators (redundant)
    for (; _First != _Last; ++_First)
        ++_Off;
    }

template<class _BidIt , class _Diff >

void _Distance2 ( _BidIt  _First, _BidIt  _Last, _Diff &  _Off, bidirectional_iterator_tag    )

inline

    {   // add to _Off distance between bidirectional iterators (redundant)
    for (; _First != _Last; ++_First)
        ++_Off;
    }

template<class _RanIt , class _Diff >

void _Distance2 ( _RanIt  _First, _RanIt  _Last, _Diff &  _Off, random_access_iterator_tag    )

inline

    {   // add to _Off distance between random-access iterators
 #if _ITERATOR_DEBUG_LEVEL == 2
    if (_First != _Last)
        {   // check for null pointers
        _DEBUG_POINTER(_First);
        _DEBUG_POINTER(_Last);
        }
 #endif /* _ITERATOR_DEBUG_LEVEL == 2 */

    _Off += _Last - _First;
    }

template<class _InIt1 , class _InIt2 >

bool _Equal ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2  )

inline

    {   // compare [_First1, _Last1) to [_First2, ...)
    for (; _First1 != _Last1; ++_First1, ++_First2)
        if (!(*_First1 == *_First2))
            return (false);
    return (true);
    }

bool _Equal ( const char *  _First1, const char *  _Last1, const char *  _First2  )

inline

    {   // compare [_First1, _Last1) to [_First2, ...), for chars
    return (_CSTD memcmp(_First1, _First2, _Last1 - _First1) == 0);
    }

bool _Equal ( const signed char *  _First1, const signed char *  _Last1, const signed char *  _First2  )

inline

    {   // compare [_First1, _Last1) to [_First2, ...), for signed chars
    return (_CSTD memcmp(_First1, _First2, _Last1 - _First1) == 0);
    }

bool _Equal ( const unsigned char *  _First1, const unsigned char *  _Last1, const unsigned char *  _First2  )

inline

    {   // compare [_First1, _Last1) to [_First2, ...), for unsigned chars
    return (_CSTD memcmp(_First1, _First2, _Last1 - _First1) == 0);
    }

template<class _InIt1 , class _InIt2 , class _Pr >

bool _Equal ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _Pr  _Pred  )

inline

    {   // compare [_First1, _Last1) to [_First2, ...) using _Pred
    for (; _First1 != _Last1; ++_First1, ++_First2)
        if (!_Pred(*_First1, *_First2))
            return (false);
    return (true);
    }

template<class _FwdIt , class _Ty >

void _Fill ( _FwdIt  _First, _FwdIt  _Last, const _Ty &  _Val  )

inline

    {   // copy _Val through [_First, _Last)
    for (; _First != _Last; ++_First)
        *_First = _Val;
    }

void _Fill ( char *  _First, char *  _Last, char  _Val  )

inline

    {   // copy char _Val through [_First, _Last)
    _CSTD memset(_First, _Val, _Last - _First);
    }

void _Fill ( signed char *  _First, signed char *  _Last, signed char  _Val  )

inline

    {   // copy signed char _Val through [_First, _Last)
    _CSTD memset(_First, _Val, _Last - _First);
    }

void _Fill ( unsigned char *  _First, unsigned char *  _Last, unsigned char  _Val  )

inline

    {   // copy unsigned char _Val through [_First, _Last)
    _CSTD memset(_First, _Val, _Last - _First);
    }

template<class _OutIt , class _Diff , class _Ty >

_OutIt _Fill_n ( _OutIt  _Dest, _Diff  _Count, const _Ty &  _Val  )

inline

    {   // copy _Val _Count times through [_Dest, ...)
    for (; 0 < _Count; --_Count, ++_Dest)
        *_Dest = _Val;
    return (_Dest);
    }

char* _Fill_n ( char *  _Dest, size_t  _Count, char  _Val  )

inline

    {   // copy char _Val _Count times through [_Dest, ...)
    _CSTD memset(_Dest, _Val, _Count);
    return (_Dest + _Count);
    }

signed char* _Fill_n ( signed char *  _Dest, size_t  _Count, signed char  _Val  )

inline

    {   // copy signed char _Val _Count times through [_Dest, ...)
    _CSTD memset(_Dest, _Val, _Count);
    return (_Dest + _Count);
    }

unsigned char* _Fill_n ( unsigned char *  _Dest, size_t  _Count, unsigned char  _Val  )

inline

    {   // copy unsigned char _Val _Count times through [_Dest, ...)
    _CSTD memset(_Dest, _Val, _Count);
    return (_Dest + _Count);
    }

template<class _InIt , class _Ty >

_InIt _Find ( _InIt  _First, _InIt  _Last, const _Ty &  _Val, true_type    )

inline

    {   // find first byte matching integral _Val
    if (!_Within_limits(_First, _Val))
        return (_Last);
    _First = static_cast<_InIt>(_CSTD memchr(
        _First, static_cast<unsigned char>(_Val), _Last - _First));
    return (_First ? _First : _Last);
    }

template<class _InIt , class _Ty >

_InIt _Find ( _InIt  _First, _InIt  _Last, const _Ty &  _Val, false_type    )

inline

    {   // find first matching _Val
    for (; _First != _Last; ++_First)
        if (*_First == _Val)
            break;
    return (_First);
    }

template<class _InIt , class _Ty >

_InIt _Find ( _InIt  _First, _InIt  _Last, const _Ty &  _Val  )

inline

    {   // find first matching _Val
    // activate optimization for pointers to (const) bytes and integral values
    typedef integral_constant<bool,
        (  is_same<_InIt, char *>::value
        || is_same<_InIt, signed char *>::value
        || is_same<_InIt, unsigned char *>::value
        || is_same<_InIt, const char *>::value
        || is_same<_InIt, const signed char *>::value
        || is_same<_InIt, const unsigned char *>::value)
        && is_integral<_Ty>::value
    > _Memchr_opt;
    return (_Find(_First, _Last, _Val, _Memchr_opt()));
    }

template<class _InIt , class _Ty , class _Pr >

_InIt _Find_pr ( _InIt  _First, _InIt  _Last, const _Ty &  _Val, _Pr  _Pred  )

inline

    {   // find first matching _Val, using _Pred
    for (; _First != _Last; ++_First)
        if (_Pred(*_First, _Val))
            break;
    return (_First);
    }

template<class _Ty >

struct _Get_unchecked_type _GET_TYPE_OR_DEFAULT	(	_Unchecked_type	,
		_Ty
	)

template<class _Ty >

struct _Is_checked_helper _HAS_ONE_TYPE

(

_Unchecked_type

)

template<class _Iter >

_Is_checked_helper<_Iter>::type _Is_checked ( _Iter  )

inline

    {   // return type is derived from true_type if iterator is checked
    return (typename _Is_checked_helper<_Iter>::type());
    }

template<class _FwdIt1 , class _FwdIt2 , class _Pr >

bool _Is_permutation ( _FwdIt1  _First1, _FwdIt1  _Last1, _FwdIt2  _First2, _Pr  _Pred  )

inline

    {   // test if [_First1, _Last1) == permuted [_First2, ...), using _Pred
    for (; _First1 != _Last1; ++_First1, ++_First2)
        if (!_Pred(*_First1, *_First2))
            break;  // find first inequality
    if (_First1 != _Last1)
        {   // check match counts in suffix
        _FwdIt2 _Last2 = _First2;
        advance(_Last2, distance(_First1, _Last1));
        for (_FwdIt1 _Next1 = _First1; _Next1 != _Last1; ++_Next1)
            if (_Next1 == _Find_pr(_First1, _Next1, *_Next1, _Pred))
                {   // new value, compare match counts
                typename iterator_traits<_FwdIt2>::difference_type _Count =
                    _Count_pr(_First2, _Last2, *_Next1, _Pred);
                if (_Count == 0
                    || _Count != _Count_pr(_Next1, _Last1, *_Next1, _Pred))
                    return (false); // match counts differ, fail
                }
        }
    return (true);
    }

template<class _Iter >

iterator_traits<_Iter>::iterator_category _Iter_cat ( const _Iter &  )

inline

    {   // return category from iterator argument
    typename iterator_traits<_Iter>::iterator_category _Cat;
    return (_Cat);
    }

template<class _InIt1 , class _InIt2 >

bool _Lexicographical_compare ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _InIt2  _Last2  )

inline

    {   // order [_First1, _Last1) vs. [_First2, _Last2)
    for (; _First1 != _Last1 && _First2 != _Last2; ++_First1, ++_First2)
        if (_DEBUG_LT(*_First1, *_First2))
            return (true);
        else if (*_First2 < *_First1)
            return (false);
    return (_First1 == _Last1 && _First2 != _Last2);
    }

bool _Lexicographical_compare ( const unsigned char *  _First1, const unsigned char *  _Last1, const unsigned char *  _First2, const unsigned char *  _Last2  )

inline

    {   // order [_First1, _Last1) vs. [_First2, _Last2), for unsigned char
    ptrdiff_t _Num1 = _Last1 - _First1;
    ptrdiff_t _Num2 = _Last2 - _First2;
    int _Ans = _CSTD memcmp(_First1, _First2, _Num1 < _Num2 ? _Num1 : _Num2);
    return (_Ans < 0 || (_Ans == 0 && _Num1 < _Num2));
    }

template<class _InIt1 , class _InIt2 , class _Pr >

bool _Lexicographical_compare ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _InIt2  _Last2, _Pr  _Pred  )

inline

    {   // order [_First1, _Last1) vs. [_First2, _Last2) using _Pred
    for (; _First1 != _Last1 && _First2 != _Last2; ++_First1, ++_First2)
        if (_DEBUG_LT_PRED(_Pred, *_First1, *_First2))
            return (true);
        else if (_Pred(*_First2, *_First1))
            return (false);
    return (_First1 == _Last1 && _First2 != _Last2);
    }

template<class _InIt , class _OutIt >

_OutIt _Move ( _InIt  _First, _InIt  _Last, _OutIt  _Dest, _Nonscalar_ptr_iterator_tag    )

inline

    {   // move [_First, _Last) to [_Dest, ...), arbitrary iterators
    for (; _First != _Last; ++_Dest, ++_First)
        *_Dest = _STD move(*_First);
    return (_Dest);
    }

template<class _InIt , class _OutIt >

_OutIt _Move ( _InIt  _First, _InIt  _Last, _OutIt  _Dest, _Scalar_ptr_iterator_tag    )

inline

    {   // move [_First, _Last) to [_Dest, ...), pointers to scalars
    ptrdiff_t _Count = _Last - _First;
    _CSTD memmove(&*_Dest, &*_First,
        _Count * sizeof (*_First));
    return (_Dest + _Count);
    }

template<class _InIt , class _OutIt >

_OutIt _Move ( _InIt  _First, _InIt  _Last, _OutIt  _Dest  )

inline

    {   // move [_First, _Last) to [_Dest, ...), unchecked
    return (_Move(_First, _Last,
        _Dest, _Ptr_cat(_First, _Dest)));
    }

template<class _BidIt1 , class _BidIt2 >

_BidIt2 _Move_backward ( _BidIt1  _First, _BidIt1  _Last, _BidIt2  _Dest, _Nonscalar_ptr_iterator_tag    )

inline

    {   // move [_First, _Last) backwards to [..., _Dest), arbitrary iterators
    while (_First != _Last)
        *--_Dest = _STD move(*--_Last);
    return (_Dest);
    }

template<class _InIt , class _OutIt >

_OutIt _Move_backward ( _InIt  _First, _InIt  _Last, _OutIt  _Dest, _Scalar_ptr_iterator_tag    )

inline

    {   // move [_First, _Last) backwards to [..., _Dest), pointers to scalars
    ptrdiff_t _Count = _Last - _First;
    _CSTD memmove(&*_Dest - _Count, &*_First,
        _Count * sizeof (*_First));
    return (_Dest - _Count);
    }

template<class _BidIt1 , class _BidIt2 >

_BidIt2 _Move_backward ( _BidIt1  _First, _BidIt1  _Last, _BidIt2  _Dest  )

inline

    {   // move [_First, _Last) backwards to [..., _Dest), unchecked
    return (_Move_backward(_First, _Last,
        _Dest, _Ptr_cat(_First, _Dest)));
    }

_CRTIMP2_PURE _NO_RETURN

(

__CLRCALL_PURE_OR_CDECL

_Xbad_alloc()

)

_CRTIMP2_PURE _NO_RETURN

(

__CLRCALL_PURE_OR_CDECL

_Xinvalid_argument_In_z_ const char *

)

template<class _Iter1 , class _Iter2 >

_Nonscalar_ptr_iterator_tag _Ptr_cat ( _Iter1 &  , _Iter2 &    )

inline

    {   // return pointer category from arbitrary arguments
    _Nonscalar_ptr_iterator_tag _Cat;
    return (_Cat);
    }

template<class _Elem1 , class _Elem2 >

_Ptr_cat_helper<_Elem1, _Elem2>::type _Ptr_cat ( _Elem1 *  , _Elem2 *    )

inline

    {   // return pointer category from pointers
    typename _Ptr_cat_helper<_Elem1, _Elem2>::type _Cat;
    return (_Cat);
    }

template<class _Elem1 , class _Elem2 >

_Ptr_cat_helper<_Elem1, _Elem2>::type _Ptr_cat ( const _Elem1 *  , _Elem2 *    )

inline

    {   // return pointer category from pointers
    typename _Ptr_cat_helper<_Elem1, _Elem2>::type _Cat;
    return (_Cat);
    }

template<class _Iter , class _UIter >

_Iter& _Rechecked ( _Iter &  _Dest, _UIter  _Src  )

inline

    {   // reset checked from unchecked, generic
    _Dest = _Src;
    return (_Dest);
    }

template<class _Ty , size_t _Size>

_Array_const_iterator<_Ty, _Size>& _Rechecked ( _Array_const_iterator< _Ty, _Size > &  _Iter, typename _Array_const_iterator< _Ty, _Size >::_Unchecked_type  _Right  )

inline

    {   // convert to checked
    return (_Iter._Rechecked(_Right));
    }

template<class _Ty , size_t _Size>

_Array_iterator<_Ty, _Size>& _Rechecked ( _Array_iterator< _Ty, _Size > &  _Iter, typename _Array_iterator< _Ty, _Size >::_Unchecked_type  _Right  )

inline

    {   // convert to checked
    return (_Iter._Rechecked(_Right));
    }

template<class _BidIt >

void _Reverse ( _BidIt  _First, _BidIt  _Last, bidirectional_iterator_tag    )

inline

    {   // reverse elements in [_First, _Last), bidirectional iterators
    for (; _First != _Last && _First != --_Last; ++_First)
        _STD iter_swap(_First, _Last);
    }

template<class _FwdIt >

void _Rotate ( _FwdIt  _First, _FwdIt  _Mid, _FwdIt  _Last, forward_iterator_tag    )

inline

    {   // rotate [_First, _Last), forward iterators
    for (_FwdIt _Next = _Mid; ; )
        {   // swap [_First, ...) into place
        _STD iter_swap(_First, _Next);
        if (++_First == _Mid)
            if (++_Next == _Last)
                break;  // done, quit
            else
                _Mid = _Next;   // mark end of next interval
        else if (++_Next == _Last)
            _Next = _Mid;   // wrap to last end
        }
    }

template<class _BidIt >

void _Rotate ( _BidIt  _First, _BidIt  _Mid, _BidIt  _Last, bidirectional_iterator_tag    )

inline

    {   // rotate [_First, _Last), bidirectional iterators
    _STD reverse(_First, _Mid);
    _STD reverse(_Mid, _Last);
    _STD reverse(_First, _Last);
    }

template<class _RanIt , class _Diff , class _Ty >

void _Rotate ( _RanIt  _First, _RanIt  _Mid, _RanIt  _Last, _Diff *  , _Ty *    )

inline

    {   // rotate [_First, _Last), random-access iterators
    _Diff _Shift = _Mid - _First;
    _Diff _Count = _Last - _First;

    for (_Diff _Factor = _Shift; _Factor != 0; )
        {   // find subcycle count as GCD of shift count and length
        _Diff _Tmp = _Count % _Factor;
        _Count = _Factor;
        _Factor = _Tmp;
        }

    if (_Count < _Last - _First)
        for (; 0 < _Count; --_Count)
            {   // rotate each subcycle
            _RanIt _Hole = _First + _Count;
            _RanIt _Next = _Hole;
            _RanIt _Next1 = _Next + _Shift == _Last ? _First : _Next + _Shift;
            for (; ; )
                {   // percolate elements back around subcycle
                iter_swap(_Next, _Next1);
                _Next = _Next1;
                _Next1 = _Shift < _Last - _Next1 ? _Next1 + _Shift
                    : _First + (_Shift - (_Last - _Next1));
                if (_Next1 == _Hole)
                    break;
                }
            }
    }

template<class _RanIt >

void _Rotate ( _RanIt  _First, _RanIt  _Mid, _RanIt  _Last, random_access_iterator_tag    )

inline

    {   // rotate [_First, _Last), random-access iterators
    _Rotate(_First, _Mid, _Last, _Dist_type(_First), _Val_type(_First));
    }

template<class _Iter >

_Iter _Unchecked ( _Iter  _Src )

inline

    {   // construct unchecked from checked, generic
    return (_Src);
    }

template<class _Ty , size_t _Size>

_Array_const_iterator<_Ty, _Size>::_Unchecked_type _Unchecked ( _Array_const_iterator< _Ty, _Size >  _Iter )

inline

    {   // convert to unchecked
    return (_Iter._Unchecked());
    }

template<class _Ty , size_t _Size>

_Array_iterator<_Ty, _Size>::_Unchecked_type _Unchecked ( _Array_iterator< _Ty, _Size >  _Iter )

inline

    {   // convert to unchecked
    return (_Iter._Unchecked());
    }

template<class _Ty , class _Ignored >

bool _Within_limits ( const _Ty &  _Val, true_type  , true_type  , _Ignored    )

inline

    {   // signed _Elem, signed _Ty
    return (SCHAR_MIN <= _Val && _Val <= SCHAR_MAX);
    }

template<class _Ty >

bool _Within_limits ( const _Ty &  _Val, true_type  , false_type  , true_type    )

inline

    {   // signed _Elem, unsigned _Ty, -1 == static_cast<_Ty>(-1)
    return (_Val <= SCHAR_MAX || static_cast<_Ty>(SCHAR_MIN) <= _Val);
    }

template<class _Ty >

bool _Within_limits ( const _Ty &  _Val, true_type  , false_type  , false_type    )

inline

    {   // signed _Elem, unsigned _Ty, -1 != static_cast<_Ty>(-1)
    return (_Val <= SCHAR_MAX);
    }

template<class _Ty , class _Ignored >

bool _Within_limits ( const _Ty &  _Val, false_type  , true_type  , _Ignored    )

inline

    {   // unsigned _Elem, signed _Ty
    return (0 <= _Val && _Val <= UCHAR_MAX);
    }

template<class _Ty , class _Ignored >

bool _Within_limits ( const _Ty &  _Val, false_type  , false_type  , _Ignored    )

inline

    {   // unsigned _Elem, unsigned _Ty
    return (_Val <= UCHAR_MAX);
    }

template<class _InIt , class _Ty >

bool _Within_limits ( _InIt  , const _Ty &  _Val  )

inline

    {   // check whether _Val is within the limits of _Elem
    typedef typename remove_pointer<_InIt>::type _Elem;
    return (_Within_limits(_Val, is_signed<_Elem>(), is_signed<_Ty>(),
        integral_constant<bool, -1 == static_cast<_Ty>(-1)>()));
    }

template<class _InIt >

bool _Within_limits ( _InIt  , const bool &    )

inline

    {   // bools are always within the limits of _Elem
    return (true);
    }

template<class _InIt , class _Diff >

void advance ( _InIt &  _Where, _Diff  _Off  )

inline

    {   // increment iterator by offset, arbitrary iterators
    _Advance(_Where, _Off, _Iter_cat(_Where));
    }

template<class _Container >

auto begin ( _Container &  _Cont ) -> decltype(_Cont.begin())

inline

    {   // get beginning of sequence
    return (_Cont.begin());
    }

template<class _Container >

auto begin ( const _Container &  _Cont ) -> decltype(_Cont.begin())

inline

    {   // get beginning of sequence
    return (_Cont.begin());
    }

template<class _Ty , size_t _Size>

_Ty* begin ( _Ty(&)  _Array[_Size] )

inline

    {   // get beginning of array
    return (_Array);
    }

template<class _Container >

auto cbegin ( const _Container &  _Cont ) -> decltype(_STD begin(_Cont))

inline

    {   // get beginning of sequence
    return (_STD begin(_Cont));
    }

template<class _Container >

auto cend ( const _Container &  _Cont ) -> decltype(_STD end(_Cont))

inline

    {   // get end of sequence
    return (_STD end(_Cont));
    }

template<class _InIt , class _OutIt >

_OutIt copy ( _InIt  _First, _InIt  _Last, _OutIt  _Dest  )

inline

    {   // copy [_First, _Last) to [_Dest, ...)
    return (_Rechecked(_Dest,
        _Copy_impl(_Unchecked(_First), _Unchecked(_Last),
            _Unchecked(_Dest))));
    }

template<class _BidIt1 , class _BidIt2 >

_BidIt2 copy_backward ( _BidIt1  _First, _BidIt1  _Last, _BidIt2  _Dest  )

inline

    {   // copy [_First, _Last) backwards to [..., _Dest)
    return (_Rechecked(_Dest,
        _Copy_backward(_Unchecked(_First), _Unchecked(_Last),
            _Unchecked(_Dest))));
    }

template<class _InIt , class _Diff , class _OutIt >

_OutIt copy_n ( _InIt  _First, _Diff  _Count, _OutIt  _Dest  )

inline

    {   // copy [_First, _First + _Count) to [_Dest, ...)
    if (_Count <= 0)
        return (_Dest);
    else
        return (_Rechecked(_Dest,
            _Copy_n(_Unchecked(_First), _Count,
                _Unchecked(_Dest))));
    }

template<class _InIt , class _Ty >

iterator_traits<_InIt>::difference_type count ( _InIt  _First, _InIt  _Last, const _Ty &  _Val  )

inline

    {   // count elements that match _Val
    _DEBUG_RANGE(_First, _Last);
    return (_Count_np(_Unchecked(_First), _Unchecked(_Last), _Val));
    }

template<class _Container >

auto crbegin ( const _Container &  _Cont ) -> decltype(_STD rbegin(_Cont))

inline

    {   // get beginning of reversed sequence
    return (_STD rbegin(_Cont));
    }

template<class _Container >

auto crend ( const _Container &  _Cont ) -> decltype(_STD rend(_Cont))

inline

    {   // get end of reversed sequence
    return (_STD rend(_Cont));
    }

template<class _InIt >

iterator_traits<_InIt>::difference_type distance ( _InIt  _First, _InIt  _Last  )

inline

    {   // return distance between iterators
    typename iterator_traits<_InIt>::difference_type _Off = 0;
    _Distance2(_First, _Last, _Off, _Iter_cat(_First));
    return (_Off);
    }

template<class _Container >

auto end ( _Container &  _Cont ) -> decltype(_Cont.end())

inline

    {   // get end of sequence
    return (_Cont.end());
    }

template<class _Container >

auto end ( const _Container &  _Cont ) -> decltype(_Cont.end())

inline

    {   // get end of sequence
    return (_Cont.end());
    }

template<class _Ty , size_t _Size>

_Ty* end ( _Ty(&)  _Array[_Size] )

inline

    {   // get end of array
    return (_Array + _Size);
    }

template<class _InIt1 , class _InIt2 >

bool equal ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2  )

inline

    {   // compare [_First1, _Last1) to [_First2, ...)
    return (_Equal(_Unchecked(_First1), _Unchecked(_Last1),
        _Unchecked(_First2)));
    }

template<class _InIt1 , class _InIt2 , class _Pr >

bool equal ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _Pr  _Pred  )

inline

    {   // compare [_First1, _Last1) to [_First2, ...)
    return (_Equal(_Unchecked(_First1), _Unchecked(_Last1),
        _Unchecked(_First2), _Pred));
    }

template<class _FwdIt , class _Ty >

void fill ( _FwdIt  _First, _FwdIt  _Last, const _Ty &  _Val  )

inline

    {   // copy _Val through [_First, _Last)
    _DEBUG_RANGE(_First, _Last);
    _Fill(_Unchecked(_First), _Unchecked(_Last), _Val);
    }

template<class _OutIt , class _Diff , class _Ty >

_OutIt fill_n ( _OutIt  _Dest, _Diff  _Count, const _Ty &  _Val  )

inline

    {   // copy _Val _Count times through [_Dest, ...)
    return (_Rechecked(_Dest, _Fill_n(_Unchecked(_Dest), _Count, _Val)));
    }

template<class _InIt , class _Ty >

_InIt find ( _InIt  _First, _InIt  _Last, const _Ty &  _Val  )

inline

    {   // find first matching _Val
    _DEBUG_RANGE(_First, _Last);
    return (_Rechecked(_First,
        _Find(_Unchecked(_First), _Unchecked(_Last), _Val)));
    }

template<class _FwdIt1 , class _FwdIt2 , class _Pr >

bool is_permutation ( _FwdIt1  _First1, _FwdIt1  _Last1, _FwdIt2  _First2, _Pr  _Pred  )

inline

    {   // test if [_First1, _Last1) == permuted [_First2, ...), using _Pred
    _DEBUG_RANGE(_First1, _Last1);
    _DEBUG_POINTER(_Pred);
    return _Is_permutation(_Unchecked(_First1), _Unchecked(_Last1),
        _Unchecked(_First2), _Pred);
    }

template<class _FwdIt1 , class _FwdIt2 >

bool is_permutation ( _FwdIt1  _First1, _FwdIt1  _Last1, _FwdIt2  _First2  )

inline

    {   // test if [_First1, _Last1) == permuted [_First2, ...)
    return (_STD is_permutation(_First1, _Last1,
        _First2, equal_to<>()));
    }

template<class _InIt1 , class _InIt2 >

bool lexicographical_compare ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _InIt2  _Last2  )

inline

    {   // order [_First1, _Last1) vs. [_First2, _Last2)
    _DEBUG_RANGE(_First1, _Last1);
    _DEBUG_RANGE(_First2, _Last2);
    return (_Lexicographical_compare(_Unchecked(_First1), _Unchecked(_Last1),
        _Unchecked(_First2), _Unchecked(_Last2)));
    }

template<class _InIt1 , class _InIt2 , class _Pr >

bool lexicographical_compare ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _InIt2  _Last2, _Pr  _Pred  )

inline

    {   // order [_First1, _Last1) vs. [_First2, _Last2) using _Pred
    _DEBUG_RANGE(_First1, _Last1);
    _DEBUG_RANGE(_First2, _Last2);
    _DEBUG_POINTER(_Pred);
    return (_Lexicographical_compare(_Unchecked(_First1), _Unchecked(_Last1),
        _Unchecked(_First2), _Unchecked(_Last2), _Pred));
    }

template<class _RanIt >

move_iterator<_RanIt> make_move_iterator ( _RanIt  _Iter )

inline

    {   // make move_iterator from iterator
    return (move_iterator<_RanIt>(_Iter));
    }

template<class _InIt , class _OutIt >

_OutIt move ( _InIt  _First, _InIt  _Last, _OutIt  _Dest  )

inline

    {   // move [_First, _Last) to [_Dest, ...)
    return (_Rechecked(_Dest,
        _Move(_Unchecked(_First), _Unchecked(_Last),
            _Unchecked(_Dest))));
    }

template<class _BidIt1 , class _BidIt2 >

_BidIt2 move_backward ( _BidIt1  _First, _BidIt1  _Last, _BidIt2  _Dest  )

inline

    {   // move [_First, _Last) backwards to [..., _Dest)
    return (_Rechecked(_Dest,
        _Move_backward(_Unchecked(_First), _Unchecked(_Last),
            _Unchecked(_Dest))));
    }

template<class _FwdIt >

_FwdIt next ( _FwdIt  _First, typename iterator_traits< _FwdIt >::difference_type  _Off = 1  )

inline

    {   // increment iterator
    static_assert((is_base_of<forward_iterator_tag,
        typename iterator_traits<_FwdIt>::iterator_category>::value),
        "next requires forward iterator");

    _STD advance(_First, _Off);
    return (_First);
    }

template<class _RanIt1 , class _Base1 , class _RanIt2 , class _Base2 >

bool operator!= ( const _Revranit< _RanIt1, _Base1 > &  _Left, const _Revranit< _RanIt2, _Base2 > &  _Right  )

inline

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

template<class _RanIt1 , class _RanIt2 >

bool operator!= ( const reverse_iterator< _RanIt1 > &  _Left, const reverse_iterator< _RanIt2 > &  _Right  )

inline

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

template<class _RanIt1 , class _RanIt2 >

bool operator!= ( const move_iterator< _RanIt1 > &  _Left, const move_iterator< _RanIt2 > &  _Right  )

inline

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

template<class _RanIt , class _Base , class _Diff >

_Revranit<_RanIt, _Base> operator+ ( _Diff  _Off, const _Revranit< _RanIt, _Base > &  _Right  )

inline

    {   // return reverse_iterator + integer
    return (_Right + _Off);
    }

template<class _RanIt , class _Diff >

reverse_iterator<_RanIt> operator+ ( _Diff  _Off, const reverse_iterator< _RanIt > &  _Right  )

inline

    {   // return reverse_iterator + integer
    return (_Right + _Off);
    }

template<class _Ty , size_t _Size>

_Array_const_iterator<_Ty, _Size> operator+ ( typename _Array_const_iterator< _Ty, _Size >::difference_type  _Off, _Array_const_iterator< _Ty, _Size >  _Next  )

inline

    {   // add offset to iterator
    return (_Next += _Off);
    }

template<class _Ty , size_t _Size>

_Array_iterator<_Ty, _Size> operator+ ( typename _Array_iterator< _Ty, _Size >::difference_type  _Off, _Array_iterator< _Ty, _Size >  _Next  )

inline

    {   // add offset to iterator
    return (_Next += _Off);
    }

template<class _RanIt , class _Diff >

move_iterator<_RanIt> operator+ ( _Diff  _Off, const move_iterator< _RanIt > &  _Right  )

inline

    {   // return move_iterator + integer
    return (_Right + _Off);
    }

template<class _RanIt1 , class _Base1 , class _RanIt2 , class _Base2 >

auto operator- ( const _Revranit< _RanIt1, _Base1 > &  _Left, const _Revranit< _RanIt2, _Base2 > &  _Right  ) -> decltype(_Right.base() - _Left.base())

inline

    {   // return difference of reverse_iterators
    return (_Right.base() - _Left.base());
    }

template<class _RanIt1 , class _RanIt2 >

auto operator- ( const reverse_iterator< _RanIt1 > &  _Left, const reverse_iterator< _RanIt2 > &  _Right  ) -> decltype(_Right.base() - _Left.base())

inline

    {   // return difference of reverse_iterators
    return (_Right.base() - _Left.base());
    }

template<class _RanIt1 , class _RanIt2 >

auto operator- ( move_iterator< _RanIt1 > &  _Left, const move_iterator< _RanIt2 > &  _Right  ) -> decltype(_Left.base() - _Right.base())

inline

    {   // test for move_iterator equality
    return (_Left.base() - _Right.base());
    }

template<class _RanIt1 , class _Base1 , class _RanIt2 , class _Base2 >

bool operator< ( const _Revranit< _RanIt1, _Base1 > &  _Left, const _Revranit< _RanIt2, _Base2 > &  _Right  )

inline

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

template<class _RanIt1 , class _RanIt2 >

bool operator< ( const reverse_iterator< _RanIt1 > &  _Left, const reverse_iterator< _RanIt2 > &  _Right  )

inline

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

template<class _RanIt1 , class _RanIt2 >

bool operator< ( const move_iterator< _RanIt1 > &  _Left, const move_iterator< _RanIt2 > &  _Right  )

inline

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

template<class _RanIt1 , class _Base1 , class _RanIt2 , class _Base2 >

bool operator<= ( const _Revranit< _RanIt1, _Base1 > &  _Left, const _Revranit< _RanIt2, _Base2 > &  _Right  )

inline

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

template<class _RanIt1 , class _RanIt2 >

bool operator<= ( const reverse_iterator< _RanIt1 > &  _Left, const reverse_iterator< _RanIt2 > &  _Right  )

inline

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

template<class _RanIt1 , class _RanIt2 >

bool operator<= ( const move_iterator< _RanIt1 > &  _Left, const move_iterator< _RanIt2 > &  _Right  )

inline

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

template<class _RanIt1 , class _Base1 , class _RanIt2 , class _Base2 >

bool operator== ( const _Revranit< _RanIt1, _Base1 > &  _Left, const _Revranit< _RanIt2, _Base2 > &  _Right  )

inline

    {   // test for reverse_iterator equality
    return (_Left._Equal(_Right));
    }

template<class _RanIt1 , class _RanIt2 >

bool operator== ( const reverse_iterator< _RanIt1 > &  _Left, const reverse_iterator< _RanIt2 > &  _Right  )

inline

    {   // test for reverse_iterator equality
    return (_Left._Equal(_Right));
    }

template<class _RanIt1 , class _RanIt2 >

bool operator== ( const move_iterator< _RanIt1 > &  _Left, const move_iterator< _RanIt2 > &  _Right  )

inline

    {   // test for move_iterator equality
    return (_Left._Equal(_Right));
    }

template<class _RanIt1 , class _Base1 , class _RanIt2 , class _Base2 >

bool operator> ( const _Revranit< _RanIt1, _Base1 > &  _Left, const _Revranit< _RanIt2, _Base2 > &  _Right  )

inline

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

template<class _RanIt1 , class _RanIt2 >

bool operator> ( const reverse_iterator< _RanIt1 > &  _Left, const reverse_iterator< _RanIt2 > &  _Right  )

inline

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

template<class _RanIt1 , class _RanIt2 >

bool operator> ( const move_iterator< _RanIt1 > &  _Left, const move_iterator< _RanIt2 > &  _Right  )

inline

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

template<class _RanIt1 , class _Base1 , class _RanIt2 , class _Base2 >

bool operator>= ( const _Revranit< _RanIt1, _Base1 > &  _Left, const _Revranit< _RanIt2, _Base2 > &  _Right  )

inline

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

template<class _RanIt1 , class _RanIt2 >

bool operator>= ( const reverse_iterator< _RanIt1 > &  _Left, const reverse_iterator< _RanIt2 > &  _Right  )

inline

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

template<class _RanIt1 , class _RanIt2 >

bool operator>= ( const move_iterator< _RanIt1 > &  _Left, const move_iterator< _RanIt2 > &  _Right  )

inline

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

template<class _BidIt >

_BidIt prev ( _BidIt  _First, typename iterator_traits< _BidIt >::difference_type  _Off = 1  )

inline

    {   // decrement iterator
    static_assert((is_base_of<bidirectional_iterator_tag,
        typename iterator_traits<_BidIt>::iterator_category>::value),
        "prev requires bidirectional iterator");

    _STD advance(_First, -_Off);
    return (_First);
    }

template<class _Container >

auto rbegin ( _Container &  _Cont ) -> decltype(_Cont.rbegin())

inline

    {   // get beginning of reversed sequence
    return (_Cont.rbegin());
    }

template<class _Container >

auto rbegin ( const _Container &  _Cont ) -> decltype(_Cont.rbegin())

inline

    {   // get beginning of reversed sequence
    return (_Cont.rbegin());
    }

template<class _Ty , size_t _Size>

reverse_iterator<_Ty *> rbegin ( _Ty(&)  _Array[_Size] )

inline

    {   // get beginning of reversed array
    return (reverse_iterator<_Ty *>(_Array + _Size));
    }

template<class _Elem >

reverse_iterator<const _Elem *> rbegin ( initializer_list< _Elem >  _Ilist )

inline

    {   // get beginning of reversed sequence
    return (reverse_iterator<const _Elem *>(_Ilist.end()));
    }

template<class _Container >

auto rend ( _Container &  _Cont ) -> decltype(_Cont.rend())

inline

    {   // get end of reversed sequence
    return (_Cont.rend());
    }

template<class _Container >

auto rend ( const _Container &  _Cont ) -> decltype(_Cont.rend())

inline

    {   // get end of reversed sequence
    return (_Cont.rend());
    }

template<class _Ty , size_t _Size>

reverse_iterator<_Ty *> rend ( _Ty(&)  _Array[_Size] )

inline

    {   // get end of reversed array
    return (reverse_iterator<_Ty *>(_Array));
    }

template<class _Elem >

reverse_iterator<const _Elem *> rend ( initializer_list< _Elem >  _Ilist )

inline

    {   // get end of reversed sequence
    return (reverse_iterator<const _Elem *>(_Ilist.begin()));
    }

template<class _BidIt >

void reverse ( _BidIt  _First, _BidIt  _Last  )

inline

    {   // reverse elements in [_First, _Last)
    _DEBUG_RANGE(_First, _Last);
    _Reverse(_Unchecked(_First), _Unchecked(_Last), _Iter_cat(_First));
    }

template<class _FwdIt >

_FwdIt rotate ( _FwdIt  _First, _FwdIt  _Mid, _FwdIt  _Last  )

inline

    {   // rotate [_First, _Last)
    _DEBUG_RANGE(_First, _Mid);
    _DEBUG_RANGE(_Mid, _Last);
    if (_First != _Mid && _Mid != _Last)
        _Rotate(_Unchecked(_First), _Unchecked(_Mid), _Unchecked(_Last),
            _Iter_cat(_First));
    _STD advance(_First, _STD distance(_Mid, _Last));
    return (_First);
    }

Variable Documentation

template<class _Iter >

iterator_traits<_Iter>::difference_type* _Dist_type(_Iter)

inline

    {   // return distance type from arbitrary argument
    return (0);
    }

template<class _Iter >

iterator_traits<_Iter>::value_type* _Val_type(_Iter)

inline

    {   // return value type from arbitrary argument
    return (0);
    }

const allocator_arg_t allocator_arg = allocator_arg_t()