OpenCores
URL https://opencores.org/ocsvn/altor32/altor32/trunk

Subversion Repositories altor32

[/] [altor32/] [trunk/] [gcc-x64/] [or1knd-elf/] [or1knd-elf/] [include/] [c++/] [4.8.0/] [bits/] [stl_vector.h] - Blame information for rev 35

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 35 ultra_embe
// Vector implementation -*- C++ -*-
2
 
3
// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
4
// 2011, 2012 Free Software Foundation, Inc.
5
//
6
// This file is part of the GNU ISO C++ Library.  This library is free
7
// software; you can redistribute it and/or modify it under the
8
// terms of the GNU General Public License as published by the
9
// Free Software Foundation; either version 3, or (at your option)
10
// any later version.
11
 
12
// This library is distributed in the hope that it will be useful,
13
// but WITHOUT ANY WARRANTY; without even the implied warranty of
14
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
// GNU General Public License for more details.
16
 
17
// Under Section 7 of GPL version 3, you are granted additional
18
// permissions described in the GCC Runtime Library Exception, version
19
// 3.1, as published by the Free Software Foundation.
20
 
21
// You should have received a copy of the GNU General Public License and
22
// a copy of the GCC Runtime Library Exception along with this program;
23
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
24
// <http://www.gnu.org/licenses/>.
25
 
26
/*
27
 *
28
 * Copyright (c) 1994
29
 * Hewlett-Packard Company
30
 *
31
 * Permission to use, copy, modify, distribute and sell this software
32
 * and its documentation for any purpose is hereby granted without fee,
33
 * provided that the above copyright notice appear in all copies and
34
 * that both that copyright notice and this permission notice appear
35
 * in supporting documentation.  Hewlett-Packard Company makes no
36
 * representations about the suitability of this software for any
37
 * purpose.  It is provided "as is" without express or implied warranty.
38
 *
39
 *
40
 * Copyright (c) 1996
41
 * Silicon Graphics Computer Systems, Inc.
42
 *
43
 * Permission to use, copy, modify, distribute and sell this software
44
 * and its documentation for any purpose is hereby granted without fee,
45
 * provided that the above copyright notice appear in all copies and
46
 * that both that copyright notice and this permission notice appear
47
 * in supporting documentation.  Silicon Graphics makes no
48
 * representations about the suitability of this  software for any
49
 * purpose.  It is provided "as is" without express or implied warranty.
50
 */
51
 
52
/** @file bits/stl_vector.h
53
 *  This is an internal header file, included by other library headers.
54
 *  Do not attempt to use it directly. @headername{vector}
55
 */
56
 
57
#ifndef _STL_VECTOR_H
58
#define _STL_VECTOR_H 1
59
 
60
#include <bits/stl_iterator_base_funcs.h>
61
#include <bits/functexcept.h>
62
#include <bits/concept_check.h>
63
#if __cplusplus >= 201103L
64
#include <initializer_list>
65
#endif
66
 
