|
|
|
1 |
|
// memory standard header |
2 |
|
#pragma once |
3 |
|
#ifndef _MEMORY_ |
4 |
|
#define _MEMORY_ |
5 |
|
#ifndef RC_INVOKED |
6 |
|
#include <iterator> |
7 |
|
#include <xmemory> |
8 |
|
|
9 |
|
#ifdef _MSC_VER |
10 |
|
#pragma pack(push,_CRT_PACKING) |
11 |
|
#pragma warning(push,3) |
12 |
|
#endif /* _MSC_VER */ |
13 |
|
_STD_BEGIN |
14 |
|
|
15 |
|
// TEMPLATE FUNCTION get_temporary_buffer |
16 |
|
template<class _Ty> inline |
17 |
|
pair<_Ty _FARQ *, _PDFT> |
18 |
|
get_temporary_buffer(_PDFT _Count) |
19 |
|
{ // get raw temporary buffer of up to _Count elements |
20 |
|
_Ty _FARQ *_Pbuf; |
21 |
|
|
22 |
|
if (_Count <= 0) |
23 |
|
_Count = 0; |
24 |
|
else if (((size_t)(-1) / _Count) < sizeof (_Ty)) |
25 |
|
_THROW_NCEE(std::bad_alloc, NULL); |
26 |
|
|
27 |
|
for (_Pbuf = 0; 0 < _Count; _Count /= 2) |
28 |
|
if ((_Pbuf = (_Ty _FARQ *)operator new( |
29 |
|
(_SIZT)_Count * sizeof (_Ty), nothrow)) != 0) |
30 |
|
break; |
31 |
|
|
32 |
|
return (pair<_Ty _FARQ *, _PDFT>(_Pbuf, _Count)); |
33 |
|
} |
34 |
|
|
35 |
|
// TEMPLATE FUNCTION return_temporary_buffer |
36 |
|
template<class _Ty> inline |
37 |
|
void return_temporary_buffer(_Ty *_Pbuf) |
38 |
|
{ // delete raw temporary buffer |
39 |
|
operator delete(_Pbuf); |
40 |
|
} |
41 |
|
|
42 |
|
// TEMPLATE FUNCTION uninitialized_copy |
43 |
|
template<class _InIt, |
44 |
|
class _FwdIt> inline |
45 |
|
_FwdIt _Uninit_copy(_InIt _First, _InIt _Last, _FwdIt _Dest, |
46 |
|
_Nonscalar_ptr_iterator_tag, _Range_checked_iterator_tag) |
47 |
|
{ // copy [_First, _Last) to raw _Dest, arbitrary type |
48 |
|
_DEBUG_RANGE(_First, _Last); |
49 |
|
_DEBUG_POINTER(_Dest); |
50 |
|
_FwdIt _Next = _Dest; |
51 |
|
|
52 |
|
_TRY_BEGIN |
53 |
|
for (; _First != _Last; ++_Dest, ++_First) |
54 |
|
_Construct(&*_Dest, *_First); |
55 |
|
_CATCH_ALL |
56 |
|
for (; _Next != _Dest; ++_Next) |
57 |
|
_Destroy(&*_Next); |
58 |
|
_RERAISE; |
59 |
|
_CATCH_END |
60 |
|
return (_Dest); |
61 |
|
} |
62 |
|
|
63 |
|
template<class _Ty1, |
64 |
|
class _Ty2> inline |
65 |
|
_Ty2 _Uninit_copy(_Ty1 _First, _Ty1 _Last, _Ty2 _Dest, |
66 |
|
_Scalar_ptr_iterator_tag, _Range_checked_iterator_tag) |
67 |
|
{ // copy [_First, _Last) to raw _Dest, scalar type |
68 |
|
_DEBUG_RANGE(_First, _Last); |
69 |
|
_DEBUG_POINTER(_Dest); |
70 |
|
size_t _Count = (size_t)(_Last - _First); |
71 |
|
_Ty2 _Result = _Dest + _Count; |
72 |
|
if (_Count > 0) |
73 |
|
_CRT_SECURE_MEMMOVE(&*_Dest, |
74 |
|
_Count * sizeof (*_First), &*_First, |
75 |
|
_Count * sizeof (*_First)); // NB: non-overlapping move |
76 |
|
return (_Result); |
77 |
|
} |
78 |
|
|
79 |
|
#if _SECURE_SCL |
80 |
|
|
81 |
|
template<class _InIt, |
82 |
|
class _FwdIt> inline |
83 |
|
_IF_CHK(_FwdIt) uninitialized_copy(_InIt _First, _InIt _Last, _FwdIt _Dest) |
84 |
|
{ // copy [_First, _Last) to raw _Dest |
85 |
|
return (_Uninit_copy(_CHECKED_BASE(_First), _CHECKED_BASE(_Last), _Dest, |
86 |
|
_Ptr_cat(_First, _Dest), _STD _Range_checked_iterator_tag())); |
87 |
|
} |
88 |
|
|
89 |
|
template<class _InIt, class _FwdElem, size_t _Size> |
90 |
|
inline |
91 |
|
_FwdElem* uninitialized_copy(_InIt _First, _InIt _Last, _FwdElem (&_Dest)[_Size]) |
92 |
|
{ // copy [_First, _Last) to raw _Dest |
93 |
|
return (uninitialized_copy(_First, _Last, |
94 |
|
_STDEXT make_checked_array_iterator(_Dest, _Size)).base()); |
95 |
|
} |
96 |
|
|
97 |
|
template<class _InIt, |
98 |
|
class _FwdIt> inline |
99 |
|
_SCL_INSECURE_DEPRECATE |
100 |
|
_IF_NOT_CHK(_FwdIt) uninitialized_copy(_InIt _First, _InIt _Last, _FwdIt _Dest) |
101 |
|
{ // copy [_First, _Last) to raw _Dest |
102 |
|
return (_Uninit_copy(_CHECKED_BASE(_First), _CHECKED_BASE(_Last), _Dest, |
103 |
|
_Ptr_cat(_First, _Dest), _STD _Range_checked_iterator_tag())); |
104 |
|
} |
105 |
|
|
106 |
|
#else |
107 |
|
|
108 |
|
template<class _InIt, |
109 |
|
class _FwdIt> inline |
110 |
|
_FwdIt uninitialized_copy(_InIt _First, _InIt _Last, _FwdIt _Dest) |
111 |
|
{ // copy [_First, _Last) to raw _Dest |
112 |
|
return (_Uninit_copy(_CHECKED_BASE(_First), _CHECKED_BASE(_Last), _Dest, |
113 |
|
_Ptr_cat(_First, _Dest), _STD _Range_checked_iterator_tag())); |
114 |
|
} |
115 |
|
|
116 |
|
#endif |
117 |
|
|
118 |
|
// TEMPLATE FUNCTION _Uninitialized_copy WITH ALLOCATOR |
119 |
|
template<class _InIt, |
120 |
|
class _FwdIt, |
121 |
|
class _Alloc> inline |
122 |
|
_FwdIt _Uninit_copy(_InIt _First, _InIt _Last, _FwdIt _Dest, |
123 |
|
_Alloc& _Al, _Nonscalar_ptr_iterator_tag, _Range_checked_iterator_tag) |
124 |
|
{ // copy [_First, _Last) to raw _Dest, using _Al, arbitrary type |
125 |
|
_DEBUG_RANGE(_First, _Last); |
126 |
|
_DEBUG_POINTER(_Dest); |
127 |
|
_FwdIt _Next = _Dest; |
128 |
|
|
129 |
|
_TRY_BEGIN |
130 |
|
for (; _First != _Last; ++_Dest, ++_First) |
131 |
|
_Al.construct(_Dest, *_First); |
132 |
|
_CATCH_ALL |
133 |
|
for (; _Next != _Dest; ++_Next) |
134 |
|
_Al.destroy(_Next); |
135 |
|
_RERAISE; |
136 |
|
_CATCH_END |
137 |
|
return (_Dest); |
138 |
|
} |
139 |
|
|
140 |
|
template<class _InIt, |
141 |
|
class _FwdIt, |
142 |
|
class _Alloc> inline |
143 |
|
_FwdIt _Uninit_copy(_InIt _First, _InIt _Last, _FwdIt _Dest, |
144 |
|
_Alloc&, _Scalar_ptr_iterator_tag, _Range_checked_iterator_tag) |
145 |
|
{ // copy [_First, _Last) to raw _Dest, scalar type |
146 |
|
_DEBUG_RANGE(_First, _Last); |
147 |
|
_DEBUG_POINTER(_Dest); |
148 |
|
size_t _Count = (size_t)(_Last - _First); |
149 |
|
_FwdIt _Result = _Dest + _Count; |
150 |
|
if (_Count > 0) |
151 |
|
_CRT_SECURE_MEMMOVE(&*_Dest, _Count * sizeof (*_First), &*_First, _Count * sizeof (*_First)); // NB: non-overlapping move |
152 |
|
return (_Result); |
153 |
|
} |
154 |
|
|
155 |
|
#if _SECURE_SCL |
156 |
|
|
157 |
|
template<class _InIt, |
158 |
|
class _FwdIt, |
159 |
|
class _Alloc> inline |
160 |
|
_IF_CHK(_FwdIt) _Uninitialized_copy(_InIt _First, _InIt _Last, _FwdIt _Dest, |
161 |
|
_Alloc& _Al) |
162 |
|
{ // copy [_First, _Last) to raw _Dest, using _Al |
163 |
|
return (_Uninit_copy(_CHECKED_BASE(_First), _CHECKED_BASE(_Last), _Dest, _Al, |
164 |
|
_Ptr_cat(_First, _Dest), _STD _Range_checked_iterator_tag())); |
165 |
|
} |
166 |
|
|
167 |
|
template<class _InIt, class _FwdElem, class _Alloc, size_t _Size> |
168 |
|
inline |
169 |
|
_FwdElem* _Uninitialized_copy(_InIt _First, _InIt _Last, _FwdElem (&_Dest)[_Size], |
170 |
|
_Alloc& _Al) |
171 |
|
{ // copy [_First, _Last) to raw _Dest, using _Al |
172 |
|
return (_Uninitialized_copy(_First, _Last, |
173 |
|
_STDEXT make_checked_array_iterator(_Dest, _Size), _Al).base()); |
174 |
|
} |
175 |
|
|
176 |
|
template<class _InIt, |
177 |
|
class _FwdIt, |
178 |
|
class _Alloc> inline |
179 |
|
_SCL_INSECURE_DEPRECATE |
180 |
|
_IF_NOT_CHK(_FwdIt) _Uninitialized_copy(_InIt _First, _InIt _Last, _FwdIt _Dest, |
181 |
|
_Alloc& _Al) |
182 |
|
{ // copy [_First, _Last) to raw _Dest, using _Al |
183 |
|
return (_Uninit_copy(_CHECKED_BASE(_First), _CHECKED_BASE(_Last), _Dest, _Al, |
184 |
|
_Ptr_cat(_First, _Dest), _STD _Range_checked_iterator_tag())); |
185 |
|
} |
186 |
|
|
187 |
|
#else |
188 |
|
|
189 |
|
template<class _InIt, |
190 |
|
class _FwdIt, |
191 |
|
class _Alloc> inline |
192 |
|
_FwdIt _Uninitialized_copy(_InIt _First, _InIt _Last, _FwdIt _Dest, |
193 |
|
_Alloc& _Al) |
194 |
|
{ // copy [_First, _Last) to raw _Dest, using _Al |
195 |
|
return (_Uninit_copy(_CHECKED_BASE(_First), _CHECKED_BASE(_Last), _Dest, _Al, |
196 |
|
_Ptr_cat(_First, _Dest), _STD _Range_checked_iterator_tag())); |
197 |
|
} |
198 |
|
|
199 |
|
#endif |
200 |
|
|
201 |
|
// TEMPLATE FUNCTION _Uninitialized_move WITH ALLOCATOR |
202 |
|
template<class _InIt, class _FwdIt, class _Alloc, class _MoveCatTy> |
203 |
|
inline |
204 |
|
_FwdIt _Uninit_move(_InIt _First, _InIt _Last, _FwdIt _Dest, |
205 |
|
_Alloc& _Al, _MoveCatTy, _Range_checked_iterator_tag) |
206 |
|
{ // move defaults to copy if there is not a more effecient way |
207 |
|
return (_STDEXT unchecked_uninitialized_copy(_First, _Last, _Dest, _Al)); |
208 |
|
} |
209 |
|
|
210 |
|
template<class _InIt, class _FwdIt, class _Alloc> |
211 |
|
inline |
212 |
|
_FwdIt _Uninit_move(_InIt _First, _InIt _Last, _FwdIt _Dest, |
213 |
|
_Alloc& _Al, _Swap_move_tag, _Range_checked_iterator_tag) |
214 |
|
{ // use swap to instead of the copy constructor |
215 |
|
_DEBUG_RANGE(_First, _Last); |
216 |
|
_DEBUG_POINTER(_Dest); |
217 |
|
_FwdIt _Next = _Dest; |
218 |
|
// empty value used in the construction |
219 |
|
typename _Alloc::value_type _Val; |
220 |
|
|
221 |
|
_TRY_BEGIN |
222 |
|
for (; _First != _Last; ++_Dest, ++_First) |
223 |
|
{ |
224 |
|
_Al.construct(_Dest, _Val); |
225 |
|
_STD _Swap_adl(*_Dest, *_First); |
226 |
|
} |
227 |
|
_CATCH_ALL |
228 |
|
for (; _Next != _Dest; ++_Next) |
229 |
|
_Al.destroy(_Next); |
230 |
|
_RERAISE; |
231 |
|
_CATCH_END |
232 |
|
return (_Dest); |
233 |
|
} |
234 |
|
|
235 |
|
#if _SECURE_SCL |
236 |
|
|
237 |
|
template<class _InIt, class _FwdIt, class _Alloc> |
238 |
|
inline |
239 |
|
_IF_CHK(_FwdIt) _Uninitialized_move(_InIt _First, _InIt _Last, _FwdIt _Dest, |
240 |
|
_Alloc& _Al) |
241 |
|
{ // move [_First, _Last) to raw _Dest, using _Al |
242 |
|
return (_Uninit_move(_CHECKED_BASE(_First), _CHECKED_BASE(_Last), _Dest, _Al, |
243 |
|
_Move_cat(_Dest), _STD _Range_checked_iterator_tag())); |
244 |
|
} |
245 |
|
|
246 |
|
template<class _InIt, class _FwdElem, class _Alloc, size_t _Size> |
247 |
|
inline |
248 |
|
_FwdElem* _Uninitialized_move(_InIt _First, _InIt _Last, _FwdElem (&_Dest)[_Size], |
249 |
|
_Alloc& _Al) |
250 |
|
{ // move [_First, _Last) to raw _Dest, using _Al |
251 |
|
return (_Uninitialized_move(_First, _Last, |
252 |
|
_STDEXT make_checked_array_iterator(_Dest, _Size), _Al).base()); |
253 |
|
} |
254 |
|
|
255 |
|
template<class _InIt, class _FwdIt, class _Alloc> |
256 |
|
inline |
257 |
|
_SCL_INSECURE_DEPRECATE |
258 |
|
_IF_NOT_CHK(_FwdIt) _Uninitialized_move(_InIt _First, _InIt _Last, _FwdIt _Dest, |
259 |
|
_Alloc& _Al) |
260 |
|
{ // move [_First, _Last) to raw _Dest, using _Al |
261 |
|
return (_Uninit_move(_CHECKED_BASE(_First), |
262 |
|
_CHECKED_BASE(_Last), _Dest, _Al, |
263 |
|
_Move_cat(_Dest), _STD _Range_checked_iterator_tag())); |
264 |
|
} |
265 |
|
|
266 |
|
#else |
267 |
|
|
268 |
|
template<class _InIt, class _FwdIt, class _Alloc> |
269 |
|
inline |
270 |
|
_FwdIt _Uninitialized_move(_InIt _First, _InIt _Last, _FwdIt _Dest, |
271 |
|
_Alloc& _Al) |
272 |
|
{ // move [_First, _Last) to raw _Dest, using _Al |
273 |
|
return (_Uninit_move(_CHECKED_BASE(_First), |
274 |
|
_CHECKED_BASE(_Last), _Dest, _Al, |
275 |
|
_Move_cat(_Dest), _STD _Range_checked_iterator_tag())); |
276 |
|
} |
277 |
|
|
278 |
|
#endif |
279 |
|
|
280 |
|
// TEMPLATE FUNCTION uninitialized_fill |
281 |
|
template<class _FwdIt, |
282 |
|
class _Tval> inline |
283 |
|
void _Uninit_fill(_FwdIt _First, _FwdIt _Last, const _Tval& _Val, |
284 |
|
_Nonscalar_ptr_iterator_tag) |
285 |
|
{ // copy _Val throughout raw [_First, _Last), arbitrary type |
286 |
|
_DEBUG_RANGE(_First, _Last); |
287 |
|
_FwdIt _Next = _First; |
288 |
|
|
289 |
|
_TRY_BEGIN |
290 |
|
for (; _First != _Last; ++_First) |
291 |
|
_Construct(&*_First, _Val); |
292 |
|
_CATCH_ALL |
293 |
|
for (; _Next != _First; ++_Next) |
294 |
|
_Destroy(&*_Next); |
295 |
|
_RERAISE; |
296 |
|
_CATCH_END |
297 |
|
} |
298 |
|
|
299 |
|
template<class _Ty, |
300 |
|
class _Tval> inline |
301 |
|
void _Uninit_fill(_Ty *_First, _Ty *_Last, const _Tval& _Val, |
302 |
|
_Scalar_ptr_iterator_tag) |
303 |
|
{ // copy _Val throughout raw [_First, _Last), scalar type |
304 |
|
std::fill(_First, _Last, _Val); |
305 |
|
} |
306 |
|
|
307 |
|
template<class _FwdIt, |
308 |
|
class _Tval> inline |
309 |
|
void uninitialized_fill(_FwdIt _First, _FwdIt _Last, const _Tval& _Val) |
310 |
|
{ // copy _Val throughout raw [_First, _Last) |
311 |
|
_Uninit_fill(_CHECKED_BASE(_First), _CHECKED_BASE(_Last), _Val, _Ptr_cat(_First, _First)); |
312 |
|
} |
313 |
|
|
314 |
|
// TEMPLATE FUNCTION uninitialized_fill_n |
315 |
|
template<class _FwdIt, |
316 |
|
class _Diff, |
317 |
|
class _Tval> inline |
318 |
|
void _Uninit_fill_n(_FwdIt _First, _Diff _Count, const _Tval& _Val, |
319 |
|
_Nonscalar_ptr_iterator_tag, _Range_checked_iterator_tag) |
320 |
|
{ // copy _Count *_Val to raw _First, arbitrary type |
321 |
|
|
322 |
|
#if _HAS_ITERATOR_DEBUGGING |
323 |
|
// if (_Count < 0) |
324 |
|
// _DEBUG_ERROR("negative count in uninitialized fill"); |
325 |
|
#endif /* _HAS_ITERATOR_DEBUGGING */ |
326 |
|
|
327 |
|
_FwdIt _Next = _First; |
328 |
|
|
329 |
|
_TRY_BEGIN |
330 |
|
for (; 0 < _Count; --_Count, ++_First) |
331 |
|
_Construct(&*_First, _Val); |
332 |
|
_CATCH_ALL |
333 |
|
for (; _Next != _First; ++_Next) |
334 |
|
_Destroy(&*_Next); |
335 |
|
_RERAISE; |
336 |
|
_CATCH_END |
337 |
|
} |
338 |
|
|
339 |
|
template<class _FwdIt, |
340 |
|
class _Diff, |
341 |
|
class _Tval> inline |
342 |
|
void _Uninit_fill_n(_FwdIt _First, _Diff _Count, const _Tval& _Val, |
343 |
|
_Scalar_ptr_iterator_tag, _Range_checked_iterator_tag) |
344 |
|
{ // copy _Count *_Val to raw _First, scalar type |
345 |
|
_STDEXT unchecked_fill_n(&*_First, _Count, _Val); |
346 |
|
} |
347 |
|
|
348 |
|
#if _SECURE_SCL |
349 |
|
|
350 |
|
template<class _FwdIt, |
351 |
|
class _Diff, |
352 |
|
class _Tval> inline |
353 |
|
_IF_CHK_(_FwdIt, void) uninitialized_fill_n(_FwdIt _First, _Diff _Count, const _Tval& _Val) |
354 |
|
{ // copy _Count *_Val to raw _First |
355 |
|
_Uninit_fill_n(_First, _Count, _Val, _Ptr_cat(_First, _First), _STD _Range_checked_iterator_tag()); |
356 |
|
} |
357 |
|
|
358 |
|
template<class _FwdElem, class _Diff, class _Tval, size_t _Size> |
359 |
|
inline |
360 |
|
void uninitialized_fill_n(_FwdElem (&_First)[_Size], _Diff _Count, const _Tval& _Val) |
361 |
|
{ // copy _Count *_Val to raw _First |
362 |
|
uninitialized_fill_n(_STDEXT make_checked_array_iterator(_First, _Size), _Count, _Val); |
363 |
|
} |
364 |
|
|
365 |
|
template<class _FwdIt, |
366 |
|
class _Diff, |
367 |
|
class _Tval> inline |
368 |
|
_SCL_INSECURE_DEPRECATE |
369 |
|
_IF_NOT_CHK_(_FwdIt, void) uninitialized_fill_n(_FwdIt _First, _Diff _Count, const _Tval& _Val) |
370 |
|
{ // copy _Count *_Val to raw _First |
371 |
|
_Uninit_fill_n(_First, _Count, _Val, _Ptr_cat(_First, _First), _STD _Range_checked_iterator_tag()); |
372 |
|
} |
373 |
|
|
374 |
|
#else |
375 |
|
|
376 |
|
template<class _FwdIt, |
377 |
|
class _Diff, |
378 |
|
class _Tval> inline |
379 |
|
void uninitialized_fill_n(_FwdIt _First, _Diff _Count, const _Tval& _Val) |
380 |
|
{ // copy _Count *_Val to raw _First |
381 |
|
_Uninit_fill_n(_First, _Count, _Val, _Ptr_cat(_First, _First), _STD _Range_checked_iterator_tag()); |
382 |
|
} |
383 |
|
|
384 |
|
#endif |
385 |
|
|
386 |
|
// TEMPLATE FUNCTION _Uninitialized_fill_n WITH ALLOCATOR |
387 |
|
template<class _FwdIt, |
388 |
|
class _Diff, |
389 |
|
class _Tval, |
390 |
|
class _Alloc> inline |
391 |
|
void _Uninit_fill_n(_FwdIt _First, _Diff _Count, |
392 |
|
const _Tval& _Val, _Alloc& _Al, _Nonscalar_ptr_iterator_tag, _Range_checked_iterator_tag) |
393 |
|
{ // copy _Count *_Val to raw _First, using _Al, arbitrary type |
394 |
|
|
395 |
|
#if _HAS_ITERATOR_DEBUGGING |
396 |
|
// if (_Count < 0) |
397 |
|
// _DEBUG_ERROR("negative count in uninitialized fill"); |
398 |
|
#endif /* _HAS_ITERATOR_DEBUGGING */ |
399 |
|
|
400 |
|
_FwdIt _Next = _First; |
401 |
|
|
402 |
|
_TRY_BEGIN |
403 |
|
for (; 0 < _Count; --_Count, ++_First) |
404 |
|
_Al.construct(_First, _Val); |
405 |
|
_CATCH_ALL |
406 |
|
for (; _Next != _First; ++_Next) |
407 |
|
_Al.destroy(_Next); |
408 |
|
_RERAISE; |
409 |
|
_CATCH_END |
410 |
|
} |
411 |
|
|
412 |
|
template<class _FwdIt, |
413 |
|
class _Diff, |
414 |
|
class _Tval, |
415 |
|
class _Alloc> inline |
416 |
|
void _Uninit_fill_n(_FwdIt _First, _Diff _Count, |
417 |
|
const _Tval& _Val, _Alloc&, _Scalar_ptr_iterator_tag, _Range_checked_iterator_tag) |
418 |
|
{ // copy _Count *_Val to raw _First, using _Al, scalar type |
419 |
|
_STDEXT unchecked_fill_n(_First, _Count, _Val); |
420 |
|
} |
421 |
|
|
422 |
|
#if _SECURE_SCL |
423 |
|
|
424 |
|
template<class _FwdIt, |
425 |
|
class _Diff, |
426 |
|
class _Tval, |
427 |
|
class _Alloc> inline |
428 |
|
_IF_CHK_(_FwdIt, void) _Uninitialized_fill_n(_FwdIt _First, _Diff _Count, |
429 |
|
const _Tval& _Val, _Alloc& _Al) |
430 |
|
{ // copy _Count *_Val to raw _First, using _Al |
431 |
|
_Uninit_fill_n(_First, _Count, _Val, _Al, |
432 |
|
_Ptr_cat(_First, _First), _STD _Range_checked_iterator_tag()); |
433 |
|
} |
434 |
|
|
435 |
|
template<class _FwdElem, class _Diff, class _Tval, class _Alloc, size_t _Size> |
436 |
|
inline |
437 |
|
void _Uninitialized_fill_n(_FwdElem (&_First)[_Size], _Diff _Count, |
438 |
|
const _Tval& _Val, _Alloc& _Al) |
439 |
|
{ // copy _Count *_Val to raw _First, using _Al |
440 |
|
_Uninitialized_fill_n(_STDEXT make_checked_array_iterator(_First, _Size), _Count, _Val, _Al); |
441 |
|
} |
442 |
|
|
443 |
|
template<class _FwdIt, |
444 |
|
class _Diff, |
445 |
|
class _Tval, |
446 |
|
class _Alloc> inline |
447 |
|
_SCL_INSECURE_DEPRECATE |
448 |
|
_IF_NOT_CHK_(_FwdIt, void) _Uninitialized_fill_n(_FwdIt _First, _Diff _Count, |
449 |
|
const _Tval& _Val, _Alloc& _Al) |
450 |
|
{ // copy _Count *_Val to raw _First, using _Al |
451 |
|
_Uninit_fill_n(_First, _Count, _Val, _Al, |
452 |
|
_Ptr_cat(_First, _First), _STD _Range_checked_iterator_tag()); |
453 |
|
} |
454 |
|
|
455 |
|
#else |
456 |
|
|
457 |
|
template<class _FwdIt, |
458 |
|
class _Diff, |
459 |
|
class _Tval, |
460 |
|
class _Alloc> inline |
461 |
|
void _Uninitialized_fill_n(_FwdIt _First, _Diff _Count, |
462 |
|
const _Tval& _Val, _Alloc& _Al) |
463 |
|
{ // copy _Count *_Val to raw _First, using _Al |
464 |
|
_Uninit_fill_n(_First, _Count, _Val, _Al, |
465 |
|
_Ptr_cat(_First, _First), _STD _Range_checked_iterator_tag()); |
466 |
|
} |
467 |
|
|
468 |
|
#endif |
469 |
|
|
470 |
|
// TEMPLATE CLASS raw_storage_iterator |
471 |
|
template<class _FwdIt, |
472 |
|
class _Ty> |
473 |
|
class raw_storage_iterator |
474 |
|
: public _Outit |
475 |
|
{ // wrap stores to raw buffer as output iterator |
476 |
|
public: |
477 |
|
typedef _FwdIt iterator_type; // retained |
478 |
|
typedef _FwdIt iter_type; // retained |
479 |
|
typedef _Ty element_type; // retained |
480 |
|
|
481 |
|
explicit raw_storage_iterator(_FwdIt _First) |
482 |
|
: _Next(_First) |
483 |
|
{ // construct with iterator |
484 |
|
} |
485 |
|
|
486 |
|
raw_storage_iterator<_FwdIt, _Ty>& operator*() |
487 |
|
{ // pretend to return designated value |
488 |
|
return (*this); |
489 |
|
} |
490 |
|
|
491 |
|
raw_storage_iterator<_FwdIt, _Ty>& operator=(const _Ty& _Val) |
492 |
|
{ // construct value designated by stored iterator |
493 |
|
_Construct(&*_Next, _Val); |
494 |
|
return (*this); |
495 |
|
} |
496 |
|
|
497 |
|
raw_storage_iterator<_FwdIt, _Ty>& operator++() |
498 |
|
{ // preincrement |
499 |
|
++_Next; |
500 |
|
return (*this); |
501 |
|
} |
502 |
|
|
503 |
|
raw_storage_iterator<_FwdIt, _Ty> operator++(int) |
504 |
|
{ // postincrement |
505 |
|
raw_storage_iterator<_FwdIt, _Ty> _Ans = *this; |
506 |
|
++_Next; |
507 |
|
return (_Ans); |
508 |
|
} |
509 |
|
|
510 |
|
private: |
511 |
|
_FwdIt _Next; // the stored iterator |
512 |
|
}; |
513 |
|
|
514 |
|
// TEMPLATE CLASS _Temp_iterator |
515 |
|
template<class _Ty> |
516 |
|
class _Temp_iterator |
517 |
|
: public _Outit |
518 |
|
{ // wrap stores to temporary buffer as output iterator |
519 |
|
public: |
520 |
|
typedef _Ty _FARQ *_Pty; |
521 |
|
|
522 |
|
#if _SECURE_SCL |
523 |
|
typedef _Range_checked_iterator_tag _Checked_iterator_category; |
524 |
|
#endif |
525 |
|
|
526 |
|
_Temp_iterator(_PDFT _Count = 0) |
527 |
|
{ // construct from desired temporary buffer size |
528 |
|
_Buf._Begin = 0; |
529 |
|
_Buf._Current = 0; |
530 |
|
_Buf._Hiwater = 0; |
531 |
|
_Buf._Size = _Count; // memorize size for lazy allocation |
532 |
|
_Pbuf = &_Buf; |
533 |
|
} |
534 |
|
|
535 |
|
_Temp_iterator(const _Temp_iterator<_Ty>& _Right) |
536 |
|
{ // construct from _Right (share active buffer) |
537 |
|
_Buf._Begin = 0; // clear stored buffer, for safe destruction |
538 |
|
_Buf._Current = 0; |
539 |
|
_Buf._Hiwater = 0; |
540 |
|
_Buf._Size = 0; |
541 |
|
*this = _Right; |
542 |
|
} |
543 |
|
|
544 |
|
~_Temp_iterator() |
545 |
|
{ // destroy the object |
546 |
|
if (_Buf._Begin != 0) |
547 |
|
{ // destroy any constructed elements in buffer |
548 |
|
for (_Pty _Next = _Buf._Begin; |
549 |
|
_Next != _Buf._Hiwater; ++_Next) |
550 |
|
_Destroy(&*_Next); |
551 |
|
std::return_temporary_buffer(_Buf._Begin); |
552 |
|
} |
553 |
|
} |
554 |
|
|
555 |
|
_Temp_iterator<_Ty>& operator=(const _Temp_iterator<_Ty>& _Right) |
556 |
|
{ // assign _Right (share active buffer) |
557 |
|
_Pbuf = _Right._Pbuf; |
558 |
|
return (*this); |
559 |
|
} |
560 |
|
|
561 |
|
_Temp_iterator<_Ty>& operator=(const _Ty& _Val) |
562 |
|
{ // assign or construct value into active buffer, and increment |
563 |
|
if (_Pbuf->_Current < _Pbuf->_Hiwater) |
564 |
|
*_Pbuf->_Current++ = _Val; // below high water mark, assign |
565 |
|
else |
566 |
|
{ // above high water mark, construct |
567 |
|
_SCL_SECURE_VALIDATE((_Pbuf->_Current - _Pbuf->_Begin) < _Pbuf->_Size); |
568 |
|
_Pty _Ptr = &*_Pbuf->_Current; |
569 |
|
_Construct(_Ptr, _Val); |
570 |
|
_Pbuf->_Hiwater = ++_Pbuf->_Current; |
571 |
|
} |
572 |
|
return (*this); |
573 |
|
} |
574 |
|
|
575 |
|
_Temp_iterator<_Ty>& operator*() |
576 |
|
{ // pretend to return designated value |
577 |
|
return (*this); |
578 |
|
} |
579 |
|
|
580 |
|
_Temp_iterator<_Ty>& operator++() |
581 |
|
{ // pretend to preincrement |
582 |
|
return (*this); |
583 |
|
} |
584 |
|
|
585 |
|
_Temp_iterator<_Ty>& operator++(int) |
586 |
|
{ // pretend to postincrement |
587 |
|
return (*this); |
588 |
|
} |
589 |
|
|
590 |
|
_Temp_iterator<_Ty>& _Init() |
591 |
|
{ // set pointer at beginning of buffer |
592 |
|
_Pbuf->_Current = _Pbuf->_Begin; |
593 |
|
return (*this); |
594 |
|
} |
595 |
|
|
596 |
|
_Pty _First() const |
597 |
|
{ // return pointer to beginning of buffer |
598 |
|
return (_Pbuf->_Begin); |
599 |
|
} |
600 |
|
|
601 |
|
_Pty _Last() const |
602 |
|
{ // return pointer past end of buffer contents |
603 |
|
return (_Pbuf->_Current); |
604 |
|
} |
605 |
|
|
606 |
|
_PDFT _Maxlen() |
607 |
|
{ // return size of buffer |
608 |
|
if (_Pbuf->_Begin == 0 && 0 < _Pbuf->_Size) |
609 |
|
{ // allocate buffer on first size query |
610 |
|
pair<_Pty, _PDFT> _Pair = |
611 |
|
std::get_temporary_buffer<_Ty>(_Pbuf->_Size); |
612 |
|
|
613 |
|
_Pbuf->_Begin = _Pair.first; |
614 |
|
_Pbuf->_Current = _Pair.first; |
615 |
|
_Pbuf->_Hiwater = _Pair.first; |
616 |
|
_Pbuf->_Size = _Pair.second; |
617 |
|
} |
618 |
|
return (_Pbuf->_Size); |
619 |
|
} |
620 |
|
|
621 |
|
static void _Xinvarg() |
622 |
|
{ // report an invalid_argument error |
623 |
|
_THROW(invalid_argument, "invalid _Temp_iterator<T> argument"); |
624 |
|
} |
625 |
|
|
626 |
|
private: |
627 |
|
struct _Bufpar |
628 |
|
{ // control information for a temporary buffer |
629 |
|
_Pty _Begin; // pointer to beginning of buffer |
630 |
|
_Pty _Current; // pointer to next available element |
631 |
|
_Pty _Hiwater; // pointer to first unconstructed element |
632 |
|
_PDFT _Size; // length of buffer |
633 |
|
}; |
634 |
|
_Bufpar _Buf; // buffer control stored in iterator |
635 |
|
_Bufpar *_Pbuf; // pointer to active buffer control |
636 |
|
}; |
637 |
|
|
638 |
|
// TEMPLATE CLASS auto_ptr |
639 |
|
template<class _Ty> |
640 |
|
class auto_ptr; |
641 |
|
|
642 |
|
template<class _Ty> |
643 |
|
struct auto_ptr_ref |
644 |
|
{ // proxy reference for auto_ptr copying |
645 |
|
explicit auto_ptr_ref(_Ty *_Right) |
646 |
|
: _Ref(_Right) |
647 |
|
{ // construct from generic pointer to auto_ptr ptr |
648 |
|
} |
649 |
|
|
650 |
|
_Ty *_Ref; // generic pointer to auto_ptr ptr |
651 |
|
}; |
652 |
|
|
653 |
|
template<class _Ty> |
654 |
|
class auto_ptr |
655 |
|
{ // wrap an object pointer to ensure destruction |
656 |
|
public: |
657 |
|
typedef _Ty element_type; |
658 |
|
|
659 |
|
explicit auto_ptr(_Ty *_Ptr = 0) _THROW0() |
660 |
|
: _Myptr(_Ptr) |
661 |
|
{ // construct from object pointer |
662 |
|
} |
663 |
|
|
664 |
|
auto_ptr(auto_ptr<_Ty>& _Right) _THROW0() |
665 |
|
: _Myptr(_Right.release()) |
666 |
|
{ // construct by assuming pointer from _Right auto_ptr |
667 |
|
} |
668 |
|
|
669 |
|
auto_ptr(auto_ptr_ref<_Ty> _Right) _THROW0() |
670 |
|
{ // construct by assuming pointer from _Right auto_ptr_ref |
671 |
|
_Ty *_Ptr = _Right._Ref; |
672 |
|
_Right._Ref = 0; // release old |
673 |
|
_Myptr = _Ptr; // reset this |
674 |
|
} |
675 |
|
|
676 |
|
template<class _Other> |
677 |
|
operator auto_ptr<_Other>() _THROW0() |
678 |
|
{ // convert to compatible auto_ptr |
679 |
|
return (auto_ptr<_Other>(*this)); |
680 |
|
} |
681 |
|
|
682 |
|
template<class _Other> |
683 |
|
operator auto_ptr_ref<_Other>() _THROW0() |
684 |
|
{ // convert to compatible auto_ptr_ref |
685 |
|
_Other *_Cvtptr = _Myptr; // test implicit conversion |
686 |
|
auto_ptr_ref<_Other> _Ans(_Cvtptr); |
687 |
|
_Myptr = 0; // pass ownership to auto_ptr_ref |
688 |
|
return (_Ans); |
689 |
|
} |
690 |
|
|
691 |
|
|
692 |
|
template<class _Other> |
693 |
|
auto_ptr<_Ty>& operator=(auto_ptr<_Other>& _Right) _THROW0() |
694 |
|
{ // assign compatible _Right (assume pointer) |
695 |
|
reset(_Right.release()); |
696 |
|
return (*this); |
697 |
|
} |
698 |
|
|
699 |
|
template<class _Other> |
700 |
|
auto_ptr(auto_ptr<_Other>& _Right) _THROW0() |
701 |
|
: _Myptr(_Right.release()) |
702 |
|
{ // construct by assuming pointer from _Right |
703 |
|
} |
704 |
|
|
705 |
|
auto_ptr<_Ty>& operator=(auto_ptr<_Ty>& _Right) _THROW0() |
706 |
|
{ // assign compatible _Right (assume pointer) |
707 |
|
reset(_Right.release()); |
708 |
|
return (*this); |
709 |
|
} |
710 |
|
|
711 |
|
auto_ptr<_Ty>& operator=(auto_ptr_ref<_Ty> _Right) _THROW0() |
712 |
|
{ // assign compatible _Right._Ref (assume pointer) |
713 |
|
_Ty *_Ptr = _Right._Ref; |
714 |
|
_Right._Ref = 0; // release old |
715 |
|
reset(_Ptr); // set new |
716 |
|
return (*this); |
717 |
|
} |
718 |
|
|
719 |
|
~auto_ptr() |
720 |
|
{ // destroy the object |
721 |
|
delete _Myptr; |
722 |
|
} |
723 |
|
|
724 |
|
_Ty& operator*() const _THROW0() |
725 |
|
{ // return designated value |
726 |
|
|
727 |
|
#if _HAS_ITERATOR_DEBUGGING |
728 |
|
if (_Myptr == 0) |
729 |
|
_DEBUG_ERROR("auto_ptr not dereferencable"); |
730 |
|
#endif /* _HAS_ITERATOR_DEBUGGING */ |
731 |
|
|
732 |
|
__analysis_assume(_Myptr); |
733 |
|
|
734 |
|
return (*get()); |
735 |
|
} |
736 |
|
|
737 |
|
_Ty *operator->() const _THROW0() |
738 |
|
{ // return pointer to class object |
739 |
|
|
740 |
|
#if _HAS_ITERATOR_DEBUGGING |
741 |
|
if (_Myptr == 0) |
742 |
|
_DEBUG_ERROR("auto_ptr not dereferencable"); |
743 |
|
#endif /* _HAS_ITERATOR_DEBUGGING */ |
744 |
|
|
745 |
|
return (get()); |
746 |
|
} |
747 |
|
|
748 |
|
_Ty *get() const _THROW0() |
749 |
|
{ // return wrapped pointer |
750 |
|
return (_Myptr); |
751 |
|
} |
752 |
|
|
753 |
|
_Ty *release() _THROW0() |
754 |
|
{ // return wrapped pointer and give up ownership |
755 |
|
_Ty *_Tmp = _Myptr; |
756 |
|
_Myptr = 0; |
757 |
|
return (_Tmp); |
758 |
|
} |
759 |
|
|
760 |
|
void reset(_Ty* _Ptr = 0) |
761 |
|
{ // destroy designated object and store new pointer |
762 |
|
if (_Ptr != _Myptr) |
763 |
|
delete _Myptr; |
764 |
|
_Myptr = _Ptr; |
765 |
|
} |
766 |
|
|
767 |
|
private: |
768 |
|
_Ty *_Myptr; // the wrapped object pointer |
769 |
|
}; |
770 |
|
_STD_END |
771 |
|
|
772 |
|
_STDEXT_BEGIN |
773 |
|
|
774 |
|
template<class _InIt, |
775 |
|
class _FwdIt> inline |
776 |
|
_FwdIt unchecked_uninitialized_copy(_InIt _First, _InIt _Last, |
777 |
|
_FwdIt _Dest) |
778 |
|
{ // copy [_First, _Last) to raw _Dest |
779 |
|
return (_STD _Uninit_copy(_CHECKED_BASE(_First), |
780 |
|
_CHECKED_BASE(_Last), _Dest, |
781 |
|
_STD _Ptr_cat(_First, _Dest), |
782 |
|
_STD _Range_checked_iterator_tag())); |
783 |
|
} |
784 |
|
|
785 |
|
template<class _InIt, |
786 |
|
class _FwdIt> inline |
787 |
|
_IF_CHK(_FwdIt) checked_uninitialized_copy(_InIt _First, _InIt _Last, |
788 |
|
_FwdIt _Dest) |
789 |
|
{ // copy [_First, _Last) to raw _Dest |
790 |
|
return (_STD _Uninit_copy(_CHECKED_BASE(_First), |
791 |
|
_CHECKED_BASE(_Last), _Dest, |
792 |
|
_STD _Ptr_cat(_First, _Dest), |
793 |
|
_STD _Range_checked_iterator_tag())); |
794 |
|
} |
795 |
|
|
796 |
|
template<class _InIt, class _FwdElem, size_t _Size> inline |
797 |
|
_FwdElem *checked_uninitialized_copy(_InIt _First, _InIt _Last, |
798 |
|
_FwdElem (&_Dest)[_Size]) |
799 |
|
{ // copy [_First, _Last) to raw _Dest |
800 |
|
return (checked_uninitialized_copy(_First, _Last, |
801 |
|
_STDEXT make_checked_array_iterator(_Dest, _Size)).base()); |
802 |
|
} |
803 |
|
|
804 |
|
template<class _InIt, |
805 |
|
class _FwdIt> inline |
806 |
|
_SCL_CHECKED_ALGORITHM_WARN _IF_NOT_CHK(_FwdIt) |
807 |
|
checked_uninitialized_copy(_InIt _First, _InIt _Last, _FwdIt _Dest) |
808 |
|
{ // copy [_First, _Last) to raw _Dest |
809 |
|
return (_STD _Uninit_copy(_CHECKED_BASE(_First), |
810 |
|
_CHECKED_BASE(_Last), _Dest, |
811 |
|
_STD _Ptr_cat(_First, _Dest), _STD _Range_checked_iterator_tag())); |
812 |
|
} |
813 |
|
|
814 |
|
template<class _InIt, |
815 |
|
class _FwdIt, |
816 |
|
class _Alloc> inline |
817 |
|
_FwdIt unchecked_uninitialized_copy(_InIt _First, _InIt _Last, |
818 |
|
_FwdIt _Dest, _Alloc& _Al) |
819 |
|
{ // copy [_First, _Last) to raw _Dest, using _Al |
820 |
|
return (_STD _Uninit_copy(_CHECKED_BASE(_First), |
821 |
|
_CHECKED_BASE(_Last), _Dest, _Al, |
822 |
|
_STD _Ptr_cat(_First, _Dest), _STD _Range_checked_iterator_tag())); |
823 |
|
} |
824 |
|
|
825 |
|
template<class _InIt, |
826 |
|
class _FwdIt, |
827 |
|
class _Alloc> inline |
828 |
|
_IF_CHK(_FwdIt) checked_uninitialized_copy(_InIt _First, _InIt _Last, |
829 |
|
_FwdIt _Dest, _Alloc& _Al) |
830 |
|
{ // copy [_First, _Last) to raw _Dest, using _Al |
831 |
|
return (_STD _Uninit_copy(_CHECKED_BASE(_First), _CHECKED_BASE(_Last), |
832 |
|
_Dest, _Al, |
833 |
|
_STD _Ptr_cat(_First, _Dest), _STD _Range_checked_iterator_tag())); |
834 |
|
} |
835 |
|
|
836 |
|
template<class _InIt, class _FwdElem, class _Alloc, size_t _Size> inline |
837 |
|
_FwdElem *checked_uninitialized_copy(_InIt _First, _InIt _Last, |
838 |
|
_FwdElem (&_Dest)[_Size], _Alloc& _Al) |
839 |
|
{ // copy [_First, _Last) to raw _Dest, using _Al |
840 |
|
return (checked_uninitialized_copy(_First, _Last, |
841 |
|
_STDEXT make_checked_array_iterator(_Dest, _Size), _Al).base()); |
842 |
|
} |
843 |
|
|
844 |
|
template<class _InIt, |
845 |
|
class _FwdIt, |
846 |
|
class _Alloc> inline |
847 |
|
_SCL_CHECKED_ALGORITHM_WARN _IF_NOT_CHK(_FwdIt) |
848 |
|
checked_uninitialized_copy(_InIt _First, _InIt _Last, |
849 |
|
_FwdIt _Dest, _Alloc& _Al) |
850 |
|
{ // copy [_First, _Last) to raw _Dest, using _Al |
851 |
|
return (_STD _Uninit_copy(_CHECKED_BASE(_First), _CHECKED_BASE(_Last), |
852 |
|
_Dest, _Al, |
853 |
|
_STD _Ptr_cat(_First, _Dest), _STD _Range_checked_iterator_tag())); |
854 |
|
} |
855 |
|
|
856 |
|
template<class _InIt, |
857 |
|
class _FwdIt, |
858 |
|
class _Alloc> inline |
859 |
|
_FwdIt _Unchecked_uninitialized_move(_InIt _First, _InIt _Last, |
860 |
|
_FwdIt _Dest, _Alloc& _Al) |
861 |
|
{ // move [_First, _Last) to raw _Dest, using _Al |
862 |
|
return (_STD _Uninit_move(_CHECKED_BASE(_First), |
863 |
|
_CHECKED_BASE(_Last), _Dest, _Al, |
864 |
|
_STD _Move_cat(_Dest), _STD _Range_checked_iterator_tag())); |
865 |
|
} |
866 |
|
|
867 |
|
template<class _InIt, class _FwdIt, class _Alloc> inline |
868 |
|
_IF_CHK(_FwdIt) _Checked_uninitialized_move(_InIt _First, _InIt _Last, |
869 |
|
_FwdIt _Dest, _Alloc& _Al) |
870 |
|
{ // move [_First, _Last) to raw _Dest, using _Al |
871 |
|
return (_STD _Uninit_move(_CHECKED_BASE(_First), _CHECKED_BASE(_Last), |
872 |
|
_Dest, _Al, |
873 |
|
_STD _Move_cat(_Dest), _STD _Range_checked_iterator_tag())); |
874 |
|
} |
875 |
|
|
876 |
|
template<class _InIt, class _FwdElem, class _Alloc, size_t _Size> inline |
877 |
|
_FwdElem *_Checked_uninitialized_move(_InIt _First, _InIt _Last, |
878 |
|
_FwdElem (&_Dest)[_Size], _Alloc& _Al) |
879 |
|
{ // move [_First, _Last) to raw _Dest, using _Al |
880 |
|
return (_Checked_uninitialized_move(_First, _Last, |
881 |
|
_STDEXT make_checked_array_iterator(_Dest, _Size), _Al).base()); |
882 |
|
} |
883 |
|
|
884 |
|
template<class _InIt, class _FwdIt, class _Alloc> inline |
885 |
|
_SCL_CHECKED_ALGORITHM_WARN _IF_NOT_CHK(_FwdIt) |
886 |
|
_Checked_uninitialized_move(_InIt _First, _InIt _Last, |
887 |
|
_FwdIt _Dest, _Alloc& _Al) |
888 |
|
{ // move [_First, _Last) to raw _Dest, using _Al |
889 |
|
return (_STD _Uninit_move(_CHECKED_BASE(_First), _CHECKED_BASE(_Last), |
890 |
|
_Dest, _Al, |
891 |
|
_STD _Move_cat(_Dest), _STD _Range_checked_iterator_tag())); |
892 |
|
} |
893 |
|
|
894 |
|
template<class _FwdIt, |
895 |
|
class _Diff, |
896 |
|
class _Tval> inline |
897 |
|
void unchecked_uninitialized_fill_n(_FwdIt _First, _Diff _Count, |
898 |
|
const _Tval& _Val) |
899 |
|
{ // copy _Count *_Val to raw _First |
900 |
|
_STD _Uninit_fill_n(_First, _Count, _Val, |
901 |
|
_STD _Ptr_cat(_First, _First), _STD _Range_checked_iterator_tag()); |
902 |
|
} |
903 |
|
|
904 |
|
template<class _FwdIt, |
905 |
|
class _Diff, |
906 |
|
class _Tval> inline |
907 |
|
_IF_CHK_(_FwdIt, void) |
908 |
|
checked_uninitialized_fill_n(_FwdIt _First, _Diff _Count, |
909 |
|
const _Tval& _Val) |
910 |
|
{ // copy _Count *_Val to raw _First |
911 |
|
_STD _Uninit_fill_n(_First, _Count, _Val, |
912 |
|
_STD _Ptr_cat(_First, _First), _STD _Range_checked_iterator_tag()); |
913 |
|
} |
914 |
|
|
915 |
|
template<class _FwdElem, class _Diff, class _Tval, size_t _Size> inline |
916 |
|
void checked_uninitialized_fill_n(_FwdElem (&_First)[_Size], |
917 |
|
_Diff _Count, const _Tval& _Val) |
918 |
|
{ // copy _Count *_Val to raw _First |
919 |
|
checked_uninitialized_fill_n( |
920 |
|
_STDEXT make_checked_array_iterator(_First, _Size), _Count, _Val); |
921 |
|
} |
922 |
|
|
923 |
|
template<class _FwdIt, |
924 |
|
class _Diff, |
925 |
|
class _Tval> inline |
926 |
|
_SCL_CHECKED_ALGORITHM_WARN _IF_NOT_CHK_(_FwdIt, void) |
927 |
|
checked_uninitialized_fill_n(_FwdIt _First, _Diff _Count, |
928 |
|
const _Tval& _Val) |
929 |
|
{ // copy _Count *_Val to raw _First |
930 |
|
_STD _Uninit_fill_n(_First, _Count, _Val, |
931 |
|
_STD _Ptr_cat(_First, _First), _STD _Range_checked_iterator_tag()); |
932 |
|
} |
933 |
|
|
934 |
|
template<class _FwdIt, |
935 |
|
class _Diff, |
936 |
|
class _Tval, |
937 |
|
class _Alloc> inline |
938 |
|
void unchecked_uninitialized_fill_n(_FwdIt _First, _Diff _Count, |
939 |
|
const _Tval& _Val, _Alloc& _Al) |
940 |
|
{ // copy _Count *_Val to raw _First, using _Al |
941 |
|
_STD _Uninit_fill_n(_First, _Count, _Val, _Al, |
942 |
|
_STD _Ptr_cat(_First, _First), _STD _Range_checked_iterator_tag()); |
943 |
|
} |
944 |
|
|
945 |
|
template<class _FwdIt, |
946 |
|
class _Diff, |
947 |
|
class _Tval, |
948 |
|
class _Alloc> inline |
949 |
|
_IF_CHK_(_FwdIt, void) |
950 |
|
checked_uninitialized_fill_n(_FwdIt _First, _Diff _Count, |
951 |
|
const _Tval& _Val, _Alloc& _Al) |
952 |
|
{ // copy _Count *_Val to raw _First, using _Al |
953 |
|
_STD _Uninit_fill_n(_First, _Count, _Val, _Al, |
954 |
|
_STD _Ptr_cat(_First, _First), _STD _Range_checked_iterator_tag()); |
955 |
|
} |
956 |
|
|
957 |
|
template<class _FwdElem, |
958 |
|
class _Diff, |
959 |
|
class _Tval, |
960 |
|
class _Alloc, |
961 |
|
size_t _Size> inline |
962 |
|
void checked_uninitialized_fill_n(_FwdElem (&_First)[_Size], |
963 |
|
_Diff _Count, const _Tval& _Val, _Alloc& _Al) |
964 |
|
{ // copy _Count *_Val to raw _First, using _Al |
965 |
|
checked_uninitialized_fill_n( |
966 |
|
_STDEXT make_checked_array_iterator(_First, _Size), |
967 |
|
_Count, _Val, _Al); |
968 |
|
} |
969 |
|
|
970 |
|
template<class _FwdIt, |
971 |
|
class _Diff, |
972 |
|
class _Tval, |
973 |
|
class _Alloc> inline |
974 |
|
_SCL_CHECKED_ALGORITHM_WARN _IF_NOT_CHK_(_FwdIt, void) |
975 |
|
checked_uninitialized_fill_n(_FwdIt _First, _Diff _Count, |
976 |
|
const _Tval& _Val, _Alloc& _Al) |
977 |
|
{ // copy _Count *_Val to raw _First, using _Al |
978 |
|
_STD _Uninit_fill_n(_First, _Count, _Val, _Al, |
979 |
|
_STD _Ptr_cat(_First, _First), _STD _Range_checked_iterator_tag()); |
980 |
|
} |
981 |
|
|
982 |
|
_STDEXT_END |
983 |
|
|
984 |
|
#if _HAS_TR1 |
985 |
|
#ifndef _XSTD2 |
986 |
|
#define _XSTD2 |
987 |
|
#endif /* _XSTD2 */ |
988 |
|
|
989 |
|
#include <exception> |
990 |
|
#include <typeinfo> |
991 |
|
|
992 |
|
#ifndef _DO_NOT_DECLARE_INTERLOCKED_INTRINSICS_IN_MEMORY |
993 |
|
extern "C" long __CLRCALL_PURE_OR_CDECL _InterlockedIncrement(volatile long *); |
994 |
|
extern "C" long __CLRCALL_PURE_OR_CDECL _InterlockedDecrement(volatile long *); |
995 |
|
extern "C" long __CLRCALL_PURE_OR_CDECL _InterlockedCompareExchange(volatile long *, |
996 |
|
long, long); |
997 |
|
|
998 |
|
#pragma intrinsic(_InterlockedIncrement) |
999 |
|
#pragma intrinsic(_InterlockedDecrement) |
1000 |
|
#pragma intrinsic(_InterlockedCompareExchange) |
1001 |
|
#endif /* _DO_NOT_DECLARE_INTERLOCKED_INTRINSICS_IN_MEMORY */ |
1002 |
|
|
1003 |
|
#define _MT_INCR(mtx, x) _InterlockedIncrement(&x) |
1004 |
|
#define _MT_DECR(mtx, x) _InterlockedDecrement(&x) |
1005 |
|
#define _MT_CMPX(x, y, z) _InterlockedCompareExchange(&x, y, z) |
1006 |
|
|
1007 |
|
_STD_BEGIN |
1008 |
|
namespace tr1 { // TR1 additions |
1009 |
|
|
1010 |
|
// CLASS bad_weak_ptr |
1011 |
|
class bad_weak_ptr |
1012 |
|
: public _XSTD exception |
1013 |
|
{ // exception type for invalid use of expired weak_ptr object |
1014 |
|
public: |
1015 |
|
explicit bad_weak_ptr(const char * = 0) |
1016 |
|
{ // construct with ignored message |
1017 |
|
} |
1018 |
|
|
1019 |
|
virtual const char *__CLR_OR_THIS_CALL what() const _THROW0() |
1020 |
|
{ // return pointer to message string |
1021 |
|
return ("tr1::bad_weak_ptr"); |
1022 |
|
} |
1023 |
|
}; |
1024 |
|
|
1025 |
|
_CRTIMP2_PURE __declspec(noreturn) void __CLRCALL_PURE_OR_CDECL _Xweak(); |
1026 |
|
|
1027 |
|
// CLASS _Ref_count_base |
1028 |
|
class _Ref_count_base |
1029 |
|
{ // common code for reference counting |
1030 |
|
private: |
1031 |
|
virtual void _Destroy() = 0; |
1032 |
|
virtual void _Delete_this() = 0; |
1033 |
|
|
1034 |
|
const volatile void *_Ptr; |
1035 |
|
long _Uses; |
1036 |
|
long _Weaks; |
1037 |
|
|
1038 |
|
protected: |
1039 |
|
_Ref_count_base(const volatile void *_Px) |
1040 |
|
: _Ptr(_Px), _Uses(0), _Weaks(1) |
1041 |
|
{ // construct |
1042 |
|
} |