1 : //==============================================================================
2 : // File <$/src/cpp/prod/lib/sequence.cpp>
3 : // This file is part of YaOrb : Yet Another Object Request Broker,
4 : // Copyright (c) 2000-2003, Marc Alff.
5 : //
6 : // This program is free software; you can redistribute it and/or
7 : // modify it under the terms of the GNU General Public License
8 : // as published by the Free Software Foundation; either version 2
9 : // of the License, or (at your option) any later version.
10 : //
11 : // This program is distributed in the hope that it will be useful,
12 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 : // GNU General Public License for more details.
15 : //
16 : // You should have received a copy of the GNU General Public License
17 : // along with this program; if not, write to the Free Software
18 : // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
19 : //
20 : //==============================================================================
21 :
22 : // Portability
23 : #include "yaorb/config.h"
24 : #include "src/cpp/prod/port/port_stdc.h"
25 :
26 : #include <yaorb/CORBA.h>
27 : #include <yaorb/YAORB.h>
28 :
29 : #include "src/cpp/prod/tool/DEVELOPMENT.h"
30 : #include "src/cpp/prod/tool/Assert.h"
31 :
32 :
33 : //=============================================================================
34 : // Implementation of CORBABooleanSeq
35 : //=============================================================================
36 :
37 1 : CORBABooleanSeq::CORBABooleanSeq()
38 : : _max(0),
39 : _length(0),
40 : _data(NULL),
41 1 : _release(false)
42 : {
43 : }
44 :
45 1 : CORBABooleanSeq::CORBABooleanSeq(CORBA::ULong max)
46 : : _max(max),
47 : _length(max),
48 : _data(NULL),
49 1 : _release(true)
50 : {
51 : ASSERT(max != 0) ;
52 :
53 1 : _data = new CORBA::Boolean[_max] ;
54 : }
55 :
56 : CORBABooleanSeq::CORBABooleanSeq(
57 : CORBA::ULong max,
58 : CORBA::ULong length,
59 : CORBA::Boolean* data,
60 2 : CORBA::Boolean release)
61 : : _max(max),
62 : _length(length),
63 : _data(data),
64 2 : _release(release)
65 : {
66 : ASSERT(length <= max) ;
67 : ASSERT((data != NULL) || (! release)) ;
68 : ASSERT((max != 0) || (! release)) ;
69 : }
70 :
71 2 : CORBABooleanSeq::CORBABooleanSeq(const CORBABooleanSeq& seq)
72 : : _max(seq._max),
73 : _length(seq._length),
74 : _data(NULL),
75 2 : _release(false)
76 : {
77 2 : if (_max != 0)
78 : {
79 1 : _data = new CORBA::Boolean[_max] ;
80 1 : _release = true ;
81 :
82 : memcpy(_data,
83 : seq._data,
84 1 : _length * sizeof(CORBA::Boolean)) ;
85 : }
86 : }
87 :
88 6 : CORBABooleanSeq::~CORBABooleanSeq()
89 : {
90 6 : if (_release)
91 : {
92 : ASSERT(_data != NULL) ;
93 3 : delete [] _data ;
94 : }
95 3 : }
96 :
97 : CORBABooleanSeq&
98 2 : CORBABooleanSeq::operator=(const CORBABooleanSeq& seq)
99 : {
100 2 : if (_max < seq._length)
101 : {
102 1 : if (_release)
103 : {
104 : ASSERT(_data != NULL) ;
105 0 : delete [] _data ;
106 : }
107 :
108 1 : _max = seq._length ;
109 1 : _data = new CORBA::Boolean[_max] ;
110 1 : _release = true ;
111 : }
112 :
113 2 : _length = seq._length ;
114 :
115 2 : if (_length != 0)
116 : {
117 : memcpy(_data,
118 : seq._data,
119 2 : _length * sizeof(CORBA::Boolean)) ;
120 : }
121 :
122 : return *this ;
123 : }
124 :
125 : CORBA::ULong
126 15 : CORBABooleanSeq::maximum() const
127 : {
128 : return _max ;
129 : }
130 :
131 : void
132 2 : CORBABooleanSeq::length(CORBA::ULong len)
133 : {
134 2 : if (_max < len)
135 : {
136 1 : CORBA::Boolean* new_data = new CORBA::Boolean[len] ;
137 :
138 1 : if (_length != 0)
139 : {
140 : memcpy(new_data,
141 : _data,
142 1 : _length * sizeof (CORBA::Boolean)) ;
143 : }
144 :
145 1 : if (_release)
146 : {
147 1 : delete [] _data ;
148 : }
149 :
150 1 : _data = new_data ;
151 1 : _max = len ;
152 1 : _release = true ;
153 : }
154 :
155 2 : if (len > _length)
156 : {
157 2 : _length = len ;
158 : }
159 : }
160 :
161 : CORBA::ULong
162 15 : CORBABooleanSeq::length() const
163 : {
164 : return _length ;
165 : }
166 :
167 : CORBA::Boolean&
168 83 : CORBABooleanSeq::operator[] (CORBA::ULong index)
169 : {
170 : ASSERT(index < _length) ;
171 : return _data[index] ;
172 : }
173 :
174 : const CORBA::Boolean&
175 0 : CORBABooleanSeq::operator[] (CORBA::ULong index) const
176 : {
177 : ASSERT(index < _length) ;
178 : return _data[index] ;
179 : }
180 :
181 : CORBA::Boolean
182 15 : CORBABooleanSeq::release() const
183 : {
184 : return _release ;
185 : }
186 :
187 : void
188 : CORBABooleanSeq::replace(
189 : CORBA::ULong max,
190 : CORBA::ULong length,
191 : CORBA::Boolean* data,
192 3 : CORBA::Boolean release)
193 : {
194 : ASSERT(length <= max) ;
195 : ASSERT((data != NULL) || (! release)) ;
196 : ASSERT((max != 0) || (! release)) ;
197 :
198 3 : if (_release)
199 : {
200 0 : delete [] _data ;
201 : }
202 :
203 3 : _max = max ;
204 3 : _length = length ;
205 3 : _data = data ;
206 3 : _release = release ;
207 : }
208 :
209 : CORBA::Boolean*
210 16 : CORBABooleanSeq::get_buffer(CORBA::Boolean orphan)
211 : {
212 16 : CORBA::Boolean* buf = _data ;
213 :
214 16 : if (orphan)
215 : {
216 1 : _max = 0 ;
217 1 : _length = 0 ;
218 1 : _data = NULL ;
219 1 : _release = false ;
220 : }
221 :
222 : return buf ;
223 : }
224 :
225 : const CORBA::Boolean*
226 15 : CORBABooleanSeq::get_buffer(void) const
227 : {
228 : return _data ;
229 : }
230 :
231 : void
232 0 : CORBABooleanSeq::cdr(YAORB::CDR* cdrs)
233 : {
234 : ASSERT(cdrs != NULL) ;
235 :
236 0 : cdrs->cdr_ULong(& _length) ;
237 :
238 0 : if (_length > _max)
239 : {
240 0 : if (_release)
241 : {
242 0 : delete [] _data ;
243 : }
244 :
245 0 : _max = _length ;
246 0 : _data = new CORBA::Boolean[_max] ;
247 0 : _release = true ;
248 : }
249 :
250 0 : cdrs->cdr_BooleanArray(_data, _length) ;
251 : }
252 :
253 : //=============================================================================
254 : // Implementation of CORBACharSeq
255 : //=============================================================================
256 :
257 1 : CORBACharSeq::CORBACharSeq()
258 : : _max(0),
259 : _length(0),
260 : _data(NULL),
261 1 : _release(false)
262 : {
263 : }
264 :
265 1 : CORBACharSeq::CORBACharSeq(CORBA::ULong max)
266 : : _max(max),
267 : _length(max),
268 : _data(NULL),
269 1 : _release(true)
270 : {
271 : ASSERT(max != 0) ;
272 :
273 1 : _data = new CORBA::Char[_max] ;
274 : }
275 :
276 : CORBACharSeq::CORBACharSeq(
277 : CORBA::ULong max,
278 : CORBA::ULong length,
279 : CORBA::Char* data,
280 2 : CORBA::Boolean release)
281 : : _max(max),
282 : _length(length),
283 : _data(data),
284 2 : _release(release)
285 : {
286 : ASSERT(length <= max) ;
287 : ASSERT((data != NULL) || (! release)) ;
288 : ASSERT((max != 0) || (! release)) ;
289 : }
290 :
291 2 : CORBACharSeq::CORBACharSeq(const CORBACharSeq& seq)
292 : : _max(seq._max),
293 : _length(seq._length),
294 : _data(NULL),
295 2 : _release(false)
296 : {
297 2 : if (_max != 0)
298 : {
299 1 : _data = new CORBA::Char[_max] ;
300 1 : _release = true ;
301 :
302 : memcpy(_data,
303 : seq._data,
304 1 : _length * sizeof(CORBA::Char)) ;
305 : }
306 : }
307 :
308 6 : CORBACharSeq::~CORBACharSeq()
309 : {
310 6 : if (_release)
311 : {
312 : ASSERT(_data != NULL) ;
313 3 : delete [] _data ;
314 : }
315 3 : }
316 :
317 : CORBACharSeq&
318 2 : CORBACharSeq::operator=(const CORBACharSeq& seq)
319 : {
320 2 : if (_max < seq._length)
321 : {
322 1 : if (_release)
323 : {
324 : ASSERT(_data != NULL) ;
325 0 : delete [] _data ;
326 : }
327 :
328 1 : _max = seq._length ;
329 1 : _data = new CORBA::Char[_max] ;
330 1 : _release = true ;
331 : }
332 :
333 2 : _length = seq._length ;
334 :
335 2 : if (_length != 0)
336 : {
337 : memcpy(_data,
338 : seq._data,
339 2 : _length * sizeof(CORBA::Char)) ;
340 : }
341 :
342 : return *this ;
343 : }
344 :
345 : CORBA::ULong
346 15 : CORBACharSeq::maximum() const
347 : {
348 : return _max ;
349 : }
350 :
351 : void
352 2 : CORBACharSeq::length(CORBA::ULong len)
353 : {
354 2 : if (_max < len)
355 : {
356 1 : CORBA::Char* new_data = new CORBA::Char[len] ;
357 :
358 1 : if (_length != 0)
359 : {
360 : memcpy(new_data,
361 : _data,
362 1 : _length * sizeof (CORBA::Char)) ;
363 : }
364 :
365 1 : if (_release)
366 : {
367 1 : delete [] _data ;
368 : }
369 :
370 1 : _data = new_data ;
371 1 : _max = len ;
372 1 : _release = true ;
373 : }
374 :
375 2 : if (len > _length)
376 : {
377 2 : _length = len ;
378 : }
379 : }
380 :
381 : CORBA::ULong
382 15 : CORBACharSeq::length() const
383 : {
384 : return _length ;
385 : }
386 :
387 : CORBA::Char&
388 83 : CORBACharSeq::operator[] (CORBA::ULong index)
389 : {
390 : ASSERT(index < _length) ;
391 : return _data[index] ;
392 : }
393 :
394 : const CORBA::Char&
395 0 : CORBACharSeq::operator[] (CORBA::ULong index) const
396 : {
397 : ASSERT(index < _length) ;
398 : return _data[index] ;
399 : }
400 :
401 : CORBA::Boolean
402 15 : CORBACharSeq::release() const
403 : {
404 : return _release ;
405 : }
406 :
407 : void
408 : CORBACharSeq::replace(
409 : CORBA::ULong max,
410 : CORBA::ULong length,
411 : CORBA::Char* data,
412 3 : CORBA::Boolean release)
413 : {
414 : ASSERT(length <= max) ;
415 : ASSERT((data != NULL) || (! release)) ;
416 : ASSERT((max != 0) || (! release)) ;
417 :
418 3 : if (_release)
419 : {
420 0 : delete [] _data ;
421 : }
422 :
423 3 : _max = max ;
424 3 : _length = length ;
425 3 : _data = data ;
426 3 : _release = release ;
427 : }
428 :
429 : CORBA::Char*
430 16 : CORBACharSeq::get_buffer(CORBA::Boolean orphan)
431 : {
432 16 : CORBA::Char* buf = _data ;
433 :
434 16 : if (orphan)
435 : {
436 1 : _max = 0 ;
437 1 : _length = 0 ;
438 1 : _data = NULL ;
439 1 : _release = false ;
440 : }
441 :
442 : return buf ;
443 : }
444 :
445 : const CORBA::Char*
446 15 : CORBACharSeq::get_buffer(void) const
447 : {
448 : return _data ;
449 : }
450 :
451 : void
452 0 : CORBACharSeq::cdr(YAORB::CDR* cdrs)
453 : {
454 : ASSERT(cdrs != NULL) ;
455 :
456 0 : cdrs->cdr_ULong(& _length) ;
457 :
458 0 : if (_length > _max)
459 : {
460 0 : if (_release)
461 : {
462 0 : delete [] _data ;
463 : }
464 :
465 0 : _max = _length ;
466 0 : _data = new CORBA::Char[_max] ;
467 0 : _release = true ;
468 : }
469 :
470 0 : cdrs->cdr_CharArray(_data, _length) ;
471 : }
472 :
473 : //=============================================================================
474 : // Implementation of CORBAWCharSeq
475 : //=============================================================================
476 :
477 1 : CORBAWCharSeq::CORBAWCharSeq()
478 : : _max(0),
479 : _length(0),
480 : _data(NULL),
481 1 : _release(false)
482 : {
483 : }
484 :
485 1 : CORBAWCharSeq::CORBAWCharSeq(CORBA::ULong max)
486 : : _max(max),
487 : _length(max),
488 : _data(NULL),
489 1 : _release(true)
490 : {
491 : ASSERT(max != 0) ;
492 :
493 1 : _data = new CORBA::WChar[_max] ;
494 : }
495 :
496 : CORBAWCharSeq::CORBAWCharSeq(
497 : CORBA::ULong max,
498 : CORBA::ULong length,
499 : CORBA::WChar* data,
500 2 : CORBA::Boolean release)
501 : : _max(max),
502 : _length(length),
503 : _data(data),
504 2 : _release(release)
505 : {
506 : ASSERT(length <= max) ;
507 : ASSERT((data != NULL) || (! release)) ;
508 : ASSERT((max != 0) || (! release)) ;
509 : }
510 :
511 2 : CORBAWCharSeq::CORBAWCharSeq(const CORBAWCharSeq& seq)
512 : : _max(seq._max),
513 : _length(seq._length),
514 : _data(NULL),
515 2 : _release(false)
516 : {
517 2 : if (_max != 0)
518 : {
519 1 : _data = new CORBA::WChar[_max] ;
520 1 : _release = true ;
521 :
522 : memcpy(_data,
523 : seq._data,
524 1 : _length * sizeof(CORBA::WChar)) ;
525 : }
526 : }
527 :
528 6 : CORBAWCharSeq::~CORBAWCharSeq()
529 : {
530 6 : if (_release)
531 : {
532 : ASSERT(_data != NULL) ;
533 3 : delete [] _data ;
534 : }
535 3 : }
536 :
537 : CORBAWCharSeq&
538 2 : CORBAWCharSeq::operator=(const CORBAWCharSeq& seq)
539 : {
540 2 : if (_max < seq._length)
541 : {
542 1 : if (_release)
543 : {
544 : ASSERT(_data != NULL) ;
545 0 : delete [] _data ;
546 : }
547 :
548 1 : _max = seq._length ;
549 1 : _data = new CORBA::WChar[_max] ;
550 1 : _release = true ;
551 : }
552 :
553 2 : _length = seq._length ;
554 :
555 2 : if (_length != 0)
556 : {
557 : memcpy(_data,
558 : seq._data,
559 2 : _length * sizeof(CORBA::WChar)) ;
560 : }
561 :
562 : return *this ;
563 : }
564 :
565 : CORBA::ULong
566 15 : CORBAWCharSeq::maximum() const
567 : {
568 : return _max ;
569 : }
570 :
571 : void
572 2 : CORBAWCharSeq::length(CORBA::ULong len)
573 : {
574 2 : if (_max < len)
575 : {
576 1 : CORBA::WChar* new_data = new CORBA::WChar[len] ;
577 :
578 1 : if (_length != 0)
579 : {
580 : memcpy(new_data,
581 : _data,
582 1 : _length * sizeof (CORBA::WChar)) ;
583 : }
584 :
585 1 : if (_release)
586 : {
587 1 : delete [] _data ;
588 : }
589 :
590 1 : _data = new_data ;
591 1 : _max = len ;
592 1 : _release = true ;
593 : }
594 :
595 2 : if (len > _length)
596 : {
597 2 : _length = len ;
598 : }
599 : }
600 :
601 : CORBA::ULong
602 15 : CORBAWCharSeq::length() const
603 : {
604 : return _length ;
605 : }
606 :
607 : CORBA::WChar&
608 83 : CORBAWCharSeq::operator[] (CORBA::ULong index)
609 : {
610 : ASSERT(index < _length) ;
611 : return _data[index] ;
612 : }
613 :
614 : const CORBA::WChar&
615 0 : CORBAWCharSeq::operator[] (CORBA::ULong index) const
616 : {
617 : ASSERT(index < _length) ;
618 : return _data[index] ;
619 : }
620 :
621 : CORBA::Boolean
622 15 : CORBAWCharSeq::release() const
623 : {
624 : return _release ;
625 : }
626 :
627 : void
628 : CORBAWCharSeq::replace(
629 : CORBA::ULong max,
630 : CORBA::ULong length,
631 : CORBA::WChar* data,
632 3 : CORBA::Boolean release)
633 : {
634 : ASSERT(length <= max) ;
635 : ASSERT((data != NULL) || (! release)) ;
636 : ASSERT((max != 0) || (! release)) ;
637 :
638 3 : if (_release)
639 : {
640 0 : delete [] _data ;
641 : }
642 :
643 3 : _max = max ;
644 3 : _length = length ;
645 3 : _data = data ;
646 3 : _release = release ;
647 : }
648 :
649 : CORBA::WChar*
650 16 : CORBAWCharSeq::get_buffer(CORBA::Boolean orphan)
651 : {
652 16 : CORBA::WChar* buf = _data ;
653 :
654 16 : if (orphan)
655 : {
656 1 : _max = 0 ;
657 1 : _length = 0 ;
658 1 : _data = NULL ;
659 1 : _release = false ;
660 : }
661 :
662 : return buf ;
663 : }
664 :
665 : const CORBA::WChar*
666 15 : CORBAWCharSeq::get_buffer(void) const
667 : {
668 : return _data ;
669 : }
670 :
671 : void
672 0 : CORBAWCharSeq::cdr(YAORB::CDR* cdrs)
673 : {
674 : ASSERT(cdrs != NULL) ;
675 :
676 0 : cdrs->cdr_ULong(& _length) ;
677 :
678 0 : if (_length > _max)
679 : {
680 0 : if (_release)
681 : {
682 0 : delete [] _data ;
683 : }
684 :
685 0 : _max = _length ;
686 0 : _data = new CORBA::WChar[_max] ;
687 0 : _release = true ;
688 : }
689 :
690 0 : cdrs->cdr_WCharArray(_data, _length) ;
691 : }
692 :
693 : //=============================================================================
694 : // Implementation of CORBAOctetSeq
695 : //=============================================================================
696 :
697 4 : CORBAOctetSeq::CORBAOctetSeq()
698 : : _max(0),
699 : _length(0),
700 : _data(NULL),
701 4 : _release(false)
702 : {
703 : }
704 :
705 1 : CORBAOctetSeq::CORBAOctetSeq(CORBA::ULong max)
706 : : _max(max),
707 : _length(max),
708 : _data(NULL),
709 1 : _release(true)
710 : {
711 : ASSERT(max != 0) ;
712 :
713 1 : _data = new CORBA::Octet[_max] ;
714 : }
715 :
716 : CORBAOctetSeq::CORBAOctetSeq(
717 : CORBA::ULong max,
718 : CORBA::ULong length,
719 : CORBA::Octet* data,
720 2 : CORBA::Boolean release)
721 : : _max(max),
722 : _length(length),
723 : _data(data),
724 2 : _release(release)
725 : {
726 : ASSERT(length <= max) ;
727 : ASSERT((data != NULL) || (! release)) ;
728 : ASSERT((max != 0) || (! release)) ;
729 : }
730 :
731 2 : CORBAOctetSeq::CORBAOctetSeq(const CORBAOctetSeq& seq)
732 : : _max(seq._max),
733 : _length(seq._length),
734 : _data(NULL),
735 2 : _release(false)
736 : {
737 2 : if (_max != 0)
738 : {
739 1 : _data = new CORBA::Octet[_max] ;
740 1 : _release = true ;
741 :
742 : memcpy(_data,
743 : seq._data,
744 1 : _length * sizeof(CORBA::Octet)) ;
745 : }
746 : }
747 :
748 7 : CORBAOctetSeq::~CORBAOctetSeq()
749 : {
750 7 : if (_release)
751 : {
752 : ASSERT(_data != NULL) ;
753 4 : delete [] _data ;
754 : }
755 3 : }
756 :
757 : CORBAOctetSeq&
758 2 : CORBAOctetSeq::operator=(const CORBAOctetSeq& seq)
759 : {
760 2 : if (_max < seq._length)
761 : {
762 1 : if (_release)
763 : {
764 : ASSERT(_data != NULL) ;
765 0 : delete [] _data ;
766 : }
767 :
768 1 : _max = seq._length ;
769 1 : _data = new CORBA::Octet[_max] ;
770 1 : _release = true ;
771 : }
772 :
773 2 : _length = seq._length ;
774 :
775 2 : if (_length != 0)
776 : {
777 : memcpy(_data,
778 : seq._data,
779 2 : _length * sizeof(CORBA::Octet)) ;
780 : }
781 :
782 : return *this ;
783 : }
784 :
785 : CORBA::ULong
786 15 : CORBAOctetSeq::maximum() const
787 : {
788 : return _max ;
789 : }
790 :
791 : void
792 3 : CORBAOctetSeq::length(CORBA::ULong len)
793 : {
794 3 : if (_max < len)
795 : {
796 2 : CORBA::Octet* new_data = new CORBA::Octet[len] ;
797 :
798 2 : if (_length != 0)
799 : {
800 : memcpy(new_data,
801 : _data,
802 1 : _length * sizeof (CORBA::Octet)) ;
803 : }
804 :
805 2 : if (_release)
806 : {
807 1 : delete [] _data ;
808 : }
809 :
810 2 : _data = new_data ;
811 2 : _max = len ;
812 2 : _release = true ;
813 : }
814 :
815 3 : if (len > _length)
816 : {
817 3 : _length = len ;
818 : }
819 : }
820 :
821 : CORBA::ULong
822 15 : CORBAOctetSeq::length() const
823 : {
824 : return _length ;
825 : }
826 :
827 : CORBA::Octet&
828 87 : CORBAOctetSeq::operator[] (CORBA::ULong index)
829 : {
830 : ASSERT(index < _length) ;
831 : return _data[index] ;
832 : }
833 :
834 : const CORBA::Octet&
835 0 : CORBAOctetSeq::operator[] (CORBA::ULong index) const
836 : {
837 : ASSERT(index < _length) ;
838 : return _data[index] ;
839 : }
840 :
841 : CORBA::Boolean
842 15 : CORBAOctetSeq::release() const
843 : {
844 : return _release ;
845 : }
846 :
847 : void
848 : CORBAOctetSeq::replace(
849 : CORBA::ULong max,
850 : CORBA::ULong length,
851 : CORBA::Octet* data,
852 3 : CORBA::Boolean release)
853 : {
854 : ASSERT(length <= max) ;
855 : ASSERT((data != NULL) || (! release)) ;
856 : ASSERT((max != 0) || (! release)) ;
857 :
858 3 : if (_release)
859 : {
860 0 : delete [] _data ;
861 : }
862 :
863 3 : _max = max ;
864 3 : _length = length ;
865 3 : _data = data ;
866 3 : _release = release ;
867 : }
868 :
869 : CORBA::Octet*
870 16 : CORBAOctetSeq::get_buffer(CORBA::Boolean orphan)
871 : {
872 16 : CORBA::Octet* buf = _data ;
873 :
874 16 : if (orphan)
875 : {
876 1 : _max = 0 ;
877 1 : _length = 0 ;
878 1 : _data = NULL ;
879 1 : _release = false ;
880 : }
881 :
882 : return buf ;
883 : }
884 :
885 : const CORBA::Octet*
886 15 : CORBAOctetSeq::get_buffer(void) const
887 : {
888 : return _data ;
889 : }
890 :
891 : void
892 2 : CORBAOctetSeq::cdr(YAORB::CDR* cdrs)
893 : {
894 : ASSERT(cdrs != NULL) ;
895 :
896 2 : cdrs->cdr_ULong(& _length) ;
897 :
898 2 : if (_length > _max)
899 : {
900 2 : if (_release)
901 : {
902 0 : delete [] _data ;
903 : }
904 :
905 2 : _max = _length ;
906 2 : _data = new CORBA::Octet[_max] ;
907 2 : _release = true ;
908 : }
909 :
910 2 : cdrs->cdr_OctetArray(_data, _length) ;
911 : }
912 :
913 : //=============================================================================
914 : // Implementation of CORBAShortSeq
915 : //=============================================================================
916 :
917 1 : CORBAShortSeq::CORBAShortSeq()
918 : : _max(0),
919 : _length(0),
920 : _data(NULL),
921 1 : _release(false)
922 : {
923 : }
924 :
925 1 : CORBAShortSeq::CORBAShortSeq(CORBA::ULong max)
926 : : _max(max),
927 : _length(max),
928 : _data(NULL),
929 1 : _release(true)
930 : {
931 : ASSERT(max != 0) ;
932 :
933 1 : _data = new CORBA::Short[_max] ;
934 : }
935 :
936 : CORBAShortSeq::CORBAShortSeq(
937 : CORBA::ULong max,
938 : CORBA::ULong length,
939 : CORBA::Short* data,
940 2 : CORBA::Boolean release)
941 : : _max(max),
942 : _length(length),
943 : _data(data),
944 2 : _release(release)
945 : {
946 : ASSERT(length <= max) ;
947 : ASSERT((data != NULL) || (! release)) ;
948 : ASSERT((max != 0) || (! release)) ;
949 : }
950 :
951 2 : CORBAShortSeq::CORBAShortSeq(const CORBAShortSeq& seq)
952 : : _max(seq._max),
953 : _length(seq._length),
954 : _data(NULL),
955 2 : _release(false)
956 : {
957 2 : if (_max != 0)
958 : {
959 1 : _data = new CORBA::Short[_max] ;
960 1 : _release = true ;
961 :
962 : memcpy(_data,
963 : seq._data,
964 1 : _length * sizeof(CORBA::Short)) ;
965 : }
966 : }
967 :
968 6 : CORBAShortSeq::~CORBAShortSeq()
969 : {
970 6 : if (_release)
971 : {
972 : ASSERT(_data != NULL) ;
973 3 : delete [] _data ;
974 : }
975 3 : }
976 :
977 : CORBAShortSeq&
978 2 : CORBAShortSeq::operator=(const CORBAShortSeq& seq)
979 : {
980 2 : if (_max < seq._length)
981 : {
982 1 : if (_release)
983 : {
984 : ASSERT(_data != NULL) ;
985 0 : delete [] _data ;
986 : }
987 :
988 1 : _max = seq._length ;
989 1 : _data = new CORBA::Short[_max] ;
990 1 : _release = true ;
991 : }
992 :
993 2 : _length = seq._length ;
994 :
995 2 : if (_length != 0)
996 : {
997 : memcpy(_data,
998 : seq._data,
999 2 : _length * sizeof(CORBA::Short)) ;
1000 : }
1001 :
1002 : return *this ;
1003 : }
1004 :
1005 : CORBA::ULong
1006 15 : CORBAShortSeq::maximum() const
1007 : {
1008 : return _max ;
1009 : }
1010 :
1011 : void
1012 2 : CORBAShortSeq::length(CORBA::ULong len)
1013 : {
1014 2 : if (_max < len)
1015 : {
1016 1 : CORBA::Short* new_data = new CORBA::Short[len] ;
1017 :
1018 1 : if (_length != 0)
1019 : {
1020 : memcpy(new_data,
1021 : _data,
1022 1 : _length * sizeof (CORBA::Short)) ;
1023 : }
1024 :
1025 1 : if (_release)
1026 : {
1027 1 : delete [] _data ;
1028 : }
1029 :
1030 1 : _data = new_data ;
1031 1 : _max = len ;
1032 1 : _release = true ;
1033 : }
1034 :
1035 2 : if (len > _length)
1036 : {
1037 2 : _length = len ;
1038 : }
1039 : }
1040 :
1041 : CORBA::ULong
1042 15 : CORBAShortSeq::length() const
1043 : {
1044 : return _length ;
1045 : }
1046 :
1047 : CORBA::Short&
1048 83 : CORBAShortSeq::operator[] (CORBA::ULong index)
1049 : {
1050 : ASSERT(index < _length) ;
1051 : return _data[index] ;
1052 : }
1053 :
1054 : const CORBA::Short&
1055 0 : CORBAShortSeq::operator[] (CORBA::ULong index) const
1056 : {
1057 : ASSERT(index < _length) ;
1058 : return _data[index] ;
1059 : }
1060 :
1061 : CORBA::Boolean
1062 15 : CORBAShortSeq::release() const
1063 : {
1064 : return _release ;
1065 : }
1066 :
1067 : void
1068 : CORBAShortSeq::replace(
1069 : CORBA::ULong max,
1070 : CORBA::ULong length,
1071 : CORBA::Short* data,
1072 3 : CORBA::Boolean release)
1073 : {
1074 : ASSERT(length <= max) ;
1075 : ASSERT((data != NULL) || (! release)) ;
1076 : ASSERT((max != 0) || (! release)) ;
1077 :
1078 3 : if (_release)
1079 : {
1080 0 : delete [] _data ;
1081 : }
1082 :
1083 3 : _max = max ;
1084 3 : _length = length ;
1085 3 : _data = data ;
1086 3 : _release = release ;
1087 : }
1088 :
1089 : CORBA::Short*
1090 16 : CORBAShortSeq::get_buffer(CORBA::Boolean orphan)
1091 : {
1092 16 : CORBA::Short* buf = _data ;
1093 :
1094 16 : if (orphan)
1095 : {
1096 1 : _max = 0 ;
1097 1 : _length = 0 ;
1098 1 : _data = NULL ;
1099 1 : _release = false ;
1100 : }
1101 :
1102 : return buf ;
1103 : }
1104 :
1105 : const CORBA::Short*
1106 15 : CORBAShortSeq::get_buffer(void) const
1107 : {
1108 : return _data ;
1109 : }
1110 :
1111 : void
1112 0 : CORBAShortSeq::cdr(YAORB::CDR* cdrs)
1113 : {
1114 : ASSERT(cdrs != NULL) ;
1115 :
1116 0 : cdrs->cdr_ULong(& _length) ;
1117 :
1118 0 : if (_length > _max)
1119 : {
1120 0 : if (_release)
1121 : {
1122 0 : delete [] _data ;
1123 : }
1124 :
1125 0 : _max = _length ;
1126 0 : _data = new CORBA::Short[_max] ;
1127 0 : _release = true ;
1128 : }
1129 :
1130 0 : cdrs->cdr_ShortArray(_data, _length) ;
1131 : }
1132 :
1133 : //=============================================================================
1134 : // Implementation of CORBAUShortSeq
1135 : //=============================================================================
1136 :
1137 1 : CORBAUShortSeq::CORBAUShortSeq()
1138 : : _max(0),
1139 : _length(0),
1140 : _data(NULL),
1141 1 : _release(false)
1142 : {
1143 : }
1144 :
1145 1 : CORBAUShortSeq::CORBAUShortSeq(CORBA::ULong max)
1146 : : _max(max),
1147 : _length(max),
1148 : _data(NULL),
1149 1 : _release(true)
1150 : {
1151 : ASSERT(max != 0) ;
1152 :
1153 1 : _data = new CORBA::UShort[_max] ;
1154 : }
1155 :
1156 : CORBAUShortSeq::CORBAUShortSeq(
1157 : CORBA::ULong max,
1158 : CORBA::ULong length,
1159 : CORBA::UShort* data,
1160 2 : CORBA::Boolean release)
1161 : : _max(max),
1162 : _length(length),
1163 : _data(data),
1164 2 : _release(release)
1165 : {
1166 : ASSERT(length <= max) ;
1167 : ASSERT((data != NULL) || (! release)) ;
1168 : ASSERT((max != 0) || (! release)) ;
1169 : }
1170 :
1171 2 : CORBAUShortSeq::CORBAUShortSeq(const CORBAUShortSeq& seq)
1172 : : _max(seq._max),
1173 : _length(seq._length),
1174 : _data(NULL),
1175 2 : _release(false)
1176 : {
1177 2 : if (_max != 0)
1178 : {
1179 1 : _data = new CORBA::UShort[_max] ;
1180 1 : _release = true ;
1181 :
1182 : memcpy(_data,
1183 : seq._data,
1184 1 : _length * sizeof(CORBA::UShort)) ;
1185 : }
1186 : }
1187 :
1188 6 : CORBAUShortSeq::~CORBAUShortSeq()
1189 : {
1190 6 : if (_release)
1191 : {
1192 : ASSERT(_data != NULL) ;
1193 3 : delete [] _data ;
1194 : }
1195 3 : }
1196 :
1197 : CORBAUShortSeq&
1198 2 : CORBAUShortSeq::operator=(const CORBAUShortSeq& seq)
1199 : {
1200 2 : if (_max < seq._length)
1201 : {
1202 1 : if (_release)
1203 : {
1204 : ASSERT(_data != NULL) ;
1205 0 : delete [] _data ;
1206 : }
1207 :
1208 1 : _max = seq._length ;
1209 1 : _data = new CORBA::UShort[_max] ;
1210 1 : _release = true ;
1211 : }
1212 :
1213 2 : _length = seq._length ;
1214 :
1215 2 : if (_length != 0)
1216 : {
1217 : memcpy(_data,
1218 : seq._data,
1219 2 : _length * sizeof(CORBA::UShort)) ;
1220 : }
1221 :
1222 : return *this ;
1223 : }
1224 :
1225 : CORBA::ULong
1226 15 : CORBAUShortSeq::maximum() const
1227 : {
1228 : return _max ;
1229 : }
1230 :
1231 : void
1232 2 : CORBAUShortSeq::length(CORBA::ULong len)
1233 : {
1234 2 : if (_max < len)
1235 : {
1236 1 : CORBA::UShort* new_data = new CORBA::UShort[len] ;
1237 :
1238 1 : if (_length != 0)
1239 : {
1240 : memcpy(new_data,
1241 : _data,
1242 1 : _length * sizeof (CORBA::UShort)) ;
1243 : }
1244 :
1245 1 : if (_release)
1246 : {
1247 1 : delete [] _data ;
1248 : }
1249 :
1250 1 : _data = new_data ;
1251 1 : _max = len ;
1252 1 : _release = true ;
1253 : }
1254 :
1255 2 : if (len > _length)
1256 : {
1257 2 : _length = len ;
1258 : }
1259 : }
1260 :
1261 : CORBA::ULong
1262 15 : CORBAUShortSeq::length() const
1263 : {
1264 : return _length ;
1265 : }
1266 :
1267 : CORBA::UShort&
1268 83 : CORBAUShortSeq::operator[] (CORBA::ULong index)
1269 : {
1270 : ASSERT(index < _length) ;
1271 : return _data[index] ;
1272 : }
1273 :
1274 : const CORBA::UShort&
1275 0 : CORBAUShortSeq::operator[] (CORBA::ULong index) const
1276 : {
1277 : ASSERT(index < _length) ;
1278 : return _data[index] ;
1279 : }
1280 :
1281 : CORBA::Boolean
1282 15 : CORBAUShortSeq::release() const
1283 : {
1284 : return _release ;
1285 : }
1286 :
1287 : void
1288 : CORBAUShortSeq::replace(
1289 : CORBA::ULong max,
1290 : CORBA::ULong length,
1291 : CORBA::UShort* data,
1292 3 : CORBA::Boolean release)
1293 : {
1294 : ASSERT(length <= max) ;
1295 : ASSERT((data != NULL) || (! release)) ;
1296 : ASSERT((max != 0) || (! release)) ;
1297 :
1298 3 : if (_release)
1299 : {
1300 0 : delete [] _data ;
1301 : }
1302 :
1303 3 : _max = max ;
1304 3 : _length = length ;
1305 3 : _data = data ;
1306 3 : _release = release ;
1307 : }
1308 :
1309 : CORBA::UShort*
1310 16 : CORBAUShortSeq::get_buffer(CORBA::Boolean orphan)
1311 : {
1312 16 : CORBA::UShort* buf = _data ;
1313 :
1314 16 : if (orphan)
1315 : {
1316 1 : _max = 0 ;
1317 1 : _length = 0 ;
1318 1 : _data = NULL ;
1319 1 : _release = false ;
1320 : }
1321 :
1322 : return buf ;
1323 : }
1324 :
1325 : const CORBA::UShort*
1326 15 : CORBAUShortSeq::get_buffer(void) const
1327 : {
1328 : return _data ;
1329 : }
1330 :
1331 : void
1332 0 : CORBAUShortSeq::cdr(YAORB::CDR* cdrs)
1333 : {
1334 : ASSERT(cdrs != NULL) ;
1335 :
1336 0 : cdrs->cdr_ULong(& _length) ;
1337 :
1338 0 : if (_length > _max)
1339 : {
1340 0 : if (_release)
1341 : {
1342 0 : delete [] _data ;
1343 : }
1344 :
1345 0 : _max = _length ;
1346 0 : _data = new CORBA::UShort[_max] ;
1347 0 : _release = true ;
1348 : }
1349 :
1350 0 : cdrs->cdr_UShortArray(_data, _length) ;
1351 : }
1352 :
1353 : //=============================================================================
1354 : // Implementation of CORBALongSeq
1355 : //=============================================================================
1356 :
1357 1 : CORBALongSeq::CORBALongSeq()
1358 : : _max(0),
1359 : _length(0),
1360 : _data(NULL),
1361 1 : _release(false)
1362 : {
1363 : }
1364 :
1365 1 : CORBALongSeq::CORBALongSeq(CORBA::ULong max)
1366 : : _max(max),
1367 : _length(max),
1368 : _data(NULL),
1369 1 : _release(true)
1370 : {
1371 : ASSERT(max != 0) ;
1372 :
1373 1 : _data = new CORBA::Long[_max] ;
1374 : }
1375 :
1376 : CORBALongSeq::CORBALongSeq(
1377 : CORBA::ULong max,
1378 : CORBA::ULong length,
1379 : CORBA::Long* data,
1380 2 : CORBA::Boolean release)
1381 : : _max(max),
1382 : _length(length),
1383 : _data(data),
1384 2 : _release(release)
1385 : {
1386 : ASSERT(length <= max) ;
1387 : ASSERT((data != NULL) || (! release)) ;
1388 : ASSERT((max != 0) || (! release)) ;
1389 : }
1390 :
1391 2 : CORBALongSeq::CORBALongSeq(const CORBALongSeq& seq)
1392 : : _max(seq._max),
1393 : _length(seq._length),
1394 : _data(NULL),
1395 2 : _release(false)
1396 : {
1397 2 : if (_max != 0)
1398 : {
1399 1 : _data = new CORBA::Long[_max] ;
1400 1 : _release = true ;
1401 :
1402 : memcpy(_data,
1403 : seq._data,
1404 1 : _length * sizeof(CORBA::Long)) ;
1405 : }
1406 : }
1407 :
1408 6 : CORBALongSeq::~CORBALongSeq()
1409 : {
1410 6 : if (_release)
1411 : {
1412 : ASSERT(_data != NULL) ;
1413 3 : delete [] _data ;
1414 : }
1415 3 : }
1416 :
1417 : CORBALongSeq&
1418 2 : CORBALongSeq::operator=(const CORBALongSeq& seq)
1419 : {
1420 2 : if (_max < seq._length)
1421 : {
1422 1 : if (_release)
1423 : {
1424 : ASSERT(_data != NULL) ;
1425 0 : delete [] _data ;
1426 : }
1427 :
1428 1 : _max = seq._length ;
1429 1 : _data = new CORBA::Long[_max] ;
1430 1 : _release = true ;
1431 : }
1432 :
1433 2 : _length = seq._length ;
1434 :
1435 2 : if (_length != 0)
1436 : {
1437 : memcpy(_data,
1438 : seq._data,
1439 2 : _length * sizeof(CORBA::Long)) ;
1440 : }
1441 :
1442 : return *this ;
1443 : }
1444 :
1445 : CORBA::ULong
1446 15 : CORBALongSeq::maximum() const
1447 : {
1448 : return _max ;
1449 : }
1450 :
1451 : void
1452 2 : CORBALongSeq::length(CORBA::ULong len)
1453 : {
1454 2 : if (_max < len)
1455 : {
1456 1 : CORBA::Long* new_data = new CORBA::Long[len] ;
1457 :
1458 1 : if (_length != 0)
1459 : {
1460 : memcpy(new_data,
1461 : _data,
1462 1 : _length * sizeof (CORBA::Long)) ;
1463 : }
1464 :
1465 1 : if (_release)
1466 : {
1467 1 : delete [] _data ;
1468 : }
1469 :
1470 1 : _data = new_data ;
1471 1 : _max = len ;
1472 1 : _release = true ;
1473 : }
1474 :
1475 2 : if (len > _length)
1476 : {
1477 2 : _length = len ;
1478 : }
1479 : }
1480 :
1481 : CORBA::ULong
1482 15 : CORBALongSeq::length() const
1483 : {
1484 : return _length ;
1485 : }
1486 :
1487 : CORBA::Long&
1488 83 : CORBALongSeq::operator[] (CORBA::ULong index)
1489 : {
1490 : ASSERT(index < _length) ;
1491 : return _data[index] ;
1492 : }
1493 :
1494 : const CORBA::Long&
1495 0 : CORBALongSeq::operator[] (CORBA::ULong index) const
1496 : {
1497 : ASSERT(index < _length) ;
1498 : return _data[index] ;
1499 : }
1500 :
1501 : CORBA::Boolean
1502 15 : CORBALongSeq::release() const
1503 : {
1504 : return _release ;
1505 : }
1506 :
1507 : void
1508 : CORBALongSeq::replace(
1509 : CORBA::ULong max,
1510 : CORBA::ULong length,
1511 : CORBA::Long* data,
1512 3 : CORBA::Boolean release)
1513 : {
1514 : ASSERT(length <= max) ;
1515 : ASSERT((data != NULL) || (! release)) ;
1516 : ASSERT((max != 0) || (! release)) ;
1517 :
1518 3 : if (_release)
1519 : {
1520 0 : delete [] _data ;
1521 : }
1522 :
1523 3 : _max = max ;
1524 3 : _length = length ;
1525 3 : _data = data ;
1526 3 : _release = release ;
1527 : }
1528 :
1529 : CORBA::Long*
1530 16 : CORBALongSeq::get_buffer(CORBA::Boolean orphan)
1531 : {
1532 16 : CORBA::Long* buf = _data ;
1533 :
1534 16 : if (orphan)
1535 : {
1536 1 : _max = 0 ;
1537 1 : _length = 0 ;
1538 1 : _data = NULL ;
1539 1 : _release = false ;
1540 : }
1541 :
1542 : return buf ;
1543 : }
1544 :
1545 : const CORBA::Long*
1546 15 : CORBALongSeq::get_buffer(void) const
1547 : {
1548 : return _data ;
1549 : }
1550 :
1551 : void
1552 0 : CORBALongSeq::cdr(YAORB::CDR* cdrs)
1553 : {
1554 : ASSERT(cdrs != NULL) ;
1555 :
1556 0 : cdrs->cdr_ULong(& _length) ;
1557 :
1558 0 : if (_length > _max)
1559 : {
1560 0 : if (_release)
1561 : {
1562 0 : delete [] _data ;
1563 : }
1564 :
1565 0 : _max = _length ;
1566 0 : _data = new CORBA::Long[_max] ;
1567 0 : _release = true ;
1568 : }
1569 :
1570 0 : cdrs->cdr_LongArray(_data, _length) ;
1571 : }
1572 :
1573 : //=============================================================================
1574 : // Implementation of CORBALongLongSeq
1575 : //=============================================================================
1576 :
1577 1 : CORBALongLongSeq::CORBALongLongSeq()
1578 : : _max(0),
1579 : _length(0),
1580 : _data(NULL),
1581 1 : _release(false)
1582 : {
1583 : }
1584 :
1585 1 : CORBALongLongSeq::CORBALongLongSeq(CORBA::ULong max)
1586 : : _max(max),
1587 : _length(max),
1588 : _data(NULL),
1589 1 : _release(true)
1590 : {
1591 : ASSERT(max != 0) ;
1592 :
1593 1 : _data = new CORBA::LongLong[_max] ;
1594 : }
1595 :
1596 : CORBALongLongSeq::CORBALongLongSeq(
1597 : CORBA::ULong max,
1598 : CORBA::ULong length,
1599 : CORBA::LongLong* data,
1600 2 : CORBA::Boolean release)
1601 : : _max(max),
1602 : _length(length),
1603 : _data(data),
1604 2 : _release(release)
1605 : {
1606 : ASSERT(length <= max) ;
1607 : ASSERT((data != NULL) || (! release)) ;
1608 : ASSERT((max != 0) || (! release)) ;
1609 : }
1610 :
1611 2 : CORBALongLongSeq::CORBALongLongSeq(const CORBALongLongSeq& seq)
1612 : : _max(seq._max),
1613 : _length(seq._length),
1614 : _data(NULL),
1615 2 : _release(false)
1616 : {
1617 2 : if (_max != 0)
1618 : {
1619 1 : _data = new CORBA::LongLong[_max] ;
1620 1 : _release = true ;
1621 :
1622 : memcpy(_data,
1623 : seq._data,
1624 1 : _length * sizeof(CORBA::LongLong)) ;
1625 : }
1626 : }
1627 :
1628 6 : CORBALongLongSeq::~CORBALongLongSeq()
1629 : {
1630 6 : if (_release)
1631 : {
1632 : ASSERT(_data != NULL) ;
1633 3 : delete [] _data ;
1634 : }
1635 3 : }
1636 :
1637 : CORBALongLongSeq&
1638 2 : CORBALongLongSeq::operator=(const CORBALongLongSeq& seq)
1639 : {
1640 2 : if (_max < seq._length)
1641 : {
1642 1 : if (_release)
1643 : {
1644 : ASSERT(_data != NULL) ;
1645 0 : delete [] _data ;
1646 : }
1647 :
1648 1 : _max = seq._length ;
1649 1 : _data = new CORBA::LongLong[_max] ;
1650 1 : _release = true ;
1651 : }
1652 :
1653 2 : _length = seq._length ;
1654 :
1655 2 : if (_length != 0)
1656 : {
1657 : memcpy(_data,
1658 : seq._data,
1659 2 : _length * sizeof(CORBA::LongLong)) ;
1660 : }
1661 :
1662 : return *this ;
1663 : }
1664 :
1665 : CORBA::ULong
1666 15 : CORBALongLongSeq::maximum() const
1667 : {
1668 : return _max ;
1669 : }
1670 :
1671 : void
1672 2 : CORBALongLongSeq::length(CORBA::ULong len)
1673 : {
1674 2 : if (_max < len)
1675 : {
1676 1 : CORBA::LongLong* new_data = new CORBA::LongLong[len] ;
1677 :
1678 1 : if (_length != 0)
1679 : {
1680 : memcpy(new_data,
1681 : _data,
1682 1 : _length * sizeof (CORBA::LongLong)) ;
1683 : }
1684 :
1685 1 : if (_release)
1686 : {
1687 1 : delete [] _data ;
1688 : }
1689 :
1690 1 : _data = new_data ;
1691 1 : _max = len ;
1692 1 : _release = true ;
1693 : }
1694 :
1695 2 : if (len > _length)
1696 : {
1697 2 : _length = len ;
1698 : }
1699 : }
1700 :
1701 : CORBA::ULong
1702 15 : CORBALongLongSeq::length() const
1703 : {
1704 : return _length ;
1705 : }
1706 :
1707 : CORBA::LongLong&
1708 91 : CORBALongLongSeq::operator[] (CORBA::ULong index)
1709 : {
1710 : ASSERT(index < _length) ;
1711 : return _data[index] ;
1712 : }
1713 :
1714 : const CORBA::LongLong&
1715 0 : CORBALongLongSeq::operator[] (CORBA::ULong index) const
1716 : {
1717 : ASSERT(index < _length) ;
1718 : return _data[index] ;
1719 : }
1720 :
1721 : CORBA::Boolean
1722 15 : CORBALongLongSeq::release() const
1723 : {
1724 : return _release ;
1725 : }
1726 :
1727 : void
1728 : CORBALongLongSeq::replace(
1729 : CORBA::ULong max,
1730 : CORBA::ULong length,
1731 : CORBA::LongLong* data,
1732 3 : CORBA::Boolean release)
1733 : {
1734 : ASSERT(length <= max) ;
1735 : ASSERT((data != NULL) || (! release)) ;
1736 : ASSERT((max != 0) || (! release)) ;
1737 :
1738 3 : if (_release)
1739 : {
1740 0 : delete [] _data ;
1741 : }
1742 :
1743 3 : _max = max ;
1744 3 : _length = length ;
1745 3 : _data = data ;
1746 3 : _release = release ;
1747 : }
1748 :
1749 : CORBA::LongLong*
1750 16 : CORBALongLongSeq::get_buffer(CORBA::Boolean orphan)
1751 : {
1752 16 : CORBA::LongLong* buf = _data ;
1753 :
1754 16 : if (orphan)
1755 : {
1756 1 : _max = 0 ;
1757 1 : _length = 0 ;
1758 1 : _data = NULL ;
1759 1 : _release = false ;
1760 : }
1761 :
1762 : return buf ;
1763 : }
1764 :
1765 : const CORBA::LongLong*
1766 15 : CORBALongLongSeq::get_buffer(void) const
1767 : {
1768 : return _data ;
1769 : }
1770 :
1771 : void
1772 0 : CORBALongLongSeq::cdr(YAORB::CDR* cdrs)
1773 : {
1774 : ASSERT(cdrs != NULL) ;
1775 :
1776 0 : cdrs->cdr_ULong(& _length) ;
1777 :
1778 0 : if (_length > _max)
1779 : {
1780 0 : if (_release)
1781 : {
1782 0 : delete [] _data ;
1783 : }
1784 :
1785 0 : _max = _length ;
1786 0 : _data = new CORBA::LongLong[_max] ;
1787 0 : _release = true ;
1788 : }
1789 :
1790 0 : cdrs->cdr_LongLongArray(_data, _length) ;
1791 : }
1792 :
1793 : //=============================================================================
1794 : // Implementation of CORBAULongSeq
1795 : //=============================================================================
1796 :
1797 1 : CORBAULongSeq::CORBAULongSeq()
1798 : : _max(0),
1799 : _length(0),
1800 : _data(NULL),
1801 1 : _release(false)
1802 : {
1803 : }
1804 :
1805 1 : CORBAULongSeq::CORBAULongSeq(CORBA::ULong max)
1806 : : _max(max),
1807 : _length(max),
1808 : _data(NULL),
1809 1 : _release(true)
1810 : {
1811 : ASSERT(max != 0) ;
1812 :
1813 1 : _data = new CORBA::ULong[_max] ;
1814 : }
1815 :
1816 : CORBAULongSeq::CORBAULongSeq(
1817 : CORBA::ULong max,
1818 : CORBA::ULong length,
1819 : CORBA::ULong* data,
1820 2 : CORBA::Boolean release)
1821 : : _max(max),
1822 : _length(length),
1823 : _data(data),
1824 2 : _release(release)
1825 : {
1826 : ASSERT(length <= max) ;
1827 : ASSERT((data != NULL) || (! release)) ;
1828 : ASSERT((max != 0) || (! release)) ;
1829 : }
1830 :
1831 2 : CORBAULongSeq::CORBAULongSeq(const CORBAULongSeq& seq)
1832 : : _max(seq._max),
1833 : _length(seq._length),
1834 : _data(NULL),
1835 2 : _release(false)
1836 : {
1837 2 : if (_max != 0)
1838 : {
1839 1 : _data = new CORBA::ULong[_max] ;
1840 1 : _release = true ;
1841 :
1842 : memcpy(_data,
1843 : seq._data,
1844 1 : _length * sizeof(CORBA::ULong)) ;
1845 : }
1846 : }
1847 :
1848 6 : CORBAULongSeq::~CORBAULongSeq()
1849 : {
1850 6 : if (_release)
1851 : {
1852 : ASSERT(_data != NULL) ;
1853 3 : delete [] _data ;
1854 : }
1855 3 : }
1856 :
1857 : CORBAULongSeq&
1858 2 : CORBAULongSeq::operator=(const CORBAULongSeq& seq)
1859 : {
1860 2 : if (_max < seq._length)
1861 : {
1862 1 : if (_release)
1863 : {
1864 : ASSERT(_data != NULL) ;
1865 0 : delete [] _data ;
1866 : }
1867 :
1868 1 : _max = seq._length ;
1869 1 : _data = new CORBA::ULong[_max] ;
1870 1 : _release = true ;
1871 : }
1872 :
1873 2 : _length = seq._length ;
1874 :
1875 2 : if (_length != 0)
1876 : {
1877 : memcpy(_data,
1878 : seq._data,
1879 2 : _length * sizeof(CORBA::ULong)) ;
1880 : }
1881 :
1882 : return *this ;
1883 : }
1884 :
1885 : CORBA::ULong
1886 15 : CORBAULongSeq::maximum() const
1887 : {
1888 : return _max ;
1889 : }
1890 :
1891 : void
1892 2 : CORBAULongSeq::length(CORBA::ULong len)
1893 : {
1894 2 : if (_max < len)
1895 : {
1896 1 : CORBA::ULong* new_data = new CORBA::ULong[len] ;
1897 :
1898 1 : if (_length != 0)
1899 : {
1900 : memcpy(new_data,
1901 : _data,
1902 1 : _length * sizeof (CORBA::ULong)) ;
1903 : }
1904 :
1905 1 : if (_release)
1906 : {
1907 1 : delete [] _data ;
1908 : }
1909 :
1910 1 : _data = new_data ;
1911 1 : _max = len ;
1912 1 : _release = true ;
1913 : }
1914 :
1915 2 : if (len > _length)
1916 : {
1917 2 : _length = len ;
1918 : }
1919 : }
1920 :
1921 : CORBA::ULong
1922 15 : CORBAULongSeq::length() const
1923 : {
1924 : return _length ;
1925 : }
1926 :
1927 : CORBA::ULong&
1928 83 : CORBAULongSeq::operator[] (CORBA::ULong index)
1929 : {
1930 : ASSERT(index < _length) ;
1931 : return _data[index] ;
1932 : }
1933 :
1934 : const CORBA::ULong&
1935 0 : CORBAULongSeq::operator[] (CORBA::ULong index) const
1936 : {
1937 : ASSERT(index < _length) ;
1938 : return _data[index] ;
1939 : }
1940 :
1941 : CORBA::Boolean
1942 15 : CORBAULongSeq::release() const
1943 : {
1944 : return _release ;
1945 : }
1946 :
1947 : void
1948 : CORBAULongSeq::replace(
1949 : CORBA::ULong max,
1950 : CORBA::ULong length,
1951 : CORBA::ULong* data,
1952 3 : CORBA::Boolean release)
1953 : {
1954 : ASSERT(length <= max) ;
1955 : ASSERT((data != NULL) || (! release)) ;
1956 : ASSERT((max != 0) || (! release)) ;
1957 :
1958 3 : if (_release)
1959 : {
1960 0 : delete [] _data ;
1961 : }
1962 :
1963 3 : _max = max ;
1964 3 : _length = length ;
1965 3 : _data = data ;
1966 3 : _release = release ;
1967 : }
1968 :
1969 : CORBA::ULong*
1970 16 : CORBAULongSeq::get_buffer(CORBA::Boolean orphan)
1971 : {
1972 16 : CORBA::ULong* buf = _data ;
1973 :
1974 16 : if (orphan)
1975 : {
1976 1 : _max = 0 ;
1977 1 : _length = 0 ;
1978 1 : _data = NULL ;
1979 1 : _release = false ;
1980 : }
1981 :
1982 : return buf ;
1983 : }
1984 :
1985 : const CORBA::ULong*
1986 15 : CORBAULongSeq::get_buffer(void) const
1987 : {
1988 : return _data ;
1989 : }
1990 :
1991 : void
1992 0 : CORBAULongSeq::cdr(YAORB::CDR* cdrs)
1993 : {
1994 : ASSERT(cdrs != NULL) ;
1995 :
1996 0 : cdrs->cdr_ULong(& _length) ;
1997 :
1998 0 : if (_length > _max)
1999 : {
2000 0 : if (_release)
2001 : {
2002 0 : delete [] _data ;
2003 : }
2004 :
2005 0 : _max = _length ;
2006 0 : _data = new CORBA::ULong[_max] ;
2007 0 : _release = true ;
2008 : }
2009 :
2010 0 : cdrs->cdr_ULongArray(_data, _length) ;
2011 : }
2012 :
2013 : //=============================================================================
2014 : // Implementation of CORBAULongLongSeq
2015 : //=============================================================================
2016 :
2017 1 : CORBAULongLongSeq::CORBAULongLongSeq()
2018 : : _max(0),
2019 : _length(0),
2020 : _data(NULL),
2021 1 : _release(false)
2022 : {
2023 : }
2024 :
2025 1 : CORBAULongLongSeq::CORBAULongLongSeq(CORBA::ULong max)
2026 : : _max(max),
2027 : _length(max),
2028 : _data(NULL),
2029 1 : _release(true)
2030 : {
2031 : ASSERT(max != 0) ;
2032 :
2033 1 : _data = new CORBA::ULongLong[_max] ;
2034 : }
2035 :
2036 : CORBAULongLongSeq::CORBAULongLongSeq(
2037 : CORBA::ULong max,
2038 : CORBA::ULong length,
2039 : CORBA::ULongLong* data,
2040 2 : CORBA::Boolean release)
2041 : : _max(max),
2042 : _length(length),
2043 : _data(data),
2044 2 : _release(release)
2045 : {
2046 : ASSERT(length <= max) ;
2047 : ASSERT((data != NULL) || (! release)) ;
2048 : ASSERT((max != 0) || (! release)) ;
2049 : }
2050 :
2051 2 : CORBAULongLongSeq::CORBAULongLongSeq(const CORBAULongLongSeq& seq)
2052 : : _max(seq._max),
2053 : _length(seq._length),
2054 : _data(NULL),
2055 2 : _release(false)
2056 : {
2057 2 : if (_max != 0)
2058 : {
2059 1 : _data = new CORBA::ULongLong[_max] ;
2060 1 : _release = true ;
2061 :
2062 : memcpy(_data,
2063 : seq._data,
2064 1 : _length * sizeof(CORBA::ULongLong)) ;
2065 : }
2066 : }
2067 :
2068 6 : CORBAULongLongSeq::~CORBAULongLongSeq()
2069 : {
2070 6 : if (_release)
2071 : {
2072 : ASSERT(_data != NULL) ;
2073 3 : delete [] _data ;
2074 : }
2075 3 : }
2076 :
2077 : CORBAULongLongSeq&
2078 2 : CORBAULongLongSeq::operator=(const CORBAULongLongSeq& seq)
2079 : {
2080 2 : if (_max < seq._length)
2081 : {
2082 1 : if (_release)
2083 : {
2084 : ASSERT(_data != NULL) ;
2085 0 : delete [] _data ;
2086 : }
2087 :
2088 1 : _max = seq._length ;
2089 1 : _data = new CORBA::ULongLong[_max] ;
2090 1 : _release = true ;
2091 : }
2092 :
2093 2 : _length = seq._length ;
2094 :
2095 2 : if (_length != 0)
2096 : {
2097 : memcpy(_data,
2098 : seq._data,
2099 2 : _length * sizeof(CORBA::ULongLong)) ;
2100 : }
2101 :
2102 : return *this ;
2103 : }
2104 :
2105 : CORBA::ULong
2106 15 : CORBAULongLongSeq::maximum() const
2107 : {
2108 : return _max ;
2109 : }
2110 :
2111 : void
2112 2 : CORBAULongLongSeq::length(CORBA::ULong len)
2113 : {
2114 2 : if (_max < len)
2115 : {
2116 1 : CORBA::ULongLong* new_data = new CORBA::ULongLong[len] ;
2117 :
2118 1 : if (_length != 0)
2119 : {
2120 : memcpy(new_data,
2121 : _data,
2122 1 : _length * sizeof (CORBA::ULongLong)) ;
2123 : }
2124 :
2125 1 : if (_release)
2126 : {
2127 1 : delete [] _data ;
2128 : }
2129 :
2130 1 : _data = new_data ;
2131 1 : _max = len ;
2132 1 : _release = true ;
2133 : }
2134 :
2135 2 : if (len > _length)
2136 : {
2137 2 : _length = len ;
2138 : }
2139 : }
2140 :
2141 : CORBA::ULong
2142 15 : CORBAULongLongSeq::length() const
2143 : {
2144 : return _length ;
2145 : }
2146 :
2147 : CORBA::ULongLong&
2148 91 : CORBAULongLongSeq::operator[] (CORBA::ULong index)
2149 : {
2150 : ASSERT(index < _length) ;
2151 : return _data[index] ;
2152 : }
2153 :
2154 : const CORBA::ULongLong&
2155 0 : CORBAULongLongSeq::operator[] (CORBA::ULong index) const
2156 : {
2157 : ASSERT(index < _length) ;
2158 : return _data[index] ;
2159 : }
2160 :
2161 : CORBA::Boolean
2162 15 : CORBAULongLongSeq::release() const
2163 : {
2164 : return _release ;
2165 : }
2166 :
2167 : void
2168 : CORBAULongLongSeq::replace(
2169 : CORBA::ULong max,
2170 : CORBA::ULong length,
2171 : CORBA::ULongLong* data,
2172 3 : CORBA::Boolean release)
2173 : {
2174 : ASSERT(length <= max) ;
2175 : ASSERT((data != NULL) || (! release)) ;
2176 : ASSERT((max != 0) || (! release)) ;
2177 :
2178 3 : if (_release)
2179 : {
2180 0 : delete [] _data ;
2181 : }
2182 :
2183 3 : _max = max ;
2184 3 : _length = length ;
2185 3 : _data = data ;
2186 3 : _release = release ;
2187 : }
2188 :
2189 : CORBA::ULongLong*
2190 16 : CORBAULongLongSeq::get_buffer(CORBA::Boolean orphan)
2191 : {
2192 16 : CORBA::ULongLong* buf = _data ;
2193 :
2194 16 : if (orphan)
2195 : {
2196 1 : _max = 0 ;
2197 1 : _length = 0 ;
2198 1 : _data = NULL ;
2199 1 : _release = false ;
2200 : }
2201 :
2202 : return buf ;
2203 : }
2204 :
2205 : const CORBA::ULongLong*
2206 15 : CORBAULongLongSeq::get_buffer(void) const
2207 : {
2208 : return _data ;
2209 : }
2210 :
2211 : void
2212 0 : CORBAULongLongSeq::cdr(YAORB::CDR* cdrs)
2213 : {
2214 : ASSERT(cdrs != NULL) ;
2215 :
2216 0 : cdrs->cdr_ULong(& _length) ;
2217 :
2218 0 : if (_length > _max)
2219 : {
2220 0 : if (_release)
2221 : {
2222 0 : delete [] _data ;
2223 : }
2224 :
2225 0 : _max = _length ;
2226 0 : _data = new CORBA::ULongLong[_max] ;
2227 0 : _release = true ;
2228 : }
2229 :
2230 0 : cdrs->cdr_ULongLongArray(_data, _length) ;
2231 : }
2232 :
2233 : //=============================================================================
2234 : // Implementation of CORBAFloatSeq
2235 : //=============================================================================
2236 :
2237 1 : CORBAFloatSeq::CORBAFloatSeq()
2238 : : _max(0),
2239 : _length(0),
2240 : _data(NULL),
2241 1 : _release(false)
2242 : {
2243 : }
2244 :
2245 1 : CORBAFloatSeq::CORBAFloatSeq(CORBA::ULong max)
2246 : : _max(max),
2247 : _length(max),
2248 : _data(NULL),
2249 1 : _release(true)
2250 : {
2251 : ASSERT(max != 0) ;
2252 :
2253 1 : _data = new CORBA::Float[_max] ;
2254 : }
2255 :
2256 : CORBAFloatSeq::CORBAFloatSeq(
2257 : CORBA::ULong max,
2258 : CORBA::ULong length,
2259 : CORBA::Float* data,
2260 2 : CORBA::Boolean release)
2261 : : _max(max),
2262 : _length(length),
2263 : _data(data),
2264 2 : _release(release)
2265 : {
2266 : ASSERT(length <= max) ;
2267 : ASSERT((data != NULL) || (! release)) ;
2268 : ASSERT((max != 0) || (! release)) ;
2269 : }
2270 :
2271 2 : CORBAFloatSeq::CORBAFloatSeq(const CORBAFloatSeq& seq)
2272 : : _max(seq._max),
2273 : _length(seq._length),
2274 : _data(NULL),
2275 2 : _release(false)
2276 : {
2277 2 : if (_max != 0)
2278 : {
2279 1 : _data = new CORBA::Float[_max] ;
2280 1 : _release = true ;
2281 :
2282 : memcpy(_data,
2283 : seq._data,
2284 1 : _length * sizeof(CORBA::Float)) ;
2285 : }
2286 : }
2287 :
2288 6 : CORBAFloatSeq::~CORBAFloatSeq()
2289 : {
2290 6 : if (_release)
2291 : {
2292 : ASSERT(_data != NULL) ;
2293 3 : delete [] _data ;
2294 : }
2295 3 : }
2296 :
2297 : CORBAFloatSeq&
2298 2 : CORBAFloatSeq::operator=(const CORBAFloatSeq& seq)
2299 : {
2300 2 : if (_max < seq._length)
2301 : {
2302 1 : if (_release)
2303 : {
2304 : ASSERT(_data != NULL) ;
2305 0 : delete [] _data ;
2306 : }
2307 :
2308 1 : _max = seq._length ;
2309 1 : _data = new CORBA::Float[_max] ;
2310 1 : _release = true ;
2311 : }
2312 :
2313 2 : _length = seq._length ;
2314 :
2315 2 : if (_length != 0)
2316 : {
2317 : memcpy(_data,
2318 : seq._data,
2319 2 : _length * sizeof(CORBA::Float)) ;
2320 : }
2321 :
2322 : return *this ;
2323 : }
2324 :
2325 : CORBA::ULong
2326 15 : CORBAFloatSeq::maximum() const
2327 : {
2328 : return _max ;
2329 : }
2330 :
2331 : void
2332 2 : CORBAFloatSeq::length(CORBA::ULong len)
2333 : {
2334 2 : if (_max < len)
2335 : {
2336 1 : CORBA::Float* new_data = new CORBA::Float[len] ;
2337 :
2338 1 : if (_length != 0)
2339 : {
2340 : memcpy(new_data,
2341 : _data,
2342 1 : _length * sizeof (CORBA::Float)) ;
2343 : }
2344 :
2345 1 : if (_release)
2346 : {
2347 1 : delete [] _data ;
2348 : }
2349 :
2350 1 : _data = new_data ;
2351 1 : _max = len ;
2352 1 : _release = true ;
2353 : }
2354 :
2355 2 : if (len > _length)
2356 : {
2357 2 : _length = len ;
2358 : }
2359 : }
2360 :
2361 : CORBA::ULong
2362 15 : CORBAFloatSeq::length() const
2363 : {
2364 : return _length ;
2365 : }
2366 :
2367 : CORBA::Float&
2368 83 : CORBAFloatSeq::operator[] (CORBA::ULong index)
2369 : {
2370 : ASSERT(index < _length) ;
2371 : return _data[index] ;
2372 : }
2373 :
2374 : const CORBA::Float&
2375 0 : CORBAFloatSeq::operator[] (CORBA::ULong index) const
2376 : {
2377 : ASSERT(index < _length) ;
2378 : return _data[index] ;
2379 : }
2380 :
2381 : CORBA::Boolean
2382 15 : CORBAFloatSeq::release() const
2383 : {
2384 : return _release ;
2385 : }
2386 :
2387 : void
2388 : CORBAFloatSeq::replace(
2389 : CORBA::ULong max,
2390 : CORBA::ULong length,
2391 : CORBA::Float* data,
2392 3 : CORBA::Boolean release)
2393 : {
2394 : ASSERT(length <= max) ;
2395 : ASSERT((data != NULL) || (! release)) ;
2396 : ASSERT((max != 0) || (! release)) ;
2397 :
2398 3 : if (_release)
2399 : {
2400 0 : delete [] _data ;
2401 : }
2402 :
2403 3 : _max = max ;
2404 3 : _length = length ;
2405 3 : _data = data ;
2406 3 : _release = release ;
2407 : }
2408 :
2409 : CORBA::Float*
2410 16 : CORBAFloatSeq::get_buffer(CORBA::Boolean orphan)
2411 : {
2412 16 : CORBA::Float* buf = _data ;
2413 :
2414 16 : if (orphan)
2415 : {
2416 1 : _max = 0 ;
2417 1 : _length = 0 ;
2418 1 : _data = NULL ;
2419 1 : _release = false ;
2420 : }
2421 :
2422 : return buf ;
2423 : }
2424 :
2425 : const CORBA::Float*
2426 15 : CORBAFloatSeq::get_buffer(void) const
2427 : {
2428 : return _data ;
2429 : }
2430 :
2431 : void
2432 0 : CORBAFloatSeq::cdr(YAORB::CDR* cdrs)
2433 : {
2434 : ASSERT(cdrs != NULL) ;
2435 :
2436 0 : cdrs->cdr_ULong(& _length) ;
2437 :
2438 0 : if (_length > _max)
2439 : {
2440 0 : if (_release)
2441 : {
2442 0 : delete [] _data ;
2443 : }
2444 :
2445 0 : _max = _length ;
2446 0 : _data = new CORBA::Float[_max] ;
2447 0 : _release = true ;
2448 : }
2449 :
2450 0 : cdrs->cdr_FloatArray(_data, _length) ;
2451 : }
2452 :
2453 : //=============================================================================
2454 : // Implementation of CORBADoubleSeq
2455 : //=============================================================================
2456 :
2457 1 : CORBADoubleSeq::CORBADoubleSeq()
2458 : : _max(0),
2459 : _length(0),
2460 : _data(NULL),
2461 1 : _release(false)
2462 : {
2463 : }
2464 :
2465 1 : CORBADoubleSeq::CORBADoubleSeq(CORBA::ULong max)
2466 : : _max(max),
2467 : _length(max),
2468 : _data(NULL),
2469 1 : _release(true)
2470 : {
2471 : ASSERT(max != 0) ;
2472 :
2473 1 : _data = new CORBA::Double[_max] ;
2474 : }
2475 :
2476 : CORBADoubleSeq::CORBADoubleSeq(
2477 : CORBA::ULong max,
2478 : CORBA::ULong length,
2479 : CORBA::Double* data,
2480 2 : CORBA::Boolean release)
2481 : : _max(max),
2482 : _length(length),
2483 : _data(data),
2484 2 : _release(release)
2485 : {
2486 : ASSERT(length <= max) ;
2487 : ASSERT((data != NULL) || (! release)) ;
2488 : ASSERT((max != 0) || (! release)) ;
2489 : }
2490 :
2491 2 : CORBADoubleSeq::CORBADoubleSeq(const CORBADoubleSeq& seq)
2492 : : _max(seq._max),
2493 : _length(seq._length),
2494 : _data(NULL),
2495 2 : _release(false)
2496 : {
2497 2 : if (_max != 0)
2498 : {
2499 1 : _data = new CORBA::Double[_max] ;
2500 1 : _release = true ;
2501 :
2502 : memcpy(_data,
2503 : seq._data,
2504 1 : _length * sizeof(CORBA::Double)) ;
2505 : }
2506 : }
2507 :
2508 6 : CORBADoubleSeq::~CORBADoubleSeq()
2509 : {
2510 6 : if (_release)
2511 : {
2512 : ASSERT(_data != NULL) ;
2513 3 : delete [] _data ;
2514 : }
2515 3 : }
2516 :
2517 : CORBADoubleSeq&
2518 2 : CORBADoubleSeq::operator=(const CORBADoubleSeq& seq)
2519 : {
2520 2 : if (_max < seq._length)
2521 : {
2522 1 : if (_release)
2523 : {
2524 : ASSERT(_data != NULL) ;
2525 0 : delete [] _data ;
2526 : }
2527 :
2528 1 : _max = seq._length ;
2529 1 : _data = new CORBA::Double[_max] ;
2530 1 : _release = true ;
2531 : }
2532 :
2533 2 : _length = seq._length ;
2534 :
2535 2 : if (_length != 0)
2536 : {
2537 : memcpy(_data,
2538 : seq._data,
2539 2 : _length * sizeof(CORBA::Double)) ;
2540 : }
2541 :
2542 : return *this ;
2543 : }
2544 :
2545 : CORBA::ULong
2546 15 : CORBADoubleSeq::maximum() const
2547 : {
2548 : return _max ;
2549 : }
2550 :
2551 : void
2552 2 : CORBADoubleSeq::length(CORBA::ULong len)
2553 : {
2554 2 : if (_max < len)
2555 : {
2556 1 : CORBA::Double* new_data = new CORBA::Double[len] ;
2557 :
2558 1 : if (_length != 0)
2559 : {
2560 : memcpy(new_data,
2561 : _data,
2562 1 : _length * sizeof (CORBA::Double)) ;
2563 : }
2564 :
2565 1 : if (_release)
2566 : {
2567 1 : delete [] _data ;
2568 : }
2569 :
2570 1 : _data = new_data ;
2571 1 : _max = len ;
2572 1 : _release = true ;
2573 : }
2574 :
2575 2 : if (len > _length)
2576 : {
2577 2 : _length = len ;
2578 : }
2579 : }
2580 :
2581 : CORBA::ULong
2582 15 : CORBADoubleSeq::length() const
2583 : {
2584 : return _length ;
2585 : }
2586 :
2587 : CORBA::Double&
2588 83 : CORBADoubleSeq::operator[] (CORBA::ULong index)
2589 : {
2590 : ASSERT(index < _length) ;
2591 : return _data[index] ;
2592 : }
2593 :
2594 : const CORBA::Double&
2595 0 : CORBADoubleSeq::operator[] (CORBA::ULong index) const
2596 : {
2597 : ASSERT(index < _length) ;
2598 : return _data[index] ;
2599 : }
2600 :
2601 : CORBA::Boolean
2602 15 : CORBADoubleSeq::release() const
2603 : {
2604 : return _release ;
2605 : }
2606 :
2607 : void
2608 : CORBADoubleSeq::replace(
2609 : CORBA::ULong max,
2610 : CORBA::ULong length,
2611 : CORBA::Double* data,
2612 3 : CORBA::Boolean release)
2613 : {
2614 : ASSERT(length <= max) ;
2615 : ASSERT((data != NULL) || (! release)) ;
2616 : ASSERT((max != 0) || (! release)) ;
2617 :
2618 3 : if (_release)
2619 : {
2620 0 : delete [] _data ;
2621 : }
2622 :
2623 3 : _max = max ;
2624 3 : _length = length ;
2625 3 : _data = data ;
2626 3 : _release = release ;
2627 : }
2628 :
2629 : CORBA::Double*
2630 16 : CORBADoubleSeq::get_buffer(CORBA::Boolean orphan)
2631 : {
2632 16 : CORBA::Double* buf = _data ;
2633 :
2634 16 : if (orphan)
2635 : {
2636 1 : _max = 0 ;
2637 1 : _length = 0 ;
2638 1 : _data = NULL ;
2639 1 : _release = false ;
2640 : }
2641 :
2642 : return buf ;
2643 : }
2644 :
2645 : const CORBA::Double*
2646 15 : CORBADoubleSeq::get_buffer(void) const
2647 : {
2648 : return _data ;
2649 : }
2650 :
2651 : void
2652 0 : CORBADoubleSeq::cdr(YAORB::CDR* cdrs)
2653 : {
2654 : ASSERT(cdrs != NULL) ;
2655 :
2656 0 : cdrs->cdr_ULong(& _length) ;
2657 :
2658 0 : if (_length > _max)
2659 : {
2660 0 : if (_release)
2661 : {
2662 0 : delete [] _data ;
2663 : }
2664 :
2665 0 : _max = _length ;
2666 0 : _data = new CORBA::Double[_max] ;
2667 0 : _release = true ;
2668 : }
2669 :
2670 0 : cdrs->cdr_DoubleArray(_data, _length) ;
2671 : }
2672 :
2673 : //=============================================================================
2674 : // Implementation of CORBALongDoubleSeq
2675 : //=============================================================================
2676 :
2677 1 : CORBALongDoubleSeq::CORBALongDoubleSeq()
2678 : : _max(0),
2679 : _length(0),
2680 : _data(NULL),
2681 1 : _release(false)
2682 : {
2683 : }
2684 :
2685 1 : CORBALongDoubleSeq::CORBALongDoubleSeq(CORBA::ULong max)
2686 : : _max(max),
2687 : _length(max),
2688 : _data(NULL),
2689 1 : _release(true)
2690 : {
2691 : ASSERT(max != 0) ;
2692 :
2693 1 : _data = new CORBA::LongDouble[_max] ;
2694 : }
2695 :
2696 : CORBALongDoubleSeq::CORBALongDoubleSeq(
2697 : CORBA::ULong max,
2698 : CORBA::ULong length,
2699 : CORBA::LongDouble* data,
2700 2 : CORBA::Boolean release)
2701 : : _max(max),
2702 : _length(length),
2703 : _data(data),
2704 2 : _release(release)
2705 : {
2706 : ASSERT(length <= max) ;
2707 : ASSERT((data != NULL) || (! release)) ;
2708 : ASSERT((max != 0) || (! release)) ;
2709 : }
2710 :
2711 2 : CORBALongDoubleSeq::CORBALongDoubleSeq(const CORBALongDoubleSeq& seq)
2712 : : _max(seq._max),
2713 : _length(seq._length),
2714 : _data(NULL),
2715 2 : _release(false)
2716 : {
2717 2 : if (_max != 0)
2718 : {
2719 1 : _data = new CORBA::LongDouble[_max] ;
2720 1 : _release = true ;
2721 :
2722 : memcpy(_data,
2723 : seq._data,
2724 1 : _length * sizeof(CORBA::LongDouble)) ;
2725 : }
2726 : }
2727 :
2728 6 : CORBALongDoubleSeq::~CORBALongDoubleSeq()
2729 : {
2730 6 : if (_release)
2731 : {
2732 : ASSERT(_data != NULL) ;
2733 3 : delete [] _data ;
2734 : }
2735 3 : }
2736 :
2737 : CORBALongDoubleSeq&
2738 2 : CORBALongDoubleSeq::operator=(const CORBALongDoubleSeq& seq)
2739 : {
2740 2 : if (_max < seq._length)
2741 : {
2742 1 : if (_release)
2743 : {
2744 : ASSERT(_data != NULL) ;
2745 0 : delete [] _data ;
2746 : }
2747 :
2748 1 : _max = seq._length ;
2749 1 : _data = new CORBA::LongDouble[_max] ;
2750 1 : _release = true ;
2751 : }
2752 :
2753 2 : _length = seq._length ;
2754 :
2755 2 : if (_length != 0)
2756 : {
2757 : memcpy(_data,
2758 : seq._data,
2759 2 : _length * sizeof(CORBA::LongDouble)) ;
2760 : }
2761 :
2762 : return *this ;
2763 : }
2764 :
2765 : CORBA::ULong
2766 15 : CORBALongDoubleSeq::maximum() const
2767 : {
2768 : return _max ;
2769 : }
2770 :
2771 : void
2772 2 : CORBALongDoubleSeq::length(CORBA::ULong len)
2773 : {
2774 2 : if (_max < len)
2775 : {
2776 1 : CORBA::LongDouble* new_data = new CORBA::LongDouble[len] ;
2777 :
2778 1 : if (_length != 0)
2779 : {
2780 : memcpy(new_data,
2781 : _data,
2782 1 : _length * sizeof (CORBA::LongDouble)) ;
2783 : }
2784 :
2785 1 : if (_release)
2786 : {
2787 1 : delete [] _data ;
2788 : }
2789 :
2790 1 : _data = new_data ;
2791 1 : _max = len ;
2792 1 : _release = true ;
2793 : }
2794 :
2795 2 : if (len > _length)
2796 : {
2797 2 : _length = len ;
2798 : }
2799 : }
2800 :
2801 : CORBA::ULong
2802 15 : CORBALongDoubleSeq::length() const
2803 : {
2804 : return _length ;
2805 : }
2806 :
2807 : CORBA::LongDouble&
2808 83 : CORBALongDoubleSeq::operator[] (CORBA::ULong index)
2809 : {
2810 : ASSERT(index < _length) ;
2811 : return _data[index] ;
2812 : }
2813 :
2814 : const CORBA::LongDouble&
2815 0 : CORBALongDoubleSeq::operator[] (CORBA::ULong index) const
2816 : {
2817 : ASSERT(index < _length) ;
2818 : return _data[index] ;
2819 : }
2820 :
2821 : CORBA::Boolean
2822 15 : CORBALongDoubleSeq::release() const
2823 : {
2824 : return _release ;
2825 : }
2826 :
2827 : void
2828 : CORBALongDoubleSeq::replace(
2829 : CORBA::ULong max,
2830 : CORBA::ULong length,
2831 : CORBA::LongDouble* data,
2832 3 : CORBA::Boolean release)
2833 : {
2834 : ASSERT(length <= max) ;
2835 : ASSERT((data != NULL) || (! release)) ;
2836 : ASSERT((max != 0) || (! release)) ;
2837 :
2838 3 : if (_release)
2839 : {
2840 0 : delete [] _data ;
2841 : }
2842 :
2843 3 : _max = max ;
2844 3 : _length = length ;
2845 3 : _data = data ;
2846 3 : _release = release ;
2847 : }
2848 :
2849 : CORBA::LongDouble*
2850 16 : CORBALongDoubleSeq::get_buffer(CORBA::Boolean orphan)
2851 : {
2852 16 : CORBA::LongDouble* buf = _data ;
2853 :
2854 16 : if (orphan)
2855 : {
2856 1 : _max = 0 ;
2857 1 : _length = 0 ;
2858 1 : _data = NULL ;
2859 1 : _release = false ;
2860 : }
2861 :
2862 : return buf ;
2863 : }
2864 :
2865 : const CORBA::LongDouble*
2866 15 : CORBALongDoubleSeq::get_buffer(void) const
2867 : {
2868 : return _data ;
2869 : }
2870 :
2871 : void
2872 0 : CORBALongDoubleSeq::cdr(YAORB::CDR* cdrs)
2873 : {
2874 : ASSERT(cdrs != NULL) ;
2875 :
2876 0 : cdrs->cdr_ULong(& _length) ;
2877 :
2878 0 : if (_length > _max)
2879 : {
2880 0 : if (_release)
2881 : {
2882 0 : delete [] _data ;
2883 : }
2884 :
2885 0 : _max = _length ;
2886 0 : _data = new CORBA::LongDouble[_max] ;
2887 0 : _release = true ;
2888 : }
2889 :
2890 0 : cdrs->cdr_LongDoubleArray(_data, _length) ;
2891 : }
2892 :
2893 : //=============================================================================
2894 : // Implementation of CORBAVoidSequence
2895 : //=============================================================================
2896 :
2897 : CORBAVoidSequence::CORBAVoidSequence(
2898 : int TSize,
2899 : TAlloc allocFn,
2900 : TCopy copyFn,
2901 : TCDR cdrFn,
2902 25 : TFree freeFn)
2903 : : _TSize(TSize),
2904 : _allocFn(allocFn),
2905 : _copyFn(copyFn),
2906 : _cdrFn(cdrFn),
2907 : _freeFn(freeFn),
2908 : _max(0),
2909 : _length(0),
2910 : _data(NULL),
2911 25 : _release(false)
2912 : {
2913 : ASSERT(_allocFn != NULL) ;
2914 : ASSERT(_copyFn != NULL) ;
2915 : ASSERT(_cdrFn != NULL) ;
2916 : ASSERT(_freeFn != NULL) ;
2917 : }
2918 :
2919 : CORBAVoidSequence::CORBAVoidSequence(
2920 : int TSize,
2921 : TAlloc allocFn,
2922 : TCopy copyFn,
2923 : TCDR cdrFn,
2924 : TFree freeFn,
2925 2 : CORBA::ULong max)
2926 : : _TSize(TSize),
2927 : _allocFn(allocFn),
2928 : _copyFn(copyFn),
2929 : _cdrFn(cdrFn),
2930 : _freeFn(freeFn),
2931 : _max(max),
2932 : _length(max),
2933 : _data(NULL),
2934 2 : _release(true)
2935 : {
2936 : ASSERT(max != 0) ;
2937 : ASSERT(_allocFn != NULL) ;
2938 : ASSERT(_copyFn != NULL) ;
2939 : ASSERT(_cdrFn != NULL) ;
2940 : ASSERT(_freeFn != NULL) ;
2941 :
2942 2 : _data = (*_allocFn)(_max) ;
2943 : }
2944 :
2945 : CORBAVoidSequence::CORBAVoidSequence(
2946 : int TSize,
2947 : TAlloc allocFn,
2948 : TCopy copyFn,
2949 : TCDR cdrFn,
2950 : TFree freeFn,
2951 : CORBA::ULong max,
2952 : CORBA::ULong length,
2953 : void* data,
2954 5 : CORBA::Boolean release)
2955 : : _TSize(TSize),
2956 : _allocFn(allocFn),
2957 : _copyFn(copyFn),
2958 : _cdrFn(cdrFn),
2959 : _freeFn(freeFn),
2960 : _max(max),
2961 : _length(length),
2962 : _data(data),
2963 5 : _release(release)
2964 : {
2965 : ASSERT(_allocFn != NULL) ;
2966 : ASSERT(_copyFn != NULL) ;
2967 : ASSERT(_cdrFn != NULL) ;
2968 : ASSERT(_freeFn != NULL) ;
2969 : }
2970 :
2971 : CORBAVoidSequence::CORBAVoidSequence(
2972 : int TSize,
2973 : TAlloc allocFn,
2974 : TCopy copyFn,
2975 : TCDR cdrFn,
2976 : TFree freeFn,
2977 5 : const CORBAVoidSequence& seq)
2978 : : _TSize(TSize),
2979 : _allocFn(allocFn),
2980 : _copyFn(copyFn),
2981 : _cdrFn(cdrFn),
2982 : _freeFn(freeFn),
2983 : _max(seq._max),
2984 : _length(seq._length),
2985 : _data(NULL),
2986 5 : _release(false)
2987 : {
2988 : ASSERT(_TSize == seq._TSize) ;
2989 : ASSERT(_allocFn != NULL) ;
2990 : ASSERT(_copyFn != NULL) ;
2991 : ASSERT(_cdrFn != NULL) ;
2992 : ASSERT(_freeFn != NULL) ;
2993 :
2994 5 : if (_max != 0)
2995 : {
2996 5 : _data = (*_allocFn)(_max) ;
2997 5 : _release = true ;
2998 :
2999 5 : CORBA::Octet *src = (CORBA::Octet*) seq._data ;
3000 5 : CORBA::Octet *dst = (CORBA::Octet*) _data ;
3001 : unsigned int index ;
3002 :
3003 37 : for (index = 0 ;
3004 : index < _length ;
3005 : index++, src += seq._TSize, dst += _TSize)
3006 : {
3007 32 : (*_copyFn)(src, dst) ;
3008 : }
3009 : }
3010 : }
3011 :
3012 : CORBAVoidSequence&
3013 : CORBAVoidSequence::operator=(
3014 0 : const CORBAVoidSequence& seq)
3015 : {
3016 : ASSERT(_TSize == seq._TSize) ;
3017 :
3018 0 : if (_max < seq._length)
3019 : {
3020 0 : if (_release)
3021 : {
3022 : ASSERT(_data != NULL) ;
3023 0 : (*_freeFn)(_data) ;
3024 : }
3025 :
3026 0 : _max = seq._length ;
3027 0 : _data = (*_allocFn)(_max) ;
3028 0 : _release = true ;
3029 : }
3030 :
3031 0 : _length = seq._length ;
3032 :
3033 0 : if (_length != 0)
3034 : {
3035 0 : CORBA::Octet *src = (CORBA::Octet*) seq._data ;
3036 0 : CORBA::Octet *dst = (CORBA::Octet*) _data ;
3037 : unsigned int index ;
3038 :
3039 0 : for (index = 0 ;
3040 : index < _length ;
3041 : index++, src += seq._TSize, dst += _TSize)
3042 : {
3043 0 : (*_copyFn)(src, dst) ;
3044 : }
3045 : }
3046 :
3047 : return *this ;
3048 : }
3049 :
3050 28 : CORBAVoidSequence::~CORBAVoidSequence()
3051 : {
3052 28 : if (_release)
3053 : {
3054 : ASSERT(_data != NULL) ;
3055 6 : (*_freeFn)(_data) ;
3056 : }
3057 22 : }
3058 :
3059 58 : CORBA::ULong CORBAVoidSequence::length(void) const
3060 : {
3061 : return _length ;
3062 : }
3063 :
3064 17 : void CORBAVoidSequence::length(CORBA::ULong len)
3065 : {
3066 17 : if (_max < len)
3067 : {
3068 : CORBA::ULong new_len = len ;
3069 : void* new_data = NULL ;
3070 4 : new_data = (*_allocFn)(new_len) ;
3071 :
3072 4 : if (_length != 0)
3073 : {
3074 0 : CORBA::Octet *src = (CORBA::Octet*) _data ;
3075 0 : CORBA::Octet *dst = (CORBA::Octet*) new_data ;
3076 : unsigned int index ;
3077 :
3078 0 : for (index = 0 ;
3079 : index < _length ;
3080 : index++, src += _TSize, dst += _TSize)
3081 : {
3082 0 : (*_copyFn)(src, dst) ;
3083 : }
3084 : }
3085 :
3086 4 : if (_release)
3087 : {
3088 : ASSERT(_data != NULL) ;
3089 0 : (*_freeFn)(_data) ;
3090 : }
3091 :
3092 4 : _data = new_data ;
3093 4 : _max = new_len ;
3094 4 : _release = true ;
3095 : }
3096 :
3097 17 : _length = len ;
3098 : }
3099 :
3100 54 : void* CORBAVoidSequence::operator[](CORBA::ULong index) const
3101 : {
3102 54 : CORBA::Octet *elem = (CORBA::Octet*) _data ;
3103 :
3104 : ASSERT(index < _max) ;
3105 :
3106 : elem += index * _TSize ;
3107 : return elem ;
3108 : }
3109 :
3110 19 : void CORBAVoidSequence::cdr(YAORB::CDR *cdrs)
3111 : {
3112 : ASSERT(cdrs != NULL) ;
3113 19 : CORBA::ULong len = 0 ;
3114 :
3115 19 : switch (cdrs->Op())
3116 : {
3117 : case YAORB::CDR_READ :
3118 : {
3119 15 : cdrs->cdr_ULong(& len) ;
3120 15 : length(len) ;
3121 15 : break ;
3122 : }
3123 : case YAORB::CDR_WRITE :
3124 : {
3125 4 : len = length() ;
3126 4 : cdrs->cdr_ULong(& len) ;
3127 : break ;
3128 : }
3129 : }
3130 :
3131 : unsigned int index ;
3132 19 : CORBA::Octet *elem = (CORBA::Octet*) _data ;
3133 :
3134 23 : for (index = 0 ;
3135 : index < _length ;
3136 : index++, elem += _TSize)
3137 : {
3138 4 : (*_cdrFn)(cdrs, elem) ;
3139 : }
3140 : }
3141 :
3142 0 : void CORBAVoidSequence::cdr(YAORB::CDR *cdrs) const
3143 : {
3144 : ASSERT(cdrs != NULL) ;
3145 : ASSERT(cdrs->Op() == YAORB::CDR_WRITE) ;
3146 : CORBAVoidSequence *that = (CORBAVoidSequence*) this ;
3147 0 : that->cdr(cdrs) ;
3148 : }
3149 :
|