67
namespace std _GLIBCXX_VISIBILITY(default)
68
{
69
_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
70
 
71
  /// See bits/stl_deque.h's _Deque_base for an explanation.
72
  template<typename _Tp, typename _Alloc>
73
    struct _Vector_base
74
    {
75
      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
76
        rebind<_Tp>::other _Tp_alloc_type;
77
      typedef typename __gnu_cxx::__alloc_traits<_Tp_alloc_type>::pointer
78
        pointer;
79
 
80
      struct _Vector_impl
81
      : public _Tp_alloc_type
82
      {
83
        pointer _M_start;
84
        pointer _M_finish;
85
        pointer _M_end_of_storage;
86
 
87
        _Vector_impl()
88
        : _Tp_alloc_type(), _M_start(0), _M_finish(0), _M_end_of_storage(0)
89
        { }
90
 
91
        _Vector_impl(_Tp_alloc_type const& __a)
92
        : _Tp_alloc_type(__a), _M_start(0), _M_finish(0), _M_end_of_storage(0)
93
        { }
94
 
95
#if __cplusplus >= 201103L
96
        _Vector_impl(_Tp_alloc_type&& __a)
97
        : _Tp_alloc_type(std::move(__a)),
98
          _M_start(0), _M_finish(0), _M_end_of_storage(0)
99
        { }
100
#endif
101
 
102
        void _M_swap_data(_Vector_impl& __x)
103
        {
104
          std::swap(_M_start, __x._M_start);
105
          std::swap(_M_finish, __x._M_finish);
106
          std::swap(_M_end_of_storage, __x._M_end_of_storage);
107
        }
108
      };
109
 
110
    public:
111
      typedef _Alloc allocator_type;
112
 
113
      _Tp_alloc_type&
114
      _M_get_Tp_allocator() _GLIBCXX_NOEXCEPT
115
      { return *static_cast<_Tp_alloc_type*>(&this->_M_impl); }
116
 
117
      const _Tp_alloc_type&
118
      _M_get_Tp_allocator() const _GLIBCXX_NOEXCEPT
119
      { return *static_cast<const _Tp_alloc_type*>(&this->_M_impl); }
120
 
121
      allocator_type
122
      get_allocator() const _GLIBCXX_NOEXCEPT
123
      { return allocator_type(_M_get_Tp_allocator()); }
124
 
125
      _Vector_base()
126
      : _M_impl() { }
127
 
128
      _Vector_base(const allocator_type& __a)
129
      : _M_impl(__a) { }
130
 
131
      _Vector_base(size_t __n)
132
      : _M_impl()
133
      { _M_create_storage(__n); }
134
 
135
      _Vector_base(size_t __n, const allocator_type& __a)
136
      : _M_impl(__a)
137
      { _M_create_storage(__n); }
138
 
139
#if __cplusplus >= 201103L
140
      _Vector_base(_Tp_alloc_type&& __a)
141
      : _M_impl(std::move(__a)) { }
142
 
143
      _Vector_base(_Vector_base&& __x)
144
      : _M_impl(std::move(__x._M_get_Tp_allocator()))
145
      { this->_M_impl._M_swap_data(__x._M_impl); }
146
 
147
      _Vector_base(_Vector_base&& __x, const allocator_type& __a)
148
      : _M_impl(__a)
149
      {
150
        if (__x.get_allocator() == __a)
151
          this->_M_impl._M_swap_data(__x._M_impl);
152
        else
153
          {
154
            size_t __n = __x._M_impl._M_finish - __x._M_impl._M_start;
155
            _M_create_storage(__n);
156
          }
157
      }
158
#endif
159
 
160
      ~_Vector_base()
161
      { _M_deallocate(this->_M_impl._M_start, this->_M_impl._M_end_of_storage
162
                      - this->_M_impl._M_start); }
163
 
164
    public:
165
      _Vector_impl _M_impl;
166
 
167
      pointer
168
      _M_allocate(size_t __n)
169
      { return __n != 0 ? _M_impl.allocate(__n) : 0; }
170
 
171
      void
172
      _M_deallocate(pointer __p, size_t __n)
173
      {
174
        if (__p)
175
          _M_impl.deallocate(__p, __n);
176
      }
177
 
178
    private:
179
      void
180
      _M_create_storage(size_t __n)
181
      {
182
        this->_M_impl._M_start = this->_M_allocate(__n);
183
        this->_M_impl._M_finish = this->_M_impl._M_start;
184
        this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
185
      }
186
    };
187
 
188
 
189
  /**
190
   *  @brief A standard container which offers fixed time access to
191
   *  individual elements in any order.
192
   *
193
   *  @ingroup sequences
194
   *
195
   *  @tparam _Tp  Type of element.
196
   *  @tparam _Alloc  Allocator type, defaults to allocator<_Tp>.
197
   *
198
   *  Meets the requirements of a <a href="tables.html#65">container</a>, a
199
   *  <a href="tables.html#66">reversible container</a>, and a
200
   *  <a href="tables.html#67">sequence</a>, including the
201
   *  <a href="tables.html#68">optional sequence requirements</a> with the
202
   *  %exception of @c push_front and @c pop_front.
203
   *
204
   *  In some terminology a %vector can be described as a dynamic
205
   *  C-style array, it offers fast and efficient access to individual
206
   *  elements in any order and saves the user from worrying about
207
   *  memory and size allocation.  Subscripting ( @c [] ) access is
208
   *  also provided as with C-style arrays.
209
  */
210
  template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
211
    class vector : protected _Vector_base<_Tp, _Alloc>
212
    {
213
      // Concept requirements.
214
      typedef typename _Alloc::value_type                _Alloc_value_type;
215
      __glibcxx_class_requires(_Tp, _SGIAssignableConcept)
216
      __glibcxx_class_requires2(_Tp, _Alloc_value_type, _SameTypeConcept)
217
 
218
      typedef _Vector_base<_Tp, _Alloc>                  _Base;
219
      typedef typename _Base::_Tp_alloc_type             _Tp_alloc_type;
220
      typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type>  _Alloc_traits;
221
 
222
    public:
223
      typedef _Tp                                        value_type;
224
      typedef typename _Base::pointer                    pointer;
225
      typedef typename _Alloc_traits::const_pointer      const_pointer;
226
      typedef typename _Alloc_traits::reference          reference;
227
      typedef typename _Alloc_traits::const_reference    const_reference;
228
      typedef __gnu_cxx::__normal_iterator<pointer, vector> iterator;
229
      typedef __gnu_cxx::__normal_iterator<const_pointer, vector>
230
      const_iterator;
231
      typedef std::reverse_iterator<const_iterator>  const_reverse_iterator;
232
      typedef std::reverse_iterator<iterator>            reverse_iterator;
233
      typedef size_t                                     size_type;
234
      typedef ptrdiff_t                                  difference_type;
235
      typedef _Alloc                                     allocator_type;
236
 
237
    protected:
238
      using _Base::_M_allocate;
239
      using _Base::_M_deallocate;
240
      using _Base::_M_impl;
241
      using _Base::_M_get_Tp_allocator;
242
 
243
    public:
244
      // [23.2.4.1] construct/copy/destroy
245
      // (assign() and get_allocator() are also listed in this section)
246
      /**
247
       *  @brief  Default constructor creates no elements.
248
       */
249
      vector()
250
      : _Base() { }
251
 
252
      /**
253
       *  @brief  Creates a %vector with no elements.
254
       *  @param  __a  An allocator object.
255
       */
256
      explicit
257
      vector(const allocator_type& __a)
258
      : _Base(__a) { }
259
 
260
#if __cplusplus >= 201103L
261
      /**
262
       *  @brief  Creates a %vector with default constructed elements.
263
       *  @param  __n  The number of elements to initially create.
264
       *  @param  __a  An allocator.
265
       *
266
       *  This constructor fills the %vector with @a __n default
267
       *  constructed elements.
268
       */
269
      explicit
270
      vector(size_type __n, const allocator_type& __a = allocator_type())
271
      : _Base(__n, __a)
272
      { _M_default_initialize(__n); }
273
 
274
      /**
275
       *  @brief  Creates a %vector with copies of an exemplar element.
276
       *  @param  __n  The number of elements to initially create.
277
       *  @param  __value  An element to copy.
278
       *  @param  __a  An allocator.
279
       *
280
       *  This constructor fills the %vector with @a __n copies of @a __value.
281
       */
282
      vector(size_type __n, const value_type& __value,
283
             const allocator_type& __a = allocator_type())
284
      : _Base(__n, __a)
285
      { _M_fill_initialize(__n, __value); }
286
#else
287
      /**
288
       *  @brief  Creates a %vector with copies of an exemplar element.
289
       *  @param  __n  The number of elements to initially create.
290
       *  @param  __value  An element to copy.
291
       *  @param  __a  An allocator.
292
       *
293
       *  This constructor fills the %vector with @a __n copies of @a __value.
294
       */
295
      explicit
296
      vector(size_type __n, const value_type& __value = value_type(),
297
             const allocator_type& __a = allocator_type())
298
      : _Base(__n, __a)
299
      { _M_fill_initialize(__n, __value); }
300
#endif
301
 
302
      /**
303
       *  @brief  %Vector copy constructor.
304
       *  @param  __x  A %vector of identical element and allocator types.
305
       *
306
       *  The newly-created %vector uses a copy of the allocation
307
       *  object used by @a __x.  All the elements of @a __x are copied,
308
       *  but any extra memory in
309
       *  @a __x (for fast expansion) will not be copied.
310
       */
311
      vector(const vector& __x)
312
      : _Base(__x.size(),
313
        _Alloc_traits::_S_select_on_copy(__x._M_get_Tp_allocator()))
314
      { this->_M_impl._M_finish =
315
          std::__uninitialized_copy_a(__x.begin(), __x.end(),
316
                                      this->_M_impl._M_start,
317
                                      _M_get_Tp_allocator());
318
      }
319
 
320
#if __cplusplus >= 201103L
321
      /**
322
       *  @brief  %Vector move constructor.
323
       *  @param  __x  A %vector of identical element and allocator types.
324
       *
325
       *  The newly-created %vector contains the exact contents of @a __x.
326
       *  The contents of @a __x are a valid, but unspecified %vector.
327
       */
328
      vector(vector&& __x) noexcept
329
      : _Base(std::move(__x)) { }
330
 
331
      /// Copy constructor with alternative allocator
332
      vector(const vector& __x, const allocator_type& __a)
333
      : _Base(__x.size(), __a)
334
      { this->_M_impl._M_finish =
335
          std::__uninitialized_copy_a(__x.begin(), __x.end(),
336
                                      this->_M_impl._M_start,
337
                                      _M_get_Tp_allocator());
338
      }
339
 
340
      /// Move constructor with alternative allocator
341
      vector(vector&& __rv, const allocator_type& __m)
342
      : _Base(std::move(__rv), __m)
343
      {
344
        if (__rv.get_allocator() != __m)
345
          {
346
            this->_M_impl._M_finish =
347
              std::__uninitialized_move_a(__rv.begin(), __rv.end(),
348
                                          this->_M_impl._M_start,
349
                                          _M_get_Tp_allocator());
350
            __rv.clear();
351
          }
352
      }
353
 
354
      /**
355
       *  @brief  Builds a %vector from an initializer list.
356
       *  @param  __l  An initializer_list.
357
       *  @param  __a  An allocator.
358
       *
359
       *  Create a %vector consisting of copies of the elements in the
360
       *  initializer_list @a __l.
361
       *
362
       *  This will call the element type's copy constructor N times
363
       *  (where N is @a __l.size()) and do no memory reallocation.
364
       */
365
      vector(initializer_list<value_type> __l,
366
             const allocator_type& __a = allocator_type())
367
      : _Base(__a)
368
      {
369
        _M_range_initialize(__l.begin(), __l.end(),
370
                            random_access_iterator_tag());
371
      }
372
#endif
373
 
374
      /**
375
       *  @brief  Builds a %vector from a range.
376
       *  @param  __first  An input iterator.
377
       *  @param  __last  An input iterator.
378
       *  @param  __a  An allocator.
379
       *
380
       *  Create a %vector consisting of copies of the elements from
381
       *  [first,last).
382
       *
383
       *  If the iterators are forward, bidirectional, or
384
       *  random-access, then this will call the elements' copy
385
       *  constructor N times (where N is distance(first,last)) and do
386
       *  no memory reallocation.  But if only input iterators are
387
       *  used, then this will do at most 2N calls to the copy
388
       *  constructor, and logN memory reallocations.
389
       */
390
#if __cplusplus >= 201103L
391
      template<typename _InputIterator,
392
               typename = std::_RequireInputIter<_InputIterator>>
393
        vector(_InputIterator __first, _InputIterator __last,
394
               const allocator_type& __a = allocator_type())
395
        : _Base(__a)
396
        { _M_initialize_dispatch(__first, __last, __false_type()); }
397
#else
398
      template<typename _InputIterator>
399
        vector(_InputIterator __first, _InputIterator __last,
400
               const allocator_type& __a = allocator_type())
401
        : _Base(__a)
402
        {
403
          // Check whether it's an integral type.  If so, it's not an iterator.
404
          typedef typename std::__is_integer<_InputIterator>::__type _Integral;
405
          _M_initialize_dispatch(__first, __last, _Integral());
406
        }
407
#endif
408
 
409
      /**
410
       *  The dtor only erases the elements, and note that if the
411
       *  elements themselves are pointers, the pointed-to memory is
412
       *  not touched in any way.  Managing the pointer is the user's
413
       *  responsibility.
414
       */
415
      ~vector() _GLIBCXX_NOEXCEPT
416
      { std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
417
                      _M_get_Tp_allocator()); }
418
 
419
      /**
420
       *  @brief  %Vector assignment operator.
421
       *  @param  __x  A %vector of identical element and allocator types.
422
       *
423
       *  All the elements of @a __x are copied, but any extra memory in
424
       *  @a __x (for fast expansion) will not be copied.  Unlike the
425
       *  copy constructor, the allocator object is not copied.
426
       */
427
      vector&
428
      operator=(const vector& __x);
429
 
430
#if __cplusplus >= 201103L
431
      /**
432
       *  @brief  %Vector move assignment operator.
433
       *  @param  __x  A %vector of identical element and allocator types.
434
       *
435
       *  The contents of @a __x are moved into this %vector (without copying,
436
       *  if the allocators permit it).
437
       *  @a __x is a valid, but unspecified %vector.
438
       */
439
      vector&
440
      operator=(vector&& __x) noexcept(_Alloc_traits::_S_nothrow_move())
441
      {
442
        constexpr bool __move_storage =
443
          _Alloc_traits::_S_propagate_on_move_assign()
444
          || _Alloc_traits::_S_always_equal();
445
        _M_move_assign(std::move(__x),
446
                       integral_constant<bool, __move_storage>());
447
        return *this;
448
      }
449
 
450
      /**
451
       *  @brief  %Vector list assignment operator.
452
       *  @param  __l  An initializer_list.
453
       *
454
       *  This function fills a %vector with copies of the elements in the
455
       *  initializer list @a __l.
456
       *
457
       *  Note that the assignment completely changes the %vector and
458
       *  that the resulting %vector's size is the same as the number
459
       *  of elements assigned.  Old data may be lost.
460
       */
461
      vector&
462
      operator=(initializer_list<value_type> __l)
463
      {
464
        this->assign(__l.begin(), __l.end());
465
        return *this;
466
      }
467
#endif
468
 
469
      /**
470
       *  @brief  Assigns a given value to a %vector.
471
       *  @param  __n  Number of elements to be assigned.
472
       *  @param  __val  Value to be assigned.
473
       *
474
       *  This function fills a %vector with @a __n copies of the given
475
       *  value.  Note that the assignment completely changes the
476
       *  %vector and that the resulting %vector's size is the same as
477
       *  the number of elements assigned.  Old data may be lost.
478
       */
479
      void
480
      assign(size_type __n, const value_type& __val)
481
      { _M_fill_assign(__n, __val); }
482
 
483
      /**
484
       *  @brief  Assigns a range to a %vector.
485
       *  @param  __first  An input iterator.
486
       *  @param  __last   An input iterator.
487
       *
488
       *  This function fills a %vector with copies of the elements in the
489
       *  range [__first,__last).
490
       *
491
       *  Note that the assignment completely changes the %vector and
492
       *  that the resulting %vector's size is the same as the number
493
       *  of elements assigned.  Old data may be lost.
494
       */
495
#if __cplusplus >= 201103L
496
      template<typename _InputIterator,
497
               typename = std::_RequireInputIter<_InputIterator>>
498
        void
499
        assign(_InputIterator __first, _InputIterator __last)
500
        { _M_assign_dispatch(__first, __last, __false_type()); }
501
#else
502
      template<typename _InputIterator>
503
        void
504
        assign(_InputIterator __first, _InputIterator __last)
505
        {
506
          // Check whether it's an integral type.  If so, it's not an iterator.
507
          typedef typename std::__is_integer<_InputIterator>::__type _Integral;
508
          _M_assign_dispatch(__first, __last, _Integral());
509
        }
510
#endif
511
 
512
#if __cplusplus >= 201103L
513
      /**
514
       *  @brief  Assigns an initializer list to a %vector.
515
       *  @param  __l  An initializer_list.
516
       *
517
       *  This function fills a %vector with copies of the elements in the
518
       *  initializer list @a __l.
519
       *
520
       *  Note that the assignment completely changes the %vector and
521
       *  that the resulting %vector's size is the same as the number
522
       *  of elements assigned.  Old data may be lost.
523
       */
524
      void
525
      assign(initializer_list<value_type> __l)
526
      { this->assign(__l.begin(), __l.end()); }
527
#endif
528
 
529
      /// Get a copy of the memory allocation object.
530
      using _Base::get_allocator;
531
 
532
      // iterators
533
      /**
534
       *  Returns a read/write iterator that points to the first
535
       *  element in the %vector.  Iteration is done in ordinary
536
       *  element order.
537
       */
538
      iterator
539
      begin() _GLIBCXX_NOEXCEPT
540
      { return iterator(this->_M_impl._M_start); }
541
 
542
      /**
543
       *  Returns a read-only (constant) iterator that points to the
544
       *  first element in the %vector.  Iteration is done in ordinary
545
       *  element order.
546
       */
547
      const_iterator
548
      begin() const _GLIBCXX_NOEXCEPT
549
      { return const_iterator(this->_M_impl._M_start); }
550
 
551
      /**
552
       *  Returns a read/write iterator that points one past the last
553
       *  element in the %vector.  Iteration is done in ordinary
554
       *  element order.
555
       */
556
      iterator
557
      end() _GLIBCXX_NOEXCEPT
558
      { return iterator(this->_M_impl._M_finish); }
559
 
560
      /**
561
       *  Returns a read-only (constant) iterator that points one past
562
       *  the last element in the %vector.  Iteration is done in
563
       *  ordinary element order.
564
       */
565
      const_iterator
566
      end() const _GLIBCXX_NOEXCEPT
567
      { return const_iterator(this->_M_impl._M_finish); }
568
 
569
      /**
570
       *  Returns a read/write reverse iterator that points to the
571
       *  last element in the %vector.  Iteration is done in reverse
572
       *  element order.
573
       */
574
      reverse_iterator
575
      rbegin() _GLIBCXX_NOEXCEPT
576
      { return reverse_iterator(end()); }
577
 
578
      /**
579
       *  Returns a read-only (constant) reverse iterator that points
580
       *  to the last element in the %vector.  Iteration is done in
581
       *  reverse element order.
582
       */
583
      const_reverse_iterator
584
      rbegin() const _GLIBCXX_NOEXCEPT
585
      { return const_reverse_iterator(end()); }
586
 
587
      /**
588
       *  Returns a read/write reverse iterator that points to one
589
       *  before the first element in the %vector.  Iteration is done
590
       *  in reverse element order.
591
       */
592
      reverse_iterator
593
      rend() _GLIBCXX_NOEXCEPT
594
      { return reverse_iterator(begin()); }
595
 
596
      /**
597
       *  Returns a read-only (constant) reverse iterator that points
598
       *  to one before the first element in the %vector.  Iteration
599
       *  is done in reverse element order.
600
       */
601
      const_reverse_iterator
602
      rend() const _GLIBCXX_NOEXCEPT
603
      { return const_reverse_iterator(begin()); }
604
 
605
#if __cplusplus >= 201103L
606
      /**
607
       *  Returns a read-only (constant) iterator that points to the
608
       *  first element in the %vector.  Iteration is done in ordinary
609
       *  element order.
610
       */
611
      const_iterator
612
      cbegin() const noexcept
613
      { return const_iterator(this->_M_impl._M_start); }
614
 
615
      /**
616
       *  Returns a read-only (constant) iterator that points one past
617
       *  the last element in the %vector.  Iteration is done in
618
       *  ordinary element order.
619
       */
620
      const_iterator
621
      cend() const noexcept
622
      { return const_iterator(this->_M_impl._M_finish); }
623
 
624
      /**
625
       *  Returns a read-only (constant) reverse iterator that points
626
       *  to the last element in the %vector.  Iteration is done in
627
       *  reverse element order.
628
       */
629
      const_reverse_iterator
630
      crbegin() const noexcept
631
      { return const_reverse_iterator(end()); }
632
 
633
      /**
634
       *  Returns a read-only (constant) reverse iterator that points
635
       *  to one before the first element in the %vector.  Iteration
636
       *  is done in reverse element order.
637
       */
638
      const_reverse_iterator
639
      crend() const noexcept
640
      { return const_reverse_iterator(begin()); }
641
#endif
642
 
643
      // [23.2.4.2] capacity
644
      /**  Returns the number of elements in the %vector.  */
645
      size_type
646
      size() const _GLIBCXX_NOEXCEPT
647
      { return size_type(this->_M_impl._M_finish - this->_M_impl._M_start); }
648
 
649
      /**  Returns the size() of the largest possible %vector.  */
650
      size_type
651
      max_size() const _GLIBCXX_NOEXCEPT
652
      { return _Alloc_traits::max_size(_M_get_Tp_allocator()); }
653
 
654
#if __cplusplus >= 201103L
655
      /**
656
       *  @brief  Resizes the %vector to the specified number of elements.
657
       *  @param  __new_size  Number of elements the %vector should contain.
658
       *
659
       *  This function will %resize the %vector to the specified
660
       *  number of elements.  If the number is smaller than the
661
       *  %vector's current size the %vector is truncated, otherwise
662
       *  default constructed elements are appended.
663
       */
664
      void
665
      resize(size_type __new_size)
666
      {
667
        if (__new_size > size())
668
          _M_default_append(__new_size - size());
669
        else if (__new_size < size())
670
          _M_erase_at_end(this->_M_impl._M_start + __new_size);
671
      }
672
 
673
      /**
674
       *  @brief  Resizes the %vector to the specified number of elements.
675
       *  @param  __new_size  Number of elements the %vector should contain.
676
       *  @param  __x  Data with which new elements should be populated.
677
       *
678
       *  This function will %resize the %vector to the specified
679
       *  number of elements.  If the number is smaller than the
680
       *  %vector's current size the %vector is truncated, otherwise
681
       *  the %vector is extended and new elements are populated with
682
       *  given data.
683
       */
684
      void
685
      resize(size_type __new_size, const value_type& __x)
686
      {
687
        if (__new_size > size())
688
          insert(end(), __new_size - size(), __x);
689
        else if (__new_size < size())
690
          _M_erase_at_end(this->_M_impl._M_start + __new_size);
691
      }
692
#else
693
      /**
694
       *  @brief  Resizes the %vector to the specified number of elements.
695
       *  @param  __new_size  Number of elements the %vector should contain.
696
       *  @param  __x  Data with which new elements should be populated.
697
       *
698
       *  This function will %resize the %vector to the specified
699
       *  number of elements.  If the number is smaller than the
700
       *  %vector's current size the %vector is truncated, otherwise
701
       *  the %vector is extended and new elements are populated with
702
       *  given data.
703
       */
704
      void
705
      resize(size_type __new_size, value_type __x = value_type())
706
      {
707
        if (__new_size > size())
708
          insert(end(), __new_size - size(), __x);
709
        else if (__new_size < size())
710
          _M_erase_at_end(this->_M_impl._M_start + __new_size);
711
      }
712
#endif
713
 
714
#if __cplusplus >= 201103L
715
      /**  A non-binding request to reduce capacity() to size().  */
716
      void
717
      shrink_to_fit()
718
      { _M_shrink_to_fit(); }
719
#endif
720
 
721
      /**
722
       *  Returns the total number of elements that the %vector can
723
       *  hold before needing to allocate more memory.
724
       */
725
      size_type
726
      capacity() const _GLIBCXX_NOEXCEPT
727
      { return size_type(this->_M_impl._M_end_of_storage
728
                         - this->_M_impl._M_start); }
729
 
730
      /**
731
       *  Returns true if the %vector is empty.  (Thus begin() would
732
       *  equal end().)
733
       */
734
      bool
735
      empty() const _GLIBCXX_NOEXCEPT
736
      { return begin() == end(); }
737
 
738
      /**
739
       *  @brief  Attempt to preallocate enough memory for specified number of
740
       *          elements.
741
       *  @param  __n  Number of elements required.
742
       *  @throw  std::length_error  If @a n exceeds @c max_size().
743
       *
744
       *  This function attempts to reserve enough memory for the
745
       *  %vector to hold the specified number of elements.  If the
746
       *  number requested is more than max_size(), length_error is
747
       *  thrown.
748
       *
749
       *  The advantage of this function is that if optimal code is a
750
       *  necessity and the user can determine the number of elements
751
       *  that will be required, the user can reserve the memory in
752
       *  %advance, and thus prevent a possible reallocation of memory
753
       *  and copying of %vector data.
754
       */
755
      void
756
      reserve(size_type __n);
757
 
758
      // element access
759
      /**
760
       *  @brief  Subscript access to the data contained in the %vector.
761
       *  @param __n The index of the element for which data should be
762
       *  accessed.
763
       *  @return  Read/write reference to data.
764
       *
765
       *  This operator allows for easy, array-style, data access.
766
       *  Note that data access with this operator is unchecked and
767
       *  out_of_range lookups are not defined. (For checked lookups
768
       *  see at().)
769
       */
770
      reference
771
      operator[](size_type __n)
772
      { return *(this->_M_impl._M_start + __n); }
773
 
774
      /**
775
       *  @brief  Subscript access to the data contained in the %vector.
776
       *  @param __n The index of the element for which data should be
777
       *  accessed.
778
       *  @return  Read-only (constant) reference to data.
779
       *
780
       *  This operator allows for easy, array-style, data access.
781
       *  Note that data access with this operator is unchecked and
782
       *  out_of_range lookups are not defined. (For checked lookups
783
       *  see at().)
784
       */
785
      const_reference
786
      operator[](size_type __n) const
787
      { return *(this->_M_impl._M_start + __n); }
788
 
789
    protected:
790
      /// Safety check used only from at().
791
      void
792
      _M_range_check(size_type __n) const
793
      {
794
        if (__n >= this->size())
795
          __throw_out_of_range(__N("vector::_M_range_check"));
796
      }
797
 
798
    public:
799
      /**
800
       *  @brief  Provides access to the data contained in the %vector.
801
       *  @param __n The index of the element for which data should be
802
       *  accessed.
803
       *  @return  Read/write reference to data.
804
       *  @throw  std::out_of_range  If @a __n is an invalid index.
805
       *
806
       *  This function provides for safer data access.  The parameter
807
       *  is first checked that it is in the range of the vector.  The
808
       *  function throws out_of_range if the check fails.
809
       */
810
      reference
811
      at(size_type __n)
812
      {
813
        _M_range_check(__n);
814
        return (*this)[__n];
815
      }
816
 
817
      /**
818
       *  @brief  Provides access to the data contained in the %vector.
819
       *  @param __n The index of the element for which data should be
820
       *  accessed.
821
       *  @return  Read-only (constant) reference to data.
822
       *  @throw  std::out_of_range  If @a __n is an invalid index.
823
       *
824
       *  This function provides for safer data access.  The parameter
825
       *  is first checked that it is in the range of the vector.  The
826
       *  function throws out_of_range if the check fails.
827
       */
828
      const_reference
829
      at(size_type __n) const
830
      {
831
        _M_range_check(__n);
832
        return (*this)[__n];
833
      }
834
 
835
      /**
836
       *  Returns a read/write reference to the data at the first
837
       *  element of the %vector.
838
       */
839
      reference
840
      front()
841
      { return *begin(); }
842
 
843
      /**
844
       *  Returns a read-only (constant) reference to the data at the first
845
       *  element of the %vector.
846
       */
847
      const_reference
848
      front() const
849
      { return *begin(); }
850
 
851
      /**
852
       *  Returns a read/write reference to the data at the last
853
       *  element of the %vector.
854
       */
855
      reference
856
      back()
857
      { return *(end() - 1); }
858
 
859
      /**
860
       *  Returns a read-only (constant) reference to the data at the
861
       *  last element of the %vector.
862
       */
863
      const_reference
864
      back() const
865
      { return *(end() - 1); }
866
 
867
      // _GLIBCXX_RESOLVE_LIB_DEFECTS
868
      // DR 464. Suggestion for new member functions in standard containers.
869
      // data access
870
      /**
871
       *   Returns a pointer such that [data(), data() + size()) is a valid
872
       *   range.  For a non-empty %vector, data() == &front().
873
       */
874
#if __cplusplus >= 201103L
875
      _Tp*
876
#else
877
      pointer
878
#endif
879
      data() _GLIBCXX_NOEXCEPT
880
      { return std::__addressof(front()); }
881
 
882
#if __cplusplus >= 201103L
883
      const _Tp*
884
#else
885
      const_pointer
886
#endif
887
      data() const _GLIBCXX_NOEXCEPT
888
      { return std::__addressof(front()); }
889
 
890
      // [23.2.4.3] modifiers
891
      /**
892
       *  @brief  Add data to the end of the %vector.
893
       *  @param  __x  Data to be added.
894
       *
895
       *  This is a typical stack operation.  The function creates an
896
       *  element at the end of the %vector and assigns the given data
897
       *  to it.  Due to the nature of a %vector this operation can be
898
       *  done in constant time if the %vector has preallocated space
899
       *  available.
900
       */
901
      void
902
      push_back(const value_type& __x)
903
      {
904
        if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
905
          {
906
            _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
907
                                     __x);
908
            ++this->_M_impl._M_finish;
909
          }
910
        else
911
#if __cplusplus >= 201103L
912
          _M_emplace_back_aux(__x);
913
#else
914
          _M_insert_aux(end(), __x);
915
#endif
916
      }
