STLdoc
STLdocumentation
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
Namespaces | Classes | Functions | Variables
cliext Namespace Reference

Namespaces

 impl
 

Classes

class  _Binary_fun
 
class  _Binary_fun_noreturn
 
class  _Cont_make_value
 
class  _Cont_make_value< _Value_t, true >
 
class  _Container_traits
 
class  _Container_traits< _Cont_t^>
 
class  _Dehandle
 
class  _Dehandle< _Value_t^>
 
class  _Fix_handle
 
class  _Fix_handle< _To_t, _From_t^>
 
class  _Fix_handle< _To_t^, _From_t >
 
class  _Fix_handle< _To_t^, _From_t^>
 
class  _Generic_type
 
class  _Generic_type< _Value_t, false >
 
class  _Generic_type< _Value_t, true >
 
class  _Int_iterator_tag
 
class  _ISort
 
class  _Map_iter_cat
 
class  _Map_iter_cat< std::bidirectional_iterator_tag >
 
class  _Map_iter_cat< std::forward_iterator_tag >
 
class  _Map_iter_cat< std::input_iterator_tag >
 
class  _Map_iter_cat< std::output_iterator_tag >
 
class  _Map_iter_cat< std::random_access_iterator_tag >
 
class  _Pick_pair
 
class  _Pick_pair< false, _Value1_t, _Value2_t >
 
class  _Pick_pair< true, _Value1_t, _Value2_t >
 
class  _Pick_tbuf
 
class  _Pick_tbuf< false, _Value_t >
 
class  _Pick_tbuf< true, _Value_t >
 
class  _Temp_gc_iterator
 
class  _Temp_iterator
 
class  _Unary_fun
 
class  _Unary_fun_noreturn
 
class  ArrayContainer
 
class  BCL_iterator
 
class  BCL_reference
 
class  BCL_reference_base
 
class  BCL_reference_base< _Cont_t, true >
 
class  bidirectional_iterator_tag
 
class  BidirectionalIterator
 
class  binary_function
 
class  binary_negate
 
class  binder1st
 
class  binder2nd
 
class  collection_adapter
 
class  collection_adapter< System::Collections::Generic::ICollection< _Value_t > >
 
class  collection_adapter< System::Collections::Generic::IDictionary< _Key_t, _Mapped_t > >
 
class  collection_adapter< System::Collections::Generic::IEnumerable< _Value_t > >
 
class  collection_adapter< System::Collections::Generic::IList< _Value_t > >
 
class  collection_adapter< System::Collections::ICollection >
 
class  collection_adapter< System::Collections::IDictionary >
 
class  collection_adapter< System::Collections::IEnumerable >
 
class  collection_adapter< System::Collections::IList >
 
class  comparer_less
 
class  ConstBidirectionalIterator
 
class  ConstRandomAccessIterator
 
class  ConstUncheckedBidirectionalIterator
 
class  ConstUncheckedRandomAccessIterator
 
class  deque
 
class  divides
 
class  Enum_iterator
 
class  equal_to
 
class  forward_iterator_tag
 
class  greater
 
class  greater_equal
 
class  hash_map
 
class  hash_multimap
 
class  hash_multiset
 
class  hash_set
 
class  input_iterator_tag
 
class  is_handle
 
class  is_handle< _Value_t^>
 
class  iterator_traits
 
class  iterator_traits< __int64 >
 
class  iterator_traits< _Iter_t^>
 
class  iterator_traits< _STLCLR Generic::ConstContainerBidirectionalIterator< _Ty > >
 
class  iterator_traits< _STLCLR Generic::ConstContainerRandomAccessIterator< _Ty > >
 
class  iterator_traits< _STLCLR Generic::ConstReverseBidirectionalIterator< _Ty > >
 
class  iterator_traits< _STLCLR Generic::ConstReverseRandomAccessIterator< _Ty > >
 
class  iterator_traits< _STLCLR Generic::ContainerBidirectionalIterator< _Ty > >
 
class  iterator_traits< _STLCLR Generic::ContainerRandomAccessIterator< _Ty > >
 
class  iterator_traits< _STLCLR Generic::IBidirectionalIterator< _Ty > >
 
class  iterator_traits< _STLCLR Generic::IForwardIterator< _Ty > >
 
class  iterator_traits< _STLCLR Generic::IInputIterator< _Ty > >
 
class  iterator_traits< _STLCLR Generic::IOutputIterator< _Ty > >
 
class  iterator_traits< _STLCLR Generic::IRandomAccessIterator< _Ty > >
 
class  iterator_traits< _STLCLR Generic::ReverseBidirectionalIterator< _Ty > >
 
class  iterator_traits< _STLCLR Generic::ReverseRandomAccessIterator< _Ty > >
 
class  iterator_traits< _Ty * >
 
class  iterator_traits< bool >
 
class  iterator_traits< char >
 
class  iterator_traits< const _Ty * >
 
class  iterator_traits< int >
 
class  iterator_traits< long >
 
class  iterator_traits< short >
 
class  iterator_traits< signed char >
 
class  iterator_traits< unsigned __int64 >
 
class  iterator_traits< unsigned char >
 
class  iterator_traits< unsigned int >
 
class  iterator_traits< unsigned long >
 
class  iterator_traits< unsigned short >
 
class  iterator_traits< wchar_t >
 
class  less
 
class  less_equal
 
class  light_pair
 
class  list
 
class  logical_and
 
class  logical_not
 
class  logical_or
 
class  map
 
class  minus
 
class  modulus
 
class  multimap
 
class  multiplies
 
class  multiset
 
class  negate
 
class  not_equal_to
 
class  output_iterator_tag
 
class  pair
 
class  plus
 
class  priority_queue
 
class  queue
 
class  random_access_iterator_tag
 
class  RandomAccessIterator
 
class  range_adapter
 
class  ref_binary_negate
 
class  ref_binder1st
 
class  ref_binder2nd
 
class  ref_divides
 
class  ref_equal_to
 
class  ref_greater
 
class  ref_greater_equal
 
class  ref_less
 
class  ref_less_equal
 
class  ref_logical_and
 
class  ref_logical_not
 
class  ref_logical_or
 
class  ref_minus
 
class  ref_modulus
 
class  ref_multiplies
 
class  ref_negate
 
class  ref_not_equal_to
 
class  ref_plus
 
class  ref_unary_negate
 
class  ReverseBidirectionalIterator
 
class  ReverseRandomAccessIterator
 
class  select_pair
 
class  select_pair< _Value1_t, _Value2_t, false >
 
class  set
 
class  stack
 
class  unary_function
 
class  unary_negate
 
class  UncheckedBCL_iterator
 
class  UncheckedBidirectionalIterator
 
class  UncheckedRandomAccessIterator
 
class  vector
 

Functions

template<typename _Iter_t >
range_adapter< _Iter_t > make_collection (_Iter_t _First, _Iter_t _Last)
 
template<class _InIt , class _Fn1 >
_Fn1 for_each_unchecked (_InIt _First, _InIt _Last, _Fn1 _Func)
 
template<class _InIt , class _Fn1 >
_Fn1 for_each (_InIt _First, _InIt _Last, _Fn1 _Func)
 
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)
 
const char * find (const char *_First, const char *_Last, int _Val)
 
const signed char * find (const signed char *_First, const signed char *_Last, int _Val)
 
const unsigned char * find (const unsigned char *_First, const unsigned char *_Last, int _Val)
 
template<class _InIt , class _Pr >
_InIt find_if_unchecked (_InIt _First, _InIt _Last, _Pr _Pred)
 
template<class _InIt , class _Pr >
_InIt find_if (_InIt _First, _InIt _Last, _Pr _Pred)
 
template<class _FwdIt >
_FwdIt adjacent_find_unchecked (_FwdIt _First, _FwdIt _Last)
 
template<class _FwdIt >
_FwdIt adjacent_find (_FwdIt _First, _FwdIt _Last)
 
template<class _FwdIt , class _Pr >
_FwdIt adjacent_find_unchecked (_FwdIt _First, _FwdIt _Last, _Pr _Pred)
 
template<class _FwdIt , class _Pr >
_FwdIt adjacent_find (_FwdIt _First, _FwdIt _Last, _Pr _Pred)
 
template<class _InIt , class _Ty >
iterator_traits< _InIt >::difference_type count_unchecked (_InIt _First, _InIt _Last, const _Ty%_Val)
 
template<class _InIt , class _Ty >
iterator_traits< _InIt >::difference_type count (_InIt _First, _InIt _Last, const _Ty%_Val)
 
template<class _InIt , class _Pr >
iterator_traits< _InIt >::difference_type count_if_unchecked (_InIt _First, _InIt _Last, _Pr _Pred)
 
template<class _InIt , class _Pr >
iterator_traits< _InIt >::difference_type count_if (_InIt _First, _InIt _Last, _Pr _Pred)
 
template<class _FwdIt1 , class _FwdIt2 >
_FwdIt1 search_unchecked (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2)
 
template<class _FwdIt1 , class _FwdIt2 >
_FwdIt1 search (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2)
 
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
_FwdIt1 search_unchecked (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred)
 
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
_FwdIt1 search (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred)
 
template<class _FwdIt1 , class _Diff2 , class _Ty >
_FwdIt1 _Search_n (_FwdIt1 _First1, _FwdIt1 _Last1, _Diff2 _Count, const _Ty%_Val, forward_iterator_tag)
 
template<class _FwdIt1 , class _Diff2 , class _Ty >
_FwdIt1 _Search_n (_FwdIt1 _First1, _FwdIt1 _Last1, _Diff2 _Count, const _Ty%_Val, random_access_iterator_tag)
 
template<class _FwdIt1 , class _Diff2 , class _Ty >
_FwdIt1 search_n (_FwdIt1 _First1, _FwdIt1 _Last1, _Diff2 _Count, const _Ty%_Val)
 
template<class _FwdIt1 , class _Diff2 , class _Ty , class _Pr >
_FwdIt1 _Search_n (_FwdIt1 _First1, _FwdIt1 _Last1, _Diff2 _Count, const _Ty%_Val, _Pr _Pred, forward_iterator_tag)
 
template<class _FwdIt1 , class _Diff2 , class _Ty , class _Pr >
_FwdIt1 _Search_n (_FwdIt1 _First1, _FwdIt1 _Last1, _Diff2 _Count, const _Ty%_Val, _Pr _Pred, random_access_iterator_tag)
 
template<class _FwdIt1 , class _Diff2 , class _Ty , class _Pr >
_FwdIt1 search_n (_FwdIt1 _First1, _FwdIt1 _Last1, _Diff2 _Count, const _Ty%_Val, _Pr _Pred)
 
template<class _FwdIt1 , class _FwdIt2 >
_FwdIt1 find_end_unchecked (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2)
 
template<class _FwdIt1 , class _FwdIt2 >
_FwdIt1 find_end (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2)
 
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
_FwdIt1 find_end_unchecked (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred)
 
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
_FwdIt1 find_end (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred)
 
template<class _FwdIt1 , class _FwdIt2 >
_FwdIt1 find_first_of_unchecked (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2)
 
template<class _FwdIt1 , class _FwdIt2 >
_FwdIt1 find_first_of (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2)
 
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
_FwdIt1 find_first_of_unchecked (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred)
 
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
_FwdIt1 find_first_of (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred)
 
template<class _FwdIt1 , class _FwdIt2 >
void iter_swap (_FwdIt1 _Left, _FwdIt2 _Right)
 
template<class _FwdIt1 , class _FwdIt2 >
_FwdIt2 swap_ranges_unchecked (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2)
 
template<class _FwdIt1 , class _FwdIt2 >
_FwdIt2 swap_ranges (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2)
 
template<class _InIt , class _OutIt , class _Fn1 >
_OutIt transform_unchecked (_InIt _First, _InIt _Last, _OutIt _Dest, _Fn1 _Func)
 
template<class _InIt , class _OutIt , class _Fn1 >
_OutIt transform (_InIt _First, _InIt _Last, _OutIt _Dest, _Fn1 _Func)
 
template<class _InIt1 , class _InIt2 , class _OutIt , class _Fn2 >
_OutIt transform_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _OutIt _Dest, _Fn2 _Func)
 
template<class _InIt1 , class _InIt2 , class _OutIt , class _Fn2 >
_OutIt transform (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _OutIt _Dest, _Fn2 _Func)
 
template<class _FwdIt , class _Ty >
void replace_unchecked (_FwdIt _First, _FwdIt _Last, const _Ty%_Oldval, const _Ty%_Newval)
 
template<class _FwdIt , class _Ty >
void replace (_FwdIt _First, _FwdIt _Last, const _Ty%_Oldval, const _Ty%_Newval)
 
template<class _FwdIt , class _Pr , class _Ty >
void replace_if_unchecked (_FwdIt _First, _FwdIt _Last, _Pr _Pred, const _Ty%_Val)
 
template<class _FwdIt , class _Pr , class _Ty >
void replace_if (_FwdIt _First, _FwdIt _Last, _Pr _Pred, const _Ty%_Val)
 
template<class _InIt , class _OutIt , class _Ty >
_OutIt replace_copy_unchecked (_InIt _First, _InIt _Last, _OutIt _Dest, const _Ty%_Oldval, const _Ty%_Newval)
 
template<class _InIt , class _OutIt , class _Ty >
_OutIt replace_copy (_InIt _First, _InIt _Last, _OutIt _Dest, const _Ty%_Oldval, const _Ty%_Newval)
 
template<class _InIt , class _OutIt , class _Pr , class _Ty >
_OutIt replace_copy_if_unchecked (_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred, const _Ty%_Val)
 
template<class _InIt , class _OutIt , class _Pr , class _Ty >
_OutIt replace_copy_if (_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred, const _Ty%_Val)
 
template<class _FwdIt , class _Fn0 >
void generate_unchecked (_FwdIt _First, _FwdIt _Last, _Fn0 _Func)
 
template<class _FwdIt , class _Fn0 >
void generate (_FwdIt _First, _FwdIt _Last, _Fn0 _Func)
 
template<class _OutIt , class _Diff , class _Fn0 >
void generate_n_unchecked (_OutIt _Dest, _Diff _Count, _Fn0 _Func)
 
template<class _OutIt , class _Diff , class _Fn0 >
void generate_n (_OutIt _Dest, _Diff _Count, _Fn0 _Func)
 
template<class _InIt , class _OutIt , class _Ty >
_OutIt remove_copy_unchecked (_InIt _First, _InIt _Last, _OutIt _Dest, const _Ty%_Val)
 
template<class _InIt , class _OutIt , class _Ty >
_OutIt remove_copy (_InIt _First, _InIt _Last, _OutIt _Dest, const _Ty%_Val)
 
template<class _InIt , class _OutIt , class _Pr >
_OutIt remove_copy_if_unchecked (_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred)
 
template<class _InIt , class _OutIt , class _Pr >
_OutIt remove_copy_if (_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred)
 
template<class _FwdIt , class _Ty >
_FwdIt remove_unchecked (_FwdIt _First, _FwdIt _Last, const _Ty%_Val)
 
template<class _FwdIt , class _Ty >
_FwdIt remove (_FwdIt _First, _FwdIt _Last, const _Ty%_Val)
 
template<class _FwdIt , class _Pr >
_FwdIt remove_if_unchecked (_FwdIt _First, _FwdIt _Last, _Pr _Pred)
 
template<class _FwdIt , class _Pr >
_FwdIt remove_if (_FwdIt _First, _FwdIt _Last, _Pr _Pred)
 
template<class _FwdIt >
_FwdIt unique_unchecked (_FwdIt _First, _FwdIt _Last)
 
template<class _FwdIt >
_FwdIt unique (_FwdIt _First, _FwdIt _Last)
 
template<class _FwdIt , class _Pr >
_FwdIt unique_unchecked (_FwdIt _First, _FwdIt _Last, _Pr _Pred)
 
template<class _FwdIt , class _Pr >
_FwdIt unique (_FwdIt _First, _FwdIt _Last, _Pr _Pred)
 
template<class _InIt , class _OutIt >
_OutIt _Unique_copy (_InIt _First, _InIt _Last, _OutIt _Dest, input_iterator_tag)
 
template<class _FwdIt , class _OutIt >
_OutIt _Unique_copy (_FwdIt _First, _FwdIt _Last, _OutIt _Dest, forward_iterator_tag)
 
template<class _BidIt , class _OutIt >
_OutIt _Unique_copy (_BidIt _First, _BidIt _Last, _OutIt _Dest, bidirectional_iterator_tag)
 
template<class _RanIt , class _OutIt >
_OutIt _Unique_copy (_RanIt _First, _RanIt _Last, _OutIt _Dest, random_access_iterator_tag)
 
template<class _InIt , class _OutIt >
_OutIt unique_copy_unchecked (_InIt _First, _InIt _Last, _OutIt _Dest)
 
template<class _InIt , class _OutIt >
_OutIt unique_copy (_InIt _First, _InIt _Last, _OutIt _Dest)
 
template<class _InIt , class _OutIt , class _Pr >
_OutIt _Unique_copy (_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred, input_iterator_tag)
 
template<class _FwdIt , class _OutIt , class _Pr >
_OutIt _Unique_copy (_FwdIt _First, _FwdIt _Last, _OutIt _Dest, _Pr _Pred, forward_iterator_tag)
 
template<class _BidIt , class _OutIt , class _Pr >
_OutIt _Unique_copy (_BidIt _First, _BidIt _Last, _OutIt _Dest, _Pr _Pred, bidirectional_iterator_tag)
 
template<class _RanIt , class _OutIt , class _Pr >
_OutIt _Unique_copy (_RanIt _First, _RanIt _Last, _OutIt _Dest, _Pr _Pred, random_access_iterator_tag)
 
template<class _InIt , class _OutIt , class _Pr >
_OutIt unique_copy_unchecked (_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred)
 
template<class _InIt , class _OutIt , class _Pr >
_OutIt unique_copy (_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred)
 
template<class _BidIt >
void _Reverse (_BidIt _First, _BidIt _Last, bidirectional_iterator_tag)
 
template<class _RanIt >
void _Reverse (_RanIt _First, _RanIt _Last, random_access_iterator_tag)
 
template<class _BidIt >
void reverse_unchecked (_BidIt _First, _BidIt _Last)
 
template<class _BidIt >
void reverse (_BidIt _First, _BidIt _Last)
 
template<class _BidIt , class _OutIt >
_OutIt reverse_copy_unchecked (_BidIt _First, _BidIt _Last, _OutIt _Dest)
 
template<class _BidIt , class _OutIt >
_OutIt reverse_copy (_BidIt _First, _BidIt _Last, _OutIt _Dest)
 
template<class _FwdIt >
void _Rotate (_FwdIt _First, _FwdIt _Mid, _FwdIt _Last, forward_iterator_tag)
 
template<class _BidIt >
void _Rotate (_BidIt _First, _BidIt _Mid, _BidIt _Last, bidirectional_iterator_tag)
 
template<class _RanIt >
void _Rotate (_RanIt _First, _RanIt _Mid, _RanIt _Last, random_access_iterator_tag)
 
template<class _FwdIt >
void rotate_unchecked (_FwdIt _First, _FwdIt _Mid, _FwdIt _Last)
 
template<class _FwdIt >
void rotate (_FwdIt _First, _FwdIt _Mid, _FwdIt _Last)
 
template<class _FwdIt , class _OutIt >
_OutIt rotate_copy_unchecked (_FwdIt _First, _FwdIt _Mid, _FwdIt _Last, _OutIt _Dest)
 
template<class _FwdIt , class _OutIt >
_OutIt rotate_copy (_FwdIt _First, _FwdIt _Mid, _FwdIt _Last, _OutIt _Dest)
 
int _Rand (void)
 
template<class _RanIt >
void random_shuffle_unchecked (_RanIt _First, _RanIt _Last)
 
template<class _RanIt >
void random_shuffle (_RanIt _First, _RanIt _Last)
 
template<class _RanIt , class _Fn1 >
void random_shuffle_unchecked (_RanIt _First, _RanIt _Last, _Fn1%_Func)
 
template<class _RanIt , class _Fn1 >
void random_shuffle (_RanIt _First, _RanIt _Last, _Fn1%_Func)
 
template<class _BidIt , class _Pr >
_BidIt partition_unchecked (_BidIt _First, _BidIt _Last, _Pr _Pred)
 
template<class _BidIt , class _Pr >
_BidIt partition (_BidIt _First, _BidIt _Last, _Pr _Pred)
 
template<class _BidIt , class _Pr , class _Diff , class _Ty >
_BidIt _XStable_partition (_BidIt _First, _BidIt _Last, _Pr _Pred, _Diff _Count, _Temp_iterator< _Ty > _Tempbuf)
 
template<class _BidIt , class _Pr >
_BidIt stable_partition_unchecked (_BidIt _First, _BidIt _Last, _Pr _Pred)
 
template<class _BidIt , class _Pr >
_BidIt stable_partition (_BidIt _First, _BidIt _Last, _Pr _Pred)
 
template<class _RanIt , class _Diff , class _Ty >
void _XPush_heap (_RanIt _First, _Diff _Hole, _Diff _Top, _Ty _Val)
 
template<class _RanIt >
void push_heap_unchecked (_RanIt _First, _RanIt _Last)
 
template<class _RanIt >
void push_heap (_RanIt _First, _RanIt _Last)
 
template<class _RanIt , class _Diff , class _Ty , class _Pr >
void _XPush_heap (_RanIt _First, _Diff _Hole, _Diff _Top, _Ty _Val, _Pr _Pred)
 
template<class _RanIt , class _Pr >
void push_heap_unchecked (_RanIt _First, _RanIt _Last, _Pr _Pred)
 
template<class _RanIt , class _Pr >
void push_heap (_RanIt _First, _RanIt _Last, _Pr _Pred)
 
template<class _RanIt , class _Diff , class _Ty >
void _XAdjust_heap (_RanIt _First, _Diff _Hole, _Diff _Bottom, _Ty _Val)
 
template<class _RanIt , class _Ty >
void _XPop_heap (_RanIt _First, _RanIt _Last, _RanIt _Dest, _Ty _Val)
 
template<class _RanIt >
void pop_heap_unchecked (_RanIt _First, _RanIt _Last)
 
template<class _RanIt >
void pop_heap (_RanIt _First, _RanIt _Last)
 
template<class _RanIt , class _Diff , class _Ty , class _Pr >
void _XAdjust_heap (_RanIt _First, _Diff _Hole, _Diff _Bottom, _Ty _Val, _Pr _Pred)
 
template<class _RanIt , class _Ty , class _Pr >
void _XPop_heap (_RanIt _First, _RanIt _Last, _RanIt _Dest, _Ty _Val, _Pr _Pred)
 
template<class _RanIt , class _Pr >
void pop_heap_unchecked (_RanIt _First, _RanIt _Last, _Pr _Pred)
 
template<class _RanIt , class _Pr >
void pop_heap (_RanIt _First, _RanIt _Last, _Pr _Pred)
 
template<class _RanIt >
void make_heap_unchecked (_RanIt _First, _RanIt _Last)
 
template<class _RanIt >
void make_heap (_RanIt _First, _RanIt _Last)
 
template<class _RanIt , class _Pr >
void make_heap_unchecked (_RanIt _First, _RanIt _Last, _Pr _Pred)
 
template<class _RanIt , class _Pr >
void make_heap (_RanIt _First, _RanIt _Last, _Pr _Pred)
 
template<class _RanIt >
void sort_heap_unchecked (_RanIt _First, _RanIt _Last)
 
template<class _RanIt >
void sort_heap (_RanIt _First, _RanIt _Last)
 
template<class _RanIt , class _Pr >
void sort_heap_unchecked (_RanIt _First, _RanIt _Last, _Pr _Pred)
 
template<class _RanIt , class _Pr >
void sort_heap (_RanIt _First, _RanIt _Last, _Pr _Pred)
 
template<class _FwdIt , class _Ty >
_FwdIt lower_bound_unchecked (_FwdIt _First, _FwdIt _Last, _Ty%_Val)
 
template<class _FwdIt , class _Ty >
_FwdIt lower_bound (_FwdIt _First, _FwdIt _Last, _Ty%_Val)
 
template<class _FwdIt , class _Ty , class _Pr >
_FwdIt lower_bound_unchecked (_FwdIt _First, _FwdIt _Last, const _Ty%_Val, _Pr _Pred)
 
template<class _FwdIt , class _Ty , class _Pr >
_FwdIt lower_bound (_FwdIt _First, _FwdIt _Last, const _Ty%_Val, _Pr _Pred)
 
template<class _FwdIt , class _Ty >
_FwdIt upper_bound_unchecked (_FwdIt _First, _FwdIt _Last, const _Ty%_Val)
 
template<class _FwdIt , class _Ty >
_FwdIt upper_bound (_FwdIt _First, _FwdIt _Last, const _Ty%_Val)
 
template<class _FwdIt , class _Ty , class _Pr >
_FwdIt upper_bound_unchecked (_FwdIt _First, _FwdIt _Last, const _Ty%_Val, _Pr _Pred)
 
template<class _FwdIt , class _Ty , class _Pr >
_FwdIt upper_bound (_FwdIt _First, _FwdIt _Last, const _Ty%_Val, _Pr _Pred)
 
template<class _FwdIt , class _Ty >
 _PAIR_TYPE (_FwdIt) equal_range_unchecked(_FwdIt _First
 
 _Iter_distance (_First, _Last, _Count)
 
 for (;0< _Count;)
 
 return (_PAIR_TYPE(_FwdIt)(_First, _First))
 
 return (cliext::equal_range_unchecked(_Unchecked(_First), _Unchecked(_Last), _Val))
 
template<class _FwdIt , class _Ty , class _Pr >
 _PAIR_TYPE (_FwdIt) equal_range_unchecked(_FwdIt _First
 
 return (cliext::equal_range_unchecked(_Unchecked(_First), _Unchecked(_Last), _Val, _Pred))
 
template<class _FwdIt , class _Ty >
bool binary_search_unchecked (_FwdIt _First, _FwdIt _Last, const _Ty%_Val)
 
template<class _FwdIt , class _Ty >
bool binary_search (_FwdIt _First, _FwdIt _Last, const _Ty%_Val)
 
template<class _FwdIt , class _Ty , class _Pr >
bool binary_search_unchecked (_FwdIt _First, _FwdIt _Last, const _Ty%_Val, _Pr _Pred)
 
template<class _FwdIt , class _Ty , class _Pr >
bool binary_search (_FwdIt _First, _FwdIt _Last, const _Ty%_Val, _Pr _Pred)
 
template<class _InIt1 , class _InIt2 , class _OutIt >
_OutIt merge_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
 
template<class _InIt1 , class _InIt2 , class _OutIt >
_OutIt merge (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
 
template<class _InIt1 , class _InIt2 , class _OutIt , class _Pr >
_OutIt merge_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred)
 
template<class _InIt1 , class _InIt2 , class _OutIt , class _Pr >
_OutIt merge (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred)
 
template<class _BidIt , class _Diff , class _Ty >
_BidIt _XBuffered_rotate (_BidIt _First, _BidIt _Mid, _BidIt _Last, _Diff _Count1, _Diff _Count2, _Temp_iterator< _Ty > _Tempbuf)
 
template<class _BidIt1 , class _BidIt2 , class _BidIt3 >
_BidIt3 _XMerge_backward (_BidIt1 _First1, _BidIt1 _Last1, _BidIt2 _First2, _BidIt2 _Last2, _BidIt3 _Dest)
 
template<class _BidIt , class _Diff , class _Ty >
void _XBuffered_merge (_BidIt _First, _BidIt _Mid, _BidIt _Last, _Diff _Count1, _Diff _Count2, _Temp_iterator< _Ty > _Tempbuf)
 
template<class _BidIt >
void inplace_merge_unchecked (_BidIt _First, _BidIt _Mid, _BidIt _Last)
 
template<class _BidIt >
void inplace_merge (_BidIt _First, _BidIt _Mid, _BidIt _Last)
 
template<class _BidIt1 , class _BidIt2 , class _BidIt3 , class _Pr >
_BidIt3 _XMerge_backward (_BidIt1 _First1, _BidIt1 _Last1, _BidIt2 _First2, _BidIt2 _Last2, _BidIt3 _Dest, _Pr _Pred)
 
template<class _BidIt , class _Diff , class _Ty , class _Pr >
void _XBuffered_merge (_BidIt _First, _BidIt _Mid, _BidIt _Last, _Diff _Count1, _Diff _Count2, _Temp_iterator< _Ty > _Tempbuf, _Pr _Pred)
 
template<class _BidIt , class _Pr >
void inplace_merge_unchecked (_BidIt _First, _BidIt _Mid, _BidIt _Last, _Pr _Pred)
 
template<class _BidIt , class _Pr >
void inplace_merge (_BidIt _First, _BidIt _Mid, _BidIt _Last, _Pr _Pred)
 
template<class _BidIt >
void _XInsertion_sort (_BidIt _First, _BidIt _Last)
 
template<class _RanIt >
void _XMed3 (_RanIt _First, _RanIt _Mid, _RanIt _Last)
 
template<class _RanIt >
void _XMedian (_RanIt _First, _RanIt _Mid, _RanIt _Last)
 
template<class _RanIt >
 _PAIR_TYPE (_RanIt) _XUnguarded_partition(_RanIt _First
 
 while (_First< _Pfirst &&!_STLCLRDB_LT(*(_Pfirst-1),*_Pfirst)&&!(*_Pfirst< *(_Pfirst-1)))--_Pfirst
 
 for (;;)
 
template<class _RanIt , class _Diff >
void _XSort (_RanIt _First, _RanIt _Last, _Diff _Ideal)
 
template<class _RanIt >
void sort_unchecked (_RanIt _First, _RanIt _Last)
 
template<class _RanIt >
void sort (_RanIt _First, _RanIt _Last)
 
template<class _BidIt , class _Pr >
void _XInsertion_sort (_BidIt _First, _BidIt _Last, _Pr _Pred)
 
template<class _RanIt , class _Pr >
void _XMed3 (_RanIt _First, _RanIt _Mid, _RanIt _Last, _Pr _Pred)
 
template<class _RanIt , class _Pr >
void _XMedian (_RanIt _First, _RanIt _Mid, _RanIt _Last, _Pr _Pred)
 
template<class _RanIt , class _Pr >
 _PAIR_TYPE (_RanIt) _XUnguarded_partition(_RanIt _First
 
template<class _RanIt , class _Diff , class _Pr >
void _XSort (_RanIt _First, _RanIt _Last, _Diff _Ideal, _Pr _Pred)
 
template<class _RanIt , class _Pr >
void sort_unchecked (_RanIt _First, _RanIt _Last, _Pr _Pred)
 
template<class _RanIt , class _Pr >
void sort (_RanIt _First, _RanIt _Last, _Pr _Pred)
 
template<class _BidIt , class _OutIt , class _Diff >
void _XChunked_merge (_BidIt _First, _BidIt _Last, _OutIt _Dest, _Diff _Chunk, _Diff _Count)
 
template<class _BidIt , class _Diff , class _Ty >
void _XBuffered_merge_sort (_BidIt _First, _BidIt _Last, _Diff _Count, _Temp_iterator< _Ty > _Tempbuf)
 
template<class _BidIt , class _Diff , class _Ty >
void _XStable_sort (_BidIt _First, _BidIt _Last, _Diff _Count, _Temp_iterator< _Ty > _Tempbuf)
 
template<class _BidIt >
void stable_sort_unchecked (_BidIt _First, _BidIt _Last)
 
template<class _BidIt >
void stable_sort (_BidIt _First, _BidIt _Last)
 
template<class _BidIt , class _OutIt , class _Diff , class _Pr >
void _XChunked_merge (_BidIt _First, _BidIt _Last, _OutIt _Dest, _Diff _Chunk, _Diff _Count, _Pr _Pred)
 
template<class _BidIt , class _Diff , class _Ty , class _Pr >
void _XBuffered_merge_sort (_BidIt _First, _BidIt _Last, _Diff _Count, _Temp_iterator< _Ty > _Tempbuf, _Pr _Pred)
 
template<class _BidIt , class _Diff , class _Ty , class _Pr >
void _XStable_sort (_BidIt _First, _BidIt _Last, _Diff _Count, _Temp_iterator< _Ty > _Tempbuf, _Pr _Pred)
 
template<class _BidIt , class _Pr >
void stable_sort_unchecked (_BidIt _First, _BidIt _Last, _Pr _Pred)
 
template<class _BidIt , class _Pr >
void stable_sort (_BidIt _First, _BidIt _Last, _Pr _Pred)
 
template<class _RanIt >
void partial_sort_unchecked (_RanIt _First, _RanIt _Mid, _RanIt _Last)
 
template<class _RanIt >
void partial_sort (_RanIt _First, _RanIt _Mid, _RanIt _Last)
 
template<class _RanIt , class _Pr >
void partial_sort_unchecked (_RanIt _First, _RanIt _Mid, _RanIt _Last, _Pr _Pred)
 
template<class _RanIt , class _Pr >
void partial_sort (_RanIt _First, _RanIt _Mid, _RanIt _Last, _Pr _Pred)
 
template<class _InIt , class _RanIt >
_RanIt partial_sort_copy_unchecked (_InIt _First1, _InIt _Last1, _RanIt _First2, _RanIt _Last2)
 
template<class _InIt , class _RanIt >
_RanIt partial_sort_copy (_InIt _First1, _InIt _Last1, _RanIt _First2, _RanIt _Last2)
 
template<class _InIt , class _RanIt , class _Pr >
_RanIt partial_sort_copy_unchecked (_InIt _First1, _InIt _Last1, _RanIt _First2, _RanIt _Last2, _Pr _Pred)
 
template<class _InIt , class _RanIt , class _Pr >
_RanIt partial_sort_copy (_InIt _First1, _InIt _Last1, _RanIt _First2, _RanIt _Last2, _Pr _Pred)
 
template<class _RanIt >
void nth_element_unchecked (_RanIt _First, _RanIt _Nth, _RanIt _Last)
 
template<class _RanIt >
void nth_element (_RanIt _First, _RanIt _Nth, _RanIt _Last)
 
template<class _RanIt , class _Pr >
void nth_element_unchecked (_RanIt _First, _RanIt _Nth, _RanIt _Last, _Pr _Pred)
 
template<class _RanIt , class _Pr >
void nth_element (_RanIt _First, _RanIt _Nth, _RanIt _Last, _Pr _Pred)
 
template<class _InIt1 , class _InIt2 >
bool includes_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2)
 
template<class _InIt1 , class _InIt2 >
bool includes (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2)
 
template<class _InIt1 , class _InIt2 , class _Pr >
bool includes_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _Pr _Pred)
 
template<class _InIt1 , class _InIt2 , class _Pr >
bool includes (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _Pr _Pred)
 
template<class _InIt1 , class _InIt2 , class _OutIt >
_OutIt set_union_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
 
template<class _InIt1 , class _InIt2 , class _OutIt >
_OutIt set_union (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
 
template<class _InIt1 , class _InIt2 , class _OutIt , class _Pr >
_OutIt set_union_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred)
 
template<class _InIt1 , class _InIt2 , class _OutIt , class _Pr >
_OutIt set_union (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred)
 
template<class _InIt1 , class _InIt2 , class _OutIt >
_OutIt set_intersection_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
 
template<class _InIt1 , class _InIt2 , class _OutIt >
_OutIt set_intersection (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
 
template<class _InIt1 , class _InIt2 , class _OutIt , class _Pr >
_OutIt set_intersection_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred)
 
template<class _InIt1 , class _InIt2 , class _OutIt , class _Pr >
_OutIt set_intersection (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred)
 
template<class _InIt1 , class _InIt2 , class _OutIt >
_OutIt set_difference_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
 
template<class _InIt1 , class _InIt2 , class _OutIt >
_OutIt set_difference (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
 
template<class _InIt1 , class _InIt2 , class _OutIt , class _Pr >
_OutIt set_difference_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred)
 
template<class _InIt1 , class _InIt2 , class _OutIt , class _Pr >
_OutIt set_difference (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred)
 
template<class _InIt1 , class _InIt2 , class _OutIt >
_OutIt set_symmetric_difference_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
 
template<class _InIt1 , class _InIt2 , class _OutIt >
_OutIt set_symmetric_difference (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
 
template<class _InIt1 , class _InIt2 , class _OutIt , class _Pr >
_OutIt set_symmetric_difference_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred)
 
template<class _InIt1 , class _InIt2 , class _OutIt , class _Pr >
_OutIt set_symmetric_difference (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred)
 
template<class _FwdIt >
_FwdIt max_element_unchecked (_FwdIt _First, _FwdIt _Last)
 
template<class _FwdIt >
_FwdIt max_element (_FwdIt _First, _FwdIt _Last)
 
template<class _FwdIt , class _Pr >
_FwdIt max_element_unchecked (_FwdIt _First, _FwdIt _Last, _Pr _Pred)
 
template<class _FwdIt , class _Pr >
_FwdIt max_element (_FwdIt _First, _FwdIt _Last, _Pr _Pred)
 
template<class _FwdIt >
_FwdIt min_element_unchecked (_FwdIt _First, _FwdIt _Last)
 
template<class _FwdIt >
_FwdIt min_element (_FwdIt _First, _FwdIt _Last)
 
template<class _FwdIt , class _Pr >
_FwdIt min_element_unchecked (_FwdIt _First, _FwdIt _Last, _Pr _Pred)
 
template<class _FwdIt , class _Pr >
_FwdIt min_element (_FwdIt _First, _FwdIt _Last, _Pr _Pred)
 
template<class _BidIt >
bool next_permutation_unchecked (_BidIt _First, _BidIt _Last)
 
template<class _BidIt >
bool next_permutation (_BidIt _First, _BidIt _Last)
 
template<class _BidIt , class _Pr >
bool next_permutation_unchecked (_BidIt _First, _BidIt _Last, _Pr _Pred)
 
template<class _BidIt , class _Pr >
bool next_permutation (_BidIt _First, _BidIt _Last, _Pr _Pred)
 
template<class _BidIt >
bool prev_permutation_unchecked (_BidIt _First, _BidIt _Last)
 
template<class _BidIt >
bool prev_permutation (_BidIt _First, _BidIt _Last)
 
template<class _BidIt , class _Pr >
bool prev_permutation_unchecked (_BidIt _First, _BidIt _Last, _Pr _Pred)
 
template<class _BidIt , class _Pr >
bool prev_permutation (_BidIt _First, _BidIt _Last, _Pr _Pred)
 
template<typename _Value_t >
bool operator== (deque< _Value_t >%_Left, deque< _Value_t >%_Right)
 
template<typename _Value_t >
bool operator!= (deque< _Value_t >%_Left, deque< _Value_t >%_Right)
 
template<typename _Value_t >
bool operator< (deque< _Value_t >%_Left, deque< _Value_t >%_Right)
 
template<typename _Value_t >
bool operator>= (deque< _Value_t >%_Left, deque< _Value_t >%_Right)
 
template<typename _Value_t >
bool operator> (deque< _Value_t >%_Left, deque< _Value_t >%_Right)
 
template<typename _Value_t >
bool operator<= (deque< _Value_t >%_Left, deque< _Value_t >%_Right)
 
template<typename _Value_t >
void swap (deque< _Value_t >%_Left, deque< _Value_t >%_Right)
 
template<typename TArg , typename TResult >
delegate TResult unary_delegate (TArg)
 
template<typename TArg >
delegate void unary_delegate_noreturn (TArg)
 
template<typename TArg1 , typename TArg2 , typename TResult >
delegate TResult binary_delegate (TArg1, TArg2)
 
template<typename TArg1 , typename TArg2 >
delegate void binary_delegate_noreturn (TArg1, TArg2)
 
template<typename _Fun_t >
unary_negate< _Fun_t > not1 (_Fun_t%_Func)
 
template<typename _Fun_t >
binary_negate< _Fun_t > not2 (_Fun_t%_Func)
 
template<typename _Fun_t , typename _Arg_t >
binder1st< _Fun_t > bind1st (_Fun_t%_Func, _Arg_t _Left)
 
template<typename _Fun_t , typename _Arg_t >
binder2nd< _Fun_t > bind2nd (_Fun_t%_Func, _Arg_t _Right)
 
template<typename _Arg_t >
comparer_less< _Arg_t, System::Collections::Generic::IComparer< _Arg_t > > make_comparer_less (System::Collections::Generic::IComparer< _Arg_t >^_Comp)
 
comparer_less< System::Object^, System::Collections::IComparer > make_comparer_less (System::Collections::IComparer^_Comp)
 
template<typename _Key_t , typename _Mapped_t >
void swap (cliext::hash_map< _Key_t, _Mapped_t >%_Left, cliext::hash_map< _Key_t, _Mapped_t >%_Right)
 
template<typename _Key_t , typename _Mapped_t >
void swap (cliext::hash_multimap< _Key_t, _Mapped_t >%_Left, cliext::hash_multimap< _Key_t, _Mapped_t >%_Right)
 
template<typename _Key_t >
void swap (cliext::hash_set< _Key_t >%_Left, cliext::hash_set< _Key_t >%_Right)
 
template<typename _Key_t >
void swap (cliext::hash_multiset< _Key_t >%_Left, cliext::hash_multiset< _Key_t >%_Right)
 
template<typename _Iter_t >
_Iter_t _Unchecked (_Iter_t _Iter)
 
template<typename _Cont_t >
ConstUncheckedBidirectionalIterator< _Cont_t > _Unchecked (ConstBidirectionalIterator< _Cont_t > _Iter)
 
template<typename _Cont_t >
UncheckedBidirectionalIterator< _Cont_t > _Unchecked (BidirectionalIterator< _Cont_t > _Iter)
 
template<typename _Cont_t >
ReverseBidirectionalIterator< _Cont_t > _Unchecked (ReverseBidirectionalIterator< _Cont_t > _Iter)
 
template<typename _Cont_t >
ConstUncheckedRandomAccessIterator< _Cont_t > _Unchecked (ConstRandomAccessIterator< _Cont_t > _Iter)
 
template<typename _Cont_t >
UncheckedRandomAccessIterator< _Cont_t > _Unchecked (RandomAccessIterator< _Cont_t > _Iter)
 
template<typename _Cont_t >
ReverseRandomAccessIterator< _Cont_t > _Unchecked (ReverseRandomAccessIterator< _Cont_t > _Iter)
 
template<typename _Cont_t , bool _Is_ref>
UncheckedBCL_iterator< _Cont_t, _Is_ref > _Unchecked (BCL_iterator< _Cont_t, _Is_ref > _Iter)
 
template<typename _Iter_t >
System::Object _Iter_container (_Iter_t%_Next)
 
template<typename _Iter_t >
System::Object _Iter_container (_Iter_t^_Next)
 
template<typename _Value_t >
bool operator== (list< _Value_t >%_Left, list< _Value_t >%_Right)
 
template<typename _Value_t >
bool operator!= (list< _Value_t >%_Left, list< _Value_t >%_Right)
 
template<typename _Value_t >
bool operator< (list< _Value_t >%_Left, list< _Value_t >%_Right)
 
template<typename _Value_t >
bool operator>= (list< _Value_t >%_Left, list< _Value_t >%_Right)
 
template<typename _Value_t >
bool operator> (list< _Value_t >%_Left, list< _Value_t >%_Right)
 
template<typename _Value_t >
bool operator<= (list< _Value_t >%_Left, list< _Value_t >%_Right)
 
template<typename _Value_t >
void swap (list< _Value_t >%_Left, list< _Value_t >%_Right)
 
template<typename _Key_t , typename _Mapped_t >
void swap (map< _Key_t, _Mapped_t >%_Left, map< _Key_t, _Mapped_t >%_Right)
 
template<typename _Key_t , typename _Mapped_t >
void swap (multimap< _Key_t, _Mapped_t >%_Left, multimap< _Key_t, _Mapped_t >%_Right)
 
template<class _Ty >
pair< _Ty *, std::ptrdiff_tget_temporary_buffer (std::ptrdiff_t _Count)
 
template<class _Ty >
void return_temporary_buffer (_Ty *_Pbuf)
 
template<class _Ty >
void swap (_Ty%_Left, _Ty%_Right)
 
template<class _InIt , class _OutIt >
_OutIt copy_unchecked (_InIt _First, _InIt _Last, _OutIt _Dest)
 
template<class _InIt , class _OutIt >
_OutIt copy (_InIt _First, _InIt _Last, _OutIt _Dest)
 
template<class _BidIt1 , class _BidIt2 >
_BidIt2 copy_backward_unchecked (_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest)
 
template<class _BidIt1 , class _BidIt2 >
_BidIt2 copy_backward (_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest)
 
template<class _InIt1 , class _InIt2 >
 mismatch_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2)
 
template<class _InIt1 , class _InIt2 >
 mismatch (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2)
 
template<class _InIt1 , class _InIt2 , class _Pr >
 mismatch_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Pr _Pred)
 
template<class _InIt1 , class _InIt2 , class _Pr >
 mismatch (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Pr _Pred)
 
template<class _InIt1 , class _InIt2 >
bool equal_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2)
 
template<class _InIt1 , class _InIt2 >
bool equal (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2)
 
bool equal (const char *_First1, const char *_Last1, const char *_First2)
 
bool equal (const signed char *_First1, const signed char *_Last1, const signed char *_First2)
 
bool equal (const unsigned char *_First1, const unsigned char *_Last1, const unsigned char *_First2)
 
template<class _InIt1 , class _InIt2 , class _Pr >
bool equal_unchecked (_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 _FwdIt , class _Ty >
void fill_unchecked (_FwdIt _First, _FwdIt _Last, const _Ty%_Val)
 
void fill_unchecked (_Out_writes_all_(_Last-_First) char *_First, _In_opt_ char *_Last, int _Val)
 
void fill_unchecked (_Out_writes_all_(_Last-_First) signed char *_First, _In_opt_ signed char *_Last, int _Val)
 
void fill_unchecked (_Out_writes_all_(_Last-_First) unsigned char *_First, _In_opt_ unsigned char *_Last, int _Val)
 
template<class _FwdIt , class _Ty >
void fill (_FwdIt _First, _FwdIt _Last, const _Ty%_Val)
 
template<class _OutIt , class _Diff , class _Ty >
void fill_n_unchecked (_OutIt _First, _Diff _Count, const _Ty%_Val)
 
void fill_n_unchecked (_Out_writes_all_(_Count) char *_First, size_t _Count, int _Val)
 
void fill_n_unchecked (_Out_writes_all_(_Count) signed char *_First, size_t _Count, int _Val)
 
void fill_n_unchecked (_Out_writes_all_(_Count) unsigned char *_First, size_t _Count, int _Val)
 
template<class _OutIt , class _Diff , class _Ty >
void fill_n (_OutIt _First, _Diff _Count, const _Ty%_Val)
 
template<class _InIt1 , class _InIt2 >
bool lexicographical_compare_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2)
 
bool lexicographical_compare_unchecked (const unsigned char *_First1, const unsigned char *_Last1, const unsigned char *_First2, const unsigned char *_Last2)
 
bool lexicographical_compare_unchecked (const char *_First1, const char *_Last1, const char *_First2, const char *_Last2)
 
template<class _InIt1 , class _InIt2 >
bool lexicographical_compare (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2)
 
template<class _InIt1 , class _InIt2 , class _Pr >
bool lexicographical_compare_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 _Ty >
const _Ty() max (const _Ty%_Left, const _Ty%_Right)
 
template<class _Ty , class _Pr >
const _Ty() max (const _Ty%_Left, const _Ty%_Right, _Pr _Pred)
 
template<class _Ty >
const _Ty() min (const _Ty%_Left, const _Ty%_Right)
 
template<class _Ty , class _Pr >
const _Ty() min (const _Ty%_Left, const _Ty%_Right, _Pr _Pred)
 
template<class _InIt , class _Ty >
_Ty accumulate_unchecked (_InIt _First, _InIt _Last, _Ty _Val)
 
template<class _InIt , class _Ty >
_Ty accumulate (_InIt _First, _InIt _Last, _Ty _Val)
 
template<class _InIt , class _Ty , class _Fn2 >
_Ty accumulate_unchecked (_InIt _First, _InIt _Last, _Ty _Val, _Fn2 _Func)
 
template<class _InIt , class _Ty , class _Fn2 >
_Ty accumulate (_InIt _First, _InIt _Last, _Ty _Val, _Fn2 _Func)
 
template<class _InIt1 , class _InIt2 , class _Ty >
_Ty inner_product_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Ty _Val)
 
template<class _InIt1 , class _InIt2 , class _Ty >
_Ty inner_product (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Ty _Val)
 
template<class _InIt1 , class _InIt2 , class _Ty , class _Fn21 , class _Fn22 >
_Ty inner_product_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Ty _Val, _Fn21 _Func1, _Fn22 _Func2)
 
template<class _InIt1 , class _InIt2 , class _Ty , class _Fn21 , class _Fn22 >
_Ty inner_product (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Ty _Val, _Fn21 _Func1, _Fn22 _Func2)
 
template<class _InIt , class _OutIt >
_OutIt partial_sum_unchecked (_InIt _First, _InIt _Last, _OutIt _Dest)
 
template<class _InIt , class _OutIt >
_OutIt partial_sum (_InIt _First, _InIt _Last, _OutIt _Dest)
 
template<class _InIt , class _OutIt , class _Fn2 >
_OutIt partial_sum_unchecked (_InIt _First, _InIt _Last, _OutIt _Dest, _Fn2 _Func)
 
template<class _InIt , class _OutIt , class _Fn2 >
_OutIt partial_sum (_InIt _First, _InIt _Last, _OutIt _Dest, _Fn2 _Func)
 
template<class _InIt , class _OutIt >
_OutIt adjacent_difference_unchecked (_InIt _First, _InIt _Last, _OutIt _Dest)
 
template<class _InIt , class _OutIt >
_OutIt adjacent_difference (_InIt _First, _InIt _Last, _OutIt _Dest)
 
template<class _InIt , class _OutIt , class _Fn2 >
_OutIt adjacent_difference_unchecked (_InIt _First, _InIt _Last, _OutIt _Dest, _Fn2 _Func)
 
template<class _InIt , class _OutIt , class _Fn2 >
_OutIt adjacent_difference (_InIt _First, _InIt _Last, _OutIt _Dest, _Fn2 _Func)
 
template<typename _Value_t , typename _Cont_t >
bool operator== (queue< _Value_t, _Cont_t >%_Left, queue< _Value_t, _Cont_t >%_Right)
 
template<typename _Value_t , typename _Cont_t >
bool operator!= (queue< _Value_t, _Cont_t >%_Left, queue< _Value_t, _Cont_t >%_Right)
 
template<typename _Value_t , typename _Cont_t >
bool operator< (queue< _Value_t, _Cont_t >%_Left, queue< _Value_t, _Cont_t >%_Right)
 
template<typename _Value_t , typename _Cont_t >
bool operator>= (queue< _Value_t, _Cont_t >%_Left, queue< _Value_t, _Cont_t >%_Right)
 
template<typename _Value_t , typename _Cont_t >
bool operator> (queue< _Value_t, _Cont_t >%_Left, queue< _Value_t, _Cont_t >%_Right)
 
template<typename _Value_t , typename _Cont_t >
bool operator<= (queue< _Value_t, _Cont_t >%_Left, queue< _Value_t, _Cont_t >%_Right)
 
template<typename _Key_t >
bool _Queue_compare (_Key_t _Left, _Key_t _Right)
 
bool _Queue_compare (System::String^_Left, System::String^_Right)
 
template<typename _Key_t >
void swap (set< _Key_t >%_Left, set< _Key_t >%_Right)
 
template<typename _Key_t >
void swap (multiset< _Key_t >%_Left, multiset< _Key_t >%_Right)
 
template<typename _Value_t , typename _Cont_t >
bool operator== (stack< _Value_t, _Cont_t >%_Left, stack< _Value_t, _Cont_t >%_Right)
 
template<typename _Value_t , typename _Cont_t >
bool operator!= (stack< _Value_t, _Cont_t >%_Left, stack< _Value_t, _Cont_t >%_Right)
 
template<typename _Value_t , typename _Cont_t >
bool operator< (stack< _Value_t, _Cont_t >%_Left, stack< _Value_t, _Cont_t >%_Right)
 
template<typename _Value_t , typename _Cont_t >
bool operator>= (stack< _Value_t, _Cont_t >%_Left, stack< _Value_t, _Cont_t >%_Right)
 
template<typename _Value_t , typename _Cont_t >
bool operator> (stack< _Value_t, _Cont_t >%_Left, stack< _Value_t, _Cont_t >%_Right)
 
template<typename _Value_t , typename _Cont_t >
bool operator<= (stack< _Value_t, _Cont_t >%_Left, stack< _Value_t, _Cont_t >%_Right)
 
template<class _Ty1 , class _Ty2 >
void swap (pair< _Ty1, _Ty2 >%_Left, pair< _Ty1, _Ty2 >%_Right)
 
template<class _Ty1 , class _Ty2 >
bool operator== (pair< _Ty1, _Ty2 >%_Left, pair< _Ty1, _Ty2 >%_Right)
 
template<class _Ty1 , class _Ty2 >
bool operator!= (pair< _Ty1, _Ty2 >%_Left, pair< _Ty1, _Ty2 >%_Right)
 
template<class _Ty1 , class _Ty2 >
bool operator< (pair< _Ty1, _Ty2 >%_Left, pair< _Ty1, _Ty2 >%_Right)
 
template<class _Ty1 , class _Ty2 >
bool operator> (pair< _Ty1, _Ty2 >%_Left, pair< _Ty1, _Ty2 >%_Right)
 
template<class _Ty1 , class _Ty2 >
bool operator<= (pair< _Ty1, _Ty2 >%_Left, pair< _Ty1, _Ty2 >%_Right)
 
template<class _Ty1 , class _Ty2 >
bool operator>= (pair< _Ty1, _Ty2 >%_Left, pair< _Ty1, _Ty2 >%_Right)
 
template<class _Ty1 , class _Ty2 >
pair< _Ty1, _Ty2 > make_pair (_Ty1 _Val1, _Ty2 _Val2)
 
template<typename _Value_t >
bool operator== (System::IComparable< _Value_t >^_Left, System::IComparable< _Value_t >^_Right)
 
template<typename _Value_t >
bool operator!= (System::IComparable< _Value_t >^_Left, System::IComparable< _Value_t >^_Right)
 
template<typename _Value_t >
bool operator< (System::IComparable< _Value_t >^_Left, System::IComparable< _Value_t >^_Right)
 
template<typename _Value_t >
bool operator>= (System::IComparable< _Value_t >^_Left, System::IComparable< _Value_t >^_Right)
 
template<typename _Value_t >
bool operator> (System::IComparable< _Value_t >^_Left, System::IComparable< _Value_t >^_Right)
 
template<typename _Value_t >
bool operator<= (System::IComparable< _Value_t >^_Left, System::IComparable< _Value_t >^_Right)
 
template<typename _Value_t >
bool operator== (System::IComparable< _Value_t >%_Left, System::IComparable< _Value_t >%_Right)
 
template<typename _Value_t >
bool operator!= (System::IComparable< _Value_t >%_Left, System::IComparable< _Value_t >%_Right)
 
template<typename _Value_t >
bool operator< (System::IComparable< _Value_t >%_Left, System::IComparable< _Value_t >%_Right)
 
template<typename _Value_t >
bool operator>= (System::IComparable< _Value_t >%_Left, System::IComparable< _Value_t >%_Right)
 
template<typename _Value_t >
bool operator> (System::IComparable< _Value_t >%_Left, System::IComparable< _Value_t >%_Right)
 
template<typename _Value_t >
bool operator<= (System::IComparable< _Value_t >%_Left, System::IComparable< _Value_t >%_Right)
 
bool operator== (System::IComparable^_Left, System::IComparable^_Right)
 
bool operator!= (System::IComparable^_Left, System::IComparable^_Right)
 
bool operator< (System::IComparable^_Left, System::IComparable^_Right)
 
bool operator>= (System::IComparable^_Left, System::IComparable^_Right)
 
bool operator> (System::IComparable^_Left, System::IComparable^_Right)
 
bool operator<= (System::IComparable^_Left, System::IComparable^_Right)
 
bool operator== (System::IComparable%_Left, System::IComparable%_Right)
 
bool operator!= (System::IComparable%_Left, System::IComparable%_Right)
 
bool operator< (System::IComparable%_Left, System::IComparable%_Right)
 
bool operator>= (System::IComparable%_Left, System::IComparable%_Right)
 
bool operator> (System::IComparable%_Left, System::IComparable%_Right)
 
bool operator<= (System::IComparable%_Left, System::IComparable%_Right)
 
template<typename _Value_t >
bool operator== (vector< _Value_t >%_Left, vector< _Value_t >%_Right)
 
template<typename _Value_t >
bool operator!= (vector< _Value_t >%_Left, vector< _Value_t >%_Right)
 
template<typename _Value_t >
bool operator< (vector< _Value_t >%_Left, vector< _Value_t >%_Right)
 
template<typename _Value_t >
bool operator>= (vector< _Value_t >%_Left, vector< _Value_t >%_Right)
 
template<typename _Value_t >
bool operator> (vector< _Value_t >%_Left, vector< _Value_t >%_Right)
 
template<typename _Value_t >
bool operator<= (vector< _Value_t >%_Left, vector< _Value_t >%_Right)
 
template<typename _Value_t >
void swap (vector< _Value_t >%_Left, vector< _Value_t >%_Right)
 
template<typename _Key_t >
bool _Hash_key_compare (_Key_t _Left, _Key_t _Right)
 
bool _Hash_key_compare (System::String^_Left, System::String^_Right)
 
int hash_value (System::Object^_Key)
 
template<typename _Traits_t >
void swap (cliext::impl::hash< _Traits_t >%_Left, cliext::impl::hash< _Traits_t >%_Right)
 
template<typename _Traits_t >
bool operator== (cliext::impl::tree< _Traits_t >%_Left, cliext::impl::tree< _Traits_t >%_Right)
 
template<typename _Traits_t >
bool operator!= (cliext::impl::tree< _Traits_t >%_Left, cliext::impl::tree< _Traits_t >%_Right)
 
template<typename _Traits_t >
bool operator< (cliext::impl::tree< _Traits_t >%_Left, cliext::impl::tree< _Traits_t >%_Right)
 
template<typename _Traits_t >
bool operator>= (cliext::impl::tree< _Traits_t >%_Left, cliext::impl::tree< _Traits_t >%_Right)
 
template<typename _Traits_t >
bool operator> (cliext::impl::tree< _Traits_t >%_Left, cliext::impl::tree< _Traits_t >%_Right)
 
template<typename _Traits_t >
bool operator<= (cliext::impl::tree< _Traits_t >%_Left, cliext::impl::tree< _Traits_t >%_Right)
 
template<typename _Traits_t >
void swap (cliext::impl::tree< _Traits_t >%_Left, cliext::impl::tree< _Traits_t >%_Right)
 
template<typename Mycont >
Mycont _Handle_alloc (Mycont^)
 
template<typename _InIt_t , typename _Diff_t >
void _Iter_advance (_InIt_t%_Where, _Diff_t _Off, input_iterator_tag)
 
template<typename _BidIt_t , typename _Diff_t >
void _Iter_advance (_BidIt_t%_Where, _Diff_t _Off, bidirectional_iterator_tag)
 
template<typename _RanIt_t , typename _Diff_t >
void _Iter_advance (_RanIt_t%_Where, _Diff_t _Off, random_access_iterator_tag)
 
template<typename _InIt_t , typename _Diff_t >
void advance (_InIt_t%_Where, _Diff_t _Off)
 
template<typename _InIt_t , typename _Diff_t >
void _Iter_distance2 (_InIt_t _First, _InIt_t _Last, _Diff_t%_Off, input_iterator_tag)
 
template<typename _RanIt_t , typename _Diff_t >
void _Iter_distance2 (_RanIt_t _First, _RanIt_t _Last, _Diff_t%_Off, random_access_iterator_tag)
 
template<typename _InIt_t >
int distance (_InIt_t _First, _InIt_t _Last)
 
template<typename _InIt_t , typename _Diff_t >
void _Iter_distance (_InIt_t _First, _InIt_t _Last, _Diff_t%_Off)
 

Variables

_FwdIt _Last
 
_FwdIt const _Ty _Val
 
_Diff _Count = 0
 
_FwdIt const _Ty _Pr _Pred
 
_RanIt _Pfirst = _Mid
 
_RanIt _Plast = _Pfirst + 1
 
_RanIt _Gfirst = _Plast
 
_RanIt _Glast = _Pfirst
 
template<class _Iter_t >
iterator_traits< _Iter_t >::iterator_category _Iter_category (_Iter_t)
 

Function Documentation

template<typename Mycont >
Mycont cliext::_Handle_alloc ( Mycont^  )
inline
138  { // allocate a container, given its handle type
139  return (gcnew Mycont);
140  }
template<typename _Key_t >
bool cliext::_Hash_key_compare ( _Key_t  _Left,
_Key_t  _Right 
)
inline
13  { // test if _Left <= _Right
14  return (!(_Right < _Left));
15  }
const _Ty & _Right
Definition: algorithm:4087
bool cliext::_Hash_key_compare ( System::String^  _Left,
System::String^  _Right 
)
inline
18  { // test if _Left <= _Right for String
19  return (!(_Right->CompareTo(_Left) < 0));
20  }
const _Ty & _Right
Definition: algorithm:4087
template<typename _InIt_t , typename _Diff_t >
void cliext::_Iter_advance ( _InIt_t%  _Where,
_Diff_t  _Off,
input_iterator_tag   
)
inline
668  { // increment iterator by offset, input iterators
669  for (; 0 < _Off; --_Off)
670  ++_Where;
671  }
template<typename _BidIt_t , typename _Diff_t >
void cliext::_Iter_advance ( _BidIt_t%  _Where,
_Diff_t  _Off,
bidirectional_iterator_tag   
)
inline
677  { // increment iterator by offset, bidirectional iterators
678  for (; 0 < _Off; --_Off)
679  ++_Where;
680  for (; _Off < 0; ++_Off)
681  --_Where;
682  }
template<typename _RanIt_t , typename _Diff_t >
void cliext::_Iter_advance ( _RanIt_t%  _Where,
_Diff_t  _Off,
random_access_iterator_tag   
)
inline
688  { // increment iterator by offset, random-access iterators
689  _Where += _Off;
690  }
template<typename _Iter_t >
System::Object cliext::_Iter_container ( _Iter_t%  _Next)
inline
4249  { // get container for arbitrary iterator
4250  return (_Next.container());
4251  }
template<typename _Iter_t >
System::Object cliext::_Iter_container ( _Iter_t^  _Next)
inline
4255  { // get container for arbitrary iterator
4256  return (_Next->container());
4257  }
template<typename _InIt_t , typename _Diff_t >
void cliext::_Iter_distance ( _InIt_t  _First,
_InIt_t  _Last,
_Diff_t%  _Off 
)
inline
731  { // add to _Off distance between iterators
732  _Iter_distance2(_First, _Last, _Off, _Iter_category(_First));
733  }
iterator_traits< _Iter_t >::iterator_category _Iter_category(_Iter_t)
Definition: xutility:654
void _Iter_distance2(_RanIt_t _First, _RanIt_t _Last, _Diff_t%_Off, random_access_iterator_tag)
Definition: xutility:713
_FwdIt _Last
Definition: algorithm:1936
cliext::_Iter_distance ( _First  ,
_Last  ,
_Count   
)
template<typename _InIt_t , typename _Diff_t >
void cliext::_Iter_distance2 ( _InIt_t  _First,
_InIt_t  _Last,
_Diff_t%  _Off,
input_iterator_tag   
)
inline
706  { // add to _Off distance between input iterators
707  for (; _First != _Last; ++_First)
708  ++_Off;
709  }
_FwdIt _Last
Definition: algorithm:1936
template<typename _RanIt_t , typename _Diff_t >
void cliext::_Iter_distance2 ( _RanIt_t  _First,
_RanIt_t  _Last,
_Diff_t%  _Off,
random_access_iterator_tag   
)
inline
715  { // add to _Off distance between random-access iterators
716  _Off += (_Diff_t)(_Last - _First);
717  }
_FwdIt _Last
Definition: algorithm:1936
template<class _FwdIt , class _Ty >
cliext::_PAIR_TYPE ( _FwdIt  )
inline
template<class _FwdIt , class _Ty , class _Pr >
cliext::_PAIR_TYPE ( _FwdIt  )
inline
template<class _RanIt >
cliext::_PAIR_TYPE ( _RanIt  )
inline
template<class _RanIt , class _Pr >
cliext::_PAIR_TYPE ( _RanIt  )
inline
template<typename _Key_t >
bool cliext::_Queue_compare ( _Key_t  _Left,
_Key_t  _Right 
)
inline
468  { // test if _Left < _Right
469  return (_Left < _Right);
470  }
const _Ty & _Right
Definition: algorithm:4087
bool cliext::_Queue_compare ( System::String^  _Left,
System::String^  _Right 
)
inline
473  { // test if _Left < _Right for String
474  return (_Left->CompareTo(_Right) < 0);
475  }
const _Ty & _Right
Definition: algorithm:4087
int cliext::_Rand ( void  )
inline
1234  { /* compute pseudo-random value */
1235  static long _Randseed = 1;
1236 
1237  _Randseed = _Randseed * 1103515245 + 12345;
1238  return ((unsigned int)(_Randseed >> 16) & 0x7fff);
1239  }
template<class _BidIt >
void cliext::_Reverse ( _BidIt  _First,
_BidIt  _Last,
bidirectional_iterator_tag   
)
inline
1085  { // reverse elements in [_First, _Last), bidirectional iterators
1086  for (; _First != _Last && _First != --_Last; ++_First)
1087  cliext::iter_swap(_First, _Last);
1088  }
void iter_swap(_FwdIt1 _Left, _FwdIt2 _Right)
Definition: algorithm:573
_FwdIt _Last
Definition: algorithm:1936
template<class _RanIt >
void cliext::_Reverse ( _RanIt  _First,
_RanIt  _Last,
random_access_iterator_tag   
)
inline
1093  { // reverse elements in [_First, _Last), random-access iterators
1094  for (; _First < _Last; ++_First)
1095  cliext::iter_swap(_First, --_Last);
1096  }
void iter_swap(_FwdIt1 _Left, _FwdIt2 _Right)
Definition: algorithm:573
_FwdIt _Last
Definition: algorithm:1936
template<class _FwdIt >
void cliext::_Rotate ( _FwdIt  _First,
_FwdIt  _Mid,
_FwdIt  _Last,
forward_iterator_tag   
)
inline
1135  { // rotate [_First, _Last), forward iterators
1136  for (_FwdIt _Next = _Mid; ; )
1137  { // swap [_First, ...) into place
1138  cliext::iter_swap(_First, _Next);
1139  if (++_First == _Mid)
1140  if (++_Next == _Last)
1141  break; // done, quit
1142  else
1143  _Mid = _Next; // mark end of next interval
1144  else if (++_Next == _Last)
1145  _Next = _Mid; // wrap to last end
1146  }
1147  }
void iter_swap(_FwdIt1 _Left, _FwdIt2 _Right)
Definition: algorithm:573
_FwdIt _Last
Definition: algorithm:1936
template<class _BidIt >
void cliext::_Rotate ( _BidIt  _First,
_BidIt  _Mid,
_BidIt  _Last,
bidirectional_iterator_tag   
)
inline
1152  { // rotate [_First, _Last), bidirectional iterators
1153  cliext::reverse(_First, _Mid);
1154  cliext::reverse(_Mid, _Last);
1155  cliext::reverse(_First, _Last);
1156  }
void reverse(_BidIt _First, _BidIt _Last)
Definition: algorithm:1105
_FwdIt _Last
Definition: algorithm:1936
template<class _RanIt >
void cliext::_Rotate ( _RanIt  _First,
_RanIt  _Mid,
_RanIt  _Last,
random_access_iterator_tag   
)
inline
1161  { // rotate [_First, _Last), random-access iterators
1164 
1165  _Diff _Shift = _Mid - _First;
1166  _Diff _Count = _Last - _First;
1167 
1168  for (_Diff _Factor = _Shift; _Factor != 0; )
1169  { // find subcycle count as GCD of shift count and length
1170  _Diff _Tmp = _Count % _Factor;
1171  _Count = _Factor, _Factor = _Tmp;
1172  }
1173 
1174  if (_Count < _Last - _First)
1175  for (; 0 < _Count; --_Count)
1176  { // rotate each subcycle
1177  _RanIt _Hole = _First + _Count;
1178  _RanIt _Next = _Hole;
1179  _Ty _Holeval = *_Hole;
1180  _RanIt _Next1 = _Next + _Shift == _Last ? _First : _Next + _Shift;
1181  while (_Next1 != _Hole)
1182  { // percolate elements back around subcycle
1183  *_Next = *_Next1;
1184  _Next = _Next1;
1185  _Next1 = _Shift < _Last - _Next1 ? _Next1 + _Shift
1186  : _First + (_Shift - (_Last - _Next1));
1187  }
1188  *_Next = _Holeval;
1189  }
1190  }
_Iter::difference_type difference_type
Definition: xutility:373
_Iter::value_type value_type
Definition: xutility:372
_Diff _Count
Definition: algorithm:1941
_FwdIt _Last
Definition: algorithm:1936
template<class _FwdIt1 , class _Diff2 , class _Ty >
_FwdIt1 cliext::_Search_n ( _FwdIt1  _First1,
_FwdIt1  _Last1,
_Diff2  _Count,
const _Ty%  _Val,
forward_iterator_tag   
)
inline
274  { // find first _Count * _Val match, forward iterators
275  if (_Count <= 0)
276  return (_First1);
277 
278  for (; _First1 != _Last1; ++_First1)
279  if (*_First1 == _Val)
280  { // found start of possible match, check it out
281  _FwdIt1 _Mid1 = _First1;
282 
283  for (_Diff2 _Count1 = _Count; ; )
284  if (--_Count1 == 0)
285  return (_First1); // found rest of match, report it
286  else if (++_Mid1 == _Last1)
287  return (_Last1); // short match at end
288  else if (!(*_Mid1 == _Val))
289  break; // short match not at end
290 
291  _First1 = _Mid1; // pick up just beyond failed match
292  }
293  return (_Last1);
294  }
_Diff _Count
Definition: algorithm:1941
_FwdIt const _Ty _Val
Definition: algorithm:1938
template<class _FwdIt1 , class _Diff2 , class _Ty >
_FwdIt1 cliext::_Search_n ( _FwdIt1  _First1,
_FwdIt1  _Last1,
_Diff2  _Count,
const _Ty%  _Val,
random_access_iterator_tag   
)
inline
301  { // find first _Count * _Val match, random-access iterators
302  if (_Count <= 0)
303  return (_First1);
304 
305  _FwdIt1 _Oldfirst1 = _First1;
306  for (; _Count <= _Last1 - _Oldfirst1; )
307  { // enough room, look for a match
308  if (*_First1 == _Val)
309  { // found part of possible match, check it out
310  _Diff2 _Count1 = _Count;
311  _FwdIt1 _Mid1 = _First1;
312 
313  for (; _Oldfirst1 != _First1 && _First1[-1] == _Val; --_First1)
314  --_Count1; // back up over any skipped prefix
315 
316  if (_Count1 <= _Last1 - _Mid1)
317  for (; ; ) // enough left, test suffix
318  if (--_Count1 == 0)
319  return (_First1); // found rest of match, report it
320  else if (!(*++_Mid1 == _Val))
321  break; // short match not at end
322 
323  _Oldfirst1 = ++_Mid1; // failed match, take small jump
324  _First1 = _Oldfirst1;
325  }
326  else
327  { // no match, take big jump and back up as needed
328  _Oldfirst1 = _First1 + 1;
329  _First1 += _Count;
330  }
331  }
332  return (_Last1);
333  }
_Diff _Count
Definition: algorithm:1941
_FwdIt const _Ty _Val
Definition: algorithm:1938
template<class _FwdIt1 , class _Diff2 , class _Ty , class _Pr >
_FwdIt1 cliext::_Search_n ( _FwdIt1  _First1,
_FwdIt1  _Last1,
_Diff2  _Count,
const _Ty%  _Val,
_Pr  _Pred,
forward_iterator_tag   
)
inline
353  { // find first _Count * _Val satisfying _Pred, forward iterators
354  if (_Count <= 0)
355  return (_First1);
356 
357  for (; _First1 != _Last1; ++_First1)
358  if (_Pred(*_First1, _Val))
359  { // found start of possible match, check it out
360  _FwdIt1 _Mid1 = _First1;
361 
362  for (_Diff2 _Count1 = _Count; ; )
363  if (--_Count1 == 0)
364  return (_First1); // found rest of match, report it
365  else if (++_Mid1 == _Last1)
366  return (_Last1); // short match at end
367  else if (!_Pred(*_Mid1, _Val))
368  break; // short match not at end
369 
370  _First1 = _Mid1; // pick up just beyond failed match
371  }
372  return (_Last1);
373  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
_Diff _Count
Definition: algorithm:1941
_FwdIt const _Ty _Val
Definition: algorithm:1938
template<class _FwdIt1 , class _Diff2 , class _Ty , class _Pr >
_FwdIt1 cliext::_Search_n ( _FwdIt1  _First1,
_FwdIt1  _Last1,
_Diff2  _Count,
const _Ty%  _Val,
_Pr  _Pred,
random_access_iterator_tag   
)
inline
381  { // find first _Count * _Val satisfying _Pred, random-access iterators
382  if (_Count <= 0)
383  return (_First1);
384 
385  _FwdIt1 _Oldfirst1 = _First1;
386  for (; _Count <= _Last1 - _Oldfirst1; )
387  { // enough room, look for a match
388  if (_Pred(*_First1, _Val))
389  { // found part of possible match, check it out
390  _Diff2 _Count1 = _Count;
391  _FwdIt1 _Mid1 = _First1;
392 
393  for (; _Oldfirst1 != _First1 && _First1[-1] == _Val; --_First1)
394  --_Count1; // back up over any skipped prefix
395 
396  if (_Count1 <= _Last1 - _Mid1)
397  for (; ; ) // enough left, test suffix
398  if (--_Count1 == 0)
399  return (_First1); // found rest of match, report it
400  else if (!_Pred(*++_Mid1, _Val))
401  break; // short match not at end
402 
403  _Oldfirst1 = ++_Mid1; // failed match, take small jump
404  _First1 = _Oldfirst1;
405  }
406  else
407  { // no match, take big jump and back up as needed
408  _Oldfirst1 = _First1 + 1;
409  _First1 += _Count;
410  }
411  }
412  return (_Last1);
413  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
_Diff _Count
Definition: algorithm:1941
_FwdIt const _Ty _Val
Definition: algorithm:1938
template<typename _Iter_t >
_Iter_t cliext::_Unchecked ( _Iter_t  _Iter)
inline
12  { // return unknown iterator unchanged
13  return (_Iter);
14  }
template<typename _Cont_t >
ConstUncheckedBidirectionalIterator<_Cont_t> cliext::_Unchecked ( ConstBidirectionalIterator< _Cont_t >  _Iter)
525  { // return unchecked version
526  ConstUncheckedBidirectionalIterator<_Cont_t> _Newiter(
527  (typename _Cont_t::node_type^)_Iter.get_node());
528 
529  return (_Newiter);
530  }
template<typename _Cont_t >
UncheckedBidirectionalIterator<_Cont_t> cliext::_Unchecked ( BidirectionalIterator< _Cont_t >  _Iter)
1046  { // return unchecked version
1047  UncheckedBidirectionalIterator<_Cont_t> _Newiter(
1048  (typename _Cont_t::node_type^)_Iter.get_node());
1049 
1050  return (_Newiter);
1051  }
template<typename _Cont_t >
ReverseBidirectionalIterator<_Cont_t> cliext::_Unchecked ( ReverseBidirectionalIterator< _Cont_t >  _Iter)
1298  { // return unchecked version
1299  ReverseBidirectionalIterator<_Cont_t> _Newiter(_Iter.base());
1300 
1301  return (_Newiter);
1302  }
template<typename _Cont_t >
ConstUncheckedRandomAccessIterator<_Cont_t> cliext::_Unchecked ( ConstRandomAccessIterator< _Cont_t >  _Iter)
2083  { // return unchecked version
2084  typedef typename _Cont_t::value_type _Value_t;
2085 
2086  return (ConstUncheckedRandomAccessIterator<_Cont_t>(
2087  (_Cont_t^)_Iter.container(),
2088  _Iter.get_bias()));
2089  }
template<typename _Cont_t >
UncheckedRandomAccessIterator<_Cont_t> cliext::_Unchecked ( RandomAccessIterator< _Cont_t >  _Iter)
2883  { // return unchecked version
2884  typedef typename _Cont_t::value_type _Value_t;
2885 
2886  return (UncheckedRandomAccessIterator<_Cont_t>(
2887  (_Cont_t^)_Iter.container(),
2888  _Iter.get_bias()));
2889  }
template<typename _Cont_t >
ReverseRandomAccessIterator<_Cont_t> cliext::_Unchecked ( ReverseRandomAccessIterator< _Cont_t >  _Iter)
3251  { // return unchecked version
3252  ReverseRandomAccessIterator<_Cont_t> _Newiter(_Iter.base());
3253 
3254  return (_Newiter);
3255  }
template<typename _Cont_t , bool _Is_ref>
UncheckedBCL_iterator<_Cont_t, _Is_ref> cliext::_Unchecked ( BCL_iterator< _Cont_t, _Is_ref >  _Iter)
4158  { // return unchecked version
4159  return (UncheckedBCL_iterator<_Cont_t, _Is_ref>(
4160  (_Cont_t^)_Iter.container(),
4161  _Iter.get_bias()));
4162  }
template<class _InIt , class _OutIt >
_OutIt cliext::_Unique_copy ( _InIt  _First,
_InIt  _Last,
_OutIt  _Dest,
input_iterator_tag   
)
inline
949  { // copy compressing pairs that match, input iterators
951 
952  _Ty _Val = *_First;
953 
954  for (*_Dest++ = _Val; ++_First != _Last; )
955  if (!(_Val == *_First))
956  _Val = *_First, *_Dest++ = _Val;
957  return (_Dest);
958  }
_Iter::value_type value_type
Definition: xutility:372
_FwdIt const _Ty _Val
Definition: algorithm:1938
_FwdIt _Last
Definition: algorithm:1936
template<class _FwdIt , class _OutIt >
_OutIt cliext::_Unique_copy ( _FwdIt  _First,
_FwdIt  _Last,
_OutIt  _Dest,
forward_iterator_tag   
)
inline
964  { // copy compressing pairs that match, forward iterators
965  _FwdIt _Firstb = _First;
966  for (*_Dest++ = *_Firstb; ++_First != _Last; )
967  if (!(*_Firstb == *_First))
968  _Firstb = _First, *_Dest++ = *_Firstb;
969  return (_Dest);
970  }
_FwdIt _Last
Definition: algorithm:1936
template<class _BidIt , class _OutIt >
_OutIt cliext::_Unique_copy ( _BidIt  _First,
_BidIt  _Last,
_OutIt  _Dest,
bidirectional_iterator_tag   
)
inline
976  { // copy compressing pairs that match, bidirectional iterators
977  return (_Unique_copy(_First, _Last, _Dest, forward_iterator_tag()));
978  }
_OutIt _Unique_copy(_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred, _Ty *)
Definition: algorithm:1814
Definition: xutility:308
_FwdIt _Last
Definition: algorithm:1936
template<class _RanIt , class _OutIt >
_OutIt cliext::_Unique_copy ( _RanIt  _First,
_RanIt  _Last,
_OutIt  _Dest,
random_access_iterator_tag   
)
inline
984  { // copy compressing pairs that match, random-access iterators
985  return (_Unique_copy(_First, _Last, _Dest, forward_iterator_tag()));
986  }
_OutIt _Unique_copy(_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred, _Ty *)
Definition: algorithm:1814
Definition: xutility:308
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt , class _OutIt , class _Pr >
_OutIt cliext::_Unique_copy ( _InIt  _First,
_InIt  _Last,
_OutIt  _Dest,
_Pr  _Pred,
input_iterator_tag   
)
inline
1013  { // copy compressing pairs satisfying _Pred, input iterators
1015 
1016  _Ty _Val = *_First;
1017 
1018  for (*_Dest++ = _Val; ++_First != _Last; )
1019  if (!_Pred(_Val, *_First))
1020  _Val = *_First, *_Dest++ = _Val;
1021  return (_Dest);
1022  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
_Iter::value_type value_type
Definition: xutility:372
_FwdIt const _Ty _Val
Definition: algorithm:1938
_FwdIt _Last
Definition: algorithm:1936
template<class _FwdIt , class _OutIt , class _Pr >
_OutIt cliext::_Unique_copy ( _FwdIt  _First,
_FwdIt  _Last,
_OutIt  _Dest,
_Pr  _Pred,
forward_iterator_tag   
)
inline
1029  { // copy compressing pairs satisfying _Pred, forward iterators
1030  _FwdIt _Firstb = _First;
1031 
1032  for (*_Dest++ = *_Firstb; ++_First != _Last; )
1033  if (!_Pred(*_Firstb, *_First))
1034  _Firstb = _First, *_Dest++ = *_Firstb;
1035  return (_Dest);
1036  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
_FwdIt _Last
Definition: algorithm:1936
template<class _BidIt , class _OutIt , class _Pr >
_OutIt cliext::_Unique_copy ( _BidIt  _First,
_BidIt  _Last,
_OutIt  _Dest,
_Pr  _Pred,
bidirectional_iterator_tag   
)
inline
1043  { // copy compressing pairs satisfying _Pred, bidirectional iterators
1044  return (_Unique_copy(_First, _Last, _Dest, _Pred,
1046  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
_OutIt _Unique_copy(_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred, _Ty *)
Definition: algorithm:1814
Definition: xutility:308
_FwdIt _Last
Definition: algorithm:1936
template<class _RanIt , class _OutIt , class _Pr >
_OutIt cliext::_Unique_copy ( _RanIt  _First,
_RanIt  _Last,
_OutIt  _Dest,
_Pr  _Pred,
random_access_iterator_tag   
)
inline
1053  { // copy compressing pairs satisfying _Pred, random-access iterators
1054  return (_Unique_copy(_First, _Last, _Dest, _Pred,
1056  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
_OutIt _Unique_copy(_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred, _Ty *)
Definition: algorithm:1814
Definition: xutility:308
_FwdIt _Last
Definition: algorithm:1936
template<class _RanIt , class _Diff , class _Ty >
void cliext::_XAdjust_heap ( _RanIt  _First,
_Diff  _Hole,
_Diff  _Bottom,
_Ty  _Val 
)
inline
1591  { // percolate _Hole to _Bottom, then push _Val, using operator<
1592  _Diff _Top = _Hole;
1593  _Diff _Idx = 2 * _Hole + 2;
1594 
1595  for (; _Idx < _Bottom; _Idx = 2 * _Idx + 2)
1596  { // move _Hole down to larger child
1597  if (_STLCLRDB_LT(*(_First + _Idx), *(_First + (_Idx - 1))))
1598  --_Idx;
1599  *(_First + _Hole) = *(_First + _Idx), _Hole = _Idx;
1600  }
1601 
1602  if (_Idx == _Bottom)
1603  { // only child at bottom, move _Hole down to it
1604  *(_First + _Hole) = *(_First + (_Bottom - 1));
1605  _Hole = _Bottom - 1;
1606  }
1607  cliext::_XPush_heap(_First, _Hole, _Top, _Val);
1608  }
#define _STLCLRDB_LT(left, right)
Definition: memory:218
void _XPush_heap(_RanIt _First, _Diff _Hole, _Diff _Top, _Ty _Val)
Definition: algorithm:1497
_FwdIt const _Ty _Val
Definition: algorithm:1938
template<class _RanIt , class _Diff , class _Ty , class _Pr >
void cliext::_XAdjust_heap ( _RanIt  _First,
_Diff  _Hole,
_Diff  _Bottom,
_Ty  _Val,
_Pr  _Pred 
)
inline
1646  { // percolate _Hole to _Bottom, then push _Val, using _Pred
1647  _Diff _Top = _Hole;
1648  _Diff _Idx = 2 * _Hole + 2;
1649 
1650  for (; _Idx < _Bottom; _Idx = 2 * _Idx + 2)
1651  { // move _Hole down to larger child
1652  if (_STLCLRDB_LT_PRED(_Pred, *(_First + _Idx),
1653  *(_First + (_Idx - 1))))
1654  --_Idx;
1655  *(_First + _Hole) = *(_First + _Idx), _Hole = _Idx;
1656  }
1657 
1658  if (_Idx == _Bottom)
1659  { // only child at bottom, move _Hole down to it
1660  *(_First + _Hole) = *(_First + (_Bottom - 1));
1661  _Hole = _Bottom - 1;
1662  }
1663  cliext::_XPush_heap(_First, _Hole, _Top, _Val, _Pred);
1664  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _STLCLRDB_LT_PRED(pred, left, right)
Definition: memory:219
void _XPush_heap(_RanIt _First, _Diff _Hole, _Diff _Top, _Ty _Val)
Definition: algorithm:1497
_FwdIt const _Ty _Val
Definition: algorithm:1938
template<class _BidIt , class _Diff , class _Ty >
void cliext::_XBuffered_merge ( _BidIt  _First,
_BidIt  _Mid,
_BidIt  _Last,
_Diff  _Count1,
_Diff  _Count2,
_Temp_iterator< _Ty >  _Tempbuf 
)
inline
2217  { // merge [_First, _Mid) with [_Mid, _Last), using operator<
2218  if (_Count1 + _Count2 == 2)
2219  { // order two one-element partitions
2220  if (_STLCLRDB_LT(*_Mid, *_First))
2221  cliext::iter_swap(_First, _Mid);
2222  }
2223  else if (_Count1 <= _Count2 && _Count1 <= _Tempbuf._Maxlen())
2224  { // buffer left partition, then merge
2225  cliext::copy_unchecked(_First, _Mid, _Tempbuf._Init());
2226  cliext::merge_unchecked(_Tempbuf._First(), _Tempbuf._Last(),
2227  _Mid, _Last, _First);
2228  }
2229  else if (_Count2 <= _Tempbuf._Maxlen())
2230  { // buffer right partition, then merge
2231  cliext::copy_unchecked(_Mid, _Last, _Tempbuf._Init());
2232  cliext::_XMerge_backward(_First, _Mid,
2233  _Tempbuf._First(), _Tempbuf._Last(), _Last);
2234  }
2235  else
2236  { // buffer too small, divide and conquer
2237  _BidIt _Firstn, _Lastn;
2238  _Diff _Count1n, _Count2n;
2239 
2240  if (_Count2 < _Count1)
2241  { // left larger, cut it in half and partition right to match
2242  _Count1n = _Count1 / 2, _Count2n = 0;
2243  _Firstn = _First;
2244  cliext::advance(_Firstn, _Count1n);
2245  _Lastn = cliext::lower_bound_unchecked(_Mid, _Last, *_Firstn);
2246  _Iter_distance(_Mid, _Lastn, _Count2n);
2247  }
2248  else
2249  { // right larger, cut it in half and partition left to match
2250  _Count1n = 0, _Count2n = _Count2 / 2;
2251  _Lastn = _Mid;
2252  cliext::advance(_Lastn, _Count2n);
2253  _Firstn = cliext::upper_bound_unchecked(_First, _Mid, *_Lastn);
2254  _Iter_distance(_First, _Firstn, _Count1n);
2255  }
2256 
2257  _BidIt _Midn = cliext::_XBuffered_rotate(_Firstn, _Mid, _Lastn,
2258  _Count1 - _Count1n, _Count2n, _Tempbuf); // rearrange middle
2259  cliext::_XBuffered_merge(_First, _Firstn, _Midn,
2260  _Count1n, _Count2n, _Tempbuf); // merge each new part
2261  cliext::_XBuffered_merge(_Midn, _Lastn, _Last,
2262  _Count1 - _Count1n, _Count2 - _Count2n, _Tempbuf);
2263  }
2264  }
_FwdIt lower_bound_unchecked(_FwdIt _First, _FwdIt _Last, _Ty%_Val)
Definition: algorithm:1797
_OutIt merge_unchecked(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
Definition: algorithm:2073
#define _STLCLRDB_LT(left, right)
Definition: memory:218
_Pty _First() const
Definition: xmemory:830
void _XBuffered_merge(_BidIt _First, _BidIt _Mid, _BidIt _Last, _Diff _Count1, _Diff _Count2, _Temp_iterator< _Ty > _Tempbuf)
Definition: algorithm:2214
ptrdiff_t _Maxlen()
Definition: xmemory:840
_BidIt _XBuffered_rotate(_BidIt _First, _BidIt _Mid, _BidIt _Last, _Diff _Count1, _Diff _Count2, _Temp_iterator< _Ty > _Tempbuf)
Definition: algorithm:2139
_Iter_distance(_First, _Last, _Count)
void iter_swap(_FwdIt1 _Left, _FwdIt2 _Right)
Definition: algorithm:573
_Temp_iterator< _Ty > & _Init()
Definition: xmemory:824
void advance(_InIt_t%_Where, _Diff_t _Off)
Definition: xutility:694
_FwdIt upper_bound_unchecked(_FwdIt _First, _FwdIt _Last, const _Ty%_Val)
Definition: algorithm:1867
_OutIt copy_unchecked(_InIt _First, _InIt _Last, _OutIt _Dest)
Definition: memory:490
_BidIt3 _XMerge_backward(_BidIt1 _First1, _BidIt1 _Last1, _BidIt2 _First2, _BidIt2 _Last2, _BidIt3 _Dest)
Definition: algorithm:2197
_FwdIt _Last
Definition: algorithm:1936
_Pty _Last() const
Definition: xmemory:835
template<class _BidIt , class _Diff , class _Ty , class _Pr >
void cliext::_XBuffered_merge ( _BidIt  _First,
_BidIt  _Mid,
_BidIt  _Last,
_Diff  _Count1,
_Diff  _Count2,
_Temp_iterator< _Ty >  _Tempbuf,
_Pr  _Pred 
)
inline
2378  { // merge [_First, _Mid) with [_Mid, _Last), using _Pred
2379  if (_Count1 + _Count2 == 2)
2380  { // order two one-element partitions
2381  if (_STLCLRDB_LT_PRED(_Pred, *_Mid, *_First))
2382  cliext::iter_swap(_First, _Mid);
2383  }
2384  else if (_Count1 <= _Count2 && _Count1 <= _Tempbuf._Maxlen())
2385  { // buffer left partition, then merge
2386  cliext::copy_unchecked(_First, _Mid, _Tempbuf._Init());
2387  cliext::merge_unchecked(_Tempbuf._First(), _Tempbuf._Last(),
2388  _Mid, _Last, _First, _Pred);
2389  }
2390  else if (_Count2 <= _Tempbuf._Maxlen())
2391  { // buffer right partition, then merge
2392  cliext::copy_unchecked(_Mid, _Last, _Tempbuf._Init());
2393  cliext::_XMerge_backward(_First, _Mid,
2394  _Tempbuf._First(), _Tempbuf._Last(), _Last, _Pred);
2395  }
2396  else
2397  { // buffer too small, divide and conquer
2398  _BidIt _Firstn, _Lastn;
2399  _Diff _Count1n, _Count2n;
2400  if (_Count2 < _Count1)
2401  { // left larger, cut it in half and partition right to match
2402  _Count1n = _Count1 / 2, _Count2n = 0;
2403  _Firstn = _First;
2404  cliext::advance(_Firstn, _Count1n);
2405  _Lastn = cliext::lower_bound_unchecked(_Mid, _Last,
2406  *_Firstn, _Pred);
2407  _Iter_distance(_Mid, _Lastn, _Count2n);
2408  }
2409  else
2410  { // right larger, cut it in half and partition left to match
2411  _Count1n = 0, _Count2n = _Count2 / 2;
2412  _Lastn = _Mid;
2413  cliext::advance(_Lastn, _Count2n);
2414  _Firstn = cliext::upper_bound_unchecked(_First, _Mid,
2415  *_Lastn, _Pred);
2416  _Iter_distance(_First, _Firstn, _Count1n);
2417  }
2418  _BidIt _Midn = cliext::_XBuffered_rotate(_Firstn, _Mid, _Lastn,
2419  _Count1 - _Count1n, _Count2n, _Tempbuf); // rearrange middle
2420  cliext::_XBuffered_merge(_First, _Firstn, _Midn,
2421  _Count1n, _Count2n, _Tempbuf, _Pred); // merge each new part
2422  cliext::_XBuffered_merge(_Midn, _Lastn, _Last,
2423  _Count1 - _Count1n, _Count2 - _Count2n, _Tempbuf, _Pred);
2424  }
2425  }
_FwdIt lower_bound_unchecked(_FwdIt _First, _FwdIt _Last, _Ty%_Val)
Definition: algorithm:1797
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
_OutIt merge_unchecked(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
Definition: algorithm:2073
#define _STLCLRDB_LT_PRED(pred, left, right)
Definition: memory:219
_Pty _First() const
Definition: xmemory:830
void _XBuffered_merge(_BidIt _First, _BidIt _Mid, _BidIt _Last, _Diff _Count1, _Diff _Count2, _Temp_iterator< _Ty > _Tempbuf)
Definition: algorithm:2214
ptrdiff_t _Maxlen()
Definition: xmemory:840
_BidIt _XBuffered_rotate(_BidIt _First, _BidIt _Mid, _BidIt _Last, _Diff _Count1, _Diff _Count2, _Temp_iterator< _Ty > _Tempbuf)
Definition: algorithm:2139
_Iter_distance(_First, _Last, _Count)
void iter_swap(_FwdIt1 _Left, _FwdIt2 _Right)
Definition: algorithm:573
_Temp_iterator< _Ty > & _Init()
Definition: xmemory:824
void advance(_InIt_t%_Where, _Diff_t _Off)
Definition: xutility:694
_FwdIt upper_bound_unchecked(_FwdIt _First, _FwdIt _Last, const _Ty%_Val)
Definition: algorithm:1867
_OutIt copy_unchecked(_InIt _First, _InIt _Last, _OutIt _Dest)
Definition: memory:490
_BidIt3 _XMerge_backward(_BidIt1 _First1, _BidIt1 _Last1, _BidIt2 _First2, _BidIt2 _Last2, _BidIt3 _Dest)
Definition: algorithm:2197
_FwdIt _Last
Definition: algorithm:1936
_Pty _Last() const
Definition: xmemory:835
template<class _BidIt , class _Diff , class _Ty >
void cliext::_XBuffered_merge_sort ( _BidIt  _First,
_BidIt  _Last,
_Diff  _Count,
_Temp_iterator< _Ty >  _Tempbuf 
)
inline
2874  { // sort using temp buffer for merges, using operator<
2875  _BidIt _Mid = _First;
2876  for (_Diff _Nleft = _Count; _ISort::_Max <= _Nleft; _Nleft -= _ISort::_Max)
2877  { // sort chunks
2878  _BidIt _Midend = _Mid;
2879  cliext::advance(_Midend, (int)_ISort::_Max);
2880 
2881  cliext::_XInsertion_sort(_Mid, _Midend);
2882  _Mid = _Midend;
2883  }
2884  cliext::_XInsertion_sort(_Mid, _Last); // sort partial last chunk
2885 
2886  for (_Diff _Chunk = _ISort::_Max; _Chunk < _Count; _Chunk *= 2)
2887  { // merge adjacent pairs of chunks to and from temp buffer
2888  cliext::_XChunked_merge(_First, _Last, _Tempbuf._Init(),
2889  _Chunk, _Count);
2890  cliext::_XChunked_merge(_Tempbuf._First(), _Tempbuf._Last(), _First,
2891  _Chunk *= 2, _Count);
2892  }
2893  }
_Pty _First() const
Definition: xmemory:830
_Temp_iterator< _Ty > & _Init()
Definition: xmemory:824
void advance(_InIt_t%_Where, _Diff_t _Off)
Definition: xutility:694
void _XChunked_merge(_BidIt _First, _BidIt _Last, _OutIt _Dest, _Diff _Chunk, _Diff _Count)
Definition: algorithm:2842
_Diff _Count
Definition: algorithm:1941
void _XInsertion_sort(_BidIt _First, _BidIt _Last)
Definition: algorithm:2519
_FwdIt _Last
Definition: algorithm:1936
_Pty _Last() const
Definition: xmemory:835
template<class _BidIt , class _Diff , class _Ty , class _Pr >
void cliext::_XBuffered_merge_sort ( _BidIt  _First,
_BidIt  _Last,
_Diff  _Count,
_Temp_iterator< _Ty >  _Tempbuf,
_Pr  _Pred 
)
inline
3051  { // sort using temp buffer for merges, using _Pred
3052  _BidIt _Mid = _First;
3053  for (_Diff _Nleft = _Count; _ISort::_Max <= _Nleft; _Nleft -= _ISort::_Max)
3054  { // sort chunks
3055  _BidIt _Midn = _Mid;
3056  cliext::advance(_Midn, (int)_ISort::_Max);
3057 
3058  cliext::_XInsertion_sort(_Mid, _Midn, _Pred);
3059  _Mid = _Midn;
3060  }
3061  cliext::_XInsertion_sort(_Mid, _Last, _Pred); // sort partial last chunk
3062 
3063  for (_Diff _Chunk = _ISort::_Max; _Chunk < _Count; _Chunk *= 2)
3064  { // merge adjacent pairs of chunks to and from temp buffer
3065  cliext::_XChunked_merge(_First, _Last, _Tempbuf._Init(),
3066  _Chunk, _Count, _Pred);
3067  cliext::_XChunked_merge(_Tempbuf._First(), _Tempbuf._Last(), _First,
3068  _Chunk *= 2, _Count, _Pred);
3069  }
3070  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
_Pty _First() const
Definition: xmemory:830
_Temp_iterator< _Ty > & _Init()
Definition: xmemory:824
void advance(_InIt_t%_Where, _Diff_t _Off)
Definition: xutility:694
void _XChunked_merge(_BidIt _First, _BidIt _Last, _OutIt _Dest, _Diff _Chunk, _Diff _Count)
Definition: algorithm:2842
_Diff _Count
Definition: algorithm:1941
void _XInsertion_sort(_BidIt _First, _BidIt _Last)
Definition: algorithm:2519
_FwdIt _Last
Definition: algorithm:1936
_Pty _Last() const
Definition: xmemory:835
template<class _BidIt , class _Diff , class _Ty >
_BidIt cliext::_XBuffered_rotate ( _BidIt  _First,
_BidIt  _Mid,
_BidIt  _Last,
_Diff  _Count1,
_Diff  _Count2,
_Temp_iterator< _Ty >  _Tempbuf 
)
inline
2141  { // rotate [_First, _Last) using temp buffer
2142  if (_Count1 <= _Count2 && _Count1 <= _Tempbuf._Maxlen())
2143  { // buffer left partition, then copy parts
2144  cliext::copy_unchecked(_First, _Mid, _Tempbuf._Init());
2145  cliext::copy_unchecked(_Mid, _Last, _First);
2147  _Tempbuf._First(), _Tempbuf._Last(), _Last));
2148  }
2149  else if (_Count2 <= _Tempbuf._Maxlen())
2150  { // buffer right partition, then copy parts
2151  cliext::copy_unchecked(_Mid, _Last, _Tempbuf._Init());
2152  cliext::copy_backward_unchecked(_First, _Mid, _Last);
2153  return (cliext::copy_unchecked(
2154  _Tempbuf._First(), _Tempbuf._Last(), _First));
2155  }
2156  else
2157  { // buffer too small, rotate in place
2158  cliext::rotate_unchecked(_First, _Mid, _Last);
2159  cliext::advance(_First, _Count2);
2160  return (_First);
2161  }
2162  }
void rotate_unchecked(_FwdIt _First, _FwdIt _Mid, _FwdIt _Last)
Definition: algorithm:1193
_Pty _First() const
Definition: xmemory:830
ptrdiff_t _Maxlen()
Definition: xmemory:840
_Temp_iterator< _Ty > & _Init()
Definition: xmemory:824
_BidIt2 copy_backward_unchecked(_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest)
Definition: memory:514
void advance(_InIt_t%_Where, _Diff_t _Off)
Definition: xutility:694
_OutIt copy_unchecked(_InIt _First, _InIt _Last, _OutIt _Dest)
Definition: memory:490
_FwdIt _Last
Definition: algorithm:1936
_Pty _Last() const
Definition: xmemory:835
template<class _BidIt , class _OutIt , class _Diff >
void cliext::_XChunked_merge ( _BidIt  _First,
_BidIt  _Last,
_OutIt  _Dest,
_Diff  _Chunk,
_Diff  _Count 
)
inline
2844  { // copy merging chunks, using operator<
2845  for (_Diff _Chunk2 = _Chunk * 2; _Chunk2 <= _Count; _Count -= _Chunk2)
2846  { // copy merging pairs of adjacent chunks
2847  _BidIt _Mid1 = _First;
2848  cliext::advance(_Mid1, _Chunk);
2849  _BidIt _Mid2 = _Mid1;
2850  cliext::advance(_Mid2, _Chunk);
2851 
2852  _Dest = cliext::merge_unchecked(_First, _Mid1,
2853  _Mid1, _Mid2, _Dest);
2854  _First = _Mid2;
2855  }
2856 
2857  if (_Count <= _Chunk)
2858  cliext::copy_unchecked(_First, _Last,
2859  _Dest); // copy partial last chunk
2860  else
2861  { // copy merging whole and partial last chunk
2862  _BidIt _Mid = _First;
2863  cliext::advance(_Mid, _Chunk);
2864 
2865  cliext::merge_unchecked(_First, _Mid, _Mid, _Last, _Dest);
2866  }
2867  }
_OutIt merge_unchecked(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
Definition: algorithm:2073
void advance(_InIt_t%_Where, _Diff_t _Off)
Definition: xutility:694
_Diff _Count
Definition: algorithm:1941
_OutIt copy_unchecked(_InIt _First, _InIt _Last, _OutIt _Dest)
Definition: memory:490
_FwdIt _Last
Definition: algorithm:1936
template<class _BidIt , class _OutIt , class _Diff , class _Pr >
void cliext::_XChunked_merge ( _BidIt  _First,
_BidIt  _Last,
_OutIt  _Dest,
_Diff  _Chunk,
_Diff  _Count,
_Pr  _Pred 
)
inline
3019  { // copy merging chunks, using _Pred
3020  for (_Diff _Chunk2 = _Chunk * 2; _Chunk2 <= _Count; _Count -= _Chunk2)
3021  { // copy merging pairs of adjacent chunks
3022  _BidIt _Mid1 = _First;
3023  cliext::advance(_Mid1, _Chunk);
3024  _BidIt _Mid2 = _Mid1;
3025  cliext::advance(_Mid2, _Chunk);
3026 
3027  _Dest = cliext::merge_unchecked(_First, _Mid1,
3028  _Mid1, _Mid2, _Dest, _Pred);
3029  _First = _Mid2;
3030  }
3031 
3032  if (_Count <= _Chunk)
3033  cliext::copy_unchecked(_First, _Last,
3034  _Dest); // copy partial last chunk
3035  else
3036  { // copy merging whole and partial last chunk
3037  _BidIt _Mid1 = _First;
3038  cliext::advance(_Mid1, _Chunk);
3039 
3040  cliext::merge_unchecked(_First, _Mid1,
3041  _Mid1, _Last, _Dest, _Pred);
3042  }
3043  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
_OutIt merge_unchecked(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
Definition: algorithm:2073
void advance(_InIt_t%_Where, _Diff_t _Off)
Definition: xutility:694
_Diff _Count
Definition: algorithm:1941
_OutIt copy_unchecked(_InIt _First, _InIt _Last, _OutIt _Dest)
Definition: memory:490
_FwdIt _Last
Definition: algorithm:1936
template<class _BidIt >
void cliext::_XInsertion_sort ( _BidIt  _First,
_BidIt  _Last 
)
inline
2520  { // insertion sort [_First, _Last), using operator<
2522 
2523  if (_First != _Last)
2524  for (_BidIt _Next = _First; ++_Next != _Last; )
2525  { // order next element
2526  _BidIt _Next1 = _Next;
2527  _Ty _Val = *_Next;
2528 
2529  if (_STLCLRDB_LT(_Val, *_First))
2530  { // found new earliest element, move to front
2531  cliext::copy_backward_unchecked(_First, _Next, ++_Next1);
2532  *_First = _Val;
2533  }
2534  else
2535  { // look for insertion point after first
2536  for (_BidIt _First1 = _Next1;
2537  _STLCLRDB_LT(_Val, *--_First1);
2538  _Next1 = _First1)
2539  *_Next1 = *_First1; // move hole down
2540  *_Next1 = _Val; // insert element in hole
2541  }
2542  }
2543  }
#define _STLCLRDB_LT(left, right)
Definition: memory:218
_BidIt2 copy_backward_unchecked(_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest)
Definition: memory:514
_Iter::value_type value_type
Definition: xutility:372
_FwdIt const _Ty _Val
Definition: algorithm:1938
_FwdIt _Last
Definition: algorithm:1936
template<class _BidIt , class _Pr >
void cliext::_XInsertion_sort ( _BidIt  _First,
_BidIt  _Last,
_Pr  _Pred 
)
inline
2677  { // insertion sort [_First, _Last), using _Pred
2679 
2680  if (_First != _Last)
2681  for (_BidIt _Next = _First; ++_Next != _Last; )
2682  { // order next element
2683  _BidIt _Next1 = _Next;
2684  _Ty _Val = *_Next;
2685 
2686  if (_STLCLRDB_LT_PRED(_Pred, _Val, *_First))
2687  { // found new earliest element, move to front
2688  cliext::copy_backward_unchecked(_First, _Next, ++_Next1);
2689  *_First = _Val;
2690  }
2691  else
2692  { // look for insertion point after first
2693  for (_BidIt _First1 = _Next1;
2694  _STLCLRDB_LT_PRED(_Pred, _Val, *--_First1);
2695  _Next1 = _First1)
2696  *_Next1 = *_First1; // move hole down
2697  *_Next1 = _Val; // insert element in hole
2698  }
2699  }
2700  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _STLCLRDB_LT_PRED(pred, left, right)
Definition: memory:219
_BidIt2 copy_backward_unchecked(_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest)
Definition: memory:514
_Iter::value_type value_type
Definition: xutility:372
_FwdIt const _Ty _Val
Definition: algorithm:1938
_FwdIt _Last
Definition: algorithm:1936
template<class _RanIt >
void cliext::_XMed3 ( _RanIt  _First,
_RanIt  _Mid,
_RanIt  _Last 
)
inline
2547  { // sort median of three elements to middle
2548  if (_STLCLRDB_LT(*_Mid, *_First))
2549  cliext::iter_swap(_Mid, _First);
2550  if (_STLCLRDB_LT(*_Last, *_Mid))
2551  cliext::iter_swap(_Last, _Mid);
2552  if (_STLCLRDB_LT(*_Mid, *_First))
2553  cliext::iter_swap(_Mid, _First);
2554  }
#define _STLCLRDB_LT(left, right)
Definition: memory:218
void iter_swap(_FwdIt1 _Left, _FwdIt2 _Right)
Definition: algorithm:573
_FwdIt _Last
Definition: algorithm:1936
template<class _RanIt , class _Pr >
void cliext::_XMed3 ( _RanIt  _First,
_RanIt  _Mid,
_RanIt  _Last,
_Pr  _Pred 
)
inline
2705  { // sort median of three elements to middle
2706  if (_STLCLRDB_LT_PRED(_Pred, *_Mid, *_First))
2707  cliext::iter_swap(_Mid, _First);
2708  if (_STLCLRDB_LT_PRED(_Pred, *_Last, *_Mid))
2709  cliext::iter_swap(_Last, _Mid);
2710  if (_STLCLRDB_LT_PRED(_Pred, *_Mid, *_First))
2711  cliext::iter_swap(_Mid, _First);
2712  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _STLCLRDB_LT_PRED(pred, left, right)
Definition: memory:219
void iter_swap(_FwdIt1 _Left, _FwdIt2 _Right)
Definition: algorithm:573
_FwdIt _Last
Definition: algorithm:1936
template<class _RanIt >
void cliext::_XMedian ( _RanIt  _First,
_RanIt  _Mid,
_RanIt  _Last 
)
inline
2558  { // sort median element to middle
2559  if (40 < _Last - _First)
2560  { // median of nine
2561  int _Step = (int)(_Last - _First + 1) / 8;
2562  cliext::_XMed3(_First, _First + _Step, _First + 2 * _Step);
2563  cliext::_XMed3(_Mid - _Step, _Mid, _Mid + _Step);
2564  cliext::_XMed3(_Last - 2 * _Step, _Last - _Step, _Last);
2565  cliext::_XMed3(_First + _Step, _Mid, _Last - _Step);
2566  }
2567  else
2568  cliext::_XMed3(_First, _Mid, _Last);
2569  }
_CRTIMP _In_opt_z_ const wchar_t _In_opt_z_ const wchar_t unsigned int
Definition: crtdefs.h:642
_FwdIt _Last
Definition: algorithm:1936
void _XMed3(_RanIt _First, _RanIt _Mid, _RanIt _Last)
Definition: algorithm:2546
template<class _RanIt , class _Pr >
void cliext::_XMedian ( _RanIt  _First,
_RanIt  _Mid,
_RanIt  _Last,
_Pr  _Pred 
)
inline
2717  { // sort median element to middle
2718  if (40 < _Last - _First)
2719  { // median of nine
2720  int _Step = (int)(_Last - _First + 1) / 8;
2721  cliext::_XMed3(_First, _First + _Step, _First + 2 * _Step, _Pred);
2722  cliext::_XMed3(_Mid - _Step, _Mid, _Mid + _Step, _Pred);
2723  cliext::_XMed3(_Last - 2 * _Step, _Last - _Step, _Last, _Pred);
2724  cliext::_XMed3(_First + _Step, _Mid, _Last - _Step, _Pred);
2725  }
2726  else
2727  cliext::_XMed3(_First, _Mid, _Last, _Pred);
2728  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
_CRTIMP _In_opt_z_ const wchar_t _In_opt_z_ const wchar_t unsigned int
Definition: crtdefs.h:642
_FwdIt _Last
Definition: algorithm:1936
void _XMed3(_RanIt _First, _RanIt _Mid, _RanIt _Last)
Definition: algorithm:2546
template<class _BidIt1 , class _BidIt2 , class _BidIt3 >
_BidIt3 cliext::_XMerge_backward ( _BidIt1  _First1,
_BidIt1  _Last1,
_BidIt2  _First2,
_BidIt2  _Last2,
_BidIt3  _Dest 
)
inline
2199  { // merge backwards to _Dest, using operator<
2200  for (; ; )
2201  if (_First1 == _Last1)
2202  return (cliext::copy_backward_unchecked(_First2, _Last2, _Dest));
2203  else if (_First2 == _Last2)
2204  return (cliext::copy_backward_unchecked(_First1, _Last1, _Dest));
2205  else if (_STLCLRDB_LT(*--_Last2, *--_Last1))
2206  *--_Dest = *_Last1, ++_Last2;
2207  else
2208  *--_Dest = *_Last2, ++_Last1;
2209  }
#define _STLCLRDB_LT(left, right)
Definition: memory:218
_BidIt2 copy_backward_unchecked(_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest)
Definition: memory:514
template<class _BidIt1 , class _BidIt2 , class _BidIt3 , class _Pr >
_BidIt3 cliext::_XMerge_backward ( _BidIt1  _First1,
_BidIt1  _Last1,
_BidIt2  _First2,
_BidIt2  _Last2,
_BidIt3  _Dest,
_Pr  _Pred 
)
inline
2359  { // merge backwards to _Dest, using _Pred
2360  for (; ; )
2361  if (_First1 == _Last1)
2362  return (cliext::copy_backward_unchecked(_First2, _Last2, _Dest));
2363  else if (_First2 == _Last2)
2364  return (cliext::copy_backward_unchecked(_First1, _Last1, _Dest));
2365  else if (_STLCLRDB_LT_PRED(_Pred, *--_Last2, *--_Last1))
2366  *--_Dest = *_Last1, ++_Last2;
2367  else
2368  *--_Dest = *_Last2, ++_Last1;
2369  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _STLCLRDB_LT_PRED(pred, left, right)
Definition: memory:219
_BidIt2 copy_backward_unchecked(_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest)
Definition: memory:514
template<class _RanIt , class _Ty >
void cliext::_XPop_heap ( _RanIt  _First,
_RanIt  _Last,
_RanIt  _Dest,
_Ty  _Val 
)
inline
1614  { // pop *_First to *_Dest and reheap, using operator<
1616 
1617  *_Dest = *_First;
1618  cliext::_XAdjust_heap(_First, _Diff(0), _Diff(_Last - _First), _Val);
1619  }
_Iter::difference_type difference_type
Definition: xutility:373
void _XAdjust_heap(_RanIt _First, _Diff _Hole, _Diff _Bottom, _Ty _Val)
Definition: algorithm:1590
_FwdIt const _Ty _Val
Definition: algorithm:1938
_FwdIt _Last
Definition: algorithm:1936
template<class _RanIt , class _Ty , class _Pr >
void cliext::_XPop_heap ( _RanIt  _First,
_RanIt  _Last,
_RanIt  _Dest,
_Ty  _Val,
_Pr  _Pred 
)
inline
1671  { // pop *_First to *_Dest and reheap, using _Pred
1673 
1674  *_Dest = *_First;
1675  cliext::_XAdjust_heap(_First, _Diff(0), _Diff(_Last - _First),
1676  _Val, _Pred);
1677  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
_Iter::difference_type difference_type
Definition: xutility:373
void _XAdjust_heap(_RanIt _First, _Diff _Hole, _Diff _Bottom, _Ty _Val)
Definition: algorithm:1590
_FwdIt const _Ty _Val
Definition: algorithm:1938
_FwdIt _Last
Definition: algorithm:1936
template<class _RanIt , class _Diff , class _Ty >
void cliext::_XPush_heap ( _RanIt  _First,
_Diff  _Hole,
_Diff  _Top,
_Ty  _Val 
)
inline
1499  { // percolate _Hole to _Top or where _Val belongs, using operator<
1500  for (_Diff _Idx = (_Hole - 1) / 2;
1501  _Top < _Hole && _STLCLRDB_LT(*(_First + _Idx), _Val);
1502  _Idx = (_Hole - 1) / 2)
1503  { // move _Hole up to parent
1504  *(_First + _Hole) = *(_First + _Idx);
1505  _Hole = _Idx;
1506  }
1507 
1508  *(_First + _Hole) = _Val; // drop _Val into final hole
1509  }
#define _STLCLRDB_LT(left, right)
Definition: memory:218
_FwdIt const _Ty _Val
Definition: algorithm:1938
template<class _RanIt , class _Diff , class _Ty , class _Pr >
void cliext::_XPush_heap ( _RanIt  _First,
_Diff  _Hole,
_Diff  _Top,
_Ty  _Val,
_Pr  _Pred 
)
inline
1544  { // percolate _Hole to _Top or where _Val belongs, using operator<
1545  for (_Diff _Idx = (_Hole - 1) / 2;
1546  _Top < _Hole && _STLCLRDB_LT_PRED(_Pred, *(_First + _Idx), _Val);
1547  _Idx = (_Hole - 1) / 2)
1548  { // move _Hole up to parent
1549  *(_First + _Hole) = *(_First + _Idx);
1550  _Hole = _Idx;
1551  }
1552 
1553  *(_First + _Hole) = _Val; // drop _Val into final hole
1554  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _STLCLRDB_LT_PRED(pred, left, right)
Definition: memory:219
_FwdIt const _Ty _Val
Definition: algorithm:1938
template<class _RanIt , class _Diff >
void cliext::_XSort ( _RanIt  _First,
_RanIt  _Last,
_Diff  _Ideal 
)
inline
2631  { // order [_First, _Last), using operator<
2632  _Diff _Count;
2633  for (; _ISort::_Max < (_Count = _Last - _First) && 0 < _Ideal; )
2634  { // divide and conquer by quicksort
2635  _PAIR_TYPE(_RanIt) _Mid =
2636  cliext::_XUnguarded_partition(_First, _Last);
2637  _Ideal /= 2, _Ideal += _Ideal / 2; // allow 1.5 log2(N) divisions
2638 
2639  if (_Mid.first - _First < _Last - _Mid.second)
2640  { // loop on second half
2641  cliext::_XSort(_First, _Mid.first, _Ideal);
2642  _First = _Mid.second;
2643  }
2644  else
2645  { // loop on first half
2646  cliext::_XSort(_Mid.second, _Last, _Ideal);
2647  _Last = _Mid.first;
2648  }
2649  }
2650 
2651  if (_ISort::_Max < _Count)
2652  { // heap sort if too many divisions
2655  }
2656  else if (1 < _Count)
2657  cliext::_XInsertion_sort(_First, _Last); // small
2658  }
#define _PAIR_TYPE(iter_t)
Definition: memory:31
void make_heap_unchecked(_RanIt _First, _RanIt _Last)
Definition: algorithm:1702
if(__pUnknown!=*__ppTargetUnknown)
Definition: vccorlib.h:394
void sort_heap_unchecked(_RanIt _First, _RanIt _Last)
Definition: algorithm:1760
_Diff _Count
Definition: algorithm:1941
void _XSort(_RanIt _First, _RanIt _Last, _Diff _Ideal)
Definition: algorithm:2630
void _XInsertion_sort(_BidIt _First, _BidIt _Last)
Definition: algorithm:2519
Definition: adapter:7
_FwdIt _Last
Definition: algorithm:1936
template<class _RanIt , class _Diff , class _Pr >
void cliext::_XSort ( _RanIt  _First,
_RanIt  _Last,
_Diff  _Ideal,
_Pr  _Pred 
)
inline
2793  { // order [_First, _Last), using _Pred
2794  _Diff _Count;
2795  for (; _ISort::_Max < (_Count = _Last - _First) && 0 < _Ideal; )
2796  { // divide and conquer by quicksort
2797  _PAIR_TYPE(_RanIt) _Mid =
2798  cliext::_XUnguarded_partition(_First, _Last, _Pred);
2799  _Ideal /= 2, _Ideal += _Ideal / 2; // allow 1.5 log2(N) divisions
2800 
2801  if (_Mid.first - _First < _Last - _Mid.second)
2802  { // loop on second half
2803  cliext::_XSort(_First, _Mid.first, _Ideal, _Pred);
2804  _First = _Mid.second;
2805  }
2806  else
2807  { // loop on first half
2808  cliext::_XSort(_Mid.second, _Last, _Ideal, _Pred);
2809  _Last = _Mid.first;
2810  }
2811  }
2812 
2813  if (_ISort::_Max < _Count)
2814  { // heap sort if too many divisions
2817  }
2818  else if (1 < _Count)
2819  cliext::_XInsertion_sort(_First, _Last, _Pred); // small
2820  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _PAIR_TYPE(iter_t)
Definition: memory:31
void make_heap_unchecked(_RanIt _First, _RanIt _Last)
Definition: algorithm:1702
if(__pUnknown!=*__ppTargetUnknown)
Definition: vccorlib.h:394
void sort_heap_unchecked(_RanIt _First, _RanIt _Last)
Definition: algorithm:1760
_Diff _Count
Definition: algorithm:1941
void _XSort(_RanIt _First, _RanIt _Last, _Diff _Ideal)
Definition: algorithm:2630
void _XInsertion_sort(_BidIt _First, _BidIt _Last)
Definition: algorithm:2519
Definition: adapter:7
_FwdIt _Last
Definition: algorithm:1936
template<class _BidIt , class _Pr , class _Diff , class _Ty >
_BidIt cliext::_XStable_partition ( _BidIt  _First,
_BidIt  _Last,
_Pr  _Pred,
_Diff  _Count,
_Temp_iterator< _Ty >  _Tempbuf 
)
inline
1339  { // partition preserving order of equivalents, using _Pred
1340  if (_Count == 1)
1341  return (_Pred(*_First) ? _Last : _First);
1342  else if (_Count <= _Tempbuf._Maxlen())
1343  { // temp buffer big enough, copy right partition out and back
1344  _BidIt _Next = _First;
1345  for (_Tempbuf._Init(); _First != _Last; ++_First)
1346  if (_Pred(*_First))
1347  *_Next++ = *_First;
1348  else
1349  *_Tempbuf++ = *_First;
1350 
1351  cliext::copy_unchecked(_Tempbuf._First(), _Tempbuf._Last(),
1352  _Next); // copy back
1353  return (_Next);
1354  }
1355  else
1356  { // temp buffer not big enough, divide and conquer
1357  _BidIt _Mid = _First;
1358  cliext::advance(_Mid, _Count / 2);
1359 
1360  _BidIt _Left = cliext::_XStable_partition(_First, _Mid, _Pred,
1361  _Count / 2, _Tempbuf); // form L1R1 in left half
1362  _BidIt _Right = cliext::_XStable_partition(_Mid, _Last, _Pred,
1363  _Count - _Count / 2, _Tempbuf); // form L2R2 in right half
1364 
1365  _Diff _Count1 = 0;
1366  _Iter_distance(_Left, _Mid, _Count1);
1367  _Diff _Count2 = 0;
1368  _Iter_distance(_Mid, _Right, _Count2);
1369 
1370  return (cliext::_XBuffered_rotate(_Left, _Mid, _Right,
1371  _Count1, _Count2, _Tempbuf)); // rotate L1R1L2R2 to L1L2R1R2
1372  }
1373  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
_Pty _First() const
Definition: xmemory:830
ptrdiff_t _Maxlen()
Definition: xmemory:840
_BidIt _XBuffered_rotate(_BidIt _First, _BidIt _Mid, _BidIt _Last, _Diff _Count1, _Diff _Count2, _Temp_iterator< _Ty > _Tempbuf)
Definition: algorithm:2139
_Iter_distance(_First, _Last, _Count)
_Temp_iterator< _Ty > & _Init()
Definition: xmemory:824
void advance(_InIt_t%_Where, _Diff_t _Off)
Definition: xutility:694
_Diff _Count
Definition: algorithm:1941
_OutIt copy_unchecked(_InIt _First, _InIt _Last, _OutIt _Dest)
Definition: memory:490
_BidIt _XStable_partition(_BidIt _First, _BidIt _Last, _Pr _Pred, _Diff _Count, _Temp_iterator< _Ty > _Tempbuf)
Definition: algorithm:1337
_FwdIt _Last
Definition: algorithm:1936
_Pty _Last() const
Definition: xmemory:835
const _Ty & _Right
Definition: algorithm:4087
template<class _BidIt , class _Diff , class _Ty >
void cliext::_XStable_sort ( _BidIt  _First,
_BidIt  _Last,
_Diff  _Count,
_Temp_iterator< _Ty >  _Tempbuf 
)
inline
2928  { // sort preserving order of equivalents, using operator<
2929  if (_Count <= _ISort::_Max)
2930  cliext::_XInsertion_sort(_First, _Last); // small
2931  else
2932  { // sort halves and merge
2933  _Diff _Count2 = (_Count + 1) / 2;
2934  _BidIt _Mid = _First;
2935  cliext::advance(_Mid, _Count2);
2936 
2937  if (_Count2 <= _Tempbuf._Maxlen())
2938  { // temp buffer big enough, sort each half using buffer
2939  cliext::_XBuffered_merge_sort(_First, _Mid, _Count2,
2940  _Tempbuf);
2941  cliext::_XBuffered_merge_sort(_Mid, _Last, _Count - _Count2,
2942  _Tempbuf);
2943  }
2944  else
2945  { // temp buffer not big enough, divide and conquer
2946  cliext::_XStable_sort(_First, _Mid, _Count2, _Tempbuf);
2947  cliext::_XStable_sort(_Mid, _Last, _Count - _Count2, _Tempbuf);
2948  }
2949 
2950  cliext::_XBuffered_merge(_First, _Mid, _Last,
2951  _Count2, _Count - _Count2, _Tempbuf); // merge sorted halves
2952  }
2953  }
void _XBuffered_merge_sort(_BidIt _First, _BidIt _Last, _Diff _Count, _Temp_iterator< _Ty > _Tempbuf)
Definition: algorithm:2872
void _XStable_sort(_BidIt _First, _BidIt _Last, _Diff _Count, _Temp_iterator< _Ty > _Tempbuf)
Definition: algorithm:2926
void _XBuffered_merge(_BidIt _First, _BidIt _Mid, _BidIt _Last, _Diff _Count1, _Diff _Count2, _Temp_iterator< _Ty > _Tempbuf)
Definition: algorithm:2214
ptrdiff_t _Maxlen()
Definition: xmemory:840
void advance(_InIt_t%_Where, _Diff_t _Off)
Definition: xutility:694
_Diff _Count
Definition: algorithm:1941
void _XInsertion_sort(_BidIt _First, _BidIt _Last)
Definition: algorithm:2519
_FwdIt _Last
Definition: algorithm:1936
template<class _BidIt , class _Diff , class _Ty , class _Pr >
void cliext::_XStable_sort ( _BidIt  _First,
_BidIt  _Last,
_Diff  _Count,
_Temp_iterator< _Ty >  _Tempbuf,
_Pr  _Pred 
)
inline
3107  { // sort preserving order of equivalents, using _Pred
3108  if (_Count <= _ISort::_Max)
3109  cliext::_XInsertion_sort(_First, _Last, _Pred); // small
3110  else
3111  { // sort halves and merge
3112  _Diff _Count2 = (_Count + 1) / 2;
3113  _BidIt _Mid = _First;
3114  cliext::advance(_Mid, _Count2);
3115 
3116  if (_Count2 <= _Tempbuf._Maxlen())
3117  { // temp buffer big enough, sort each half using buffer
3118  cliext::_XBuffered_merge_sort(_First, _Mid, _Count2,
3119  _Tempbuf, _Pred);
3120  cliext::_XBuffered_merge_sort(_Mid, _Last, _Count - _Count2,
3121  _Tempbuf, _Pred);
3122  }
3123  else
3124  { // temp buffer not big enough, divide and conquer
3125  cliext::_XStable_sort(_First, _Mid, _Count2, _Tempbuf,
3126  _Pred);
3127  cliext::_XStable_sort(_Mid, _Last, _Count - _Count2, _Tempbuf,
3128  _Pred);
3129  }
3130 
3131  cliext::_XBuffered_merge(_First, _Mid, _Last,
3132  _Count2, _Count - _Count2, _Tempbuf, _Pred); // merge halves
3133  }
3134  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
void _XBuffered_merge_sort(_BidIt _First, _BidIt _Last, _Diff _Count, _Temp_iterator< _Ty > _Tempbuf)
Definition: algorithm:2872
void _XStable_sort(_BidIt _First, _BidIt _Last, _Diff _Count, _Temp_iterator< _Ty > _Tempbuf)
Definition: algorithm:2926
void _XBuffered_merge(_BidIt _First, _BidIt _Mid, _BidIt _Last, _Diff _Count1, _Diff _Count2, _Temp_iterator< _Ty > _Tempbuf)
Definition: algorithm:2214
ptrdiff_t _Maxlen()
Definition: xmemory:840
void advance(_InIt_t%_Where, _Diff_t _Off)
Definition: xutility:694
_Diff _Count
Definition: algorithm:1941
void _XInsertion_sort(_BidIt _First, _BidIt _Last)
Definition: algorithm:2519
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt , class _Ty >
_Ty cliext::accumulate ( _InIt  _First,
_InIt  _Last,
_Ty  _Val 
)
inline
20  { // return sum of _Val and all in [_First, _Last)
21  _STLCLRDB_RANGE(_First, _Last);
23  _Unchecked(_First), _Unchecked(_Last), _Val));
24  }
_Ty accumulate_unchecked(_InIt _First, _InIt _Last, _Ty _Val)
Definition: numeric:10
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_FwdIt const _Ty _Val
Definition: algorithm:1938
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt , class _Ty , class _Fn2 >
_Ty cliext::accumulate ( _InIt  _First,
_InIt  _Last,
_Ty  _Val,
_Fn2  _Func 
)
inline
43  { // return sum of _Val and all in [_First, _Last), using _Func
44  _STLCLRDB_RANGE(_First, _Last);
45  _STLCLRDB_POINTER(_Func);
47  _Unchecked(_First), _Unchecked(_Last), _Val, _Func));
48  }
_Ty accumulate_unchecked(_InIt _First, _InIt _Last, _Ty _Val)
Definition: numeric:10
#define _STLCLRDB_POINTER(first)
Definition: memory:221
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_FwdIt const _Ty _Val
Definition: algorithm:1938
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt , class _Ty >
_Ty cliext::accumulate_unchecked ( _InIt  _First,
_InIt  _Last,
_Ty  _Val 
)
inline
11  { // return sum of _Val and all in [_First, _Last)
12  for (; _First != _Last; ++_First)
13  _Val = _Val + *_First;
14  return (_Val);
15  }
_FwdIt const _Ty _Val
Definition: algorithm:1938
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt , class _Ty , class _Fn2 >
_Ty cliext::accumulate_unchecked ( _InIt  _First,
_InIt  _Last,
_Ty  _Val,
_Fn2  _Func 
)
inline
32  { // return sum of _Val and all in [_First, _Last), using _Func
33  for (; _First != _Last; ++_First)
34  _Val = _Func(_Val, *_First);
35  return (_Val);
36  }
_FwdIt const _Ty _Val
Definition: algorithm:1938
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt , class _OutIt >
_OutIt cliext::adjacent_difference ( _InIt  _First,
_InIt  _Last,
_OutIt  _Dest 
)
inline
202  { // compute adjacent differences into _Dest
203  _STLCLRDB_RANGE(_First, _Last);
204  _STLCLRDB_POINTER(_Dest);
206  _Unchecked(_First), _Unchecked(_Last),
207  _Unchecked(_Dest)));
208  }
#define _STLCLRDB_POINTER(first)
Definition: memory:221
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_OutIt adjacent_difference_unchecked(_InIt _First, _InIt _Last, _OutIt _Dest)
Definition: numeric:176
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt , class _OutIt , class _Fn2 >
_OutIt cliext::adjacent_difference ( _InIt  _First,
_InIt  _Last,
_OutIt  _Dest,
_Fn2  _Func 
)
inline
241  { // compute adjacent differences into _Dest, using _Func
242  _STLCLRDB_RANGE(_First, _Last);
243  _STLCLRDB_POINTER(_Dest);
244  _STLCLRDB_POINTER(_Func);
246  _Unchecked(_First), _Unchecked(_Last),
247  _Unchecked(_Dest), _Func));
248  }
#define _STLCLRDB_POINTER(first)
Definition: memory:221
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_OutIt adjacent_difference_unchecked(_InIt _First, _InIt _Last, _OutIt _Dest)
Definition: numeric:176
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt , class _OutIt >
_OutIt cliext::adjacent_difference_unchecked ( _InIt  _First,
_InIt  _Last,
_OutIt  _Dest 
)
inline
178  { // compute adjacent differences into _Dest
180 
181  if (_First == _Last)
182  return (_Dest);
183  else
184  { // compute nontrivial difference
185  _Ty _Val = *_First;
186 
187  for (*_Dest = _Val; ++_First != _Last; )
188  { // compute another difference
189  _Ty _Tmp = *_First;
190 
191  *++_Dest = _Tmp - _Val;
192  _Val = _Tmp;
193  }
194  return (++_Dest);
195  }
196  }
_Iter::value_type value_type
Definition: xutility:372
_FwdIt const _Ty _Val
Definition: algorithm:1938
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt , class _OutIt , class _Fn2 >
_OutIt cliext::adjacent_difference_unchecked ( _InIt  _First,
_InIt  _Last,
_OutIt  _Dest,
_Fn2  _Func 
)
inline
216  { // compute adjacent differences into _Dest, using _Func
218 
219  if (_First == _Last)
220  return (_Dest);
221  else
222  { // compute nontrivial difference
223  _Ty _Val = *_First;
224 
225  for (*_Dest = _Val; ++_First != _Last; )
226  { // compute another difference
227  _Ty _Tmp = *_First;
228 
229  *++_Dest = _Func(_Tmp, _Val);
230  _Val = _Tmp;
231  }
232  return (++_Dest);
233  }
234  }
_Iter::value_type value_type
Definition: xutility:372
_FwdIt const _Ty _Val
Definition: algorithm:1938
_FwdIt _Last
Definition: algorithm:1936
template<class _FwdIt >
_FwdIt cliext::adjacent_find ( _FwdIt  _First,
_FwdIt  _Last 
)
inline
115  { // find first matching successor
116  _STLCLRDB_RANGE(_First, _Last);
118  _Unchecked(_First), _Unchecked(_Last)));
119  }
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_FwdIt _Last
Definition: algorithm:1936
_FwdIt adjacent_find_unchecked(_FwdIt _First, _FwdIt _Last)
Definition: algorithm:105
template<class _FwdIt , class _Pr >
_FwdIt cliext::adjacent_find ( _FwdIt  _First,
_FwdIt  _Last,
_Pr  _Pred 
)
inline
135  { // find first satisfying _Pred with successor
136  _STLCLRDB_RANGE(_First, _Last);
139  _Unchecked(_First), _Unchecked(_Last), _Pred));
140  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _STLCLRDB_POINTER(first)
Definition: memory:221
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_FwdIt _Last
Definition: algorithm:1936
_FwdIt adjacent_find_unchecked(_FwdIt _First, _FwdIt _Last)
Definition: algorithm:105
template<class _FwdIt >
_FwdIt cliext::adjacent_find_unchecked ( _FwdIt  _First,
_FwdIt  _Last 
)
inline
106  { // find first matching successor
107  for (_FwdIt _Firstb; (_Firstb = _First) != _Last && ++_First != _Last; )
108  if (*_Firstb == *_First)
109  return (_Firstb);
110  return (_Last);
111  }
_FwdIt _Last
Definition: algorithm:1936
template<class _FwdIt , class _Pr >
_FwdIt cliext::adjacent_find_unchecked ( _FwdIt  _First,
_FwdIt  _Last,
_Pr  _Pred 
)
inline
125  { // find first satisfying _Pred with successor
126  for (_FwdIt _Firstb; (_Firstb = _First) != _Last && ++_First != _Last; )
127  if (_Pred(*_Firstb, *_First))
128  return (_Firstb);
129  return (_Last);
130  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
_FwdIt _Last
Definition: algorithm:1936
template<typename _InIt_t , typename _Diff_t >
void cliext::advance ( _InIt_t%  _Where,
_Diff_t  _Off 
)
inline
695  { // increment iterator by _Off, arbitrary iterators
696  _Iter_advance(_Where, _Off, _Iter_category(_Where));
697  }
iterator_traits< _Iter_t >::iterator_category _Iter_category(_Iter_t)
Definition: xutility:654
void _Iter_advance(_RanIt_t%_Where, _Diff_t _Off, random_access_iterator_tag)
Definition: xutility:686
template<typename TArg1 , typename TArg2 , typename TResult >
delegate TResult cliext::binary_delegate ( TArg1  ,
TArg2   
)
template<typename TArg1 , typename TArg2 >
delegate void cliext::binary_delegate_noreturn ( TArg1  ,
TArg2   
)
template<class _FwdIt , class _Ty >
bool cliext::binary_search ( _FwdIt  _First,
_FwdIt  _Last,
const _Ty%  _Val 
)
inline
2041  { // test if _Val equivalent to some element, using operator<
2042  _STLCLRDB_ORDER(_First, _Last);
2044  _Unchecked(_First), _Unchecked(_Last), _Val));
2045  }
#define _STLCLRDB_ORDER(first, last)
Definition: memory:223
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
bool binary_search_unchecked(_FwdIt _First, _FwdIt _Last, const _Ty%_Val)
Definition: algorithm:2030
_FwdIt const _Ty _Val
Definition: algorithm:1938
_FwdIt _Last
Definition: algorithm:1936
template<class _FwdIt , class _Ty , class _Pr >
bool cliext::binary_search ( _FwdIt  _First,
_FwdIt  _Last,
const _Ty%  _Val,
_Pr  _Pred 
)
inline
2063  { // test if _Val equivalent to some element, using _Pred
2064  _STLCLRDB_ORDER_PRED(_First, _Last, _Pred);
2066  _Unchecked(_First), _Unchecked(_Last), _Val, _Pred));
2067  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_ORDER_PRED(first, last, pred)
Definition: memory:224
bool binary_search_unchecked(_FwdIt _First, _FwdIt _Last, const _Ty%_Val)
Definition: algorithm:2030
_FwdIt const _Ty _Val
Definition: algorithm:1938
_FwdIt _Last
Definition: algorithm:1936
template<class _FwdIt , class _Ty >
bool cliext::binary_search_unchecked ( _FwdIt  _First,
_FwdIt  _Last,
const _Ty%  _Val 
)
inline
2032  { // test if _Val equivalent to some element, using operator<
2033  _First = cliext::lower_bound_unchecked(_First, _Last, _Val);
2034  return (_First != _Last && !(_Val < *_First));
2035  }
_FwdIt lower_bound_unchecked(_FwdIt _First, _FwdIt _Last, _Ty%_Val)
Definition: algorithm:1797
_FwdIt const _Ty _Val
Definition: algorithm:1938
_FwdIt _Last
Definition: algorithm:1936
template<class _FwdIt , class _Ty , class _Pr >
bool cliext::binary_search_unchecked ( _FwdIt  _First,
_FwdIt  _Last,
const _Ty%  _Val,
_Pr  _Pred 
)
inline
2053  { // test if _Val equivalent to some element, using _Pred
2054  _First = cliext::lower_bound_unchecked(_First, _Last, _Val, _Pred);
2055  return (_First != _Last && !_Pred(_Val, *_First));
2056  }
_FwdIt lower_bound_unchecked(_FwdIt _First, _FwdIt _Last, _Ty%_Val)
Definition: algorithm:1797
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
_FwdIt const _Ty _Val
Definition: algorithm:1938
_FwdIt _Last
Definition: algorithm:1936
template<typename _Fun_t , typename _Arg_t >
binder1st<_Fun_t> cliext::bind1st ( _Fun_t%  _Func,
_Arg_t  _Left 
)
inline
926  { // return a binder1st functor adapter
927  typename _Fun_t::first_argument_type _Val = _Left;
928 
929  return (binder1st<_Fun_t>(_Func, _Val));
930  }
Definition: xfunctional:443
_FwdIt const _Ty _Val
Definition: algorithm:1938
template<typename _Fun_t , typename _Arg_t >
binder2nd<_Fun_t> cliext::bind2nd ( _Fun_t%  _Func,
_Arg_t  _Right 
)
inline
1017  { // return a binder2nd functor adapter
1018  typename _Fun_t::second_argument_type _Val = _Right;
1019 
1020  return (binder2nd<_Fun_t>(_Func, _Val));
1021  }
Definition: xfunctional:485
_FwdIt const _Ty _Val
Definition: algorithm:1938
const _Ty & _Right
Definition: algorithm:4087
template<class _InIt , class _OutIt >
_OutIt cliext::copy ( _InIt  _First,
_InIt  _Last,
_OutIt  _Dest 
)
inline
500  { // copy [_First, _Last) to [_Dest, ...)
501  #if _HAS_ITERATOR_DEBUGGING
502  _STLCLRDB_RANGE(_First, _Last);
503  if (_First != _Last)
504  _STLCLRDB_POINTER(_Dest);
505  #endif /* _HAS_ITERATOR_DEBUGGING */
506  return (cliext::copy_unchecked(
507  _Unchecked(_First), _Unchecked(_Last),
508  _Unchecked(_Dest)));
509  }
#define _STLCLRDB_POINTER(first)
Definition: memory:221
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_OutIt copy_unchecked(_InIt _First, _InIt _Last, _OutIt _Dest)
Definition: memory:490
_FwdIt _Last
Definition: algorithm:1936
template<class _BidIt1 , class _BidIt2 >
_BidIt2 cliext::copy_backward ( _BidIt1  _First,
_BidIt1  _Last,
_BidIt2  _Dest 
)
inline
525  { // copy [_First, _Last) backwards to [..., _Dest)
526  #if _HAS_ITERATOR_DEBUGGING
527  _STLCLRDB_RANGE(_First, _Last);
528  if (_First != _Last)
529  _STLCLRDB_POINTER(_Dest);
530  #endif /* _HAS_ITERATOR_DEBUGGING */
532  _Unchecked(_First), _Unchecked(_Last),
533  _Unchecked(_Dest)));
534  }
#define _STLCLRDB_POINTER(first)
Definition: memory:221
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
_BidIt2 copy_backward_unchecked(_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest)
Definition: memory:514
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_FwdIt _Last
Definition: algorithm:1936
template<class _BidIt1 , class _BidIt2 >
_BidIt2 cliext::copy_backward_unchecked ( _BidIt1  _First,
_BidIt1  _Last,
_BidIt2  _Dest 
)
inline
516  { // copy [_First, _Last) backwards to [..., _Dest)
517  while (_First != _Last)
518  *--_Dest = *--_Last;
519  return (_Dest);
520  }
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt , class _OutIt >
_OutIt cliext::copy_unchecked ( _InIt  _First,
_InIt  _Last,
_OutIt  _Dest 
)
inline
491  { // copy [_First, _Last) to [_Dest, ...)
492  for (; _First != _Last; ++_Dest, ++_First)
493  *_Dest = *_First;
494  return (_Dest);
495  }
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt , class _Ty >
iterator_traits<_InIt>::difference_type cliext::count ( _InIt  _First,
_InIt  _Last,
const _Ty%  _Val 
)
inline
160  { // count elements that match _Val
161  _STLCLRDB_RANGE(_First, _Last);
163  _Val));
164  }
iterator_traits< _InIt >::difference_type count_unchecked(_InIt _First, _InIt _Last, const _Ty%_Val)
Definition: algorithm:146
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_FwdIt const _Ty _Val
Definition: algorithm:1938
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt , class _Pr >
iterator_traits<_InIt>::difference_type cliext::count_if ( _InIt  _First,
_InIt  _Last,
_Pr  _Pred 
)
inline
184  { // count elements satisfying _Pred
185  _STLCLRDB_RANGE(_First, _Last);
188  _Pred));
189  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _STLCLRDB_POINTER(first)
Definition: memory:221
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
iterator_traits< _InIt >::difference_type count_if_unchecked(_InIt _First, _InIt _Last, _Pr _Pred)
Definition: algorithm:170
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt , class _Pr >
iterator_traits<_InIt>::difference_type cliext::count_if_unchecked ( _InIt  _First,
_InIt  _Last,
_Pr  _Pred 
)
inline
171  { // count elements satisfying _Pred
173 
174  for (; _First != _Last; ++_First)
175  if (_Pred(*_First))
176  ++_Count;
177  return (_Count);
178  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
_Iter::difference_type difference_type
Definition: xutility:373
_Diff _Count
Definition: algorithm:1941
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt , class _Ty >
iterator_traits<_InIt>::difference_type cliext::count_unchecked ( _InIt  _First,
_InIt  _Last,
const _Ty%  _Val 
)
inline
147  { // count elements that match _Val
149 
150  for (; _First != _Last; ++_First)
151  if (*_First == _Val)
152  ++_Count;
153  return (_Count);
154  }
_Iter::difference_type difference_type
Definition: xutility:373
_Diff _Count
Definition: algorithm:1941
_FwdIt const _Ty _Val
Definition: algorithm:1938
_FwdIt _Last
Definition: algorithm:1936
template<typename _InIt_t >
int cliext::distance ( _InIt_t  _First,
_InIt_t  _Last 
)
inline
721  { // return distance between iterators
722  int _Off = 0;
723 
724  _Iter_distance2(_First, _Last, _Off, _Iter_category(_First));
725  return (_Off);
726  }
iterator_traits< _Iter_t >::iterator_category _Iter_category(_Iter_t)
Definition: xutility:654
void _Iter_distance2(_RanIt_t _First, _RanIt_t _Last, _Diff_t%_Off, random_access_iterator_tag)
Definition: xutility:713
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt1 , class _InIt2 >
bool cliext::equal ( _InIt1  _First1,
_InIt1  _Last1,
_InIt2  _First2 
)
inline
613  { // compare [_First1, _Last1) to [First2, ...)
614  #if _HAS_ITERATOR_DEBUGGING
615  _STLCLRDB_RANGE(_First1, _Last1);
616  if (_First1 != _Last1)
617  _STLCLRDB_POINTER(_First2);
618  #endif /* _HAS_ITERATOR_DEBUGGING */
619  return (cliext::equal_unchecked(
620  _Unchecked(_First1), _Unchecked(_Last1),
621  _Unchecked(_First2)));
622  }
#define _STLCLRDB_POINTER(first)
Definition: memory:221
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
bool equal_unchecked(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2)
Definition: memory:600
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
bool cliext::equal ( const char *  _First1,
const char *  _Last1,
const char *  _First2 
)
inline
628  { // compare [_First1, _Last1) to [First2, ...), for chars
629  #if _HAS_ITERATOR_DEBUGGING
630  _STLCLRDB_RANGE(_First1, _Last1);
631  if (_First1 != _Last1)
632  _STLCLRDB_POINTER(_First2);
633  #endif /* _HAS_ITERATOR_DEBUGGING */
634 
635  return (std::memcmp(_First1, _First2, _Last1 - _First1) == 0);
636  }
#define _STLCLRDB_POINTER(first)
Definition: memory:221
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_Check_return_ int __cdecl memcmp(_In_reads_bytes_(_Size) const void *_Buf1, _In_reads_bytes_(_Size) const void *_Buf2, _In_ size_t _Size)
bool cliext::equal ( const signed char *  _First1,
const signed char *  _Last1,
const signed char *  _First2 
)
inline
640  { // compare [_First1, _Last1) to [First2, ...), for signed chars
641  #if _HAS_ITERATOR_DEBUGGING
642  _STLCLRDB_RANGE(_First1, _Last1);
643  if (_First1 != _Last1)
644  _STLCLRDB_POINTER(_First2);
645  #endif /* _HAS_ITERATOR_DEBUGGING */
646 
647  return (std::memcmp(_First1, _First2, _Last1 - _First1) == 0);
648  }
#define _STLCLRDB_POINTER(first)
Definition: memory:221
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_Check_return_ int __cdecl memcmp(_In_reads_bytes_(_Size) const void *_Buf1, _In_reads_bytes_(_Size) const void *_Buf2, _In_ size_t _Size)
bool cliext::equal ( const unsigned char *  _First1,
const unsigned char *  _Last1,
const unsigned char *  _First2 
)
inline
652  { // compare [_First1, _Last1) to [First2, ...), for unsigned chars
653  #if _HAS_ITERATOR_DEBUGGING
654  _STLCLRDB_RANGE(_First1, _Last1);
655  if (_First1 != _Last1)
656  _STLCLRDB_POINTER(_First2);
657  #endif /* _HAS_ITERATOR_DEBUGGING */
658 
659  return (std::memcmp(_First1, _First2, _Last1 - _First1) == 0);
660  }
#define _STLCLRDB_POINTER(first)
Definition: memory:221
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_Check_return_ int __cdecl memcmp(_In_reads_bytes_(_Size) const void *_Buf1, _In_reads_bytes_(_Size) const void *_Buf2, _In_ size_t _Size)
template<class _InIt1 , class _InIt2 , class _Pr >
bool cliext::equal ( _InIt1  _First1,
_InIt1  _Last1,
_InIt2  _First2,
_Pr  _Pred 
)
inline
681  { // compare [_First1, _Last1) to [First2, ...) using _Pred
682  #if _HAS_ITERATOR_DEBUGGING
683  _STLCLRDB_RANGE(_First1, _Last1);
684  if (_First1 != _Last1)
685  _STLCLRDB_POINTER(_First2);
687  #endif /* _HAS_ITERATOR_DEBUGGING */
688  return (cliext::equal_unchecked(
689  _Unchecked(_First1), _Unchecked(_Last1),
690  _Unchecked(_First2), _Pred));
691  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _STLCLRDB_POINTER(first)
Definition: memory:221
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
bool equal_unchecked(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2)
Definition: memory:600
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
template<class _InIt1 , class _InIt2 >
bool cliext::equal_unchecked ( _InIt1  _First1,
_InIt1  _Last1,
_InIt2  _First2 
)
inline
602  { // compare [_First1, _Last1) to [First2, ...)
603  for (; _First1 != _Last1; ++_First1, ++_First2)
604  if (!(*_First1 == *_First2))
605  return (false);
606  return (true);
607  }
template<class _InIt1 , class _InIt2 , class _Pr >
bool cliext::equal_unchecked ( _InIt1  _First1,
_InIt1  _Last1,
_InIt2  _First2,
_Pr  _Pred 
)
inline
669  { // compare [_First1, _Last1) to [First2, ...) using _Pred
670  for (; _First1 != _Last1; ++_First1, ++_First2)
671  if (!_Pred(*_First1, *_First2))
672  return (false);
673  return (true);
674  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
template<class _FwdIt , class _Ty >
void cliext::fill ( _FwdIt  _First,
_FwdIt  _Last,
const _Ty%  _Val 
)
inline
733  { // copy _Val through [_First, _Last)
734  _STLCLRDB_RANGE(_First, _Last);
736  }
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
void fill_unchecked(_FwdIt _First, _FwdIt _Last, const _Ty%_Val)
Definition: memory:696
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_FwdIt const _Ty _Val
Definition: algorithm:1938
_FwdIt _Last
Definition: algorithm:1936
template<class _OutIt , class _Diff , class _Ty >
void cliext::fill_n ( _OutIt  _First,
_Diff  _Count,
const _Ty%  _Val 
)
inline
780  { // copy _Val _Count times through [_First, ...)
781  #if _HAS_ITERATOR_DEBUGGING
782  if (0 < _Count)
783  _STLCLRDB_POINTER(_First);
784  #endif /* _HAS_ITERATOR_DEBUGGING */
785 
787  }
#define _STLCLRDB_POINTER(first)
Definition: memory:221
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
_Diff _Count
Definition: algorithm:1941
_FwdIt const _Ty _Val
Definition: algorithm:1938
void fill_n_unchecked(_OutIt _First, _Diff _Count, const _Ty%_Val)
Definition: memory:742
template<class _OutIt , class _Diff , class _Ty >
void cliext::fill_n_unchecked ( _OutIt  _First,
_Diff  _Count,
const _Ty%  _Val 
)
inline
743  { // copy _Val _Count times through [_First, ...)
744  for (; 0 < _Count; --_Count, ++_First)
745  *_First = _Val;
746  }
_Diff _Count
Definition: algorithm:1941
_FwdIt const _Ty _Val
Definition: algorithm:1938
void cliext::fill_n_unchecked ( _Out_writes_all_(_Count) char *  _First,
size_t  _Count,
int  _Val 
)
inline
755  { // copy char _Val _Count times through [_First, ...)
756  std::memset(_First, _Val, _Count);
757  }
_Diff _Count
Definition: algorithm:1941
_FwdIt const _Ty _Val
Definition: algorithm:1938
void cliext::fill_n_unchecked ( _Out_writes_all_(_Count) signed char *  _First,
size_t  _Count,
int  _Val 
)
inline
763  { // copy signed char _Val _Count times through [_First, ...)
764  std::memset(_First, _Val, _Count);
765  }
_Diff _Count
Definition: algorithm:1941
_FwdIt const _Ty _Val
Definition: algorithm:1938
void cliext::fill_n_unchecked ( _Out_writes_all_(_Count) unsigned char *  _First,
size_t  _Count,
int  _Val 
)
inline
771  { // copy unsigned char _Val _Count times through [_First, ...)
772  std::memset(_First, _Val, _Count);
773  }
_Diff _Count
Definition: algorithm:1941
_FwdIt const _Ty _Val
Definition: algorithm:1938
template<class _FwdIt , class _Ty >
void cliext::fill_unchecked ( _FwdIt  _First,
_FwdIt  _Last,
const _Ty%  _Val 
)
inline
697  { // copy _Val through [_First, _Last)
698  for (; _First != _Last; ++_First)
699  *_First = _Val;
700  }
_FwdIt const _Ty _Val
Definition: algorithm:1938
_FwdIt _Last
Definition: algorithm:1936
void cliext::fill_unchecked ( _Out_writes_all_(_Last-_First) char *  _First,
_In_opt_ char *  _Last,
int  _Val 
)
inline
709  { // copy char _Val through [_First, _Last)
710  std::memset(_First, _Val, _Last - _First);
711  }
_FwdIt const _Ty _Val
Definition: algorithm:1938
_FwdIt _Last
Definition: algorithm:1936
void cliext::fill_unchecked ( _Out_writes_all_(_Last-_First) signed char *  _First,
_In_opt_ signed char *  _Last,
int  _Val 
)
inline
717  { // copy signed char _Val through [_First, _Last)
718  std::memset(_First, _Val, _Last - _First);
719  }
_FwdIt const _Ty _Val
Definition: algorithm:1938
_FwdIt _Last
Definition: algorithm:1936
void cliext::fill_unchecked ( _Out_writes_all_(_Last-_First) unsigned char *  _First,
_In_opt_ unsigned char *  _Last,
int  _Val 
)
inline
725  { // copy unsigned char _Val through [_First, _Last)
726  std::memset(_First, _Val, _Last - _First);
727  }
_FwdIt const _Ty _Val
Definition: algorithm:1938
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt , class _Ty >
_InIt cliext::find ( _InIt  _First,
_InIt  _Last,
const _Ty%  _Val 
)
inline
48  { // find first matching _Val
49  _STLCLRDB_RANGE(_First, _Last);
51  _Val));
52  }
_InIt find_unchecked(_InIt _First, _InIt _Last, const _Ty%_Val)
Definition: algorithm:37
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_FwdIt const _Ty _Val
Definition: algorithm:1938
_FwdIt _Last
Definition: algorithm:1936
const char* cliext::find ( const char *  _First,
const char *  _Last,
int  _Val 
)
inline
57  { // find first char that matches _Val
58  _STLCLRDB_RANGE(_First, _Last);
59  _First = (const char *)std::memchr(_First, _Val, _Last - _First);
60  return (_First == 0 ? _Last : _First);
61  }
_Check_return_ _CRTIMP _CONST_RETURN void *__cdecl memchr(_In_reads_bytes_opt_(_MaxCount) const void *_Buf, _In_ int _Val, _In_ size_t _MaxCount)
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_FwdIt const _Ty _Val
Definition: algorithm:1938
_FwdIt _Last
Definition: algorithm:1936
const signed char* cliext::find ( const signed char *  _First,
const signed char *  _Last,
int  _Val 
)
inline
65  { // find first signed char that matches _Val
66  _STLCLRDB_RANGE(_First, _Last);
67  _First = (const signed char *)std::memchr(_First, _Val,
68  _Last - _First);
69  return (_First == 0 ? _Last : _First);
70  }
_Check_return_ _CRTIMP _CONST_RETURN void *__cdecl memchr(_In_reads_bytes_opt_(_MaxCount) const void *_Buf, _In_ int _Val, _In_ size_t _MaxCount)
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_FwdIt const _Ty _Val
Definition: algorithm:1938
_FwdIt _Last
Definition: algorithm:1936
const unsigned char* cliext::find ( const unsigned char *  _First,
const unsigned char *  _Last,
int  _Val 
)
inline
74  { // find first unsigned char that matches _Val
75  _STLCLRDB_RANGE(_First, _Last);
76  _First = (const unsigned char *)std::memchr(_First, _Val,
77  _Last - _First);
78  return (_First == 0 ? _Last : _First);
79  }
_Check_return_ _CRTIMP _CONST_RETURN void *__cdecl memchr(_In_reads_bytes_opt_(_MaxCount) const void *_Buf, _In_ int _Val, _In_ size_t _MaxCount)
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_FwdIt const _Ty _Val
Definition: algorithm:1938
_FwdIt _Last
Definition: algorithm:1936
template<class _FwdIt1 , class _FwdIt2 >
_FwdIt1 cliext::find_end ( _FwdIt1  _First1,
_FwdIt1  _Last1,
_FwdIt2  _First2,
_FwdIt2  _Last2 
)
inline
463  { // find last [_First2, _Last2) match
464  _STLCLRDB_RANGE(_First1, _Last1);
465  _STLCLRDB_RANGE(_First2, _Last2);
467  _Unchecked(_First1), _Unchecked(_Last1),
468  _Unchecked(_First2), _Unchecked(_Last2)));
469  }
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
_FwdIt1 find_end_unchecked(_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2)
Definition: algorithm:431
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
_FwdIt1 cliext::find_end ( _FwdIt1  _First1,
_FwdIt1  _Last1,
_FwdIt2  _First2,
_FwdIt2  _Last2,
_Pr  _Pred 
)
inline
508  { // find last [_First2, _Last2) satisfying _Pred
509  _STLCLRDB_RANGE(_First1, _Last1);
510  _STLCLRDB_RANGE(_First2, _Last2);
513  _Unchecked(_First1), _Unchecked(_Last1),
514  _Unchecked(_First2), _Unchecked(_Last2), _Pred));
515  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _STLCLRDB_POINTER(first)
Definition: memory:221
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
_FwdIt1 find_end_unchecked(_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2)
Definition: algorithm:431
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
template<class _FwdIt1 , class _FwdIt2 >
_FwdIt1 cliext::find_end_unchecked ( _FwdIt1  _First1,
_FwdIt1  _Last1,
_FwdIt2  _First2,
_FwdIt2  _Last2 
)
inline
433  { // find last [_First2, _Last2) match
436 
437  _Diff1 _Count1 = 0;
438  _Iter_distance(_First1, _Last1, _Count1);
439  _Diff2 _Count2 = 0;
440  _Iter_distance(_First2, _Last2, _Count2);
441  _FwdIt1 _Ans = _Last1;
442 
443  if (0 < _Count2)
444  for (; _Count2 <= _Count1; ++_First1, --_Count1)
445  { // room for match, try it
446  _FwdIt1 _Mid1 = _First1;
447  for (_FwdIt2 _Mid2 = _First2; ; ++_Mid1)
448  if (!(*_Mid1 == *_Mid2))
449  break;
450  else if (++_Mid2 == _Last2)
451  { // potential answer, save it
452  _Ans = _First1;
453  break;
454  }
455  }
456  return (_Ans);
457  }
_Iter::difference_type difference_type
Definition: xutility:373
_Iter_distance(_First, _Last, _Count)
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
_FwdIt1 cliext::find_end_unchecked ( _FwdIt1  _First1,
_FwdIt1  _Last1,
_FwdIt2  _First2,
_FwdIt2  _Last2,
_Pr  _Pred 
)
inline
477  { // find last [_First2, _Last2) satisfying _Pred
480 
481  _Diff1 _Count1 = 0;
482  _Iter_distance(_First1, _Last1, _Count1);
483  _Diff2 _Count2 = 0;
484  _Iter_distance(_First2, _Last2, _Count2);
485  _FwdIt1 _Ans = _Last1;
486 
487  if (0 < _Count2)
488  for (; _Count2 <= _Count1; ++_First1, --_Count1)
489  { // room for match, try it
490  _FwdIt1 _Mid1 = _First1;
491  for (_FwdIt2 _Mid2 = _First2; ; ++_Mid1)
492  if (!_Pred(*_Mid1, *_Mid2))
493  break;
494  else if (++_Mid2 == _Last2)
495  { // potential answer, save it
496  _Ans = _First1;
497  break;
498  }
499  }
500  return (_Ans);
501  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
_Iter::difference_type difference_type
Definition: xutility:373
_Iter_distance(_First, _Last, _Count)
template<class _FwdIt1 , class _FwdIt2 >
_FwdIt1 cliext::find_first_of ( _FwdIt1  _First1,
_FwdIt1  _Last1,
_FwdIt2  _First2,
_FwdIt2  _Last2 
)
inline
534  { // look for one of [_First2, _Last2) that matches element
535  _STLCLRDB_RANGE(_First1, _Last1);
536  _STLCLRDB_RANGE(_First2, _Last2);
538  _Unchecked(_First1), _Unchecked(_Last1),
539  _Unchecked(_First2), _Unchecked(_Last2)));
540  }
_FwdIt1 find_first_of_unchecked(_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2)
Definition: algorithm:520
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
_FwdIt1 cliext::find_first_of ( _FwdIt1  _First1,
_FwdIt1  _Last1,
_FwdIt2  _First2,
_FwdIt2  _Last2,
_Pr  _Pred 
)
inline
561  { // look for one of [_First2, _Last2) satisfying _Pred with element
562  _STLCLRDB_RANGE(_First1, _Last1);
563  _STLCLRDB_RANGE(_First2, _Last2);
566  _Unchecked(_First1), _Unchecked(_Last1),
567  _Unchecked(_First2), _Unchecked(_Last2), _Pred));
568  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
_FwdIt1 find_first_of_unchecked(_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2)
Definition: algorithm:520
#define _STLCLRDB_POINTER(first)
Definition: memory:221
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
template<class _FwdIt1 , class _FwdIt2 >
_FwdIt1 cliext::find_first_of_unchecked ( _FwdIt1  _First1,
_FwdIt1  _Last1,
_FwdIt2  _First2,
_FwdIt2  _Last2 
)
inline
522  { // look for one of [_First2, _Last2) that matches element
523  for (; _First1 != _Last1; ++_First1)
524  for (_FwdIt2 _Mid2 = _First2; _Mid2 != _Last2; ++_Mid2)
525  if (*_First1 == *_Mid2)
526  return (_First1);
527  return (_First1);
528  }
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
_FwdIt1 cliext::find_first_of_unchecked ( _FwdIt1  _First1,
_FwdIt1  _Last1,
_FwdIt2  _First2,
_FwdIt2  _Last2,
_Pr  _Pred 
)
inline
548  { // look for one of [_First2, _Last2) satisfying _Pred with element
549  for (; _First1 != _Last1; ++_First1)
550  for (_FwdIt2 _Mid2 = _First2; _Mid2 != _Last2; ++_Mid2)
551  if (_Pred(*_First1, *_Mid2))
552  return (_First1);
553  return (_First1);
554  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
template<class _InIt , class _Pr >
_InIt cliext::find_if ( _InIt  _First,
_InIt  _Last,
_Pr  _Pred 
)
inline
96  { // find first satisfying _Pred
97  _STLCLRDB_RANGE(_First, _Last);
100  _Unchecked(_First), _Unchecked(_Last), _Pred));
101  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
_InIt find_if_unchecked(_InIt _First, _InIt _Last, _Pr _Pred)
Definition: algorithm:85
#define _STLCLRDB_POINTER(first)
Definition: memory:221
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt , class _Pr >
_InIt cliext::find_if_unchecked ( _InIt  _First,
_InIt  _Last,
_Pr  _Pred 
)
inline
86  { // find first satisfying _Pred
87  for (; _First != _Last; ++_First)
88  if (_Pred(*_First))
89  break;
90  return (_First);
91  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt , class _Ty >
_InIt cliext::find_unchecked ( _InIt  _First,
_InIt  _Last,
const _Ty%  _Val 
)
inline
38  { // find first matching _Val
39  for (; _First != _Last; ++_First)
40  if (*_First == _Val)
41  break;
42  return (_First);
43  }
_FwdIt const _Ty _Val
Definition: algorithm:1938
_FwdIt _Last
Definition: algorithm:1936
cliext::for ( )
1945  { // divide and conquer, check midpoint
1946  _Diff _Count2 = _Count / 2;
1947  _FwdIt _Mid = _First;
1948  cliext::advance(_Mid, _Count2);
1949 
1950  if (_STLCLRDB_LT(*_Mid, _Val))
1951  { // range begins above _Mid, loop
1952  _First = ++_Mid;
1953  _Count -= _Count2 + 1;
1954  }
1955  else if (_Val < *_Mid)
1956  _Count = _Count2; // range in first half, loop
1957  else
1958  { // range straddles mid, find each end and return
1959  _FwdIt _First2 = lower_bound(_First, _Mid, _Val);
1960  cliext::advance(_First, _Count);
1961  _FwdIt _Last2 = upper_bound(++_Mid, _First, _Val);
1962  return (_PAIR_TYPE(_FwdIt)(_First2, _Last2));
1963  }
1964  }
#define _STLCLRDB_LT(left, right)
Definition: memory:218
#define _PAIR_TYPE(iter_t)
Definition: memory:31
_FwdIt lower_bound(_FwdIt _First, _FwdIt _Last, const _Ty &_Val, _Pr _Pred)
Definition: algorithm:2529
_FwdIt upper_bound(_FwdIt _First, _FwdIt _Last, const _Ty &_Val, _Pr _Pred)
Definition: algorithm:2578
void advance(_InIt_t%_Where, _Diff_t _Off)
Definition: xutility:694
_Diff _Count
Definition: algorithm:1941
_FwdIt const _Ty _Val
Definition: algorithm:1938
cliext::for ( ;;  )
2592  { // partition
2593  for (; _Gfirst < _Last; ++_Gfirst)
2594  if (_STLCLRDB_LT(*_Pfirst, *_Gfirst))
2595  ;
2596  else if (*_Gfirst < *_Pfirst)
2597  break;
2598  else
2600  for (; _First < _Glast; --_Glast)
2601  if (_STLCLRDB_LT(*(_Glast - 1), *_Pfirst))
2602  ;
2603  else if (*_Pfirst < *(_Glast - 1))
2604  break;
2605  else
2606  cliext::iter_swap(--_Pfirst, _Glast - 1);
2607  if (_Glast == _First && _Gfirst == _Last)
2608  return (_PAIR_TYPE(_RanIt)(_Pfirst, _Plast));
2609 
2610  if (_Glast == _First)
2611  { // no room at bottom, rotate pivot upward
2612  if (_Plast != _Gfirst)
2614  ++_Plast;
2616  }
2617  else if (_Gfirst == _Last)
2618  { // no room at top, rotate pivot downward
2619  if (--_Glast != --_Pfirst)
2620  cliext::iter_swap(_Glast, _Pfirst);
2622  }
2623  else
2624  cliext::iter_swap(_Gfirst++, --_Glast);
2625  }
#define _STLCLRDB_LT(left, right)
Definition: memory:218
_RanIt _Plast
Definition: algorithm:2577
#define _PAIR_TYPE(iter_t)
Definition: memory:31
_RanIt _Pfirst
Definition: algorithm:2576
_RanIt _Glast
Definition: algorithm:2589
_RanIt _Gfirst
Definition: algorithm:2588
void iter_swap(_FwdIt1 _Left, _FwdIt2 _Right)
Definition: algorithm:573
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt , class _Fn1 >
_Fn1 cliext::for_each ( _InIt  _First,
_InIt  _Last,
_Fn1  _Func 
)
inline
27  { // perform function for each element
28  _STLCLRDB_RANGE(_First, _Last);
29  _STLCLRDB_POINTER(_Func);
31  _Func));
32  }
#define _STLCLRDB_POINTER(first)
Definition: memory:221
_Fn1 for_each_unchecked(_InIt _First, _InIt _Last, _Fn1 _Func)
Definition: algorithm:17
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt , class _Fn1 >
_Fn1 cliext::for_each_unchecked ( _InIt  _First,
_InIt  _Last,
_Fn1  _Func 
)
inline
18  { // perform function for each element
19  for (; _First != _Last; ++_First)
20  _Func(*_First);
21  return (_Func);
22  }
_FwdIt _Last
Definition: algorithm:1936
template<class _FwdIt , class _Fn0 >
void cliext::generate ( _FwdIt  _First,
_FwdIt  _Last,
_Fn0  _Func 
)
inline
764  { // replace [_First, _Last) with _Func()
765  _STLCLRDB_RANGE(_First, _Last);
766  _STLCLRDB_POINTER(_Func);
768  }
void generate_unchecked(_FwdIt _First, _FwdIt _Last, _Fn0 _Func)
Definition: algorithm:755
#define _STLCLRDB_POINTER(first)
Definition: memory:221
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_FwdIt _Last
Definition: algorithm:1936
template<class _OutIt , class _Diff , class _Fn0 >
void cliext::generate_n ( _OutIt  _Dest,
_Diff  _Count,
_Fn0  _Func 
)
inline
784  { // replace [_Dest, _Dest + _Count) with _Func()
785  _STLCLRDB_POINTER(_Dest);
786  _STLCLRDB_POINTER(_Func);
788  }
#define _STLCLRDB_POINTER(first)
Definition: memory:221
void generate_n_unchecked(_OutIt _Dest, _Diff _Count, _Fn0 _Func)
Definition: algorithm:774
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
_Diff _Count
Definition: algorithm:1941
template<class _OutIt , class _Diff , class _Fn0 >
void cliext::generate_n_unchecked ( _OutIt  _Dest,
_Diff  _Count,
_Fn0  _Func 
)
inline
775  { // replace [_Dest, _Dest + _Count) with _Func()
776  for (; 0 < _Count; --_Count, ++_Dest)
777  *_Dest = _Func();
778  }
_Diff _Count
Definition: algorithm:1941
template<class _FwdIt , class _Fn0 >
void cliext::generate_unchecked ( _FwdIt  _First,
_FwdIt  _Last,
_Fn0  _Func 
)
inline
756  { // replace [_First, _Last) with _Func()
757  for (; _First != _Last; ++_First)
758  *_First = _Func();
759  }
_FwdIt _Last
Definition: algorithm:1936
template<class _Ty >
pair<_Ty *, std::ptrdiff_t> cliext::get_temporary_buffer ( std::ptrdiff_t  _Count)
inline
269  { // get raw temporary buffer of up to _Count elements
270  _Ty *_Pbuf;
271 
272  if (_Count < 0)
273  _Count = 0;
274  for (_Pbuf = 0; 0 < _Count; _Count /= 2)
275  try
276  { // try to allocate storage
277  _Pbuf = (_Ty *)::operator new(_Count * sizeof (_Ty));
278  break;
279  }
280  catch (...)
281  { // loop if new fails
282  }
283 
284  return (pair<_Ty *, std::ptrdiff_t>(_Pbuf, _Count));
285  }
Definition: utility:80
_Diff _Count
Definition: algorithm:1941
int cliext::hash_value ( System::Object^  _Key)
inline
26  { // get hash code from object
27  return (_Key->GetHashCode());
28  }
template<class _InIt1 , class _InIt2 >
bool cliext::includes ( _InIt1  _First1,
_InIt1  _Last1,
_InIt2  _First2,
_InIt2  _Last2 
)
inline
3420  { // test if all [_First1, _Last1) in [_First2, _Last2), using operator<
3421  _STLCLRDB_ORDER(_First1, _Last1);
3422  _STLCLRDB_ORDER(_First2, _Last2);
3424  _Unchecked(_First1), _Unchecked(_Last1),
3425  _Unchecked(_First2), _Unchecked(_Last2)));
3426  }
#define _STLCLRDB_ORDER(first, last)
Definition: memory:223
bool includes_unchecked(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2)
Definition: algorithm:3403
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
template<class _InIt1 , class _InIt2 , class _Pr >
bool cliext::includes ( _InIt1  _First1,
_InIt1  _Last1,
_InIt2  _First2,
_InIt2  _Last2,
_Pr  _Pred 
)
inline
3450  { // test if set [_First1, _Last1) in [_First2, _Last2), using _Pred
3451  _STLCLRDB_ORDER_PRED(_First1, _Last1, _Pred);
3452  _STLCLRDB_ORDER_PRED(_First2, _Last2, _Pred);
3454  _Unchecked(_First1), _Unchecked(_Last1),
3455  _Unchecked(_First2), _Unchecked(_Last2), _Pred));
3456  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
bool includes_unchecked(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2)
Definition: algorithm:3403
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_ORDER_PRED(first, last, pred)
Definition: memory:224
template<class _InIt1 , class _InIt2 >
bool cliext::includes_unchecked ( _InIt1  _First1,
_InIt1  _Last1,
_InIt2  _First2,
_InIt2  _Last2 
)
inline
3405  { // test if all [_First1, _Last1) in [_First2, _Last2), using operator<
3406  for (; _First1 != _Last1 && _First2 != _Last2; )
3407  if (_STLCLRDB_LT(*_First2, *_First1))
3408  return (false);
3409  else if (*_First1 < *_First2)
3410  ++_First1;
3411  else
3412  ++_First1, ++_First2;
3413  return (_First2 == _Last2);
3414  }
#define _STLCLRDB_LT(left, right)
Definition: memory:218
template<class _InIt1 , class _InIt2 , class _Pr >
bool cliext::includes_unchecked ( _InIt1  _First1,
_InIt1  _Last1,
_InIt2  _First2,
_InIt2  _Last2,
_Pr  _Pred 
)
inline
3434  { // test if set [_First1, _Last1) in [_First2, _Last2), using _Pred
3435  for (; _First1 != _Last1 && _First2 != _Last2; )
3436  if (_STLCLRDB_LT_PRED(_Pred, *_First2, *_First1))
3437  return (false);
3438  else if (_Pred(*_First1, *_First2))
3439  ++_First1;
3440  else
3441  ++_First1, ++_First2;
3442  return (_First2 == _Last2);
3443  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _STLCLRDB_LT_PRED(pred, left, right)
Definition: memory:219
template<class _InIt1 , class _InIt2 , class _Ty >
_Ty cliext::inner_product ( _InIt1  _First1,
_InIt1  _Last1,
_InIt2  _First2,
_Ty  _Val 
)
inline
67  { // return inner product of sequences
68  _STLCLRDB_RANGE(_First1, _Last1);
69  _STLCLRDB_POINTER(_First2);
71  _Unchecked(_First1), _Unchecked(_Last1),
72  _Unchecked(_First2), _Val));
73  }
#define _STLCLRDB_POINTER(first)
Definition: memory:221
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_FwdIt const _Ty _Val
Definition: algorithm:1938
_Ty inner_product_unchecked(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Ty _Val)
Definition: numeric:54
template<class _InIt1 , class _InIt2 , class _Ty , class _Fn21 , class _Fn22 >
_Ty cliext::inner_product ( _InIt1  _First1,
_InIt1  _Last1,
_InIt2  _First2,
_Ty  _Val,
_Fn21  _Func1,
_Fn22  _Func2 
)
inline
96  { // return inner product of sequences, using _Func1 and _Func2
97  _STLCLRDB_RANGE(_First1, _Last1);
98  _STLCLRDB_POINTER(_First2);
99  _STLCLRDB_POINTER(_Func1);
100  _STLCLRDB_POINTER(_Func2);
102  _Unchecked(_First1), _Unchecked(_Last1),
103  _Unchecked(_First2), _Val, _Func1, _Func2));
104  }
#define _STLCLRDB_POINTER(first)
Definition: memory:221
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_FwdIt const _Ty _Val
Definition: algorithm:1938
_Ty inner_product_unchecked(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Ty _Val)
Definition: numeric:54
template<class _InIt1 , class _InIt2 , class _Ty >
_Ty cliext::inner_product_unchecked ( _InIt1  _First1,
_InIt1  _Last1,
_InIt2  _First2,
_Ty  _Val 
)
inline
56  { // return inner product of sequences
57  for (; _First1 != _Last1; ++_First1, ++_First2)
58  _Val = _Val + *_First1 * *_First2;
59  return (_Val);
60  }
_FwdIt const _Ty _Val
Definition: algorithm:1938
template<class _InIt1 , class _InIt2 , class _Ty , class _Fn21 , class _Fn22 >
_Ty cliext::inner_product_unchecked ( _InIt1  _First1,
_InIt1  _Last1,
_InIt2  _First2,
_Ty  _Val,
_Fn21  _Func1,
_Fn22  _Func2 
)
inline
83  { // return inner product of sequences, using _Func1 and _Func2
84  for (; _First1 != _Last1; ++_First1, ++_First2)
85  _Val = _Func1(_Val, _Func2(*_First1, *_First2));
86  return (_Val);
87  }
_FwdIt const _Ty _Val
Definition: algorithm:1938
template<class _BidIt >
void cliext::inplace_merge ( _BidIt  _First,
_BidIt  _Mid,
_BidIt  _Last 
)
inline
2345  { // merge [_First, _Mid) with [_Mid, _Last), using operator<
2346  _STLCLRDB_ORDER(_First, _Mid);
2347  _STLCLRDB_ORDER(_Mid, _Last);
2349  _Unchecked(_First), _Unchecked(_Mid), _Unchecked(_Last));
2350  }
#define _STLCLRDB_ORDER(first, last)
Definition: memory:223
void inplace_merge_unchecked(_BidIt _First, _BidIt _Mid, _BidIt _Last)
Definition: algorithm:2324
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
_FwdIt _Last
Definition: algorithm:1936
template<class _BidIt , class _Pr >
void cliext::inplace_merge ( _BidIt  _First,
_BidIt  _Mid,
_BidIt  _Last,
_Pr  _Pred 
)
inline
2510  { // merge [_First, _Mid) with [_Mid, _Last), using _Pred
2511  _STLCLRDB_ORDER_PRED(_First, _Mid, _Pred);
2514  _Unchecked(_First), _Unchecked(_Mid), _Unchecked(_Last), _Pred);
2515  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
void inplace_merge_unchecked(_BidIt _First, _BidIt _Mid, _BidIt _Last)
Definition: algorithm:2324
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_ORDER_PRED(first, last, pred)
Definition: memory:224
_FwdIt _Last
Definition: algorithm:1936
template<class _BidIt >
void cliext::inplace_merge_unchecked ( _BidIt  _First,
_BidIt  _Mid,
_BidIt  _Last 
)
inline
2325  { // merge [_First, _Mid) with [_Mid, _Last), using operator<
2328 
2329  if (_First != _Mid && _Mid != _Last)
2330  { // merge nontrivial sequence
2331  _Diff _Count1 = 0;
2332  _Iter_distance(_First, _Mid, _Count1);
2333  _Diff _Count2 = 0;
2334  _Iter_distance(_Mid, _Last, _Count2);
2335  _TEMP_ITER(_BidIt, _Ty)
2336  _Tempbuf(_Count1 < _Count2 ? _Count1 : _Count2);
2337 
2338  cliext::_XBuffered_merge(_First, _Mid, _Last,
2339  _Count1, _Count2, _Tempbuf);
2340  }
2341  }
_Iter::difference_type difference_type
Definition: xutility:373
#define _TEMP_ITER(iter_t, value_t)
Definition: memory:244
_Iter_distance(_First, _Last, _Count)
_Iter::value_type value_type
Definition: xutility:372
void _XBuffered_merge(_BidIt _First, _BidIt _Mid, _BidIt _Last, _Diff _Count1, _Diff _Count2, _Temp_iterator< _Ty > _Tempbuf, _Pr _Pred)
Definition: algorithm:2375
Definition: adapter:7
_FwdIt _Last
Definition: algorithm:1936
template<class _BidIt , class _Pr >
void cliext::inplace_merge_unchecked ( _BidIt  _First,
_BidIt  _Mid,
_BidIt  _Last,
_Pr  _Pred 
)
inline
2489  { // merge [_First, _Mid) with [_Mid, _Last), using _Pred
2492 
2493  if (_First != _Mid && _Mid != _Last)
2494  { // merge nontrivial sequence
2495  _Diff _Count1 = 0;
2496  _Iter_distance(_First, _Mid, _Count1);
2497  _Diff _Count2 = 0;
2498  _Iter_distance(_Mid, _Last, _Count2);
2499  _TEMP_ITER(_BidIt, _Ty)
2500  _Tempbuf(_Count1 < _Count2 ? _Count1 : _Count2);
2501  cliext::_XBuffered_merge(_First, _Mid, _Last,
2502  _Count1, _Count2, _Tempbuf, _Pred);
2503  }
2504  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
_Iter::difference_type difference_type
Definition: xutility:373
#define _TEMP_ITER(iter_t, value_t)
Definition: memory:244
_Iter_distance(_First, _Last, _Count)
_Iter::value_type value_type
Definition: xutility:372
void _XBuffered_merge(_BidIt _First, _BidIt _Mid, _BidIt _Last, _Diff _Count1, _Diff _Count2, _Temp_iterator< _Ty > _Tempbuf, _Pr _Pred)
Definition: algorithm:2375
Definition: adapter:7
_FwdIt _Last
Definition: algorithm:1936
template<class _FwdIt1 , class _FwdIt2 >
void cliext::iter_swap ( _FwdIt1  _Left,
_FwdIt2  _Right 
)
inline
574  { // swap *_Left and *_Right
575  cliext::swap(*_Left, *_Right);
576  }
void swap(deque< _Value_t >%_Left, deque< _Value_t >%_Right)
Definition: deque:1660
const _Ty & _Right
Definition: algorithm:4087
template<class _InIt1 , class _InIt2 >
bool cliext::lexicographical_compare ( _InIt1  _First1,
_InIt1  _Last1,
_InIt2  _First2,
_InIt2  _Last2 
)
inline
832  { // order [_First1, _Last1) vs. [First2, Last2)
833  _STLCLRDB_RANGE(_First1, _Last1);
834  _STLCLRDB_RANGE(_First2, _Last2);
836  _Unchecked(_First1), _Unchecked(_Last1),
837  _Unchecked(_First2), _Unchecked(_Last2)));
838  }
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
bool lexicographical_compare_unchecked(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2)
Definition: memory:792
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
template<class _InIt1 , class _InIt2 , class _Pr >
bool cliext::lexicographical_compare ( _InIt1  _First1,
_InIt1  _Last1,
_InIt2  _First2,
_InIt2  _Last2,
_Pr  _Pred 
)
inline
860  { // order [_First1, _Last1) vs. [First2, Last2) using _Pred
861  _STLCLRDB_RANGE(_First1, _Last1);
862  _STLCLRDB_RANGE(_First2, _Last2);
865  _Unchecked(_First1), _Unchecked(_Last1),
866  _Unchecked(_First2), _Unchecked(_Last2), _Pred));
867  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _STLCLRDB_POINTER(first)
Definition: memory:221
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
bool lexicographical_compare_unchecked(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2)
Definition: memory:792
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
template<class _InIt1 , class _InIt2 >
bool cliext::lexicographical_compare_unchecked ( _InIt1  _First1,
_InIt1  _Last1,
_InIt2  _First2,
_InIt2  _Last2 
)
inline
794  { // order [_First1, _Last1) vs. [First2, Last2)
795  for (; _First1 != _Last1 && _First2 != _Last2; ++_First1, ++_First2)
796  if (_STLCLRDB_LT(*_First1, *_First2))
797  return (true);
798  else if (*_First2 < *_First1)
799  return (false);
800  return (_First1 == _Last1 && _First2 != _Last2);
801  }
#define _STLCLRDB_LT(left, right)
Definition: memory:218
bool cliext::lexicographical_compare_unchecked ( const unsigned char *  _First1,
const unsigned char *  _Last1,
const unsigned char *  _First2,
const unsigned char *  _Last2 
)
inline
808  { // order [_First1, _Last1) vs. [First2, Last2), for unsigned char
809  std::ptrdiff_t _Num1 = _Last1 - _First1;
810  std::ptrdiff_t _Num2 = _Last2 - _First2;
811  int _Ans = std::memcmp(_First1, _First2, _Num1 < _Num2 ? _Num1 : _Num2);
812  return (_Ans < 0 || _Ans == 0 && _Num1 < _Num2);
813  }
_W64 int ptrdiff_t
Definition: crtdefs.h:530
_Check_return_ int __cdecl memcmp(_In_reads_bytes_(_Size) const void *_Buf1, _In_reads_bytes_(_Size) const void *_Buf2, _In_ size_t _Size)
bool cliext::lexicographical_compare_unchecked ( const char *  _First1,
const char *  _Last1,
const char *  _First2,
const char *  _Last2 
)
inline
819  { // order [_First1, _Last1) vs. [First2, Last2), for nonnegative char
820  std::ptrdiff_t _Num1 = _Last1 - _First1;
821  std::ptrdiff_t _Num2 = _Last2 - _First2;
822  int _Ans = std::memcmp(_First1, _First2, _Num1 < _Num2 ? _Num1 : _Num2);
823  return (_Ans < 0 || _Ans == 0 && _Num1 < _Num2);
824  }
_W64 int ptrdiff_t
Definition: crtdefs.h:530
_Check_return_ int __cdecl memcmp(_In_reads_bytes_(_Size) const void *_Buf1, _In_reads_bytes_(_Size) const void *_Buf2, _In_ size_t _Size)
template<class _InIt1 , class _InIt2 , class _Pr >
bool cliext::lexicographical_compare_unchecked ( _InIt1  _First1,
_InIt1  _Last1,
_InIt2  _First2,
_InIt2  _Last2,
_Pr  _Pred 
)
inline
846  { // order [_First1, _Last1) vs. [First2, Last2) using _Pred
847  for (; _First1 != _Last1 && _First2 != _Last2; ++_First1, ++_First2)
848  if (_STLCLRDB_LT_PRED(_Pred, *_First1, *_First2))
849  return (true);
850  else if (_Pred(*_First2, *_First1))
851  return (false);
852  return (_First1 == _Last1 && _First2 != _Last2);
853  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _STLCLRDB_LT_PRED(pred, left, right)
Definition: memory:219
template<class _FwdIt , class _Ty >
_FwdIt cliext::lower_bound ( _FwdIt  _First,
_FwdIt  _Last,
_Ty%  _Val 
)
inline
1822  { // find first element not before _Val, using operator<
1823  _STLCLRDB_ORDER(_First, _Last);
1825  _Unchecked(_First), _Unchecked(_Last), _Val));
1826  }
_FwdIt lower_bound_unchecked(_FwdIt _First, _FwdIt _Last, _Ty%_Val)
Definition: algorithm:1797
#define _STLCLRDB_ORDER(first, last)
Definition: memory:223
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
_FwdIt const _Ty _Val
Definition: algorithm:1938
_FwdIt _Last
Definition: algorithm:1936
template<class _FwdIt , class _Ty , class _Pr >
_FwdIt cliext::lower_bound ( _FwdIt  _First,
_FwdIt  _Last,
const _Ty%  _Val,
_Pr  _Pred 
)
inline
1858  { // find first element not before _Val, using _Pred
1859  _STLCLRDB_ORDER_PRED(_First, _Last, _Pred);
1861  _Unchecked(_First), _Unchecked(_Last), _Val, _Pred));
1862  }
_FwdIt lower_bound_unchecked(_FwdIt _First, _FwdIt _Last, _Ty%_Val)
Definition: algorithm:1797
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_ORDER_PRED(first, last, pred)
Definition: memory:224
_FwdIt const _Ty _Val
Definition: algorithm:1938
_FwdIt _Last
Definition: algorithm:1936
template<class _FwdIt , class _Ty >
_FwdIt cliext::lower_bound_unchecked ( _FwdIt  _First,
_FwdIt  _Last,
_Ty%  _Val 
)
inline
1799  { // find first element not before _Val, using operator<
1801 
1802  _Diff _Count = 0;
1803  _Iter_distance(_First, _Last, _Count);
1804 
1805  for (; 0 < _Count; )
1806  { // divide and conquer, find half that contains answer
1807  _Diff _Count2 = _Count / 2;
1808  _FwdIt _Mid = _First;
1809  cliext::advance(_Mid, _Count2);
1810 
1811  if (_STLCLRDB_LT(*_Mid, _Val))
1812  _First = ++_Mid, _Count -= _Count2 + 1;
1813  else
1814  _Count = _Count2;
1815  }
1816  return (_First);
1817  }
#define _STLCLRDB_LT(left, right)
Definition: memory:218
_Iter::difference_type difference_type
Definition: xutility:373
_Iter_distance(_First, _Last, _Count)
void advance(_InIt_t%_Where, _Diff_t _Off)
Definition: xutility:694
_Diff _Count
Definition: algorithm:1941
_FwdIt const _Ty _Val
Definition: algorithm:1938
_FwdIt _Last
Definition: algorithm:1936
template<class _FwdIt , class _Ty , class _Pr >
_FwdIt cliext::lower_bound_unchecked ( _FwdIt  _First,
_FwdIt  _Last,
const _Ty%  _Val,
_Pr  _Pred 
)
inline
1834  { // find first element not before _Val, using _Pred
1836 
1837  _Diff _Count = 0;
1838  _Iter_distance(_First, _Last, _Count);
1839  for (; 0 < _Count; )
1840  { // divide and conquer, find half that contains answer
1841  _Diff _Count2 = _Count / 2;
1842  _FwdIt _Mid = _First;
1843  cliext::advance(_Mid, _Count2);
1844 
1845  if (_STLCLRDB_LT_PRED(_Pred, *_Mid, _Val))
1846  _First = ++_Mid, _Count -= _Count2 + 1;
1847  else
1848  _Count = _Count2;
1849  }
1850  return (_First);
1851  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _STLCLRDB_LT_PRED(pred, left, right)
Definition: memory:219
_Iter::difference_type difference_type
Definition: xutility:373
_Iter_distance(_First, _Last, _Count)
void advance(_InIt_t%_Where, _Diff_t _Off)
Definition: xutility:694
_Diff _Count
Definition: algorithm:1941
_FwdIt const _Ty _Val
Definition: algorithm:1938
_FwdIt _Last
Definition: algorithm:1936
template<typename _Iter_t >
range_adapter<_Iter_t> cliext::make_collection ( _Iter_t  _First,
_Iter_t  _Last 
)
inline
1478  { // wrap an iterator pair
1479  return (gcnew range_adapter<_Iter_t>(_First, _Last));
1480  }
_FwdIt _Last
Definition: algorithm:1936
template<typename _Arg_t >
comparer_less<_Arg_t, System::Collections::Generic::IComparer<_Arg_t> > cliext::make_comparer_less ( System::Collections::Generic::IComparer< _Arg_t >^  _Comp)
inline
1074  { // make comparer less from IComparer<T>
1075  typedef System::Collections::Generic::IComparer<_Arg_t> _Mycomp_t;
1076 
1077  return (gcnew comparer_less<_Arg_t, _Mycomp_t>(_Comp));
1078  }
comparer_less<System::Object^, System::Collections::IComparer> cliext::make_comparer_less ( System::Collections::IComparer^  _Comp)
inline
1082  { // make comparer less from IComparer
1083  typedef System::Collections::IComparer _Mycomp_t;
1084 
1085  return (gcnew comparer_less<System::Object^, _Mycomp_t>(_Comp));
1086  }
template<class _RanIt >
void cliext::make_heap ( _RanIt  _First,
_RanIt  _Last 
)
inline
1722  { // make [_First, _Last) into a heap, using operator<
1723  _STLCLRDB_RANGE(_First, _Last);
1725  }
void make_heap_unchecked(_RanIt _First, _RanIt _Last)
Definition: algorithm:1702
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_FwdIt _Last
Definition: algorithm:1936
template<class _RanIt , class _Pr >
void cliext::make_heap ( _RanIt  _First,
_RanIt  _Last,
_Pr  _Pred 
)
inline
1751  { // make [_First, _Last) into a heap, using _Pred
1752  _STLCLRDB_RANGE(_First, _Last);
1755  _Pred);
1756  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _STLCLRDB_POINTER(first)
Definition: memory:221
void make_heap_unchecked(_RanIt _First, _RanIt _Last)
Definition: algorithm:1702
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_FwdIt _Last
Definition: algorithm:1936
template<class _RanIt >
void cliext::make_heap_unchecked ( _RanIt  _First,
_RanIt  _Last 
)
inline
1703  { // make [_First, _Last) into a heap, using operator<
1706 
1707  if (1 < _Last - _First)
1708  { // make nontrivial heap
1709  _Diff _Bottom = _Last - _First;
1710 
1711  for (_Diff _Hole = _Bottom / 2; 0 < _Hole; )
1712  { // reheap top half, bottom to top
1713  --_Hole;
1714  cliext::_XAdjust_heap(_First, _Hole, _Bottom,
1715  _Ty(*(_First + _Hole)));
1716  }
1717  }
1718  }
_Iter::difference_type difference_type
Definition: xutility:373
_Iter::value_type value_type
Definition: xutility:372
void _XAdjust_heap(_RanIt _First, _Diff _Hole, _Diff _Bottom, _Ty _Val)
Definition: algorithm:1590
_FwdIt _Last
Definition: algorithm:1936
template<class _RanIt , class _Pr >
void cliext::make_heap_unchecked ( _RanIt  _First,
_RanIt  _Last,
_Pr  _Pred 
)
inline
1731  { // make [_First, _Last) into a heap, using _Pred
1734 
1735  if (1 < _Last - _First)
1736  { // make nontrivial heap
1737  _Diff _Bottom = _Last - _First;
1738 
1739  for (_Diff _Hole = _Bottom / 2; 0 < _Hole; )
1740  { // reheap top half, bottom to top
1741  --_Hole;
1742  cliext::_XAdjust_heap(_First, _Hole, _Bottom,
1743  _Ty(*(_First + _Hole)), _Pred);
1744  }
1745  }
1746  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
_Iter::difference_type difference_type
Definition: xutility:373
_Iter::value_type value_type
Definition: xutility:372
void _XAdjust_heap(_RanIt _First, _Diff _Hole, _Diff _Bottom, _Ty _Val)
Definition: algorithm:1590
_FwdIt _Last
Definition: algorithm:1936
template<class _Ty1 , class _Ty2 >
pair<_Ty1, _Ty2> cliext::make_pair ( _Ty1  _Val1,
_Ty2  _Val2 
)
inline
162  { // return pair composed from arguments
163  return (pair<_Ty1, _Ty2>(_Val1, _Val2));
164  }
_Types1 &&::value _Val2
Definition: tuple:759
Definition: utility:80
template<class _Ty >
const _Ty() cliext::max ( const _Ty%  _Left,
const _Ty%  _Right 
)
inline
872  { // return larger of _Left and _Right
873  return (_STLCLRDB_LT(_Left, _Right) ? _Right : _Left);
874  }
#define _STLCLRDB_LT(left, right)
Definition: memory:218
const _Ty & _Right
Definition: algorithm:4087
template<class _Ty , class _Pr >
const _Ty() cliext::max ( const _Ty%  _Left,
const _Ty%  _Right,
_Pr  _Pred 
)
inline
880  { // return larger of _Left and _Right using _Pred
881  return (_STLCLRDB_LT_PRED(_Pred, _Left, _Right) ? _Right : _Left);
882  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _STLCLRDB_LT_PRED(pred, left, right)
Definition: memory:219
const _Ty & _Right
Definition: algorithm:4087
template<class _FwdIt >
_FwdIt cliext::max_element ( _FwdIt  _First,
_FwdIt  _Last 
)
inline
3732  { // find largest element, using operator<
3733  _STLCLRDB_RANGE(_First, _Last);
3735  _Unchecked(_First), _Unchecked(_Last)));
3736  }
_FwdIt max_element_unchecked(_FwdIt _First, _FwdIt _Last)
Definition: algorithm:3720
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_FwdIt _Last
Definition: algorithm:1936
template<class _FwdIt , class _Pr >
_FwdIt cliext::max_element ( _FwdIt  _First,
_FwdIt  _Last,
_Pr  _Pred 
)
inline
3754  { // find largest element, using _Pred
3755  _STLCLRDB_RANGE(_First, _Last);
3758  _Unchecked(_First), _Unchecked(_Last), _Pred));
3759  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _STLCLRDB_POINTER(first)
Definition: memory:221
_FwdIt max_element_unchecked(_FwdIt _First, _FwdIt _Last)
Definition: algorithm:3720
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_FwdIt _Last
Definition: algorithm:1936
template<class _FwdIt >
_FwdIt cliext::max_element_unchecked ( _FwdIt  _First,
_FwdIt  _Last 
)
inline
3721  { // find largest element, using operator<
3722  _FwdIt _Found = _First;
3723  if (_First != _Last)
3724  for (; ++_First != _Last; )
3725  if (_STLCLRDB_LT(*_Found, *_First))
3726  _Found = _First;
3727  return (_Found);
3728  }
#define _STLCLRDB_LT(left, right)
Definition: memory:218
_FwdIt _Last
Definition: algorithm:1936
template<class _FwdIt , class _Pr >
_FwdIt cliext::max_element_unchecked ( _FwdIt  _First,
_FwdIt  _Last,
_Pr  _Pred 
)
inline
3742  { // find largest element, using _Pred
3743  _FwdIt _Found = _First;
3744  if (_First != _Last)
3745  for (; ++_First != _Last; )
3746  if (_STLCLRDB_LT_PRED(_Pred, *_Found, *_First))
3747  _Found = _First;
3748  return (_Found);
3749  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _STLCLRDB_LT_PRED(pred, left, right)
Definition: memory:219
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt1 , class _InIt2 , class _OutIt >
_OutIt cliext::merge ( _InIt1  _First1,
_InIt1  _Last1,
_InIt2  _First2,
_InIt2  _Last2,
_OutIt  _Dest 
)
inline
2091  { // copy merging ranges, both using operator<
2092  _STLCLRDB_ORDER(_First1, _Last1);
2093  _STLCLRDB_ORDER(_First2, _Last2);
2094  _STLCLRDB_POINTER(_Dest);
2095  return (cliext::merge_unchecked(
2096  _Unchecked(_First1), _Unchecked(_Last1),
2097  _Unchecked(_First2), _Unchecked(_Last2),
2098  _Unchecked(_Dest)));
2099  }
_OutIt merge_unchecked(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
Definition: algorithm:2073
#define _STLCLRDB_ORDER(first, last)
Definition: memory:223
#define _STLCLRDB_POINTER(first)
Definition: memory:221
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
template<class _InIt1 , class _InIt2 , class _OutIt , class _Pr >
_OutIt cliext::merge ( _InIt1  _First1,
_InIt1  _Last1,
_InIt2  _First2,
_InIt2  _Last2,
_OutIt  _Dest,
_Pr  _Pred 
)
inline
2125  { // copy merging ranges, both using _Pred
2126  _STLCLRDB_ORDER_PRED(_First1, _Last1, _Pred);
2127  _STLCLRDB_ORDER_PRED(_First2, _Last2, _Pred);
2128  _STLCLRDB_POINTER(_Dest);
2129  return (cliext::merge_unchecked(
2130  _Unchecked(_First1), _Unchecked(_Last1),
2131  _Unchecked(_First2), _Unchecked(_Last2),
2132  _Unchecked(_Dest), _Pred));
2133  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
_OutIt merge_unchecked(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
Definition: algorithm:2073
#define _STLCLRDB_POINTER(first)
Definition: memory:221
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_ORDER_PRED(first, last, pred)
Definition: memory:224
template<class _InIt1 , class _InIt2 , class _OutIt >
_OutIt cliext::merge_unchecked ( _InIt1  _First1,
_InIt1  _Last1,
_InIt2  _First2,
_InIt2  _Last2,
_OutIt  _Dest 
)
inline
2075  { // copy merging ranges, both using operator<
2076  for (; _First1 != _Last1 && _First2 != _Last2; ++_Dest)
2077  if (_STLCLRDB_LT(*_First2, *_First1))
2078  *_Dest = *_First2, ++_First2;
2079  else
2080  *_Dest = *_First1, ++_First1;
2081 
2082  _Dest = cliext::copy_unchecked(_First1, _Last1, _Dest); // copy any tail
2083  return (cliext::copy_unchecked(_First2, _Last2, _Dest));
2084  }
#define _STLCLRDB_LT(left, right)
Definition: memory:218
_OutIt copy_unchecked(_InIt _First, _InIt _Last, _OutIt _Dest)
Definition: memory:490
template<class _InIt1 , class _InIt2 , class _OutIt , class _Pr >
_OutIt cliext::merge_unchecked ( _InIt1  _First1,
_InIt1  _Last1,
_InIt2  _First2,
_InIt2  _Last2,
_OutIt  _Dest,
_Pr  _Pred 
)
inline
2108  { // copy merging ranges, both using _Pred
2109  for (; _First1 != _Last1 && _First2 != _Last2; ++_Dest)
2110  if (_STLCLRDB_LT_PRED(_Pred, *_First2, *_First1))
2111  *_Dest = *_First2, ++_First2;
2112  else
2113  *_Dest = *_First1, ++_First1;
2114 
2115  _Dest = cliext::copy_unchecked(_First1, _Last1, _Dest); // copy any tail
2116  return (cliext::copy_unchecked(_First2, _Last2, _Dest));
2117  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _STLCLRDB_LT_PRED(pred, left, right)
Definition: memory:219
_OutIt copy_unchecked(_InIt _First, _InIt _Last, _OutIt _Dest)
Definition: memory:490
template<class _Ty >
const _Ty() cliext::min ( const _Ty%  _Left,
const _Ty%  _Right 
)
inline
887  { // return smaller of _Left and _Right
888  return (_STLCLRDB_LT(_Right, _Left) ? _Right : _Left);
889  }
#define _STLCLRDB_LT(left, right)
Definition: memory:218
const _Ty & _Right
Definition: algorithm:4087
template<class _Ty , class _Pr >
const _Ty() cliext::min ( const _Ty%  _Left,
const _Ty%  _Right,
_Pr  _Pred 
)
inline
895  { // return smaller of _Left and _Right using _Pred
896  return (_STLCLRDB_LT_PRED(_Pred, _Right, _Left) ? _Right : _Left);
897  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _STLCLRDB_LT_PRED(pred, left, right)
Definition: memory:219
const _Ty & _Right
Definition: algorithm:4087
template<class _FwdIt >
_FwdIt cliext::min_element ( _FwdIt  _First,
_FwdIt  _Last 
)
inline
3775  { // find smallest element, using operator<
3776  _STLCLRDB_RANGE(_First, _Last);
3778  _Unchecked(_First), _Unchecked(_Last)));
3779  }
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_FwdIt min_element_unchecked(_FwdIt _First, _FwdIt _Last)
Definition: algorithm:3763
_FwdIt _Last
Definition: algorithm:1936
template<class _FwdIt , class _Pr >
_FwdIt cliext::min_element ( _FwdIt  _First,
_FwdIt  _Last,
_Pr  _Pred 
)
inline
3797  { // find smallest element, using _Pred
3798  _STLCLRDB_RANGE(_First, _Last);
3801  _Unchecked(_First), _Unchecked(_Last), _Pred));
3802  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _STLCLRDB_POINTER(first)
Definition: memory:221
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_FwdIt min_element_unchecked(_FwdIt _First, _FwdIt _Last)
Definition: algorithm:3763
_FwdIt _Last
Definition: algorithm:1936
template<class _FwdIt >
_FwdIt cliext::min_element_unchecked ( _FwdIt  _First,
_FwdIt  _Last 
)
inline
3764  { // find smallest element, using operator<
3765  _FwdIt _Found = _First;
3766  if (_First != _Last)
3767  for (; ++_First != _Last; )
3768  if (_STLCLRDB_LT(*_First, *_Found))
3769  _Found = _First;
3770  return (_Found);
3771  }
#define _STLCLRDB_LT(left, right)
Definition: memory:218
_FwdIt _Last
Definition: algorithm:1936
template<class _FwdIt , class _Pr >
_FwdIt cliext::min_element_unchecked ( _FwdIt  _First,
_FwdIt  _Last,
_Pr  _Pred 
)
inline
3785  { // find smallest element, using _Pred
3786  _FwdIt _Found = _First;
3787  if (_First != _Last)
3788  for (; ++_First != _Last; )
3789  if (_STLCLRDB_LT_PRED(_Pred, *_First, *_Found))
3790  _Found = _First;
3791  return (_Found);
3792  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _STLCLRDB_LT_PRED(pred, left, right)
Definition: memory:219
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt1 , class _InIt2 >
cliext::mismatch ( _InIt1  _First1,
_InIt1  _Last1,
_InIt2  _First2 
)
inline
553  { // return [_First1, _Last1) and [_First2, _Last2) mismatch
554  #if _HAS_ITERATOR_DEBUGGING
555  _STLCLRDB_RANGE(_First1, _Last1);
556  if (_First1 != _Last1)
557  _STLCLRDB_POINTER(_First2);
558  #endif /* _HAS_ITERATOR_DEBUGGING */
559 
561  _Unchecked(_First1), _Unchecked(_Last1),
562  _Unchecked(_First2)));
563  }
#define _STLCLRDB_POINTER(first)
Definition: memory:221
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
mismatch_unchecked(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2)
Definition: memory:540
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
template<class _InIt1 , class _InIt2 , class _Pr >
cliext::mismatch ( _InIt1  _First1,
_InIt1  _Last1,
_InIt2  _First2,
_Pr  _Pred 
)
inline
584  { // return [_First1, _Last1) and [_First2, _Last2) mismatch using _Pred
585  #if _HAS_ITERATOR_DEBUGGING
586  _STLCLRDB_RANGE(_First1, _Last1);
587  if (_First1 != _Last1)
588  _STLCLRDB_POINTER(_First2);
590  #endif /* _HAS_ITERATOR_DEBUGGING */
591 
593  _Unchecked(_First1), _Unchecked(_Last1),
594  _Unchecked(_First2), _Pred));
595  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _STLCLRDB_POINTER(first)
Definition: memory:221
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
mismatch_unchecked(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2)
Definition: memory:540
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
template<class _InIt1 , class _InIt2 >
cliext::mismatch_unchecked ( _InIt1  _First1,
_InIt1  _Last1,
_InIt2  _First2 
)
inline
542  { // return [_First1, _Last1) and [_First2, _Last2) mismatch
543  for (; _First1 != _Last1 && *_First1 == *_First2; )
544  ++_First1, ++_First2;
545  return (_PAIR_TYPE2(_InIt1, _InIt2)(_First1, _First2));
546  }
#define _PAIR_TYPE2(iter1_t, iter2_t)
Definition: memory:34
template<class _InIt1 , class _InIt2 , class _Pr >
cliext::mismatch_unchecked ( _InIt1  _First1,
_InIt1  _Last1,
_InIt2  _First2,
_Pr  _Pred 
)
inline
572  { // return [_First1, _Last1) and [_First2, _Last2) mismatch using _Pred
573  for (; _First1 != _Last1 && _Pred(*_First1, *_First2); )
574  ++_First1, ++_First2;
575  return (_PAIR_TYPE2(_InIt1, _InIt2)(_First1, _First2));
576  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _PAIR_TYPE2(iter1_t, iter2_t)
Definition: memory:34
template<class _BidIt >
bool cliext::next_permutation ( _BidIt  _First,
_BidIt  _Last 
)
inline
3835  { // permute and test for pure ascending, using operator<
3836  _STLCLRDB_RANGE(_First, _Last);
3838  _Unchecked(_First), _Unchecked(_Last)));
3839  }
bool next_permutation_unchecked(_BidIt _First, _BidIt _Last)
Definition: algorithm:3806
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_FwdIt _Last
Definition: algorithm:1936
template<class _BidIt , class _Pr >
bool cliext::next_permutation ( _BidIt  _First,
_BidIt  _Last,
_Pr  _Pred 
)
inline
3874  { // permute and test for pure ascending, using _Pred
3875  _STLCLRDB_RANGE(_First, _Last);
3878  _Unchecked(_First), _Unchecked(_Last), _Pred));
3879  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
bool next_permutation_unchecked(_BidIt _First, _BidIt _Last)
Definition: algorithm:3806
#define _STLCLRDB_POINTER(first)
Definition: memory:221
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_FwdIt _Last
Definition: algorithm:1936
template<class _BidIt >
bool cliext::next_permutation_unchecked ( _BidIt  _First,
_BidIt  _Last 
)
inline
3807  { // permute and test for pure ascending, using operator<
3808  _BidIt _Next = _Last;
3809  if (_First == _Last || _First == --_Next)
3810  return (false);
3811 
3812  for (; ; )
3813  { // find rightmost element smaller than successor
3814  _BidIt _Next1 = _Next;
3815  if (_STLCLRDB_LT(*--_Next, *_Next1))
3816  { // swap with rightmost element that's smaller, flip suffix
3817  _BidIt _Mid = _Last;
3818  for (; !_STLCLRDB_LT(*_Next, *--_Mid); )
3819  ;
3820  cliext::iter_swap(_Next, _Mid);
3821  cliext::reverse(_Next1, _Last);
3822  return (true);
3823  }
3824 
3825  if (_Next == _First)
3826  { // pure descending, flip all
3827  cliext::reverse(_First, _Last);
3828  return (false);
3829  }
3830  }
3831  }
void reverse(_BidIt _First, _BidIt _Last)
Definition: algorithm:1105
#define _STLCLRDB_LT(left, right)
Definition: memory:218
void iter_swap(_FwdIt1 _Left, _FwdIt2 _Right)
Definition: algorithm:573
_FwdIt _Last
Definition: algorithm:1936
template<class _BidIt , class _Pr >
bool cliext::next_permutation_unchecked ( _BidIt  _First,
_BidIt  _Last,
_Pr  _Pred 
)
inline
3845  { // permute and test for pure ascending, using _Pred
3846  _BidIt _Next = _Last;
3847  if (_First == _Last || _First == --_Next)
3848  return (false);
3849 
3850  for (; ; )
3851  { // find rightmost element smaller than successor
3852  _BidIt _Next1 = _Next;
3853  if (_STLCLRDB_LT_PRED(_Pred, *--_Next, *_Next1))
3854  { // swap with rightmost element that's smaller, flip suffix
3855  _BidIt _Mid = _Last;
3856  for (; !_STLCLRDB_LT_PRED(_Pred, *_Next, *--_Mid); )
3857  ;
3858  cliext::iter_swap(_Next, _Mid);
3859  cliext::reverse(_Next1, _Last);
3860  return (true);
3861  }
3862 
3863  if (_Next == _First)
3864  { // pure descending, flip all
3865  cliext::reverse(_First, _Last);
3866  return (false);
3867  }
3868  }
3869  }
void reverse(_BidIt _First, _BidIt _Last)
Definition: algorithm:1105
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _STLCLRDB_LT_PRED(pred, left, right)
Definition: memory:219
void iter_swap(_FwdIt1 _Left, _FwdIt2 _Right)
Definition: algorithm:573
_FwdIt _Last
Definition: algorithm:1936
template<typename _Fun_t >
unary_negate<_Fun_t> cliext::not1 ( _Fun_t%  _Func)
inline
753  { // return a unary_negate functor adapter
754  return (unary_negate<_Fun_t>(_Func));
755  }
Definition: xfunctional:387
template<typename _Fun_t >
binary_negate<_Fun_t> cliext::not2 ( _Fun_t%  _Func)
inline
838  { // return a binary_negate functor adapter
839  return (binary_negate<_Fun_t>(_Func));
840  }
Definition: xfunctional:414
template<class _RanIt >
void cliext::nth_element ( _RanIt  _First,
_RanIt  _Nth,
_RanIt  _Last 
)
inline
3360  { // order Nth element, using operator<
3361  _STLCLRDB_RANGE(_First, _Nth);
3362  _STLCLRDB_RANGE(_Nth, _Last);
3364  _Unchecked(_First), _Unchecked(_Nth), _Unchecked(_Last));
3365  }
void nth_element_unchecked(_RanIt _First, _RanIt _Nth, _RanIt _Last)
Definition: algorithm:3340
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_FwdIt _Last
Definition: algorithm:1936
template<class _RanIt , class _Pr >
void cliext::nth_element ( _RanIt  _First,
_RanIt  _Nth,
_RanIt  _Last,
_Pr  _Pred 
)
inline
3392  { // order Nth element, using _Pred
3393  _STLCLRDB_RANGE(_First, _Nth);
3394  _STLCLRDB_RANGE(_Nth, _Last);
3397  _Unchecked(_First), _Unchecked(_Nth), _Unchecked(_Last), _Pred);
3398  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
void nth_element_unchecked(_RanIt _First, _RanIt _Nth, _RanIt _Last)
Definition: algorithm:3340
#define _STLCLRDB_POINTER(first)
Definition: memory:221
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_FwdIt _Last
Definition: algorithm:1936
template<class _RanIt >
void cliext::nth_element_unchecked ( _RanIt  _First,
_RanIt  _Nth,
_RanIt  _Last 
)
inline
3341  { // order Nth element, using operator<
3342  for (; _ISort::_Max < _Last - _First; )
3343  { // divide and conquer, ordering partition containing Nth
3344  _PAIR_TYPE(_RanIt) _Mid =
3345  cliext::_XUnguarded_partition(_First, _Last);
3346 
3347  if (_Mid.second <= _Nth)
3348  _First = _Mid.second;
3349  else if (_Mid.first <= _Nth)
3350  return; // Nth inside fat pivot, done
3351  else
3352  _Last = _Mid.first;
3353  }
3354 
3355  cliext::_XInsertion_sort(_First, _Last); // sort any remainder
3356  }
else
Definition: vccorlib.h:1721
#define _PAIR_TYPE(iter_t)
Definition: memory:31
return(cliext::equal_range_unchecked(_Unchecked(_First), _Unchecked(_Last), _Val, _Pred))
if(__pUnknown!=*__ppTargetUnknown)
Definition: vccorlib.h:394
Definition: adapter:7
void _XInsertion_sort(_BidIt _First, _BidIt _Last, _Pr _Pred)
Definition: algorithm:2676
_FwdIt _Last
Definition: algorithm:1936
template<class _RanIt , class _Pr >
void cliext::nth_element_unchecked ( _RanIt  _First,
_RanIt  _Nth,
_RanIt  _Last,
_Pr  _Pred 
)
inline
3372  { // order Nth element, using _Pred
3373  for (; _ISort::_Max < _Last - _First; )
3374  { // divide and conquer, ordering partition containing Nth
3375  _PAIR_TYPE(_RanIt) _Mid =
3376  cliext::_XUnguarded_partition(_First, _Last, _Pred);
3377 
3378  if (_Mid.second <= _Nth)
3379  _First = _Mid.second;
3380  else if (_Mid.first <= _Nth)
3381  return; // Nth inside fat pivot, done
3382  else
3383  _Last = _Mid.first;
3384  }
3385 
3386  cliext::_XInsertion_sort(_First, _Last, _Pred); // sort any remainder
3387  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
else
Definition: vccorlib.h:1721
#define _PAIR_TYPE(iter_t)
Definition: memory:31
return(cliext::equal_range_unchecked(_Unchecked(_First), _Unchecked(_Last), _Val, _Pred))
if(__pUnknown!=*__ppTargetUnknown)
Definition: vccorlib.h:394
Definition: adapter:7
void _XInsertion_sort(_BidIt _First, _BidIt _Last, _Pr _Pred)
Definition: algorithm:2676
_FwdIt _Last
Definition: algorithm:1936
template<class _Ty1 , class _Ty2 >
bool cliext::operator!= ( pair< _Ty1, _Ty2 >%  _Left,
pair< _Ty1, _Ty2 >%  _Right 
)
inline
122  { // test for pair inequality
123  return (!(_Left == _Right));
124  }
template<typename _Value_t >
bool cliext::operator!= ( System::IComparable< _Value_t >^  _Left,
System::IComparable< _Value_t >^  _Right 
)
260  { // test if _Left != _Right
261  return (!(_Left == _Right));
262  }
void * _Right
Definition: utility:36
template<typename _Value_t >
bool cliext::operator!= ( System::IComparable< _Value_t >%  _Left,
System::IComparable< _Value_t >%  _Right 
)
302  { // test if _Left != _Right
303  return (!(_Left == _Right));
304  }
void * _Right
Definition: utility:36
bool cliext::operator!= ( System::IComparable^  _Left,
System::IComparable^  _Right 
)
inline
342  { // test if _Left != _Right
343  return (!(_Left == _Right));
344  }
void * _Right
Definition: utility:36
bool cliext::operator!= ( System::IComparable%  _Left,
System::IComparable%  _Right 
)
inline
378  { // test if _Left != _Right
379  return (!(_Left == _Right));
380  }
void * _Right
Definition: utility:36
template<typename _Value_t , typename _Cont_t >
bool cliext::operator!= ( stack< _Value_t, _Cont_t >%  _Left,
stack< _Value_t, _Cont_t >%  _Right 
)
382  { // test if _Left != _Right
383  return (!(_Left == _Right));
384  }
template<typename _Value_t , typename _Cont_t >
bool cliext::operator!= ( queue< _Value_t, _Cont_t >%  _Left,
queue< _Value_t, _Cont_t >%  _Right 
)
inline
427  { // test if _Left != _Right
428  return (!(_Left == _Right));
429  }
template<typename _Traits_t >
bool cliext::operator!= ( cliext::impl::tree< _Traits_t >%  _Left,
cliext::impl::tree< _Traits_t >%  _Right 
)
inline
1392  { // test if _Left != _Right
1393  return (!(_Left == _Right));
1394  }
template<typename _Value_t >
bool cliext::operator!= ( vector< _Value_t >%  _Left,
vector< _Value_t >%  _Right 
)
inline
1419  { // test if _Left != _Right
1420  return (!(_Left == _Right));
1421  }
template<typename _Value_t >
bool cliext::operator!= ( deque< _Value_t >%  _Left,
deque< _Value_t >%  _Right 
)
inline
1617  { // test if _Left != _Right
1618  return (!(_Left == _Right));
1619  }
template<typename _Value_t >
bool cliext::operator!= ( list< _Value_t >%  _Left,
list< _Value_t >%  _Right 
)
inline
1805  { // test if _Left != _Right
1806  return (!(_Left == _Right));
1807  }
template<class _Ty1 , class _Ty2 >
bool cliext::operator< ( pair< _Ty1, _Ty2 >%  _Left,
pair< _Ty1, _Ty2 >%  _Right 
)
inline
130  { // test if _Left < _Right for pairs
131  return (_Left.first < _Right.first ||
132  !(_Right.first < _Left.first) && _Left.second < _Right.second);
133  }
_Ty1 first
Definition: utility:198
second
Definition: utility:167
template<typename _Value_t >
bool cliext::operator< ( System::IComparable< _Value_t >^  _Left,
System::IComparable< _Value_t >^  _Right 
)
267  { // test if _Left < _Right
268  return (_Left->CompareTo(_Right) < 0);
269  }
void * _Right
Definition: utility:36
template<typename _Value_t >
bool cliext::operator< ( System::IComparable< _Value_t >%  _Left,
System::IComparable< _Value_t >%  _Right 
)
309  { // test if _Left < _Right
310  return (_Left.CompareTo((_Value_t)%(System::Object%)_Right) < 0);
311  }
void * _Right
Definition: utility:36
bool cliext::operator< ( System::IComparable^  _Left,
System::IComparable^  _Right 
)
inline
348  { // test if _Left < _Right
349  return (_Left->CompareTo(_Right) < 0);
350  }
void * _Right
Definition: utility:36
bool cliext::operator< ( System::IComparable%  _Left,
System::IComparable%  _Right 
)
inline
384  { // test if _Left < _Right
385  return (_Left.CompareTo(%(System::Object%)_Right) < 0);
386  }
void * _Right
Definition: utility:36
template<typename _Value_t , typename _Cont_t >
bool cliext::operator< ( stack< _Value_t, _Cont_t >%  _Left,
stack< _Value_t, _Cont_t >%  _Right 
)
390  { // test if _Left < _Right
391  return (*_Left.get_container() < *_Right.get_container());
392  }
template<typename _Value_t , typename _Cont_t >
bool cliext::operator< ( queue< _Value_t, _Cont_t >%  _Left,
queue< _Value_t, _Cont_t >%  _Right 
)
inline
435  { // test if _Left < _Right
436  return (*_Left.get_container() < *_Right.get_container());
437  }
template<typename _Traits_t >
bool cliext::operator< ( cliext::impl::tree< _Traits_t >%  _Left,
cliext::impl::tree< _Traits_t >%  _Right 
)
inline
1399  { // test if _Left < _Right
1400  typedef cliext::impl::tree<_Traits_t> _Mytype_t;
1401 
1402  _Mytype_t::size_type _Idx = 0;
1403  _Mytype_t::node_type^ _Pleft = _Left.front_node();
1404  _Mytype_t::node_type^ _Pright = _Right.front_node();
1405  _Mytype_t::key_compare^ _Pred = _Left.key_comp();
1406 
1407  for (; _Idx != _Left.size() && _Idx != _Right.size(); ++_Idx)
1408  { // compare next two elements
1409  if (_Pred(_Left.get_key(_Pleft->_Myval),
1410  _Right.get_key(_Pright->_Myval)))
1411  return (true);
1412  else if (_Pred(_Right.get_key(_Pright->_Myval),
1413  _Left.get_key(_Pleft->_Myval)))
1414  return (false);
1415  _Pleft = _Pleft->next_node();
1416  _Pright = _Pright->next_node();
1417  }
1418  return (_Idx == _Left.size() && _Idx != _Right.size());
1419  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
key_compare key_comp() new
Definition: xtree:337
Definition: xtree:177
size_type size()
Definition: xtree:379
node_type front_node()
Definition: xtree:297
template<typename _Value_t >
bool cliext::operator< ( vector< _Value_t >%  _Left,
vector< _Value_t >%  _Right 
)
inline
1426  { // test if _Left < _Right
1427  vector<_Value_t>::size_type _Idx = 0;
1428 
1429  for (; _Idx != _Left.size() && _Idx != _Right.size(); ++_Idx)
1430  if (_Left.at(_Idx) < _Right.at(_Idx))
1431  return (true);
1432  else if (_Right.at(_Idx) < _Left.at(_Idx))
1433  return (false);
1434  return (_Idx == _Left.size() && _Idx != _Right.size());
1435  }
const_reference at(size_type _Pos) const
Definition: vector:1166
size_type size() const _NOEXCEPT
Definition: vector:1146
_Mybase::size_type size_type
Definition: vector:662
template<typename _Value_t >
bool cliext::operator< ( deque< _Value_t >%  _Left,
deque< _Value_t >%  _Right 
)
inline
1624  { // test if _Left < _Right
1625  deque<_Value_t>::size_type _Idx = 0;
1626 
1627  for (; _Idx != _Left.size() && _Idx != _Right.size(); ++_Idx)
1628  if (_Left.at(_Idx) < _Right.at(_Idx))
1629  return (true);
1630  else if (_Right.at(_Idx) < _Left.at(_Idx))
1631  return (false);
1632  return (_Idx == _Left.size() && _Idx != _Right.size());
1633  }
const_reference at(size_type _Pos) const
Definition: deque:1370
size_type size() const _NOEXCEPT
Definition: deque:1350
_Mybase::size_type size_type
Definition: deque:934
template<typename _Value_t >
bool cliext::operator< ( list< _Value_t >%  _Left,
list< _Value_t >%  _Right 
)
inline
1812  { // test if _Left < _Right
1813  typedef list<_Value_t> _Mytype_t;
1814 
1815  _Mytype_t::size_type _Idx = 0;
1816  _Mytype_t::node_type^ _Pleft = _Left.front_node();
1817  _Mytype_t::node_type^ _Pright = _Right.front_node();
1818 
1819  for (; _Idx != _Left.size() && _Idx != _Right.size(); ++_Idx)
1820  { // compare next two elements
1821  if (_Pleft->_Myval < _Pright->_Myval)
1822  return (true);
1823  else if (_Pright->_Myval < _Pleft->_Myval)
1824  return (false);
1825  _Pleft = _Pleft->_Next;
1826  _Pright = _Pright->_Next;
1827  }
1828  return (_Idx == _Left.size() && _Idx != _Right.size());
1829  }
Definition: list:860
size_type size() const _NOEXCEPT
Definition: list:1234
template<class _Ty1 , class _Ty2 >
bool cliext::operator<= ( pair< _Ty1, _Ty2 >%  _Left,
pair< _Ty1, _Ty2 >%  _Right 
)
inline
147  { // test if _Left <= _Right for pairs
148  return (!(_Right < _Left));
149  }
template<typename _Value_t >
bool cliext::operator<= ( System::IComparable< _Value_t >^  _Left,
System::IComparable< _Value_t >^  _Right 
)
288  { // test if _Left <= _Right
289  return (!(_Right < _Left));
290  }
void * _Right
Definition: utility:36
template<typename _Value_t >
bool cliext::operator<= ( System::IComparable< _Value_t >%  _Left,
System::IComparable< _Value_t >%  _Right 
)
330  { // test if _Left <= _Right
331  return (!(_Right < _Left));
332  }
void * _Right
Definition: utility:36
bool cliext::operator<= ( System::IComparable^  _Left,
System::IComparable^  _Right 
)
inline
366  { // test if _Left <= _Right
367  return (!(_Right < _Left));
368  }
void * _Right
Definition: utility:36
bool cliext::operator<= ( System::IComparable%  _Left,
System::IComparable%  _Right 
)
inline
402  { // test if _Left <= _Right
403  return (!(_Right < _Left));
404  }
void * _Right
Definition: utility:36
template<typename _Value_t , typename _Cont_t >
bool cliext::operator<= ( stack< _Value_t, _Cont_t >%  _Left,
stack< _Value_t, _Cont_t >%  _Right 
)
414  { // test if _Left <= _Right
415  return (!(_Right < _Left));
416  }
template<typename _Value_t , typename _Cont_t >
bool cliext::operator<= ( queue< _Value_t, _Cont_t >%  _Left,
queue< _Value_t, _Cont_t >%  _Right 
)
inline
459  { // test if _Left <= _Right
460  return (!(_Right < _Left));
461  }
template<typename _Traits_t >
bool cliext::operator<= ( cliext::impl::tree< _Traits_t >%  _Left,
cliext::impl::tree< _Traits_t >%  _Right 
)
inline
1438  { // test if _Left <= _Right
1439  return (!(_Right < _Left));
1440  }
template<typename _Value_t >
bool cliext::operator<= ( vector< _Value_t >%  _Left,
vector< _Value_t >%  _Right 
)
inline
1454  { // test if _Left <= _Right
1455  return (!(_Right < _Left));
1456  }
template<typename _Value_t >
bool cliext::operator<= ( deque< _Value_t >%  _Left,
deque< _Value_t >%  _Right 
)
inline
1652  { // test if _Left <= _Right
1653  return (!(_Right < _Left));
1654  }
template<typename _Value_t >
bool cliext::operator<= ( list< _Value_t >%  _Left,
list< _Value_t >%  _Right 
)
inline
1848  { // test if _Left <= _Right
1849  return (!(_Right < _Left));
1850  }
template<class _Ty1 , class _Ty2 >
bool cliext::operator== ( pair< _Ty1, _Ty2 >%  _Left,
pair< _Ty1, _Ty2 >%  _Right 
)
inline
114  { // test for pair equality
115  return (_Left.first == _Right.first && _Left.second == _Right.second);
116  }
_Ty1 first
Definition: utility:198
second
Definition: utility:167
template<typename _Value_t >
bool cliext::operator== ( System::IComparable< _Value_t >^  _Left,
System::IComparable< _Value_t >^  _Right 
)
253  { // test if _Left == _Right
254  return (_Left->CompareTo(_Right) == 0);
255  }
void * _Right
Definition: utility:36
template<typename _Value_t >
bool cliext::operator== ( System::IComparable< _Value_t >%  _Left,
System::IComparable< _Value_t >%  _Right 
)
295  { // test if _Left == _Right
296  return (_Left.CompareTo((_Value_t)%(System::Object%)_Right) == 0);
297  }
void * _Right
Definition: utility:36
bool cliext::operator== ( System::IComparable^  _Left,
System::IComparable^  _Right 
)
inline
336  { // test if _Left == _Right
337  return (_Left->CompareTo(_Right) == 0);
338  }
void * _Right
Definition: utility:36
bool cliext::operator== ( System::IComparable%  _Left,
System::IComparable%  _Right 
)
inline
372  { // test if _Left == _Right
373  return (_Left.CompareTo(%(System::Object%)_Right) == 0);
374  }
void * _Right
Definition: utility:36
template<typename _Value_t , typename _Cont_t >
bool cliext::operator== ( stack< _Value_t, _Cont_t >%  _Left,
stack< _Value_t, _Cont_t >%  _Right 
)
374  { // test if _Left == _Right
375  return (*_Left.get_container() == *_Right.get_container());
376  }
template<typename _Value_t , typename _Cont_t >
bool cliext::operator== ( queue< _Value_t, _Cont_t >%  _Left,
queue< _Value_t, _Cont_t >%  _Right 
)
inline
419  { // test if _Left == _Right
420  return (*_Left.get_container() == *_Right.get_container());
421  }
template<typename _Traits_t >
bool cliext::operator== ( cliext::impl::tree< _Traits_t >%  _Left,
cliext::impl::tree< _Traits_t >%  _Right 
)
inline
1362  { // test if _Left == _Right
1363  typedef cliext::impl::tree<_Traits_t> _Mytype_t;
1364 
1365  _Mytype_t::size_type _Size = _Left.size();
1366 
1367  if (_Size != _Right.size())
1368  return (false);
1369  else
1370  { // same length, compare elements
1371  _Mytype_t::node_type^ _Pleft = _Left.front_node();
1372  _Mytype_t::node_type^ _Pright = _Right.front_node();
1373  _Mytype_t::key_compare^ _Pred = _Left.key_comp();
1374 
1375  for (; 0 < _Size; --_Size)
1376  { // compare next two elements
1377  if (_Pred(_Left.get_key(_Pleft->_Myval),
1378  _Right.get_key(_Pright->_Myval))
1379  || _Pred(_Right.get_key(_Pright->_Myval),
1380  _Left.get_key(_Pleft->_Myval)))
1381  return (false);
1382  _Pleft = _Pleft->next_node();
1383  _Pright = _Pright->next_node();
1384  }
1385  return (true);
1386  }
1387  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
key_compare key_comp() new
Definition: xtree:337
Definition: xtree:177
size_type size()
Definition: xtree:379
node_type front_node()
Definition: xtree:297
_Check_return_ _In_ long _Size
Definition: io.h:325
template<typename _Value_t >
bool cliext::operator== ( vector< _Value_t >%  _Left,
vector< _Value_t >%  _Right 
)
inline
1402  { // test if _Left == _Right
1404 
1405  if (_Size != _Right.size())
1406  return (false);
1407  else
1408  { // same length, compare elements
1409  for (int _Idx = 0; _Idx != _Size; ++_Idx)
1410  if (_Left.at(_Idx) != _Right.at(_Idx))
1411  return (false);
1412  return (true);
1413  }
1414  }
const_reference at(size_type _Pos) const
Definition: vector:1166
size_type size() const _NOEXCEPT
Definition: vector:1146
_Mybase::size_type size_type
Definition: vector:662
_Check_return_ _In_ long _Size
Definition: io.h:325
template<typename _Value_t >
bool cliext::operator== ( deque< _Value_t >%  _Left,
deque< _Value_t >%  _Right 
)
inline
1600  { // test if _Left == _Right
1602 
1603  if (_Size != _Right.size())
1604  return (false);
1605  else
1606  { // same length, compare elements
1607  for (int _Idx = 0; _Idx != _Size; ++_Idx)
1608  if (_Left.at(_Idx) != _Right.at(_Idx))
1609  return (false);
1610  return (true);
1611  }
1612  }
const_reference at(size_type _Pos) const
Definition: deque:1370
size_type size() const _NOEXCEPT
Definition: deque:1350
_Mybase::size_type size_type
Definition: deque:934
_Check_return_ _In_ long _Size
Definition: io.h:325
template<typename _Value_t >
bool cliext::operator== ( list< _Value_t >%  _Left,
list< _Value_t >%  _Right 
)
inline
1779  { // test if _Left == _Right
1780  typedef list<_Value_t> _Mytype_t;
1781 
1782  _Mytype_t::size_type _Size = _Left.size();
1783 
1784  if (_Size != _Right.size())
1785  return (false);
1786  else
1787  { // same length, compare elements
1788  _Mytype_t::node_type^ _Pleft = _Left.front_node();
1789  _Mytype_t::node_type^ _Pright = _Right.front_node();
1790 
1791  for (; 0 < _Size; --_Size)
1792  { // compare next two elements
1793  if (_Pleft->_Myval != _Pright->_Myval)
1794  return (false);
1795  _Pleft = _Pleft->_Next;
1796  _Pright = _Pright->_Next;
1797  }
1798  return (true);
1799  }
1800  }
Definition: list:860
size_type size() const _NOEXCEPT
Definition: list:1234
_Check_return_ _In_ long _Size
Definition: io.h:325
template<class _Ty1 , class _Ty2 >
bool cliext::operator> ( pair< _Ty1, _Ty2 >%  _Left,
pair< _Ty1, _Ty2 >%  _Right 
)
inline
139  { // test if _Left > _Right for pairs
140  return (_Right < _Left);
141  }
template<typename _Value_t >
bool cliext::operator> ( System::IComparable< _Value_t >^  _Left,
System::IComparable< _Value_t >^  _Right 
)
281  { // test if _Left > _Right
282  return (_Right < _Left);
283  }
void * _Right
Definition: utility:36
template<typename _Value_t >
bool cliext::operator> ( System::IComparable< _Value_t >%  _Left,
System::IComparable< _Value_t >%  _Right 
)
323  { // test if _Left > _Right
324  return (_Right < _Left);
325  }
void * _Right
Definition: utility:36
bool cliext::operator> ( System::IComparable^  _Left,
System::IComparable^  _Right 
)
inline
360  { // test if _Left > _Right
361  return (_Right < _Left);
362  }
void * _Right
Definition: utility:36
bool cliext::operator> ( System::IComparable%  _Left,
System::IComparable%  _Right 
)
inline
396  { // test if _Left > _Right
397  return (_Right < _Left);
398  }
void * _Right
Definition: utility:36
template<typename _Value_t , typename _Cont_t >
bool cliext::operator> ( stack< _Value_t, _Cont_t >%  _Left,
stack< _Value_t, _Cont_t >%  _Right 
)
406  { // test if _Left > _Right
407  return (_Right < _Left);
408  }
template<typename _Value_t , typename _Cont_t >
bool cliext::operator> ( queue< _Value_t, _Cont_t >%  _Left,
queue< _Value_t, _Cont_t >%  _Right 
)
inline
451  { // test if _Left > _Right
452  return (_Right < _Left);
453  }
template<typename _Traits_t >
bool cliext::operator> ( cliext::impl::tree< _Traits_t >%  _Left,
cliext::impl::tree< _Traits_t >%  _Right 
)
inline
1431  { // test if _Left > _Right
1432  return (_Right < _Left);
1433  }
template<typename _Value_t >
bool cliext::operator> ( vector< _Value_t >%  _Left,
vector< _Value_t >%  _Right 
)
inline
1447  { // test if _Left > _Right
1448  return (_Right < _Left);
1449  }
template<typename _Value_t >
bool cliext::operator> ( deque< _Value_t >%  _Left,
deque< _Value_t >%  _Right 
)
inline
1645  { // test if _Left > _Right
1646  return (_Right < _Left);
1647  }
template<typename _Value_t >
bool cliext::operator> ( list< _Value_t >%  _Left,
list< _Value_t >%  _Right 
)
inline
1841  { // test if _Left > _Right
1842  return (_Right < _Left);
1843  }
template<class _Ty1 , class _Ty2 >
bool cliext::operator>= ( pair< _Ty1, _Ty2 >%  _Left,
pair< _Ty1, _Ty2 >%  _Right 
)
inline
155  { // test if _Left >= _Right for pairs
156  return (!(_Left < _Right));
157  }
template<typename _Value_t >
bool cliext::operator>= ( System::IComparable< _Value_t >^  _Left,
System::IComparable< _Value_t >^  _Right 
)
274  { // test if _Left >= _Right
275  return (!(_Left < _Right));
276  }
void * _Right
Definition: utility:36
template<typename _Value_t >
bool cliext::operator>= ( System::IComparable< _Value_t >%  _Left,
System::IComparable< _Value_t >%  _Right 
)
316  { // test if _Left >= _Right
317  return (!(_Left < _Right));
318  }
void * _Right
Definition: utility:36
bool cliext::operator>= ( System::IComparable^  _Left,
System::IComparable^  _Right 
)
inline
354  { // test if _Left >= _Right
355  return (!(_Left < _Right));
356  }
void * _Right
Definition: utility:36
bool cliext::operator>= ( System::IComparable%  _Left,
System::IComparable%  _Right 
)
inline
390  { // test if _Left >= _Right
391  return (!(_Left < _Right));
392  }
void * _Right
Definition: utility:36
template<typename _Value_t , typename _Cont_t >
bool cliext::operator>= ( stack< _Value_t, _Cont_t >%  _Left,
stack< _Value_t, _Cont_t >%  _Right 
)
398  { // test if _Left >= _Right
399  return (!(_Left < _Right));
400  }
template<typename _Value_t , typename _Cont_t >
bool cliext::operator>= ( queue< _Value_t, _Cont_t >%  _Left,
queue< _Value_t, _Cont_t >%  _Right 
)
inline
443  { // test if _Left >= _Right
444  return (!(_Left < _Right));
445  }
template<typename _Traits_t >
bool cliext::operator>= ( cliext::impl::tree< _Traits_t >%  _Left,
cliext::impl::tree< _Traits_t >%  _Right 
)
inline
1424  { // test if _Left >= _Right
1425  return (!(_Left < _Right));
1426  }
template<typename _Value_t >
bool cliext::operator>= ( vector< _Value_t >%  _Left,
vector< _Value_t >%  _Right 
)
inline
1440  { // test if _Left >= _Right
1441  return (!(_Left < _Right));
1442  }
template<typename _Value_t >
bool cliext::operator>= ( deque< _Value_t >%  _Left,
deque< _Value_t >%  _Right 
)
inline
1638  { // test if _Left >= _Right
1639  return (!(_Left < _Right));
1640  }
template<typename _Value_t >
bool cliext::operator>= ( list< _Value_t >%  _Left,
list< _Value_t >%  _Right 
)
inline
1834  { // test if _Left >= _Right
1835  return (!(_Left < _Right));
1836  }
template<class _RanIt >
void cliext::partial_sort ( _RanIt  _First,
_RanIt  _Mid,
_RanIt  _Last 
)
inline
3216  { // order [First, _Last) up to _Mid, using operator<
3217  _STLCLRDB_RANGE(_First, _Mid);
3218  _STLCLRDB_RANGE(_Mid, _Last);
3220  _Unchecked(_First), _Unchecked(_Mid), _Unchecked(_Last));
3221  }
void partial_sort_unchecked(_RanIt _First, _RanIt _Mid, _RanIt _Last)
Definition: algorithm:3201
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_FwdIt _Last
Definition: algorithm:1936
template<class _RanIt , class _Pr >
void cliext::partial_sort ( _RanIt  _First,
_RanIt  _Mid,
_RanIt  _Last,
_Pr  _Pred 
)
inline
3243  { // order [First, _Last) up to _Mid, using _Pred
3244  _STLCLRDB_RANGE(_First, _Mid);
3245  _STLCLRDB_RANGE(_Mid, _Last);
3248  _Unchecked(_First), _Unchecked(_Mid), _Unchecked(_Last), _Pred);
3249  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _STLCLRDB_POINTER(first)
Definition: memory:221
void partial_sort_unchecked(_RanIt _First, _RanIt _Mid, _RanIt _Last)
Definition: algorithm:3201
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt , class _RanIt >
_RanIt cliext::partial_sort_copy ( _InIt  _First1,
_InIt  _Last1,
_RanIt  _First2,
_RanIt  _Last2 
)
inline
3285  { // copy [First1, _Last1) into [_First2, _Last2), using operator<
3286  _STLCLRDB_RANGE(_First1, _Last1);
3287  _STLCLRDB_RANGE(_First2, _Last2);
3289  _Unchecked(_First1), _Unchecked(_Last1),
3290  _Unchecked(_First2), _Unchecked(_Last2)));
3291  }
_RanIt partial_sort_copy_unchecked(_InIt _First1, _InIt _Last1, _RanIt _First2, _RanIt _Last2)
Definition: algorithm:3254
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
template<class _InIt , class _RanIt , class _Pr >
_RanIt cliext::partial_sort_copy ( _InIt  _First1,
_InIt  _Last1,
_RanIt  _First2,
_RanIt  _Last2,
_Pr  _Pred 
)
inline
3329  { // copy [First1, _Last1) into [_First2, _Last2) using _Pred
3330  _STLCLRDB_RANGE(_First1, _Last1);
3331  _STLCLRDB_RANGE(_First2, _Last2);
3334  _Unchecked(_First1), _Unchecked(_Last1),
3335  _Unchecked(_First2), _Unchecked(_Last2), _Pred));
3336  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
_RanIt partial_sort_copy_unchecked(_InIt _First1, _InIt _Last1, _RanIt _First2, _RanIt _Last2)
Definition: algorithm:3254
#define _STLCLRDB_POINTER(first)
Definition: memory:221
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
template<class _InIt , class _RanIt >
_RanIt cliext::partial_sort_copy_unchecked ( _InIt  _First1,
_InIt  _Last1,
_RanIt  _First2,
_RanIt  _Last2 
)
inline
3256  { // copy [First1, _Last1) into [_First2, _Last2), using operator<
3259 
3260  if (_First1 == _Last1 || _First2 == _Last2)
3261  return (_First2);
3262  else
3263  { // copy and sort nontrivial
3264  _RanIt _Mid2 = _First2;
3265 
3266  for (; _First1 != _Last1 && _Mid2 != _Last2; ++_First1, ++_Mid2)
3267  *_Mid2 = *_First1; // copy min(_Last1-_First1, _Last2-_First2)
3268  cliext::make_heap_unchecked(_First2, _Mid2);
3269 
3270  for (; _First1 != _Last1; ++_First1)
3271  if (_STLCLRDB_LT(*_First1, *_First2))
3272  cliext::_XAdjust_heap(_First2, _Diff(0),
3273  _Diff(_Mid2 - _First2),
3274  _Ty(*_First1)); // replace top with new largest
3275 
3276  cliext::sort_heap_unchecked(_First2, _Mid2);
3277  return (_Mid2);
3278  }
3279  }
#define _STLCLRDB_LT(left, right)
Definition: memory:218
_Iter::difference_type difference_type
Definition: xutility:373
void make_heap_unchecked(_RanIt _First, _RanIt _Last)
Definition: algorithm:1702
_Iter::value_type value_type
Definition: xutility:372
void _XAdjust_heap(_RanIt _First, _Diff _Hole, _Diff _Bottom, _Ty _Val)
Definition: algorithm:1590
void sort_heap_unchecked(_RanIt _First, _RanIt _Last)
Definition: algorithm:1760
template<class _InIt , class _RanIt , class _Pr >
_RanIt cliext::partial_sort_copy_unchecked ( _InIt  _First1,
_InIt  _Last1,
_RanIt  _First2,
_RanIt  _Last2,
_Pr  _Pred 
)
inline
3299  { // copy [First1, _Last1) into [_First2, _Last2) using _Pred
3302 
3303  if (_First1 == _Last1 || _First2 == _Last2)
3304  return (_First2);
3305  else
3306  { // copy and sort nontrivial
3307  _RanIt _Mid2 = _First2;
3308 
3309  for (; _First1 != _Last1 && _Mid2 != _Last2; ++_First1, ++_Mid2)
3310  *_Mid2 = *_First1; // copy min(_Last1-_First1, _Last2-_First2)
3311  cliext::make_heap_unchecked(_First2, _Mid2, _Pred);
3312 
3313  for (; _First1 != _Last1; ++_First1)
3314  if (_STLCLRDB_LT_PRED(_Pred, *_First1, *_First2))
3315  cliext::_XAdjust_heap(_First2, _Diff(0),
3316  _Diff(_Mid2 - _First2),
3317  _Ty(*_First1), _Pred); // replace top with new largest
3318 
3319  cliext::sort_heap_unchecked(_First2, _Mid2, _Pred);
3320  return (_Mid2);
3321  }
3322  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _STLCLRDB_LT_PRED(pred, left, right)
Definition: memory:219
_Iter::difference_type difference_type
Definition: xutility:373
void make_heap_unchecked(_RanIt _First, _RanIt _Last)
Definition: algorithm:1702
_Iter::value_type value_type
Definition: xutility:372
void _XAdjust_heap(_RanIt _First, _Diff _Hole, _Diff _Bottom, _Ty _Val)
Definition: algorithm:1590
void sort_heap_unchecked(_RanIt _First, _RanIt _Last)
Definition: algorithm:1760
template<class _RanIt >
void cliext::partial_sort_unchecked ( _RanIt  _First,
_RanIt  _Mid,
_RanIt  _Last 
)
inline
3202  { // order [First, _Last) up to _Mid, using operator<
3204 
3205  cliext::make_heap_unchecked(_First, _Mid);
3206 
3207  for (_RanIt _Next = _Mid; _Next < _Last; ++_Next)
3208  if (_STLCLRDB_LT(*_Next, *_First))
3209  _XPop_heap(_First, _Mid, _Next,
3210  _Ty(*_Next)); // replace top with new largest
3211  cliext::sort_heap_unchecked(_First, _Mid);
3212  }
#define _STLCLRDB_LT(left, right)
Definition: memory:218
void make_heap_unchecked(_RanIt _First, _RanIt _Last)
Definition: algorithm:1702
_Iter::value_type value_type
Definition: xutility:372
void sort_heap_unchecked(_RanIt _First, _RanIt _Last)
Definition: algorithm:1760
_FwdIt _Last
Definition: algorithm:1936
void _XPop_heap(_RanIt _First, _RanIt _Last, _RanIt _Dest, _Ty _Val, _Pr _Pred)
Definition: algorithm:1669
template<class _RanIt , class _Pr >
void cliext::partial_sort_unchecked ( _RanIt  _First,
_RanIt  _Mid,
_RanIt  _Last,
_Pr  _Pred 
)
inline
3228  { // order [First, _Last) up to _Mid, using _Pred
3230 
3231  cliext::make_heap_unchecked(_First, _Mid, _Pred);
3232 
3233  for (_RanIt _Next = _Mid; _Next < _Last; ++_Next)
3234  if (_STLCLRDB_LT_PRED(_Pred, *_Next, *_First))
3235  _XPop_heap(_First, _Mid, _Next,
3236  _Ty(*_Next), _Pred); // replace top with new largest
3237  cliext::sort_heap_unchecked(_First, _Mid, _Pred);
3238  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _STLCLRDB_LT_PRED(pred, left, right)
Definition: memory:219
void make_heap_unchecked(_RanIt _First, _RanIt _Last)
Definition: algorithm:1702
_Iter::value_type value_type
Definition: xutility:372
void sort_heap_unchecked(_RanIt _First, _RanIt _Last)
Definition: algorithm:1760
_FwdIt _Last
Definition: algorithm:1936
void _XPop_heap(_RanIt _First, _RanIt _Last, _RanIt _Dest, _Ty _Val, _Pr _Pred)
Definition: algorithm:1669
template<class _InIt , class _OutIt >
_OutIt cliext::partial_sum ( _InIt  _First,
_InIt  _Last,
_OutIt  _Dest 
)
inline
130  { // compute partial sums into _Dest
131  _STLCLRDB_RANGE(_First, _Last);
132  _STLCLRDB_POINTER(_Dest);
134  _Unchecked(_First), _Unchecked(_Last),
135  _Unchecked(_Dest)));
136  }
#define _STLCLRDB_POINTER(first)
Definition: memory:221
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
_OutIt partial_sum_unchecked(_InIt _First, _InIt _Last, _OutIt _Dest)
Definition: numeric:109
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt , class _OutIt , class _Fn2 >
_OutIt cliext::partial_sum ( _InIt  _First,
_InIt  _Last,
_OutIt  _Dest,
_Fn2  _Func 
)
inline
164  { // compute partial sums into _Dest, using _Func
165  _STLCLRDB_RANGE(_First, _Last);
166  _STLCLRDB_POINTER(_Dest);
167  _STLCLRDB_POINTER(_Func);
169  _Unchecked(_First), _Unchecked(_Last),
170  _Unchecked(_Dest), _Func));
171  }
#define _STLCLRDB_POINTER(first)
Definition: memory:221
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
_OutIt partial_sum_unchecked(_InIt _First, _InIt _Last, _OutIt _Dest)
Definition: numeric:109
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt , class _OutIt >
_OutIt cliext::partial_sum_unchecked ( _InIt  _First,
_InIt  _Last,
_OutIt  _Dest 
)
inline
111  { // compute partial sums into _Dest
113 
114  if (_First == _Last)
115  return (_Dest);
116  else
117  { // compute nontrivial sum
118  _Ty _Val = *_First;
119 
120  for (*_Dest = _Val; ++_First != _Last; *++_Dest = _Val)
121  _Val = _Val + *_First;
122  return (++_Dest);
123  }
124  }
_Iter::value_type value_type
Definition: xutility:372
_FwdIt const _Ty _Val
Definition: algorithm:1938
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt , class _OutIt , class _Fn2 >
_OutIt cliext::partial_sum_unchecked ( _InIt  _First,
_InIt  _Last,
_OutIt  _Dest,
_Fn2  _Func 
)
inline
144  { // compute partial sums into _Dest, using _Func
146 
147  if (_First == _Last)
148  return (_Dest);
149  else
150  { // compute nontrivial sum
151  _Ty _Val = *_First;
152 
153  for (*_Dest = _Val; ++_First != _Last; *++_Dest = _Val)
154  _Val = _Func(_Val, *_First);
155  return (++_Dest);
156  }
157  }
_Iter::value_type value_type
Definition: xutility:372
_FwdIt const _Ty _Val
Definition: algorithm:1938
_FwdIt _Last
Definition: algorithm:1936
template<class _BidIt , class _Pr >
_BidIt cliext::partition ( _BidIt  _First,
_BidIt  _Last,
_Pr  _Pred 
)
inline
1325  { // move elements satisfying _Pred to beginning of sequence
1326  _STLCLRDB_RANGE(_First, _Last);
1329  _Unchecked(_First), _Unchecked(_Last), _Pred));
1330  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _STLCLRDB_POINTER(first)
Definition: memory:221
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
_BidIt partition_unchecked(_BidIt _First, _BidIt _Last, _Pr _Pred)
Definition: algorithm:1303
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_FwdIt _Last
Definition: algorithm:1936
template<class _BidIt , class _Pr >
_BidIt cliext::partition_unchecked ( _BidIt  _First,
_BidIt  _Last,
_Pr  _Pred 
)
inline
1304  { // move elements satisfying _Pred to beginning of sequence
1305  for (; ; ++_First)
1306  { // find any out-of-order pair
1307  for (; _First != _Last && _Pred(*_First); ++_First)
1308  ; // skip in-place elements at beginning
1309  if (_First == _Last)
1310  break; // done
1311 
1312  for (; _First != --_Last && !_Pred(*_Last); )
1313  ; // skip in-place elements at end
1314  if (_First == _Last)
1315  break; // done
1316 
1317  cliext::iter_swap(_First, _Last); // swap out-of-place pair and loop
1318  }
1319  return (_First);
1320  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
void iter_swap(_FwdIt1 _Left, _FwdIt2 _Right)
Definition: algorithm:573
_FwdIt _Last
Definition: algorithm:1936
template<class _RanIt >
void cliext::pop_heap ( _RanIt  _First,
_RanIt  _Last 
)
inline
1631  { // pop *_First to *(_Last - 1) and reheap, using operator<
1632  _STLCLRDB_RANGE(_First, _Last);
1633  _STLCLRDB_HEAP(_First, _Last);
1634 
1635  if (1 < _Last - _First)
1637  }
#define _STLCLRDB_HEAP(first, last)
Definition: algorithm:1489
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
void pop_heap_unchecked(_RanIt _First, _RanIt _Last)
Definition: algorithm:1622
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_FwdIt _Last
Definition: algorithm:1936
template<class _RanIt , class _Pr >
void cliext::pop_heap ( _RanIt  _First,
_RanIt  _Last,
_Pr  _Pred 
)
inline
1692  { // pop *_First to *(_Last - 1) and reheap, using _Pred
1693  _STLCLRDB_RANGE(_First, _Last);
1695  _STLCLRDB_HEAP_PRED(_First, _Last, _Pred);
1697  _Pred);
1698  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _STLCLRDB_HEAP_PRED(first, last, pred)
Definition: algorithm:1490
#define _STLCLRDB_POINTER(first)
Definition: memory:221
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
void pop_heap_unchecked(_RanIt _First, _RanIt _Last)
Definition: algorithm:1622
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_FwdIt _Last
Definition: algorithm:1936
template<class _RanIt >
void cliext::pop_heap_unchecked ( _RanIt  _First,
_RanIt  _Last 
)
inline
1623  { // pop *_First to *(_Last - 1) and reheap, using operator<
1625 
1626  _XPop_heap(_First, _Last - 1, _Last - 1, _Ty(*(_Last - 1)));
1627  }
_Iter::value_type value_type
Definition: xutility:372
_FwdIt _Last
Definition: algorithm:1936
void _XPop_heap(_RanIt _First, _RanIt _Last, _RanIt _Dest, _Ty _Val, _Pr _Pred)
Definition: algorithm:1669
template<class _RanIt , class _Pr >
void cliext::pop_heap_unchecked ( _RanIt  _First,
_RanIt  _Last,
_Pr  _Pred 
)
inline
1682  { // pop *_First to *(_Last - 1) and reheap, using _Pred
1684 
1685  if (1 < _Last - _First)
1686  _XPop_heap(_First, _Last - 1, _Last - 1, _Ty(*(_Last - 1)), _Pred);
1687  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
_Iter::value_type value_type
Definition: xutility:372
_FwdIt _Last
Definition: algorithm:1936
void _XPop_heap(_RanIt _First, _RanIt _Last, _RanIt _Dest, _Ty _Val, _Pr _Pred)
Definition: algorithm:1669
template<class _BidIt >
bool cliext::prev_permutation ( _BidIt  _First,
_BidIt  _Last 
)
inline
3911  { // reverse permute and test for pure descending, using operator<
3912  _STLCLRDB_RANGE(_First, _Last);
3914  _Unchecked(_First), _Unchecked(_Last)));
3915  }
bool prev_permutation_unchecked(_BidIt _First, _BidIt _Last)
Definition: algorithm:3883
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_FwdIt _Last
Definition: algorithm:1936
template<class _BidIt , class _Pr >
bool cliext::prev_permutation ( _BidIt  _First,
_BidIt  _Last,
_Pr  _Pred 
)
inline
3950  { // reverse permute and test for pure descending, using _Pred
3951  _STLCLRDB_RANGE(_First, _Last);
3954  _Unchecked(_First), _Unchecked(_Last), _Pred));
3955  }
bool prev_permutation_unchecked(_BidIt _First, _BidIt _Last)
Definition: algorithm:3883
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _STLCLRDB_POINTER(first)
Definition: memory:221
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_FwdIt _Last
Definition: algorithm:1936
template<class _BidIt >
bool cliext::prev_permutation_unchecked ( _BidIt  _First,
_BidIt  _Last 
)
inline
3884  { // reverse permute and test for pure descending, using operator<
3885  _BidIt _Next = _Last;
3886  if (_First == _Last || _First == --_Next)
3887  return (false);
3888  for (; ; )
3889  { // find rightmost element not smaller than successor
3890  _BidIt _Next1 = _Next;
3891  if (_STLCLRDB_LT(*_Next1, *--_Next))
3892  { // swap with rightmost element that's not smaller, flip suffix
3893  _BidIt _Mid = _Last;
3894  for (; !_STLCLRDB_LT(*--_Mid, *_Next); )
3895  ;
3896  cliext::iter_swap(_Next, _Mid);
3897  cliext::reverse(_Next1, _Last);
3898  return (true);
3899  }
3900 
3901  if (_Next == _First)
3902  { // pure ascending, flip all
3903  cliext::reverse(_First, _Last);
3904  return (false);
3905  }
3906  }
3907  }
void reverse(_BidIt _First, _BidIt _Last)
Definition: algorithm:1105
#define _STLCLRDB_LT(left, right)
Definition: memory:218
void iter_swap(_FwdIt1 _Left, _FwdIt2 _Right)
Definition: algorithm:573
_FwdIt _Last
Definition: algorithm:1936
template<class _BidIt , class _Pr >
bool cliext::prev_permutation_unchecked ( _BidIt  _First,
_BidIt  _Last,
_Pr  _Pred 
)
inline
3921  { // reverse permute and test for pure descending, using _Pred
3922  _BidIt _Next = _Last;
3923  if (_First == _Last || _First == --_Next)
3924  return (false);
3925 
3926  for (; ; )
3927  { // find rightmost element not smaller than successor
3928  _BidIt _Next1 = _Next;
3929  if (_STLCLRDB_LT_PRED(_Pred, *_Next1, *--_Next))
3930  { // swap with rightmost element that's not smaller, flip suffix
3931  _BidIt _Mid = _Last;
3932  for (; !_STLCLRDB_LT_PRED(_Pred, *--_Mid, *_Next); )
3933  ;
3934  cliext::iter_swap(_Next, _Mid);
3935  cliext::reverse(_Next1, _Last);
3936  return (true);
3937  }
3938 
3939  if (_Next == _First)
3940  { // pure ascending, flip all
3941  cliext::reverse(_First, _Last);
3942  return (false);
3943  }
3944  }
3945  }
void reverse(_BidIt _First, _BidIt _Last)
Definition: algorithm:1105
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _STLCLRDB_LT_PRED(pred, left, right)
Definition: memory:219
void iter_swap(_FwdIt1 _Left, _FwdIt2 _Right)
Definition: algorithm:573
_FwdIt _Last
Definition: algorithm:1936
template<class _RanIt >
void cliext::push_heap ( _RanIt  _First,
_RanIt  _Last 
)
inline
1525  { // push *(_Last - 1) onto heap at [_First, _Last - 1), using operator<
1528 
1529  _STLCLRDB_RANGE(_First, _Last);
1530  if (_First != _Last)
1531  { // check and push non-empty heap+addition
1532  _STLCLRDB_HEAP(_First, _Last - 1);
1534  }
1535  }
#define _STLCLRDB_HEAP(first, last)
Definition: algorithm:1489
_Iter::difference_type difference_type
Definition: xutility:373
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
_Iter::value_type value_type
Definition: xutility:372
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
void push_heap_unchecked(_RanIt _First, _RanIt _Last)
Definition: algorithm:1512
_FwdIt _Last
Definition: algorithm:1936
template<class _RanIt , class _Pr >
void cliext::push_heap ( _RanIt  _First,
_RanIt  _Last,
_Pr  _Pred 
)
inline
1572  { // push *(_Last - 1) onto heap at [_First, _Last - 1), using _Pred
1575 
1576  _STLCLRDB_RANGE(_First, _Last);
1578  if (_First != _Last)
1579  { // check and push non-empty heap+addition
1580  _STLCLRDB_HEAP_PRED(_First, _Last - 1, _Pred);
1582  _Pred);
1583  }
1584  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _STLCLRDB_HEAP_PRED(first, last, pred)
Definition: algorithm:1490
#define _STLCLRDB_POINTER(first)
Definition: memory:221
_Iter::difference_type difference_type
Definition: xutility:373
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
_Iter::value_type value_type
Definition: xutility:372
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
void push_heap_unchecked(_RanIt _First, _RanIt _Last)
Definition: algorithm:1512
_FwdIt _Last
Definition: algorithm:1936
template<class _RanIt >
void cliext::push_heap_unchecked ( _RanIt  _First,
_RanIt  _Last 
)
inline
1513  { // push *(_Last - 1) onto heap at [_First, _Last - 1), using operator<
1516 
1517  --_Last;
1518  _Diff _Count = _Last - _First;
1519  if (0 < _Count)
1520  cliext::_XPush_heap(_First, _Count, _Diff(0), _Ty(*_Last));
1521  }
_Iter::difference_type difference_type
Definition: xutility:373
void _XPush_heap(_RanIt _First, _Diff _Hole, _Diff _Top, _Ty _Val)
Definition: algorithm:1497
_Iter::value_type value_type
Definition: xutility:372
_Diff _Count
Definition: algorithm:1941
_FwdIt _Last
Definition: algorithm:1936
template<class _RanIt , class _Pr >
void cliext::push_heap_unchecked ( _RanIt  _First,
_RanIt  _Last,
_Pr  _Pred 
)
inline
1559  { // push *(_Last - 1) onto heap at [_First, _Last - 1), using _Pred
1562 
1563  --_Last;
1564  _Diff _Count = _Last - _First;
1565  if (0 < _Count)
1566  cliext::_XPush_heap(_First, _Count, _Diff(0), _Ty(*_Last), _Pred);
1567  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
_Iter::difference_type difference_type
Definition: xutility:373
void _XPush_heap(_RanIt _First, _Diff _Hole, _Diff _Top, _Ty _Val)
Definition: algorithm:1497
_Iter::value_type value_type
Definition: xutility:372
_Diff _Count
Definition: algorithm:1941
_FwdIt _Last
Definition: algorithm:1936
template<class _RanIt >
void cliext::random_shuffle ( _RanIt  _First,
_RanIt  _Last 
)
inline
1269  { // shuffle [_First, _Last)
1270  _STLCLRDB_RANGE(_First, _Last);
1272  _Unchecked(_First), _Unchecked(_Last));
1273  }
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
void random_shuffle_unchecked(_RanIt _First, _RanIt _Last)
Definition: algorithm:1242
_FwdIt _Last
Definition: algorithm:1936
template<class _RanIt , class _Fn1 >
void cliext::random_shuffle ( _RanIt  _First,
_RanIt  _Last,
_Fn1%  _Func 
)
inline
1294  { // shuffle [_First, _Last) using random function _Func
1295  _STLCLRDB_RANGE(_First, _Last);
1297  _Unchecked(_First), _Unchecked(_Last), _Func);
1298  }
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
void random_shuffle_unchecked(_RanIt _First, _RanIt _Last)
Definition: algorithm:1242
_FwdIt _Last
Definition: algorithm:1936
template<class _RanIt >
void cliext::random_shuffle_unchecked ( _RanIt  _First,
_RanIt  _Last 
)
inline
1243  { // shuffle [_First, _Last)
1245 
1246  if (_First != _Last)
1247  { // shuffle nontrivial [_First, _Last)
1248  const int _RANDOM_BITS = 15; // minimum random bits from _Rand()
1249  const int _RANDOM_MAX = (1U << _RANDOM_BITS) - 1;
1250 
1251  _RanIt _Next = _First;
1252  for (unsigned long _Index = 2; ++_Next != _Last; ++_Index)
1253  { // assume unsigned long big enough for _Diff count
1254  unsigned long _Rm = _RANDOM_MAX;
1255  unsigned long _Rn = _Rand() & _RANDOM_MAX;
1256  for (; _Rm < _Index && _Rm != ~0UL;
1257  _Rm = _Rm << _RANDOM_BITS | _RANDOM_MAX)
1258  _Rn = _Rn << _RANDOM_BITS
1259  | (_Rand() & _RANDOM_MAX); // build random value
1260 
1261  cliext::iter_swap(_Next,
1262  _First + _Diff(_Rn % _Index)); // swap a pair
1263  }
1264  }
1265  }
_Iter::difference_type difference_type
Definition: xutility:373
int _Rand(void)
Definition: algorithm:1233
void iter_swap(_FwdIt1 _Left, _FwdIt2 _Right)
Definition: algorithm:573
_FwdIt _Last
Definition: algorithm:1936
template<class _RanIt , class _Fn1 >
void cliext::random_shuffle_unchecked ( _RanIt  _First,
_RanIt  _Last,
_Fn1%  _Func 
)
inline
1279  { // shuffle [_First, _Last) using random function _Func
1281 
1282  if (_First != _Last)
1283  { // shuffle nonempty [_First, _Last) using random function _Func
1284  _RanIt _Next = _First;
1285 
1286  for (_Diff _Index = 2; ++_Next != _Last; ++_Index)
1287  cliext::iter_swap(_Next, _First + _Diff(_Func(_Index)));
1288  }
1289  }
_Iter::difference_type difference_type
Definition: xutility:373
void iter_swap(_FwdIt1 _Left, _FwdIt2 _Right)
Definition: algorithm:573
_FwdIt _Last
Definition: algorithm:1936
template<class _FwdIt , class _Ty >
_FwdIt cliext::remove ( _FwdIt  _First,
_FwdIt  _Last,
const _Ty%  _Val 
)
inline
862  { // remove each matching _Val
863  _STLCLRDB_RANGE(_First, _Last);
865  _Val));
866  }
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_FwdIt remove_unchecked(_FwdIt _First, _FwdIt _Last, const _Ty%_Val)
Definition: algorithm:846
_FwdIt const _Ty _Val
Definition: algorithm:1938
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt , class _OutIt , class _Ty >
_OutIt cliext::remove_copy ( _InIt  _First,
_InIt  _Last,
_OutIt  _Dest,
const _Ty%  _Val 
)
inline
808  { // copy omitting each matching _Val
809  _STLCLRDB_RANGE(_First, _Last);
810  _STLCLRDB_POINTER(_Dest);
812  _Unchecked(_First), _Unchecked(_Last),
813  _Unchecked(_Dest), _Val));
814  }
#define _STLCLRDB_POINTER(first)
Definition: memory:221
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_OutIt remove_copy_unchecked(_InIt _First, _InIt _Last, _OutIt _Dest, const _Ty%_Val)
Definition: algorithm:794
_FwdIt const _Ty _Val
Definition: algorithm:1938
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt , class _OutIt , class _Pr >
_OutIt cliext::remove_copy_if ( _InIt  _First,
_InIt  _Last,
_OutIt  _Dest,
_Pr  _Pred 
)
inline
834  { // copy omitting each element satisfying _Pred
835  _STLCLRDB_RANGE(_First, _Last);
836  _STLCLRDB_POINTER(_Dest);
839  _Unchecked(_First), _Unchecked(_Last),
840  _Unchecked(_Dest), _Pred));
841  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _STLCLRDB_POINTER(first)
Definition: memory:221
_OutIt remove_copy_if_unchecked(_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred)
Definition: algorithm:820
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt , class _OutIt , class _Pr >
_OutIt cliext::remove_copy_if_unchecked ( _InIt  _First,
_InIt  _Last,
_OutIt  _Dest,
_Pr  _Pred 
)
inline
822  { // copy omitting each element satisfying _Pred
823  for (; _First != _Last; ++_First)
824  if (!_Pred(*_First))
825  *_Dest++ = *_First;
826  return (_Dest);
827  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt , class _OutIt , class _Ty >
_OutIt cliext::remove_copy_unchecked ( _InIt  _First,
_InIt  _Last,
_OutIt  _Dest,
const _Ty%  _Val 
)
inline
796  { // copy omitting each matching _Val
797  for (; _First != _Last; ++_First)
798  if (!(*_First == _Val))
799  *_Dest++ = *_First;
800  return (_Dest);
801  }
_FwdIt const _Ty _Val
Definition: algorithm:1938
_FwdIt _Last
Definition: algorithm:1936
template<class _FwdIt , class _Pr >
_FwdIt cliext::remove_if ( _FwdIt  _First,
_FwdIt  _Last,
_Pr  _Pred 
)
inline
888  { // remove each satisfying _Pred
889  _STLCLRDB_RANGE(_First, _Last);
892  _Unchecked(_First), _Unchecked(_Last), _Pred));
893  }
_FwdIt remove_if_unchecked(_FwdIt _First, _FwdIt _Last, _Pr _Pred)
Definition: algorithm:871
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _STLCLRDB_POINTER(first)
Definition: memory:221
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_FwdIt _Last
Definition: algorithm:1936
template<class _FwdIt , class _Pr >
_FwdIt cliext::remove_if_unchecked ( _FwdIt  _First,
_FwdIt  _Last,
_Pr  _Pred 
)
inline
873  { // remove each satisfying _Pred
874  _First = cliext::find_if_unchecked(_First, _Last, _Pred);
875  if (_First == _Last)
876  return (_First); // empty sequence, all done
877  else
878  { // nonempty sequence, worth doing
879  _FwdIt _First1 = _First;
880  return (cliext::remove_copy_if_unchecked(++_First1, _Last,
881  _First, _Pred));
882  }
883  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
_InIt find_if_unchecked(_InIt _First, _InIt _Last, _Pr _Pred)
Definition: algorithm:85
_OutIt remove_copy_if_unchecked(_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred)
Definition: algorithm:820
_FwdIt _Last
Definition: algorithm:1936
template<class _FwdIt , class _Ty >
_FwdIt cliext::remove_unchecked ( _FwdIt  _First,
_FwdIt  _Last,
const _Ty%  _Val 
)
inline
848  { // remove each matching _Val
849  _First = cliext::find_unchecked(_First, _Last, _Val);
850  if (_First == _Last)
851  return (_First); // empty sequence, all done
852  else
853  { // nonempty sequence, worth doing
854  _FwdIt _First1 = _First;
855  return (cliext::remove_copy(++_First1, _Last, _First, _Val));
856  }
857  }
_InIt find_unchecked(_InIt _First, _InIt _Last, const _Ty%_Val)
Definition: algorithm:37
_OutIt remove_copy(_InIt _First, _InIt _Last, _OutIt _Dest, const _Ty%_Val)
Definition: algorithm:806
_FwdIt const _Ty _Val
Definition: algorithm:1938
_FwdIt _Last
Definition: algorithm:1936
template<class _FwdIt , class _Ty >
void cliext::replace ( _FwdIt  _First,
_FwdIt  _Last,
const _Ty%  _Oldval,
const _Ty%  _Newval 
)
inline
669  { // replace each matching _Oldval with _Newval
670  _STLCLRDB_RANGE(_First, _Last);
672  _Oldval, _Newval);
673  }
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
void replace_unchecked(_FwdIt _First, _FwdIt _Last, const _Ty%_Oldval, const _Ty%_Newval)
Definition: algorithm:657
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt , class _OutIt , class _Ty >
_OutIt cliext::replace_copy ( _InIt  _First,
_InIt  _Last,
_OutIt  _Dest,
const _Ty%  _Oldval,
const _Ty%  _Newval 
)
inline
716  { // copy replacing each matching _Oldval with _Newval
717  _STLCLRDB_RANGE(_First, _Last);
718  _STLCLRDB_POINTER(_Dest);
720  _Unchecked(_First), _Unchecked(_Last),
721  _Unchecked(_Dest), _Oldval, _Newval));
722  }
_OutIt replace_copy_unchecked(_InIt _First, _InIt _Last, _OutIt _Dest, const _Ty%_Oldval, const _Ty%_Newval)
Definition: algorithm:703
#define _STLCLRDB_POINTER(first)
Definition: memory:221
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt , class _OutIt , class _Pr , class _Ty >
_OutIt cliext::replace_copy_if ( _InIt  _First,
_InIt  _Last,
_OutIt  _Dest,
_Pr  _Pred,
const _Ty%  _Val 
)
inline
743  { // copy replacing each satisfying _Pred with _Val
744  _STLCLRDB_RANGE(_First, _Last);
745  _STLCLRDB_POINTER(_Dest);
748  _Unchecked(_First), _Unchecked(_Last),
749  _Unchecked(_Dest), _Pred, _Val));
750  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
_OutIt replace_copy_if_unchecked(_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred, const _Ty%_Val)
Definition: algorithm:729
#define _STLCLRDB_POINTER(first)
Definition: memory:221
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_FwdIt const _Ty _Val
Definition: algorithm:1938
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt , class _OutIt , class _Pr , class _Ty >
_OutIt cliext::replace_copy_if_unchecked ( _InIt  _First,
_InIt  _Last,
_OutIt  _Dest,
_Pr  _Pred,
const _Ty%  _Val 
)
inline
731  { // copy replacing each satisfying _Pred with _Val
732  for (; _First != _Last; ++_First, ++_Dest)
733  *_Dest = _Pred(*_First) ? _Val : *_First;
734  return (_Dest);
735  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
_FwdIt const _Ty _Val
Definition: algorithm:1938
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt , class _OutIt , class _Ty >
_OutIt cliext::replace_copy_unchecked ( _InIt  _First,
_InIt  _Last,
_OutIt  _Dest,
const _Ty%  _Oldval,
const _Ty%  _Newval 
)
inline
705  { // copy replacing each matching _Oldval with _Newval
706  for (; _First != _Last; ++_First, ++_Dest)
707  *_Dest = *_First == _Oldval ? _Newval : *_First;
708  return (_Dest);
709  }
_FwdIt _Last
Definition: algorithm:1936
template<class _FwdIt , class _Pr , class _Ty >
void cliext::replace_if ( _FwdIt  _First,
_FwdIt  _Last,
_Pr  _Pred,
const _Ty%  _Val 
)
inline
692  { // replace each satisfying _Pred with _Val
693  _STLCLRDB_RANGE(_First, _Last);
696  _Pred, _Val);
697  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _STLCLRDB_POINTER(first)
Definition: memory:221
void replace_if_unchecked(_FwdIt _First, _FwdIt _Last, _Pr _Pred, const _Ty%_Val)
Definition: algorithm:679
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_FwdIt const _Ty _Val
Definition: algorithm:1938
_FwdIt _Last
Definition: algorithm:1936
template<class _FwdIt , class _Pr , class _Ty >
void cliext::replace_if_unchecked ( _FwdIt  _First,
_FwdIt  _Last,
_Pr  _Pred,
const _Ty%  _Val 
)
inline
681  { // replace each satisfying _Pred with _Val
682  for (; _First != _Last; ++_First)
683  if (_Pred(*_First))
684  *_First = _Val;
685  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
_FwdIt const _Ty _Val
Definition: algorithm:1938
_FwdIt _Last
Definition: algorithm:1936
template<class _FwdIt , class _Ty >
void cliext::replace_unchecked ( _FwdIt  _First,
_FwdIt  _Last,
const _Ty%  _Oldval,
const _Ty%  _Newval 
)
inline
659  { // replace each matching _Oldval with _Newval
660  for (; _First != _Last; ++_First)
661  if (*_First == _Oldval)
662  *_First = _Newval;
663  }
_FwdIt _Last
Definition: algorithm:1936
cliext::return ( _PAIR_TYPE(_FwdIt)(_First, _First)  )
cliext::return ( cliext::  equal_range_unchecked_Unchecked(_First), _Unchecked(_Last), _Val)
cliext::return ( cliext::  equal_range_unchecked_Unchecked(_First), _Unchecked(_Last), _Val, _Pred)
template<class _Ty >
void cliext::return_temporary_buffer ( _Ty *  _Pbuf)
inline
290  { // delete raw temporary buffer
291  ::operator delete(_Pbuf);
292  }
template<class _BidIt >
void cliext::reverse ( _BidIt  _First,
_BidIt  _Last 
)
inline
1106  { // reverse elements in [_First, _Last)
1107  _STLCLRDB_RANGE(_First, _Last);
1109  }
void reverse_unchecked(_BidIt _First, _BidIt _Last)
Definition: algorithm:1099
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_FwdIt _Last
Definition: algorithm:1936
template<class _BidIt , class _OutIt >
_OutIt cliext::reverse_copy ( _BidIt  _First,
_BidIt  _Last,
_OutIt  _Dest 
)
inline
1124  { // copy reversing elements in [_First, _Last)
1125  _STLCLRDB_RANGE(_First, _Last);
1126  _STLCLRDB_POINTER(_Dest);
1128  _Unchecked(_First), _Unchecked(_Last), _Unchecked(_Dest)));
1129  }
#define _STLCLRDB_POINTER(first)
Definition: memory:221
_OutIt reverse_copy_unchecked(_BidIt _First, _BidIt _Last, _OutIt _Dest)
Definition: algorithm:1114
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_FwdIt _Last
Definition: algorithm:1936
template<class _BidIt , class _OutIt >
_OutIt cliext::reverse_copy_unchecked ( _BidIt  _First,
_BidIt  _Last,
_OutIt  _Dest 
)
inline
1115  { // copy reversing elements in [_First, _Last)
1116  for (; _First != _Last; ++_Dest)
1117  *_Dest = *--_Last;
1118  return (_Dest);
1119  }
_FwdIt _Last
Definition: algorithm:1936
template<class _BidIt >
void cliext::reverse_unchecked ( _BidIt  _First,
_BidIt  _Last 
)
inline
1100  { // reverse elements in [_First, _Last)
1101  _Reverse(_First, _Last, _Iter_category(_First));
1102  }
iterator_traits< _Iter_t >::iterator_category _Iter_category(_Iter_t)
Definition: xutility:654
void _Reverse(_BidIt _First, _BidIt _Last, bidirectional_iterator_tag)
Definition: xutility:3158
_FwdIt _Last
Definition: algorithm:1936
template<class _FwdIt >
void cliext::rotate ( _FwdIt  _First,
_FwdIt  _Mid,
_FwdIt  _Last 
)
inline
1201  { // rotate [_First, _Last)
1202  _STLCLRDB_RANGE(_First, _Mid);
1203  _STLCLRDB_RANGE(_Mid, _Last);
1204  if (_First != _Mid && _Mid != _Last)
1205  _Rotate(_Unchecked(_First), _Unchecked(_Mid), _Unchecked(_Last),
1206  _Iter_category(_First));
1207  }
iterator_traits< _Iter_t >::iterator_category _Iter_category(_Iter_t)
Definition: xutility:654
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
void _Rotate(_RanIt _First, _RanIt _Mid, _RanIt _Last, random_access_iterator_tag)
Definition: algorithm:1159
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_FwdIt _Last
Definition: algorithm:1936
template<class _FwdIt , class _OutIt >
_OutIt cliext::rotate_copy ( _FwdIt  _First,
_FwdIt  _Mid,
_FwdIt  _Last,
_OutIt  _Dest 
)
inline
1223  { // copy rotating [_First, _Last)
1224  _STLCLRDB_RANGE(_First, _Mid);
1225  _STLCLRDB_RANGE(_Mid, _Last);
1226  _STLCLRDB_POINTER(_Dest);
1228  _Unchecked(_First), _Unchecked(_Mid), _Unchecked(_Last),
1229  _Unchecked(_Dest)));
1230  }
#define _STLCLRDB_POINTER(first)
Definition: memory:221
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
_OutIt rotate_copy_unchecked(_FwdIt _First, _FwdIt _Mid, _FwdIt _Last, _OutIt _Dest)
Definition: algorithm:1212
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_FwdIt _Last
Definition: algorithm:1936
template<class _FwdIt , class _OutIt >
_OutIt cliext::rotate_copy_unchecked ( _FwdIt  _First,
_FwdIt  _Mid,
_FwdIt  _Last,
_OutIt  _Dest 
)
inline
1214  { // copy rotating [_First, _Last)
1215  _Dest = cliext::copy_unchecked(_Mid, _Last, _Dest);
1216  return (cliext::copy_unchecked(_First, _Mid, _Dest));
1217  }
_OutIt copy_unchecked(_InIt _First, _InIt _Last, _OutIt _Dest)
Definition: memory:490
_FwdIt _Last
Definition: algorithm:1936
template<class _FwdIt >
void cliext::rotate_unchecked ( _FwdIt  _First,
_FwdIt  _Mid,
_FwdIt  _Last 
)
inline
1194  { // rotate [_First, _Last)
1195  if (_First != _Mid && _Mid != _Last)
1196  _Rotate(_First, _Mid, _Last, _Iter_category(_First));
1197  }
iterator_traits< _Iter_t >::iterator_category _Iter_category(_Iter_t)
Definition: xutility:654
void _Rotate(_RanIt _First, _RanIt _Mid, _RanIt _Last, random_access_iterator_tag)
Definition: algorithm:1159
_FwdIt _Last
Definition: algorithm:1936
template<class _FwdIt1 , class _FwdIt2 >
_FwdIt1 cliext::search ( _FwdIt1  _First1,
_FwdIt1  _Last1,
_FwdIt2  _First2,
_FwdIt2  _Last2 
)
inline
221  { // find first [_First2, _Last2) match
222  _STLCLRDB_RANGE(_First1, _Last1);
223  _STLCLRDB_RANGE(_First2, _Last2);
224  return (cliext::search_unchecked(_Unchecked(_First1), _Unchecked(_Last1),
225  _Unchecked(_First2), _Unchecked(_Last2)));
226  }
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_FwdIt1 search_unchecked(_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2)
Definition: algorithm:194
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
_FwdIt1 cliext::search ( _FwdIt1  _First1,
_FwdIt1  _Last1,
_FwdIt2  _First2,
_FwdIt2  _Last2,
_Pr  _Pred 
)
inline
260  { // find first [_First2, _Last2) satisfying _Pred
261  _STLCLRDB_RANGE(_First1, _Last1);
262  _STLCLRDB_RANGE(_First2, _Last2);
264  return (cliext::search_unchecked(_Unchecked(_First1), _Unchecked(_Last1),
265  _Unchecked(_First2), _Unchecked(_Last2), _Pred));
266  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _STLCLRDB_POINTER(first)
Definition: memory:221
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_FwdIt1 search_unchecked(_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2)
Definition: algorithm:194
template<class _FwdIt1 , class _Diff2 , class _Ty >
_FwdIt1 cliext::search_n ( _FwdIt1  _First1,
_FwdIt1  _Last1,
_Diff2  _Count,
const _Ty%  _Val 
)
inline
340  { // find first _Count * _Val match
341  _STLCLRDB_RANGE(_First1, _Last1);
342  return (_Search_n(_Unchecked(_First1), _Unchecked(_Last1),
343  _Count, _Val, _Iter_category(_First1)));
344  }
iterator_traits< _Iter_t >::iterator_category _Iter_category(_Iter_t)
Definition: xutility:654
_FwdIt1 _Search_n(_FwdIt1 _First1, _FwdIt1 _Last1, _Diff2 _Count, const _Ty &_Val, _Pr _Pred, forward_iterator_tag)
Definition: algorithm:664
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_Diff _Count
Definition: algorithm:1941
_FwdIt const _Ty _Val
Definition: algorithm:1938
template<class _FwdIt1 , class _Diff2 , class _Ty , class _Pr >
_FwdIt1 cliext::search_n ( _FwdIt1  _First1,
_FwdIt1  _Last1,
_Diff2  _Count,
const _Ty%  _Val,
_Pr  _Pred 
)
inline
421  { // find first _Count * _Val satisfying _Pred
422  _STLCLRDB_RANGE(_First1, _Last1);
424  return (_Search_n(_Unchecked(_First1), _Unchecked(_Last1),
425  _Count, _Val, _Pred, _Iter_category(_First1)));
426  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
iterator_traits< _Iter_t >::iterator_category _Iter_category(_Iter_t)
Definition: xutility:654
_FwdIt1 _Search_n(_FwdIt1 _First1, _FwdIt1 _Last1, _Diff2 _Count, const _Ty &_Val, _Pr _Pred, forward_iterator_tag)
Definition: algorithm:664
#define _STLCLRDB_POINTER(first)
Definition: memory:221
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_Diff _Count
Definition: algorithm:1941
_FwdIt const _Ty _Val
Definition: algorithm:1938
template<class _FwdIt1 , class _FwdIt2 >
_FwdIt1 cliext::search_unchecked ( _FwdIt1  _First1,
_FwdIt1  _Last1,
_FwdIt2  _First2,
_FwdIt2  _Last2 
)
inline
196  { // find first [_First2, _Last2) match
199 
200  _Diff1 _Count1 = 0;
201  _Iter_distance(_First1, _Last1, _Count1);
202  _Diff2 _Count2 = 0;
203  _Iter_distance(_First2, _Last2, _Count2);
204 
205  for (; _Count2 <= _Count1; ++_First1, --_Count1)
206  { // room for match, try it
207  _FwdIt1 _Mid1 = _First1;
208  for (_FwdIt2 _Mid2 = _First2; ; ++_Mid1, ++_Mid2)
209  if (_Mid2 == _Last2)
210  return (_First1);
211  else if (!(*_Mid1 == *_Mid2))
212  break;
213  }
214  return (_Last1);
215  }
_Iter::difference_type difference_type
Definition: xutility:373
_Iter_distance(_First, _Last, _Count)
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
_FwdIt1 cliext::search_unchecked ( _FwdIt1  _First1,
_FwdIt1  _Last1,
_FwdIt2  _First2,
_FwdIt2  _Last2,
_Pr  _Pred 
)
inline
234  { // find first [_First2, _Last2) satisfying _Pred
237 
238  _Diff1 _Count1 = 0;
239  _Iter_distance(_First1, _Last1, _Count1);
240  _Diff2 _Count2 = 0;
241  _Iter_distance(_First2, _Last2, _Count2);
242 
243  for (; _Count2 <= _Count1; ++_First1, --_Count1)
244  { // room for match, try it
245  _FwdIt1 _Mid1 = _First1;
246  for (_FwdIt2 _Mid2 = _First2; ; ++_Mid1, ++_Mid2)
247  if (_Mid2 == _Last2)
248  return (_First1);
249  else if (!_Pred(*_Mid1, *_Mid2))
250  break;
251  }
252  return (_Last1);
253  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
_Iter::difference_type difference_type
Definition: xutility:373
_Iter_distance(_First, _Last, _Count)
template<class _InIt1 , class _InIt2 , class _OutIt >
_OutIt cliext::set_difference ( _InIt1  _First1,
_InIt1  _Last1,
_InIt2  _First2,
_InIt2  _Last2,
_OutIt  _Dest 
)
inline
3610  { // take set [_First2, _Last2) from [_First1, _Last1), using operator<
3611  _STLCLRDB_ORDER(_First1, _Last1);
3612  _STLCLRDB_ORDER(_First2, _Last2);
3613  _STLCLRDB_POINTER(_Dest);
3615  _Unchecked(_First1), _Unchecked(_Last1),
3616  _Unchecked(_First2), _Unchecked(_Last2), _Unchecked(_Dest)));
3617  }
#define _STLCLRDB_ORDER(first, last)
Definition: memory:223
#define _STLCLRDB_POINTER(first)
Definition: memory:221
_OutIt set_difference_unchecked(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
Definition: algorithm:3592
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
template<class _InIt1 , class _InIt2 , class _OutIt , class _Pr >
_OutIt cliext::set_difference ( _InIt1  _First1,
_InIt1  _Last1,
_InIt2  _First2,
_InIt2  _Last2,
_OutIt  _Dest,
_Pr  _Pred 
)
inline
3643  { // take set [_First2, _Last2) from [_First1, _Last1), using _Pred
3644  _STLCLRDB_ORDER_PRED(_First1, _Last1, _Pred);
3645  _STLCLRDB_ORDER_PRED(_First2, _Last2, _Pred);
3646  _STLCLRDB_POINTER(_Dest);
3648  _Unchecked(_First1), _Unchecked(_Last1),
3649  _Unchecked(_First2), _Unchecked(_Last2), _Unchecked(_Dest), _Pred));
3650  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _STLCLRDB_POINTER(first)
Definition: memory:221
_OutIt set_difference_unchecked(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
Definition: algorithm:3592
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_ORDER_PRED(first, last, pred)
Definition: memory:224
template<class _InIt1 , class _InIt2 , class _OutIt >
_OutIt cliext::set_difference_unchecked ( _InIt1  _First1,
_InIt1  _Last1,
_InIt2  _First2,
_InIt2  _Last2,
_OutIt  _Dest 
)
inline
3594  { // take set [_First2, _Last2) from [_First1, _Last1), using operator<
3595  for (; _First1 != _Last1 && _First2 != _Last2; )
3596  if (_STLCLRDB_LT(*_First1, *_First2))
3597  *_Dest++ = *_First1, ++_First1;
3598  else if (*_First2 < *_First1)
3599  ++_First2;
3600  else
3601  ++_First1, ++_First2;
3602  return (cliext::copy_unchecked(_First1, _Last1, _Dest));
3603  }
#define _STLCLRDB_LT(left, right)
Definition: memory:218
_OutIt copy_unchecked(_InIt _First, _InIt _Last, _OutIt _Dest)
Definition: memory:490
template<class _InIt1 , class _InIt2 , class _OutIt , class _Pr >
_OutIt cliext::set_difference_unchecked ( _InIt1  _First1,
_InIt1  _Last1,
_InIt2  _First2,
_InIt2  _Last2,
_OutIt  _Dest,
_Pr  _Pred 
)
inline
3626  { // take set [_First2, _Last2) from [_First1, _Last1), using _Pred
3627  for (; _First1 != _Last1 && _First2 != _Last2; )
3628  if (_STLCLRDB_LT_PRED(_Pred, *_First1, *_First2))
3629  *_Dest++ = *_First1, ++_First1;
3630  else if (_Pred(*_First2, *_First1))
3631  ++_First2;
3632  else
3633  ++_First1, ++_First2;
3634  return (cliext::copy_unchecked(_First1, _Last1, _Dest));
3635  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _STLCLRDB_LT_PRED(pred, left, right)
Definition: memory:219
_OutIt copy_unchecked(_InIt _First, _InIt _Last, _OutIt _Dest)
Definition: memory:490
template<class _InIt1 , class _InIt2 , class _OutIt >
_OutIt cliext::set_intersection ( _InIt1  _First1,
_InIt1  _Last1,
_InIt2  _First2,
_InIt2  _Last2,
_OutIt  _Dest 
)
inline
3546  { // AND sets [_First1, _Last1) and [_First2, _Last2), using operator<
3547  _STLCLRDB_ORDER(_First1, _Last1);
3548  _STLCLRDB_ORDER(_First2, _Last2);
3549  _STLCLRDB_POINTER(_Dest);
3551  _Unchecked(_First1), _Unchecked(_Last1),
3552  _Unchecked(_First2), _Unchecked(_Last2), _Unchecked(_Dest)));
3553  }
#define _STLCLRDB_ORDER(first, last)
Definition: memory:223
#define _STLCLRDB_POINTER(first)
Definition: memory:221
_OutIt set_intersection_unchecked(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
Definition: algorithm:3528
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
template<class _InIt1 , class _InIt2 , class _OutIt , class _Pr >
_OutIt cliext::set_intersection ( _InIt1  _First1,
_InIt1  _Last1,
_InIt2  _First2,
_InIt2  _Last2,
_OutIt  _Dest,
_Pr  _Pred 
)
inline
3579  { // AND sets [_First1, _Last1) and [_First2, _Last2), using _Pred
3580  _STLCLRDB_ORDER_PRED(_First1, _Last1, _Pred);
3581  _STLCLRDB_ORDER_PRED(_First2, _Last2, _Pred);
3582  _STLCLRDB_POINTER(_Dest);
3584  _Unchecked(_First1), _Unchecked(_Last1),
3585  _Unchecked(_First2), _Unchecked(_Last2), _Unchecked(_Dest), _Pred));
3586  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _STLCLRDB_POINTER(first)
Definition: memory:221
_OutIt set_intersection_unchecked(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
Definition: algorithm:3528
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_ORDER_PRED(first, last, pred)
Definition: memory:224
template<class _InIt1 , class _InIt2 , class _OutIt >
_OutIt cliext::set_intersection_unchecked ( _InIt1  _First1,
_InIt1  _Last1,
_InIt2  _First2,
_InIt2  _Last2,
_OutIt  _Dest 
)
inline
3530  { // AND sets [_First1, _Last1) and [_First2, _Last2), using operator<
3531  for (; _First1 != _Last1 && _First2 != _Last2; )
3532  if (_STLCLRDB_LT(*_First1, *_First2))
3533  ++_First1;
3534  else if (*_First2 < *_First1)
3535  ++_First2;
3536  else
3537  *_Dest++ = *_First1++, ++_First2;
3538  return (_Dest);
3539  }
#define _STLCLRDB_LT(left, right)
Definition: memory:218
template<class _InIt1 , class _InIt2 , class _OutIt , class _Pr >
_OutIt cliext::set_intersection_unchecked ( _InIt1  _First1,
_InIt1  _Last1,
_InIt2  _First2,
_InIt2  _Last2,
_OutIt  _Dest,
_Pr  _Pred 
)
inline
3562  { // AND sets [_First1, _Last1) and [_First2, _Last2), using _Pred
3563  for (; _First1 != _Last1 && _First2 != _Last2; )
3564  if (_STLCLRDB_LT_PRED(_Pred, *_First1, *_First2))
3565  ++_First1;
3566  else if (_Pred(*_First2, *_First1))
3567  ++_First2;
3568  else
3569  *_Dest++ = *_First1++, ++_First2;
3570  return (_Dest);
3571  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _STLCLRDB_LT_PRED(pred, left, right)
Definition: memory:219
template<class _InIt1 , class _InIt2 , class _OutIt >
_OutIt cliext::set_symmetric_difference ( _InIt1  _First1,
_InIt1  _Last1,
_InIt2  _First2,
_InIt2  _Last2,
_OutIt  _Dest 
)
inline
3675  { // XOR sets [_First1, _Last1) and [_First2, _Last2), using operator<
3676  _STLCLRDB_ORDER(_First1, _Last1);
3677  _STLCLRDB_ORDER(_First2, _Last2);
3678  _STLCLRDB_POINTER(_Dest);
3680  _Unchecked(_First1), _Unchecked(_Last1),
3681  _Unchecked(_First2), _Unchecked(_Last2), _Unchecked(_Dest)));
3682  }
#define _STLCLRDB_ORDER(first, last)
Definition: memory:223
#define _STLCLRDB_POINTER(first)
Definition: memory:221
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
_OutIt set_symmetric_difference_unchecked(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
Definition: algorithm:3656
template<class _InIt1 , class _InIt2 , class _OutIt , class _Pr >
_OutIt cliext::set_symmetric_difference ( _InIt1  _First1,
_InIt1  _Last1,
_InIt2  _First2,
_InIt2  _Last2,
_OutIt  _Dest,
_Pr  _Pred 
)
inline
3709  { // XOR sets [_First1, _Last1) and [_First2, _Last2), using _Pred
3710  _STLCLRDB_ORDER_PRED(_First1, _Last1, _Pred);
3711  _STLCLRDB_ORDER_PRED(_First2, _Last2, _Pred);
3712  _STLCLRDB_POINTER(_Dest);
3714  _Unchecked(_First1), _Unchecked(_Last1),
3715  _Unchecked(_First2), _Unchecked(_Last2), _Unchecked(_Dest), _Pred));
3716  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _STLCLRDB_POINTER(first)
Definition: memory:221
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_ORDER_PRED(first, last, pred)
Definition: memory:224
_OutIt set_symmetric_difference_unchecked(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
Definition: algorithm:3656
template<class _InIt1 , class _InIt2 , class _OutIt >
_OutIt cliext::set_symmetric_difference_unchecked ( _InIt1  _First1,
_InIt1  _Last1,
_InIt2  _First2,
_InIt2  _Last2,
_OutIt  _Dest 
)
inline
3658  { // XOR sets [_First1, _Last1) and [_First2, _Last2), using operator<
3659  for (; _First1 != _Last1 && _First2 != _Last2; )
3660  if (_STLCLRDB_LT(*_First1, *_First2))
3661  *_Dest++ = *_First1, ++_First1;
3662  else if (*_First2 < *_First1)
3663  *_Dest++ = *_First2, ++_First2;
3664  else
3665  ++_First1, ++_First2;
3666  _Dest = cliext::copy_unchecked(_First1, _Last1, _Dest);
3667  return (cliext::copy_unchecked(_First2, _Last2, _Dest));
3668  }
#define _STLCLRDB_LT(left, right)
Definition: memory:218
_OutIt copy_unchecked(_InIt _First, _InIt _Last, _OutIt _Dest)
Definition: memory:490
template<class _InIt1 , class _InIt2 , class _OutIt , class _Pr >
_OutIt cliext::set_symmetric_difference_unchecked ( _InIt1  _First1,
_InIt1  _Last1,
_InIt2  _First2,
_InIt2  _Last2,
_OutIt  _Dest,
_Pr  _Pred 
)
inline
3691  { // XOR sets [_First1, _Last1) and [_First2, _Last2), using _Pred
3692  for (; _First1 != _Last1 && _First2 != _Last2; )
3693  if (_STLCLRDB_LT_PRED(_Pred, *_First1, *_First2))
3694  *_Dest++ = *_First1, ++_First1;
3695  else if (_Pred(*_First2, *_First1))
3696  *_Dest++ = *_First2, ++_First2;
3697  else
3698  ++_First1, ++_First2;
3699  _Dest = cliext::copy_unchecked(_First1, _Last1, _Dest);
3700  return (cliext::copy_unchecked(_First2, _Last2, _Dest));
3701  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _STLCLRDB_LT_PRED(pred, left, right)
Definition: memory:219
_OutIt copy_unchecked(_InIt _First, _InIt _Last, _OutIt _Dest)
Definition: memory:490
template<class _InIt1 , class _InIt2 , class _OutIt >
_OutIt cliext::set_union ( _InIt1  _First1,
_InIt1  _Last1,
_InIt2  _First2,
_InIt2  _Last2,
_OutIt  _Dest 
)
inline
3481  { // OR sets [_First1, _Last1) and [_First2, _Last2), using operator<
3482  _STLCLRDB_ORDER(_First1, _Last1);
3483  _STLCLRDB_ORDER(_First2, _Last2);
3484  _STLCLRDB_POINTER(_Dest);
3486  _Unchecked(_First1), _Unchecked(_Last1),
3487  _Unchecked(_First2), _Unchecked(_Last2), _Unchecked(_Dest)));
3488  }
#define _STLCLRDB_ORDER(first, last)
Definition: memory:223
_OutIt set_union_unchecked(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
Definition: algorithm:3462
#define _STLCLRDB_POINTER(first)
Definition: memory:221
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
template<class _InIt1 , class _InIt2 , class _OutIt , class _Pr >
_OutIt cliext::set_union ( _InIt1  _First1,
_InIt1  _Last1,
_InIt2  _First2,
_InIt2  _Last2,
_OutIt  _Dest,
_Pr  _Pred 
)
inline
3515  { // OR sets [_First1, _Last1) and [_First2, _Last2), using _Pred
3516  _STLCLRDB_ORDER_PRED(_First1, _Last1, _Pred);
3517  _STLCLRDB_ORDER_PRED(_First2, _Last2, _Pred);
3518  _STLCLRDB_POINTER(_Dest);
3520  _Unchecked(_First1), _Unchecked(_Last1),
3521  _Unchecked(_First2), _Unchecked(_Last2), _Unchecked(_Dest), _Pred));
3522  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
_OutIt set_union_unchecked(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
Definition: algorithm:3462
#define _STLCLRDB_POINTER(first)
Definition: memory:221
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_ORDER_PRED(first, last, pred)
Definition: memory:224
template<class _InIt1 , class _InIt2 , class _OutIt >
_OutIt cliext::set_union_unchecked ( _InIt1  _First1,
_InIt1  _Last1,
_InIt2  _First2,
_InIt2  _Last2,
_OutIt  _Dest 
)
inline
3464  { // OR sets [_First1, _Last1) and [_First2, _Last2), using operator<
3465  for (; _First1 != _Last1 && _First2 != _Last2; )
3466  if (_STLCLRDB_LT(*_First1, *_First2))
3467  *_Dest++ = *_First1, ++_First1;
3468  else if (*_First2 < *_First1)
3469  *_Dest++ = *_First2, ++_First2;
3470  else
3471  *_Dest++ = *_First1, ++_First1, ++_First2;
3472  _Dest = cliext::copy_unchecked(_First1, _Last1, _Dest);
3473  return (cliext::copy_unchecked(_First2, _Last2, _Dest));
3474  }
#define _STLCLRDB_LT(left, right)
Definition: memory:218
_OutIt copy_unchecked(_InIt _First, _InIt _Last, _OutIt _Dest)
Definition: memory:490
template<class _InIt1 , class _InIt2 , class _OutIt , class _Pr >
_OutIt cliext::set_union_unchecked ( _InIt1  _First1,
_InIt1  _Last1,
_InIt2  _First2,
_InIt2  _Last2,
_OutIt  _Dest,
_Pr  _Pred 
)
inline
3497  { // OR sets [_First1, _Last1) and [_First2, _Last2), using _Pred
3498  for (; _First1 != _Last1 && _First2 != _Last2; )
3499  if (_STLCLRDB_LT_PRED(_Pred, *_First1, *_First2))
3500  *_Dest++ = *_First1, ++_First1;
3501  else if (_Pred(*_First2, *_First1))
3502  *_Dest++ = *_First2, ++_First2;
3503  else
3504  *_Dest++ = *_First1, ++_First1, ++_First2;
3505  _Dest = cliext::copy_unchecked(_First1, _Last1, _Dest);
3506  return (cliext::copy_unchecked(_First2, _Last2, _Dest));
3507  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _STLCLRDB_LT_PRED(pred, left, right)
Definition: memory:219
_OutIt copy_unchecked(_InIt _First, _InIt _Last, _OutIt _Dest)
Definition: memory:490
template<class _RanIt >
void cliext::sort ( _RanIt  _First,
_RanIt  _Last 
)
inline
2668  { // order [_First, _Last), using operator<
2669  _STLCLRDB_RANGE(_First, _Last);
2671  }
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
void sort_unchecked(_RanIt _First, _RanIt _Last)
Definition: algorithm:2661
_FwdIt _Last
Definition: algorithm:1936
template<class _RanIt , class _Pr >
void cliext::sort ( _RanIt  _First,
_RanIt  _Last,
_Pr  _Pred 
)
inline
2832  { // order [_First, _Last), using _Pred
2833  _STLCLRDB_RANGE(_First, _Last);
2836  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _STLCLRDB_POINTER(first)
Definition: memory:221
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
void sort_unchecked(_RanIt _First, _RanIt _Last)
Definition: algorithm:2661
_FwdIt _Last
Definition: algorithm:1936
template<class _RanIt >
void cliext::sort_heap ( _RanIt  _First,
_RanIt  _Last 
)
inline
1768  { // order heap by repeatedly popping, using operator<
1769  _STLCLRDB_RANGE(_First, _Last);
1770  _STLCLRDB_HEAP(_First, _Last);
1772  }
#define _STLCLRDB_HEAP(first, last)
Definition: algorithm:1489
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
void sort_heap_unchecked(_RanIt _First, _RanIt _Last)
Definition: algorithm:1760
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_FwdIt _Last
Definition: algorithm:1936
template<class _RanIt , class _Pr >
void cliext::sort_heap ( _RanIt  _First,
_RanIt  _Last,
_Pr  _Pred 
)
inline
1786  { // order heap by repeatedly popping, using _Pred
1787  _STLCLRDB_RANGE(_First, _Last);
1789  _STLCLRDB_HEAP_PRED(_First, _Last, _Pred);
1791  _Pred);
1792  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _STLCLRDB_HEAP_PRED(first, last, pred)
Definition: algorithm:1490
#define _STLCLRDB_POINTER(first)
Definition: memory:221
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
void sort_heap_unchecked(_RanIt _First, _RanIt _Last)
Definition: algorithm:1760
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_FwdIt _Last
Definition: algorithm:1936
template<class _RanIt >
void cliext::sort_heap_unchecked ( _RanIt  _First,
_RanIt  _Last 
)
inline
1761  { // order heap by repeatedly popping, using operator<
1762  for (; 1 < _Last - _First; --_Last)
1764  }
void pop_heap_unchecked(_RanIt _First, _RanIt _Last)
Definition: algorithm:1622
_FwdIt _Last
Definition: algorithm:1936
template<class _RanIt , class _Pr >
void cliext::sort_heap_unchecked ( _RanIt  _First,
_RanIt  _Last,
_Pr  _Pred 
)
inline
1778  { // order heap by repeatedly popping, using _Pred
1779  for (; 1 < _Last - _First; --_Last)
1781  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
void pop_heap_unchecked(_RanIt _First, _RanIt _Last)
Definition: algorithm:1622
_FwdIt _Last
Definition: algorithm:1936
template<class _RanIt >
void cliext::sort_unchecked ( _RanIt  _First,
_RanIt  _Last 
)
inline
2662  { // order [_First, _Last), using operator<
2663  cliext::_XSort(_First, _Last, _Last - _First);
2664  }
void _XSort(_RanIt _First, _RanIt _Last, _Diff _Ideal)
Definition: algorithm:2630
_FwdIt _Last
Definition: algorithm:1936
template<class _RanIt , class _Pr >
void cliext::sort_unchecked ( _RanIt  _First,
_RanIt  _Last,
_Pr  _Pred 
)
inline
2825  { // order [_First, _Last), using _Pred
2826  cliext::_XSort(_First, _Last, _Last - _First, _Pred);
2827  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
void _XSort(_RanIt _First, _RanIt _Last, _Diff _Ideal)
Definition: algorithm:2630
_FwdIt _Last
Definition: algorithm:1936
template<class _BidIt , class _Pr >
_BidIt cliext::stable_partition ( _BidIt  _First,
_BidIt  _Last,
_Pr  _Pred 
)
inline
1446  { // partition preserving order of equivalents, using _Pred
1447  _STLCLRDB_RANGE(_First, _Last);
1450  _Unchecked(_First), _Unchecked(_Last), _Pred));
1451 
1452  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
_BidIt stable_partition_unchecked(_BidIt _First, _BidIt _Last, _Pr _Pred)
Definition: algorithm:1423
#define _STLCLRDB_POINTER(first)
Definition: memory:221
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_FwdIt _Last
Definition: algorithm:1936
template<class _BidIt , class _Pr >
_BidIt cliext::stable_partition_unchecked ( _BidIt  _First,
_BidIt  _Last,
_Pr  _Pred 
)
inline
1425  { // partition preserving order of equivalents, using _Pred
1428 
1429  if (_First == _Last)
1430  return (_First);
1431  else
1432  { // partition nontrivial sequence
1433  _Diff _Count = 0;
1434  _Iter_distance(_First, _Last, _Count);
1435  _TEMP_ITER(_BidIt, _Ty) _Tempbuf(_Count);
1436 
1437  return (cliext::_XStable_partition(_First, _Last, _Pred, _Count,
1438  _Tempbuf));
1439  }
1440  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
_Iter::difference_type difference_type
Definition: xutility:373
#define _TEMP_ITER(iter_t, value_t)
Definition: memory:244
return(cliext::equal_range_unchecked(_Unchecked(_First), _Unchecked(_Last), _Val, _Pred))
_Iter_distance(_First, _Last, _Count)
_Iter::value_type value_type
Definition: xutility:372
_Diff _Count
Definition: algorithm:1941
Definition: adapter:7
_BidIt _XStable_partition(_BidIt _First, _BidIt _Last, _Pr _Pred, _Diff _Count, _Temp_iterator< _Ty > _Tempbuf)
Definition: algorithm:1337
_FwdIt _Last
Definition: algorithm:1936
template<class _BidIt >
void cliext::stable_sort ( _BidIt  _First,
_BidIt  _Last 
)
inline
3007  { // sort preserving order of equivalents, using operator<
3008  _STLCLRDB_RANGE(_First, _Last);
3010  }
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
void stable_sort_unchecked(_BidIt _First, _BidIt _Last)
Definition: algorithm:2990
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_FwdIt _Last
Definition: algorithm:1936
template<class _BidIt , class _Pr >
void cliext::stable_sort ( _BidIt  _First,
_BidIt  _Last,
_Pr  _Pred 
)
inline
3192  { // sort preserving order of equivalents, using _Pred
3193  _STLCLRDB_RANGE(_First, _Last);
3196  _Unchecked(_First), _Unchecked(_Last), _Pred);
3197  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _STLCLRDB_POINTER(first)
Definition: memory:221
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
void stable_sort_unchecked(_BidIt _First, _BidIt _Last)
Definition: algorithm:2990
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_FwdIt _Last
Definition: algorithm:1936
template<class _BidIt >
void cliext::stable_sort_unchecked ( _BidIt  _First,
_BidIt  _Last 
)
inline
2991  { // sort preserving order of equivalents, using operator<
2994 
2995  if (_First != _Last)
2996  { // sort nontrivial sequence
2997  _Diff _Count = 0;
2998  _Iter_distance(_First, _Last, _Count);
2999  _TEMP_ITER(_BidIt, _Ty) _Tempbuf((_Count + 1) / 2);
3000 
3001  cliext::_XStable_sort(_First, _Last, _Count, _Tempbuf);
3002  }
3003  }
_Iter::difference_type difference_type
Definition: xutility:373
#define _TEMP_ITER(iter_t, value_t)
Definition: memory:244
void _XStable_sort(_BidIt _First, _BidIt _Last, _Diff _Count, _Temp_iterator< _Ty > _Tempbuf, _Pr _Pred)
Definition: algorithm:3105
_Iter_distance(_First, _Last, _Count)
_Iter::value_type value_type
Definition: xutility:372
_Diff _Count
Definition: algorithm:1941
Definition: adapter:7
_FwdIt _Last
Definition: algorithm:1936
template<class _BidIt , class _Pr >
void cliext::stable_sort_unchecked ( _BidIt  _First,
_BidIt  _Last,
_Pr  _Pred 
)
inline
3176  { // sort preserving order of equivalents, using _Pred
3179 
3180  if (_First != _Last)
3181  { // sort nontrivial sequence
3182  _Diff _Count = 0;
3183  _Iter_distance(_First, _Last, _Count);
3184  _TEMP_ITER(_BidIt, _Ty) _Tempbuf((_Count + 1) / 2);
3185  cliext::_XStable_sort(_First, _Last, _Count, _Tempbuf, _Pred);
3186  }
3187  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
_Iter::difference_type difference_type
Definition: xutility:373
#define _TEMP_ITER(iter_t, value_t)
Definition: memory:244
void _XStable_sort(_BidIt _First, _BidIt _Last, _Diff _Count, _Temp_iterator< _Ty > _Tempbuf, _Pr _Pred)
Definition: algorithm:3105
_Iter_distance(_First, _Last, _Count)
_Iter::value_type value_type
Definition: xutility:372
_Diff _Count
Definition: algorithm:1941
Definition: adapter:7
_FwdIt _Last
Definition: algorithm:1936
template<class _Ty1 , class _Ty2 >
void cliext::swap ( pair< _Ty1, _Ty2 >%  _Left,
pair< _Ty1, _Ty2 >%  _Right 
)
inline
106  { // swap _Left and _Right pairs
107  _Left.swap(_Right);
108  }
void swap(_Myt &_Right)&&_NOEXCEPT_OP(_Swap_adl(this-> second, _Right.second)))
Definition: utility:180
template<class _Ty >
void cliext::swap ( _Ty%  _Left,
_Ty%  _Right 
)
inline
482  { // exchange values stored at _Left and _Right
483  _Ty _Tmp = _Left;
484  _Left = _Right, _Right = _Tmp;
485  }
const _Ty & _Right
Definition: algorithm:4087
template<typename _Key_t >
void cliext::swap ( set< _Key_t >%  _Left,
set< _Key_t >%  _Right 
)
inline
562  { // swap two sets
563  _Left.swap(_Right);
564  }
void swap(_Myt &_Right)
Definition: set:155
template<typename _Key_t >
void cliext::swap ( cliext::hash_set< _Key_t >%  _Left,
cliext::hash_set< _Key_t >%  _Right 
)
inline
658  { // swap two hash_sets
659  _Left.swap(_Right);
660  }
void swap(hash_set%_Right)
Definition: hash_set:639
template<typename _Traits_t >
void cliext::swap ( cliext::impl::hash< _Traits_t >%  _Left,
cliext::impl::hash< _Traits_t >%  _Right 
)
inline
1017  { // swap two hash objects
1018  _Left.swap(_Right);
1019  }
void swap(_Mytype_t%_Right)
Definition: xhash:473
template<typename _Key_t >
void cliext::swap ( multiset< _Key_t >%  _Left,
multiset< _Key_t >%  _Right 
)
inline
1089  { // swap two multisets
1090  _Left.swap(_Right);
1091  }
void swap(_Myt &_Right)
Definition: set:344
template<typename _Key_t , typename _Mapped_t >
void cliext::swap ( map< _Key_t, _Mapped_t >%  _Left,
map< _Key_t, _Mapped_t >%  _Right 
)
inline
1245  { // swap two maps
1246  _Left.swap(_Right);
1247  }
void swap(_Myt &_Right)
Definition: map:187
template<typename _Key_t >
void cliext::swap ( cliext::hash_multiset< _Key_t >%  _Left,
cliext::hash_multiset< _Key_t >%  _Right 
)
inline
1253  { // swap two hash_multisets
1254  _Left.swap(_Right);
1255  }
void swap(hash_multiset%_Right)
Definition: hash_set:1234
template<typename _Key_t , typename _Mapped_t >
void cliext::swap ( cliext::hash_map< _Key_t, _Mapped_t >%  _Left,
cliext::hash_map< _Key_t, _Mapped_t >%  _Right 
)
inline
1380  { // swap two hash_maps
1381  _Left.swap(_Right);
1382  }
void swap(hash_map%_Right)
Definition: hash_map:1360
template<typename _Traits_t >
void cliext::swap ( cliext::impl::tree< _Traits_t >%  _Left,
cliext::impl::tree< _Traits_t >%  _Right 
)
inline
1448  { // swap two trees
1449  _Left.swap(_Right);
1450  }
void swap(_Mytype_t%_Right)
Definition: xtree:811
template<typename _Value_t >
void cliext::swap ( vector< _Value_t >%  _Left,
vector< _Value_t >%  _Right 
)
inline
1464  { // swap two vectors
1465  _Left.swap(_Right);
1466  }
void swap(_Myt &_Right)
Definition: vector:1513
template<typename _Value_t >
void cliext::swap ( deque< _Value_t >%  _Left,
deque< _Value_t >%  _Right 
)
inline
1662  { // swap two deques
1663  _Left.swap(_Right);
1664  }
void swap(_Myt &_Right)
Definition: deque:1646
template<typename _Value_t >
void cliext::swap ( list< _Value_t >%  _Left,
list< _Value_t >%  _Right 
)
inline
1858  { // swap two lists
1859  _Left.swap(_Right);
1860  }
void swap(_Myt &_Right)
Definition: list:1508
template<typename _Key_t , typename _Mapped_t >
void cliext::swap ( multimap< _Key_t, _Mapped_t >%  _Left,
multimap< _Key_t, _Mapped_t >%  _Right 
)
inline
2213  { // swap two multimaps
2214  _Left.swap(_Right);
2215  }
void swap(_Myt &_Right)
Definition: map:400
template<typename _Key_t , typename _Mapped_t >
void cliext::swap ( cliext::hash_multimap< _Key_t, _Mapped_t >%  _Left,
cliext::hash_multimap< _Key_t, _Mapped_t >%  _Right 
)
inline
2461  { // swap two hash_multimaps
2462  _Left.swap(_Right);
2463  }
void swap(hash_multimap%_Right)
Definition: hash_map:2441
template<class _FwdIt1 , class _FwdIt2 >
_FwdIt2 cliext::swap_ranges ( _FwdIt1  _First1,
_FwdIt1  _Last1,
_FwdIt2  _First2 
)
inline
593  { // swap [_First1, _Last1) with [_First2, ...)
594  _STLCLRDB_RANGE(_First1, _Last1);
596  _Unchecked(_First1), _Unchecked(_Last1),
597  _Unchecked(_First2)));
598  }
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
_FwdIt2 swap_ranges_unchecked(_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2)
Definition: algorithm:581
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
template<class _FwdIt1 , class _FwdIt2 >
_FwdIt2 cliext::swap_ranges_unchecked ( _FwdIt1  _First1,
_FwdIt1  _Last1,
_FwdIt2  _First2 
)
inline
583  { // swap [_First1, _Last1) with [_First2, ...)
584  for (; _First1 != _Last1; ++_First1, ++_First2)
585  cliext::iter_swap(_First1, _First2);
586  return (_First2);
587  }
void iter_swap(_FwdIt1 _Left, _FwdIt2 _Right)
Definition: algorithm:573
template<class _InIt , class _OutIt , class _Fn1 >
_OutIt cliext::transform ( _InIt  _First,
_InIt  _Last,
_OutIt  _Dest,
_Fn1  _Func 
)
inline
616  { // transform [_First, _Last) with _Func
617  _STLCLRDB_RANGE(_First, _Last);
618  _STLCLRDB_POINTER(_Dest);
619  _STLCLRDB_POINTER(_Func);
621  _Unchecked(_First), _Unchecked(_Last),
622  _Dest, _Func));
623  }
#define _STLCLRDB_POINTER(first)
Definition: memory:221
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
_OutIt transform_unchecked(_InIt _First, _InIt _Last, _OutIt _Dest, _Fn1 _Func)
Definition: algorithm:604
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt1 , class _InIt2 , class _OutIt , class _Fn2 >
_OutIt cliext::transform ( _InIt1  _First1,
_InIt1  _Last1,
_InIt2  _First2,
_OutIt  _Dest,
_Fn2  _Func 
)
inline
644  { // transform [_First1, _Last1) and [_First2, _Last2) with _Func
645  _STLCLRDB_RANGE(_First1, _Last1);
646  _STLCLRDB_POINTER(_First2);
647  _STLCLRDB_POINTER(_Dest);
648  _STLCLRDB_POINTER(_Func);
650  _Unchecked(_First1), _Unchecked(_Last1),
651  _Unchecked(_First2), _Dest, _Func));
652  }
#define _STLCLRDB_POINTER(first)
Definition: memory:221
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
_OutIt transform_unchecked(_InIt _First, _InIt _Last, _OutIt _Dest, _Fn1 _Func)
Definition: algorithm:604
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
template<class _InIt , class _OutIt , class _Fn1 >
_OutIt cliext::transform_unchecked ( _InIt  _First,
_InIt  _Last,
_OutIt  _Dest,
_Fn1  _Func 
)
inline
606  { // transform [_First, _Last) with _Func
607  for (; _First != _Last; ++_First, ++_Dest)
608  *_Dest = _Func(*_First);
609  return (_Dest);
610  }
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt1 , class _InIt2 , class _OutIt , class _Fn2 >
_OutIt cliext::transform_unchecked ( _InIt1  _First1,
_InIt1  _Last1,
_InIt2  _First2,
_OutIt  _Dest,
_Fn2  _Func 
)
inline
632  { // transform [_First1, _Last1) and [_First2, _Last2) with _Func
633  for (; _First1 != _Last1; ++_First1, ++_First2, ++_Dest)
634  *_Dest = _Func(*_First1, *_First2);
635  return (_Dest);
636  }
template<typename TArg , typename TResult >
delegate TResult cliext::unary_delegate ( TArg  )
template<typename TArg >
delegate void cliext::unary_delegate_noreturn ( TArg  )
template<class _FwdIt >
_FwdIt cliext::unique ( _FwdIt  _First,
_FwdIt  _Last 
)
inline
912  { // remove each matching previous
913  _STLCLRDB_RANGE(_First, _Last);
914  return (cliext::unique_unchecked(
915  _Unchecked(_First), _Unchecked(_Last)));
916  }
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
_FwdIt unique_unchecked(_FwdIt _First, _FwdIt _Last)
Definition: algorithm:897
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_FwdIt _Last
Definition: algorithm:1936
template<class _FwdIt , class _Pr >
_FwdIt cliext::unique ( _FwdIt  _First,
_FwdIt  _Last,
_Pr  _Pred 
)
inline
937  { // remove each satisfying _Pred with previous
938  _STLCLRDB_RANGE(_First, _Last);
940  return (cliext::unique_unchecked(
941  _Unchecked(_First), _Unchecked(_Last), _Pred));
942  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _STLCLRDB_POINTER(first)
Definition: memory:221
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
_FwdIt unique_unchecked(_FwdIt _First, _FwdIt _Last)
Definition: algorithm:897
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt , class _OutIt >
_OutIt cliext::unique_copy ( _InIt  _First,
_InIt  _Last,
_OutIt  _Dest 
)
inline
999  { // copy compressing pairs that match
1000  _STLCLRDB_RANGE(_First, _Last);
1001  _STLCLRDB_POINTER(_Dest);
1002  return (unique_copy_unchecked(
1003  _Unchecked(_First), _Unchecked(_Last),
1004  _Unchecked(_Dest)));
1005  }
#define _STLCLRDB_POINTER(first)
Definition: memory:221
_OutIt unique_copy_unchecked(_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred)
Definition: algorithm:1061
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt , class _OutIt , class _Pr >
_OutIt cliext::unique_copy ( _InIt  _First,
_InIt  _Last,
_OutIt  _Dest,
_Pr  _Pred 
)
inline
1072  { // copy compressing pairs satisfying _Pred
1073  _STLCLRDB_RANGE(_First, _Last);
1074  _STLCLRDB_POINTER(_Dest);
1076  return (unique_copy_unchecked(
1077  _Unchecked(_First), _Unchecked(_Last),
1078  _Unchecked(_Dest), _Pred));
1079  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _STLCLRDB_POINTER(first)
Definition: memory:221
_OutIt unique_copy_unchecked(_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred)
Definition: algorithm:1061
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_RANGE(first, last)
Definition: memory:226
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt , class _OutIt >
_OutIt cliext::unique_copy_unchecked ( _InIt  _First,
_InIt  _Last,
_OutIt  _Dest 
)
inline
991  { // copy compressing pairs that match
992  return (_First == _Last ? _Dest
993  : _Unique_copy(_First, _Last, _Dest, _Iter_category(_First)));
994  }
iterator_traits< _Iter_t >::iterator_category _Iter_category(_Iter_t)
Definition: xutility:654
_OutIt _Unique_copy(_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred, _Ty *)
Definition: algorithm:1814
_FwdIt _Last
Definition: algorithm:1936
template<class _InIt , class _OutIt , class _Pr >
_OutIt cliext::unique_copy_unchecked ( _InIt  _First,
_InIt  _Last,
_OutIt  _Dest,
_Pr  _Pred 
)
inline
1063  { // copy compressing pairs satisfying _Pred
1064  return (_First == _Last ? _Dest
1065  : _Unique_copy(_First, _Last, _Dest, _Pred, _Iter_category(_First)));
1066  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
iterator_traits< _Iter_t >::iterator_category _Iter_category(_Iter_t)
Definition: xutility:654
_OutIt _Unique_copy(_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred, _Ty *)
Definition: algorithm:1814
_FwdIt _Last
Definition: algorithm:1936
template<class _FwdIt >
_FwdIt cliext::unique_unchecked ( _FwdIt  _First,
_FwdIt  _Last 
)
inline
898  { // remove each matching previous
899  for (_FwdIt _Firstb; (_Firstb = _First) != _Last && ++_First != _Last; )
900  if (*_Firstb == *_First)
901  { // copy down
902  for (; ++_First != _Last; )
903  if (!(*_Firstb == *_First))
904  *++_Firstb = *_First;
905  return (++_Firstb);
906  }
907  return (_Last);
908  }
_FwdIt _Last
Definition: algorithm:1936
template<class _FwdIt , class _Pr >
_FwdIt cliext::unique_unchecked ( _FwdIt  _First,
_FwdIt  _Last,
_Pr  _Pred 
)
inline
922  { // remove each satisfying _Pred with previous
923  for (_FwdIt _Firstb; (_Firstb = _First) != _Last && ++_First != _Last; )
924  if (_Pred(*_Firstb, *_First))
925  { // copy down
926  for (; ++_First != _Last; )
927  if (!_Pred(*_Firstb, *_First))
928  *++_Firstb = *_First;
929  return (++_Firstb);
930  }
931  return (_Last);
932  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
_FwdIt _Last
Definition: algorithm:1936
template<class _FwdIt , class _Ty >
_FwdIt cliext::upper_bound ( _FwdIt  _First,
_FwdIt  _Last,
const _Ty%  _Val 
)
inline
1891  { // find first element that _Val is before, using operator<
1892  _STLCLRDB_ORDER(_First, _Last);
1894  _Unchecked(_First), _Unchecked(_Last), _Val));
1895  }
#define _STLCLRDB_ORDER(first, last)
Definition: memory:223
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
_FwdIt upper_bound_unchecked(_FwdIt _First, _FwdIt _Last, const _Ty%_Val)
Definition: algorithm:1867
_FwdIt const _Ty _Val
Definition: algorithm:1938
_FwdIt _Last
Definition: algorithm:1936
template<class _FwdIt , class _Ty , class _Pr >
_FwdIt cliext::upper_bound ( _FwdIt  _First,
_FwdIt  _Last,
const _Ty%  _Val,
_Pr  _Pred 
)
inline
1927  { // find first element that _Val is before, using _Pred
1928  _STLCLRDB_ORDER_PRED(_First, _Last, _Pred);
1930  _Unchecked(_First), _Unchecked(_Last), _Val, _Pred));
1931  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
_Iter_t _Unchecked(_Iter_t _Iter)
Definition: iterator:11
#define _STLCLRDB_ORDER_PRED(first, last, pred)
Definition: memory:224
_FwdIt upper_bound_unchecked(_FwdIt _First, _FwdIt _Last, const _Ty%_Val)
Definition: algorithm:1867
_FwdIt const _Ty _Val
Definition: algorithm:1938
_FwdIt _Last
Definition: algorithm:1936
template<class _FwdIt , class _Ty >
_FwdIt cliext::upper_bound_unchecked ( _FwdIt  _First,
_FwdIt  _Last,
const _Ty%  _Val 
)
inline
1869  { // find first element that _Val is before, using operator<
1871 
1872  _Diff _Count = 0;
1873  _Iter_distance(_First, _Last, _Count);
1874  for (; 0 < _Count; )
1875  { // divide and conquer, find half that contains answer
1876  _Diff _Count2 = _Count / 2;
1877  _FwdIt _Mid = _First;
1878  cliext::advance(_Mid, _Count2);
1879 
1880  if (!_STLCLRDB_LT(_Val, *_Mid))
1881  _First = ++_Mid, _Count -= _Count2 + 1;
1882  else
1883  _Count = _Count2;
1884  }
1885  return (_First);
1886  }
#define _STLCLRDB_LT(left, right)
Definition: memory:218
_Iter::difference_type difference_type
Definition: xutility:373
_Iter_distance(_First, _Last, _Count)
void advance(_InIt_t%_Where, _Diff_t _Off)
Definition: xutility:694
_Diff _Count
Definition: algorithm:1941
_FwdIt const _Ty _Val
Definition: algorithm:1938
_FwdIt _Last
Definition: algorithm:1936
template<class _FwdIt , class _Ty , class _Pr >
_FwdIt cliext::upper_bound_unchecked ( _FwdIt  _First,
_FwdIt  _Last,
const _Ty%  _Val,
_Pr  _Pred 
)
inline
1903  { // find first element that _Val is before, using _Pred
1905 
1906  _Diff _Count = 0;
1907  _Iter_distance(_First, _Last, _Count);
1908  for (; 0 < _Count; )
1909  { // divide and conquer, find half that contains answer
1910  _Diff _Count2 = _Count / 2;
1911  _FwdIt _Mid = _First;
1912  cliext::advance(_Mid, _Count2);
1913 
1914  if (!_STLCLRDB_LT_PRED(_Pred, _Val, *_Mid))
1915  _First = ++_Mid, _Count -= _Count2 + 1;
1916  else
1917  _Count = _Count2;
1918  }
1919  return (_First);
1920  }
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
#define _STLCLRDB_LT_PRED(pred, left, right)
Definition: memory:219
_Iter::difference_type difference_type
Definition: xutility:373
_Iter_distance(_First, _Last, _Count)
void advance(_InIt_t%_Where, _Diff_t _Off)
Definition: xutility:694
_Diff _Count
Definition: algorithm:1941
_FwdIt const _Ty _Val
Definition: algorithm:1938
_FwdIt _Last
Definition: algorithm:1936
cliext::while ( )

Variable Documentation

_Diff cliext::_Count = 0
_RanIt cliext::_Gfirst = _Plast
_RanIt cliext::_Glast = _Pfirst
template<class _Iter_t >
iterator_traits<_Iter_t>::iterator_category cliext::_Iter_category(_Iter_t)
inline
655  { // return category from iterator argument
657 
658  return (_Cat);
659  }
_Iter::iterator_category iterator_category
Definition: xutility:371
_RanIt cliext::_Last
Initial value:
{
_RanIt _Mid = _First + (_Last - _First) / 2
_FwdIt _Last
Definition: algorithm:1936
_RanIt cliext::_Pfirst = _Mid
_RanIt cliext::_Plast = _Pfirst + 1
_RanIt _Pr cliext::_Pred
Initial value:
{
_Iter::difference_type difference_type
Definition: xutility:373
_FwdIt const _Ty cliext::_Val
Initial value:
{
_Iter::difference_type difference_type
Definition: xutility:373