home *** CD-ROM | disk | FTP | other *** search
/ PC World 2000 January / PCWorld_2000-01_cd.bin / Software / Servis / Devc / _SETUP.4 / Group3 / stl_uninitialized.h < prev    next >
C/C++ Source or Header  |  1998-03-08  |  9KB  |  243 lines
  1. /*
  2.  *
  3.  * Copyright (c) 1994
  4.  * Hewlett-Packard Company
  5.  *
  6.  * Permission to use, copy, modify, distribute and sell this software
  7.  * and its documentation for any purpose is hereby granted without fee,
  8.  * provided that the above copyright notice appear in all copies and
  9.  * that both that copyright notice and this permission notice appear
  10.  * in supporting documentation.  Hewlett-Packard Company makes no
  11.  * representations about the suitability of this software for any
  12.  * purpose.  It is provided "as is" without express or implied warranty.
  13.  *
  14.  *
  15.  * Copyright (c) 1996,1997
  16.  * Silicon Graphics Computer Systems, Inc.
  17.  *
  18.  * Permission to use, copy, modify, distribute and sell this software
  19.  * and its documentation for any purpose is hereby granted without fee,
  20.  * provided that the above copyright notice appear in all copies and
  21.  * that both that copyright notice and this permission notice appear
  22.  * in supporting documentation.  Silicon Graphics makes no
  23.  * representations about the suitability of this software for any
  24.  * purpose.  It is provided "as is" without express or implied warranty.
  25.  */
  26.  
  27. /* NOTE: This is an internal header file, included by other STL headers.
  28.  *   You should not attempt to use it directly.
  29.  */
  30.  
  31. #ifndef __SGI_STL_INTERNAL_UNINITIALIZED_H
  32. #define __SGI_STL_INTERNAL_UNINITIALIZED_H
  33.  
  34. __STL_BEGIN_NAMESPACE
  35.  
  36. // Valid if copy construction is equivalent to assignment, and if the
  37. //  destructor is trivial.
  38. template <class InputIterator, class ForwardIterator>
  39. inline ForwardIterator 
  40. __uninitialized_copy_aux(InputIterator first, InputIterator last,
  41.                          ForwardIterator result,
  42.                          __true_type) {
  43.   return copy(first, last, result);
  44. }
  45.  
  46. template <class InputIterator, class ForwardIterator>
  47. ForwardIterator 
  48. __uninitialized_copy_aux(InputIterator first, InputIterator last,
  49.                          ForwardIterator result,
  50.                          __false_type) {
  51.   ForwardIterator cur = result;
  52.   __STL_TRY {
  53.     for ( ; first != last; ++first, ++cur)
  54.       construct(&*cur, *first);
  55.     return cur;
  56.   }
  57.   __STL_UNWIND(destroy(result, cur));
  58. }
  59.  
  60.  
  61. template <class InputIterator, class ForwardIterator, class T>
  62. inline ForwardIterator
  63. __uninitialized_copy(InputIterator first, InputIterator last,
  64.                      ForwardIterator result, T*) {
  65.   typedef typename __type_traits<T>::is_POD_type is_POD;
  66.   return __uninitialized_copy_aux(first, last, result, is_POD());
  67. }
  68.  
  69. template <class InputIterator, class ForwardIterator>
  70. inline ForwardIterator
  71.   uninitialized_copy(InputIterator first, InputIterator last,
  72.                      ForwardIterator result) {
  73.   return __uninitialized_copy(first, last, result, value_type(result));
  74. }
  75.  
  76. inline char* uninitialized_copy(const char* first, const char* last,
  77.                                 char* result) {
  78.   memmove(result, first, last - first);
  79.   return result + (last - first);
  80. }
  81.  
  82. inline wchar_t* uninitialized_copy(const wchar_t* first, const wchar_t* last,
  83.                                    wchar_t* result) {
  84.   memmove(result, first, sizeof(wchar_t) * (last - first));
  85.   return result + (last - first);
  86. }
  87.  
  88. template <class InputIterator, class Size, class ForwardIterator>
  89. pair<InputIterator, ForwardIterator>
  90. __uninitialized_copy_n(InputIterator first, Size count,
  91.                        ForwardIterator result,
  92.                        input_iterator_tag) {
  93.   ForwardIterator cur = result;
  94.   __STL_TRY {
  95.     for ( ; count > 0 ; --count, ++first, ++cur) 
  96.       construct(&*cur, *first);
  97.     return pair<InputIterator, ForwardIterator>(first, cur);
  98.   }
  99.   __STL_UNWIND(destroy(result, cur));
  100. }
  101.  
  102. template <class RandomAccessIterator, class Size, class ForwardIterator>
  103. inline pair<RandomAccessIterator, ForwardIterator>
  104. __uninitialized_copy_n(RandomAccessIterator first, Size count,
  105.                        ForwardIterator result,
  106.                        random_access_iterator_tag) {
  107.   RandomAccessIterator last = first + count;
  108.   return make_pair(last, uninitialized_copy(first, last, result));
  109. }
  110.  
  111. template <class InputIterator, class Size, class ForwardIterator>
  112. inline pair<InputIterator, ForwardIterator>
  113. uninitialized_copy_n(InputIterator first, Size count,
  114.                      ForwardIterator result) {
  115.   return __uninitialized_copy_n(first, count, result,
  116.                                 iterator_category(first));
  117. }
  118.  
  119. // Valid if copy construction is equivalent to assignment, and if the
  120. //  destructor is trivial.
  121. template <class ForwardIterator, class T>
  122. inline void
  123. __uninitialized_fill_aux(ForwardIterator first, ForwardIterator last, 
  124.                          const T& x, __true_type)
  125. {
  126.   fill(first, last, x);
  127. }
  128.  
  129. template <class ForwardIterator, class T>
  130. void
  131. __uninitialized_fill_aux(ForwardIterator first, ForwardIterator last, 
  132.                          const T& x, __false_type)
  133. {
  134.   ForwardIterator cur = first;
  135.   __STL_TRY {
  136.     for ( ; cur != last; ++cur)
  137.       construct(&*cur, x);
  138.   }
  139.   __STL_UNWIND(destroy(first, cur));
  140. }
  141.  
  142. template <class ForwardIterator, class T, class T1>
  143. inline void __uninitialized_fill(ForwardIterator first, ForwardIterator last, 
  144.                                  const T& x, T1*) {
  145.   typedef typename __type_traits<T1>::is_POD_type is_POD;
  146.   __uninitialized_fill_aux(first, last, x, is_POD());
  147.                    
  148. }
  149.  
  150. template <class ForwardIterator, class T>
  151. inline void uninitialized_fill(ForwardIterator first, ForwardIterator last, 
  152.                                const T& x) {
  153.   __uninitialized_fill(first, last, x, value_type(first));
  154. }
  155.  
  156. // Valid if copy construction is equivalent to assignment, and if the
  157. //  destructor is trivial.
  158. template <class ForwardIterator, class Size, class T>
  159. inline ForwardIterator
  160. __uninitialized_fill_n_aux(ForwardIterator first, Size n,
  161.                            const T& x, __true_type) {
  162.   return fill_n(first, n, x);
  163. }
  164.  
  165. template <class ForwardIterator, class Size, class T>
  166. ForwardIterator
  167. __uninitialized_fill_n_aux(ForwardIterator first, Size n,
  168.                            const T& x, __false_type) {
  169.   ForwardIterator cur = first;
  170.   __STL_TRY {
  171.     for ( ; n > 0; --n, ++cur)
  172.       construct(&*cur, x);
  173.     return cur;
  174.   }
  175.   __STL_UNWIND(destroy(first, cur));
  176. }
  177.  
  178. template <class ForwardIterator, class Size, class T, class T1>
  179. inline ForwardIterator __uninitialized_fill_n(ForwardIterator first, Size n,
  180.                                               const T& x, T1*) {
  181.   typedef typename __type_traits<T1>::is_POD_type is_POD;
  182.   return __uninitialized_fill_n_aux(first, n, x, is_POD());
  183.                                     
  184. }
  185.  
  186. template <class ForwardIterator, class Size, class T>
  187. inline ForwardIterator uninitialized_fill_n(ForwardIterator first, Size n,
  188.                                             const T& x) {
  189.   return __uninitialized_fill_n(first, n, x, value_type(first));
  190. }
  191.  
  192. // Copies [first1, last1) into [result, result + (last1 - first1)), and
  193. //  copies [first2, last2) into
  194. //  [result, result + (last1 - first1) + (last2 - first2)).
  195.  
  196. template <class InputIterator1, class InputIterator2, class ForwardIterator>
  197. inline ForwardIterator
  198. __uninitialized_copy_copy(InputIterator1 first1, InputIterator1 last1,
  199.                           InputIterator2 first2, InputIterator2 last2,
  200.                           ForwardIterator result) {
  201.   ForwardIterator mid = uninitialized_copy(first1, last1, result);
  202.   __STL_TRY {
  203.     return uninitialized_copy(first2, last2, mid);
  204.   }
  205.   __STL_UNWIND(destroy(result, mid));
  206. }
  207.  
  208. // Fills [result, mid) with x, and copies [first, last) into
  209. //  [mid, mid + (last - first)).
  210. template <class ForwardIterator, class T, class InputIterator>
  211. inline ForwardIterator 
  212. __uninitialized_fill_copy(ForwardIterator result, ForwardIterator mid,
  213.                           const T& x,
  214.                           InputIterator first, InputIterator last) {
  215.   uninitialized_fill(result, mid, x);
  216.   __STL_TRY {
  217.     return uninitialized_copy(first, last, mid);
  218.   }
  219.   __STL_UNWIND(destroy(result, mid));
  220. }
  221.  
  222. // Copies [first1, last1) into [first2, first2 + (last1 - first1)), and
  223. //  fills [first2 + (last1 - first1), last2) with x.
  224. template <class InputIterator, class ForwardIterator, class T>
  225. inline void
  226. __uninitialized_copy_fill(InputIterator first1, InputIterator last1,
  227.                           ForwardIterator first2, ForwardIterator last2,
  228.                           const T& x) {
  229.   ForwardIterator mid2 = uninitialized_copy(first1, last1, first2);
  230.   __STL_TRY {
  231.     uninitialized_fill(mid2, last2, x);
  232.   }
  233.   __STL_UNWIND(destroy(first2, mid2));
  234. }
  235.  
  236. __STL_END_NAMESPACE
  237.  
  238. #endif /* __SGI_STL_INTERNAL_UNINITIALIZED_H */
  239.  
  240. // Local Variables:
  241. // mode:C++
  242. // End:
  243.