1 mike 1.5 //%/////////////////////////////////////////////////////////////////////////////
2 //
3 // Copyright (c) 2000, 2001 The Open group, BMC Software, Tivoli Systems, IBM
4 //
5 // Permission is hereby granted, free of charge, to any person obtaining a copy
6 // of this software and associated documentation files (the "Software"), to
7 // deal in the Software without restriction, including without limitation the
8 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
9 // sell copies of the Software, and to permit persons to whom the Software is
10 // furnished to do so, subject to the following conditions:
11 //
12 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
13 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
14 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
15 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
16 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
17 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
18 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
19 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
20 //
21 //==============================================================================
22 mike 1.5 //
23 // Author: Mike Brasher (mbrasher@bmc.com)
24 //
|
25 kumpf 1.10 // Modified By: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
|
26 mike 1.5 //
27 //%/////////////////////////////////////////////////////////////////////////////
28
29 #if defined(PEGASUS_EXPLICIT_INSTANTIATION) || !defined(PEGASUS_ARRAY_T)
30
31 #ifndef PEGASUS_ARRAY_T
32 template<class PEGASUS_ARRAY_T>
33 #else
34 PEGASUS_TEMPLATE_SPECIALIZATION
35 #endif
36 Array<PEGASUS_ARRAY_T>::Array()
37 {
|
38 kumpf 1.10 _rep = Rep::create(0);
|
39 mike 1.5 }
40
41 #ifndef PEGASUS_ARRAY_T
42 template<class PEGASUS_ARRAY_T>
43 #else
44 PEGASUS_TEMPLATE_SPECIALIZATION
45 #endif
46 Array<PEGASUS_ARRAY_T>::Array(const Array<PEGASUS_ARRAY_T>& x)
47 {
|
48 kumpf 1.10 _rep = x._rep->clone();
|
49 mike 1.5 }
50
51 #ifndef PEGASUS_ARRAY_T
52 template<class PEGASUS_ARRAY_T>
53 #else
54 PEGASUS_TEMPLATE_SPECIALIZATION
55 #endif
56 Array<PEGASUS_ARRAY_T>::Array(Uint32 size)
57 {
58 _rep = Rep::create(size);
|
59 kumpf 1.8 #if defined(PEGASUS_PLATFORM_HPUX_PARISC_ACC) || defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU)
|
60 kumpf 1.7 InitializeRaw<PEGASUS_ARRAY_T>(_rep->data(), size);
61 #else
|
62 mike 1.5 InitializeRaw(_rep->data(), size);
|
63 kumpf 1.7 #endif
|
64 mike 1.5 }
65
66 #ifndef PEGASUS_ARRAY_T
67 template<class PEGASUS_ARRAY_T>
68 #else
69 PEGASUS_TEMPLATE_SPECIALIZATION
70 #endif
71 Array<PEGASUS_ARRAY_T>::Array(Uint32 size, const PEGASUS_ARRAY_T& x)
72 {
73 _rep = Rep::create(size);
74
75 PEGASUS_ARRAY_T* data = _rep->data();
76
77 while (size--)
78 new(data++) PEGASUS_ARRAY_T(x);
79 }
80
81 #ifndef PEGASUS_ARRAY_T
82 template<class PEGASUS_ARRAY_T>
83 #else
84 PEGASUS_TEMPLATE_SPECIALIZATION
85 mike 1.5 #endif
86 Array<PEGASUS_ARRAY_T>::Array(const PEGASUS_ARRAY_T* items, Uint32 size)
87 {
88 _rep = Rep::create(size);
|
89 kumpf 1.8 #if defined(PEGASUS_PLATFORM_HPUX_PARISC_ACC) || defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU)
|
90 kumpf 1.7 CopyToRaw<PEGASUS_ARRAY_T>(_rep->data(), items, size);
91 #else
|
92 mike 1.5 CopyToRaw(_rep->data(), items, size);
|
93 kumpf 1.7 #endif
|
94 mike 1.5 }
95
96 #ifndef PEGASUS_ARRAY_T
97 template<class PEGASUS_ARRAY_T>
98 #else
99 PEGASUS_TEMPLATE_SPECIALIZATION
100 #endif
101 Array<PEGASUS_ARRAY_T>::~Array()
102 {
|
103 kumpf 1.10 Rep::destroy(_rep);
|
104 mike 1.5 }
105
106 #ifndef PEGASUS_ARRAY_T
107 template<class PEGASUS_ARRAY_T>
108 #else
109 PEGASUS_TEMPLATE_SPECIALIZATION
110 #endif
111 Array<PEGASUS_ARRAY_T>& Array<PEGASUS_ARRAY_T>::operator=(
112 const Array<PEGASUS_ARRAY_T>& x)
113 {
114 if (x._rep != _rep)
115 {
|
116 kumpf 1.10 Rep::destroy(_rep);
117 _rep = x._rep->clone();
|
118 mike 1.5 }
119 return *this;
120 }
121
122 #ifndef PEGASUS_ARRAY_T
123 template<class PEGASUS_ARRAY_T>
124 #else
125 PEGASUS_TEMPLATE_SPECIALIZATION
126 #endif
127 void Array<PEGASUS_ARRAY_T>::clear()
128 {
|
129 kumpf 1.10 Rep::destroy(_rep);
130 _rep = Rep::create(0);
|
131 mike 1.5 }
132
133 #ifndef PEGASUS_ARRAY_T
134 template<class PEGASUS_ARRAY_T>
135 #else
136 PEGASUS_TEMPLATE_SPECIALIZATION
137 #endif
|
138 kumpf 1.10 void Array<PEGASUS_ARRAY_T>::reserve(Uint32 capacity)
|
139 mike 1.5 {
|
140 kumpf 1.10 if (capacity > _rep->capacity)
141 {
142 Uint32 size = this->size();
143 Rep* rep = Rep::create(capacity);
144 rep->size = size;
|
145 kumpf 1.8 #if defined(PEGASUS_PLATFORM_HPUX_PARISC_ACC) || defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU)
|
146 kumpf 1.10 CopyToRaw<PEGASUS_ARRAY_T>(rep->data(), _rep->data(), size);
|
147 kumpf 1.7 #else
|
148 kumpf 1.10 CopyToRaw(rep->data(), _rep->data(), size);
|
149 kumpf 1.7 #endif
|
150 kumpf 1.10 Rep::destroy(_rep);
151 _rep = rep;
|
152 mike 1.5 }
153 }
154
155 #ifndef PEGASUS_ARRAY_T
156 template<class PEGASUS_ARRAY_T>
157 #else
158 PEGASUS_TEMPLATE_SPECIALIZATION
159 #endif
160 void Array<PEGASUS_ARRAY_T>::grow(Uint32 size, const PEGASUS_ARRAY_T& x)
161 {
162 Uint32 oldSize = _rep->size;
163 reserve(oldSize + size);
164
165 PEGASUS_ARRAY_T* p = _rep->data() + oldSize;
166 Uint32 n = size;
167
168 while (n--)
169 new(p++) PEGASUS_ARRAY_T(x);
170
171 _rep->size += size;
172 }
173 mike 1.5
174 #ifndef PEGASUS_ARRAY_T
175 template<class PEGASUS_ARRAY_T>
176 #else
177 PEGASUS_TEMPLATE_SPECIALIZATION
178 #endif
179 void Array<PEGASUS_ARRAY_T>::swap(Array<PEGASUS_ARRAY_T>& x)
180 {
181 Rep* tmp = _rep;
182 _rep = x._rep;
183 x._rep = tmp;
184 }
185
186 #ifndef PEGASUS_ARRAY_T
187 template<class PEGASUS_ARRAY_T>
188 #else
189 PEGASUS_TEMPLATE_SPECIALIZATION
190 #endif
|
191 kumpf 1.10 Uint32 Array<PEGASUS_ARRAY_T>::size() const
192 {
193 return _rep->size;
194 }
195
196 #ifndef PEGASUS_ARRAY_T
197 template<class PEGASUS_ARRAY_T>
198 #else
199 PEGASUS_TEMPLATE_SPECIALIZATION
200 #endif
201 Uint32 Array<PEGASUS_ARRAY_T>::getCapacity() const
202 {
203 return _rep->capacity;
204 }
205
206 #ifndef PEGASUS_ARRAY_T
207 template<class PEGASUS_ARRAY_T>
208 #else
209 PEGASUS_TEMPLATE_SPECIALIZATION
210 #endif
211 const PEGASUS_ARRAY_T* Array<PEGASUS_ARRAY_T>::getData() const
212 kumpf 1.10 {
213 return _rep->data();
214 }
215
216 #ifndef PEGASUS_ARRAY_T
217 template<class PEGASUS_ARRAY_T>
218 #else
219 PEGASUS_TEMPLATE_SPECIALIZATION
220 #endif
|
221 mike 1.5 void Array<PEGASUS_ARRAY_T>::append(const PEGASUS_ARRAY_T& x)
222 {
|
223 kumpf 1.9 reserve(size() + 1);
|
224 mike 1.5 new (_data() + size()) PEGASUS_ARRAY_T(x);
225 _rep->size++;
226 }
227
228 #ifndef PEGASUS_ARRAY_T
229 template<class PEGASUS_ARRAY_T>
230 #else
231 PEGASUS_TEMPLATE_SPECIALIZATION
232 #endif
233 void Array<PEGASUS_ARRAY_T>::append(const PEGASUS_ARRAY_T* x, Uint32 size)
234 {
|
235 kumpf 1.9 reserve(this->size() + size);
|
236 kumpf 1.8 #if defined(PEGASUS_PLATFORM_HPUX_PARISC_ACC) || defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU)
|
237 kumpf 1.7 CopyToRaw<PEGASUS_ARRAY_T>(_data() + this->size(), x, size);
238 #else
|
239 mike 1.5 CopyToRaw(_data() + this->size(), x, size);
|
240 kumpf 1.7 #endif
|
241 mike 1.5 _rep->size += size;
242 }
243
244 #ifndef PEGASUS_ARRAY_T
245 template<class PEGASUS_ARRAY_T>
246 #else
247 PEGASUS_TEMPLATE_SPECIALIZATION
248 #endif
|
249 kumpf 1.10 void Array<PEGASUS_ARRAY_T>::appendArray(const Array<PEGASUS_ARRAY_T>& x)
250 {
251 append(x.getData(), x.size());
252 }
253
254 #ifndef PEGASUS_ARRAY_T
255 template<class PEGASUS_ARRAY_T>
256 #else
257 PEGASUS_TEMPLATE_SPECIALIZATION
258 #endif
|
259 mike 1.5 void Array<PEGASUS_ARRAY_T>::prepend(const PEGASUS_ARRAY_T& x)
260 {
|
261 kumpf 1.9 reserve(size() + 1);
|
262 mike 1.5 memmove(_data() + 1, _data(), sizeof(PEGASUS_ARRAY_T) * size());
263 new(_data()) PEGASUS_ARRAY_T(x);
264 _rep->size++;
265 }
266
267 #ifndef PEGASUS_ARRAY_T
268 template<class PEGASUS_ARRAY_T>
269 #else
270 PEGASUS_TEMPLATE_SPECIALIZATION
271 #endif
272 void Array<PEGASUS_ARRAY_T>::prepend(const PEGASUS_ARRAY_T* x, Uint32 size)
273 {
|
274 kumpf 1.9 reserve(this->size() + size);
|
275 mike 1.5 memmove(_data() + size, _data(), sizeof(PEGASUS_ARRAY_T) * this->size());
|
276 kumpf 1.8 #if defined(PEGASUS_PLATFORM_HPUX_PARISC_ACC) || defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU)
|
277 kumpf 1.7 CopyToRaw<PEGASUS_ARRAY_T>(_data(), x, size);
278 #else
|
279 mike 1.5 CopyToRaw(_data(), x, size);
|
280 kumpf 1.7 #endif
|
281 mike 1.5 _rep->size += size;
282 }
283
284 #ifndef PEGASUS_ARRAY_T
285 template<class PEGASUS_ARRAY_T>
286 #else
287 PEGASUS_TEMPLATE_SPECIALIZATION
288 #endif
289 void Array<PEGASUS_ARRAY_T>::insert(Uint32 pos, const PEGASUS_ARRAY_T& x)
290 {
291 if (pos > size())
292 ThrowOutOfBounds();
293
|
294 kumpf 1.9 reserve(size() + 1);
|
295 mike 1.5
296 Uint32 n = size() - pos;
297
298 if (n)
299 memmove(_data() + pos + 1, _data() + pos, sizeof(PEGASUS_ARRAY_T) * n);
300
301 new(_data() + pos) PEGASUS_ARRAY_T(x);
302 _rep->size++;
303 }
304
305 #ifndef PEGASUS_ARRAY_T
306 template<class PEGASUS_ARRAY_T>
307 #else
308 PEGASUS_TEMPLATE_SPECIALIZATION
309 #endif
310 void Array<PEGASUS_ARRAY_T>::insert(Uint32 pos, const PEGASUS_ARRAY_T* x, Uint32 size)
311 {
312 if (pos + size > this->size())
313 ThrowOutOfBounds();
314
|
315 kumpf 1.9 reserve(this->size() + size);
|
316 mike 1.5
317 Uint32 n = this->size() - pos;
318
319 if (n)
320 memmove(
321 _data() + pos + size, _data() + pos, sizeof(PEGASUS_ARRAY_T) * n);
322
|
323 kumpf 1.8 #if defined(PEGASUS_PLATFORM_HPUX_PARISC_ACC) || defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU)
|
324 kumpf 1.7 CopyToRaw<PEGASUS_ARRAY_T>(_data() + pos, x, size);
325 #else
|
326 mike 1.5 CopyToRaw(_data() + pos, x, size);
|
327 kumpf 1.7 #endif
|
328 mike 1.5 _rep->size += size;
329 }
330
331 #ifndef PEGASUS_ARRAY_T
332 template<class PEGASUS_ARRAY_T>
333 #else
334 PEGASUS_TEMPLATE_SPECIALIZATION
335 #endif
336 void Array<PEGASUS_ARRAY_T>::remove(Uint32 pos)
337 {
338 if (pos >= this->size())
339 ThrowOutOfBounds();
340
|
341 kumpf 1.8 #if defined(PEGASUS_PLATFORM_HPUX_PARISC_ACC) || defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU)
|
342 kumpf 1.7 Destroy<PEGASUS_ARRAY_T>(_data() + pos);
343 #else
|
344 mike 1.5 Destroy(_data() + pos);
|
345 kumpf 1.7 #endif
|
346 mike 1.5
347 Uint32 rem = this->size() - pos - 1;
348
349 if (rem)
350 memmove(_data() + pos, _data() + pos + 1, sizeof(PEGASUS_ARRAY_T) * rem);
351
352 _rep->size--;
353 }
354
355 #ifndef PEGASUS_ARRAY_T
356 template<class PEGASUS_ARRAY_T>
357 #else
358 PEGASUS_TEMPLATE_SPECIALIZATION
359 #endif
360 void Array<PEGASUS_ARRAY_T>::remove(Uint32 pos, Uint32 size)
361 {
362 if (pos + size > this->size())
363 ThrowOutOfBounds();
364
|
365 kumpf 1.8 #if defined(PEGASUS_PLATFORM_HPUX_PARISC_ACC) || defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU)
|
366 kumpf 1.7 Destroy<PEGASUS_ARRAY_T>(_data() + pos, size);
367 #else
|
368 mike 1.5 Destroy(_data() + pos, size);
|
369 kumpf 1.7 #endif
|
370 mike 1.5
371 Uint32 rem = this->size() - (pos + size);
372
373 if (rem)
374 memmove(
375 _data() + pos, _data() + pos + size, sizeof(PEGASUS_ARRAY_T) * rem);
376
377 _rep->size -= size;
378 }
379
|
380 mike 1.6 #ifdef PEGASUS_HAS_EBCDIC
381
382 #ifndef PEGASUS_ARRAY_T
383 template<class PEGASUS_ARRAY_T>
384 #else
385 PEGASUS_TEMPLATE_SPECIALIZATION
386 #endif
387 void Array<PEGASUS_ARRAY_T>::etoa()
388 {
389 #if PEGASUS_ARRAY_T == Sint8
390 __etoa_l((char *)_data(),_rep->size);
391 #endif
392 }
393
394 #ifndef PEGASUS_ARRAY_T
395 template<class PEGASUS_ARRAY_T>
396 #else
397 PEGASUS_TEMPLATE_SPECIALIZATION
398 #endif
399 void Array<PEGASUS_ARRAY_T>::atoe()
400 {
401 mike 1.6 #if PEGASUS_ARRAY_T == Sint8
402 __atoe_l((char *)_data(),_rep->size);
403 #endif
404 }
405
406 #endif
|
407 kumpf 1.10
408 #ifndef PEGASUS_ARRAY_T
409 template<class PEGASUS_ARRAY_T>
410 #else
411 PEGASUS_TEMPLATE_SPECIALIZATION
412 #endif
413 PEGASUS_ARRAY_T* Array<PEGASUS_ARRAY_T>::begin()
414 {
415 return _rep->data();
416 }
417
418 #ifndef PEGASUS_ARRAY_T
419 template<class PEGASUS_ARRAY_T>
420 #else
421 PEGASUS_TEMPLATE_SPECIALIZATION
422 #endif
423 PEGASUS_ARRAY_T* Array<PEGASUS_ARRAY_T>::end()
424 {
425 return _rep->data() + size();
426 }
427
428 kumpf 1.10 #ifndef PEGASUS_ARRAY_T
429 template<class PEGASUS_ARRAY_T>
430 #else
431 PEGASUS_TEMPLATE_SPECIALIZATION
432 #endif
433 const PEGASUS_ARRAY_T* Array<PEGASUS_ARRAY_T>::begin() const
434 {
435 return getData();
436 }
437
438 #ifndef PEGASUS_ARRAY_T
439 template<class PEGASUS_ARRAY_T>
440 #else
441 PEGASUS_TEMPLATE_SPECIALIZATION
442 #endif
443 const PEGASUS_ARRAY_T* Array<PEGASUS_ARRAY_T>::end() const
444 {
445 return getData() + size();
446 }
447
448 #ifndef PEGASUS_ARRAY_T
449 kumpf 1.10 template<class PEGASUS_ARRAY_T>
450 #else
451 PEGASUS_TEMPLATE_SPECIALIZATION
452 #endif
453 void Array<PEGASUS_ARRAY_T>::set(ArrayRep<PEGASUS_ARRAY_T>* rep)
454 {
455 if (_rep != rep)
456 {
457 Rep::destroy(_rep);
458 _rep = rep->clone();
459 }
460 }
461
462 #ifndef PEGASUS_ARRAY_T
463 template<class PEGASUS_ARRAY_T>
464 #else
465 PEGASUS_TEMPLATE_SPECIALIZATION
466 #endif
467 PEGASUS_ARRAY_T* Array<PEGASUS_ARRAY_T>::_data() const
468 {
469 return _rep->data();
470 kumpf 1.10 }
471
472
473 #ifndef PEGASUS_ARRAY_T
474 template<class PEGASUS_ARRAY_T>
475 #else
476 PEGASUS_TEMPLATE_SPECIALIZATION
477 #endif
478 Boolean operator==(
479 const Array<PEGASUS_ARRAY_T>& x,
480 const Array<PEGASUS_ARRAY_T>& y)
481 {
482 return Equal(x, y);
483 }
484
485 #ifndef PEGASUS_ARRAY_T
486 template<class PEGASUS_ARRAY_T>
487 #else
488 PEGASUS_TEMPLATE_SPECIALIZATION
489 #endif
490 PEGASUS_ARRAY_T& Array<PEGASUS_ARRAY_T>::operator[](Uint32 pos)
491 kumpf 1.10 {
492 if (pos >= size())
493 ThrowOutOfBounds();
494
495 return _rep->data()[pos];
496 }
497
498 #ifndef PEGASUS_ARRAY_T
499 template<class PEGASUS_ARRAY_T>
500 #else
501 PEGASUS_TEMPLATE_SPECIALIZATION
502 #endif
503 const PEGASUS_ARRAY_T& Array<PEGASUS_ARRAY_T>::operator[](
504 Uint32 pos) const
505 {
506 if (pos >= size())
507 ThrowOutOfBounds();
508
509 return _rep->data()[pos];
510 }
|
511 mike 1.6
|
512 mike 1.5 #endif /*defined(PEGASUS_EXPLICIT_INSTANTIATION) || !defined(PEGASUS_ARRAY_T)*/
|
Return to
ArrayImpl.h
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / Common