1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
|
/*
*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Copyright (c) 1996,1997
* Silicon Graphics Computer Systems, Inc.
*
* Copyright (c) 1997
* Moscow Center for SPARC Technology
*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#ifndef _STLP_VECTOR_C
#define _STLP_VECTOR_C
#if !defined (_STLP_INTERNAL_VECTOR_H)
# include <stl/_vector.h>
#endif
#include <stl/_range_errors.h>
_STLP_BEGIN_NAMESPACE
_STLP_MOVE_TO_PRIV_NAMESPACE
template <class _Tp, class _Alloc>
void _Vector_base<_Tp,_Alloc>::_M_throw_length_error() const {
__stl_throw_length_error("vector");
}
template <class _Tp, class _Alloc>
void _Vector_base<_Tp, _Alloc>::_M_throw_out_of_range() const {
__stl_throw_out_of_range("vector");
}
#if defined (_STLP_USE_PTR_SPECIALIZATIONS)
# define vector _STLP_PTR_IMPL_NAME(vector)
#elif defined (_STLP_DEBUG)
# define vector _STLP_NON_DBG_NAME(vector)
#else
_STLP_MOVE_TO_STD_NAMESPACE
#endif
#if defined (_STLP_NESTED_TYPE_PARAM_BUG)
# define __iterator__ _Tp*
#else
# define __iterator__ _STLP_TYPENAME_ON_RETURN_TYPE vector<_Tp, _Alloc>::iterator
#endif
template <class _Tp, class _Alloc>
void vector<_Tp, _Alloc>::reserve(size_type __n) {
if (capacity() < __n) {
if (max_size() < __n) {
this->_M_throw_length_error();
}
const size_type __old_size = size();
pointer __tmp;
if (this->_M_start) {
__tmp = _M_allocate_and_copy(__n, this->_M_start, this->_M_finish);
_M_clear();
} else {
__tmp = this->_M_end_of_storage.allocate(__n, __n);
}
_M_set(__tmp, __tmp + __old_size, __tmp + __n);
}
}
template <class _Tp, class _Alloc>
void vector<_Tp, _Alloc>::_M_insert_overflow_aux(pointer __pos, const _Tp& __x, const __false_type& /*DO NOT USE!!*/,
size_type __fill_len, bool __atend ) {
const size_type __old_size = size();
size_type __len = __old_size + (max)(__old_size, __fill_len);
pointer __new_start = this->_M_end_of_storage.allocate(__len, __len);
pointer __new_finish = __new_start;
_STLP_TRY {
__new_finish = _STLP_PRIV __uninitialized_move(this->_M_start, __pos, __new_start, _TrivialUCopy(), _Movable());
// handle insertion
if (__fill_len == 1) {
_Copy_Construct(__new_finish, __x);
++__new_finish;
} else
__new_finish = _STLP_PRIV __uninitialized_fill_n(__new_finish, __fill_len, __x);
if (!__atend)
__new_finish = _STLP_PRIV __uninitialized_move(__pos, this->_M_finish, __new_finish, _TrivialUCopy(), _Movable()); // copy remainder
}
_STLP_UNWIND((_STLP_STD::_Destroy_Range(__new_start,__new_finish),
this->_M_end_of_storage.deallocate(__new_start,__len)))
_M_clear_after_move();
_M_set(__new_start, __new_finish, __new_start + __len);
}
template <class _Tp, class _Alloc>
void vector<_Tp, _Alloc>::_M_insert_overflow(pointer __pos, const _Tp& __x, const __true_type& /*_TrivialCopy*/,
size_type __fill_len, bool __atend ) {
const size_type __old_size = size();
size_type __len = __old_size + (max)(__old_size, __fill_len);
pointer __new_start = this->_M_end_of_storage.allocate(__len, __len);
pointer __new_finish = __STATIC_CAST(pointer, _STLP_PRIV __copy_trivial(this->_M_start, __pos, __new_start));
// handle insertion
__new_finish = _STLP_PRIV __fill_n(__new_finish, __fill_len, __x);
if (!__atend)
__new_finish = __STATIC_CAST(pointer, _STLP_PRIV __copy_trivial(__pos, this->_M_finish, __new_finish)); // copy remainder
_M_clear();
_M_set(__new_start, __new_finish, __new_start + __len);
}
template <class _Tp, class _Alloc>
void vector<_Tp, _Alloc>::_M_fill_insert_aux(iterator __pos, size_type __n,
const _Tp& __x, const __true_type& /*_Movable*/) {
if (_M_is_inside(__x)) {
_Tp __x_copy = __x;
_M_fill_insert_aux(__pos, __n, __x_copy, __true_type());
return;
}
iterator __src = this->_M_finish - 1;
iterator __dst = __src + __n;
for (; __src >= __pos; --__dst, --__src) {
_STLP_STD::_Move_Construct(__dst, *__src);
_STLP_STD::_Destroy_Moved(__src);
}
_STLP_PRIV __uninitialized_fill_n(__pos, __n, __x);
this->_M_finish += __n;
}
template <class _Tp, class _Alloc>
void vector<_Tp, _Alloc>::_M_fill_insert_aux (iterator __pos, size_type __n,
const _Tp& __x, const __false_type& /*_Movable*/) {
//Here self referencing needs to be checked even for non movable types.
if (_M_is_inside(__x)) {
_Tp __x_copy = __x;
_M_fill_insert_aux(__pos, __n, __x_copy, __false_type());
return;
}
const size_type __elems_after = this->_M_finish - __pos;
pointer __old_finish = this->_M_finish;
if (__elems_after > __n) {
_STLP_PRIV __ucopy_ptrs(this->_M_finish - __n, this->_M_finish, this->_M_finish, _TrivialUCopy());
this->_M_finish += __n;
_STLP_PRIV __copy_backward_ptrs(__pos, __old_finish - __n, __old_finish, _TrivialCopy());
_STLP_STD::fill(__pos, __pos + __n, __x);
} else {
this->_M_finish = _STLP_PRIV __uninitialized_fill_n(this->_M_finish, __n - __elems_after, __x);
_STLP_PRIV __ucopy_ptrs(__pos, __old_finish, this->_M_finish, _TrivialUCopy());
this->_M_finish += __elems_after;
_STLP_STD::fill(__pos, __old_finish, __x);
}
}
template <class _Tp, class _Alloc>
void vector<_Tp, _Alloc>::_M_fill_insert(iterator __pos,
size_type __n, const _Tp& __x) {
if (__n != 0) {
if (size_type(this->_M_end_of_storage._M_data - this->_M_finish) >= __n) {
_M_fill_insert_aux(__pos, __n, __x, _Movable());
} else
_M_insert_overflow(__pos, __x, _TrivialCopy(), __n);
}
}
template <class _Tp, class _Alloc>
vector<_Tp, _Alloc>& vector<_Tp, _Alloc>::operator = (const vector<_Tp, _Alloc>& __x) {
if (&__x != this) {
const size_type __xlen = __x.size();
if (__xlen > capacity()) {
size_type __len = __xlen;
pointer __tmp = _M_allocate_and_copy(__len, __CONST_CAST(const_pointer, __x._M_start) + 0,
__CONST_CAST(const_pointer, __x._M_finish) + 0);
_M_clear();
this->_M_start = __tmp;
this->_M_end_of_storage._M_data = this->_M_start + __len;
} else if (size() >= __xlen) {
pointer __i = _STLP_PRIV __copy_ptrs(__CONST_CAST(const_pointer, __x._M_start) + 0,
__CONST_CAST(const_pointer, __x._M_finish) + 0, this->_M_start, _TrivialCopy());
_STLP_STD::_Destroy_Range(__i, this->_M_finish);
} else {
_STLP_PRIV __copy_ptrs(__CONST_CAST(const_pointer, __x._M_start),
__CONST_CAST(const_pointer, __x._M_start) + size(), this->_M_start, _TrivialCopy());
_STLP_PRIV __ucopy_ptrs(__CONST_CAST(const_pointer, __x._M_start) + size(),
__CONST_CAST(const_pointer, __x._M_finish) + 0, this->_M_finish, _TrivialUCopy());
}
this->_M_finish = this->_M_start + __xlen;
}
return *this;
}
template <class _Tp, class _Alloc>
void vector<_Tp, _Alloc>::_M_fill_assign(size_t __n, const _Tp& __val) {
if (__n > capacity()) {
vector<_Tp, _Alloc> __tmp(__n, __val, get_allocator());
__tmp.swap(*this);
} else if (__n > size()) {
fill(begin(), end(), __val);
this->_M_finish = _STLP_PRIV __uninitialized_fill_n(this->_M_finish, __n - size(), __val);
} else
erase(_STLP_PRIV __fill_n(begin(), __n, __val), end());
}
template <class _Tp, class _Alloc>
__iterator__
vector<_Tp, _Alloc>::insert(iterator __pos, const _Tp& __x) {
size_type __n = __pos - begin();
_M_fill_insert(__pos, 1, __x);
return begin() + __n;
}
#undef __iterator__
#if defined (vector)
# undef vector
_STLP_MOVE_TO_STD_NAMESPACE
#endif
_STLP_END_NAMESPACE
#endif /* _STLP_VECTOR_C */
// Local Variables:
// mode:C++
// End:
|