917
 
918
#if __cplusplus >= 201103L
919
      void
920
      push_back(value_type&& __x)
921
      { emplace_back(std::move(__x)); }
922
 
923
      template<typename... _Args>
924
        void
925
        emplace_back(_Args&&... __args);
926
#endif
927
 
928
      /**
929
       *  @brief  Removes last element.
930
       *
931
       *  This is a typical stack operation. It shrinks the %vector by one.
932
       *
933
       *  Note that no data is returned, and if the last element's
934
       *  data is needed, it should be retrieved before pop_back() is
935
       *  called.
936
       */
937
      void
938
      pop_back()
939
      {
940
        --this->_M_impl._M_finish;
941
        _Alloc_traits::destroy(this->_M_impl, this->_M_impl._M_finish);
942
      }
943
 
944
#if __cplusplus >= 201103L
945
      /**
946
       *  @brief  Inserts an object in %vector before specified iterator.
947
       *  @param  __position  An iterator into the %vector.
948
       *  @param  __args  Arguments.
949
       *  @return  An iterator that points to the inserted data.
950
       *
951
       *  This function will insert an object of type T constructed
952
       *  with T(std::forward<Args>(args)...) before the specified location.
953
       *  Note that this kind of operation could be expensive for a %vector
954
       *  and if it is frequently used the user should consider using
955
       *  std::list.
956
       */
