libstdc++-v3/include/bits/stl_uninitialized.h

   1 // Raw memory manipulators -*- C++ -*-
   2
   3 // Copyright (C) 2001 Free Software Foundation, Inc.
   4 //
   5 // This file is part of the GNU ISO C++ Library.  This library is free
   6 // software; you can redistribute it and/or modify it under the
   7 // terms of the GNU General Public License as published by the
   8 // Free Software Foundation; either version 2, or (at your option)
   9 // any later version.
  10
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15
  16 // You should have received a copy of the GNU General Public License along
  17 // with this library; see the file COPYING.  If not, write to the Free
  18 // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  19 // USA.
  20
  21 // As a special exception, you may use this file as part of a free software
  22 // library without restriction.  Specifically, if other files instantiate
  23 // templates or use macros or inline functions from this file, or you compile
  24 // this file and link it with other files to produce an executable, this
  25 // file does not by itself cause the resulting executable to be covered by
  26 // the GNU General Public License.  This exception does not however
  27 // invalidate any other reasons why the executable file might be covered by
  28 // the GNU General Public License.
  29
  30 /*
  31  *
  32  * Copyright (c) 1994
  33  * Hewlett-Packard Company
  34  *
  35  * Permission to use, copy, modify, distribute and sell this software
  36  * and its documentation for any purpose is hereby granted without fee,
  37  * provided that the above copyright notice appear in all copies and
  38  * that both that copyright notice and this permission notice appear
  39  * in supporting documentation.  Hewlett-Packard Company makes no
  40  * representations about the suitability of this software for any
  41  * purpose.  It is provided "as is" without express or implied warranty.
  42  *
  43  *
  44  * Copyright (c) 1996,1997
  45  * Silicon Graphics Computer Systems, Inc.
  46  *
  47  * Permission to use, copy, modify, distribute and sell this software
  48  * and its documentation for any purpose is hereby granted without fee,
  49  * provided that the above copyright notice appear in all copies and
  50  * that both that copyright notice and this permission notice appear
  51  * in supporting documentation.  Silicon Graphics makes no
  52  * representations about the suitability of this software for any
  53  * purpose.  It is provided "as is" without express or implied warranty.
  54  */
  55
  56 /** @file stl_uninitialized.h
  57  *  This is an internal header file, included by other library headers.
  58  *  You should not attempt to use it directly.
  59  */
  60
  61 #ifndef _CPP_BITS_STL_UNINITIALIZED_H
  62 #define _CPP_BITS_STL_UNINITIALIZED_H 1
  63
  64 #include <bits/std_cstring.h>
  65
  66 namespace std
  67 {
  68
  69   // uninitialized_copy
  70
  71   template<typename _InputIter, typename _ForwardIter>
  72     inline _ForwardIter
  73     __uninitialized_copy_aux(_InputIter __first, _InputIter __last,
  74                              _ForwardIter __result,
  75                              __true_type)
  76     { return copy(__first, __last, __result); }
  77
  78   template<typename _InputIter, typename _ForwardIter>
  79     _ForwardIter
  80     __uninitialized_copy_aux(_InputIter __first, _InputIter __last,
  81                              _ForwardIter __result,
  82                              __false_type)
  83     {
  84       _ForwardIter __cur = __result;
  85       try {
  86         for ( ; __first != __last; ++__first, ++__cur)
  87           _Construct(&*__cur, *__first);
  88         return __cur;
  89       }
  90       catch(...)
  91         {
  92           _Destroy(__result, __cur);
  93           __throw_exception_again;
  94         }
  95     }
  96
  97   /**
  98    *  @brief Copies the range [first,last) into result.
  99    *  @param  first  An input iterator.
 100    *  @param  last   An input iterator.
 101    *  @param  result An output iterator.
 102    *  @return   result + (first - last)
 103    *
 104    *  Like copy(), but does not require an initialized output range.
 105   */
 106   template<typename _InputIter, typename _ForwardIter>
 107     inline _ForwardIter
 108     uninitialized_copy(_InputIter __first, _InputIter __last, _ForwardIter __result)
 109     {
 110       typedef typename iterator_traits<_InputIter>::value_type _ValueType;
 111       typedef typename __type_traits<_ValueType>::is_POD_type _Is_POD;
 112       return __uninitialized_copy_aux(__first, __last, __result, _Is_POD());
 113     }
 114
 115   inline char*
 116   uninitialized_copy(const char* __first, const char* __last, char* __result)
 117   {
 118     memmove(__result, __first, __last - __first);
 119     return __result + (__last - __first);
 120   }
 121
 122   inline wchar_t*
 123   uninitialized_copy(const wchar_t* __first, const wchar_t* __last,
 124                      wchar_t* __result)
 125   {
 126     memmove(__result, __first, sizeof(wchar_t) * (__last - __first));
 127     return __result + (__last - __first);
 128   }
 129
 130   // uninitialized_copy_n (not part of the C++ standard)
 131
 132   template<typename _InputIter, typename _Size, typename _ForwardIter>
 133     pair<_InputIter, _ForwardIter>
 134     __uninitialized_copy_n(_InputIter __first, _Size __count,
 135                            _ForwardIter __result,
 136                            input_iterator_tag)
 137     {
 138       _ForwardIter __cur = __result;
 139       try {
 140         for ( ; __count > 0 ; --__count, ++__first, ++__cur)
 141           _Construct(&*__cur, *__first);
 142         return pair<_InputIter, _ForwardIter>(__first, __cur);
 143       }
 144       catch(...)
 145         {
 146           _Destroy(__result, __cur);
 147           __throw_exception_again;
 148         }
 149     }
 150
 151   template<typename _RandomAccessIter, typename _Size, typename _ForwardIter>
 152     inline pair<_RandomAccessIter, _ForwardIter>
 153     __uninitialized_copy_n(_RandomAccessIter __first, _Size __count,
 154                            _ForwardIter __result,
 155                            random_access_iterator_tag)
 156     {
 157       _RandomAccessIter __last = __first + __count;
 158       return pair<_RandomAccessIter, _ForwardIter>(
 159                      __last,
 160                      uninitialized_copy(__first, __last, __result));
 161     }
 162
 163   template<typename _InputIter, typename _Size, typename _ForwardIter>
 164     inline pair<_InputIter, _ForwardIter>
 165     __uninitialized_copy_n(_InputIter __first, _Size __count,
 166                          _ForwardIter __result) {
 167       return __uninitialized_copy_n(__first, __count, __result,
 168                                     __iterator_category(__first));
 169     }
 170
 171   /**
 172    *  @brief Copies the range [first,last) into result.
 173    *  @param  first  An input iterator.
 174    *  @param  last   An input iterator.
 175    *  @param  result An output iterator.
 176    *  @return   result + (first - last)
 177    *
 178    *  Like copy(), but does not require an initialized output range.
 179   */
 180   template<typename _InputIter, typename _Size, typename _ForwardIter>
 181     inline pair<_InputIter, _ForwardIter>
 182     uninitialized_copy_n(_InputIter __first, _Size __count,
 183                          _ForwardIter __result) {
 184       return __uninitialized_copy_n(__first, __count, __result,
 185                                     __iterator_category(__first));
 186     }
 187
 188   // Valid if copy construction is equivalent to assignment, and if the
 189   // destructor is trivial.
 190   template<typename _ForwardIter, typename _Tp>
 191     inline void
 192     __uninitialized_fill_aux(_ForwardIter __first, _ForwardIter __last,
 193                              const _Tp& __x, __true_type)
 194     { fill(__first, __last, __x); }
 195
 196   template<typename _ForwardIter, typename _Tp>
 197     void
 198     __uninitialized_fill_aux(_ForwardIter __first, _ForwardIter __last,
 199                              const _Tp& __x, __false_type)
 200     {
 201       _ForwardIter __cur = __first;
 202       try {
 203         for ( ; __cur != __last; ++__cur)
 204           _Construct(&*__cur, __x);
 205       }
 206       catch(...)
 207         {
 208           _Destroy(__first, __cur);
 209           __throw_exception_again;
 210         }
 211     }
 212
 213   /**
 214    *  @brief Copies the value x into the range [first,last).
 215    *  @param  first  An input iterator.
 216    *  @param  last   An input iterator.
 217    *  @param  x      The source value.
 218    *  @return   Nothing.
 219    *
 220    *  Like fill(), but does not require an initialized output range.
 221   */
 222   template<typename _ForwardIter, typename _Tp>
 223     inline void
 224     uninitialized_fill(_ForwardIter __first, _ForwardIter __last, const _Tp& __x)
 225     {
 226       typedef typename iterator_traits<_ForwardIter>::value_type _ValueType;
 227       typedef typename __type_traits<_ValueType>::is_POD_type _Is_POD;
 228       __uninitialized_fill_aux(__first, __last, __x, _Is_POD());
 229     }
 230
 231   // Valid if copy construction is equivalent to assignment, and if the
 232   //  destructor is trivial.
 233   template<typename _ForwardIter, typename _Size, typename _Tp>
 234     inline _ForwardIter
 235     __uninitialized_fill_n_aux(_ForwardIter __first, _Size __n,
 236                                const _Tp& __x, __true_type)
 237     {
 238       return fill_n(__first, __n, __x);
 239     }
 240
 241   template<typename _ForwardIter, typename _Size, typename _Tp>
 242     _ForwardIter
 243     __uninitialized_fill_n_aux(_ForwardIter __first, _Size __n,
 244                                const _Tp& __x, __false_type)
 245     {
 246       _ForwardIter __cur = __first;
 247       try {
 248         for ( ; __n > 0; --__n, ++__cur)
 249           _Construct(&*__cur, __x);
 250         return __cur;
 251       }
 252       catch(...)
 253         {
 254           _Destroy(__first, __cur);
 255           __throw_exception_again;
 256         }
 257     }
 258
 259   /**
 260    *  @brief Copies the value x into the range [first,first+n).
 261    *  @param  first  An input iterator.
 262    *  @param  n      The number of copies to make.
 263    *  @param  x      The source value.
 264    *  @return   first+n
 265    *
 266    *  Like fill_n(), but does not require an initialized output range.
 267   */
 268   template<typename _ForwardIter, typename _Size, typename _Tp>
 269     inline _ForwardIter
 270     uninitialized_fill_n(_ForwardIter __first, _Size __n, const _Tp& __x)
 271     {
 272       typedef typename iterator_traits<_ForwardIter>::value_type _ValueType;
 273       typedef typename __type_traits<_ValueType>::is_POD_type _Is_POD;
 274       return __uninitialized_fill_n_aux(__first, __n, __x, _Is_POD());
 275     }
 276
 277   // Extensions: __uninitialized_copy_copy, __uninitialized_copy_fill,
 278   // __uninitialized_fill_copy.
 279
 280   // __uninitialized_copy_copy
 281   // Copies [first1, last1) into [result, result + (last1 - first1)), and
 282   //  copies [first2, last2) into
 283   //  [result, result + (last1 - first1) + (last2 - first2)).
 284
 285   template<typename _InputIter1, typename _InputIter2, typename _ForwardIter>
 286     inline _ForwardIter
 287     __uninitialized_copy_copy(_InputIter1 __first1, _InputIter1 __last1,
 288                               _InputIter2 __first2, _InputIter2 __last2,
 289                               _ForwardIter __result)
 290     {
 291       _ForwardIter __mid = uninitialized_copy(__first1, __last1, __result);
 292       try {
 293         return uninitialized_copy(__first2, __last2, __mid);
 294       }
 295       catch(...)
 296         {
 297           _Destroy(__result, __mid);
 298           __throw_exception_again;
 299         }
 300     }
 301
 302   // __uninitialized_fill_copy
 303   // Fills [result, mid) with x, and copies [first, last) into
 304   //  [mid, mid + (last - first)).
 305   template<typename _ForwardIter, typename _Tp, typename _InputIter>
 306     inline _ForwardIter
 307     __uninitialized_fill_copy(_ForwardIter __result, _ForwardIter __mid,
 308                               const _Tp& __x,
 309                               _InputIter __first, _InputIter __last)
 310     {
 311       uninitialized_fill(__result, __mid, __x);
 312       try {
 313         return uninitialized_copy(__first, __last, __mid);
 314       }
 315       catch(...)
 316         {
 317           _Destroy(__result, __mid);
 318           __throw_exception_again;
 319         }
 320     }
 321
 322   // __uninitialized_copy_fill
 323   // Copies [first1, last1) into [first2, first2 + (last1 - first1)), and
 324   //  fills [first2 + (last1 - first1), last2) with x.
 325   template<typename _InputIter, typename _ForwardIter, typename _Tp>
 326     inline void
 327     __uninitialized_copy_fill(_InputIter __first1, _InputIter __last1,
 328                               _ForwardIter __first2, _ForwardIter __last2,
 329                               const _Tp& __x)
 330     {
 331       _ForwardIter __mid2 = uninitialized_copy(__first1, __last1, __first2);
 332       try {
 333         uninitialized_fill(__mid2, __last2, __x);
 334       }
 335       catch(...)
 336         {
 337           _Destroy(__first2, __mid2);
 338           __throw_exception_again;
 339         }
 340     }
 341
 342 } // namespace std
 343
 344 #endif /* _CPP_BITS_STL_UNINITIALIZED_H */
 345
 346 // Local Variables:
 347 // mode:C++
 348 // End: