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.12 prepend(&x, 1);
|
262 mike 1.5 }
263
264 #ifndef PEGASUS_ARRAY_T
265 template<class PEGASUS_ARRAY_T>
266 #else
267 PEGASUS_TEMPLATE_SPECIALIZATION
268 #endif
269 void Array<PEGASUS_ARRAY_T>::prepend(const PEGASUS_ARRAY_T* x, Uint32 size)
270 {
|
271 kumpf 1.9 reserve(this->size() + size);
|
272 mike 1.5 memmove(_data() + size, _data(), sizeof(PEGASUS_ARRAY_T) * this->size());
|
273 kumpf 1.8 #if defined(PEGASUS_PLATFORM_HPUX_PARISC_ACC) || defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU)
|
274 kumpf 1.7 CopyToRaw<PEGASUS_ARRAY_T>(_data(), x, size);
275 #else
|
276 mike 1.5 CopyToRaw(_data(), x, size);
|
277 kumpf 1.7 #endif
|
278 mike 1.5 _rep->size += size;
279 }
280
281 #ifndef PEGASUS_ARRAY_T
282 template<class PEGASUS_ARRAY_T>
283 #else
284 PEGASUS_TEMPLATE_SPECIALIZATION
285 #endif
286 void Array<PEGASUS_ARRAY_T>::insert(Uint32 pos, const PEGASUS_ARRAY_T& x)
287 {
|
288 kumpf 1.12 insert(pos, &x, 1);
|
289 mike 1.5 }
290
291 #ifndef PEGASUS_ARRAY_T
292 template<class PEGASUS_ARRAY_T>
293 #else
294 PEGASUS_TEMPLATE_SPECIALIZATION
295 #endif
296 void Array<PEGASUS_ARRAY_T>::insert(Uint32 pos, const PEGASUS_ARRAY_T* x, Uint32 size)
297 {
|
298 kumpf 1.12 if (pos > this->size())
|
299 mike 1.5 ThrowOutOfBounds();
300
|
301 kumpf 1.9 reserve(this->size() + size);
|
302 mike 1.5
303 Uint32 n = this->size() - pos;
304
305 if (n)
306 memmove(
307 _data() + pos + size, _data() + pos, sizeof(PEGASUS_ARRAY_T) * n);
308
|
309 kumpf 1.8 #if defined(PEGASUS_PLATFORM_HPUX_PARISC_ACC) || defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU)
|
310 kumpf 1.7 CopyToRaw<PEGASUS_ARRAY_T>(_data() + pos, x, size);
311 #else
|
312 mike 1.5 CopyToRaw(_data() + pos, x, size);
|
313 kumpf 1.7 #endif
|
314 mike 1.5 _rep->size += size;
315 }
316
317 #ifndef PEGASUS_ARRAY_T
318 template<class PEGASUS_ARRAY_T>
319 #else
320 PEGASUS_TEMPLATE_SPECIALIZATION
321 #endif
322 void Array<PEGASUS_ARRAY_T>::remove(Uint32 pos)
323 {
|
324 kumpf 1.12 remove(pos, 1);
|
325 mike 1.5 }
326
327 #ifndef PEGASUS_ARRAY_T
328 template<class PEGASUS_ARRAY_T>
329 #else
330 PEGASUS_TEMPLATE_SPECIALIZATION
331 #endif
332 void Array<PEGASUS_ARRAY_T>::remove(Uint32 pos, Uint32 size)
333 {
|
334 kumpf 1.12 if (pos + size - 1 > this->size())
|
335 mike 1.5 ThrowOutOfBounds();
336
|
337 kumpf 1.8 #if defined(PEGASUS_PLATFORM_HPUX_PARISC_ACC) || defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU)
|
338 kumpf 1.7 Destroy<PEGASUS_ARRAY_T>(_data() + pos, size);
339 #else
|
340 mike 1.5 Destroy(_data() + pos, size);
|
341 kumpf 1.7 #endif
|
342 mike 1.5
343 Uint32 rem = this->size() - (pos + size);
344
345 if (rem)
346 memmove(
347 _data() + pos, _data() + pos + size, sizeof(PEGASUS_ARRAY_T) * rem);
348
349 _rep->size -= size;
350 }
351
|
352 mike 1.6 #ifdef PEGASUS_HAS_EBCDIC
353
354 #ifndef PEGASUS_ARRAY_T
355 template<class PEGASUS_ARRAY_T>
356 #else
357 PEGASUS_TEMPLATE_SPECIALIZATION
358 #endif
359 void Array<PEGASUS_ARRAY_T>::etoa()
360 {
361 #if PEGASUS_ARRAY_T == Sint8
362 __etoa_l((char *)_data(),_rep->size);
363 #endif
364 }
365
366 #ifndef PEGASUS_ARRAY_T
367 template<class PEGASUS_ARRAY_T>
368 #else
369 PEGASUS_TEMPLATE_SPECIALIZATION
370 #endif
371 void Array<PEGASUS_ARRAY_T>::atoe()
372 {
373 mike 1.6 #if PEGASUS_ARRAY_T == Sint8
374 __atoe_l((char *)_data(),_rep->size);
375 #endif
376 }
377
378 #endif
|
379 kumpf 1.10
380 #ifndef PEGASUS_ARRAY_T
381 template<class PEGASUS_ARRAY_T>
382 #else
383 PEGASUS_TEMPLATE_SPECIALIZATION
384 #endif
385 PEGASUS_ARRAY_T* Array<PEGASUS_ARRAY_T>::begin()
386 {
387 return _rep->data();
388 }
389
390 #ifndef PEGASUS_ARRAY_T
391 template<class PEGASUS_ARRAY_T>
392 #else
393 PEGASUS_TEMPLATE_SPECIALIZATION
394 #endif
395 PEGASUS_ARRAY_T* Array<PEGASUS_ARRAY_T>::end()
396 {
397 return _rep->data() + size();
398 }
399
400 kumpf 1.10 #ifndef PEGASUS_ARRAY_T
401 template<class PEGASUS_ARRAY_T>
402 #else
403 PEGASUS_TEMPLATE_SPECIALIZATION
404 #endif
405 const PEGASUS_ARRAY_T* Array<PEGASUS_ARRAY_T>::begin() const
406 {
407 return getData();
408 }
409
410 #ifndef PEGASUS_ARRAY_T
411 template<class PEGASUS_ARRAY_T>
412 #else
413 PEGASUS_TEMPLATE_SPECIALIZATION
414 #endif
415 const PEGASUS_ARRAY_T* Array<PEGASUS_ARRAY_T>::end() const
416 {
417 return getData() + size();
418 }
419
420 #ifndef PEGASUS_ARRAY_T
421 kumpf 1.10 template<class PEGASUS_ARRAY_T>
422 #else
423 PEGASUS_TEMPLATE_SPECIALIZATION
424 #endif
425 void Array<PEGASUS_ARRAY_T>::set(ArrayRep<PEGASUS_ARRAY_T>* rep)
426 {
427 if (_rep != rep)
428 {
429 Rep::destroy(_rep);
430 _rep = rep->clone();
431 }
432 }
433
434 #ifndef PEGASUS_ARRAY_T
435 template<class PEGASUS_ARRAY_T>
436 #else
437 PEGASUS_TEMPLATE_SPECIALIZATION
438 #endif
439 PEGASUS_ARRAY_T* Array<PEGASUS_ARRAY_T>::_data() const
440 {
441 return _rep->data();
442 kumpf 1.10 }
443
444
445 #ifndef PEGASUS_ARRAY_T
446 template<class PEGASUS_ARRAY_T>
447 #else
448 PEGASUS_TEMPLATE_SPECIALIZATION
449 #endif
450 Boolean operator==(
451 const Array<PEGASUS_ARRAY_T>& x,
452 const Array<PEGASUS_ARRAY_T>& y)
453 {
454 return Equal(x, y);
455 }
456
457 #ifndef PEGASUS_ARRAY_T
458 template<class PEGASUS_ARRAY_T>
459 #else
460 PEGASUS_TEMPLATE_SPECIALIZATION
461 #endif
462 PEGASUS_ARRAY_T& Array<PEGASUS_ARRAY_T>::operator[](Uint32 pos)
463 kumpf 1.10 {
464 if (pos >= size())
465 ThrowOutOfBounds();
466
467 return _rep->data()[pos];
468 }
469
470 #ifndef PEGASUS_ARRAY_T
471 template<class PEGASUS_ARRAY_T>
472 #else
473 PEGASUS_TEMPLATE_SPECIALIZATION
474 #endif
475 const PEGASUS_ARRAY_T& Array<PEGASUS_ARRAY_T>::operator[](
476 Uint32 pos) const
477 {
478 if (pos >= size())
479 ThrowOutOfBounds();
480
481 return _rep->data()[pos];
482 }
|
483 mike 1.6
|
484 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