957
      template<typename... _Args>
958
        iterator
959
        emplace(iterator __position, _Args&&... __args);
960
#endif
961
 
962
      /**
963
       *  @brief  Inserts given value into %vector before specified iterator.
964
       *  @param  __position  An iterator into the %vector.
965
       *  @param  __x  Data to be inserted.
966
       *  @return  An iterator that points to the inserted data.
967
       *
968
       *  This function will insert a copy of the given value before
969
       *  the specified location.  Note that this kind of operation
970
       *  could be expensive for a %vector and if it is frequently
971
       *  used the user should consider using std::list.
972
       */
973
      iterator
974
      insert(iterator __position, const value_type& __x);
975
 
976
#if __cplusplus >= 201103L
977
      /**
978
       *  @brief  Inserts given rvalue into %vector before specified iterator.
979
       *  @param  __position  An iterator into the %vector.
980
       *  @param  __x  Data to be inserted.
981
       *  @return  An iterator that points to the inserted data.
982
       *
983
       *  This function will insert a copy of the given rvalue before
984
       *  the specified location.  Note that this kind of operation
985
       *  could be expensive for a %vector and if it is frequently
986
       *  used the user should consider using std::list.
987
       */
988
      iterator
989
      insert(iterator __position, value_type&& __x)
990
      { return emplace(__position, std::move(__x)); }
