STLdoc
STLdocumentation
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
Classes | Macros | Typedefs | Functions | Variables
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  _Zero_then_variadic_args_t
 
struct  _One_then_variadic_args_t
 
class  _Compressed_pair< _Ty1, _Ty2, bool >
 
class  _Compressed_pair< _Ty1, _Ty2, false >
 
struct  _Is_checked_helper< _Ty, class >
 
struct  _Is_checked_helper< _Ty, void_t< typename _Ty::_Unchecked_type > >
 
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  _General_ptr_iterator_tag
 
struct  _Trivially_copyable_ptr_iterator_tag
 
struct  _Really_trivial_ptr_iterator_tag
 
struct  _Any_tag
 
struct  iterator< _Category, _Ty, _Diff, _Pointer, _Reference >
 
struct  _Iterator012< _Category, _Ty, _Diff, _Pointer, _Reference, _Base >
 
struct  _Iterator_traits_base< class, class >
 
struct  _Iterator_traits_base< _Iter, void_t< typename _Iter::iterator_category, typename _Iter::value_type, typename _Iter::difference_type, typename _Iter::pointer, typename _Iter::reference > >
 
struct  iterator_traits< _Iter >
 
struct  iterator_traits< _Ty * >
 
struct  iterator_traits< const _Ty * >
 
struct  _Is_iterator< _Ty, class >
 
struct  _Is_iterator< _Ty, void_t< typename iterator_traits< _Ty >::iterator_category > >
 
struct  _Is_same_size< _Ty1, _Ty2 >
 
struct  _Unwrap_enum< _Elem, _Is_enum >
 
struct  _Unwrap_enum< _Elem, false >
 
struct  _Both_or_neither_bool< _Ty1, _Ty2 >
 
struct  _Ptr_cat_helper< _Source, _Dest >
 
struct  _Ptr_cat_helper< _Elem, _Elem >
 
struct  _Ptr_cat_helper< _Anything *, const _Anything * >
 
struct  pointer_traits< _Ty >
 
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 > >
 
struct  _Char_traits_eq< _Traits >
 
struct  _Char_traits_lt< _Traits >
 
struct  _Is_character< _Ty >
 
struct  _Is_character< char >
 
struct  _Is_character< signed char >
 
struct  _Is_character< unsigned char >
 
struct  _Fill_memset_is_safe_helper< _FwdIt, _Ty >
 
struct  _Value_equality_is_bitwise_equality< _Elem1, _Elem2 >
 
struct  _Equal_memcmp_is_safe_helper< _Elem1, _Elem2, _Pr >
 
struct  _Equal_memcmp_is_safe_helper< _Elem1, _Elem2, equal_to<> >
 
struct  _Equal_memcmp_is_safe_helper< _Elem1 *, _Elem2 *, equal_to<> >
 
struct  _Equal_memcmp_is_safe_helper< _Elem, _Elem, _Char_traits_eq< char_traits< _Elem > > >
 
struct  _Equal_memcmp_is_safe_helper< _Elem, _Elem, equal_to< _Elem > >
 
struct  _Lex_compare_check_element_types_helper< _Elem1, _Elem2, _FTy >
 
struct  _Lex_compare_check_element_types_helper< _Elem1, _Elem2, void >
 
struct  _Lex_compare_optimize< _Memcmp_pr >
 
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)   decltype(_Unchecked(_STD declval<_Iter>()))
 
#define _DEFINE_DEPRECATE_UNCHECKED(_Func)
 
#define _USE_DEPRECATE_UNCHECKED(_Iter)   (_Unchecked_iterators::_Deprecate(_Is_checked(_Iter)))
 
#define _DEPRECATE_UNCHECKED(_Func, _Iter)
 
#define _CHECK_RANIT_RANGE(_First, _Last, _Target)
 
#define _CHECK_RANIT_RANGE_BACKWARD(_First, _Last, _Target)
 
#define _CHECK_RANIT_RANGE_N(_Iter, _Diff)
 
#define _DEBUG_LT(x, y)   ((x) < (y))
 
#define _DEBUG_LT_PRED(pred, x, y)   pred(x, y)
 
#define _DEBUG_ORDER_PRED(first, last, pred)
 
#define _DEBUG_POINTER(first)
 
#define _DEBUG_POINTER_IF(test, first)
 
#define _DEBUG_POINTER2(first, file, line)
 
#define _DEBUG_RANGE(first, last)
 
#define _DEBUG_RANGE2(first, last, file, line)
 
#define _DEBUG_RANGE_PTR(first, last, ptr)
 
#define _DEBUG_RANGE_PTR2(first, last, ptr, file, line)
 
#define _DEBUG_ARRAY_SIZE(_Array, _Desired)
 

Typedefs

typedef _Container_base0 _Container_base
 
typedef _Iterator_base0 _Iterator_base
 
typedef iterator< output_iterator_tag, void, void, void, void_Outit
 
template<class _Iter >
using _Iter_value_t = typename iterator_traits< _Iter >::value_type
 
template<class _Iter >
using _Iter_diff_t = typename iterator_traits< _Iter >::difference_type
 
template<class _Iter >
using _Iter_cat_t = typename iterator_traits< _Iter >::iterator_category
 
template<class _Memcmp_pr , class _Obj1 , class _Obj2 , class _FTy >
using _Lex_compare_check_element_types = _Lex_compare_optimize< conditional_t< _Lex_compare_check_element_types_helper< remove_const_t< _Obj1 >, remove_const_t< _Obj2 >, _FTy >::value, _Memcmp_pr, void >>
 

Functions

template<class _Iter >
_Iter _Unchecked (_Iter _Src)
 
template<class _Iter , class _UIter >
_Iter & _Rechecked (_Iter &_Dest, _UIter _Src)
 
template<class _Iter , class _Diff >
auto _Unchecked_n (_Iter _Src, _Diff)
 
template<class _Source , class _Dest >
_General_ptr_iterator_tag _Ptr_copy_cat (const _Source &, const _Dest &)
 
template<class _Source , class _Dest >
conditional_t< is_trivially_assignable< _Dest &, _Source & >::value, typename _Ptr_cat_helper< remove_const_t< _Source >, _Dest >::type, _General_ptr_iterator_tag_Ptr_copy_cat (_Source *const &, _Dest *const &)
 
template<class _Source , class _Dest >
_General_ptr_iterator_tag _Ptr_move_cat (const _Source &, const _Dest &)
 
template<class _Source , class _Dest >
conditional_t< is_trivially_assignable< _Dest &, _Source >::value, typename _Ptr_cat_helper< remove_const_t< _Source >, _Dest >::type, _General_ptr_iterator_tag_Ptr_move_cat (_Source *const &, _Dest *const &)
 
template<class _InIt , class _Diff >
void _Advance1 (_InIt &_Where, _Diff _Off, input_iterator_tag)
 
template<class _BidIt , class _Diff >
void _Advance1 (_BidIt &_Where, _Diff _Off, bidirectional_iterator_tag)
 
template<class _RanIt , class _Diff >
void _Advance1 (_RanIt &_Where, _Diff _Off, random_access_iterator_tag)
 
template<class _InIt , class _Diff >
void advance (_InIt &_Where, _Diff _Off)
 
template<class _InIt >
_Iter_diff_t< _InIt > _Distance1 (_InIt _First, _InIt _Last, input_iterator_tag)
 
template<class _RanIt >
_Iter_diff_t< _RanIt > _Distance1 (_RanIt _First, _RanIt _Last, random_access_iterator_tag)
 
template<class _InIt >
_Iter_diff_t< _InIt > distance (_InIt _First, _InIt _Last)
 
template<class _InIt >
_InIt next (_InIt _First, _Iter_diff_t< _InIt > _Off=1)
 
template<class _BidIt >
_BidIt prev (_BidIt _First, _Iter_diff_t< _BidIt > _Off=1)
 
