diff options
Diffstat (limited to 'libraries/irrlicht-1.8/include/irrList.h')
-rw-r--r-- | libraries/irrlicht-1.8/include/irrList.h | 832 |
1 files changed, 416 insertions, 416 deletions
diff --git a/libraries/irrlicht-1.8/include/irrList.h b/libraries/irrlicht-1.8/include/irrList.h index 54eed83..a84afd5 100644 --- a/libraries/irrlicht-1.8/include/irrList.h +++ b/libraries/irrlicht-1.8/include/irrList.h | |||
@@ -1,416 +1,416 @@ | |||
1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt | 1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt |
2 | // This file is part of the "Irrlicht Engine". | 2 | // This file is part of the "Irrlicht Engine". |
3 | // For conditions of distribution and use, see copyright notice in irrlicht.h | 3 | // For conditions of distribution and use, see copyright notice in irrlicht.h |
4 | 4 | ||
5 | #ifndef __IRR_LIST_H_INCLUDED__ | 5 | #ifndef __IRR_LIST_H_INCLUDED__ |
6 | #define __IRR_LIST_H_INCLUDED__ | 6 | #define __IRR_LIST_H_INCLUDED__ |
7 | 7 | ||
8 | #include "irrTypes.h" | 8 | #include "irrTypes.h" |
9 | #include "irrAllocator.h" | 9 | #include "irrAllocator.h" |
10 | #include "irrMath.h" | 10 | #include "irrMath.h" |
11 | 11 | ||
12 | namespace irr | 12 | namespace irr |
13 | { | 13 | { |
14 | namespace core | 14 | namespace core |
15 | { | 15 | { |
16 | 16 | ||
17 | 17 | ||
18 | //! Doubly linked list template. | 18 | //! Doubly linked list template. |
19 | template <class T> | 19 | template <class T> |
20 | class list | 20 | class list |
21 | { | 21 | { |
22 | private: | 22 | private: |
23 | 23 | ||
24 | //! List element node with pointer to previous and next element in the list. | 24 | //! List element node with pointer to previous and next element in the list. |
25 | struct SKListNode | 25 | struct SKListNode |
26 | { | 26 | { |
27 | SKListNode(const T& e) : Next(0), Prev(0), Element(e) {} | 27 | SKListNode(const T& e) : Next(0), Prev(0), Element(e) {} |
28 | 28 | ||
29 | SKListNode* Next; | 29 | SKListNode* Next; |
30 | SKListNode* Prev; | 30 | SKListNode* Prev; |
31 | T Element; | 31 | T Element; |
32 | }; | 32 | }; |
33 | 33 | ||
34 | public: | 34 | public: |
35 | class ConstIterator; | 35 | class ConstIterator; |
36 | 36 | ||
37 | //! List iterator. | 37 | //! List iterator. |
38 | class Iterator | 38 | class Iterator |
39 | { | 39 | { |
40 | public: | 40 | public: |
41 | Iterator() : Current(0) {} | 41 | Iterator() : Current(0) {} |
42 | 42 | ||
43 | Iterator& operator ++() { Current = Current->Next; return *this; } | 43 | Iterator& operator ++() { Current = Current->Next; return *this; } |
44 | Iterator& operator --() { Current = Current->Prev; return *this; } | 44 | Iterator& operator --() { Current = Current->Prev; return *this; } |
45 | Iterator operator ++(s32) { Iterator tmp = *this; Current = Current->Next; return tmp; } | 45 | Iterator operator ++(s32) { Iterator tmp = *this; Current = Current->Next; return tmp; } |
46 | Iterator operator --(s32) { Iterator tmp = *this; Current = Current->Prev; return tmp; } | 46 | Iterator operator --(s32) { Iterator tmp = *this; Current = Current->Prev; return tmp; } |
47 | 47 | ||
48 | Iterator& operator +=(s32 num) | 48 | Iterator& operator +=(s32 num) |
49 | { | 49 | { |
50 | if(num > 0) | 50 | if(num > 0) |
51 | { | 51 | { |
52 | while (num-- && this->Current != 0) ++(*this); | 52 | while (num-- && this->Current != 0) ++(*this); |
53 | } | 53 | } |
54 | else | 54 | else |
55 | { | 55 | { |
56 | while(num++ && this->Current != 0) --(*this); | 56 | while(num++ && this->Current != 0) --(*this); |
57 | } | 57 | } |
58 | return *this; | 58 | return *this; |
59 | } | 59 | } |
60 | 60 | ||
61 | Iterator operator + (s32 num) const { Iterator tmp = *this; return tmp += num; } | 61 | Iterator operator + (s32 num) const { Iterator tmp = *this; return tmp += num; } |
62 | Iterator& operator -=(s32 num) { return (*this)+=(-num); } | 62 | Iterator& operator -=(s32 num) { return (*this)+=(-num); } |
63 | Iterator operator - (s32 num) const { return (*this)+ (-num); } | 63 | Iterator operator - (s32 num) const { return (*this)+ (-num); } |
64 | 64 | ||
65 | bool operator ==(const Iterator& other) const { return Current == other.Current; } | 65 | bool operator ==(const Iterator& other) const { return Current == other.Current; } |
66 | bool operator !=(const Iterator& other) const { return Current != other.Current; } | 66 | bool operator !=(const Iterator& other) const { return Current != other.Current; } |
67 | bool operator ==(const ConstIterator& other) const { return Current == other.Current; } | 67 | bool operator ==(const ConstIterator& other) const { return Current == other.Current; } |
68 | bool operator !=(const ConstIterator& other) const { return Current != other.Current; } | 68 | bool operator !=(const ConstIterator& other) const { return Current != other.Current; } |
69 | 69 | ||
70 | #if defined (_MSC_VER) && (_MSC_VER < 1300) | 70 | #if defined (_MSC_VER) && (_MSC_VER < 1300) |
71 | #pragma warning(disable:4284) // infix notation problem when using iterator operator -> | 71 | #pragma warning(disable:4284) // infix notation problem when using iterator operator -> |
72 | #endif | 72 | #endif |
73 | 73 | ||
74 | T & operator * () { return Current->Element; } | 74 | T & operator * () { return Current->Element; } |
75 | T * operator ->() { return &Current->Element; } | 75 | T * operator ->() { return &Current->Element; } |
76 | 76 | ||
77 | private: | 77 | private: |
78 | explicit Iterator(SKListNode* begin) : Current(begin) {} | 78 | explicit Iterator(SKListNode* begin) : Current(begin) {} |
79 | 79 | ||
80 | SKListNode* Current; | 80 | SKListNode* Current; |
81 | 81 | ||
82 | friend class list<T>; | 82 | friend class list<T>; |
83 | friend class ConstIterator; | 83 | friend class ConstIterator; |
84 | }; | 84 | }; |
85 | 85 | ||
86 | //! List iterator for const access. | 86 | //! List iterator for const access. |
87 | class ConstIterator | 87 | class ConstIterator |
88 | { | 88 | { |
89 | public: | 89 | public: |
90 | 90 | ||
91 | ConstIterator() : Current(0) {} | 91 | ConstIterator() : Current(0) {} |
92 | ConstIterator(const Iterator& iter) : Current(iter.Current) {} | 92 | ConstIterator(const Iterator& iter) : Current(iter.Current) {} |
93 | 93 | ||
94 | ConstIterator& operator ++() { Current = Current->Next; return *this; } | 94 | ConstIterator& operator ++() { Current = Current->Next; return *this; } |
95 | ConstIterator& operator --() { Current = Current->Prev; return *this; } | 95 | ConstIterator& operator --() { Current = Current->Prev; return *this; } |
96 | ConstIterator operator ++(s32) { ConstIterator tmp = *this; Current = Current->Next; return tmp; } | 96 | ConstIterator operator ++(s32) { ConstIterator tmp = *this; Current = Current->Next; return tmp; } |
97 | ConstIterator operator --(s32) { ConstIterator tmp = *this; Current = Current->Prev; return tmp; } | 97 | ConstIterator operator --(s32) { ConstIterator tmp = *this; Current = Current->Prev; return tmp; } |
98 | 98 | ||
99 | ConstIterator& operator +=(s32 num) | 99 | ConstIterator& operator +=(s32 num) |
100 | { | 100 | { |
101 | if(num > 0) | 101 | if(num > 0) |
102 | { | 102 | { |
103 | while(num-- && this->Current != 0) ++(*this); | 103 | while(num-- && this->Current != 0) ++(*this); |
104 | } | 104 | } |
105 | else | 105 | else |
106 | { | 106 | { |
107 | while(num++ && this->Current != 0) --(*this); | 107 | while(num++ && this->Current != 0) --(*this); |
108 | } | 108 | } |
109 | return *this; | 109 | return *this; |
110 | } | 110 | } |
111 | 111 | ||
112 | ConstIterator operator + (s32 num) const { ConstIterator tmp = *this; return tmp += num; } | 112 | ConstIterator operator + (s32 num) const { ConstIterator tmp = *this; return tmp += num; } |
113 | ConstIterator& operator -=(s32 num) { return (*this)+=(-num); } | 113 | ConstIterator& operator -=(s32 num) { return (*this)+=(-num); } |
114 | ConstIterator operator - (s32 num) const { return (*this)+ (-num); } | 114 | ConstIterator operator - (s32 num) const { return (*this)+ (-num); } |
115 | 115 | ||
116 | bool operator ==(const ConstIterator& other) const { return Current == other.Current; } | 116 | bool operator ==(const ConstIterator& other) const { return Current == other.Current; } |
117 | bool operator !=(const ConstIterator& other) const { return Current != other.Current; } | 117 | bool operator !=(const ConstIterator& other) const { return Current != other.Current; } |
118 | bool operator ==(const Iterator& other) const { return Current == other.Current; } | 118 | bool operator ==(const Iterator& other) const { return Current == other.Current; } |
119 | bool operator !=(const Iterator& other) const { return Current != other.Current; } | 119 | bool operator !=(const Iterator& other) const { return Current != other.Current; } |
120 | 120 | ||
121 | const T & operator * () { return Current->Element; } | 121 | const T & operator * () { return Current->Element; } |
122 | const T * operator ->() { return &Current->Element; } | 122 | const T * operator ->() { return &Current->Element; } |
123 | 123 | ||
124 | ConstIterator & operator =(const Iterator & iterator) { Current = iterator.Current; return *this; } | 124 | ConstIterator & operator =(const Iterator & iterator) { Current = iterator.Current; return *this; } |
125 | 125 | ||
126 | private: | 126 | private: |
127 | explicit ConstIterator(SKListNode* begin) : Current(begin) {} | 127 | explicit ConstIterator(SKListNode* begin) : Current(begin) {} |
128 | 128 | ||
129 | SKListNode* Current; | 129 | SKListNode* Current; |
130 | 130 | ||
131 | friend class Iterator; | 131 | friend class Iterator; |
132 | friend class list<T>; | 132 | friend class list<T>; |
133 | }; | 133 | }; |
134 | 134 | ||
135 | //! Default constructor for empty list. | 135 | //! Default constructor for empty list. |
136 | list() | 136 | list() |
137 | : First(0), Last(0), Size(0) {} | 137 | : First(0), Last(0), Size(0) {} |
138 | 138 | ||
139 | 139 | ||
140 | //! Copy constructor. | 140 | //! Copy constructor. |
141 | list(const list<T>& other) : First(0), Last(0), Size(0) | 141 | list(const list<T>& other) : First(0), Last(0), Size(0) |
142 | { | 142 | { |
143 | *this = other; | 143 | *this = other; |
144 | } | 144 | } |
145 | 145 | ||
146 | 146 | ||
147 | //! Destructor | 147 | //! Destructor |
148 | ~list() | 148 | ~list() |
149 | { | 149 | { |
150 | clear(); | 150 | clear(); |
151 | } | 151 | } |
152 | 152 | ||
153 | 153 | ||
154 | //! Assignment operator | 154 | //! Assignment operator |
155 | void operator=(const list<T>& other) | 155 | void operator=(const list<T>& other) |
156 | { | 156 | { |
157 | if(&other == this) | 157 | if(&other == this) |
158 | { | 158 | { |
159 | return; | 159 | return; |
160 | } | 160 | } |
161 | 161 | ||
162 | clear(); | 162 | clear(); |
163 | 163 | ||
164 | SKListNode* node = other.First; | 164 | SKListNode* node = other.First; |
165 | while(node) | 165 | while(node) |
166 | { | 166 | { |
167 | push_back(node->Element); | 167 | push_back(node->Element); |
168 | node = node->Next; | 168 | node = node->Next; |
169 | } | 169 | } |
170 | } | 170 | } |
171 | 171 | ||
172 | 172 | ||
173 | //! Returns amount of elements in list. | 173 | //! Returns amount of elements in list. |
174 | /** \return Amount of elements in the list. */ | 174 | /** \return Amount of elements in the list. */ |
175 | u32 size() const | 175 | u32 size() const |
176 | { | 176 | { |
177 | return Size; | 177 | return Size; |
178 | } | 178 | } |
179 | u32 getSize() const | 179 | u32 getSize() const |
180 | { | 180 | { |
181 | return Size; | 181 | return Size; |
182 | } | 182 | } |
183 | 183 | ||
184 | 184 | ||
185 | //! Clears the list, deletes all elements in the list. | 185 | //! Clears the list, deletes all elements in the list. |
186 | /** All existing iterators of this list will be invalid. */ | 186 | /** All existing iterators of this list will be invalid. */ |
187 | void clear() | 187 | void clear() |
188 | { | 188 | { |
189 | while(First) | 189 | while(First) |
190 | { | 190 | { |
191 | SKListNode * next = First->Next; | 191 | SKListNode * next = First->Next; |
192 | allocator.destruct(First); | 192 | allocator.destruct(First); |
193 | allocator.deallocate(First); | 193 | allocator.deallocate(First); |
194 | First = next; | 194 | First = next; |
195 | } | 195 | } |
196 | 196 | ||
197 | //First = 0; handled by loop | 197 | //First = 0; handled by loop |
198 | Last = 0; | 198 | Last = 0; |
199 | Size = 0; | 199 | Size = 0; |
200 | } | 200 | } |
201 | 201 | ||
202 | 202 | ||
203 | //! Checks for empty list. | 203 | //! Checks for empty list. |
204 | /** \return True if the list is empty and false if not. */ | 204 | /** \return True if the list is empty and false if not. */ |
205 | bool empty() const | 205 | bool empty() const |
206 | { | 206 | { |
207 | return (First == 0); | 207 | return (First == 0); |
208 | } | 208 | } |
209 | 209 | ||
210 | 210 | ||
211 | //! Adds an element at the end of the list. | 211 | //! Adds an element at the end of the list. |
212 | /** \param element Element to add to the list. */ | 212 | /** \param element Element to add to the list. */ |
213 | void push_back(const T& element) | 213 | void push_back(const T& element) |
214 | { | 214 | { |
215 | SKListNode* node = allocator.allocate(1); | 215 | SKListNode* node = allocator.allocate(1); |
216 | allocator.construct(node, element); | 216 | allocator.construct(node, element); |
217 | 217 | ||
218 | ++Size; | 218 | ++Size; |
219 | 219 | ||
220 | if (First == 0) | 220 | if (First == 0) |
221 | First = node; | 221 | First = node; |
222 | 222 | ||
223 | node->Prev = Last; | 223 | node->Prev = Last; |
224 | 224 | ||
225 | if (Last != 0) | 225 | if (Last != 0) |
226 | Last->Next = node; | 226 | Last->Next = node; |
227 | 227 | ||
228 | Last = node; | 228 | Last = node; |
229 | } | 229 | } |
230 | 230 | ||
231 | 231 | ||
232 | //! Adds an element at the begin of the list. | 232 | //! Adds an element at the begin of the list. |
233 | /** \param element: Element to add to the list. */ | 233 | /** \param element: Element to add to the list. */ |
234 | void push_front(const T& element) | 234 | void push_front(const T& element) |
235 | { | 235 | { |
236 | SKListNode* node = allocator.allocate(1); | 236 | SKListNode* node = allocator.allocate(1); |
237 | allocator.construct(node, element); | 237 | allocator.construct(node, element); |
238 | 238 | ||
239 | ++Size; | 239 | ++Size; |
240 | 240 | ||
241 | if (First == 0) | 241 | if (First == 0) |
242 | { | 242 | { |
243 | Last = node; | 243 | Last = node; |
244 | First = node; | 244 | First = node; |
245 | } | 245 | } |
246 | else | 246 | else |
247 | { | 247 | { |
248 | node->Next = First; | 248 | node->Next = First; |
249 | First->Prev = node; | 249 | First->Prev = node; |
250 | First = node; | 250 | First = node; |
251 | } | 251 | } |
252 | } | 252 | } |
253 | 253 | ||
254 | 254 | ||
255 | //! Gets first node. | 255 | //! Gets first node. |
256 | /** \return A list iterator pointing to the beginning of the list. */ | 256 | /** \return A list iterator pointing to the beginning of the list. */ |
257 | Iterator begin() | 257 | Iterator begin() |
258 | { | 258 | { |
259 | return Iterator(First); | 259 | return Iterator(First); |
260 | } | 260 | } |
261 | 261 | ||
262 | 262 | ||
263 | //! Gets first node. | 263 | //! Gets first node. |
264 | /** \return A const list iterator pointing to the beginning of the list. */ | 264 | /** \return A const list iterator pointing to the beginning of the list. */ |
265 | ConstIterator begin() const | 265 | ConstIterator begin() const |
266 | { | 266 | { |
267 | return ConstIterator(First); | 267 | return ConstIterator(First); |
268 | } | 268 | } |
269 | 269 | ||
270 | 270 | ||
271 | //! Gets end node. | 271 | //! Gets end node. |
272 | /** \return List iterator pointing to null. */ | 272 | /** \return List iterator pointing to null. */ |
273 | Iterator end() | 273 | Iterator end() |
274 | { | 274 | { |
275 | return Iterator(0); | 275 | return Iterator(0); |
276 | } | 276 | } |
277 | 277 | ||
278 | 278 | ||
279 | //! Gets end node. | 279 | //! Gets end node. |
280 | /** \return Const list iterator pointing to null. */ | 280 | /** \return Const list iterator pointing to null. */ |
281 | ConstIterator end() const | 281 | ConstIterator end() const |
282 | { | 282 | { |
283 | return ConstIterator(0); | 283 | return ConstIterator(0); |
284 | } | 284 | } |
285 | 285 | ||
286 | 286 | ||
287 | //! Gets last element. | 287 | //! Gets last element. |
288 | /** \return List iterator pointing to the last element of the list. */ | 288 | /** \return List iterator pointing to the last element of the list. */ |
289 | Iterator getLast() | 289 | Iterator getLast() |
290 | { | 290 | { |
291 | return Iterator(Last); | 291 | return Iterator(Last); |
292 | } | 292 | } |
293 | 293 | ||
294 | 294 | ||
295 | //! Gets last element. | 295 | //! Gets last element. |
296 | /** \return Const list iterator pointing to the last element of the list. */ | 296 | /** \return Const list iterator pointing to the last element of the list. */ |
297 | ConstIterator getLast() const | 297 | ConstIterator getLast() const |
298 | { | 298 | { |
299 | return ConstIterator(Last); | 299 | return ConstIterator(Last); |
300 | } | 300 | } |
301 | 301 | ||
302 | 302 | ||
303 | //! Inserts an element after an element. | 303 | //! Inserts an element after an element. |
304 | /** \param it Iterator pointing to element after which the new element | 304 | /** \param it Iterator pointing to element after which the new element |
305 | should be inserted. | 305 | should be inserted. |
306 | \param element The new element to be inserted into the list. | 306 | \param element The new element to be inserted into the list. |
307 | */ | 307 | */ |
308 | void insert_after(const Iterator& it, const T& element) | 308 | void insert_after(const Iterator& it, const T& element) |
309 | { | 309 | { |
310 | SKListNode* node = allocator.allocate(1); | 310 | SKListNode* node = allocator.allocate(1); |
311 | allocator.construct(node, element); | 311 | allocator.construct(node, element); |
312 | 312 | ||
313 | node->Next = it.Current->Next; | 313 | node->Next = it.Current->Next; |
314 | 314 | ||
315 | if (it.Current->Next) | 315 | if (it.Current->Next) |
316 | it.Current->Next->Prev = node; | 316 | it.Current->Next->Prev = node; |
317 | 317 | ||
318 | node->Prev = it.Current; | 318 | node->Prev = it.Current; |
319 | it.Current->Next = node; | 319 | it.Current->Next = node; |
320 | ++Size; | 320 | ++Size; |
321 | 321 | ||
322 | if (it.Current == Last) | 322 | if (it.Current == Last) |
323 | Last = node; | 323 | Last = node; |
324 | } | 324 | } |
325 | 325 | ||
326 | 326 | ||
327 | //! Inserts an element before an element. | 327 | //! Inserts an element before an element. |
328 | /** \param it Iterator pointing to element before which the new element | 328 | /** \param it Iterator pointing to element before which the new element |
329 | should be inserted. | 329 | should be inserted. |
330 | \param element The new element to be inserted into the list. | 330 | \param element The new element to be inserted into the list. |
331 | */ | 331 | */ |
332 | void insert_before(const Iterator& it, const T& element) | 332 | void insert_before(const Iterator& it, const T& element) |
333 | { | 333 | { |
334 | SKListNode* node = allocator.allocate(1); | 334 | SKListNode* node = allocator.allocate(1); |
335 | allocator.construct(node, element); | 335 | allocator.construct(node, element); |
336 | 336 | ||
337 | node->Prev = it.Current->Prev; | 337 | node->Prev = it.Current->Prev; |
338 | 338 | ||
339 | if (it.Current->Prev) | 339 | if (it.Current->Prev) |
340 | it.Current->Prev->Next = node; | 340 | it.Current->Prev->Next = node; |
341 | 341 | ||
342 | node->Next = it.Current; | 342 | node->Next = it.Current; |
343 | it.Current->Prev = node; | 343 | it.Current->Prev = node; |
344 | ++Size; | 344 | ++Size; |
345 | 345 | ||
346 | if (it.Current == First) | 346 | if (it.Current == First) |
347 | First = node; | 347 | First = node; |
348 | } | 348 | } |
349 | 349 | ||
350 | 350 | ||
351 | //! Erases an element. | 351 | //! Erases an element. |
352 | /** \param it Iterator pointing to the element which shall be erased. | 352 | /** \param it Iterator pointing to the element which shall be erased. |
353 | \return Iterator pointing to next element. */ | 353 | \return Iterator pointing to next element. */ |
354 | Iterator erase(Iterator& it) | 354 | Iterator erase(Iterator& it) |
355 | { | 355 | { |
356 | // suggest changing this to a const Iterator& and | 356 | // suggest changing this to a const Iterator& and |
357 | // working around line: it.Current = 0 (possibly with a mutable, or just let it be garbage?) | 357 | // working around line: it.Current = 0 (possibly with a mutable, or just let it be garbage?) |
358 | 358 | ||
359 | Iterator returnIterator(it); | 359 | Iterator returnIterator(it); |
360 | ++returnIterator; | 360 | ++returnIterator; |
361 | 361 | ||
362 | if(it.Current == First) | 362 | if(it.Current == First) |
363 | { | 363 | { |
364 | First = it.Current->Next; | 364 | First = it.Current->Next; |
365 | } | 365 | } |
366 | else | 366 | else |
367 | { | 367 | { |
368 | it.Current->Prev->Next = it.Current->Next; | 368 | it.Current->Prev->Next = it.Current->Next; |
369 | } | 369 | } |
370 | 370 | ||
371 | if(it.Current == Last) | 371 | if(it.Current == Last) |
372 | { | 372 | { |
373 | Last = it.Current->Prev; | 373 | Last = it.Current->Prev; |
374 | } | 374 | } |
375 | else | 375 | else |
376 | { | 376 | { |
377 | it.Current->Next->Prev = it.Current->Prev; | 377 | it.Current->Next->Prev = it.Current->Prev; |
378 | } | 378 | } |
379 | 379 | ||
380 | allocator.destruct(it.Current); | 380 | allocator.destruct(it.Current); |
381 | allocator.deallocate(it.Current); | 381 | allocator.deallocate(it.Current); |
382 | it.Current = 0; | 382 | it.Current = 0; |
383 | --Size; | 383 | --Size; |
384 | 384 | ||
385 | return returnIterator; | 385 | return returnIterator; |
386 | } | 386 | } |
387 | 387 | ||
388 | //! Swap the content of this list container with the content of another list | 388 | //! Swap the content of this list container with the content of another list |
389 | /** Afterwards this object will contain the content of the other object and the other | 389 | /** Afterwards this object will contain the content of the other object and the other |
390 | object will contain the content of this object. Iterators will afterwards be valid for | 390 | object will contain the content of this object. Iterators will afterwards be valid for |
391 | the swapped object. | 391 | the swapped object. |
392 | \param other Swap content with this object */ | 392 | \param other Swap content with this object */ |
393 | void swap(list<T>& other) | 393 | void swap(list<T>& other) |
394 | { | 394 | { |
395 | core::swap(First, other.First); | 395 | core::swap(First, other.First); |
396 | core::swap(Last, other.Last); | 396 | core::swap(Last, other.Last); |
397 | core::swap(Size, other.Size); | 397 | core::swap(Size, other.Size); |
398 | core::swap(allocator, other.allocator); // memory is still released by the same allocator used for allocation | 398 | core::swap(allocator, other.allocator); // memory is still released by the same allocator used for allocation |
399 | } | 399 | } |
400 | 400 | ||
401 | 401 | ||
402 | private: | 402 | private: |
403 | 403 | ||
404 | SKListNode* First; | 404 | SKListNode* First; |
405 | SKListNode* Last; | 405 | SKListNode* Last; |
406 | u32 Size; | 406 | u32 Size; |
407 | irrAllocator<SKListNode> allocator; | 407 | irrAllocator<SKListNode> allocator; |
408 | 408 | ||
409 | }; | 409 | }; |
410 | 410 | ||
411 | 411 | ||
412 | } // end namespace core | 412 | } // end namespace core |
413 | }// end namespace irr | 413 | }// end namespace irr |
414 | 414 | ||
415 | #endif | 415 | #endif |
416 | 416 | ||