991
 
992
      /**
993
       *  @brief  Inserts an initializer_list into the %vector.
994
       *  @param  __position  An iterator into the %vector.
995
       *  @param  __l  An initializer_list.
996
       *
997
       *  This function will insert copies of the data in the
998
       *  initializer_list @a l into the %vector before the location
999
       *  specified by @a position.
1000
       *
1001
       *  Note that this kind of operation could be expensive for a
1002
       *  %vector and if it is frequently used the user should
1003
       *  consider using std::list.
1004
       */
1005
      void
1006
      insert(iterator __position, initializer_list<value_type> __l)
1007
      { this->insert(__position, __l.begin(), __l.end()); }
1008
#endif
1009
 
1010
      /**
1011
       *  @brief  Inserts a number of copies of given data into the %vector.
1012
       *  @param  __position  An iterator into the %vector.
1013
       *  @param  __n  Number of elements to be inserted.
1014
       *  @param  __x  Data to be inserted.
1015
       *
1016
       *  This function will insert a specified number of copies of
1017
       *  the given data before the location specified by @a position.
1018
       *
1019
       *  Note that this kind of operation could be expensive for a
1020
       *  %vector and if it is frequently used the user should
1021
       *  consider using std::list.
1022
       */
1023
      void
1024
      insert(iterator __position, size_type __n, const value_type& __x)