template<class _RanIt >
reverse_iterator< _RanIt > operator+ (typename reverse_iterator< _RanIt >::difference_type _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 _RanIt >
reverse_iterator< _RanIt > make_reverse_iterator (_RanIt _Iter)
 
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>
constexpr _Ty * begin (_Ty(&_Array)[_Size]) _NOEXCEPT
 
template<class _Ty , size_t _Size>
constexpr _Ty * end (_Ty(&_Array)[_Size]) _NOEXCEPT
 
template<class _Container >
constexpr auto cbegin (const _Container &_Cont) _NOEXCEPT_OP(_NOEXCEPT_OP(_STD begin(_Cont))) -> decltype(_STD begin(_Cont))
 
template<class _Container >
constexpr auto cend (const _Container &_Cont) _NOEXCEPT_OP(_NOEXCEPT_OP(_STD end(_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 (_XSTD initializer_list< _Elem > _Ilist)
 
template<class _Elem >
reverse_iterator< const _Elem * > rend (_XSTD 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 _Container >
constexpr auto size (const _Container &_Cont) -> decltype(_Cont.size())
 
template<class _Ty , size_t _Size>
constexpr size_t size (const _Ty(&)[_Size]) _NOEXCEPT
 
template<class _Container >
constexpr auto empty (const _Container &_Cont) -> decltype(_Cont.empty())
 
template<class _Ty , size_t _Size>
constexpr bool empty (const _Ty(&)[_Size]) _NOEXCEPT
 
template<class _Elem >
constexpr bool empty (_XSTD initializer_list< _Elem > _Ilist) _NOEXCEPT
 
template<class _Container >
constexpr auto data (_Container &_Cont) -> decltype(_Cont.data())
 
template<class _Container >
constexpr auto data (const _Container &_Cont) -> decltype(_Cont.data())
 
template<class _Ty , size_t _Size>
constexpr _Ty * data (_Ty(&_Array)[_Size]) _NOEXCEPT
 
template<class _Elem >
constexpr const _Elem * data (_XSTD initializer_list< _Elem > _Ilist) _NOEXCEPT
 
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, _Sizeoperator+ (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, _Sizeoperator+ (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_memmove (_InIt _First, _InIt _Last, _OutIt _Dest)
 
template<class _InIt , class _OutIt >
_OutIt _Copy_unchecked1 (_InIt _First, _InIt _Last, _OutIt _Dest, _General_ptr_iterator_tag)
 
template<class _InIt , class _OutIt >
_OutIt _Copy_unchecked1 (_InIt _First, _InIt _Last, _OutIt _Dest, _Trivially_copyable_ptr_iterator_tag)
 
template<class _InIt , class _OutIt >
_OutIt _Copy_unchecked (_InIt _First, _InIt _Last, _OutIt _Dest)
 
template<class _InIt , class _OutIt >
_OutIt _Copy_no_deprecate1 (_InIt _First, _InIt _Last, _OutIt _Dest, input_iterator_tag, _Any_tag)
 
template<class _InIt , class _OutIt >
_OutIt _Copy_no_deprecate1 (_InIt _First, _InIt _Last, _OutIt _Dest, random_access_iterator_tag, random_access_iterator_tag)
 
template<class _InIt , class _OutIt >
_OutIt _Copy_no_deprecate (_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_unchecked2 (_InIt _First, _Diff _Count, _OutIt _Dest, input_iterator_tag)
 
template<class _InIt , class _Diff , class _OutIt >
_OutIt _Copy_n_unchecked2 (_InIt _First, _Diff _Count, _OutIt _Dest, forward_iterator_tag)
 
template<class _InIt , class _Diff , class _OutIt >
_OutIt _Copy_n_unchecked1 (_InIt _First, _Diff _Count, _OutIt _Dest, _General_ptr_iterator_tag)
 
template<class _InIt , class _Diff , class _OutIt >
_OutIt _Copy_n_unchecked1 (_InIt _First, _Diff _Count, _OutIt _Dest, _Trivially_copyable_ptr_iterator_tag)
 
template<class _InIt , class _Diff , class _OutIt >
_OutIt _Copy_n_unchecked (_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_memmove (_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest)
 
template<class _BidIt1 , class _BidIt2 >
_BidIt2 _Copy_backward_unchecked1 (_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest, _General_ptr_iterator_tag)
 
template<class _BidIt1 , class _BidIt2 >
_BidIt2 _Copy_backward_unchecked1 (_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest, _Trivially_copyable_ptr_iterator_tag)
 
template<class _BidIt1 , class _BidIt2 >
_BidIt2 _Copy_backward_unchecked (_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest)
 
template<class _BidIt1 , class _BidIt2 >
_BidIt2 _Copy_backward1 (_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest, input_iterator_tag, _Any_tag)
 
template<class _BidIt1 , class _BidIt2 >
_BidIt2 _Copy_backward1 (_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest, random_access_iterator_tag, random_access_iterator_tag)
 
template<class _BidIt1 , class _BidIt2 >
_BidIt2 copy_backward (_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest)
 
template<class _InIt , class _OutIt >
_OutIt _Move_unchecked1 (_InIt _First, _InIt _Last, _OutIt _Dest, _General_ptr_iterator_tag)
 
template<class _InIt , class _OutIt >
_OutIt _Move_unchecked1 (_InIt _First, _InIt _Last, _OutIt _Dest, _Trivially_copyable_ptr_iterator_tag)
 
template<class _InIt , class _OutIt >
_OutIt _Move_unchecked (_InIt _First, _InIt _Last, _OutIt _Dest)
 
template<class _InIt , class _OutIt >
_OutIt _Move_no_deprecate1 (_InIt _First, _InIt _Last, _OutIt _Dest, input_iterator_tag, _Any_tag)
 
template<class _InIt , class _OutIt >
_OutIt _Move_no_deprecate1 (_InIt _First, _InIt _Last, _OutIt _Dest, random_access_iterator_tag, random_access_iterator_tag)
 
template<class _InIt , class _OutIt >
_OutIt _Move_no_deprecate (_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_unchecked1 (_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest, _General_ptr_iterator_tag)
 
template<class _BidIt1 , class _BidIt2 >
_BidIt2 _Move_backward_unchecked1 (_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest, _Trivially_copyable_ptr_iterator_tag)
 
template<class _BidIt1 , class _BidIt2 >
_BidIt2 _Move_backward_unchecked (_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest)
 
template<class _BidIt1 , class _BidIt2 >
_BidIt2 _Move_backward1 (_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest, input_iterator_tag, _Any_tag)
 
template<class _BidIt1 , class _BidIt2 >
_BidIt2 _Move_backward1 (_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest, random_access_iterator_tag, random_access_iterator_tag)
 
template<class _BidIt1 , class _BidIt2 >
_BidIt2 move_backward (_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest)
 
template<class _FwdIt , class _Ty >
_Fill_memset_is_safe_helper< _FwdIt, _Ty >::type _Fill_memset_is_safe (const _FwdIt &, const _Ty &)
 
template<class _FwdIt , class _Ty >
void _Fill_unchecked1 (_FwdIt _First, _FwdIt _Last, const _Ty &_Val, false_type)
 
template<class _FwdIt , class _Ty >
void _Fill_unchecked1 (_FwdIt _First, _FwdIt _Last, const _Ty &_Val, true_type)
 
template<class _FwdIt , class _Ty >
void _Fill_unchecked (_FwdIt _First, _FwdIt _Last, const _Ty &_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_unchecked1 (_OutIt _Dest, _Diff _Count, const _Ty &_Val, false_type)
 
template<class _OutIt , class _Diff , class _Ty >
_OutIt _Fill_n_unchecked1 (_OutIt _Dest, _Diff _Count, const _Ty &_Val, true_type)
 
template<class _OutIt , class _Diff , class _Ty >
_OutIt _Fill_n_unchecked (_OutIt _Dest, _Diff _Count, const _Ty &_Val)
 
template<class _OutIt , class _Diff , class _Ty >
_OutIt fill_n (_OutIt _Dest, _Diff _Count, const _Ty &_Val)
 
template<class _Iter1 , class _Iter2 , class _Pr >
false_type _Equal_memcmp_is_safe (const _Iter1 &, const _Iter2 &, const _Pr &)
 
template<class _Obj1 , class _Obj2 , class _Pr >
_Equal_memcmp_is_safe_helper< remove_const_t< _Obj1 >, remove_const_t< _Obj2 >, _Pr >::type _Equal_memcmp_is_safe (_Obj1 *const &, _Obj2 *const &, const _Pr &)
 
template<class _InIt1 , class _InIt2 , class _Pr >
bool _Equal_unchecked1 (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Pr &_Pred, false_type)
 
template<class _InIt1 , class _InIt2 , class _Pr >
bool _Equal_unchecked1 (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Pr &, true_type)
 
template<class _InIt1 , class _InIt2 , class _Pr >
bool _Equal_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Pr &_Pred)
 
template<class _InIt1 , class _InIt2 , class _Pr >
bool _Equal_no_deprecate1 (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Pr &_Pred, input_iterator_tag, input_iterator_tag)
 
template<class _InIt1 , class _InIt2 , class _Pr >
bool _Equal_no_deprecate1 (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Pr &_Pred, random_access_iterator_tag, random_access_iterator_tag)
 
template<class _InIt1 , class _InIt2 , class _Pr >
bool _Equal_no_deprecate (_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 equal (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2)
 
template<class _InIt1 , class _InIt2 , class _Pr >
bool _Equal_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _Pr &_Pred, input_iterator_tag, input_iterator_tag)
 
template<class _InIt1 , class _InIt2 , class _Pr >
bool _Equal_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _Pr &_Pred, random_access_iterator_tag, random_access_iterator_tag)
 
template<class _InIt1 , class _InIt2 , class _Pr >
bool equal (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _Pr _Pred)
 
template<class _InIt1 , class _InIt2 >
bool equal (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2)
 
template<class _InIt1 , class _InIt2 , class _Pr >
_Lex_compare_optimize< void_Lex_compare_memcmp_classify (const _InIt1 &, const _InIt2 &, const _Pr &)
 
template<class _Obj1 , class _Obj2 , class _FTy >
_Lex_compare_check_element_types< less< int >, _Obj1, _Obj2, _FTy > _Lex_compare_memcmp_classify (_Obj1 *const &, _Obj2 *const &, const less< _FTy > &)
 
template<class _InIt1 , class _InIt2 , class _Pr >
bool _Lex_compare_unchecked1 (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _Pr &_Pred, _Lex_compare_optimize< void >)
 
template<class _InIt1 , class _InIt2 , class _Pr , class _Memcmp_pr >
bool _Lex_compare_unchecked1 (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _Pr &, _Lex_compare_optimize< _Memcmp_pr >)
 
template<class _InIt1 , class _InIt2 , class _Pr >
bool _Lex_compare_unchecked (_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 _InIt1 , class _InIt2 >
bool lexicographical_compare (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2)
 
template<class _Ty >
bool _Within_limits (const _Ty &_Val, true_type, true_type, _Any_tag)
 
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 >
bool _Within_limits (const _Ty &_Val, false_type, true_type, _Any_tag)
 
template<class _Ty >
bool _Within_limits (const _Ty &_Val, false_type, false_type, _Any_tag)
 
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_unchecked1 (_InIt _First, _InIt _Last, const _Ty &_Val, true_type)
 
template<class _InIt , class _Ty >
_InIt _Find_unchecked1 (_InIt _First, _InIt _Last, const _Ty &_Val, false_type)
 
template<class _InIt , class _Ty >
_InIt _Find_unchecked (_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 >
_Iter_diff_t< _InIt > _Count_unchecked (_InIt _First, _InIt _Last, const _Ty &_Val)
 
template<class _InIt , class _Ty >
_Iter_diff_t< _InIt > count (_InIt _First, _InIt _Last, const _Ty &_Val)
 
template<class _InIt , class _Ty , class _Pr >
_Iter_diff_t< _InIt > _Count_pr (_InIt _First, _InIt _Last, const _Ty &_Val, _Pr &_Pred)
 
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
void _Trim_matching_suffixes (_FwdIt1 &, _FwdIt2 &, _Pr &, forward_iterator_tag, forward_iterator_tag)
 
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
void _Trim_matching_suffixes (_FwdIt1 &_Last1, _FwdIt2 &_Last2, _Pr &_Pred, bidirectional_iterator_tag, bidirectional_iterator_tag)
 
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
bool _Check_match_counts (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr &_Pred)
 
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
bool _Is_permutation_unchecked (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _Pr &_Pred)
 
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
bool _Is_permutation_no_deprecate1 (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _Pr &_Pred, forward_iterator_tag, forward_iterator_tag)
 
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
bool _Is_permutation_no_deprecate1 (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _Pr &_Pred, random_access_iterator_tag, random_access_iterator_tag)
 
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
bool _Is_permutation_no_deprecate (_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 _FwdIt1 , class _FwdIt2 , class _Pr >
bool _Is_permutation_unchecked (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr &_Pred, forward_iterator_tag, forward_iterator_tag)
 
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
bool _Is_permutation_unchecked (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr &_Pred, random_access_iterator_tag, random_access_iterator_tag)
 
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
bool is_permutation (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred)
 
template<class _FwdIt1 , class _FwdIt2 >
bool is_permutation (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2)
 
template<class _BidIt >
void _Reverse_unchecked (_BidIt _First, _BidIt _Last)
 
template<class _BidIt >
void reverse (_BidIt _First, _BidIt _Last)
 
template<class _FwdIt >
_FwdIt _Rotate_unchecked1 (_FwdIt _First, _FwdIt _Mid, _FwdIt _Last, forward_iterator_tag)
 
template<class _BidIt >
pair< _BidIt, _BidIt > _Reverse_until_sentinel_unchecked (_BidIt _First, _BidIt _Sentinel, _BidIt _Last)
 
template<class _BidIt >
_BidIt _Rotate_unchecked1 (_BidIt _First, _BidIt _Mid, _BidIt _Last, bidirectional_iterator_tag)
 
template<class _RanIt >
_RanIt _Rotate_unchecked1 (_RanIt _First, _RanIt _Mid, _RanIt _Last, random_access_iterator_tag)
 
template<class _FwdIt >
_FwdIt _Rotate_unchecked (_FwdIt _First, _FwdIt _Mid, _FwdIt _Last)
 
template<class _FwdIt >
_FwdIt rotate (_FwdIt _First, _FwdIt _Mid, _FwdIt _Last)
 
_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xbad_alloc ()
 
_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xinvalid_argument (_In_z_ const char *)
 
_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xlength_error (_In_z_ const char *)
 
_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xout_of_range (_In_z_ const char *)
 
_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xoverflow_error (_In_z_ const char *)
 
_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xruntime_error (_In_z_ const char *)
 

Variables

template<class _Iter >
_Is_checked_helper< _Iter >::type _Is_checked (_Iter)
 
constexpr allocator_arg_t allocator_arg {}
 

Macro Definition Documentation

#define _CHECK_RANIT_RANGE (   _First,
  _Last,
  _Target 
)
#define _CHECK_RANIT_RANGE_BACKWARD (   _First,
  _Last,
  _Target 
)
#define _CHECK_RANIT_RANGE_N (   _Iter,
  _Diff 
)
#define _DEBUG_ARRAY_SIZE (   _Array,
  _Desired 
)
#define _DEBUG_ERROR (   mesg)
#define _DEBUG_LT (   x,
 
)    ((x) < (y))
#define _DEBUG_LT_PRED (   pred,
  x,
 
)    pred(x, y)
#define _DEBUG_ORDER_PRED (   first,
  last,
  pred 
)
#define _DEBUG_POINTER (   first)
#define _DEBUG_POINTER2 (   first,
  file,
  line 
)
#define _DEBUG_POINTER_IF (   test,
  first 
)
#define _DEBUG_RANGE (   first,
  last 
)
#define _DEBUG_RANGE2 (   first,
  last,
  file,
  line 
)
#define _DEBUG_RANGE_PTR (   first,
  last,
  ptr 
)
#define _DEBUG_RANGE_PTR2 (   first,
  last,
  ptr,
  file,
  line 
)
#define _DEFINE_DEPRECATE_UNCHECKED (   _Func)
Value:
struct _Unchecked_iterators \
{ /* Warns about unchecked iterators */ \
static void _SCL_INSECURE_DEPRECATE_FN(_Func) _Deprecate(false_type) \
{ /* Detected unchecked iterator, warn */ \
} \
\
static void _Deprecate(true_type) \
{ /* Detected checked iterator, do not warn */ \
} \
}
Definition: xtr1common:22
#define _SCL_INSECURE_DEPRECATE_FN(_Func)
Definition: yvals.h:311
#define _DEPRECATE_UNCHECKED (   _Func,
  _Iter 
)
Value:
#define _USE_DEPRECATE_UNCHECKED(_Iter)
Definition: xutility:475
#define _DEFINE_DEPRECATE_UNCHECKED(_Func)
Definition: xutility:463
_UNCHECKED_TYPE (   _Iter)    decltype(_Unchecked(_STD declval<_Iter>()))
inline
#define _USE_DEPRECATE_UNCHECKED (   _Iter)    (_Unchecked_iterators::_Deprecate(_Is_checked(_Iter)))
#define _XUTILITY_

Typedef Documentation

template<class _Iter >
using _Iter_cat_t = typename iterator_traits<_Iter>::iterator_category
template<class _Iter >
using _Iter_diff_t = typename iterator_traits<_Iter>::difference_type
template<class _Iter >
using _Iter_value_t = typename iterator_traits<_Iter>::value_type
template<class _Memcmp_pr , class _Obj1 , class _Obj2 , class _FTy >
using _Lex_compare_check_element_types = _Lex_compare_optimize<conditional_t< _Lex_compare_check_element_types_helper<remove_const_t<_Obj1>, remove_const_t<_Obj2>, _FTy>::value, _Memcmp_pr, void>>

Function Documentation

