This is the mail archive of the libstdc++@gcc.gnu.org mailing list for the libstdc++ project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

Re: [Patch] Qualify standard functions with std:: in stl_algo.h


Sorry... I attached the wrong patch, that without the
additional declarations (which doesn't compile!).

Paolo.

//////////
diff -urN libstdc++-v3-last/include/bits/stl_algo.h libstdc++-v3/include/bits/stl_algo.h
--- libstdc++-v3-last/include/bits/stl_algo.h	2003-06-10 23:52:23.000000000 +0200
+++ libstdc++-v3/include/bits/stl_algo.h	2003-06-29 22:41:25.000000000 +0200
@@ -295,7 +295,7 @@
       __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>)
       __glibcpp_function_requires(_EqualOpConcept<
 		typename iterator_traits<_InputIterator>::value_type, _Tp>)
-      return find(__first, __last, __val, __iterator_category(__first));
+      return std::find(__first, __last, __val, __iterator_category(__first));
     }
 
   /**
@@ -315,7 +315,7 @@
       __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>)
       __glibcpp_function_requires(_UnaryPredicateConcept<_Predicate,
 	      typename iterator_traits<_InputIterator>::value_type>)
-      return find_if(__first, __last, __pred, __iterator_category(__first));
+      return std::find_if(__first, __last, __pred, __iterator_category(__first));
     }
 
   /**
@@ -467,7 +467,7 @@
       _ForwardIterator2 __tmp(__first2);
       ++__tmp;
       if (__tmp == __last2)
-	return find(__first1, __last1, *__first2);
+	return std::find(__first1, __last1, *__first2);
 
       // General case.
 
@@ -478,7 +478,7 @@
       _ForwardIterator1 __current = __first1;
 
       while (__first1 != __last1) {
-	__first1 = find(__first1, __last1, *__first2);
+	__first1 = std::find(__first1, __last1, *__first2);
 	if (__first1 == __last1)
 	  return __last1;
 
@@ -607,7 +607,7 @@
       if (__count <= 0)
 	return __first;
       else {
-	__first = find(__first, __last, __val);
+	__first = std::find(__first, __last, __val);
 	while (__first != __last) {
 	  _Integer __n = __count - 1;
 	  _ForwardIterator __i = __first;
@@ -619,7 +619,7 @@
 	  if (__n == 0)
 	    return __first;
 	  else
-	    __first = find(__i, __last, __val);
+	    __first = std::find(__i, __last, __val);
 	}
 	return __last;
       }
@@ -710,7 +710,7 @@
 	    typename iterator_traits<_ForwardIterator1>::value_type>)
 
       for ( ; __first1 != __last1; ++__first1, ++__first2)
-	iter_swap(__first1, __first2);
+	std::iter_swap(__first1, __first2);
       return __first2;
     }
 
@@ -1048,10 +1048,10 @@
       __glibcpp_function_requires(_EqualOpConcept<
 	    typename iterator_traits<_ForwardIterator>::value_type, _Tp>)
 
-      __first = find(__first, __last, __value);
+      __first = std::find(__first, __last, __value);
       _ForwardIterator __i = __first;
       return __first == __last ? __first
-			       : remove_copy(++__i, __last, __first, __value);
+			       : std::remove_copy(++__i, __last, __first, __value);
     }
 
   /**
@@ -1080,10 +1080,10 @@
       __glibcpp_function_requires(_UnaryPredicateConcept<_Predicate,
 	    typename iterator_traits<_ForwardIterator>::value_type>)
 
-      __first = find_if(__first, __last, __pred);
+      __first = std::find_if(__first, __last, __pred);
       _ForwardIterator __i = __first;
       return __first == __last ? __first
-			       : remove_copy_if(++__i, __last, __first, __pred);
+			       : std::remove_copy_if(++__i, __last, __first, __pred);
     }
 
   /**
@@ -1243,8 +1243,7 @@
       typedef typename iterator_traits<_OutputIterator>::iterator_category _IterType;
 
       if (__first == __last) return __result;
-      return __unique_copy(__first, __last,
-__result, __binary_pred, _IterType());
+      return __unique_copy(__first, __last, __result, __binary_pred, _IterType());
     }
 
   /**
@@ -1269,8 +1268,8 @@
 	  __glibcpp_function_requires(_EqualityComparableConcept<
 		    typename iterator_traits<_ForwardIterator>::value_type>)
 
-	  __first = adjacent_find(__first, __last);
-	  return unique_copy(__first, __last, __first);
+	  __first = std::adjacent_find(__first, __last);
+	  return std::unique_copy(__first, __last, __first);
     }
 
   /**
@@ -1298,8 +1297,8 @@
 		typename iterator_traits<_ForwardIterator>::value_type,
 		typename iterator_traits<_ForwardIterator>::value_type>)
 
-      __first = adjacent_find(__first, __last, __binary_pred);
-      return unique_copy(__first, __last, __first, __binary_pred);
+      __first = std::adjacent_find(__first, __last, __binary_pred);
+      return std::unique_copy(__first, __last, __first, __binary_pred);
     }
 
   /**
@@ -1317,7 +1316,7 @@
 	    if (__first == __last || __first == --__last)
 		  return;
 	    else
-		  iter_swap(__first++, __last);
+		  std::iter_swap(__first++, __last);
     }
 
   /**
@@ -1332,7 +1331,7 @@
 			  random_access_iterator_tag)
     {
 	  while (__first < __last)
-	    iter_swap(__first++, --__last);
+	    std::iter_swap(__first++, --__last);
     }
 
   /**
@@ -1425,7 +1424,7 @@
 
       _ForwardIterator __first2 = __middle;
       do {
-	swap(*__first++, *__first2++);
+	std::swap(*__first++, *__first2++);
 	if (__first == __middle)
 	  __middle = __first2;
       } while (__first2 != __last);
@@ -1433,7 +1432,7 @@
       __first2 = __middle;
 
       while (__first2 != __last) {
-	swap(*__first++, *__first2++);
+	std::swap(*__first++, *__first2++);
 	if (__first == __middle)
 	  __middle = __first2;
 	else if (__first2 == __last)
@@ -1464,7 +1463,7 @@
       __reverse(__middle, __last,   bidirectional_iterator_tag());
 
       while (__first != __middle && __middle != __last)
-	swap (*__first++, *--__last);
+	std::swap(*__first++, *--__last);
 
       if (__first == __middle) {
 	__reverse(__middle, __last,   bidirectional_iterator_tag());
@@ -1501,7 +1500,7 @@
       _Distance __l = __n - __k;
 
       if (__k == __l) {
-	swap_ranges(__first, __middle, __middle);
+	std::swap_ranges(__first, __middle, __middle);
 	return;
       }
 
@@ -1596,7 +1595,7 @@
       __glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator,
 		typename iterator_traits<_ForwardIterator>::value_type>)
 
-      return copy(__first, __middle, copy(__middle, __last, __result));
+      return std::copy(__first, __middle, copy(__middle, __last, __result));
     }
 
 
@@ -1641,7 +1640,7 @@
 
       if (__first == __last) return;
       for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
-	iter_swap(__i, __first + __random_number((__i - __first) + 1));
+	std::iter_swap(__i, __first + __random_number((__i - __first) + 1));
     }
 
   /**
@@ -1668,7 +1667,7 @@
 
       if (__first == __last) return;
       for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
-	iter_swap(__i, __first + __rand((__i - __first) + 1));
+	std::iter_swap(__i, __first + __rand((__i - __first) + 1));
     }
 
 
@@ -1692,7 +1691,7 @@
 
       while (++__next != __last)
 	if (__pred(*__next)) {
-	  swap(*__first, *__next);
+	  std::swap(*__first, *__next);
 	  ++__first;
 	}
 
@@ -1726,7 +1725,7 @@
 	    --__last;
 	  else
 	    break;
-	iter_swap(__first, __last);
+	std::iter_swap(__first, __last);
 	++__first;
       }
     }
@@ -1772,15 +1771,15 @@
       if (__len == 1)
 	return __pred(*__first) ? __last : __first;
       _ForwardIterator __middle = __first;
-      advance(__middle, __len / 2);
+      std::advance(__middle, __len / 2);
       _ForwardIterator __begin = __inplace_stable_partition(__first, __middle,
 							__pred,
 							__len / 2);
       _ForwardIterator __end = __inplace_stable_partition(__middle, __last,
 						      __pred,
 						      __len - __len / 2);
-      rotate(__begin, __middle, __end);
-      advance(__begin, std::distance(__middle, __end));
+      std::rotate(__begin, __middle, __end);
+      std::advance(__begin, std::distance(__middle, __end));
       return __begin;
     }
 
@@ -1809,12 +1808,12 @@
 	    *__result2 = *__first;
 	    ++__result2;
 	  }
-	copy(__buffer, __result2, __result1);
+	std::copy(__buffer, __result2, __result1);
 	return __result1;
       }
       else {
 	_ForwardIterator __middle = __first;
-	advance(__middle, __len / 2);
+	std::advance(__middle, __len / 2);
 	_ForwardIterator __begin = __stable_partition_adaptive(__first, __middle,
 							   __pred,
 							   __len / 2,
@@ -1823,8 +1822,8 @@
 							  __pred,
 							  __len - __len / 2,
 							  __buffer, __buffer_size);
-	rotate(__begin, __middle, __end);
-	advance(__begin, std::distance(__middle, __end));
+	std::rotate(__begin, __middle, __end);
+	std::advance(__begin, std::distance(__middle, __end));
 	return __begin;
       }
     }
@@ -1891,7 +1890,7 @@
 	  --__last;
 	if (!(__first < __last))
 	  return __first;
-	iter_swap(__first, __last);
+	std::iter_swap(__first, __last);
 	++__first;
       }
     }
@@ -1914,7 +1913,7 @@
 	  --__last;
 	if (!(__first < __last))
 	  return __first;
-	iter_swap(__first, __last);
+	std::iter_swap(__first, __last);
 	++__first;
       }
     }
@@ -1981,7 +1980,7 @@
       {
 	typename iterator_traits<_RandomAccessIterator>::value_type __val = *__i;
 	if (__val < *__first) {
-	  copy_backward(__first, __i, __i + 1);
+	  std::copy_backward(__first, __i, __i + 1);
 	  *__first = __val;
 	}
 	else
@@ -2005,7 +2004,7 @@
       {
 	typename iterator_traits<_RandomAccessIterator>::value_type __val = *__i;
 	if (__comp(__val, *__first)) {
-	  copy_backward(__first, __i, __i + 1);
+	  std::copy_backward(__first, __i, __i + 1);
 	  *__first = __val;
 	}
 	else
@@ -2093,6 +2092,19 @@
       return __k;
     }
 
+  template<typename _RandomAccessIterator>
+    void
+    partial_sort(_RandomAccessIterator,
+		 _RandomAccessIterator,
+		 _RandomAccessIterator);
+
+  template<typename _RandomAccessIterator, typename _Compare>
+    void
+    partial_sort(_RandomAccessIterator,
+		 _RandomAccessIterator,
+		 _RandomAccessIterator,
+		 _Compare);
+
   /**
    *  @if maint
    *  This is a helper function for the sort routine.
@@ -2107,7 +2119,7 @@
 
       while (__last - __first > _S_threshold) {
 	if (__depth_limit == 0) {
-	  partial_sort(__first, __last, __last);
+	  std::partial_sort(__first, __last, __last);
 	  return;
 	}
 	--__depth_limit;
@@ -2135,7 +2147,7 @@
 
       while (__last - __first > _S_threshold) {
 	if (__depth_limit == 0) {
-	  partial_sort(__first, __last, __last, __comp);
+	  std::partial_sort(__first, __last, __last, __comp);
 	  return;
 	}
 	--__depth_limit;
@@ -2256,6 +2268,20 @@
 			     __comp);
     }
 
+
+  template<typename _InputIterator1, typename _InputIterator2, typename _OutputIterator>
+    _OutputIterator
+    merge(_InputIterator1, _InputIterator1,
+	  _InputIterator2, _InputIterator2,
+	  _OutputIterator);
+
+  template<typename _InputIterator1, typename _InputIterator2, typename _OutputIterator,
+	   typename _Compare>
+    _OutputIterator
+    merge(_InputIterator1, _InputIterator1,
+	  _InputIterator2, _InputIterator2,
+	  _OutputIterator, _Compare);
+
   template<typename _RandomAccessIterator1, typename _RandomAccessIterator2,
 	   typename _Distance>
     void
@@ -2265,15 +2291,15 @@
       _Distance __two_step = 2 * __step_size;
 
       while (__last - __first >= __two_step) {
-	__result = merge(__first, __first + __step_size,
-			 __first + __step_size, __first + __two_step,
-			 __result);
+	__result = std::merge(__first, __first + __step_size,
+			      __first + __step_size, __first + __two_step,
+			      __result);
 	__first += __two_step;
       }
 
       __step_size = std::min(_Distance(__last - __first), __step_size);
-      merge(__first, __first + __step_size, __first + __step_size, __last,
-	    __result);
+      std::merge(__first, __first + __step_size, __first + __step_size, __last,
+		 __result);
     }
 
   template<typename _RandomAccessIterator1, typename _RandomAccessIterator2,
@@ -2286,18 +2312,18 @@
       _Distance __two_step = 2 * __step_size;
 
       while (__last - __first >= __two_step) {
-	__result = merge(__first, __first + __step_size,
-			 __first + __step_size, __first + __two_step,
-			 __result,
-			 __comp);
+	__result = std::merge(__first, __first + __step_size,
+			      __first + __step_size, __first + __two_step,
+			      __result,
+			      __comp);
 	__first += __two_step;
       }
       __step_size = std::min(_Distance(__last - __first), __step_size);
 
-      merge(__first, __first + __step_size,
-	    __first + __step_size, __last,
-	    __result,
-	    __comp);
+      std::merge(__first, __first + __step_size,
+		 __first + __step_size, __last,
+		 __result,
+		 __comp);
     }
 
   enum { _S_chunk_size = 7 };
@@ -2512,11 +2538,11 @@
 	    _RandomAccessIterator>)
       __glibcpp_function_requires(_LessThanComparableConcept<_ValueType>)
 
-      make_heap(__first, __middle);
+      std::make_heap(__first, __middle);
       for (_RandomAccessIterator __i = __middle; __i < __last; ++__i)
 	if (*__i < *__first)
 	  __pop_heap(__first, __middle, __i, _ValueType(*__i));
-      sort_heap(__first, __middle);
+      std::sort_heap(__first, __middle);
     }
 
   /**
@@ -2552,11 +2578,11 @@
       __glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
 							  _ValueType, _ValueType>)
 
-      make_heap(__first, __middle, __comp);
+      std::make_heap(__first, __middle, __comp);
       for (_RandomAccessIterator __i = __middle; __i < __last; ++__i)
 	if (__comp(*__i, *__first))
 	  __pop_heap(__first, __middle, __i, _ValueType(*__i), __comp);
-      sort_heap(__first, __middle, __comp);
+      std::sort_heap(__first, __middle, __comp);
     }
 
   /**
@@ -2599,7 +2625,7 @@
 	++__result_real_last;
 	++__first;
       }
-      make_heap(__result_first, __result_real_last);
+      std::make_heap(__result_first, __result_real_last);
       while (__first != __last) {
 	if (*__first < *__result_first)
 	  __adjust_heap(__result_first, _DistanceType(0),
@@ -2607,7 +2633,7 @@
 			_InputValueType(*__first));
 	++__first;
       }
-      sort_heap(__result_first, __result_real_last);
+      std::sort_heap(__result_first, __result_real_last);
       return __result_real_last;
     }
 
@@ -2655,7 +2681,7 @@
 	++__result_real_last;
 	++__first;
       }
-      make_heap(__result_first, __result_real_last, __comp);
+      std::make_heap(__result_first, __result_real_last, __comp);
       while (__first != __last) {
 	if (__comp(*__first, *__result_first))
 	  __adjust_heap(__result_first, _DistanceType(0),
@@ -2664,7 +2690,7 @@
 			__comp);
 	++__first;
       }
-      sort_heap(__result_first, __result_real_last, __comp);
+      std::sort_heap(__result_first, __result_real_last, __comp);
       return __result_real_last;
     }
 
@@ -2789,7 +2815,7 @@
       while (__len > 0) {
 	__half = __len >> 1;
 	__middle = __first;
-	advance(__middle, __half);
+	std::advance(__middle, __half);
 	if (*__middle < __val) {
 	  __first = __middle;
 	  ++__first;
@@ -2834,7 +2860,7 @@
       while (__len > 0) {
 	__half = __len >> 1;
 	__middle = __first;
-	advance(__middle, __half);
+	std::advance(__middle, __half);
 	if (__comp(*__middle, __val)) {
 	  __first = __middle;
 	  ++__first;
@@ -2876,7 +2902,7 @@
       while (__len > 0) {
 	__half = __len >> 1;
 	__middle = __first;
-	advance(__middle, __half);
+	std::advance(__middle, __half);
 	if (__val < *__middle)
 	  __len = __half;
 	else {
@@ -2921,7 +2947,7 @@
       while (__len > 0) {
 	__half = __len >> 1;
 	__middle = __first;
-	advance(__middle, __half);
+	std::advance(__middle, __half);
 	if (__comp(__val, *__middle))
 	  __len = __half;
 	else {
@@ -2969,7 +2995,7 @@
       while (__len > 0) {
 	__half = __len >> 1;
 	__middle = __first;
-	advance(__middle, __half);
+	std::advance(__middle, __half);
 	if (*__middle < __val) {
 	  __first = __middle;
 	  ++__first;
@@ -2978,13 +3004,13 @@
 	else if (__val < *__middle)
 	  __len = __half;
 	else {
-	  __left = lower_bound(__first, __middle, __val);
-	  advance(__first, __len);
-	  __right = upper_bound(++__middle, __first, __val);
-	  return pair<_ForwardIterator, _ForwardIterator>(__left, __right);
+	  __left = std::lower_bound(__first, __middle, __val);
+	  std::advance(__first, __len);
+	  __right = std::upper_bound(++__middle, __first, __val);
+	  return std::pair<_ForwardIterator, _ForwardIterator>(__left, __right);
 	}
       }
-      return pair<_ForwardIterator, _ForwardIterator>(__first, __first);
+      return std::pair<_ForwardIterator, _ForwardIterator>(__first, __first);
     }
 
   /**
@@ -3024,7 +3050,7 @@
       while (__len > 0) {
 	__half = __len >> 1;
 	__middle = __first;
-	advance(__middle, __half);
+	std::advance(__middle, __half);
 	if (__comp(*__middle, __val)) {
 	  __first = __middle;
 	  ++__first;
@@ -3033,13 +3059,13 @@
 	else if (__comp(__val, *__middle))
 	  __len = __half;
 	else {
-	  __left = lower_bound(__first, __middle, __val, __comp);
-	  advance(__first, __len);
-	  __right = upper_bound(++__middle, __first, __val, __comp);
-	  return pair<_ForwardIterator, _ForwardIterator>(__left, __right);
+	  __left = std::lower_bound(__first, __middle, __val, __comp);
+	  std::advance(__first, __len);
+	  __right = std::upper_bound(++__middle, __first, __val, __comp);
+	  return std::pair<_ForwardIterator, _ForwardIterator>(__left, __right);
 	}
       }
-      return pair<_ForwardIterator, _ForwardIterator>(__first, __first);
+      return std::pair<_ForwardIterator, _ForwardIterator>(__first, __first);
     }
 
   /**
@@ -3065,7 +3091,7 @@
 		typename iterator_traits<_ForwardIterator>::value_type>)
       __glibcpp_function_requires(_LessThanComparableConcept<_Tp>)
 
-      _ForwardIterator __i = lower_bound(__first, __last, __val);
+      _ForwardIterator __i = std::lower_bound(__first, __last, __val);
       return __i != __last && !(__val < *__i);
     }
 
@@ -3096,7 +3122,7 @@
       __glibcpp_function_requires(_BinaryPredicateConcept<_Compare, _Tp,
 		typename iterator_traits<_ForwardIterator>::value_type>)
 
-      _ForwardIterator __i = lower_bound(__first, __last, __val, __comp);
+      _ForwardIterator __i = std::lower_bound(__first, __last, __val, __comp);
       return __i != __last && !__comp(__val, *__i);
     }
 
@@ -3144,7 +3170,7 @@
 	}
 	++__result;
       }
-      return copy(__first2, __last2, copy(__first1, __last1, __result));
+      return std::copy(__first2, __last2, std::copy(__first1, __last1, __result));
     }
 
   /**
@@ -3197,7 +3223,7 @@
 	}
 	++__result;
       }
-      return copy(__first2, __last2, copy(__first1, __last1, __result));
+      return std::copy(__first2, __last2, std::copy(__first1, __last1, __result));
     }
 
   /**
@@ -3216,7 +3242,7 @@
 	return;
       if (__len1 + __len2 == 2) {
 	if (*__middle < *__first)
-	      iter_swap(__first, __middle);
+	  std::iter_swap(__first, __middle);
 	return;
       }
       _BidirectionalIterator __first_cut = __first;
@@ -3225,19 +3251,19 @@
       _Distance __len22 = 0;
       if (__len1 > __len2) {
 	__len11 = __len1 / 2;
-	advance(__first_cut, __len11);
-	__second_cut = lower_bound(__middle, __last, *__first_cut);
+	std::advance(__first_cut, __len11);
+	__second_cut = std::lower_bound(__middle, __last, *__first_cut);
 	__len22 = std::distance(__middle, __second_cut);
       }
       else {
 	__len22 = __len2 / 2;
-	advance(__second_cut, __len22);
-	__first_cut = upper_bound(__first, __middle, *__second_cut);
+	std::advance(__second_cut, __len22);
+	__first_cut = std::upper_bound(__first, __middle, *__second_cut);
 	__len11 = std::distance(__first, __first_cut);
       }
-      rotate(__first_cut, __middle, __second_cut);
+      std::rotate(__first_cut, __middle, __second_cut);
       _BidirectionalIterator __new_middle = __first_cut;
-      advance(__new_middle, std::distance(__middle, __second_cut));
+      std::advance(__new_middle, std::distance(__middle, __second_cut));
       __merge_without_buffer(__first, __first_cut, __new_middle,
 			     __len11, __len22);
       __merge_without_buffer(__new_middle, __second_cut, __last,
@@ -3261,7 +3287,7 @@
 	return;
       if (__len1 + __len2 == 2) {
 	if (__comp(*__middle, *__first))
-	      iter_swap(__first, __middle);
+	  std::iter_swap(__first, __middle);
 	return;
       }
       _BidirectionalIterator __first_cut = __first;
@@ -3270,8 +3296,8 @@
       _Distance __len22 = 0;
       if (__len1 > __len2) {
 	__len11 = __len1 / 2;
-	advance(__first_cut, __len11);
-	__second_cut = lower_bound(__middle, __last, *__first_cut, __comp);
+	std::advance(__first_cut, __len11);
+	__second_cut = std::lower_bound(__middle, __last, *__first_cut, __comp);
 	__len22 = std::distance(__middle, __second_cut);
       }
       else {
@@ -3280,9 +3306,9 @@
 	__first_cut = upper_bound(__first, __middle, *__second_cut, __comp);
 	__len11 = std::distance(__first, __first_cut);
       }
-      rotate(__first_cut, __middle, __second_cut);
+      std::rotate(__first_cut, __middle, __second_cut);
       _BidirectionalIterator __new_middle = __first_cut;
-      advance(__new_middle, std::distance(__middle, __second_cut));
+      std::advance(__new_middle, std::distance(__middle, __second_cut));
       __merge_without_buffer(__first, __first_cut, __new_middle,
 			     __len11, __len22, __comp);
       __merge_without_buffer(__new_middle, __second_cut, __last,
@@ -3306,18 +3332,18 @@
     {
       _BidirectionalIterator2 __buffer_end;
       if (__len1 > __len2 && __len2 <= __buffer_size) {
-	__buffer_end = copy(__middle, __last, __buffer);
-	copy_backward(__first, __middle, __last);
-	return copy(__buffer, __buffer_end, __first);
+	__buffer_end = std::copy(__middle, __last, __buffer);
+	std::copy_backward(__first, __middle, __last);
+	return std::copy(__buffer, __buffer_end, __first);
       }
       else if (__len1 <= __buffer_size) {
-	__buffer_end = copy(__first, __middle, __buffer);
-	copy(__middle, __last, __first);
-	return copy_backward(__buffer, __buffer_end, __last);
+	__buffer_end = std::copy(__first, __middle, __buffer);
+	std::copy(__middle, __last, __first);
+	return std::copy_backward(__buffer, __buffer_end, __last);
       }
       else {
-	rotate(__first, __middle, __last);
-	advance(__first, std::distance(__middle, __last));
+	std::rotate(__first, __middle, __last);
+	std::advance(__first, std::distance(__middle, __last));
 	return __first;
       }
     }
@@ -3335,22 +3361,22 @@
 		     _BidirectionalIterator3 __result)
     {
       if (__first1 == __last1)
-	return copy_backward(__first2, __last2, __result);
+	return std::copy_backward(__first2, __last2, __result);
       if (__first2 == __last2)
-	return copy_backward(__first1, __last1, __result);
+	return std::copy_backward(__first1, __last1, __result);
       --__last1;
       --__last2;
       while (true) {
 	if (*__last2 < *__last1) {
 	  *--__result = *__last1;
 	  if (__first1 == __last1)
-	    return copy_backward(__first2, ++__last2, __result);
+	    return std::copy_backward(__first2, ++__last2, __result);
 	  --__last1;
 	}
 	else {
 	  *--__result = *__last2;
 	  if (__first2 == __last2)
-	    return copy_backward(__first1, ++__last1, __result);
+	    return std::copy_backward(__first1, ++__last1, __result);
 	  --__last2;
 	}
       }
@@ -3370,22 +3396,22 @@
 		     _Compare __comp)
     {
       if (__first1 == __last1)
-	return copy_backward(__first2, __last2, __result);
+	return std::copy_backward(__first2, __last2, __result);
       if (__first2 == __last2)
-	return copy_backward(__first1, __last1, __result);
+	return std::copy_backward(__first1, __last1, __result);
       --__last1;
       --__last2;
       while (true) {
 	if (__comp(*__last2, *__last1)) {
 	  *--__result = *__last1;
 	  if (__first1 == __last1)
-	    return copy_backward(__first2, ++__last2, __result);
+	    return std::copy_backward(__first2, ++__last2, __result);
 	  --__last1;
 	}
 	else {
 	  *--__result = *__last2;
 	  if (__first2 == __last2)
-	    return copy_backward(__first1, ++__last1, __result);
+	    return std::copy_backward(__first1, ++__last1, __result);
 	  --__last2;
 	}
       }
@@ -3405,11 +3431,11 @@
 		     _Pointer __buffer, _Distance __buffer_size)
     {
 	  if (__len1 <= __len2 && __len1 <= __buffer_size) {
-	    _Pointer __buffer_end = copy(__first, __middle, __buffer);
-	    merge(__buffer, __buffer_end, __middle, __last, __first);
+	    _Pointer __buffer_end = std::copy(__first, __middle, __buffer);
+	    std::merge(__buffer, __buffer_end, __middle, __last, __first);
 	  }
 	  else if (__len2 <= __buffer_size) {
-	    _Pointer __buffer_end = copy(__middle, __last, __buffer);
+	    _Pointer __buffer_end = std::copy(__middle, __last, __buffer);
 	    __merge_backward(__first, __middle, __buffer, __buffer_end, __last);
 	  }
 	  else {
@@ -3419,14 +3445,14 @@
 	    _Distance __len22 = 0;
 	    if (__len1 > __len2) {
 		  __len11 = __len1 / 2;
-		  advance(__first_cut, __len11);
-		  __second_cut = lower_bound(__middle, __last, *__first_cut);
+		  std::advance(__first_cut, __len11);
+		  __second_cut = std::lower_bound(__middle, __last, *__first_cut);
 		  __len22 = std::distance(__middle, __second_cut);
 	    }
 	    else {
 		  __len22 = __len2 / 2;
-		  advance(__second_cut, __len22);
-		  __first_cut = upper_bound(__first, __middle, *__second_cut);
+		  std::advance(__second_cut, __len22);
+		  __first_cut = std::upper_bound(__first, __middle, *__second_cut);
 		  __len11 = std::distance(__first, __first_cut);
 	    }
 	    _BidirectionalIterator __new_middle =
@@ -3456,11 +3482,11 @@
 		     _Compare __comp)
     {
 	  if (__len1 <= __len2 && __len1 <= __buffer_size) {
-	    _Pointer __buffer_end = copy(__first, __middle, __buffer);
-	    merge(__buffer, __buffer_end, __middle, __last, __first, __comp);
+	    _Pointer __buffer_end = std::copy(__first, __middle, __buffer);
+	    std::merge(__buffer, __buffer_end, __middle, __last, __first, __comp);
 	  }
 	  else if (__len2 <= __buffer_size) {
-	    _Pointer __buffer_end = copy(__middle, __last, __buffer);
+	    _Pointer __buffer_end = std::copy(__middle, __last, __buffer);
 	    __merge_backward(__first, __middle, __buffer, __buffer_end, __last,
 					     __comp);
 	  }
@@ -3471,14 +3497,14 @@
 	    _Distance __len22 = 0;
 	    if (__len1 > __len2) {
 		  __len11 = __len1 / 2;
-		  advance(__first_cut, __len11);
-		  __second_cut = lower_bound(__middle, __last, *__first_cut, __comp);
+		  std::advance(__first_cut, __len11);
+		  __second_cut = std::lower_bound(__middle, __last, *__first_cut, __comp);
 		  __len22 = std::distance(__middle, __second_cut);
 	    }
 	    else {
 		  __len22 = __len2 / 2;
-		  advance(__second_cut, __len22);
-		  __first_cut = upper_bound(__first, __middle, *__second_cut, __comp);
+		  std::advance(__second_cut, __len22);
+		  __first_cut = std::upper_bound(__first, __middle, *__second_cut, __comp);
 		  __len11 = std::distance(__first, __first_cut);
 	    }
 	    _BidirectionalIterator __new_middle =
@@ -3682,7 +3708,7 @@
 	}
 	++__result;
       }
-      return copy(__first2, __last2, copy(__first1, __last1, __result));
+      return std::copy(__first2, __last2, std::copy(__first1, __last1, __result));
     }
 
   template<typename _InputIterator1, typename _InputIterator2, typename _OutputIterator,
@@ -3720,7 +3746,7 @@
 	}
 	++__result;
       }
-      return copy(__first2, __last2, copy(__first1, __last1, __result));
+      return std::copy(__first2, __last2, std::copy(__first1, __last1, __result));
     }
 
   template<typename _InputIterator1, typename _InputIterator2, typename _OutputIterator>
@@ -3816,7 +3842,7 @@
 	  ++__first1;
 	  ++__first2;
 	}
-      return copy(__first1, __last1, __result);
+      return std::copy(__first1, __last1, __result);
     }
 
   template<typename _InputIterator1, typename _InputIterator2, typename _OutputIterator,
@@ -3850,7 +3876,7 @@
 	  ++__first1;
 	  ++__first2;
 	}
-      return copy(__first1, __last1, __result);
+      return std::copy(__first1, __last1, __result);
     }
 
   template<typename _InputIterator1, typename _InputIterator2, typename _OutputIterator>
@@ -3885,7 +3911,7 @@
 	  ++__first1;
 	  ++__first2;
 	}
-      return copy(__first2, __last2, copy(__first1, __last1, __result));
+      return std::copy(__first2, __last2, std::copy(__first1, __last1, __result));
     }
 
   template<typename _InputIterator1, typename _InputIterator2, typename _OutputIterator,
@@ -3923,7 +3949,7 @@
 	  ++__first1;
 	  ++__first2;
 	}
-      return copy(__first2, __last2, copy(__first1, __last1, __result));
+      return std::copy(__first2, __last2, std::copy(__first1, __last1, __result));
     }
 
   // min_element and max_element, with and without an explicitly supplied
@@ -4028,12 +4054,12 @@
 	  _BidirectionalIterator __j = __last;
 	  while (!(*__i < *--__j))
 	    {}
-	  iter_swap(__i, __j);
-	  reverse(__ii, __last);
+	  std::iter_swap(__i, __j);
+	  std::reverse(__ii, __last);
 	  return true;
 	}
 	if (__i == __first) {
-	  reverse(__first, __last);
+	  std::reverse(__first, __last);
 	  return false;
 	}
       }
@@ -4066,12 +4092,12 @@
 	  _BidirectionalIterator __j = __last;
 	  while (!__comp(*__i, *--__j))
 	    {}
-	  iter_swap(__i, __j);
-	  reverse(__ii, __last);
+	  std::iter_swap(__i, __j);
+	  std::reverse(__ii, __last);
 	  return true;
 	}
 	if (__i == __first) {
-	  reverse(__first, __last);
+	  std::reverse(__first, __last);
 	  return false;
 	}
       }
@@ -4102,12 +4128,12 @@
 	  _BidirectionalIterator __j = __last;
 	  while (!(*--__j < *__i))
 	    {}
-	  iter_swap(__i, __j);
-	  reverse(__ii, __last);
+	  std::iter_swap(__i, __j);
+	  std::reverse(__ii, __last);
 	  return true;
 	}
 	if (__i == __first) {
-	  reverse(__first, __last);
+	  std::reverse(__first, __last);
 	  return false;
 	}
       }
@@ -4140,12 +4166,12 @@
 	  _BidirectionalIterator __j = __last;
 	  while (!__comp(*--__j, *__i))
 	    {}
-	  iter_swap(__i, __j);
-	  reverse(__ii, __last);
+	  std::iter_swap(__i, __j);
+	  std::reverse(__ii, __last);
 	  return true;
 	}
 	if (__i == __first) {
-	  reverse(__first, __last);
+	  std::reverse(__first, __last);
 	  return false;
 	}
       }
@@ -4214,7 +4240,7 @@
 	_ForwardIterator1 __result = __last1;
 	while (1) {
 	  _ForwardIterator1 __new_result
-	    = search(__first1, __last1, __first2, __last2);
+	    = std::search(__first1, __last1, __first2, __last2);
 	  if (__new_result == __last1)
 	    return __result;
 	  else {
@@ -4240,7 +4266,7 @@
 	_ForwardIterator1 __result = __last1;
 	while (1) {
 	  _ForwardIterator1 __new_result
-	    = search(__first1, __last1, __first2, __last2, __comp);
+	    = std::search(__first1, __last1, __first2, __last2, __comp);
 	  if (__new_result == __last1)
 	    return __result;
 	  else {
@@ -4268,14 +4294,14 @@
 
       _RevIterator1 __rlast1(__first1);
       _RevIterator2 __rlast2(__first2);
-      _RevIterator1 __rresult = search(_RevIterator1(__last1), __rlast1,
-				   _RevIterator2(__last2), __rlast2);
+      _RevIterator1 __rresult = std::search(_RevIterator1(__last1), __rlast1,
+					    _RevIterator2(__last2), __rlast2);
 
       if (__rresult == __rlast1)
 	return __last1;
       else {
 	_BidirectionalIterator1 __result = __rresult.base();
-	advance(__result, -std::distance(__first2, __last2));
+	std::advance(__result, -std::distance(__first2, __last2));
 	return __result;
       }
     }
@@ -4297,15 +4323,15 @@
 
       _RevIterator1 __rlast1(__first1);
       _RevIterator2 __rlast2(__first2);
-      _RevIterator1 __rresult = search(_RevIterator1(__last1), __rlast1,
-				   _RevIterator2(__last2), __rlast2,
-				   __comp);
+      _RevIterator1 __rresult = std::search(_RevIterator1(__last1), __rlast1,
+					    _RevIterator2(__last2), __rlast2,
+					    __comp);
 
       if (__rresult == __rlast1)
 	return __last1;
       else {
 	_BidirectionalIterator1 __result = __rresult.base();
-	advance(__result, -std::distance(__first2, __last2));
+	std::advance(__result, -std::distance(__first2, __last2));
 	return __result;
       }
     }

Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]