1025
      { _M_fill_insert(__position, __n, __x); }
1026
 
1027
      /**
1028
       *  @brief  Inserts a range into the %vector.
1029
       *  @param  __position  An iterator into the %vector.
1030
       *  @param  __first  An input iterator.
1031
       *  @param  __last   An input iterator.
1032
       *
1033
       *  This function will insert copies of the data in the range
1034
       *  [__first,__last) into the %vector before the location specified
1035
       *  by @a pos.
1036
       *
1037
       *  Note that this kind of operation could be expensive for a
1038
       *  %vector and if it is frequently used the user should
1039
       *  consider using std::list.
1040
       */
1041
#if __cplusplus >= 201103L
1042
      template<typename _InputIterator,
1043
               typename = std::_RequireInputIter<_InputIterator>>
1044
        void
1045
        insert(iterator __position, _InputIterator __first,
1046
               _InputIterator __last)
1047
        { _M_insert_dispatch(__position, __first, __last, __false_type()); }
1048
#else
1049
      template<typename _InputIterator>
1050
        void
1051
        insert(iterator __position, _InputIterator __first,
1052
               _InputIterator __last)
1053
        {
1054
          // Check whether it's an integral type.  If so, it's not an iterator.
1055
          typedef typename std::__is_integer<_InputIterator>::__type _Integral;
1056
          _M_insert_dispatch(__position, __first, __last, _Integral());
1057
        }
1058
#endif
1059
 
1060
      /**
1061
       *  @brief  Remove element at given position.
1062
       *  @param  __position  Iterator pointing to element to be erased.
1063
       *  @return  An iterator pointing to the next element (or end()).
1064
       *
1065
       *  This function will erase the element at the given position and thus
1066
       *  shorten the %vector by one.
1067
       *
1068
       *  Note This operation could be expensive and if it is
1069
       *  frequently used the user should consider using std::list.
1070
       *  The user is also cautioned that this function only erases
1071
       *  the element, and that if the element is itself a pointer,
1072
       *  the pointed-to memory is not touched in any way.  Managing
1073
       *  the pointer is the user's responsibility.
1074
       */
1075
      iterator
1076
      erase(iterator __position);
1077
 
1078
      /**
1079
       *  @brief  Remove a range of elements.
1080
       *  @param  __first  Iterator pointing to the first element to be erased.
1081
       *  @param  __last  Iterator pointing to one past the last element to be
1082
       *                  erased.
1083
       *  @return  An iterator pointing to the element pointed to by @a __last
1084
       *           prior to erasing (or end()).
1085
       *
1086
       *  This function will erase the elements in the range
1087
       *  [__first,__last) and shorten the %vector accordingly.
1088
       *
1089
       *  Note This operation could be expensive and if it is
1090
       *  frequently used the user should consider using std::list.
1091
       *  The user is also cautioned that this function only erases
1092
       *  the elements, and that if the elements themselves are
1093
       *  pointers, the pointed-to memory is not touched in any way.
1094
       *  Managing the pointer is the user's responsibility.
1095
       */
1096
      iterator
1097
      erase(iterator __first, iterator __last);
1098
 
