aboutsummaryrefslogtreecommitdiff
path: root/libstdc++/stl/algobase.h
diff options
context:
space:
mode:
Diffstat (limited to 'libstdc++/stl/algobase.h')
-rw-r--r--libstdc++/stl/algobase.h841
1 files changed, 841 insertions, 0 deletions
diff --git a/libstdc++/stl/algobase.h b/libstdc++/stl/algobase.h
new file mode 100644
index 00000000000..0a17f48b2e7
--- /dev/null
+++ b/libstdc++/stl/algobase.h
@@ -0,0 +1,841 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation. Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose. It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation. Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose. It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef _SGI_STL_ALGOBASE_H
+#define _SGI_STL_ALGOBASE_H
+
+#include <string.h>
+#include <limits.h>
+#include <function.h>
+#include <pair.h>
+#include <iterator.h>
+#include <new.h>
+#include <type_traits.h>
+
+template <class ForwardIterator1, class ForwardIterator2, class T>
+inline void __iter_swap(ForwardIterator1 a, ForwardIterator2 b, T*) {
+ T tmp = *a;
+ *a = *b;
+ *b = tmp;
+}
+
+template <class ForwardIterator1, class ForwardIterator2>
+inline void iter_swap(ForwardIterator1 a, ForwardIterator2 b) {
+ __iter_swap(a, b, value_type(a));
+}
+
+template <class T>
+inline void swap(T& a, T& b) {
+ T tmp = a;
+ a = b;
+ b = tmp;
+}
+
+#ifdef __BORLANDC__
+#include <stdlib.h>
+#else
+
+template <class T>
+inline const T& min(const T& a, const T& b) {
+ return b < a ? b : a;
+}
+
+template <class T>
+inline const T& max(const T& a, const T& b) {
+ return a < b ? b : a;
+}
+
+#endif
+
+template <class T, class Compare>
+inline const T& min(const T& a, const T& b, Compare comp) {
+ return comp(b, a) ? b : a;
+}
+
+template <class T, class Compare>
+inline const T& max(const T& a, const T& b, Compare comp) {
+ return comp(a, b) ? b : a;
+}
+
+template <class InputIterator, class Distance>
+inline void __distance(InputIterator first, InputIterator last, Distance& n,
+ input_iterator_tag) {
+ while (first != last) { ++first; ++n; }
+}
+
+template <class ForwardIterator, class Distance>
+inline void __distance(ForwardIterator first, ForwardIterator last,
+ Distance& n,
+ forward_iterator_tag) {
+ while (first != last) { ++first; ++n; }
+}
+
+template <class BidirectionalIterator, class Distance>
+inline void __distance(BidirectionalIterator first, BidirectionalIterator last,
+ Distance& n, bidirectional_iterator_tag) {
+ while (first != last) { ++first; ++n; }
+}
+
+template <class RandomAccessIterator, class Distance>
+inline void __distance(RandomAccessIterator first, RandomAccessIterator last,
+ Distance& n, random_access_iterator_tag) {
+ n += last - first;
+}
+
+template <class InputIterator, class Distance>
+inline void distance(InputIterator first, InputIterator last, Distance& n) {
+ __distance(first, last, n, iterator_category(first));
+}
+
+#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
+
+template <class InputIterator>
+inline iterator_traits<InputIterator>::difference_type
+__distance(InputIterator first, InputIterator last, input_iterator_tag) {
+ iterator_traits<InputIterator>::difference_type n = 0;
+ while (first != last) {
+ ++first; ++n;
+ }
+ return n;
+}
+
+template <class ForwardIterator>
+inline iterator_traits<ForwardIterator>::difference_type
+__distance(ForwardIterator first, ForwardIterator last, forward_iterator_tag) {
+ return __distance(first, last, input_iterator_tag());
+}
+
+template <class BidirectionalIterator>
+inline iterator_traits<BidirectionalIterator>::difference_type
+__distance(BidirectionalIterator first, BidirectionalIterator last,
+ bidirectional_iterator_tag) {
+ return __distance(first, last, input_iterator_tag());
+}
+
+template <class RandomAccessIterator>
+inline iterator_traits<RandomAccessIterator>::difference_type
+__distance(RandomAccessIterator first, RandomAccessIterator last,
+ random_access_iterator_tag) {
+ return last - first;
+}
+
+template <class InputIterator>
+inline iterator_traits<InputIterator>::difference_type
+distance(InputIterator first, InputIterator last) {
+ return __distance(first, last,
+ iterator_traits<InputIterator>::iterator_category());
+}
+
+#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
+
+template <class InputIterator, class Distance>
+inline void __advance(InputIterator& i, Distance n, input_iterator_tag) {
+ while (n--) ++i;
+}
+
+template <class ForwardIterator, class Distance>
+inline void __advance(ForwardIterator& i, Distance n, forward_iterator_tag) {
+ while (n--) ++i;
+}
+
+#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
+#pragma set woff 1183
+#endif
+
+template <class BidirectionalIterator, class Distance>
+inline void __advance(BidirectionalIterator& i, Distance n,
+ bidirectional_iterator_tag) {
+ if (n >= 0)
+ while (n--) ++i;
+ else
+ while (n++) --i;
+}
+
+#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
+#pragma reset woff 1183
+#endif
+
+template <class RandomAccessIterator, class Distance>
+inline void __advance(RandomAccessIterator& i, Distance n,
+ random_access_iterator_tag) {
+ i += n;
+}
+
+template <class InputIterator, class Distance>
+inline void advance(InputIterator& i, Distance n) {
+ __advance(i, n, iterator_category(i));
+}
+
+template <class InputIterator, class OutputIterator>
+inline OutputIterator __copy(InputIterator first, InputIterator last,
+ OutputIterator result, input_iterator_tag)
+{
+ for ( ; first != last; ++result, ++first)
+ *result = *first;
+ return result;
+}
+
+template <class InputIterator, class OutputIterator>
+inline OutputIterator __copy(InputIterator first, InputIterator last,
+ OutputIterator result, forward_iterator_tag)
+{
+ return __copy(first, last, result, input_iterator_tag());
+}
+
+template <class InputIterator, class OutputIterator>
+inline OutputIterator __copy(InputIterator first, InputIterator last,
+ OutputIterator result, bidirectional_iterator_tag)
+{
+ return __copy(first, last, result, input_iterator_tag());
+}
+
+template <class RandomAccessIterator, class OutputIterator, class Distance>
+inline OutputIterator
+__copy_d(RandomAccessIterator first, RandomAccessIterator last,
+ OutputIterator result, Distance*)
+{
+ for (Distance n = last - first; n > 0; --n, ++result, ++first)
+ *result = *first;
+ return result;
+}
+
+template <class RandomAccessIterator, class OutputIterator>
+inline OutputIterator
+__copy(RandomAccessIterator first, RandomAccessIterator last,
+ OutputIterator result, random_access_iterator_tag)
+{
+ return __copy_d(first, last, result, distance_type(first));
+}
+
+template <class InputIterator, class OutputIterator>
+struct __copy_dispatch
+{
+ OutputIterator operator()(InputIterator first, InputIterator last,
+ OutputIterator result) {
+ return __copy(first, last, result, iterator_category(first));
+ }
+};
+
+#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
+
+template <class T>
+inline T* __copy_t(const T* first, const T* last, T* result, __true_type) {
+ memmove(result, first, sizeof(T) * (last - first));
+ return result + (last - first);
+}
+
+template <class T>
+inline T* __copy_t(const T* first, const T* last, T* result, __false_type) {
+ return __copy_d(first, last, result, (ptrdiff_t*) 0);
+}
+
+template <class T>
+struct __copy_dispatch<T*, T*>
+{
+ T* operator()(T* first, T* last, T* result) {
+ return __copy_t(first, last, result,
+ __type_traits<T>::has_trivial_assignment_operator());
+ }
+};
+
+template <class T>
+struct __copy_dispatch<const T*, T*>
+{
+ T* operator()(const T* first, const T* last, T* result) {
+ return __copy_t(first, last, result,
+ __type_traits<T>::has_trivial_assignment_operator());
+ }
+};
+
+#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
+
+template <class InputIterator, class OutputIterator>
+inline OutputIterator copy(InputIterator first, InputIterator last,
+ OutputIterator result)
+{
+ return __copy_dispatch<InputIterator,OutputIterator>()(first, last, result);
+}
+
+inline char* copy(const char* first, const char* last, char* result) {
+ memmove(result, first, last - first);
+ return result + (last - first);
+}
+
+inline wchar_t* copy(const wchar_t* first, const wchar_t* last,
+ wchar_t* result) {
+ memmove(result, first, sizeof(wchar_t) * (last - first));
+ return result + (last - first);
+}
+
+template <class BidirectionalIterator1, class BidirectionalIterator2>
+inline BidirectionalIterator2 __copy_backward(BidirectionalIterator1 first,
+ BidirectionalIterator1 last,
+ BidirectionalIterator2 result) {
+ while (first != last) *--result = *--last;
+ return result;
+}
+
+
+template <class BidirectionalIterator1, class BidirectionalIterator2>
+struct __copy_backward_dispatch
+{
+ BidirectionalIterator2 operator()(BidirectionalIterator1 first,
+ BidirectionalIterator1 last,
+ BidirectionalIterator2 result) {
+ return __copy_backward(first, last, result);
+ }
+};
+
+#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
+
+template <class T>
+inline T* __copy_backward_t(const T* first, const T* last, T* result,
+ __true_type) {
+ const ptrdiff_t N = last - first;
+ memmove(result - N, first, sizeof(T) * N);
+ return result - N;
+}
+
+template <class T>
+inline T* __copy_backward_t(const T* first, const T* last, T* result,
+ __false_type) {
+ return __copy_backward(first, last, result);
+}
+
+template <class T>
+struct __copy_backward_dispatch<T*, T*>
+{
+ T* operator()(T* first, T* last, T* result) {
+ return
+ __copy_backward_t(first, last, result,
+ __type_traits<T>::has_trivial_assignment_operator());
+ }
+};
+
+template <class T>
+struct __copy_backward_dispatch<const T*, T*>
+{
+ T* operator()(const T* first, const T* last, T* result) {
+ return
+ __copy_backward_t(first, last, result,
+ __type_traits<T>::has_trivial_assignment_operator());
+ }
+};
+
+#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
+
+template <class BidirectionalIterator1, class BidirectionalIterator2>
+inline BidirectionalIterator2 copy_backward(BidirectionalIterator1 first,
+ BidirectionalIterator1 last,
+ BidirectionalIterator2 result) {
+ return __copy_backward_dispatch<BidirectionalIterator1,
+ BidirectionalIterator2>()(first, last,
+ result);
+}
+
+template <class InputIterator, class Size, class OutputIterator>
+OutputIterator __copy_n(InputIterator first, Size count,
+ OutputIterator result,
+ input_iterator_tag) {
+ for ( ; count > 0; --count, ++first, ++result)
+ *result = *first;
+ return result;
+}
+
+template <class ForwardIterator, class Size, class OutputIterator>
+inline OutputIterator __copy_n(ForwardIterator first, Size count,
+ OutputIterator result,
+ forward_iterator_tag) {
+ return __copy_n(first, count, result, input_iterator_tag());
+}
+
+template <class BidirectionalIterator, class Size, class OutputIterator>
+inline OutputIterator __copy_n(BidirectionalIterator first, Size count,
+ OutputIterator result,
+ bidirectional_iterator_tag) {
+ return __copy_n(first, count, result, input_iterator_tag());
+}
+
+template <class RandomAccessIterator, class Size, class OutputIterator>
+inline OutputIterator __copy_n(RandomAccessIterator first, Size count,
+ OutputIterator result,
+ random_access_iterator_tag) {
+ return copy(first, first + count, result);
+}
+
+template <class InputIterator, class Size, class OutputIterator>
+inline OutputIterator copy_n(InputIterator first, Size count,
+ OutputIterator result) {
+ return __copy_n(first, count, result, iterator_category(first));
+}
+
+template <class ForwardIterator, class T>
+void fill(ForwardIterator first, ForwardIterator last, const T& value) {
+ for ( ; first != last; ++first)
+ *first = value;
+}
+
+template <class OutputIterator, class Size, class T>
+OutputIterator fill_n(OutputIterator first, Size n, const T& value) {
+ for ( ; n > 0; --n, ++first)
+ *first = value;
+ return first;
+}
+
+template <class InputIterator1, class InputIterator2>
+pair<InputIterator1, InputIterator2> mismatch(InputIterator1 first1,
+ InputIterator1 last1,
+ InputIterator2 first2) {
+ while (first1 != last1 && *first1 == *first2) {
+ ++first1;
+ ++first2;
+ }
+ return pair<InputIterator1, InputIterator2>(first1, first2);
+}
+
+template <class InputIterator1, class InputIterator2, class BinaryPredicate>
+pair<InputIterator1, InputIterator2> mismatch(InputIterator1 first1,
+ InputIterator1 last1,
+ InputIterator2 first2,
+ BinaryPredicate binary_pred) {
+ while (first1 != last1 && binary_pred(*first1, *first2)) {
+ ++first1;
+ ++first2;
+ }
+ return pair<InputIterator1, InputIterator2>(first1, first2);
+}
+
+template <class InputIterator1, class InputIterator2>
+inline bool equal(InputIterator1 first1, InputIterator1 last1,
+ InputIterator2 first2) {
+ for ( ; first1 != last1; ++first1, ++first2)
+ if (*first1 != *first2)
+ return false;
+ return true;
+}
+
+template <class InputIterator1, class InputIterator2, class BinaryPredicate>
+inline bool equal(InputIterator1 first1, InputIterator1 last1,
+ InputIterator2 first2, BinaryPredicate binary_pred) {
+ for ( ; first1 != last1; ++first1, ++first2)
+ if (!binary_pred(*first1, *first2))
+ return false;
+ return true;
+}
+
+template <class InputIterator1, class InputIterator2>
+bool lexicographical_compare(InputIterator1 first1, InputIterator1 last1,
+ InputIterator2 first2, InputIterator2 last2) {
+ for ( ; first1 != last1 && first2 != last2; ++first1, ++first2) {
+ if (*first1 < *first2)
+ return true;
+ if (*first2 < *first1)
+ return false;
+ }
+ return first1 == last1 && first2 != last2;
+}
+
+template <class InputIterator1, class InputIterator2, class Compare>
+bool lexicographical_compare(InputIterator1 first1, InputIterator1 last1,
+ InputIterator2 first2, InputIterator2 last2,
+ Compare comp) {
+ for ( ; first1 != last1 && first2 != last2; ++first1, ++first2) {
+ if (comp(*first1, *first2))
+ return true;
+ if (comp(*first2, *first1))
+ return false;
+ }
+ return first1 == last1 && first2 != last2;
+}
+
+inline bool
+lexicographical_compare(const unsigned char* first1,
+ const unsigned char* last1,
+ const unsigned char* first2,
+ const unsigned char* last2)
+{
+ const size_t len1 = last1 - first1;
+ const size_t len2 = last2 - first2;
+ const int result = memcmp(first1, first2, min(len1, len2));
+ return result != 0 ? result < 0 : len1 < len2;
+}
+
+inline bool lexicographical_compare(const char* first1, const char* last1,
+ const char* first2, const char* last2)
+{
+#if CHAR_MAX == SCHAR_MAX
+ return lexicographical_compare((const signed char*) first1,
+ (const signed char*) last1,
+ (const signed char*) first2,
+ (const signed char*) last2);
+#else
+ return lexicographical_compare((const unsigned char*) first1,
+ (const unsigned char*) last1,
+ (const unsigned char*) first2,
+ (const unsigned char*) last2);
+#endif
+}
+
+template <class InputIterator1, class InputIterator2>
+int lexicographical_compare_3way(InputIterator1 first1, InputIterator1 last1,
+ InputIterator2 first2, InputIterator2 last2)
+{
+ while (first1 != last1 && first2 != last2) {
+ if (*first1 < *first2) return -1;
+ if (*first2 < *first1) return 1;
+ ++first1; ++first2;
+ }
+ if (first2 == last2) {
+ return !(first1 == last1);
+ } else {
+ return -1;
+ }
+}
+
+inline int
+lexicographical_compare_3way(const unsigned char* first1,
+ const unsigned char* last1,
+ const unsigned char* first2,
+ const unsigned char* last2)
+{
+ const int len1 = last1 - first1;
+ const int len2 = last2 - first2;
+ const int result = memcmp(first1, first2, min(len1, len2));
+ return result == 0 ? len1 - len2 : result;
+}
+
+inline int lexicographical_compare_3way(const char* first1, const char* last1,
+ const char* first2, const char* last2)
+{
+#if CHAR_MAX == SCHAR_MAX
+ return lexicographical_compare_3way(
+ (const signed char*) first1,
+ (const signed char*) last1,
+ (const signed char*) first2,
+ (const signed char*) last2);
+#else
+ return lexicographical_compare_3way((const unsigned char*) first1,
+ (const unsigned char*) last1,
+ (const unsigned char*) first2,
+ (const unsigned char*) last2);
+#endif
+}
+
+template <class T>
+inline void destroy(T* pointer) {
+ pointer->~T();
+}
+
+template <class T1, class T2>
+inline void construct(T1* p, const T2& value) {
+ new (p) T1(value);
+}
+
+template <class ForwardIterator>
+inline void
+__destroy_aux(ForwardIterator first, ForwardIterator last, __false_type) {
+ for ( ; first < last; ++first)
+ destroy(&*first);
+}
+
+template <class ForwardIterator>
+inline void __destroy_aux(ForwardIterator, ForwardIterator, __true_type) {
+}
+
+template <class ForwardIterator, class T>
+inline void __destroy(ForwardIterator first, ForwardIterator last, T*) {
+ __destroy_aux(first, last, __type_traits<T>::has_trivial_destructor());
+}
+
+template <class ForwardIterator>
+inline void destroy(ForwardIterator first, ForwardIterator last) {
+ __destroy(first, last, value_type(first));
+}
+
+inline void destroy(char*, char*) {}
+inline void destroy(wchar_t*, wchar_t*) {}
+
+// Valid if copy construction is equivalent to assignment, and if the
+// destructor is trivial.
+template <class InputIterator, class ForwardIterator>
+inline ForwardIterator
+__uninitialized_copy_aux(InputIterator first, InputIterator last,
+ ForwardIterator result,
+ __true_type) {
+ return copy(first, last, result);
+}
+
+template <class InputIterator, class ForwardIterator>
+ForwardIterator
+__uninitialized_copy_aux(InputIterator first, InputIterator last,
+ ForwardIterator result,
+ __false_type) {
+ ForwardIterator cur = result;
+# ifdef __STL_USE_EXCEPTIONS
+ try {
+# endif /* __STL_USE_EXCEPTIONS */
+ for ( ; first != last; ++first, ++cur)
+ construct(&*cur, *first);
+ return cur;
+# ifdef __STL_USE_EXCEPTIONS
+ }
+ catch(...) {
+ destroy(result, cur);
+ throw;
+ }
+# endif /* __STL_USE_EXCEPTIONS */
+}
+
+
+template <class InputIterator, class ForwardIterator, class T>
+inline ForwardIterator
+__uninitialized_copy(InputIterator first, InputIterator last,
+ ForwardIterator result, T*) {
+ return __uninitialized_copy_aux(first, last, result,
+ __type_traits<T>::is_POD_type());
+}
+
+template <class InputIterator, class ForwardIterator>
+inline ForwardIterator
+ uninitialized_copy(InputIterator first, InputIterator last,
+ ForwardIterator result) {
+ return __uninitialized_copy(first, last, result, value_type(result));
+}
+
+inline char* uninitialized_copy(const char* first, const char* last,
+ char* result) {
+ memmove(result, first, last - first);
+ return result + (last - first);
+}
+
+inline wchar_t* uninitialized_copy(const wchar_t* first, const wchar_t* last,
+ wchar_t* result) {
+ memmove(result, first, sizeof(wchar_t) * (last - first));
+ return result + (last - first);
+}
+
+template <class InputIterator, class Size, class ForwardIterator>
+ForwardIterator __uninitialized_copy_n(InputIterator first, Size count,
+ ForwardIterator result,
+ input_iterator_tag) {
+ ForwardIterator cur = result;
+# ifdef __STL_USE_EXCEPTIONS
+ try {
+# endif /* __STL_USE_EXCEPTIONS */
+ for ( ; count > 0 ; --count, ++first, ++cur)
+ construct(&*cur, *first);
+ return cur;
+# ifdef __STL_USE_EXCEPTIONS
+ }
+ catch(...) {
+ destroy(result, cur);
+ throw;
+ }
+# endif /* __STL_USE_EXCEPTIONS */
+}
+
+template <class ForwardIterator1, class Size, class ForwardIterator>
+inline ForwardIterator
+__uninitialized_copy_n(ForwardIterator1 first, Size count,
+ ForwardIterator result,
+ forward_iterator_tag) {
+ return __uninitialized_copy_n(first, count, result, input_iterator_tag());
+}
+
+template <class BidirectionalIterator, class Size, class ForwardIterator>
+inline ForwardIterator
+__uninitialized_copy_n(BidirectionalIterator first, Size count,
+ ForwardIterator result,
+ bidirectional_iterator_tag) {
+ return __uninitialized_copy_n(first, count, result, input_iterator_tag());
+}
+
+template <class RandomAccessIterator, class Size, class ForwardIterator>
+inline ForwardIterator
+__uninitialized_copy_n(RandomAccessIterator first, Size count,
+ ForwardIterator result,
+ random_access_iterator_tag) {
+ return uninitialized_copy(first, first + count, result);
+}
+
+template <class InputIterator, class Size, class ForwardIterator>
+inline ForwardIterator uninitialized_copy_n(InputIterator first, Size count,
+ ForwardIterator result) {
+ return __uninitialized_copy_n(first, count, result,
+ iterator_category(first));
+}
+
+// Valid if copy construction is equivalent to assignment, and if the
+// destructor is trivial.
+template <class ForwardIterator, class T>
+inline void
+__uninitialized_fill_aux(ForwardIterator first, ForwardIterator last,
+ const T& x, __true_type)
+{
+ fill(first, last, x);
+}
+
+template <class ForwardIterator, class T>
+void
+__uninitialized_fill_aux(ForwardIterator first, ForwardIterator last,
+ const T& x, __false_type)
+{
+ ForwardIterator cur = first;
+# ifdef __STL_USE_EXCEPTIONS
+ try {
+# endif /* __STL_USE_EXCEPTIONS */
+ for ( ; cur != last; ++cur)
+ construct(&*cur, x);
+# ifdef __STL_USE_EXCEPTIONS
+ }
+ catch(...) {
+ destroy(first, cur);
+ throw;
+ }
+# endif /* __STL_USE_EXCEPTIONS */
+}
+
+template <class ForwardIterator, class T, class T1>
+inline void __uninitialized_fill(ForwardIterator first, ForwardIterator last,
+ const T& x, T1*) {
+ __uninitialized_fill_aux(first, last, x,
+ __type_traits<T1>::is_POD_type());
+}
+
+template <class ForwardIterator, class T>
+inline void uninitialized_fill(ForwardIterator first, ForwardIterator last,
+ const T& x) {
+ __uninitialized_fill(first, last, x, value_type(first));
+}
+
+// Valid if copy construction is equivalent to assignment, and if the
+// destructor is trivial.
+template <class ForwardIterator, class Size, class T>
+inline ForwardIterator
+__uninitialized_fill_n_aux(ForwardIterator first, Size n,
+ const T& x, __true_type) {
+ return fill_n(first, n, x);
+}
+
+template <class ForwardIterator, class Size, class T>
+ForwardIterator
+__uninitialized_fill_n_aux(ForwardIterator first, Size n,
+ const T& x, __false_type) {
+ ForwardIterator cur = first;
+# ifdef __STL_USE_EXCEPTIONS
+ try {
+# endif /* __STL_USE_EXCEPTIONS */
+ for ( ; n > 0; --n, ++cur)
+ construct(&*cur, x);
+ return cur;
+# ifdef __STL_USE_EXCEPTIONS
+ }
+ catch(...) {
+ destroy(first, cur);
+ throw;
+ }
+# endif /* __STL_USE_EXCEPTIONS */
+}
+
+template <class ForwardIterator, class Size, class T, class T1>
+inline ForwardIterator __uninitialized_fill_n(ForwardIterator first, Size n,
+ const T& x, T1*) {
+ return __uninitialized_fill_n_aux(first, n, x,
+ __type_traits<T1>::is_POD_type());
+}
+
+template <class ForwardIterator, class Size, class T>
+inline ForwardIterator uninitialized_fill_n(ForwardIterator first, Size n,
+ const T& x) {
+ return __uninitialized_fill_n(first, n, x, value_type(first));
+}
+
+// Copies [first1, last1) into [result, result + (last1 - first1)), and
+// copies [first2, last2) into
+// [result, result + (last1 - first1) + (last2 - first2)).
+
+template <class InputIterator1, class InputIterator2, class ForwardIterator>
+inline ForwardIterator
+__uninitialized_copy_copy(InputIterator1 first1, InputIterator1 last1,
+ InputIterator2 first2, InputIterator2 last2,
+ ForwardIterator result) {
+ ForwardIterator mid = uninitialized_copy(first1, last1, result);
+# ifdef __STL_USE_EXCEPTIONS
+ try {
+# endif /* __STL_USE_EXCEPTIONS */
+ return uninitialized_copy(first2, last2, mid);
+# ifdef __STL_USE_EXCEPTIONS
+ }
+ catch(...) {
+ destroy(result, mid);
+ throw;
+ }
+# endif /* __STL_USE_EXCEPTIONS */
+}
+
+// Fills [result, mid) with x, and copies [first, last) into
+// [mid, mid + (last - first)).
+template <class ForwardIterator, class T, class InputIterator>
+inline ForwardIterator
+__uninitialized_fill_copy(ForwardIterator result, ForwardIterator mid,
+ const T& x,
+ InputIterator first, InputIterator last) {
+ uninitialized_fill(result, mid, x);
+# ifdef __STL_USE_EXCEPTIONS
+ try {
+# endif /* __STL_USE_EXCEPTIONS */
+ return uninitialized_copy(first, last, mid);
+# ifdef __STL_USE_EXCEPTIONS
+ }
+ catch(...) {
+ destroy(result, mid);
+ throw;
+ }
+# endif /* __STL_USE_EXCEPTIONS */
+}
+
+// Copies [first1, last1) into [first2, first2 + (last1 - first1)), and
+// fills [first2 + (last1 - first1), last2) with x.
+template <class InputIterator, class ForwardIterator, class T>
+inline void
+__uninitialized_copy_fill(InputIterator first1, InputIterator last1,
+ ForwardIterator first2, ForwardIterator last2,
+ const T& x) {
+ ForwardIterator mid2 = uninitialized_copy(first1, last1, first2);
+# ifdef __STL_USE_EXCEPTIONS
+ try {
+# endif /* __STL_USE_EXCEPTIONS */
+ uninitialized_fill(mid2, last2, x);
+# ifdef __STL_USE_EXCEPTIONS
+ }
+ catch(...) {
+ destroy(first2, mid2);
+ throw;
+ }
+# endif /* __STL_USE_EXCEPTIONS */
+}
+
+#endif /* _SGI_STL_ALGOBASE_H */
generated by cgit v1.2.3 (git 2.25.1) at 2024-07-18 13:14:27 +0000