template<class _InIt , class _Diff >
void _Advance1 ( _InIt &  _Where,
_Diff  _Off,
input_iterator_tag   
)
inline
1060  { // increment iterator by offset, input iterators
1061  #if _ITERATOR_DEBUG_LEVEL == 2
1062  if (_Off < 0)
1063  _DEBUG_ERROR("negative offset in advance");
1064  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
1065 
1066  for (; 0 < _Off; --_Off)
1067  ++_Where;
1068  }
#define _DEBUG_ERROR(mesg)
Definition: xutility:32
template<class _BidIt , class _Diff >
void _Advance1 ( _BidIt &  _Where,
_Diff  _Off,
bidirectional_iterator_tag   
)
inline
1073  { // increment iterator by offset, bidirectional iterators
1074  for (; 0 < _Off; --_Off)
1075  ++_Where;
1076  for (; _Off < 0; ++_Off)
1077  --_Where;
1078  }
template<class _RanIt , class _Diff >
void _Advance1 ( _RanIt &  _Where,
_Diff  _Off,
random_access_iterator_tag   
)
inline
1083  { // increment iterator by offset, random-access iterators
1084  _Where += _Off;
1085  }
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
bool _Check_match_counts ( _FwdIt1  _First1,
_FwdIt1  _Last1,
_FwdIt2  _First2,
_FwdIt2  _Last2,
_Pr &  _Pred 
)
inline
3367  { // test if [_First1, _Last1) == permuted [_First2, _Last2), using _Pred, same lengths
3368  _Trim_matching_suffixes(_Last1, _Last2, _Pred,
3370  for (_FwdIt1 _Next1 = _First1; _Next1 != _Last1; ++_Next1)
3371  if (_Next1 == _Find_pr(_First1, _Next1, *_Next1, _Pred))
3372  { // new value, compare match counts
3373  _Iter_diff_t<_FwdIt2> _Count2 = _Count_pr(_First2, _Last2, *_Next1, _Pred);
3374  if (_Count2 == 0)
3375  return (false); // second range lacks value, fail
3376  _FwdIt1 _Skip1 = _STD next(_Next1);
3377  _Iter_diff_t<_FwdIt1> _Count1 = _Count_pr(_Skip1, _Last1, *_Next1, _Pred) + 1;
3378  if (_Count2 != _Count1)
3379  return (false); // match counts differ, fail
3380  }
3381 
3382  return (true);
3383  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
typename iterator_traits< _Iter >::difference_type _Iter_diff_t
Definition: xutility:651
typename iterator_traits< _Iter >::iterator_category _Iter_cat_t
Definition: xutility:655
_InIt _Find_pr(_InIt _First, _InIt _Last, const _Ty &_Val, _Pr &_Pred)
Definition: xutility:3293
void _Trim_matching_suffixes(_FwdIt1 &, _FwdIt2 &, _Pr &, forward_iterator_tag, forward_iterator_tag)
Definition: xutility:3343
_Iter_diff_t< _InIt > _Count_pr(_InIt _First, _InIt _Last, const _Ty &_Val, _Pr &_Pred)
Definition: xutility:3329
_InIt next(_InIt _First, _Iter_diff_t< _InIt > _Off=1)
Definition: xutility:1131
template<class _BidIt1 , class _BidIt2 >
_BidIt2 _Copy_backward1 ( _BidIt1  _First,
_BidIt1  _Last,
_BidIt2  _Dest,
input_iterator_tag  ,
_Any_tag   
)
inline
2548  { // copy [_First, _Last) backwards to [..., _Dest), arbitrary iterators
2549  return (_Rechecked(_Dest,
2550  _Copy_backward_unchecked(_First, _Last, _Unchecked_idl0(_Dest))));
2551  }
_Iter & _Rechecked(_Iter &_Dest, _UIter _Src)
Definition: xutility:456
_BidIt2 _Copy_backward_unchecked(_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest)
Definition: xutility:2537
_FwdIt _Last
Definition: algorithm:1936
template<class _BidIt1 , class _BidIt2 >
_BidIt2 _Copy_backward1 ( _BidIt1  _First,
_BidIt1  _Last,
_BidIt2  _Dest,
random_access_iterator_tag  ,
random_access_iterator_tag   
)
inline
2557  { // copy [_First, _Last) backwards to [..., _Dest), random-access iterators
2558  _CHECK_RANIT_RANGE_BACKWARD(_First, _Last, _Dest);
2559  return (_Rechecked(_Dest,
2560  _Copy_backward_unchecked(_First, _Last, _Unchecked(_Dest))));
2561  }
_Iter & _Rechecked(_Iter &_Dest, _UIter _Src)
Definition: xutility:456
_BidIt2 _Copy_backward_unchecked(_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest)
Definition: xutility:2537
#define _CHECK_RANIT_RANGE_BACKWARD(_First, _Last, _Target)
Definition: xutility:488
_Iter _Unchecked(_Iter _Src)
Definition: xutility:426
_FwdIt _Last
Definition: algorithm:1936
template<class _BidIt1 , class _BidIt2 >
_BidIt2 _Copy_backward_memmove ( _BidIt1  _First,
_BidIt1  _Last,
_BidIt2  _Dest 
)
inline
2508  { // implement copy_backward-like function as memmove
2509  const char * const _First_ch = reinterpret_cast<const char *>(_First);
2510  const char * const _Last_ch = reinterpret_cast<const char *>(_Last);
2511  char * const _Dest_ch = reinterpret_cast<char *>(_Dest);
2512  const size_t _Count = _Last_ch - _First_ch;
2513  return (static_cast<_BidIt2>(
2514  _CSTD memmove(_Dest_ch - _Count, _First_ch, _Count)));
2515  }
_VCRTIMP void *__cdecl memmove(_Out_writes_bytes_all_opt_(_Size) void *_Dst, _In_reads_bytes_opt_(_Size) void const *_Src, _In_ size_t _Size)
unsigned int _Count
Definition: xcomplex:668
#define _CSTD
Definition: yvals.h:570
_FwdIt _Last
Definition: algorithm:1936
template<class _BidIt1 , class _BidIt2 >
_BidIt2 _Copy_backward_unchecked ( _BidIt1  _First,
_BidIt1  _Last,
_BidIt2  _Dest 
)
inline
2539  { // copy [_First, _Last) backwards to [..., _Dest), choose optimization
2540  return (_Copy_backward_unchecked1(_First, _Last,
2541  _Dest, _Ptr_copy_cat(_First, _Dest)));
2542  }
_BidIt2 _Copy_backward_unchecked1(_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest, _General_ptr_iterator_tag)
Definition: xutility:2519
_General_ptr_iterator_tag _Ptr_copy_cat(const _Source &, const _Dest &)
Definition: xutility:781
_FwdIt _Last
Definition: algorithm:1936
template<class _BidIt1 , class _BidIt2 >
_BidIt2 _Copy_backward_unchecked1 ( _BidIt1  _First,
_BidIt1  _Last,
_BidIt2  _Dest,
_General_ptr_iterator_tag   
)
inline
2521  { // copy [_First, _Last) backwards to [..., _Dest), no special optimization
2522  while (_First != _Last)
2523  *--_Dest = *--_Last;
2524  return (_Dest);
2525  }
_FwdIt _Last
Definition: algorithm:1936
template<class _BidIt1 , class _BidIt2 >
_BidIt2 _Copy_backward_unchecked1 ( _BidIt1  _First,
_BidIt1  _Last,
_BidIt2  _Dest,
_Trivially_copyable_ptr_iterator_tag   
)
inline
2531  { // copy [_First, _Last) backwards to [..., _Dest), memmove optimization
2532  return (_Copy_backward_memmove(_First, _Last, _Dest));
2533  }
_BidIt2 _Copy_backward_memmove(_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest)
Definition: xutility:2506
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt , class _OutIt >
_OutIt _Copy_memmove ( _InIt  _First,
_InIt  _Last,
_OutIt  _Dest 
)
inline
2301  { // implement copy-like function as memmove
2302  const char * const _First_ch = reinterpret_cast<const char *>(_First);
2303  const char * const _Last_ch = reinterpret_cast<const char *>(_Last);
2304  char * const _Dest_ch = reinterpret_cast<char *>(_Dest);
2305  const size_t _Count = _Last_ch - _First_ch;
2306  _CSTD memmove(_Dest_ch, _First_ch, _Count);
2307  return (reinterpret_cast<_OutIt>(_Dest_ch + _Count));
2308  }
_VCRTIMP void *__cdecl memmove(_Out_writes_bytes_all_opt_(_Size) void *_Dst, _In_reads_bytes_opt_(_Size) void const *_Src, _In_ size_t _Size)
unsigned int _Count
Definition: xcomplex:668
#define _CSTD
Definition: yvals.h:570
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt , class _Diff , class _OutIt >
_OutIt _Copy_n_unchecked ( _InIt  _First,
_Diff  _Count,
_OutIt  _Dest 
)
inline
2446  { // copy [_First, _First + _Count) to [_Dest, ...), choose optimization
2447  return (_Copy_n_unchecked1(_First, _Count,
2448  _Dest, _Ptr_copy_cat(_First, _Dest)));
2449  }
unsigned int _Count
Definition: xcomplex:668
_General_ptr_iterator_tag _Ptr_copy_cat(const _Source &, const _Dest &)
Definition: xutility:781
_OutIt _Copy_n_unchecked1(_InIt _First, _Diff _Count, _OutIt _Dest, _General_ptr_iterator_tag)
Definition: xutility:2421
template<class _InIt , class _Diff , class _OutIt >
_OutIt _Copy_n_unchecked1 ( _InIt  _First,
_Diff  _Count,
_OutIt  _Dest,
_General_ptr_iterator_tag   
)
inline
2423  { // copy [_First, _First + _Count) to [_Dest, ...), no special optimization
2424  // note that we must dispatch on iterator power here to avoid incrementing
2425  // istream_iterator too many times; see LWG# 2471
2426  return (_Copy_n_unchecked2(_First, _Count,
2427  _Dest, _Iter_cat_t<_InIt>()));
2428  }
_OutIt _Copy_n_unchecked2(_InIt _First, _Diff _Count, _OutIt _Dest, input_iterator_tag)
Definition: xutility:2393
unsigned int _Count
Definition: xcomplex:668
typename iterator_traits< _Iter >::iterator_category _Iter_cat_t
Definition: xutility:655
template<class _InIt , class _Diff , class _OutIt >
_OutIt _Copy_n_unchecked1 ( _InIt  _First,
_Diff  _Count,
_OutIt  _Dest,
_Trivially_copyable_ptr_iterator_tag   
)
inline
2435  { // copy [_First, _First + _Count) to [_Dest, ...), memmove optimization
2436  if (0 < _Count)
2437  return (_Copy_memmove(_First, _First + _Count, _Dest));
2438  return (_Dest);
2439  }
unsigned int _Count
Definition: xcomplex:668
_OutIt _Copy_memmove(_InIt _First, _InIt _Last, _OutIt _Dest)
Definition: xutility:2299
template<class _InIt , class _Diff , class _OutIt >
_OutIt _Copy_n_unchecked2 ( _InIt  _First,
_Diff  _Count,
_OutIt  _Dest,
input_iterator_tag   
)
inline
2395  { // copy [_First, _First + _Count) to [_Dest, ...), input iterators
2396  if (0 < _Count)
2397  {
2398  *_Dest = *_First;
2399  while (0 < --_Count)
2400  *++_Dest = *++_First;
2401  return (++_Dest);
2402  }
2403 
2404  return (_Dest);
2405  }
unsigned int _Count
Definition: xcomplex:668
template<class _InIt , class _Diff , class _OutIt >
_OutIt _Copy_n_unchecked2 ( _InIt  _First,
_Diff  _Count,
_OutIt  _Dest,
forward_iterator_tag   
)
inline
2412  { // copy [_First, _First + _Count) to [_Dest, ...), forward iterators
2413  for (; 0 < _Count; --_Count, (void)++_Dest, ++_First)
2414  *_Dest = *_First;
2415  return (_Dest);
2416  }
unsigned int _Count
Definition: xcomplex:668
_CRT_BEGIN_C_HEADER typedef void(__CRTDECL *unexpected_handler)()
template<class _InIt , class _OutIt >
_OutIt _Copy_no_deprecate ( _InIt  _First,
_InIt  _Last,
_OutIt  _Dest 
)
inline
2361  { // copy [_First, _Last) to [_Dest, ...), no _SCL_INSECURE_DEPRECATE_FN warnings
2362  _DEBUG_RANGE_PTR(_First, _Last, _Dest);
2363  return (_Copy_no_deprecate1(_Unchecked(_First), _Unchecked(_Last),
2365  }
typename iterator_traits< _Iter >::iterator_category _Iter_cat_t
Definition: xutility:655
_OutIt _Copy_no_deprecate1(_InIt _First, _InIt _Last, _OutIt _Dest, input_iterator_tag, _Any_tag)
Definition: xutility:2340
_Iter _Unchecked(_Iter _Src)
Definition: xutility:426
#define _DEBUG_RANGE_PTR(first, last, ptr)
Definition: xutility:824
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt , class _OutIt >
_OutIt _Copy_no_deprecate1 ( _InIt  _First,
_InIt  _Last,
_OutIt  _Dest,
input_iterator_tag  ,
_Any_tag   
)
inline
2342  { // copy [_First, _Last) to [_Dest, ...), arbitrary iterators
2343  return (_Rechecked(_Dest,
2344  _Copy_unchecked(_First, _Last, _Unchecked_idl0(_Dest))));
2345  }
_Iter & _Rechecked(_Iter &_Dest, _UIter _Src)
Definition: xutility:456
_OutIt _Copy_unchecked(_InIt _First, _InIt _Last, _OutIt _Dest)
Definition: xutility:2330
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt , class _OutIt >
_OutIt _Copy_no_deprecate1 ( _InIt  _First,
_InIt  _Last,
_OutIt  _Dest,
random_access_iterator_tag  ,
random_access_iterator_tag   
)
inline
2351  { // copy [_First, _Last) to [_Dest, ...), random-access iterators
2352  _CHECK_RANIT_RANGE(_First, _Last, _Dest);
2353  return (_Rechecked(_Dest,
2354  _Copy_unchecked(_First, _Last, _Unchecked(_Dest))));
2355  }
_Iter & _Rechecked(_Iter &_Dest, _UIter _Src)
Definition: xutility:456
_Iter _Unchecked(_Iter _Src)
Definition: xutility:426
_OutIt _Copy_unchecked(_InIt _First, _InIt _Last, _OutIt _Dest)
Definition: xutility:2330
#define _CHECK_RANIT_RANGE(_First, _Last, _Target)
Definition: xutility:487
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt , class _OutIt >
_OutIt _Copy_unchecked ( _InIt  _First,
_InIt  _Last,
_OutIt  _Dest 
)
inline
2332  { // copy [_First, _Last) to [_Dest, ...)
2333  // note: _Copy_unchecked is called directly elsewhere in the STL
2334  return (_Copy_unchecked1(_First, _Last,
2335  _Dest, _Ptr_copy_cat(_First, _Dest)));
2336  }
_General_ptr_iterator_tag _Ptr_copy_cat(const _Source &, const _Dest &)
Definition: xutility:781
_FwdIt _Last
Definition: algorithm:1936
_OutIt _Copy_unchecked1(_InIt _First, _InIt _Last, _OutIt _Dest, _General_ptr_iterator_tag)
Definition: xutility:2312
template<class _InIt , class _OutIt >
_OutIt _Copy_unchecked1 ( _InIt  _First,
_InIt  _Last,
_OutIt  _Dest,
_General_ptr_iterator_tag   
)
inline
2314  { // copy [_First, _Last) to [_Dest, ...), arbitrary iterators
2315  for (; _First != _Last; ++_Dest, (void)++_First)
2316  *_Dest = *_First;
2317  return (_Dest);
2318  }
_CRT_BEGIN_C_HEADER typedef void(__CRTDECL *unexpected_handler)()
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt , class _OutIt >
_OutIt _Copy_unchecked1 ( _InIt  _First,
_InIt  _Last,
_OutIt  _Dest,
_Trivially_copyable_ptr_iterator_tag   
)
inline
2324  { // copy [_First, _Last) to [_Dest, ...), pointers to trivially copyable
2325  return (_Copy_memmove(_First, _Last, _Dest));
2326  }
_OutIt _Copy_memmove(_InIt _First, _InIt _Last, _OutIt _Dest)
Definition: xutility:2299
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt , class _Ty , class _Pr >
_Iter_diff_t<_InIt> _Count_pr ( _InIt  _First,
_InIt  _Last,
const _Ty &  _Val,
_Pr &  _Pred 
)
inline
3330  { // count elements that match _Val, using _Pred
3332 
3333  for (; _First != _Last; ++_First)
3334  if (_Pred(*_First, _Val))
3335  ++_Count;
3336  return (_Count);
3337  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
unsigned int _Count
Definition: xcomplex:668
typename iterator_traits< _Iter >::difference_type _Iter_diff_t
Definition: xutility:651
_In_ int _Val
Definition: vcruntime_string.h:62
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt , class _Ty >
_Iter_diff_t<_InIt> _Count_unchecked ( _InIt  _First,
_InIt  _Last,
const _Ty &  _Val 
)
inline
3306  { // count elements that match _Val
3308 
3309  for (; _First != _Last; ++_First)
3310  if (*_First == _Val)
3311  ++_Count;
3312  return (_Count);
3313  }
unsigned int _Count
Definition: xcomplex:668
typename iterator_traits< _Iter >::difference_type _Iter_diff_t
Definition: xutility:651
_In_ int _Val
Definition: vcruntime_string.h:62
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt >
_Iter_diff_t<_InIt> _Distance1 ( _InIt  _First,
_InIt  _Last,
input_iterator_tag   
)
inline
1099  { // return distance between iterators; input
1100  _Iter_diff_t<_InIt> _Off = 0;
1101  for (; _First != _Last; ++_First)
1102  ++_Off;
1103 
1104  return (_Off);
1105  }
typename iterator_traits< _Iter >::difference_type _Iter_diff_t
Definition: xutility:651
_FwdIt _Last
Definition: algorithm:1936
template<class _RanIt >
_Iter_diff_t<_RanIt> _Distance1 ( _RanIt  _First,
_RanIt  _Last,
random_access_iterator_tag   
)
inline
1110  { // return distance between iterators; random-access
1111  #if _ITERATOR_DEBUG_LEVEL == 2
1112  if (_First != _Last)
1113  { // check for null pointers
1114  _DEBUG_POINTER(_First);
1116  }
1117  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
1118 
1119  return (_Last - _First);
1120  }
#define _DEBUG_POINTER(first)
Definition: xutility:819
_FwdIt _Last
Definition: algorithm:1936
template<class _Iter1 , class _Iter2 , class _Pr >
false_type _Equal_memcmp_is_safe ( const _Iter1 &  ,
const _Iter2 &  ,
const _Pr &   
)
inline
2896  { // return equal optimization category for arbitrary iterators
2897  return {};
2898  }
template<class _Obj1 , class _Obj2 , class _Pr >
_Equal_memcmp_is_safe_helper< remove_const_t<_Obj1>, remove_const_t<_Obj2>, _Pr>::type _Equal_memcmp_is_safe ( _Obj1 *const &  ,
_Obj2 *const &  ,
const _Pr &   
)
inline
2908  { // return equal optimization category for pointers
2909  return {};
2910  }
template<class _InIt1 , class _InIt2 , class _Pr >
bool _Equal_no_deprecate ( _InIt1  _First1,
_InIt1  _Last1,
_InIt2  _First2,
_Pr &  _Pred 
)
inline
2970  { // compare [_First1, _Last1) to [_First2, ...) using _Pred, no _SCL_INSECURE_DEPRECATE_FN warnings
2971  _DEBUG_RANGE_PTR(_First1, _Last1, _First2);
2972  _DEBUG_POINTER_IF(_First1 != _Last1, _Pred);
2973  return (_Equal_no_deprecate1(_Unchecked(_First1), _Unchecked(_Last1),
2975  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _DEBUG_POINTER_IF(test, first)
Definition: xutility:820
typename iterator_traits< _Iter >::iterator_category _Iter_cat_t
Definition: xutility:655
bool _Equal_no_deprecate1(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Pr &_Pred, input_iterator_tag, input_iterator_tag)
Definition: xutility:2949
_Iter _Unchecked(_Iter _Src)
Definition: xutility:426
#define _DEBUG_RANGE_PTR(first, last, ptr)
Definition: xutility:824
template<class _InIt1 , class _InIt2 , class _Pr >
bool _Equal_no_deprecate1 ( _InIt1  _First1,
_InIt1  _Last1,
_InIt2  _First2,
_Pr &  _Pred,
input_iterator_tag  ,
input_iterator_tag   
)
inline
2951  { // compare [_First1, _Last1) to [_First2, ...) using _Pred, arbitrary iterators
2952  return (_Equal_unchecked(_First1, _Last1, _Unchecked_idl0(_First2), _Pred));
2953  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
bool _Equal_unchecked(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Pr &_Pred)
Definition: xutility:2939
template<class _InIt1 , class _InIt2 , class _Pr >
bool _Equal_no_deprecate1 ( _InIt1  _First1,
_InIt1  _Last1,
_InIt2  _First2,
_Pr &  _Pred,
random_access_iterator_tag  ,
random_access_iterator_tag   
)
inline
2960  { // compare [_First1, _Last1) to [_First2, ...) using _Pred, random-access iterators
2961  _CHECK_RANIT_RANGE(_First1, _Last1, _First2);
2962  return (_Equal_unchecked(_First1, _Last1, _Unchecked(_First2), _Pred));
2963  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
_Iter _Unchecked(_Iter _Src)
Definition: xutility:426
bool _Equal_unchecked(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Pr &_Pred)
Definition: xutility:2939
#define _CHECK_RANIT_RANGE(_First, _Last, _Target)
Definition: xutility:487
template<class _InIt1 , class _InIt2 , class _Pr >
bool _Equal_unchecked ( _InIt1  _First1,
_InIt1  _Last1,
_InIt2  _First2,
_Pr &  _Pred 
)
inline
2941  { // compare [_First1, _Last1) to [_First2, ...) using _Pred, choose optimization
2942  return (_Equal_unchecked1(_First1, _Last1, _First2, _Pred,
2943  _Equal_memcmp_is_safe(_First1, _First2, _Pred)));
2944  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
false_type _Equal_memcmp_is_safe(const _Iter1 &, const _Iter2 &, const _Pr &)
Definition: xutility:2895
bool _Equal_unchecked1(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Pr &_Pred, false_type)
Definition: xutility:2915
template<class _InIt1 , class _InIt2 , class _Pr >
bool _Equal_unchecked ( _InIt1  _First1,
_InIt1  _Last1,
_InIt2  _First2,
_InIt2  _Last2,
_Pr &  _Pred,
input_iterator_tag  ,
input_iterator_tag   
)
inline
3030  { // compare [_First1, _Last1) to [_First2, _Last2)
3031  // using _Pred, arbitrary iterators
3032  _DEBUG_POINTER_IF(_First1 != _Last1 && _First2 != _Last2, _Pred);
3033  for (; _First1 != _Last1 && _First2 != _Last2; ++_First1, (void)++_First2)
3034  if (!_Pred(*_First1, *_First2))
3035  return (false);
3036  return (_First1 == _Last1 && _First2 == _Last2);
3037  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _DEBUG_POINTER_IF(test, first)
Definition: xutility:820
_CRT_BEGIN_C_HEADER typedef void(__CRTDECL *unexpected_handler)()
template<class _InIt1 , class _InIt2 , class _Pr >
bool _Equal_unchecked ( _InIt1  _First1,
_InIt1  _Last1,
_InIt2  _First2,
_InIt2  _Last2,
_Pr &  _Pred,
random_access_iterator_tag  ,
random_access_iterator_tag   
)
inline
3045  { // compare [_First1, _Last1) to [_First2, _Last2)
3046  // using _Pred, random-access iterators
3047  if (_Last1 - _First1 != _Last2 - _First2)
3048  return (false);
3049  _DEBUG_POINTER_IF(_First1 != _Last1, _Pred);
3050  return (_Equal_unchecked(_First1, _Last1, _First2, _Pred));
3051  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _DEBUG_POINTER_IF(test, first)
Definition: xutility:820
bool _Equal_unchecked(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Pr &_Pred)
Definition: xutility:2939
template<class _InIt1 , class _InIt2 , class _Pr >
bool _Equal_unchecked1 ( _InIt1  _First1,
_InIt1  _Last1,
_InIt2  _First2,
_Pr &  _Pred,
false_type   
)
inline
2917  { // compare [_First1, _Last1) to [_First2, ...) using _Pred, no special optimization
2918  for (; _First1 != _Last1; ++_First1, (void)++_First2)
2919  if (!_Pred(*_First1, *_First2))
2920  return (false);
2921  return (true);
2922  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
_CRT_BEGIN_C_HEADER typedef void(__CRTDECL *unexpected_handler)()
template<class _InIt1 , class _InIt2 , class _Pr >
bool _Equal_unchecked1 ( _InIt1  _First1,
_InIt1  _Last1,
_InIt2  _First2,
_Pr &  ,
true_type   
)
inline
2929  { // compare [_First1, _Last1) to [_First2, ...) using _Pr, memcmp optimization
2930  const char * const _First1_ch = reinterpret_cast<const char *>(_First1);
2931  const char * const _First2_ch = reinterpret_cast<const char *>(_First2);
2932  const size_t _Count = reinterpret_cast<const char *>(_Last1) - _First1_ch;
2933  return (_CSTD memcmp(_First1_ch, _First2_ch, _Count) == 0);
2934  }
unsigned int _Count
Definition: xcomplex:668
_Check_return_ int __cdecl memcmp(_In_reads_bytes_(_Size) void const *_Buf1, _In_reads_bytes_(_Size) void const *_Buf2, _In_ size_t _Size)
#define _CSTD
Definition: yvals.h:570
template<class _FwdIt , class _Ty >
_Fill_memset_is_safe_helper<_FwdIt, _Ty>::type _Fill_memset_is_safe ( const _FwdIt &  ,
const _Ty &   
)
inline
2757  { // type deduction for _Fill_memset_is_safe_helper
2758  return {};
2759  }
template<class _OutIt , class _Diff , class _Ty >
_OutIt _Fill_n_unchecked ( _OutIt  _Dest,
_Diff  _Count,
const _Ty &  _Val 
)
inline
2820  { // copy _Val _Count times through [_Dest, ...), choose optimization
2821  // note: This is called directly from elsewhere in the STL
2822  return (_Fill_n_unchecked1(_Dest, _Count, _Val, _Fill_memset_is_safe(_Dest, _Val)));
2823  }
unsigned int _Count
Definition: xcomplex:668
_In_ int _Val
Definition: vcruntime_string.h:62
_Fill_memset_is_safe_helper< _FwdIt, _Ty >::type _Fill_memset_is_safe(const _FwdIt &, const _Ty &)
Definition: xutility:2756
_OutIt _Fill_n_unchecked1(_OutIt _Dest, _Diff _Count, const _Ty &_Val, false_type)
Definition: xutility:2795
template<class _OutIt , class _Diff , class _Ty >
_OutIt _Fill_n_unchecked1 ( _OutIt  _Dest,
_Diff  _Count,
const _Ty &  _Val,
false_type   
)
inline
2796  { // copy _Val _Count times through [_Dest, ...), no special optimization
2797  for (; 0 < _Count; --_Count, (void)++_Dest)
2798  *_Dest = _Val;
2799  return (_Dest);
2800  }
unsigned int _Count
Definition: xcomplex:668
_In_ int _Val
Definition: vcruntime_string.h:62
_CRT_BEGIN_C_HEADER typedef void(__CRTDECL *unexpected_handler)()
template<class _OutIt , class _Diff , class _Ty >
_OutIt _Fill_n_unchecked1 ( _OutIt  _Dest,
_Diff  _Count,
const _Ty &  _Val,
true_type   
)
inline
2806  { // copy _Val _Count times through [_Dest, ...), memset optimization
2807  if (0 < _Count)
2808  {
2809  _CSTD memset(_Dest, _Val, _Count);
2810  return (_Dest + _Count);
2811  }
2812 
2813  return (_Dest);
2814  }
unsigned int _Count
Definition: xcomplex:668
_In_ int _Val
Definition: vcruntime_string.h:62
#define _CSTD
Definition: yvals.h:570
template<class _FwdIt , class _Ty >
void _Fill_unchecked ( _FwdIt  _First,
_FwdIt  _Last,
const _Ty &  _Val 
)
inline
2779  { // copy _Val through [_First, _Last), choose optimization
2780  _Fill_unchecked1(_First, _Last, _Val, _Fill_memset_is_safe(_First, _Val));
2781  }
_In_ int _Val
Definition: vcruntime_string.h:62
_Fill_memset_is_safe_helper< _FwdIt, _Ty >::type _Fill_memset_is_safe(const _FwdIt &, const _Ty &)
Definition: xutility:2756
void _Fill_unchecked1(_FwdIt _First, _FwdIt _Last, const _Ty &_Val, false_type)
Definition: xutility:2763
_FwdIt _Last
Definition: algorithm:1936
template<class _FwdIt , class _Ty >
void _Fill_unchecked1 ( _FwdIt  _First,
_FwdIt  _Last,
const _Ty &  _Val,
false_type   
)
inline
2764  { // copy _Val through [_First, _Last), no special optimization
2765  for (; _First != _Last; ++_First)
2766  *_First = _Val;
2767  }
_In_ int _Val
Definition: vcruntime_string.h:62
_FwdIt _Last
Definition: algorithm:1936
template<class _FwdIt , class _Ty >
void _Fill_unchecked1 ( _FwdIt  _First,
_FwdIt  _Last,
const _Ty &  _Val,
true_type   
)
inline
2772  { // copy _Val through [_First, _Last), memset optimization
2773  _CSTD memset(_First, _Val, _Last - _First);
2774  }
_In_ int _Val
Definition: vcruntime_string.h:62
#define _CSTD
Definition: yvals.h:570
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt , class _Ty , class _Pr >
_InIt _Find_pr ( _InIt  _First,
_InIt  _Last,
const _Ty &  _Val,
_Pr &  _Pred 
)
inline
3294  { // find first matching _Val, using _Pred
3295  for (; _First != _Last; ++_First)
3296  if (_Pred(*_First, _Val))
3297  break;
3298  return (_First);
3299  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
_In_ int _Val
Definition: vcruntime_string.h:62
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt , class _Ty >
_InIt _Find_unchecked ( _InIt  _First,
_InIt  _Last,
const _Ty &  _Val 
)
inline
3266  { // find first matching _Val; choose optimization
3267  // activate optimization for pointers to (const) bytes and integral values
3268  typedef integral_constant<bool,
3276  > _Memchr_opt;
3277  return (_Find_unchecked1(_First, _Last, _Val, _Memchr_opt()));
3278  }
Definition: xtr1common:22
_In_ int _Val
Definition: vcruntime_string.h:62
#define bool
Definition: stdbool.h:15
_InIt _Find_unchecked1(_InIt _First, _InIt _Last, const _Ty &_Val, true_type)
Definition: xutility:3244
Definition: xtr1common:238
Definition: xtr1common:86
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt , class _Ty >
_InIt _Find_unchecked1 ( _InIt  _First,
_InIt  _Last,
const _Ty &  _Val,
true_type   
)
inline
3245  { // find first byte matching integral _Val
3246  if (!_Within_limits(_First, _Val))
3247  return (_Last);
3248  _First = static_cast<_InIt>(_CSTD memchr(
3249  _First, static_cast<unsigned char>(_Val), _Last - _First));
3250  return (_First ? _First : _Last);
3251  }
bool _Within_limits(const _Ty &_Val, true_type, true_type, _Any_tag)
Definition: xutility:3198
_In_ int _Val
Definition: vcruntime_string.h:62
_CRT_BEGIN_C_HEADER _Check_return_ _VCRTIMP void _CONST_RETURN *__cdecl memchr(_In_reads_bytes_opt_(_MaxCount) void const *_Buf, _In_ int _Val, _In_ size_t _MaxCount)
#define _CSTD
Definition: yvals.h:570
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt , class _Ty >
_InIt _Find_unchecked1 ( _InIt  _First,
_InIt  _Last,
const _Ty &  _Val,
false_type   
)
inline
3256  { // find first matching _Val
3257  for (; _First != _Last; ++_First)
3258  if (*_First == _Val)
3259  break;
3260  return (_First);
3261  }
_In_ int _Val
Definition: vcruntime_string.h:62
_FwdIt _Last
Definition: algorithm:1936
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
bool _Is_permutation_no_deprecate ( _FwdIt1  _First1,
_FwdIt1  _Last1,
_FwdIt2  _First2,
_Pr &  _Pred 
)
inline
3428  { // test if [_First1, _Last1) == permuted [_First2, ...), using _Pred, no deprecation warnings
3429  _DEBUG_RANGE_PTR(_First1, _Last1, _First2);
3430  _DEBUG_POINTER_IF(_First1 != _Last1, _Pred);
3431  return (_Is_permutation_no_deprecate1(_Unchecked(_First1), _Unchecked(_Last1),
3433  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _DEBUG_POINTER_IF(test, first)
Definition: xutility:820
typename iterator_traits< _Iter >::iterator_category _Iter_cat_t
Definition: xutility:655
bool _Is_permutation_no_deprecate1(_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _Pr &_Pred, forward_iterator_tag, forward_iterator_tag)
Definition: xutility:3407
_Iter _Unchecked(_Iter _Src)
Definition: xutility:426
#define _DEBUG_RANGE_PTR(first, last, ptr)
Definition: xutility:824
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
bool _Is_permutation_no_deprecate1 ( _FwdIt1  _First1,
_FwdIt1  _Last1,
_FwdIt2  _First2,
_Pr &  _Pred,
forward_iterator_tag  ,
forward_iterator_tag   
)
inline
3409  { // test if [_First1, _Last1) == permuted [_First2, ...), using _Pred
3410  return (_Is_permutation_unchecked(_First1, _Last1, _Unchecked_idl0(_First2), _Pred));
3411  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
bool _Is_permutation_unchecked(_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _Pr &_Pred)
Definition: xutility:3389
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
bool _Is_permutation_no_deprecate1 ( _FwdIt1  _First1,
_FwdIt1  _Last1,
_FwdIt2  _First2,
_Pr &  _Pred,
random_access_iterator_tag  ,
random_access_iterator_tag   
)
inline
3418  { // test if [_First1, _Last1) == permuted [_First2, ...), using _Pred
3419  _CHECK_RANIT_RANGE(_First1, _Last1, _First2);
3420  return (_Is_permutation_unchecked(_First1, _Last1, _Unchecked(_First2), _Pred));
3421  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
bool _Is_permutation_unchecked(_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _Pr &_Pred)
Definition: xutility:3389
_Iter _Unchecked(_Iter _Src)
Definition: xutility:426
#define _CHECK_RANIT_RANGE(_First, _Last, _Target)
Definition: xutility:487
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
bool _Is_permutation_unchecked ( _FwdIt1  _First1,
_FwdIt1  _Last1,
_FwdIt2  _First2,
_Pr &  _Pred 
)
inline
3391  { // test if [_First1, _Last1) == permuted [_First2, ...), using _Pred
3392  for (; _First1 != _Last1; ++_First1, (void)++_First2)
3393  if (!_Pred(*_First1, *_First2))
3394  { // found first inequality, check match counts in suffix
3395  _FwdIt2 _Last2 = _STD next(_First2,
3396  _STD distance(_First1, _Last1));
3397  return (_Check_match_counts(_First1, _Last1,
3398  _First2, _Last2, _Pred));
3399  }
3400 
3401  return (true);
3402  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
_Iter_diff_t< _InIt > distance(_InIt _First, _InIt _Last)
Definition: xutility:1124
bool _Check_match_counts(_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr &_Pred)
Definition: xutility:3365
_CRT_BEGIN_C_HEADER typedef void(__CRTDECL *unexpected_handler)()
_InIt next(_InIt _First, _Iter_diff_t< _InIt > _Off=1)
Definition: xutility:1131
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
bool _Is_permutation_unchecked ( _FwdIt1  _First1,
_FwdIt1  _Last1,
_FwdIt2  _First2,
_FwdIt2  _Last2,
_Pr &  _Pred,
forward_iterator_tag  ,
forward_iterator_tag   
)
inline
3488  { // test if [_First1, _Last1) == permuted [_First2, _Last2),
3489  // using _Pred, arbitrary iterators
3490  _DEBUG_POINTER_IF(_First1 != _Last1 && _First2 != _Last2, _Pred);
3491  for (; _First1 != _Last1 && _First2 != _Last2; ++_First1, (void)++_First2)
3492  if (!_Pred(*_First1, *_First2))
3493  { // found first inequality, check match counts in suffix
3494  if (_STD distance(_First1, _Last1)
3495  != _STD distance(_First2, _Last2))
3496  return (false); // lengths differ, fail
3497  else
3498  return (_Check_match_counts(_First1, _Last1,
3499  _First2, _Last2, _Pred));
3500  }
3501 
3502  return (_First1 == _Last1 && _First2 == _Last2);
3503  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _DEBUG_POINTER_IF(test, first)
Definition: xutility:820
_Iter_diff_t< _InIt > distance(_InIt _First, _InIt _Last)
Definition: xutility:1124
bool _Check_match_counts(_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr &_Pred)
Definition: xutility:3365
_CRT_BEGIN_C_HEADER typedef void(__CRTDECL *unexpected_handler)()
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
bool _Is_permutation_unchecked ( _FwdIt1  _First1,
_FwdIt1  _Last1,
_FwdIt2  _First2,
_FwdIt2  _Last2,
_Pr &  _Pred,
random_access_iterator_tag  ,
random_access_iterator_tag   
)
inline
3511  { // test if [_First1, _Last1) == permuted [_First2, _Last2),
3512  // using _Pred, random-access iterators
3513  if (_Last1 - _First1 != _Last2 - _First2)
3514  return (false);
3515  _DEBUG_POINTER_IF(_First1 != _Last1, _Pred);
3516  return (_Is_permutation_unchecked(_First1, _Last1, _First2, _Pred));
3517  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _DEBUG_POINTER_IF(test, first)
Definition: xutility:820
bool _Is_permutation_unchecked(_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _Pr &_Pred)
Definition: xutility:3389
template<class _InIt1 , class _InIt2 , class _Pr >
_Lex_compare_optimize<void> _Lex_compare_memcmp_classify ( const _InIt1 &  ,
const _InIt2 &  ,
const _Pr &   
)
inline
3119  { // return lex_compare optimization category for arbitrary iterators
3120  // note that overload selecting greater<_FTy> is in <xfunctional>
3121  return {};
3122  }
template<class _Obj1 , class _Obj2 , class _FTy >
_Lex_compare_check_element_types<less<int>, _Obj1, _Obj2, _FTy> _Lex_compare_memcmp_classify ( _Obj1 *const &  ,
_Obj2 *const &  ,
const less< _FTy > &   
)
inline
3129  { // return lex_compare optimization category for pointer iterators and less<_FTy>
3130  return {};
3131  }
template<class _InIt1 , class _InIt2 , class _Pr >
bool _Lex_compare_unchecked ( _InIt1  _First1,
_InIt1  _Last1,
_InIt2  _First2,
_InIt2  _Last2,
_Pr &  _Pred 
)
inline
3168  { // order [_First1, _Last1) vs. [_First2, _Last2) using _Pred, choose optimization
3169  return (_Lex_compare_unchecked1(_First1, _Last1, _First2, _Last2, _Pred,
3170  _Lex_compare_memcmp_classify(_First1, _First2, _Pred)));
3171  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
bool _Lex_compare_unchecked1(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _Pr &_Pred, _Lex_compare_optimize< void >)
Definition: xutility:3136
_Lex_compare_optimize< void > _Lex_compare_memcmp_classify(const _InIt1 &, const _InIt2 &, const _Pr &)
Definition: xutility:3118
template<class _InIt1 , class _InIt2 , class _Pr >
bool _Lex_compare_unchecked1 ( _InIt1  _First1,
_InIt1  _Last1,
_InIt2  _First2,
_InIt2  _Last2,
_Pr &  _Pred,
_Lex_compare_optimize< void  
)
inline
3138  { // order [_First1, _Last1) vs. [_First2, _Last2) using _Pred, no special optimization
3139  for (; _First1 != _Last1 && _First2 != _Last2; ++_First1, (void)++_First2)
3140  { // something to compare, do it
3141  if (_DEBUG_LT_PRED(_Pred, *_First1, *_First2))
3142  return (true);
3143  else if (_Pred(*_First2, *_First1))
3144  return (false);
3145  }
3146 
3147  return (_First1 == _Last1 && _First2 != _Last2);
3148  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _DEBUG_LT_PRED(pred, x, y)
Definition: xutility:817
_CRT_BEGIN_C_HEADER typedef void(__CRTDECL *unexpected_handler)()
template<class _InIt1 , class _InIt2 , class _Pr , class _Memcmp_pr >
bool _Lex_compare_unchecked1 ( _InIt1  _First1,
_InIt1  _Last1,
_InIt2  _First2,
_InIt2  _Last2,
_Pr &  ,
_Lex_compare_optimize< _Memcmp_pr >   
)
inline
3156  { // order [_First1, _Last1) vs. [_First2, _Last2) using _Pr, memcmp optimization
3157  const size_t _Num1 = _Last1 - _First1;
3158  const size_t _Num2 = _Last2 - _First2;
3159  const int _Ans = _CSTD memcmp(_First1, _First2, _Num1 < _Num2 ? _Num1 : _Num2);
3160  return (_Memcmp_pr{}(_Ans, 0) || _Ans == 0 && _Num1 < _Num2);
3161  }
_Check_return_ int __cdecl memcmp(_In_reads_bytes_(_Size) void const *_Buf1, _In_reads_bytes_(_Size) void const *_Buf2, _In_ size_t _Size)
#define _CSTD
Definition: yvals.h:570
template<class _BidIt1 , class _BidIt2 >
_BidIt2 _Move_backward1 ( _BidIt1  _First,
_BidIt1  _Last,
_BidIt2  _Dest,
input_iterator_tag  ,
_Any_tag   
)
inline
2685  { // move [_First, _Last) backwards to [..., _Dest), arbitrary iterators
2686  return (_Rechecked(_Dest,
2687  _Move_backward_unchecked(_First, _Last, _Unchecked_idl0(_Dest))));
2688  }
_Iter & _Rechecked(_Iter &_Dest, _UIter _Src)
Definition: xutility:456
_BidIt2 _Move_backward_unchecked(_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest)
Definition: xutility:2674
_FwdIt _Last
Definition: algorithm:1936
template<class _BidIt1 , class _BidIt2 >
_BidIt2 _Move_backward1 ( _BidIt1  _First,
_BidIt1  _Last,
_BidIt2  _Dest,
random_access_iterator_tag  ,
random_access_iterator_tag   
)
inline
2694  { // move [_First, _Last) backwards to [..., _Dest), random-access iterators
2695  _CHECK_RANIT_RANGE_BACKWARD(_First, _Last, _Dest);
2696  return (_Rechecked(_Dest,
2697  _Move_backward_unchecked(_First, _Last, _Unchecked(_Dest))));
2698  }
_Iter & _Rechecked(_Iter &_Dest, _UIter _Src)
Definition: xutility:456
#define _CHECK_RANIT_RANGE_BACKWARD(_First, _Last, _Target)
Definition: xutility:488
_Iter _Unchecked(_Iter _Src)
Definition: xutility:426
_BidIt2 _Move_backward_unchecked(_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest)
Definition: xutility:2674
_FwdIt _Last
Definition: algorithm:1936
template<class _BidIt1 , class _BidIt2 >
_BidIt2 _Move_backward_unchecked ( _BidIt1  _First,
_BidIt1  _Last,
_BidIt2  _Dest 
)
inline
2676  { // move [_First, _Last) backwards to [..., _Dest), choose optimization
2677  return (_Move_backward_unchecked1(_First, _Last,
2678  _Dest, _Ptr_move_cat(_First, _Dest)));
2679  }
_BidIt2 _Move_backward_unchecked1(_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest, _General_ptr_iterator_tag)
Definition: xutility:2656
_General_ptr_iterator_tag _Ptr_move_cat(const _Source &, const _Dest &)
Definition: xutility:798
_FwdIt _Last
Definition: algorithm:1936
template<class _BidIt1 , class _BidIt2 >
_BidIt2 _Move_backward_unchecked1 ( _BidIt1  _First,
_BidIt1  _Last,
_BidIt2  _Dest,
_General_ptr_iterator_tag   
)
inline
2658  { // move [_First, _Last) backwards to [..., _Dest), no special optimization
2659  while (_First != _Last)
2660  *--_Dest = _STD move(*--_Last);
2661  return (_Dest);
2662  }
_OutIt move(_InIt _First, _InIt _Last, _OutIt _Dest)
Definition: xutility:2633
_FwdIt _Last
Definition: algorithm:1936
template<class _BidIt1 , class _BidIt2 >
_BidIt2 _Move_backward_unchecked1 ( _BidIt1  _First,
_BidIt1  _Last,
_BidIt2  _Dest,
_Trivially_copyable_ptr_iterator_tag   
)
inline
2668  { // move [_First, _Last) backwards to [..., _Dest), memmove optimization
2669  return (_Copy_backward_memmove(_First, _Last, _Dest));
2670  }
_BidIt2 _Copy_backward_memmove(_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest)
Definition: xutility:2506
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt , class _OutIt >
_OutIt _Move_no_deprecate ( _InIt  _First,
_InIt  _Last,
_OutIt  _Dest 
)
inline
2625  { // move [_First, _Last) to [_Dest, ...), no _SCL_INSECURE_DEPRECATE_FN warnings
2626  _DEBUG_RANGE_PTR(_First, _Last, _Dest);
2627  return (_Move_no_deprecate1(_Unchecked(_First), _Unchecked(_Last),
2629  }
typename iterator_traits< _Iter >::iterator_category _Iter_cat_t
Definition: xutility:655
_Iter _Unchecked(_Iter _Src)
Definition: xutility:426
#define _DEBUG_RANGE_PTR(first, last, ptr)
Definition: xutility:824
_FwdIt _Last
Definition: algorithm:1936
_OutIt _Move_no_deprecate1(_InIt _First, _InIt _Last, _OutIt _Dest, input_iterator_tag, _Any_tag)
Definition: xutility:2604
template<class _InIt , class _OutIt >
_OutIt _Move_no_deprecate1 ( _InIt  _First,
_InIt  _Last,
_OutIt  _Dest,
input_iterator_tag  ,
_Any_tag   
)
inline
2606  { // move [_First, _Last) to [_Dest, ...), arbitrary iterators
2607  return (_Rechecked(_Dest,
2608  _Move_unchecked(_First, _Last, _Unchecked_idl0(_Dest))));
2609  }
_Iter & _Rechecked(_Iter &_Dest, _UIter _Src)
Definition: xutility:456
_OutIt _Move_unchecked(_InIt _First, _InIt _Last, _OutIt _Dest)
Definition: xutility:2595
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt , class _OutIt >
_OutIt _Move_no_deprecate1 ( _InIt  _First,
_InIt  _Last,
_OutIt  _Dest,
random_access_iterator_tag  ,
random_access_iterator_tag   
)
inline
2615  { // move [_First, _Last) to [_Dest, ...), random-access iterators
2616  _CHECK_RANIT_RANGE(_First, _Last, _Dest);
2617  return (_Rechecked(_Dest,
2618  _Move_unchecked(_First, _Last, _Unchecked(_Dest))));
2619  }
_Iter & _Rechecked(_Iter &_Dest, _UIter _Src)
Definition: xutility:456
_OutIt _Move_unchecked(_InIt _First, _InIt _Last, _OutIt _Dest)
Definition: xutility:2595
_Iter _Unchecked(_Iter _Src)
Definition: xutility:426
#define _CHECK_RANIT_RANGE(_First, _Last, _Target)
Definition: xutility:487
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt , class _OutIt >
_OutIt _Move_unchecked ( _InIt  _First,
_InIt  _Last,
_OutIt  _Dest 
)
inline
2597  { // move [_First, _Last) to [_Dest, ...), choose optimization
2598  return (_Move_unchecked1(_First, _Last,
2599  _Dest, _Ptr_move_cat(_First, _Dest)));
2600  }
_OutIt _Move_unchecked1(_InIt _First, _InIt _Last, _OutIt _Dest, _General_ptr_iterator_tag)
Definition: xutility:2577
_General_ptr_iterator_tag _Ptr_move_cat(const _Source &, const _Dest &)
Definition: xutility:798
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt , class _OutIt >
_OutIt _Move_unchecked1 ( _InIt  _First,
_InIt  _Last,
_OutIt  _Dest,
_General_ptr_iterator_tag   
)
inline
2579  { // move [_First, _Last) to [_Dest, ...), no special optimization
2580  for (; _First != _Last; ++_Dest, (void)++_First)
2581  *_Dest = _STD move(*_First);
2582  return (_Dest);
2583  }
_OutIt move(_InIt _First, _InIt _Last, _OutIt _Dest)
Definition: xutility:2633
_CRT_BEGIN_C_HEADER typedef void(__CRTDECL *unexpected_handler)()
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt , class _OutIt >
_OutIt _Move_unchecked1 ( _InIt  _First,
_InIt  _Last,
_OutIt  _Dest,
_Trivially_copyable_ptr_iterator_tag   
)
inline
2589  { // move [_First, _Last) to [_Dest, ...), memmove optimization
2590  return (_Copy_memmove(_First, _Last, _Dest));
2591  }
_OutIt _Copy_memmove(_InIt _First, _InIt _Last, _OutIt _Dest)
Definition: xutility:2299
_FwdIt _Last
Definition: algorithm:1936
template<class _Source , class _Dest >
_General_ptr_iterator_tag _Ptr_copy_cat ( const _Source &  ,
const _Dest &   
)
inline
782  { // return pointer copy optimization category for arbitrary iterators
783  return {};
784  }
template<class _Source , class _Dest >
conditional_t<is_trivially_assignable<_Dest&, _Source&>::value, typename _Ptr_cat_helper<remove_const_t<_Source>, _Dest>::type, _General_ptr_iterator_tag> _Ptr_copy_cat ( _Source *const &  ,
_Dest *const &   
)
inline
792  { // return pointer copy optimization category for pointers
793  return {};
794  }
template<class _Source , class _Dest >
_General_ptr_iterator_tag _Ptr_move_cat ( const _Source &  ,
const _Dest &   
)
inline
799  { // return pointer move optimization category for arbitrary iterators
800  return {};
801  }
template<class _Source , class _Dest >
conditional_t<is_trivially_assignable<_Dest&, _Source>::value, typename _Ptr_cat_helper<remove_const_t<_Source>, _Dest>::type, _General_ptr_iterator_tag> _Ptr_move_cat ( _Source *const &  ,
_Dest *const &   
)
inline
809  { // return pointer move optimization category for pointers
810  return {};
811  }
template<class _Iter , class _UIter >
_Iter& _Rechecked ( _Iter &  _Dest,
_UIter  _Src 
)
inline
457  { // reset checked from unchecked, generic
458  _Dest = _Src;
459  return (_Dest);
460  }
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
1904  { // convert to checked
1905  return (_Iter._Rechecked(_Right));
1906  }
_Myiter & _Rechecked(_Unchecked_type _Right)
Definition: xutility:1574
constexpr const _Ty &() _Right
Definition: algorithm:3591
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
2040  { // convert to checked
2041  return (_Iter._Rechecked(_Right));
2042  }
_Myiter & _Rechecked(_Unchecked_type _Right)
Definition: xutility:1945
constexpr const _Ty &() _Right
Definition: algorithm:3591
template<class _BidIt >
void _Reverse_unchecked ( _BidIt  _First,
_BidIt  _Last 
)
inline
3546  { // reverse elements in [_First, _Last), bidirectional iterators
3547  for (; _First != _Last && _First != --_Last; ++_First)
3548  _STD iter_swap(_First, _Last);
3549  }
_STD_BEGIN void iter_swap(_FwdIt1 _Left, _FwdIt2 _Right)
Definition: utility:21
_FwdIt _Last
Definition: algorithm:1936
template<class _BidIt >
pair<_BidIt, _BidIt> _Reverse_until_sentinel_unchecked ( _BidIt  _First,
_BidIt  _Sentinel,
_BidIt  _Last 
)
inline
3585  { // reverse until either _First or _Last hits _Sentinel
3586  while (_First != _Sentinel && _Last != _Sentinel)
3587  _STD iter_swap(_First++, --_Last);
3588  return (_STD make_pair(_First, _Last));
3589  }
constexpr pair< typename _Unrefwrap< _Ty1 >::type, typename _Unrefwrap< _Ty2 >::type > make_pair(_Ty1 &&_Val1, _Ty2 &&_Val2)
Definition: utility:323
_STD_BEGIN void iter_swap(_FwdIt1 _Left, _FwdIt2 _Right)
Definition: utility:21
_FwdIt _Last
Definition: algorithm:1936
template<class _FwdIt >
_FwdIt _Rotate_unchecked ( _FwdIt  _First,
_FwdIt  _Mid,
_FwdIt  _Last 
)
inline
3614  { // rotate [_First, _Last)
3615  if (_First == _Mid)
3616  return (_Last);
3617  if (_Mid == _Last)
3618  return (_First);
3619  return (_Rotate_unchecked1(_First, _Mid, _Last, _Iter_cat_t<_FwdIt>()));
3620  }
typename iterator_traits< _Iter >::iterator_category _Iter_cat_t
Definition: xutility:655
_FwdIt _Rotate_unchecked1(_FwdIt _First, _FwdIt _Mid, _FwdIt _Last, forward_iterator_tag)
Definition: xutility:3560
_FwdIt _Last
Definition: algorithm:1936
template<class _FwdIt >
_FwdIt _Rotate_unchecked1 ( _FwdIt  _First,
_FwdIt  _Mid,
_FwdIt  _Last,
forward_iterator_tag   
)
inline
3562  { // rotate [_First, _Last), forward iterators
3563  for (_FwdIt _Next = _Mid, _Res = _Last; ; )
3564  { // swap [_First, ...) into place
3565  _STD iter_swap(_First, _Next);
3566  if (++_First == _Mid)
3567  { // quit if done, else define next interval
3568  if (++_Next == _Last)
3569  return (_Res == _Last ? _Mid : _Res);
3570  else
3571  _Mid = _Next; // mark end of next interval
3572  }
3573  else if (++_Next == _Last)
3574  { // wrap to last end
3575  if (_Res == _Last)
3576  _Res = _First;
3577  _Next = _Mid;
3578  }
3579  }
3580  }
_STD_BEGIN void iter_swap(_FwdIt1 _Left, _FwdIt2 _Right)
Definition: utility:21
_FwdIt _Last
Definition: algorithm:1936
template<class _BidIt >
_BidIt _Rotate_unchecked1 ( _BidIt  _First,
_BidIt  _Mid,
_BidIt  _Last,
bidirectional_iterator_tag   
)
inline
3594  { // rotate [_First, _Last), bidirectional iterators
3595  _Reverse_unchecked(_First, _Mid);
3596  _Reverse_unchecked(_Mid, _Last);
3598  _Reverse_unchecked(_Tmp.first, _Tmp.second);
3599  return (_Mid != _Tmp.first ? _Tmp.first : _Tmp.second);
3600  }
_Ty2 second
Definition: utility:243
_Ty1 first
Definition: utility:242
void _Reverse_unchecked(_BidIt _First, _BidIt _Last)
Definition: xutility:3545
pair< _BidIt, _BidIt > _Reverse_until_sentinel_unchecked(_BidIt _First, _BidIt _Sentinel, _BidIt _Last)
Definition: xutility:3583
_FwdIt _Last
Definition: algorithm:1936
template<class _RanIt >
_RanIt _Rotate_unchecked1 ( _RanIt  _First,
_RanIt  _Mid,
_RanIt  _Last,
random_access_iterator_tag   
)
inline
3605  { // rotate [_First, _Last), random-access iterators
3606  _Reverse_unchecked(_First, _Mid);
3607  _Reverse_unchecked(_Mid, _Last);
3608  _Reverse_unchecked(_First, _Last);
3609  return (_First + (_Last - _Mid));
3610  }
void _Reverse_unchecked(_BidIt _First, _BidIt _Last)
Definition: xutility:3545
_FwdIt _Last
Definition: algorithm:1936
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
void _Trim_matching_suffixes ( _FwdIt1 &  ,
_FwdIt2 &  ,
_Pr &  ,
forward_iterator_tag  ,
forward_iterator_tag   
)
inline
3345  { // trim matching suffixes, forward iterators (do nothing)
3346  }
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
void _Trim_matching_suffixes ( _FwdIt1 &  _Last1,
_FwdIt2 &  _Last2,
_Pr &  _Pred,
bidirectional_iterator_tag  ,
bidirectional_iterator_tag   
)
inline
3353  { // trim matching suffixes, bidirectional iterators
3354  // assumptions: same lengths, non-empty, !_Pred(*_First1, *_First2)
3355  while (_Pred(*--_Last1, *--_Last2))
3356  ; // find last inequality
3357  ++_Last1;
3358  ++_Last2;
3359  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
template<class _Iter >
_Iter _Unchecked ( _Iter  _Src)
inline
427  { // construct unchecked from checked, generic
428  return (_Src);
429  }
template<class _Ty , size_t _Size>
_Array_const_iterator<_Ty, _Size>::_Unchecked_type _Unchecked ( _Array_const_iterator< _Ty, _Size _Iter)
inline
1894  { // convert to unchecked
1895  return (_Iter._Unchecked());
1896  }
_Unchecked_type _Unchecked() const
Definition: xutility:1580
template<class _Ty , size_t _Size>
_Array_iterator<_Ty, _Size>::_Unchecked_type _Unchecked ( _Array_iterator< _Ty, _Size _Iter)
inline
2030  { // convert to unchecked
2031  return (_Iter._Unchecked());
2032  }
_Unchecked_type _Unchecked() const
Definition: xutility:1951
template<class _Iter , class _Diff >
auto _Unchecked_n ( _Iter  _Src,
_Diff   
)
inline
679  { // blindly unwrap _Src under IDL == 0
680  return (_Unchecked(_Src));
681  }
_Iter _Unchecked(_Iter _Src)
Definition: xutility:426
template<class _Ty >
bool _Within_limits ( const _Ty &  _Val,
true_type  ,
true_type  ,
_Any_tag   
)
inline
3199  { // signed _Elem, signed _Ty
3200  return (SCHAR_MIN <= _Val && _Val <= SCHAR_MAX);
3201  }
#define SCHAR_MIN
Definition: limits.h:18
_In_ int _Val
Definition: vcruntime_string.h:62
#define SCHAR_MAX
Definition: limits.h:19
template<class _Ty >
bool _Within_limits ( const _Ty &  _Val,
true_type  ,
false_type  ,
true_type   
)
inline
3205  { // signed _Elem, unsigned _Ty, -1 == static_cast<_Ty>(-1)
3206  return (_Val <= SCHAR_MAX || static_cast<_Ty>(SCHAR_MIN) <= _Val);
3207  }
#define SCHAR_MIN
Definition: limits.h:18
_In_ int _Val
Definition: vcruntime_string.h:62
#define SCHAR_MAX
Definition: limits.h:19
template<class _Ty >
bool _Within_limits ( const _Ty &  _Val,
true_type  ,
false_type  ,
false_type   
)
inline
3211  { // signed _Elem, unsigned _Ty, -1 != static_cast<_Ty>(-1)
3212  return (_Val <= SCHAR_MAX);
3213  }
_In_ int _Val
Definition: vcruntime_string.h:62
#define SCHAR_MAX
Definition: limits.h:19
template<class _Ty >
bool _Within_limits ( const _Ty &  _Val,
false_type  ,
true_type  ,
_Any_tag   
)
inline
3217  { // unsigned _Elem, signed _Ty
3218  return (0 <= _Val && _Val <= UCHAR_MAX);
3219  }
_In_ int _Val
Definition: vcruntime_string.h:62
#define UCHAR_MAX
Definition: limits.h:20
template<class _Ty >
bool _Within_limits ( const _Ty &  _Val,
false_type  ,
false_type  ,
_Any_tag   
)
inline
3223  { // unsigned _Elem, unsigned _Ty
3224  return (_Val <= UCHAR_MAX);
3225  }
_In_ int _Val
Definition: vcruntime_string.h:62
#define UCHAR_MAX
Definition: limits.h:20
template<class _InIt , class _Ty >
bool _Within_limits ( _InIt  ,
const _Ty &  _Val 
)
inline
3230  { // check whether _Val is within the limits of _Elem
3231  typedef typename remove_pointer<_InIt>::type _Elem;
3233  integral_constant<bool, -1 == static_cast<_Ty>(-1)>()));
3234  }
Definition: xtr1common:22
bool _Within_limits(const _Ty &_Val, true_type, true_type, _Any_tag)
Definition: xutility:3198
_In_ int _Val
Definition: vcruntime_string.h:62
_Ty type
Definition: type_traits:166
Definition: type_traits:728
template<class _InIt >
bool _Within_limits ( _InIt  ,
const bool  
)
inline
3238  { // bools are always within the limits of _Elem
3239  return (true);
3240  }
_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xinvalid_argument ( _In_z_ const char *  )
_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xlength_error ( _In_z_ const char *  )
_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xout_of_range ( _In_z_ const char *  )
_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xoverflow_error ( _In_z_ const char *  )
_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xruntime_error ( _In_z_ const char *  )
template<class _InIt , class _Diff >
void advance ( _InIt &  _Where,
_Diff  _Off 
)
inline
1090  { // increment iterator by offset, arbitrary iterators
1091  // we remove_const_t before _Iter_cat_t for better diagnostics if the user passes an iterator that is const
1092  _Advance1(_Where, _Off, _Iter_cat_t<remove_const_t<_InIt>>());
1093  }
typename remove_const< _Ty >::type remove_const_t
Definition: type_traits:1820
typename iterator_traits< _Iter >::iterator_category _Iter_cat_t
Definition: xutility:655
void _Advance1(_InIt &_Where, _Diff _Off, input_iterator_tag)
Definition: xutility:1059
template<class _Container >
auto begin ( _Container &  _Cont) -> decltype(_Cont.begin())
inline
1355  { // get beginning of sequence
1356  return (_Cont.begin());
1357  }
template<class _Container >
auto begin ( const _Container &  _Cont) -> decltype(_Cont.begin())
inline
1361  { // get beginning of sequence
1362  return (_Cont.begin());
1363  }
template<class _Ty , size_t _Size>
constexpr _Ty* begin ( _Ty(&)  _Array[_Size])
inline
1380  { // get beginning of array
1381  return (_Array);
1382  }
template<class _Container >
constexpr auto cbegin ( const _Container &  _Cont) -> decltype(_STD begin(_Cont))
inline
1396  { // get beginning of sequence
1397  return (_STD begin(_Cont));
1398  }
auto begin(_Container &_Cont) -> decltype(_Cont.begin())
Definition: xutility:1354
template<class _Container >
constexpr auto cend ( const _Container &  _Cont) -> decltype(_STD end(_Cont))
inline
1404  { // get end of sequence
1405  return (_STD end(_Cont));
1406  }
auto end(_Container &_Cont) -> decltype(_Cont.end())
Definition: xutility:1366
template<class _InIt , class _OutIt >
_OutIt copy ( _InIt  _First,
_InIt  _Last,
_OutIt  _Dest 
)
inline
2371  { // copy [_First, _Last) to [_Dest, ...)
2372  _DEPRECATE_UNCHECKED(copy, _Dest);
2373  return (_Copy_no_deprecate(_First, _Last, _Dest));
2374  }
_OutIt copy(_InIt _First, _InIt _Last, _OutIt _Dest)
Definition: xutility:2369
#define _DEPRECATE_UNCHECKED(_Func, _Iter)
Definition: xutility:478
_OutIt _Copy_no_deprecate(_InIt _First, _InIt _Last, _OutIt _Dest)
Definition: xutility:2359
_FwdIt _Last
Definition: algorithm:1936
template<class _BidIt1 , class _BidIt2 >
_BidIt2 copy_backward ( _BidIt1  _First,
_BidIt1  _Last,
_BidIt2  _Dest 
)
inline
2567  { // copy [_First, _Last) backwards to [..., _Dest)
2569  _DEBUG_RANGE_PTR(_First, _Last, _Dest);
2570  return (_Copy_backward1(_Unchecked(_First), _Unchecked(_Last),
2572  }
#define _DEPRECATE_UNCHECKED(_Func, _Iter)
Definition: xutility:478
typename iterator_traits< _Iter >::iterator_category _Iter_cat_t
Definition: xutility:655
_BidIt2 _Copy_backward1(_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest, input_iterator_tag, _Any_tag)
Definition: xutility:2546
_BidIt2 copy_backward(_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest)
Definition: xutility:2565
_Iter _Unchecked(_Iter _Src)
Definition: xutility:426
#define _DEBUG_RANGE_PTR(first, last, ptr)
Definition: xutility:824
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt , class _Diff , class _OutIt >
_OutIt copy_n ( _InIt  _First,
_Diff  _Count,
_OutIt  _Dest 
)
inline
2456  { // copy [_First, _First + _Count) to [_Dest, ...)
2457  // Note that we _DEPRECATE_UNCHECKED _Dest because _Count logically goes with _First
2458  _DEPRECATE_UNCHECKED(copy_n, _Dest);
2459  return (_Rechecked(_Dest,
2461  }
_OutIt copy_n(_InIt _First, _Diff _Count, _OutIt _Dest)
Definition: xutility:2454
_Iter & _Rechecked(_Iter &_Dest, _UIter _Src)
Definition: xutility:456
#define _DEPRECATE_UNCHECKED(_Func, _Iter)
Definition: xutility:478
unsigned int _Count
Definition: xcomplex:668
auto _Unchecked_n(_Iter _Src, _Diff)
Definition: xutility:678
_OutIt _Copy_n_unchecked(_InIt _First, _Diff _Count, _OutIt _Dest)
Definition: xutility:2444
template<class _InIt , class _Ty >
_Iter_diff_t<_InIt> count ( _InIt  _First,
_InIt  _Last,
const _Ty &  _Val 
)
inline
3319  { // count elements that match _Val
3320  _DEBUG_RANGE(_First, _Last);
3321  return (_Count_unchecked(_Unchecked(_First), _Unchecked(_Last), _Val));
3322  }
#define _DEBUG_RANGE(first, last)
Definition: xutility:822
_Iter_diff_t< _InIt > _Count_unchecked(_InIt _First, _InIt _Last, const _Ty &_Val)
Definition: xutility:3305
_In_ int _Val
Definition: vcruntime_string.h:62
_Iter _Unchecked(_Iter _Src)
Definition: xutility:426
_FwdIt _Last
Definition: algorithm:1936
template<class _Container >
auto crbegin ( const _Container &  _Cont) -> decltype(_STD rbegin(_Cont))
inline
1465  { // get beginning of reversed sequence
1466  return (_STD rbegin(_Cont));
1467  }
auto rbegin(_Container &_Cont) -> decltype(_Cont.rbegin())
Definition: xutility:1410
template<class _Container >
auto crend ( const _Container &  _Cont) -> decltype(_STD rend(_Cont))
inline
1472  { // get end of reversed sequence
1473  return (_STD rend(_Cont));
1474  }
auto rend(_Container &_Cont) -> decltype(_Cont.rend())
Definition: xutility:1422
template<class _Container >
constexpr auto data ( _Container &  _Cont) -> decltype(_Cont.data())
inline
1515  { // get data() for container
1516  return (_Cont.data());
1517  }
template<class _Container >
constexpr auto data ( const _Container &  _Cont) -> decltype(_Cont.data())
inline
1522  { // get pointer to data of const container
1523  return (_Cont.data());
1524  }
template<class _Ty , size_t _Size>
constexpr _Ty* data ( _Ty(&)  _Array[_Size])
inline
1529  { // get pointer to data of array
1530  return (_Array);
1531  }
template<class _Elem >
constexpr const _Elem* data ( _XSTD initializer_list< _Elem >  _Ilist)
inline
1536  { // get pointer to data of initializer_list
1537  return (_Ilist.begin());
1538  }
template<class _InIt >
_Iter_diff_t<_InIt> distance ( _InIt  _First,
_InIt  _Last 
)
inline
1125  { // return distance between iterators
1126  return (_Distance1(_First, _Last, _Iter_cat_t<_InIt>()));
1127  }
typename iterator_traits< _Iter >::iterator_category _Iter_cat_t
Definition: xutility:655
_Iter_diff_t< _InIt > _Distance1(_InIt _First, _InIt _Last, input_iterator_tag)
Definition: xutility:1098
_FwdIt _Last
Definition: algorithm:1936
template<class _Container >
constexpr auto empty ( const _Container &  _Cont) -> decltype(_Cont.empty())
inline
1494  { // get empty() for container
1495  return (_Cont.empty());
1496  }
template<class _Ty , size_t _Size>
constexpr bool empty ( const   _Ty(&)[_Size])
inline
1501  { // get dimension==0 for array (can't happen)
1502  return (false);
1503  }
template<class _Elem >
constexpr bool empty ( _XSTD initializer_list< _Elem >  _Ilist)
inline
1508  { // get dimension==0 for initializer_list
1509  return (_Ilist.size() == 0);
1510  }
template<class _Container >
auto end ( _Container &  _Cont) -> decltype(_Cont.end())
inline
1367  { // get end of sequence
1368  return (_Cont.end());
1369  }
template<class _Container >
auto end ( const _Container &  _Cont) -> decltype(_Cont.end())
inline
1373  { // get end of sequence
1374  return (_Cont.end());
1375  }
template<class _Ty , size_t _Size>
constexpr _Ty* end ( _Ty(&)  _Array[_Size])
inline
1387  { // get end of array
1388  return (_Array + _Size);
1389  }
_Size
Definition: vcruntime_string.h:36
template<class _InIt1 , class _InIt2 , class _Pr >
bool equal ( _InIt1  _First1,
_InIt1  _Last1,
_InIt2  _First2,
_Pr  _Pred 
)
inline
2982  { // compare [_First1, _Last1) to [_First2, ...) using _Pred
2983  _DEPRECATE_UNCHECKED(equal, _First2);
2984  return (_Equal_no_deprecate(_First1, _Last1, _First2, _Pred));
2985  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
bool equal(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Pr _Pred)
Definition: xutility:2980
#define _DEPRECATE_UNCHECKED(_Func, _Iter)
Definition: xutility:478
bool _Equal_no_deprecate(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Pr &_Pred)
Definition: xutility:2968
template<class _InIt1 , class _InIt2 >
bool equal ( _InIt1  _First1,
_InIt1  _Last1,
_InIt2  _First2 
)
inline
3006  { // compare [_First1, _Last1) to [_First2, ...)
3007  return (_STD equal(_First1, _Last1, _First2,
3008  equal_to<>()));
3009  }
bool equal(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Pr _Pred)
Definition: xutility:2980
Definition: xstddef:217
template<class _InIt1 , class _InIt2 , class _Pr >
bool equal ( _InIt1  _First1,
_InIt1  _Last1,
_InIt2  _First2,
_InIt2  _Last2,
_Pr  _Pred 
)
inline
3058  { // compare [_First1, _Last1) to [_First2, _Last2) using _Pred
3059  _DEBUG_RANGE(_First1, _Last1);
3060  _DEBUG_RANGE(_First2, _Last2);
3061  return (_Equal_unchecked(_Unchecked(_First1), _Unchecked(_Last1),
3062  _Unchecked(_First2), _Unchecked(_Last2), _Pred,
3064  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _DEBUG_RANGE(first, last)
Definition: xutility:822
typename iterator_traits< _Iter >::iterator_category _Iter_cat_t
Definition: xutility:655
_Iter _Unchecked(_Iter _Src)
Definition: xutility:426
bool _Equal_unchecked(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Pr &_Pred)
Definition: xutility:2939
template<class _InIt1 , class _InIt2 >
bool equal ( _InIt1  _First1,
_InIt1  _Last1,
_InIt2  _First2,
_InIt2  _Last2 
)
inline
3071  { // compare [_First1, _Last1) to [_First2, _Last2)
3072  return (_STD equal(_First1, _Last1, _First2, _Last2,
3073  equal_to<>()));
3074  }
bool equal(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Pr _Pred)
Definition: xutility:2980
Definition: xstddef:217
template<class _FwdIt , class _Ty >
void fill ( _FwdIt  _First,
_FwdIt  _Last,
const _Ty &  _Val 
)
inline
2786  { // copy _Val through [_First, _Last)
2787  _DEBUG_RANGE(_First, _Last);
2789  }
#define _DEBUG_RANGE(first, last)
Definition: xutility:822
_In_ int _Val
Definition: vcruntime_string.h:62
_Iter _Unchecked(_Iter _Src)
Definition: xutility:426
void _Fill_unchecked(_FwdIt _First, _FwdIt _Last, const _Ty &_Val)
Definition: xutility:2778
_FwdIt _Last
Definition: algorithm:1936
template<class _OutIt , class _Diff , class _Ty >
_OutIt fill_n ( _OutIt  _Dest,
_Diff  _Count,
const _Ty &  _Val 
)
inline
2829  { // copy _Val _Count times through [_Dest, ...)
2830  return (_Rechecked(_Dest,
2832  }
_Iter & _Rechecked(_Iter &_Dest, _UIter _Src)
Definition: xutility:456
_OutIt _Fill_n_unchecked(_OutIt _Dest, _Diff _Count, const _Ty &_Val)
Definition: xutility:2819
unsigned int _Count
Definition: xcomplex:668
_In_ int _Val
Definition: vcruntime_string.h:62
auto _Unchecked_n(_Iter _Src, _Diff)
Definition: xutility:678
template<class _InIt , class _Ty >
_InIt find ( _InIt  _First,
_InIt  _Last,
const _Ty &  _Val 
)
inline
3283  { // find first matching _Val
3284  _DEBUG_RANGE(_First, _Last);
3285  return (_Rechecked(_First,
3287  }
_Iter & _Rechecked(_Iter &_Dest, _UIter _Src)
Definition: xutility:456
#define _DEBUG_RANGE(first, last)
Definition: xutility:822
_In_ int _Val
Definition: vcruntime_string.h:62
_Iter _Unchecked(_Iter _Src)
Definition: xutility:426
_InIt _Find_unchecked(_InIt _First, _InIt _Last, const _Ty &_Val)
Definition: xutility:3265
_FwdIt _Last
Definition: algorithm:1936
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
bool is_permutation ( _FwdIt1  _First1,
_FwdIt1  _Last1,
_FwdIt2  _First2,
_Pr  _Pred 
)
inline
3440  { // test if [_First1, _Last1) == permuted [_First2, ...), using _Pred
3442  return (_Is_permutation_no_deprecate(_First1, _Last1, _First2, _Pred));
3443  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _DEPRECATE_UNCHECKED(_Func, _Iter)
Definition: xutility:478
bool _Is_permutation_no_deprecate(_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _Pr &_Pred)
Definition: xutility:3426
bool is_permutation(_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _Pr _Pred)
Definition: xutility:3438
template<class _FwdIt1 , class _FwdIt2 >
bool is_permutation ( _FwdIt1  _First1,
_FwdIt1  _Last1,
_FwdIt2  _First2 
)
inline
3464  { // test if [_First1, _Last1) == permuted [_First2, ...)
3465  return (_STD is_permutation(_First1, _Last1,
3466  _First2, equal_to<>()));
3467  }
bool is_permutation(_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _Pr _Pred)
Definition: xutility:3438
Definition: xstddef:217
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
bool is_permutation ( _FwdIt1  _First1,
_FwdIt1  _Last1,
_FwdIt2  _First2,
_FwdIt2  _Last2,
_Pr  _Pred 
)
inline
3524  { // test if [_First1, _Last1) == permuted [_First2, _Last2),
3525  // using _Pred
3526  _DEBUG_RANGE(_First1, _Last1);
3527  _DEBUG_RANGE(_First2, _Last2);
3528  return (_Is_permutation_unchecked(_Unchecked(_First1), _Unchecked(_Last1),
3529  _Unchecked(_First2), _Unchecked(_Last2), _Pred,
3531  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _DEBUG_RANGE(first, last)
Definition: xutility:822
typename iterator_traits< _Iter >::iterator_category _Iter_cat_t
Definition: xutility:655
bool _Is_permutation_unchecked(_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _Pr &_Pred)
Definition: xutility:3389
_Iter _Unchecked(_Iter _Src)
Definition: xutility:426
template<class _FwdIt1 , class _FwdIt2 >
bool is_permutation ( _FwdIt1  _First1,
_FwdIt1  _Last1,
_FwdIt2  _First2,
_FwdIt2  _Last2 
)
inline
3538  { // test if [_First1, _Last1) == permuted [_First2, _Last2)
3539  return (_STD is_permutation(_First1, _Last1,
3540  _First2, _Last2, equal_to<>()));
3541  }
bool is_permutation(_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _Pr _Pred)
Definition: xutility:3438
Definition: xstddef:217
template<class _InIt1 , class _InIt2 , class _Pr >
bool lexicographical_compare ( _InIt1  _First1,
_InIt1  _Last1,
_InIt2  _First2,
_InIt2  _Last2,
_Pr  _Pred 
)
inline
3178  { // order [_First1, _Last1) vs. [_First2, _Last2) using _Pred
3179  _DEBUG_RANGE(_First1, _Last1);
3180  _DEBUG_RANGE(_First2, _Last2);
3181  _DEBUG_POINTER_IF(_First1 != _Last1 && _First2 != _Last2, _Pred);
3182  return (_Lex_compare_unchecked(_Unchecked(_First1), _Unchecked(_Last1),
3183  _Unchecked(_First2), _Unchecked(_Last2), _Pred));
3184  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _DEBUG_RANGE(first, last)
Definition: xutility:822
#define _DEBUG_POINTER_IF(test, first)
Definition: xutility:820
bool _Lex_compare_unchecked(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _Pr &_Pred)
Definition: xutility:3166
_Iter _Unchecked(_Iter _Src)
Definition: xutility:426
template<class _InIt1 , class _InIt2 >
bool lexicographical_compare ( _InIt1  _First1,
_InIt1  _Last1,
_InIt2  _First2,
_InIt2  _Last2 
)
inline
3191  { // order [_First1, _Last1) vs. [_First2, _Last2)
3192  return (_STD lexicographical_compare(_First1, _Last1,
3193  _First2, _Last2, less<>()));
3194  }
bool lexicographical_compare(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _Pr _Pred)
Definition: xutility:3176
Definition: xstddef:231
template<class _RanIt >
move_iterator<_RanIt> make_move_iterator ( _RanIt  _Iter)
inline
2268  { // make move_iterator from iterator
2269  return (move_iterator<_RanIt>(_Iter));
2270  }
Definition: xutility:2055
template<class _RanIt >
reverse_iterator<_RanIt> make_reverse_iterator ( _RanIt  _Iter)
inline
1347  { // make reverse_iterator from iterator
1348  return (reverse_iterator<_RanIt>(_Iter));
1349  }
Definition: xutility:1158
template<class _InIt , class _OutIt >
_OutIt move ( _InIt  _First,
_InIt  _Last,
_OutIt  _Dest 
)
inline
2635  { // move [_First, _Last) to [_Dest, ...)
2636  _DEPRECATE_UNCHECKED(move, _Dest);
2637  return (_Move_no_deprecate(_First, _Last, _Dest));
2638  }
#define _DEPRECATE_UNCHECKED(_Func, _Iter)
Definition: xutility:478
_OutIt move(_InIt _First, _InIt _Last, _OutIt _Dest)
Definition: xutility:2633
_OutIt _Move_no_deprecate(_InIt _First, _InIt _Last, _OutIt _Dest)
Definition: xutility:2623
_FwdIt _Last
Definition: algorithm:1936
template<class _BidIt1 , class _BidIt2 >
_BidIt2 move_backward ( _BidIt1  _First,
_BidIt1  _Last,
_BidIt2  _Dest 
)
inline
2704  { // move [_First, _Last) backwards to [..., _Dest)
2706  _DEBUG_RANGE_PTR(_First, _Last, _Dest);
2707  return (_Move_backward1(_Unchecked(_First), _Unchecked(_Last),
2709  }
#define _DEPRECATE_UNCHECKED(_Func, _Iter)
Definition: xutility:478
typename iterator_traits< _Iter >::iterator_category _Iter_cat_t
Definition: xutility:655
_BidIt2 move_backward(_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest)
Definition: xutility:2702
_Iter _Unchecked(_Iter _Src)
Definition: xutility:426
_BidIt2 _Move_backward1(_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest, input_iterator_tag, _Any_tag)
Definition: xutility:2683
#define _DEBUG_RANGE_PTR(first, last, ptr)
Definition: xutility:824
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt >
_InIt next ( _InIt  _First,
_Iter_diff_t< _InIt >  _Off = 1 
)
inline
1132  { // increment iterator
1133  static_assert(is_base_of<input_iterator_tag,
1135  "next requires input iterator");
1136 
1137  _STD advance(_First, _Off);
1138  return (_First);
1139  }
Definition: type_traits:982
Definition: xutility:506
Definition: xutility:618
void advance(_InIt &_Where, _Diff _Off)
Definition: xutility:1089
template<class _RanIt1 , class _RanIt2 >
bool operator!= ( const reverse_iterator< _RanIt1 > &  _Left,
const reverse_iterator< _RanIt2 > &  _Right 
)
inline
1308  { // test for reverse_iterator inequality
1309  return (!(_Left == _Right));
1310  }
template<class _RanIt1 , class _RanIt2 >
bool operator!= ( const move_iterator< _RanIt1 > &  _Left,
const move_iterator< _RanIt2 > &  _Right 
)
inline
2225  { // test for move_iterator inequality
2226  return (!(_Left == _Right));
2227  }
template<class _RanIt >
reverse_iterator<_RanIt> operator+ ( typename reverse_iterator< _RanIt >::difference_type  _Off,
const reverse_iterator< _RanIt > &  _Right 
)
inline
1283  { // return reverse_iterator + integer
1284  return (_Right + _Off);
1285  }
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
1913  { // add offset to iterator
1914  return (_Next += _Off);
1915  }
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
2049  { // add offset to iterator
2050  return (_Next += _Off);
2051  }
template<class _RanIt , class _Diff >
move_iterator<_RanIt> operator+ ( _Diff  _Off,
const move_iterator< _RanIt > &  _Right 
)
inline
2197  { // return move_iterator + integer
2198  return (_Right + _Off);
2199  }
template<class _RanIt1 , class _RanIt2 >
auto operator- ( const reverse_iterator< _RanIt1 > &  _Left,
const reverse_iterator< _RanIt2 > &  _Right 
) -> decltype(_Right.base() - _Left.base())
inline
1292  { // return difference of reverse_iterators
1293  return (_Right.base() - _Left.base());
1294  }
_RanIt base() const
Definition: xutility:1197
template<class _RanIt1 , class _RanIt2 >
auto operator- ( move_iterator< _RanIt1 > &  _Left,
const move_iterator< _RanIt2 > &  _Right 
) -> decltype(_Left.base() - _Right.base())
inline
2207  { // test for move_iterator equality
2208  return (_Left.base() - _Right.base());
2209  }
_RanIt base() const
Definition: xutility:2094
template<class _RanIt1 , class _RanIt2 >
bool operator< ( const reverse_iterator< _RanIt1 > &  _Left,
const reverse_iterator< _RanIt2 > &  _Right 
)
inline
1316  { // test for reverse_iterator < reverse_iterator
1317  return (_Right.base() < _Left.base());
1318  }
_RanIt base() const
Definition: xutility:1197
template<class _RanIt1 , class _RanIt2 >
bool operator< ( const move_iterator< _RanIt1 > &  _Left,
const move_iterator< _RanIt2 > &  _Right 
)
inline
2234  { // test for move_iterator < move_iterator
2235  return (_Left._Less(_Right));
2236  }
bool _Less(const move_iterator< _RanIt2 > &_Right) const
Definition: xutility:2171
template<class _RanIt1 , class _RanIt2 >
bool operator<= ( const reverse_iterator< _RanIt1 > &  _Left,
const reverse_iterator< _RanIt2 > &  _Right 
)
inline
1332  { // test for reverse_iterator <= reverse_iterator
1333  return (!(_Right < _Left));
1334  }
template<class _RanIt1 , class _RanIt2 >
bool operator<= ( const move_iterator< _RanIt1 > &  _Left,
const move_iterator< _RanIt2 > &  _Right 
)
inline
2252  { // test for move_iterator <= move_iterator
2253  return (!(_Right < _Left));
2254  }
template<class _RanIt1 , class _RanIt2 >
bool operator== ( const reverse_iterator< _RanIt1 > &  _Left,
const reverse_iterator< _RanIt2 > &  _Right 
)
inline
1300  { // test for reverse_iterator equality
1301  return (_Left.base() == _Right.base());
1302  }
_RanIt base() const
Definition: xutility:1197
template<class _RanIt1 , class _RanIt2 >
bool operator== ( const move_iterator< _RanIt1 > &  _Left,
const move_iterator< _RanIt2 > &  _Right 
)
inline
2216  { // test for move_iterator equality
2217  return (_Left._Equal(_Right));
2218  }
bool _Equal(const move_iterator< _RanIt2 > &_Right) const
Definition: xutility:2136
template<class _RanIt1 , class _RanIt2 >
bool operator> ( const reverse_iterator< _RanIt1 > &  _Left,
const reverse_iterator< _RanIt2 > &  _Right 
)
inline
1324  { // test for reverse_iterator > reverse_iterator
1325  return (_Right < _Left);
1326  }
template<class _RanIt1 , class _RanIt2 >
bool operator> ( const move_iterator< _RanIt1 > &  _Left,
const move_iterator< _RanIt2 > &  _Right 
)
inline
2243  { // test for move_iterator > move_iterator
2244  return (_Right < _Left);
2245  }
template<class _RanIt1 , class _RanIt2 >
bool operator>= ( const reverse_iterator< _RanIt1 > &  _Left,
const reverse_iterator< _RanIt2 > &  _Right 
)
inline
1340  { // test for reverse_iterator >= reverse_iterator
1341  return (!(_Left < _Right));
1342  }
template<class _RanIt1 , class _RanIt2 >
bool operator>= ( const move_iterator< _RanIt1 > &  _Left,
const move_iterator< _RanIt2 > &  _Right 
)
inline
2261  { // test for move_iterator >= move_iterator
2262  return (!(_Left < _Right));
2263  }
template<class _BidIt >
_BidIt prev ( _BidIt  _First,
_Iter_diff_t< _BidIt >  _Off = 1 
)
inline
1144  { // decrement iterator
1145  static_assert(is_base_of<bidirectional_iterator_tag,
1147  "prev requires bidirectional iterator");
1148 
1149  _STD advance(_First, -_Off);
1150  return (_First);
1151  }
Definition: type_traits:982
Definition: xutility:618
void advance(_InIt &_Where, _Diff _Off)
Definition: xutility:1089
Definition: xutility:524
template<class _Container >
auto rbegin ( _Container &  _Cont) -> decltype(_Cont.rbegin())
inline
1411  { // get beginning of reversed sequence
1412  return (_Cont.rbegin());
1413  }
template<class _Container >
auto rbegin ( const _Container &  _Cont) -> decltype(_Cont.rbegin())
inline
1417  { // get beginning of reversed sequence
1418  return (_Cont.rbegin());
1419  }
template<class _Ty , size_t _Size>
reverse_iterator<_Ty *> rbegin ( _Ty(&)  _Array[_Size])
inline
1436  { // get beginning of reversed array
1437  return (reverse_iterator<_Ty *>(_Array + _Size));
1438  }
Definition: xutility:1158
_Size
Definition: vcruntime_string.h:36
template<class _Elem >
reverse_iterator<const _Elem *> rbegin ( _XSTD initializer_list< _Elem >  _Ilist)
inline
1450  { // get beginning of reversed sequence
1451  return (reverse_iterator<const _Elem *>(_Ilist.end()));
1452  }
Definition: xutility:1158
template<class _Container >
auto rend ( _Container &  _Cont) -> decltype(_Cont.rend())
inline
1423  { // get end of reversed sequence
1424  return (_Cont.rend());
1425  }
template<class _Container >
auto rend ( const _Container &  _Cont) -> decltype(_Cont.rend())
inline
1429  { // get end of reversed sequence
1430  return (_Cont.rend());
1431  }
template<class _Ty , size_t _Size>
reverse_iterator<_Ty *> rend ( _Ty(&)  _Array[_Size])
inline
1443  { // get end of reversed array
1444  return (reverse_iterator<_Ty *>(_Array));
1445  }
Definition: xutility:1158
template<class _Elem >
reverse_iterator<const _Elem *> rend ( _XSTD initializer_list< _Elem >  _Ilist)
inline
1457  { // get end of reversed sequence
1458  return (reverse_iterator<const _Elem *>(_Ilist.begin()));
1459  }
Definition: xutility:1158
template<class _BidIt >
void reverse ( _BidIt  _First,
_BidIt  _Last 
)
inline
3553  { // reverse elements in [_First, _Last)
3554  _DEBUG_RANGE(_First, _Last);
3556  }
#define _DEBUG_RANGE(first, last)
Definition: xutility:822
_Iter _Unchecked(_Iter _Src)
Definition: xutility:426
void _Reverse_unchecked(_BidIt _First, _BidIt _Last)
Definition: xutility:3545
_FwdIt _Last
Definition: algorithm:1936
template<class _FwdIt >
_FwdIt rotate ( _FwdIt  _First,
_FwdIt  _Mid,
_FwdIt  _Last 
)
inline
3624  { // rotate [_First, _Last)
3625  _DEBUG_RANGE(_First, _Mid);
3626  _DEBUG_RANGE(_Mid, _Last);
3627  return (_Rechecked(_First,
3628  _Rotate_unchecked(_Unchecked(_First), _Unchecked(_Mid),
3629  _Unchecked(_Last))));
3630  }
_Iter & _Rechecked(_Iter &_Dest, _UIter _Src)
Definition: xutility:456
_FwdIt _Rotate_unchecked(_FwdIt _First, _FwdIt _Mid, _FwdIt _Last)
Definition: xutility:3613
#define _DEBUG_RANGE(first, last)
Definition: xutility:822
_Iter _Unchecked(_Iter _Src)
Definition: xutility:426
_FwdIt _Last
Definition: algorithm:1936
template<class _Container >
constexpr auto size ( const _Container &  _Cont) -> decltype(_Cont.size())
inline
1480  { // get size() for container
1481  return (_Cont.size());
1482  }
template<class _Ty , size_t _Size>
constexpr size_t size ( const   _Ty(&)[_Size])
inline
1487  { // get dimension for array
1488  return (_Size);
1489  }
_Size
Definition: vcruntime_string.h:36

Variable Documentation

template<class _Iter >
_Is_checked_helper<_Iter>::type _Is_checked(_Iter)
inline
420  { // return type is true_type if iterator is checked
421  return {};
422  }
constexpr allocator_arg_t allocator_arg {}