1099
      /**
1100
       *  @brief  Swaps data with another %vector.
1101
       *  @param  __x  A %vector of the same element and allocator types.
1102
       *
1103
       *  This exchanges the elements between two vectors in constant time.
1104
       *  (Three pointers, so it should be quite fast.)
1105
       *  Note that the global std::swap() function is specialized such that
1106
       *  std::swap(v1,v2) will feed to this function.
1107
       */
1108
      void
1109
      swap(vector& __x)
1110
#if __cplusplus >= 201103L
1111
                        noexcept(_Alloc_traits::_S_nothrow_swap())
1112
#endif
1113
      {
1114
        this->_M_impl._M_swap_data(__x._M_impl);
1115
        _Alloc_traits::_S_on_swap(_M_get_Tp_allocator(),
1116
                                  __x._M_get_Tp_allocator());
1117
      }
1118
 
1119
      /**
1120
       *  Erases all the elements.  Note that this function only erases the
1121
       *  elements, and that if the elements themselves are pointers, the
1122
       *  pointed-to memory is not touched in any way.  Managing the pointer is
1123
       *  the user's responsibility.
1124
       */
1125
      void
1126
      clear() _GLIBCXX_NOEXCEPT
1127
      { _M_erase_at_end(this->_M_impl._M_start); }
1128
 
1129
    protected:
1130
      /**
1131
       *  Memory expansion handler.  Uses the member allocation function to
1132
       *  obtain @a n bytes of memory, and then copies [first,last) into it.
1133
       */
1134
      template<typename _ForwardIterator>
1135
        pointer
1136
        _M_allocate_and_copy(size_type __n,
1137
                             _ForwardIterator __first, _ForwardIterator __last)
1138
        {
1139
          pointer __result = this->_M_allocate(__n);
1140
          __try
1141
            {
1142
              std::__uninitialized_copy_a(__first, __last, __result,
1143
                                          _M_get_Tp_allocator());
1144
              return __result;
1145
            }
1146
          __catch(...)
1147
            {
1148
              _M_deallocate(__result, __n);
1149
              __throw_exception_again;
1150
            }
1151
        }
1152
 
1153
 
1154
      // Internal constructor functions follow.
1155
 
1156
      // Called by the range constructor to implement [23.1.1]/9
1157
 
1158
      // _GLIBCXX_RESOLVE_LIB_DEFECTS
1159
      // 438. Ambiguity in the "do the right thing" clause
1160
      template<typename _Integer>
1161
        void
1162
        _M_initialize_dispatch(_Integer __n, _Integer __value, __true_type)
1163
        {
1164
          this->_M_impl._M_start = _M_allocate(static_cast<size_type>(__n));
1165
          this->_M_impl._M_end_of_storage =
1166
            this->_M_impl._M_start + static_cast<size_type>(__n);
1167
          _M_fill_initialize(static_cast<size_type>(__n), __value);
1168
        }
1169
 
1170
      // Called by the range constructor to implement [23.1.1]/9
1171
      template<typename _InputIterator>
1172
        void
1173
        _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
1174
                               __false_type)
1175
        {
1176
          typedef typename std::iterator_traits<_InputIterator>::
1177
            iterator_category _IterCategory;
1178
          _M_range_initialize(__first, __last, _IterCategory());
1179
        }
1180
 
1181
      // Called by the second initialize_dispatch above
1182
      template<typename _InputIterator>
1183
        void
1184
        _M_range_initialize(_InputIterator __first,
1185
                            _InputIterator __last, std::input_iterator_tag)
1186
        {
1187
          for (; __first != __last; ++__first)
1188
            push_back(*__first);
1189
        }
1190
 
1191
      // Called by the second initialize_dispatch above
1192
      template<typename _ForwardIterator>
1193
        void
1194
        _M_range_initialize(_ForwardIterator __first,
1195
                            _ForwardIterator __last, std::forward_iterator_tag)
1196
        {
1197
          const size_type __n = std::distance(__first, __last);
1198
          this->_M_impl._M_start = this->_M_allocate(__n);
1199
          this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
1200
          this->_M_impl._M_finish =
1201
            std::__uninitialized_copy_a(__first, __last,
1202
                                        this->_M_impl._M_start,
1203
                                        _M_get_Tp_allocator());
1204
        }
1205
 
1206
      // Called by the first initialize_dispatch above and by the
1207
      // vector(n,value,a) constructor.
1208
      void
1209
      _M_fill_initialize(size_type __n, const value_type& __value)
1210
      {
1211
        std::__uninitialized_fill_n_a(this->_M_impl._M_start, __n, __value,
1212
                                      _M_get_Tp_allocator());
1213
        this->_M_impl._M_finish = this->_M_impl._M_end_of_storage;
1214
      }
1215
 
1216
#if __cplusplus >= 201103L
1217
      // Called by the vector(n) constructor.
1218
      void
1219
      _M_default_initialize(size_type __n)
1220
      {
1221
        std::__uninitialized_default_n_a(this->_M_impl._M_start, __n,
1222
                                         _M_get_Tp_allocator());
1223
        this->_M_impl._M_finish = this->_M_impl._M_end_of_storage;
1224
      }
1225
#endif
1226
 
1227
      // Internal assign functions follow.  The *_aux functions do the actual
1228
      // assignment work for the range versions.
1229
 
1230
      // Called by the range assign to implement [23.1.1]/9
1231
 
1232
      // _GLIBCXX_RESOLVE_LIB_DEFECTS
1233
      // 438. Ambiguity in the "do the right thing" clause
1234
      template<typename _Integer>
1235
        void
1236
        _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
1237
        { _M_fill_assign(__n, __val); }
1238
 
1239
      // Called by the range assign to implement [23.1.1]/9
1240
      template<typename _InputIterator>
1241
        void
1242
        _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
1243
                           __false_type)
1244
        {
1245
          typedef typename std::iterator_traits<_InputIterator>::
1246
            iterator_category _IterCategory;
1247
          _M_assign_aux(__first, __last, _IterCategory());
1248
        }
1249
 
1250
      // Called by the second assign_dispatch above
1251
      template<typename _InputIterator>
1252
        void
1253
        _M_assign_aux(_InputIterator __first, _InputIterator __last,
1254
                      std::input_iterator_tag);
1255
 
1256
      // Called by the second assign_dispatch above
1257
      template<typename _ForwardIterator>
1258
        void
1259
        _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
1260
                      std::forward_iterator_tag);
1261
 
1262
      // Called by assign(n,t), and the range assign when it turns out
1263
      // to be the same thing.
1264
      void
1265
      _M_fill_assign(size_type __n, const value_type& __val);
1266
 
1267
 
1268
      // Internal insert functions follow.
1269
 
1270
      // Called by the range insert to implement [23.1.1]/9
1271
 
1272
      // _GLIBCXX_RESOLVE_LIB_DEFECTS
1273
      // 438. Ambiguity in the "do the right thing" clause
1274
      template<typename _Integer>
1275
        void
1276
        _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val,
1277
                           __true_type)
