1 : // xmemory internal header (from <memory>)
2 : #pragma once
3 : #ifndef _XMEMORY_
4 : #define _XMEMORY_
5 : #ifndef RC_INVOKED
6 : #include <cstdlib>
7 : #include <exception>
8 : #include <new>
9 : #include <xutility>
10 :
11 : #ifdef _MSC_VER
12 : #pragma pack(push,_CRT_PACKING)
13 : #pragma warning(push,3)
14 : #pragma warning(disable: 4100)
15 : #endif /* _MSC_VER */
16 :
17 : #ifndef _FARQ /* specify standard memory model */
18 : #define _FARQ
19 : #define _PDFT ptrdiff_t
20 : #define _SIZT size_t
21 : #endif /* _FARQ */
22 :
23 : #define _CPOINTER_X(T, A) \
24 : typename A::template rebind<T>::other::const_pointer
25 : #define _CREFERENCE_X(T, A) \
26 : typename A::template rebind<T>::other::const_reference
27 : #define _POINTER_X(T, A) \
28 : typename A::template rebind<T>::other::pointer
29 : #define _REFERENCE_X(T, A) \
30 : typename A::template rebind<T>::other::reference
31 :
32 : _STD_BEGIN
33 : // TEMPLATE FUNCTION _Allocate
34 : template<class _Ty> inline
35 : _Ty _FARQ *_Allocate(_SIZT _Count, _Ty _FARQ *)
36 74 : { // check for integer overflow
37 74 : if (_Count <= 0)
38 0 : _Count = 0;
39 74 : else if (((_SIZT)(-1) / _Count) < sizeof (_Ty))
40 0 : _THROW_NCEE(std::bad_alloc, NULL);
41 :
42 : // allocate storage for _Count elements of type _Ty
43 74 : return ((_Ty _FARQ *)::operator new(_Count * sizeof (_Ty)));
44 74 : }
45 :
46 : // TEMPLATE FUNCTION _Construct
47 : template<class _T1,
48 : class _T2> inline
49 : void _Construct(_T1 _FARQ *_Ptr, const _T2& _Val)
50 15 : { // construct object at _Ptr with value _Val
51 15 : void _FARQ *_Vptr = _Ptr;
52 15 : ::new (_Vptr) _T1(_Val);
53 15 : }
54 :
55 : // TEMPLATE FUNCTION _Destroy
56 : template<class _Ty> inline
57 : void _Destroy(_Ty _FARQ *_Ptr)
58 15 : { // destroy object at _Ptr
59 12 : _DESTRUCTOR(_Ty, _Ptr);
60 15 : }
61 :
62 : template<> inline
63 : void _Destroy(char _FARQ *)
64 : { // destroy a char (do nothing)
65 : }
66 :
67 : template<> inline
68 : void _Destroy(wchar_t _FARQ *)
69 : { // destroy a wchar_t (do nothing)
70 : }
71 :
72 :
73 : // TEMPLATE CLASS _Allocator_base
74 : template<class _Ty>
75 : struct _Allocator_base
76 : { // base class for generic allocators
77 : typedef _Ty value_type;
78 : };
79 :
80 : // TEMPLATE CLASS _Allocator_base<const _Ty>
81 : template<class _Ty>
82 : struct _Allocator_base<const _Ty>
83 : { // base class for generic allocators for const _Ty
84 : typedef _Ty value_type;
85 : };
86 :
87 : // TEMPLATE CLASS allocator
88 : template<class _Ty>
89 : class allocator
90 : : public _Allocator_base<_Ty>
91 : { // generic allocator for objects of class _Ty
92 : public:
93 : typedef _Allocator_base<_Ty> _Mybase;
94 : typedef typename _Mybase::value_type value_type;
95 : typedef value_type _FARQ *pointer;
96 : typedef value_type _FARQ& reference;
97 : typedef const value_type _FARQ *const_pointer;
98 : typedef const value_type _FARQ& const_reference;
99 :
100 : typedef _SIZT size_type;
101 : typedef _PDFT difference_type;
102 :
103 : template<class _Other>
104 : struct rebind
105 : { // convert an allocator<_Ty> to an allocator <_Other>
106 : typedef allocator<_Other> other;
107 : };
108 :
109 : pointer address(reference _Val) const
110 : { // return address of mutable _Val
111 : return (&_Val);
112 : }
113 :
114 : const_pointer address(const_reference _Val) const
115 : { // return address of nonmutable _Val
116 : return (&_Val);
117 : }
118 :
119 121 : allocator() _THROW0()
120 : { // construct default allocator (do nothing)
121 121 : }
122 :
123 121 : allocator(const allocator<_Ty>&) _THROW0()
124 : { // construct by copying (do nothing)
125 121 : }
126 :
127 : template<class _Other>
128 4 : allocator(const allocator<_Other>&) _THROW0()
129 : { // construct from a related allocator (do nothing)
130 4 : }
131 :
132 : template<class _Other>
133 : allocator<_Ty>& operator=(const allocator<_Other>&)
134 : { // assign from a related allocator (do nothing)
135 : return (*this);
136 : }
137 :
138 : void deallocate(pointer _Ptr, size_type)
139 73 : { // deallocate object at _Ptr, ignore size
140 73 : ::operator delete(_Ptr);
141 73 : }
142 :
143 : pointer allocate(size_type _Count)
144 74 : { // allocate array of _Count elements
145 74 : return (_Allocate(_Count, (pointer)0));
146 74 : }
147 :
148 : pointer allocate(size_type _Count, const void _FARQ *)
149 : { // allocate array of _Count elements, ignore hint
150 : return (allocate(_Count));
151 : }
152 :
153 : void construct(pointer _Ptr, const _Ty& _Val)
154 15 : { // construct object at _Ptr with value _Val
155 15 : _Construct(_Ptr, _Val);
156 15 : }
157 :
158 : void destroy(pointer _Ptr)
159 15 : { // destroy object at _Ptr
160 15 : _Destroy(_Ptr);
161 15 : }
162 :
163 : _SIZT max_size() const _THROW0()
164 75 : { // estimate maximum array size
165 75 : _SIZT _Count = (_SIZT)(-1) / sizeof (_Ty);
166 75 : return (0 < _Count ? _Count : 1);
167 75 : }
168 : };
169 :
170 : // allocator TEMPLATE OPERATORS
171 : template<class _Ty,
172 : class _Other> inline
173 : bool operator==(const allocator<_Ty>&, const allocator<_Other>&) _THROW0()
174 5 : { // test for allocator equality (always true)
175 5 : return (true);
176 5 : }
177 :
178 : template<class _Ty,
179 : class _Other> inline
180 : bool operator!=(const allocator<_Ty>&, const allocator<_Other>&) _THROW0()
181 : { // test for allocator inequality (always false)
182 : return (false);
183 : }
184 :
185 : // CLASS allocator<void>
186 : template<> class _CRTIMP2_PURE allocator<void>
187 : { // generic allocator for type void
188 : public:
189 : typedef void _Ty;
190 : typedef _Ty _FARQ *pointer;
191 : typedef const _Ty _FARQ *const_pointer;
192 : typedef _Ty value_type;
193 :
194 : template<class _Other>
195 : struct rebind
196 : { // convert an allocator<void> to an allocator <_Other>
197 : typedef allocator<_Other> other;
198 : };
199 :
200 : allocator() _THROW0()
201 : { // construct default allocator (do nothing)
202 : }
203 :
204 : allocator(const allocator<_Ty>&) _THROW0()
205 : { // construct by copying (do nothing)
206 : }
207 :
208 : template<class _Other>
209 : allocator(const allocator<_Other>&) _THROW0()
210 : { // construct from related allocator (do nothing)
211 : }
212 :
213 : template<class _Other>
214 : allocator<_Ty>& operator=(const allocator<_Other>&)
215 : { // assign from a related allocator (do nothing)
216 : return (*this);
217 : }
218 : };
219 :
220 : // TEMPLATE FUNCTION _Destroy_range
221 : template<class _Alloc> inline
222 : void _Destroy_range(typename _Alloc::pointer _First,
223 : typename _Alloc::pointer _Last, _Alloc& _Al)
224 54 : { // destroy [_First, _Last)
225 54 : _Destroy_range(_First, _Last, _Al, _Ptr_cat(_First, _Last));
226 54 : }
227 :
228 : template<class _Alloc> inline
229 : void _Destroy_range(typename _Alloc::pointer _First,
230 : typename _Alloc::pointer _Last, _Alloc& _Al,
231 : _Nonscalar_ptr_iterator_tag)
232 13 : { // destroy [_First, _Last), arbitrary type
233 13 : for (; _First != _Last; ++_First)
234 13 : _Al.destroy(_First);
235 13 : }
236 :
237 : template<class _Alloc> inline
238 : void _Destroy_range(typename _Alloc::pointer _First,
239 : typename _Alloc::pointer _Last, _Alloc& _Al,
240 : _Scalar_ptr_iterator_tag)
241 41 : { // destroy [_First, _Last), scalar type (do nothing)
242 41 : }
243 : _STD_END
244 :
245 : #ifdef _MSC_VER
246 : #pragma warning(default: 4100)
247 : #pragma warning(pop)
248 : #pragma pack(pop)
249 : #endif /* _MSC_VER */
250 :
251 : #endif /* RC_INVOKED */
252 : #endif /* _XMEMORY_ */
253 :
254 : /*
255 : * Copyright (c) 1992-2007 by P.J. Plauger. ALL RIGHTS RESERVED.
256 : * Consult your license regarding permissions and restrictions.
257 : */
258 :
259 : /*
260 : * This file is derived from software bearing the following
261 : * restrictions:
262 : *
263 : * Copyright (c) 1994
264 : * Hewlett-Packard Company
265 : *
266 : * Permission to use, copy, modify, distribute and sell this
267 : * software and its documentation for any purpose is hereby
268 : * granted without fee, provided that the above copyright notice
269 : * appear in all copies and that both that copyright notice and
270 : * this permission notice appear in supporting documentation.
271 : * Hewlett-Packard Company makes no representations about the
272 : * suitability of this software for any purpose. It is provided
273 : * "as is" without express or implied warranty.
274 : V5.03:0009 */
|