1278
        { _M_fill_insert(__pos, __n, __val); }
1279
 
1280
      // Called by the range insert to implement [23.1.1]/9
1281
      template<typename _InputIterator>
1282
        void
1283
        _M_insert_dispatch(iterator __pos, _InputIterator __first,
1284
                           _InputIterator __last, __false_type)
1285
        {
1286
          typedef typename std::iterator_traits<_InputIterator>::
1287
            iterator_category _IterCategory;
1288
          _M_range_insert(__pos, __first, __last, _IterCategory());
1289
        }
1290
 
1291
      // Called by the second insert_dispatch above
1292
      template<typename _InputIterator>
1293
        void
1294
        _M_range_insert(iterator __pos, _InputIterator __first,
1295
                        _InputIterator __last, std::input_iterator_tag);
1296
 
1297
      // Called by the second insert_dispatch above
1298
      template<typename _ForwardIterator>
1299
        void
1300
        _M_range_insert(iterator __pos, _ForwardIterator __first,
1301
                        _ForwardIterator __last, std::forward_iterator_tag);
1302
 
1303
      // Called by insert(p,n,x), and the range insert when it turns out to be
1304
      // the same thing.
1305
      void
1306
      _M_fill_insert(iterator __pos, size_type __n, const value_type& __x);
1307
 
1308
#if __cplusplus >= 201103L
1309
      // Called by resize(n).
1310
      void
1311
      _M_default_append(size_type __n);
1312
 
1313
      bool
1314
      _M_shrink_to_fit();
1315
#endif
1316
 
1317
      // Called by insert(p,x)
1318
#if __cplusplus < 201103L
1319
      void
1320
      _M_insert_aux(iterator __position, const value_type& __x);
1321
#else
1322
      template<typename... _Args>
1323
        void
1324
        _M_insert_aux(iterator __position, _Args&&... __args);
1325
 
1326
      template<typename... _Args>
1327
        void
1328
        _M_emplace_back_aux(_Args&&... __args);
1329
#endif
1330
 
1331
      // Called by the latter.
1332
      size_type
1333
      _M_check_len(size_type __n, const char* __s) const
1334
      {
1335
        if (max_size() - size() < __n)
1336
          __throw_length_error(__N(__s));
1337
 
1338
        const size_type __len = size() + std::max(size(), __n);
1339
        return (__len < size() || __len > max_size()) ? max_size() : __len;
1340
      }
1341
 
1342
      // Internal erase functions follow.
1343
 
1344
      // Called by erase(q1,q2), clear(), resize(), _M_fill_assign,
1345
      // _M_assign_aux.
1346
      void
1347
      _M_erase_at_end(pointer __pos)
1348
      {
1349
        std::_Destroy(__pos, this->_M_impl._M_finish, _M_get_Tp_allocator());
1350
        this->_M_impl._M_finish = __pos;
1351
      }
1352
 
1353
#if __cplusplus >= 201103L
1354
    private:
1355
      // Constant-time move assignment when source object's memory can be
1356
      // moved, either because the source's allocator will move too
1357
      // or because the allocators are equal.
1358
      void
1359
      _M_move_assign(vector&& __x, std::true_type) noexcept
1360
      {
1361
        const vector __tmp(std::move(*this));
1362
        this->_M_impl._M_swap_data(__x._M_impl);
1363
        if (_Alloc_traits::_S_propagate_on_move_assign())
1364
          std::__alloc_on_move(_M_get_Tp_allocator(),
1365
                               __x._M_get_Tp_allocator());
1366
      }
1367
 
1368
      // Do move assignment when it might not be possible to move source
1369
      // object's memory, resulting in a linear-time operation.
1370
      void
1371
      _M_move_assign(vector&& __x, std::false_type)
1372
      {
1373
        if (__x._M_get_Tp_allocator() == this->_M_get_Tp_allocator())
1374
          _M_move_assign(std::move(__x), std::true_type());
1375
        else
1376
          {
1377
            // The rvalue's allocator cannot be moved and is not equal,
1378
            // so we need to individually move each element.
1379
            this->assign(std::__make_move_if_noexcept_iterator(__x.begin()),
1380
                         std::__make_move_if_noexcept_iterator(__x.end()));
1381
            __x.clear();
1382
          }
1383
      }
1384
#endif
1385
    };
1386
 
1387
 
1388
  /**
1389
   *  @brief  Vector equality comparison.
1390
   *  @param  __x  A %vector.
1391
   *  @param  __y  A %vector of the same type as @a __x.
1392
   *  @return  True iff the size and elements of the vectors are equal.
1393
   *
1394
   *  This is an equivalence relation.  It is linear in the size of the
1395
   *  vectors.  Vectors are considered equivalent if their sizes are equal,
1396
   *  and if corresponding elements compare equal.
1397
  */
1398
  template<typename _Tp, typename _Alloc>
1399
    inline bool
1400
    operator==(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
1401
    { return (__x.size() == __y.size()
1402
              && std::equal(__x.begin(), __x.end(), __y.begin())); }
1403
 
1404
  /**
1405
   *  @brief  Vector ordering relation.
1406
   *  @param  __x  A %vector.
1407
   *  @param  __y  A %vector of the same type as @a __x.
1408
   *  @return  True iff @a __x is lexicographically less than @a __y.
1409
   *
1410
   *  This is a total ordering relation.  It is linear in the size of the
1411
   *  vectors.  The elements must be comparable with @c <.
1412
   *
1413
   *  See std::lexicographical_compare() for how the determination is made.
1414
  */
1415
  template<typename _Tp, typename _Alloc>
1416
    inline bool
1417
    operator<(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
1418
    { return std::lexicographical_compare(__x.begin(), __x.end(),
1419
                                          __y.begin(), __y.end()); }
1420
 
1421
  /// Based on operator==
1422
  template<typename _Tp, typename _Alloc>
1423
    inline bool
1424
    operator!=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
1425
    { return !(__x == __y); }
1426
 
1427
  /// Based on operator<
1428
  template<typename _Tp, typename _Alloc>
1429
    inline bool
1430
    operator>(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
1431
    { return __y < __x; }
1432
 
1433
  /// Based on operator<
1434
  template<typename _Tp, typename _Alloc>
1435
    inline bool
1436
    operator<=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
1437
    { return !(__y < __x); }
1438
 
1439
  /// Based on operator<
1440
  template<typename _Tp, typename _Alloc>
1441
    inline bool
1442
    operator>=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
1443
    { return !(__x < __y); }
1444
 
1445
  /// See std::vector::swap().
1446
  template<typename _Tp, typename _Alloc>
1447
    inline void
1448
    swap(vector<_Tp, _Alloc>& __x, vector<_Tp, _Alloc>& __y)
1449
    { __x.swap(__y); }
1450
 
1451
_GLIBCXX_END_NAMESPACE_CONTAINER
1452
} // namespace std
1453
 
1454
#endif /* _STL_VECTOR_H */

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.