GCC Code Coverage Report

Directory: ./
File: src/hpp/common-idl.hh
Date: 2024-09-11 11:37:19
Exec Total Coverage
Lines: 18 174 10.3%
Branches: 6 106 5.7%
Line Branch Exec Source
1 // This file is generated by omniidl (C++ backend)- omniORB_4_3. Do not edit.
2 #ifndef __common_hh__
3 #define __common_hh__
4
5 #ifndef __CORBA_H_EXTERNAL_GUARD__
6 #include <omniORB4/CORBA.h>
7 #endif
8
9 #ifndef USE_stub_in_nt_dll
10 # define USE_stub_in_nt_dll_NOT_DEFINED_common
11 #endif
12 #ifndef USE_core_stub_in_nt_dll
13 # define USE_core_stub_in_nt_dll_NOT_DEFINED_common
14 #endif
15 #ifndef USE_dyn_stub_in_nt_dll
16 # define USE_dyn_stub_in_nt_dll_NOT_DEFINED_common
17 #endif
18
19
20
21
22
23
24 #ifdef USE_stub_in_nt_dll
25 # ifndef USE_core_stub_in_nt_dll
26 # define USE_core_stub_in_nt_dll
27 # endif
28 # ifndef USE_dyn_stub_in_nt_dll
29 # define USE_dyn_stub_in_nt_dll
30 # endif
31 #endif
32
33 #ifdef _core_attr
34 # error "A local CPP macro _core_attr has already been defined."
35 #else
36 # ifdef USE_core_stub_in_nt_dll
37 # define _core_attr _OMNIORB_NTDLL_IMPORT
38 # else
39 # define _core_attr
40 # endif
41 #endif
42
43 #ifdef _dyn_attr
44 # error "A local CPP macro _dyn_attr has already been defined."
45 #else
46 # ifdef USE_dyn_stub_in_nt_dll
47 # define _dyn_attr _OMNIORB_NTDLL_IMPORT
48 # else
49 # define _dyn_attr
50 # endif
51 #endif
52
53
54
55 _CORBA_MODULE hpp
56
57 _CORBA_MODULE_BEG
58
59 _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_value_type;
60
61 typedef ::CORBA::Double value_type;
62 typedef ::CORBA::Double_out value_type_out;
63
64 _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_size_type;
65
66 typedef ::CORBA::LongLong size_type;
67 typedef ::CORBA::LongLong_out size_type_out;
68
69 _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_frame_index;
70
71 typedef ::CORBA::ULong frame_index;
72 typedef ::CORBA::ULong_out frame_index_out;
73
74 _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_Names_t;
75
76 class Names_t_var;
77
78 class Names_t : public _CORBA_Unbounded_Sequence_String {
79 public:
80 typedef Names_t_var _var_type;
81 ✗ inline Names_t() {}
82 ✗ inline Names_t(const Names_t& _s)
83 ✗ : _CORBA_Unbounded_Sequence_String(_s) {}
84
85 ✗ inline Names_t(_CORBA_ULong _max)
86 ✗ : _CORBA_Unbounded_Sequence_String(_max) {}
87 3 inline Names_t(_CORBA_ULong _max, _CORBA_ULong _len, char** _val, _CORBA_Boolean _rel=0)
88 3 : _CORBA_Unbounded_Sequence_String(_max, _len, _val, _rel) {}
89
90
91
92 ✗ inline Names_t& operator = (const Names_t& _s) {
93 ✗ _CORBA_Unbounded_Sequence_String::operator=(_s);
94 ✗ return *this;
95 }
96 };
97
98 class Names_t_out;
99
100 class Names_t_var {
101 public:
102 3 inline Names_t_var() : _pd_seq(0) {}
103 inline Names_t_var(Names_t* _s) : _pd_seq(_s) {}
104 inline Names_t_var(const Names_t_var& _s) {
105 if (_s._pd_seq) _pd_seq = new Names_t(*_s._pd_seq);
106 else _pd_seq = 0;
107 }
108
2/4
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✗ Branch 3 not taken.
 3 inline ~Names_t_var() { if (_pd_seq) delete _pd_seq; }
109
110 3 inline Names_t_var& operator = (Names_t* _s) {
111
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 3 if (_pd_seq) delete _pd_seq;
112 3 _pd_seq = _s;
113 3 return *this;
114 }
115 inline Names_t_var& operator = (const Names_t_var& _s) {
116 if (&_s != this) {
117 if (_s._pd_seq) {
118 if (!_pd_seq) _pd_seq = new Names_t;
119 *_pd_seq = *_s._pd_seq;
120 }
121 else if (_pd_seq) {
122 delete _pd_seq;
123 _pd_seq = 0;
124 }
125 }
126 return *this;
127 }
128 inline _CORBA_String_element operator [] (_CORBA_ULong _s) {
129 return (*_pd_seq)[_s];
130 }
131
132
133
134 inline Names_t* operator -> () { return _pd_seq; }
135 inline const Names_t* operator -> () const { return _pd_seq; }
136 #if defined(__GNUG__)
137 3 inline operator Names_t& () const { return *_pd_seq; }
138 #else
139 inline operator const Names_t& () const { return *_pd_seq; }
140 inline operator Names_t& () { return *_pd_seq; }
141 #endif
142
143 ✗ inline const Names_t& in() const { return *_pd_seq; }
144 inline Names_t& inout() { return *_pd_seq; }
145 ✗ inline Names_t*& out() {
146 ✗ if (_pd_seq) { delete _pd_seq; _pd_seq = 0; }
147 ✗ return _pd_seq;
148 }
149 ✗ inline Names_t* _retn() { Names_t* tmp = _pd_seq; _pd_seq = 0; return tmp; }
150
151 friend class Names_t_out;
152
153 private:
154 Names_t* _pd_seq;
155 };
156
157 class Names_t_out {
158 public:
159 ✗ inline Names_t_out(Names_t*& _s) : _data(_s) { _data = 0; }
160 inline Names_t_out(Names_t_var& _s)
161 : _data(_s._pd_seq) { _s = (Names_t*) 0; }
162 inline Names_t_out(const Names_t_out& _s) : _data(_s._data) {}
163 inline Names_t_out& operator = (const Names_t_out& _s) {
164 _data = _s._data;
165 return *this;
166 }
167 ✗ inline Names_t_out& operator = (Names_t* _s) {
168 ✗ _data = _s;
169 ✗ return *this;
170 }
171 inline operator Names_t*&() { return _data; }
172 inline Names_t*& ptr() { return _data; }
173 inline Names_t* operator->() { return _data; }
174
175 inline _CORBA_String_element operator [] (_CORBA_ULong _i) {
176 return (*_data)[_i];
177 }
178
179
180
181 Names_t*& _data;
182
183 private:
184 Names_t_out();
185 Names_t_out& operator=(const Names_t_var&);
186 };
187
188 _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_stringSeqSeq;
189
190 class stringSeqSeq_var;
191
192 class stringSeqSeq : public _CORBA_Unbounded_Sequence< Names_t > {
193 public:
194 typedef stringSeqSeq_var _var_type;
195 ✗ inline stringSeqSeq() {}
196 ✗ inline stringSeqSeq(const stringSeqSeq& _s)
197 ✗ : _CORBA_Unbounded_Sequence< Names_t > (_s) {}
198
199 inline stringSeqSeq(_CORBA_ULong _max)
200 : _CORBA_Unbounded_Sequence< Names_t > (_max) {}
201 inline stringSeqSeq(_CORBA_ULong _max, _CORBA_ULong _len, Names_t* _val, _CORBA_Boolean _rel=0)
202 : _CORBA_Unbounded_Sequence< Names_t > (_max, _len, _val, _rel) {}
203
204
205
206 inline stringSeqSeq& operator = (const stringSeqSeq& _s) {
207 _CORBA_Unbounded_Sequence< Names_t > ::operator=(_s);
208 return *this;
209 }
210 };
211
212 class stringSeqSeq_out;
213
214 class stringSeqSeq_var {
215 public:
216 inline stringSeqSeq_var() : _pd_seq(0) {}
217 inline stringSeqSeq_var(stringSeqSeq* _s) : _pd_seq(_s) {}
218 inline stringSeqSeq_var(const stringSeqSeq_var& _s) {
219 if (_s._pd_seq) _pd_seq = new stringSeqSeq(*_s._pd_seq);
220 else _pd_seq = 0;
221 }
222 inline ~stringSeqSeq_var() { if (_pd_seq) delete _pd_seq; }
223
224 inline stringSeqSeq_var& operator = (stringSeqSeq* _s) {
225 if (_pd_seq) delete _pd_seq;
226 _pd_seq = _s;
227 return *this;
228 }
229 inline stringSeqSeq_var& operator = (const stringSeqSeq_var& _s) {
230 if (&_s != this) {
231 if (_s._pd_seq) {
232 if (!_pd_seq) _pd_seq = new stringSeqSeq;
233 *_pd_seq = *_s._pd_seq;
234 }
235 else if (_pd_seq) {
236 delete _pd_seq;
237 _pd_seq = 0;
238 }
239 }
240 return *this;
241 }
242 inline Names_t& operator [] (_CORBA_ULong _s) {
243 return (*_pd_seq)[_s];
244 }
245
246
247
248 inline stringSeqSeq* operator -> () { return _pd_seq; }
249 inline const stringSeqSeq* operator -> () const { return _pd_seq; }
250 #if defined(__GNUG__)
251 inline operator stringSeqSeq& () const { return *_pd_seq; }
252 #else
253 inline operator const stringSeqSeq& () const { return *_pd_seq; }
254 inline operator stringSeqSeq& () { return *_pd_seq; }
255 #endif
256
257 inline const stringSeqSeq& in() const { return *_pd_seq; }
258 inline stringSeqSeq& inout() { return *_pd_seq; }
259 inline stringSeqSeq*& out() {
260 if (_pd_seq) { delete _pd_seq; _pd_seq = 0; }
261 return _pd_seq;
262 }
263 inline stringSeqSeq* _retn() { stringSeqSeq* tmp = _pd_seq; _pd_seq = 0; return tmp; }
264
265 friend class stringSeqSeq_out;
266
267 private:
268 stringSeqSeq* _pd_seq;
269 };
270
271 class stringSeqSeq_out {
272 public:
273 inline stringSeqSeq_out(stringSeqSeq*& _s) : _data(_s) { _data = 0; }
274 inline stringSeqSeq_out(stringSeqSeq_var& _s)
275 : _data(_s._pd_seq) { _s = (stringSeqSeq*) 0; }
276 inline stringSeqSeq_out(const stringSeqSeq_out& _s) : _data(_s._data) {}
277 inline stringSeqSeq_out& operator = (const stringSeqSeq_out& _s) {
278 _data = _s._data;
279 return *this;
280 }
281 inline stringSeqSeq_out& operator = (stringSeqSeq* _s) {
282 _data = _s;
283 return *this;
284 }
285 inline operator stringSeqSeq*&() { return _data; }
286 inline stringSeqSeq*& ptr() { return _data; }
287 inline stringSeqSeq* operator->() { return _data; }
288
289 inline Names_t& operator [] (_CORBA_ULong _i) {
290 return (*_data)[_i];
291 }
292
293
294
295 stringSeqSeq*& _data;
296
297 private:
298 stringSeqSeq_out();
299 stringSeqSeq_out& operator=(const stringSeqSeq_var&);
300 };
301
302 class Error : public ::CORBA::UserException {
303 public:
304
305 ::CORBA::String_member msg;
306
307
308
309 ✗ inline Error() {
310 ✗ pd_insertToAnyFn = insertToAnyFn;
311 ✗ pd_insertToAnyFnNCP = insertToAnyFnNCP;
312 }
313 Error(const Error&);
314 Error(const char* i_msg);
315 Error& operator=(const Error&);
316 virtual ~Error();
317 virtual void _raise() const;
318 static Error* _downcast(::CORBA::Exception*);
319 static const Error* _downcast(const ::CORBA::Exception*);
320 static inline Error* _narrow(::CORBA::Exception* _e) {
321 return _downcast(_e);
322 }
323
324 void operator>>=(cdrStream&) const ;
325 void operator<<=(cdrStream&) ;
326
327 static _core_attr insertExceptionToAny insertToAnyFn;
328 static _core_attr insertExceptionToAnyNCP insertToAnyFnNCP;
329
330 virtual ::CORBA::Exception* _NP_duplicate() const;
331
332 static _core_attr const char* _PD_repoId;
333 static _core_attr const char* _PD_typeId;
334
335 private:
336 virtual const char* _NP_typeId() const;
337 virtual const char* _NP_repoId(int*) const;
338 virtual void _NP_marshal(cdrStream&) const;
339 };
340
341 _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_Error;
342
343 _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_boolSeq;
344
345 class boolSeq_var;
346
347 class boolSeq : public _CORBA_Unbounded_Sequence_Boolean {
348 public:
349 typedef boolSeq_var _var_type;
350 ✗ inline boolSeq() {}
351 ✗ inline boolSeq(const boolSeq& _s)
352 ✗ : _CORBA_Unbounded_Sequence_Boolean(_s) {}
353
354 inline boolSeq(_CORBA_ULong _max)
355 : _CORBA_Unbounded_Sequence_Boolean(_max) {}
356 inline boolSeq(_CORBA_ULong _max, _CORBA_ULong _len, ::CORBA::Boolean* _val, _CORBA_Boolean _rel=0)
357 : _CORBA_Unbounded_Sequence_Boolean(_max, _len, _val, _rel) {}
358
359
360
361 inline boolSeq& operator = (const boolSeq& _s) {
362 _CORBA_Unbounded_Sequence_Boolean::operator=(_s);
363 return *this;
364 }
365 };
366
367 class boolSeq_out;
368
369 class boolSeq_var {
370 public:
371 ✗ inline boolSeq_var() : _pd_seq(0) {}
372 inline boolSeq_var(boolSeq* _s) : _pd_seq(_s) {}
373 inline boolSeq_var(const boolSeq_var& _s) {
374 if (_s._pd_seq) _pd_seq = new boolSeq(*_s._pd_seq);
375 else _pd_seq = 0;
376 }
377 ✗ inline ~boolSeq_var() { if (_pd_seq) delete _pd_seq; }
378
379 ✗ inline boolSeq_var& operator = (boolSeq* _s) {
380 ✗ if (_pd_seq) delete _pd_seq;
381 ✗ _pd_seq = _s;
382 ✗ return *this;
383 }
384 inline boolSeq_var& operator = (const boolSeq_var& _s) {
385 if (&_s != this) {
386 if (_s._pd_seq) {
387 if (!_pd_seq) _pd_seq = new boolSeq;
388 *_pd_seq = *_s._pd_seq;
389 }
390 else if (_pd_seq) {
391 delete _pd_seq;
392 _pd_seq = 0;
393 }
394 }
395 return *this;
396 }
397 inline ::CORBA::Boolean& operator [] (_CORBA_ULong _s) {
398 return (*_pd_seq)[_s];
399 }
400
401
402
403 inline boolSeq* operator -> () { return _pd_seq; }
404 inline const boolSeq* operator -> () const { return _pd_seq; }
405 #if defined(__GNUG__)
406 ✗ inline operator boolSeq& () const { return *_pd_seq; }
407 #else
408 inline operator const boolSeq& () const { return *_pd_seq; }
409 inline operator boolSeq& () { return *_pd_seq; }
410 #endif
411
412 ✗ inline const boolSeq& in() const { return *_pd_seq; }
413 inline boolSeq& inout() { return *_pd_seq; }
414 ✗ inline boolSeq*& out() {
415 ✗ if (_pd_seq) { delete _pd_seq; _pd_seq = 0; }
416 ✗ return _pd_seq;
417 }
418 ✗ inline boolSeq* _retn() { boolSeq* tmp = _pd_seq; _pd_seq = 0; return tmp; }
419
420 friend class boolSeq_out;
421
422 private:
423 boolSeq* _pd_seq;
424 };
425
426 class boolSeq_out {
427 public:
428 ✗ inline boolSeq_out(boolSeq*& _s) : _data(_s) { _data = 0; }
429 inline boolSeq_out(boolSeq_var& _s)
430 : _data(_s._pd_seq) { _s = (boolSeq*) 0; }
431 inline boolSeq_out(const boolSeq_out& _s) : _data(_s._data) {}
432 inline boolSeq_out& operator = (const boolSeq_out& _s) {
433 _data = _s._data;
434 return *this;
435 }
436 ✗ inline boolSeq_out& operator = (boolSeq* _s) {
437 ✗ _data = _s;
438 ✗ return *this;
439 }
440 inline operator boolSeq*&() { return _data; }
441 inline boolSeq*& ptr() { return _data; }
442 inline boolSeq* operator->() { return _data; }
443
444 inline ::CORBA::Boolean& operator [] (_CORBA_ULong _i) {
445 return (*_data)[_i];
446 }
447
448
449
450 boolSeq*& _data;
451
452 private:
453 boolSeq_out();
454 boolSeq_out& operator=(const boolSeq_var&);
455 };
456
457 _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_intSeq;
458
459 class intSeq_var;
460
461 class intSeq : public _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Long, 4, 4 > {
462 public:
463 typedef intSeq_var _var_type;
464 ✗ inline intSeq() {}
465 ✗ inline intSeq(const intSeq& _s)
466 ✗ : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Long, 4, 4 > (_s) {}
467
468 inline intSeq(_CORBA_ULong _max)
469 : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Long, 4, 4 > (_max) {}
470 inline intSeq(_CORBA_ULong _max, _CORBA_ULong _len, ::CORBA::Long* _val, _CORBA_Boolean _rel=0)
471 : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Long, 4, 4 > (_max, _len, _val, _rel) {}
472
473
474
475 ✗ inline intSeq& operator = (const intSeq& _s) {
476 ✗ _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Long, 4, 4 > ::operator=(_s);
477 ✗ return *this;
478 }
479 };
480
481 class intSeq_out;
482
483 class intSeq_var {
484 public:
485 ✗ inline intSeq_var() : _pd_seq(0) {}
486 inline intSeq_var(intSeq* _s) : _pd_seq(_s) {}
487 inline intSeq_var(const intSeq_var& _s) {
488 if (_s._pd_seq) _pd_seq = new intSeq(*_s._pd_seq);
489 else _pd_seq = 0;
490 }
491 ✗ inline ~intSeq_var() { if (_pd_seq) delete _pd_seq; }
492
493 ✗ inline intSeq_var& operator = (intSeq* _s) {
494 ✗ if (_pd_seq) delete _pd_seq;
495 ✗ _pd_seq = _s;
496 ✗ return *this;
497 }
498 inline intSeq_var& operator = (const intSeq_var& _s) {
499 if (&_s != this) {
500 if (_s._pd_seq) {
501 if (!_pd_seq) _pd_seq = new intSeq;
502 *_pd_seq = *_s._pd_seq;
503 }
504 else if (_pd_seq) {
505 delete _pd_seq;
506 _pd_seq = 0;
507 }
508 }
509 return *this;
510 }
511 inline ::CORBA::Long& operator [] (_CORBA_ULong _s) {
512 return (*_pd_seq)[_s];
513 }
514
515
516
517 inline intSeq* operator -> () { return _pd_seq; }
518 inline const intSeq* operator -> () const { return _pd_seq; }
519 #if defined(__GNUG__)
520 ✗ inline operator intSeq& () const { return *_pd_seq; }
521 #else
522 inline operator const intSeq& () const { return *_pd_seq; }
523 inline operator intSeq& () { return *_pd_seq; }
524 #endif
525
526 ✗ inline const intSeq& in() const { return *_pd_seq; }
527 inline intSeq& inout() { return *_pd_seq; }
528 inline intSeq*& out() {
529 if (_pd_seq) { delete _pd_seq; _pd_seq = 0; }
530 return _pd_seq;
531 }
532 ✗ inline intSeq* _retn() { intSeq* tmp = _pd_seq; _pd_seq = 0; return tmp; }
533
534 friend class intSeq_out;
535
536 private:
537 intSeq* _pd_seq;
538 };
539
540 class intSeq_out {
541 public:
542 inline intSeq_out(intSeq*& _s) : _data(_s) { _data = 0; }
543 inline intSeq_out(intSeq_var& _s)
544 : _data(_s._pd_seq) { _s = (intSeq*) 0; }
545 inline intSeq_out(const intSeq_out& _s) : _data(_s._data) {}
546 inline intSeq_out& operator = (const intSeq_out& _s) {
547 _data = _s._data;
548 return *this;
549 }
550 inline intSeq_out& operator = (intSeq* _s) {
551 _data = _s;
552 return *this;
553 }
554 inline operator intSeq*&() { return _data; }
555 inline intSeq*& ptr() { return _data; }
556 inline intSeq* operator->() { return _data; }
557
558 inline ::CORBA::Long& operator [] (_CORBA_ULong _i) {
559 return (*_data)[_i];
560 }
561
562
563
564 intSeq*& _data;
565
566 private:
567 intSeq_out();
568 intSeq_out& operator=(const intSeq_var&);
569 };
570
571 _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_intSeqSeq;
572
573 class intSeqSeq_var;
574
575 class intSeqSeq : public _CORBA_Unbounded_Sequence< intSeq > {
576 public:
577 typedef intSeqSeq_var _var_type;
578 ✗ inline intSeqSeq() {}
579 ✗ inline intSeqSeq(const intSeqSeq& _s)
580 ✗ : _CORBA_Unbounded_Sequence< intSeq > (_s) {}
581
582 inline intSeqSeq(_CORBA_ULong _max)
583 : _CORBA_Unbounded_Sequence< intSeq > (_max) {}
584 inline intSeqSeq(_CORBA_ULong _max, _CORBA_ULong _len, intSeq* _val, _CORBA_Boolean _rel=0)
585 : _CORBA_Unbounded_Sequence< intSeq > (_max, _len, _val, _rel) {}
586
587
588
589 inline intSeqSeq& operator = (const intSeqSeq& _s) {
590 _CORBA_Unbounded_Sequence< intSeq > ::operator=(_s);
591 return *this;
592 }
593 };
594
595 class intSeqSeq_out;
596
597 class intSeqSeq_var {
598 public:
599 ✗ inline intSeqSeq_var() : _pd_seq(0) {}
600 inline intSeqSeq_var(intSeqSeq* _s) : _pd_seq(_s) {}
601 inline intSeqSeq_var(const intSeqSeq_var& _s) {
602 if (_s._pd_seq) _pd_seq = new intSeqSeq(*_s._pd_seq);
603 else _pd_seq = 0;
604 }
605 ✗ inline ~intSeqSeq_var() { if (_pd_seq) delete _pd_seq; }
606
607 ✗ inline intSeqSeq_var& operator = (intSeqSeq* _s) {
608 ✗ if (_pd_seq) delete _pd_seq;
609 ✗ _pd_seq = _s;
610 ✗ return *this;
611 }
612 inline intSeqSeq_var& operator = (const intSeqSeq_var& _s) {
613 if (&_s != this) {
614 if (_s._pd_seq) {
615 if (!_pd_seq) _pd_seq = new intSeqSeq;
616 *_pd_seq = *_s._pd_seq;
617 }
618 else if (_pd_seq) {
619 delete _pd_seq;
620 _pd_seq = 0;
621 }
622 }
623 return *this;
624 }
625 inline intSeq& operator [] (_CORBA_ULong _s) {
626 return (*_pd_seq)[_s];
627 }
628
629
630
631 inline intSeqSeq* operator -> () { return _pd_seq; }
632 inline const intSeqSeq* operator -> () const { return _pd_seq; }
633 #if defined(__GNUG__)
634 ✗ inline operator intSeqSeq& () const { return *_pd_seq; }
635 #else
636 inline operator const intSeqSeq& () const { return *_pd_seq; }
637 inline operator intSeqSeq& () { return *_pd_seq; }
638 #endif
639
640 ✗ inline const intSeqSeq& in() const { return *_pd_seq; }
641 inline intSeqSeq& inout() { return *_pd_seq; }
642 inline intSeqSeq*& out() {
643 if (_pd_seq) { delete _pd_seq; _pd_seq = 0; }
644 return _pd_seq;
645 }
646 inline intSeqSeq* _retn() { intSeqSeq* tmp = _pd_seq; _pd_seq = 0; return tmp; }
647
648 friend class intSeqSeq_out;
649
650 private:
651 intSeqSeq* _pd_seq;
652 };
653
654 class intSeqSeq_out {
655 public:
656 inline intSeqSeq_out(intSeqSeq*& _s) : _data(_s) { _data = 0; }
657 inline intSeqSeq_out(intSeqSeq_var& _s)
658 : _data(_s._pd_seq) { _s = (intSeqSeq*) 0; }
659 inline intSeqSeq_out(const intSeqSeq_out& _s) : _data(_s._data) {}
660 inline intSeqSeq_out& operator = (const intSeqSeq_out& _s) {
661 _data = _s._data;
662 return *this;
663 }
664 inline intSeqSeq_out& operator = (intSeqSeq* _s) {
665 _data = _s;
666 return *this;
667 }
668 inline operator intSeqSeq*&() { return _data; }
669 inline intSeqSeq*& ptr() { return _data; }
670 inline intSeqSeq* operator->() { return _data; }
671
672 inline intSeq& operator [] (_CORBA_ULong _i) {
673 return (*_data)[_i];
674 }
675
676
677
678 intSeqSeq*& _data;
679
680 private:
681 intSeqSeq_out();
682 intSeqSeq_out& operator=(const intSeqSeq_var&);
683 };
684
685 _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_floatSeq;
686
687 class floatSeq_var;
688
689 class floatSeq : public _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Double, 8, 8 > {
690 public:
691 typedef floatSeq_var _var_type;
692 11 inline floatSeq() {}
693 ✗ inline floatSeq(const floatSeq& _s)
694 ✗ : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Double, 8, 8 > (_s) {}
695
696 inline floatSeq(_CORBA_ULong _max)
697 : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Double, 8, 8 > (_max) {}
698 ✗ inline floatSeq(_CORBA_ULong _max, _CORBA_ULong _len, ::CORBA::Double* _val, _CORBA_Boolean _rel=0)
699 ✗ : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Double, 8, 8 > (_max, _len, _val, _rel) {}
700
701
702
703 ✗ inline floatSeq& operator = (const floatSeq& _s) {
704 ✗ _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Double, 8, 8 > ::operator=(_s);
705 ✗ return *this;
706 }
707 };
708
709 class floatSeq_out;
710
711 class floatSeq_var {
712 public:
713 11 inline floatSeq_var() : _pd_seq(0) {}
714 inline floatSeq_var(floatSeq* _s) : _pd_seq(_s) {}
715 inline floatSeq_var(const floatSeq_var& _s) {
716 if (_s._pd_seq) _pd_seq = new floatSeq(*_s._pd_seq);
717 else _pd_seq = 0;
718 }
719
2/4
✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 11 times.
✗ Branch 3 not taken.
 11 inline ~floatSeq_var() { if (_pd_seq) delete _pd_seq; }
720
721 11 inline floatSeq_var& operator = (floatSeq* _s) {
722
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 11 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 11 if (_pd_seq) delete _pd_seq;
723 11 _pd_seq = _s;
724 11 return *this;
725 }
726 inline floatSeq_var& operator = (const floatSeq_var& _s) {
727 if (&_s != this) {
728 if (_s._pd_seq) {
729 if (!_pd_seq) _pd_seq = new floatSeq;
730 *_pd_seq = *_s._pd_seq;
731 }
732 else if (_pd_seq) {
733 delete _pd_seq;
734 _pd_seq = 0;
735 }
736 }
737 return *this;
738 }
739 inline ::CORBA::Double& operator [] (_CORBA_ULong _s) {
740 return (*_pd_seq)[_s];
741 }
742
743
744
745 inline floatSeq* operator -> () { return _pd_seq; }
746 inline const floatSeq* operator -> () const { return _pd_seq; }
747 #if defined(__GNUG__)
748 11 inline operator floatSeq& () const { return *_pd_seq; }
749 #else
750 inline operator const floatSeq& () const { return *_pd_seq; }
751 inline operator floatSeq& () { return *_pd_seq; }
752 #endif
753
754 5 inline const floatSeq& in() const { return *_pd_seq; }
755 ✗ inline floatSeq& inout() { return *_pd_seq; }
756 ✗ inline floatSeq*& out() {
757 ✗ if (_pd_seq) { delete _pd_seq; _pd_seq = 0; }
758 ✗ return _pd_seq;
759 }
760 ✗ inline floatSeq* _retn() { floatSeq* tmp = _pd_seq; _pd_seq = 0; return tmp; }
761
762 friend class floatSeq_out;
763
764 private:
765 floatSeq* _pd_seq;
766 };
767
768 class floatSeq_out {
769 public:
770 ✗ inline floatSeq_out(floatSeq*& _s) : _data(_s) { _data = 0; }
771 inline floatSeq_out(floatSeq_var& _s)
772 : _data(_s._pd_seq) { _s = (floatSeq*) 0; }
773 inline floatSeq_out(const floatSeq_out& _s) : _data(_s._data) {}
774 inline floatSeq_out& operator = (const floatSeq_out& _s) {
775 _data = _s._data;
776 return *this;
777 }
778 ✗ inline floatSeq_out& operator = (floatSeq* _s) {
779 ✗ _data = _s;
780 ✗ return *this;
781 }
782 inline operator floatSeq*&() { return _data; }
783 inline floatSeq*& ptr() { return _data; }
784 inline floatSeq* operator->() { return _data; }
785
786 inline ::CORBA::Double& operator [] (_CORBA_ULong _i) {
787 return (*_data)[_i];
788 }
789
790
791
792 floatSeq*& _data;
793
794 private:
795 floatSeq_out();
796 floatSeq_out& operator=(const floatSeq_var&);
797 };
798
799 _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_floatSeqSeq;
800
801 class floatSeqSeq_var;
802
803 class floatSeqSeq : public _CORBA_Unbounded_Sequence< floatSeq > {
804 public:
805 typedef floatSeqSeq_var _var_type;
806 ✗ inline floatSeqSeq() {}
807 ✗ inline floatSeqSeq(const floatSeqSeq& _s)
808 ✗ : _CORBA_Unbounded_Sequence< floatSeq > (_s) {}
809
810 inline floatSeqSeq(_CORBA_ULong _max)
811 : _CORBA_Unbounded_Sequence< floatSeq > (_max) {}
812 inline floatSeqSeq(_CORBA_ULong _max, _CORBA_ULong _len, floatSeq* _val, _CORBA_Boolean _rel=0)
813 : _CORBA_Unbounded_Sequence< floatSeq > (_max, _len, _val, _rel) {}
814
815
816
817 inline floatSeqSeq& operator = (const floatSeqSeq& _s) {
818 _CORBA_Unbounded_Sequence< floatSeq > ::operator=(_s);
819 return *this;
820 }
821 };
822
823 class floatSeqSeq_out;
824
825 class floatSeqSeq_var {
826 public:
827 ✗ inline floatSeqSeq_var() : _pd_seq(0) {}
828 inline floatSeqSeq_var(floatSeqSeq* _s) : _pd_seq(_s) {}
829 inline floatSeqSeq_var(const floatSeqSeq_var& _s) {
830 if (_s._pd_seq) _pd_seq = new floatSeqSeq(*_s._pd_seq);
831 else _pd_seq = 0;
832 }
833 ✗ inline ~floatSeqSeq_var() { if (_pd_seq) delete _pd_seq; }
834
835 ✗ inline floatSeqSeq_var& operator = (floatSeqSeq* _s) {
836 ✗ if (_pd_seq) delete _pd_seq;
837 ✗ _pd_seq = _s;
838 ✗ return *this;
839 }
840 inline floatSeqSeq_var& operator = (const floatSeqSeq_var& _s) {
841 if (&_s != this) {
842 if (_s._pd_seq) {
843 if (!_pd_seq) _pd_seq = new floatSeqSeq;
844 *_pd_seq = *_s._pd_seq;
845 }
846 else if (_pd_seq) {
847 delete _pd_seq;
848 _pd_seq = 0;
849 }
850 }
851 return *this;
852 }
853 inline floatSeq& operator [] (_CORBA_ULong _s) {
854 return (*_pd_seq)[_s];
855 }
856
857
858
859 inline floatSeqSeq* operator -> () { return _pd_seq; }
860 inline const floatSeqSeq* operator -> () const { return _pd_seq; }
861 #if defined(__GNUG__)
862 ✗ inline operator floatSeqSeq& () const { return *_pd_seq; }
863 #else
864 inline operator const floatSeqSeq& () const { return *_pd_seq; }
865 inline operator floatSeqSeq& () { return *_pd_seq; }
866 #endif
867
868 ✗ inline const floatSeqSeq& in() const { return *_pd_seq; }
869 inline floatSeqSeq& inout() { return *_pd_seq; }
870 ✗ inline floatSeqSeq*& out() {
871 ✗ if (_pd_seq) { delete _pd_seq; _pd_seq = 0; }
872 ✗ return _pd_seq;
873 }
874 ✗ inline floatSeqSeq* _retn() { floatSeqSeq* tmp = _pd_seq; _pd_seq = 0; return tmp; }
875
876 friend class floatSeqSeq_out;
877
878 private:
879 floatSeqSeq* _pd_seq;
880 };
881
882 class floatSeqSeq_out {
883 public:
884 ✗ inline floatSeqSeq_out(floatSeqSeq*& _s) : _data(_s) { _data = 0; }
885 inline floatSeqSeq_out(floatSeqSeq_var& _s)
886 : _data(_s._pd_seq) { _s = (floatSeqSeq*) 0; }
887 inline floatSeqSeq_out(const floatSeqSeq_out& _s) : _data(_s._data) {}
888 inline floatSeqSeq_out& operator = (const floatSeqSeq_out& _s) {
889 _data = _s._data;
890 return *this;
891 }
892 ✗ inline floatSeqSeq_out& operator = (floatSeqSeq* _s) {
893 ✗ _data = _s;
894 ✗ return *this;
895 }
896 inline operator floatSeqSeq*&() { return _data; }
897 inline floatSeqSeq*& ptr() { return _data; }
898 inline floatSeqSeq* operator->() { return _data; }
899
900 inline floatSeq& operator [] (_CORBA_ULong _i) {
901 return (*_data)[_i];
902 }
903
904
905
906 floatSeqSeq*& _data;
907
908 private:
909 floatSeqSeq_out();
910 floatSeqSeq_out& operator=(const floatSeqSeq_var&);
911 };
912
913 _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_Transform_;
914
915 typedef ::CORBA::Double Transform_[7];
916 typedef ::CORBA::Double Transform__slice;
917
918 ✗ _CORBA_MODULE_INLINE Transform__slice* Transform__alloc() {
919 ✗ return new Transform__slice[7];
920 }
921
922 ✗ _CORBA_MODULE_INLINE Transform__slice* Transform__dup(const Transform__slice* _s) {
923 ✗ if (!_s) return 0;
924 ✗ Transform__slice* _data = Transform__alloc();
925 ✗ if (_data) {
926 ✗ for (_CORBA_ULong _0i0 = 0; _0i0 < 7; _0i0++){
927
928 ✗ _data[_0i0] = _s[_0i0];
929
930 }
931
932 }
933 ✗ return _data;
934 }
935
936 _CORBA_MODULE_INLINE void Transform__copy(Transform__slice* _to, const Transform__slice* _from){
937 for (_CORBA_ULong _0i0 = 0; _0i0 < 7; _0i0++){
938
939 _to[_0i0] = _from[_0i0];
940
941 }
942
943 }
944
945 ✗ _CORBA_MODULE_INLINE void Transform__free(Transform__slice* _s) {
946 ✗ delete [] _s;
947 }
948
949 class Transform__copyHelper {
950 public:
951 static inline Transform__slice* alloc() { return ::hpp::Transform__alloc(); }
952 static inline Transform__slice* dup(const Transform__slice* p) { return ::hpp::Transform__dup(p); }
953 ✗ static inline void free(Transform__slice* p) { ::hpp::Transform__free(p); }
954 };
955
956 typedef _CORBA_Array_Fix_Var<Transform__copyHelper,Transform__slice> Transform__var;
957 typedef _CORBA_Array_Fix_Forany<Transform__copyHelper,Transform__slice> Transform__forany;
958
959 typedef Transform__slice* Transform__out;
960
961 _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_TransformSeq;
962
963 class TransformSeq_var;
964
965 class TransformSeq : public _CORBA_Unbounded_Sequence_Array_w_FixSizeElement< Transform_, Transform__slice, ::CORBA::Double, 7, 8, 8 > {
966 public:
967 typedef TransformSeq_var _var_type;
968 ✗ inline TransformSeq() {}
969 ✗ inline TransformSeq(const TransformSeq& _s)
970 ✗ : _CORBA_Unbounded_Sequence_Array_w_FixSizeElement< Transform_, Transform__slice, ::CORBA::Double, 7, 8, 8 > (_s) {}
971
972 inline TransformSeq(_CORBA_ULong _max)
973 : _CORBA_Unbounded_Sequence_Array_w_FixSizeElement< Transform_, Transform__slice, ::CORBA::Double, 7, 8, 8 > (_max) {}
974 inline TransformSeq(_CORBA_ULong _max, _CORBA_ULong _len, Transform_* _val, _CORBA_Boolean _rel=0)
975 : _CORBA_Unbounded_Sequence_Array_w_FixSizeElement< Transform_, Transform__slice, ::CORBA::Double, 7, 8, 8 > (_max, _len, _val, _rel) {}
976
977
978
979 inline TransformSeq& operator = (const TransformSeq& _s) {
980 _CORBA_Unbounded_Sequence_Array_w_FixSizeElement< Transform_, Transform__slice, ::CORBA::Double, 7, 8, 8 > ::operator=(_s);
981 return *this;
982 }
983 };
984
985 class TransformSeq_out;
986
987 class TransformSeq_var {
988 public:
989 ✗ inline TransformSeq_var() : _pd_seq(0) {}
990 inline TransformSeq_var(TransformSeq* _s) : _pd_seq(_s) {}
991 inline TransformSeq_var(const TransformSeq_var& _s) {
992 if (_s._pd_seq) _pd_seq = new TransformSeq(*_s._pd_seq);
993 else _pd_seq = 0;
994 }
995 ✗ inline ~TransformSeq_var() { if (_pd_seq) delete _pd_seq; }
996
997 ✗ inline TransformSeq_var& operator = (TransformSeq* _s) {
998 ✗ if (_pd_seq) delete _pd_seq;
999 ✗ _pd_seq = _s;
1000 ✗ return *this;
1001 }
1002 inline TransformSeq_var& operator = (const TransformSeq_var& _s) {
1003 if (&_s != this) {
1004 if (_s._pd_seq) {
1005 if (!_pd_seq) _pd_seq = new TransformSeq;
1006 *_pd_seq = *_s._pd_seq;
1007 }
1008 else if (_pd_seq) {
1009 delete _pd_seq;
1010 _pd_seq = 0;
1011 }
1012 }
1013 return *this;
1014 }
1015 inline Transform__slice* operator [] (_CORBA_ULong _s) {
1016 return (Transform__slice*) ((_pd_seq->NP_data())[_s]);
1017 }
1018
1019
1020
1021 inline TransformSeq* operator -> () { return _pd_seq; }
1022 inline const TransformSeq* operator -> () const { return _pd_seq; }
1023 #if defined(__GNUG__)
1024 ✗ inline operator TransformSeq& () const { return *_pd_seq; }
1025 #else
1026 inline operator const TransformSeq& () const { return *_pd_seq; }
1027 inline operator TransformSeq& () { return *_pd_seq; }
1028 #endif
1029
1030 inline const TransformSeq& in() const { return *_pd_seq; }
1031 inline TransformSeq& inout() { return *_pd_seq; }
1032 inline TransformSeq*& out() {
1033 if (_pd_seq) { delete _pd_seq; _pd_seq = 0; }
1034 return _pd_seq;
1035 }
1036 ✗ inline TransformSeq* _retn() { TransformSeq* tmp = _pd_seq; _pd_seq = 0; return tmp; }
1037
1038 friend class TransformSeq_out;
1039
1040 private:
1041 TransformSeq* _pd_seq;
1042 };
1043
1044 class TransformSeq_out {
1045 public:
1046 inline TransformSeq_out(TransformSeq*& _s) : _data(_s) { _data = 0; }
1047 inline TransformSeq_out(TransformSeq_var& _s)
1048 : _data(_s._pd_seq) { _s = (TransformSeq*) 0; }
1049 inline TransformSeq_out(const TransformSeq_out& _s) : _data(_s._data) {}
1050 inline TransformSeq_out& operator = (const TransformSeq_out& _s) {
1051 _data = _s._data;
1052 return *this;
1053 }
1054 inline TransformSeq_out& operator = (TransformSeq* _s) {
1055 _data = _s;
1056 return *this;
1057 }
1058 inline operator TransformSeq*&() { return _data; }
1059 inline TransformSeq*& ptr() { return _data; }
1060 inline TransformSeq* operator->() { return _data; }
1061
1062 inline Transform__slice* operator [] (_CORBA_ULong _i) {
1063 return (Transform__slice*) ((_data->NP_data())[_i]);
1064 }
1065
1066
1067
1068 TransformSeq*& _data;
1069
1070 private:
1071 TransformSeq_out();
1072 TransformSeq_out& operator=(const TransformSeq_var&);
1073 };
1074
1075 _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_Quaternion_;
1076
1077 typedef ::CORBA::Double Quaternion_[4];
1078 typedef ::CORBA::Double Quaternion__slice;
1079
1080 ✗ _CORBA_MODULE_INLINE Quaternion__slice* Quaternion__alloc() {
1081 ✗ return new Quaternion__slice[4];
1082 }
1083
1084 ✗ _CORBA_MODULE_INLINE Quaternion__slice* Quaternion__dup(const Quaternion__slice* _s) {
1085 ✗ if (!_s) return 0;
1086 ✗ Quaternion__slice* _data = Quaternion__alloc();
1087 ✗ if (_data) {
1088 ✗ for (_CORBA_ULong _0i0 = 0; _0i0 < 4; _0i0++){
1089
1090 ✗ _data[_0i0] = _s[_0i0];
1091
1092 }
1093
1094 }
1095 ✗ return _data;
1096 }
1097
1098 _CORBA_MODULE_INLINE void Quaternion__copy(Quaternion__slice* _to, const Quaternion__slice* _from){
1099 for (_CORBA_ULong _0i0 = 0; _0i0 < 4; _0i0++){
1100
1101 _to[_0i0] = _from[_0i0];
1102
1103 }
1104
1105 }
1106
1107 ✗ _CORBA_MODULE_INLINE void Quaternion__free(Quaternion__slice* _s) {
1108 ✗ delete [] _s;
1109 }
1110
1111 class Quaternion__copyHelper {
1112 public:
1113 static inline Quaternion__slice* alloc() { return ::hpp::Quaternion__alloc(); }
1114 static inline Quaternion__slice* dup(const Quaternion__slice* p) { return ::hpp::Quaternion__dup(p); }
1115 static inline void free(Quaternion__slice* p) { ::hpp::Quaternion__free(p); }
1116 };
1117
1118 typedef _CORBA_Array_Fix_Var<Quaternion__copyHelper,Quaternion__slice> Quaternion__var;
1119 typedef _CORBA_Array_Fix_Forany<Quaternion__copyHelper,Quaternion__slice> Quaternion__forany;
1120
1121 typedef Quaternion__slice* Quaternion__out;
1122
1123 enum ComparisonType { Equality, EqualToZero, Superior, Inferior /*, __max_ComparisonType=0xffffffff */ };
1124 typedef ComparisonType& ComparisonType_out;
1125
1126 _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_ComparisonType;
1127
1128 _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_ComparisonTypes_t;
1129
1130 // Need to declare <<= for elem type, as GCC expands templates early
1131 #if defined(__GNUG__) && __GNUG__ == 2 && __GNUC_MINOR__ == 7
1132 friend inline void operator >>= (ComparisonType, cdrStream&);
1133 friend inline void operator <<= (ComparisonType&, cdrStream&);
1134 #endif
1135
1136 class ComparisonTypes_t_var;
1137
1138 class ComparisonTypes_t : public _CORBA_Unbounded_Sequence_w_FixSizeElement< ComparisonType, 4, 4 > {
1139 public:
1140 typedef ComparisonTypes_t_var _var_type;
1141 ✗ inline ComparisonTypes_t() {}
1142 ✗ inline ComparisonTypes_t(const ComparisonTypes_t& _s)
1143 ✗ : _CORBA_Unbounded_Sequence_w_FixSizeElement< ComparisonType, 4, 4 > (_s) {}
1144
1145 inline ComparisonTypes_t(_CORBA_ULong _max)
1146 : _CORBA_Unbounded_Sequence_w_FixSizeElement< ComparisonType, 4, 4 > (_max) {}
1147 inline ComparisonTypes_t(_CORBA_ULong _max, _CORBA_ULong _len, ComparisonType* _val, _CORBA_Boolean _rel=0)
1148 : _CORBA_Unbounded_Sequence_w_FixSizeElement< ComparisonType, 4, 4 > (_max, _len, _val, _rel) {}
1149
1150
1151
1152 inline ComparisonTypes_t& operator = (const ComparisonTypes_t& _s) {
1153 _CORBA_Unbounded_Sequence_w_FixSizeElement< ComparisonType, 4, 4 > ::operator=(_s);
1154 return *this;
1155 }
1156 };
1157
1158 class ComparisonTypes_t_out;
1159
1160 class ComparisonTypes_t_var {
1161 public:
1162 ✗ inline ComparisonTypes_t_var() : _pd_seq(0) {}
1163 inline ComparisonTypes_t_var(ComparisonTypes_t* _s) : _pd_seq(_s) {}
1164 inline ComparisonTypes_t_var(const ComparisonTypes_t_var& _s) {
1165 if (_s._pd_seq) _pd_seq = new ComparisonTypes_t(*_s._pd_seq);
1166 else _pd_seq = 0;
1167 }
1168 ✗ inline ~ComparisonTypes_t_var() { if (_pd_seq) delete _pd_seq; }
1169
1170 ✗ inline ComparisonTypes_t_var& operator = (ComparisonTypes_t* _s) {
1171 ✗ if (_pd_seq) delete _pd_seq;
1172 ✗ _pd_seq = _s;
1173 ✗ return *this;
1174 }
1175 inline ComparisonTypes_t_var& operator = (const ComparisonTypes_t_var& _s) {
1176 if (&_s != this) {
1177 if (_s._pd_seq) {
1178 if (!_pd_seq) _pd_seq = new ComparisonTypes_t;
1179 *_pd_seq = *_s._pd_seq;
1180 }
1181 else if (_pd_seq) {
1182 delete _pd_seq;
1183 _pd_seq = 0;
1184 }
1185 }
1186 return *this;
1187 }
1188 inline ComparisonType& operator [] (_CORBA_ULong _s) {
1189 return (*_pd_seq)[_s];
1190 }
1191
1192
1193
1194 inline ComparisonTypes_t* operator -> () { return _pd_seq; }
1195 inline const ComparisonTypes_t* operator -> () const { return _pd_seq; }
1196 #if defined(__GNUG__)
1197 ✗ inline operator ComparisonTypes_t& () const { return *_pd_seq; }
1198 #else
1199 inline operator const ComparisonTypes_t& () const { return *_pd_seq; }
1200 inline operator ComparisonTypes_t& () { return *_pd_seq; }
1201 #endif
1202
1203 ✗ inline const ComparisonTypes_t& in() const { return *_pd_seq; }
1204 inline ComparisonTypes_t& inout() { return *_pd_seq; }
1205 inline ComparisonTypes_t*& out() {
1206 if (_pd_seq) { delete _pd_seq; _pd_seq = 0; }
1207 return _pd_seq;
1208 }
1209 ✗ inline ComparisonTypes_t* _retn() { ComparisonTypes_t* tmp = _pd_seq; _pd_seq = 0; return tmp; }
1210
1211 friend class ComparisonTypes_t_out;
1212
1213 private:
1214 ComparisonTypes_t* _pd_seq;
1215 };
1216
1217 class ComparisonTypes_t_out {
1218 public:
1219 inline ComparisonTypes_t_out(ComparisonTypes_t*& _s) : _data(_s) { _data = 0; }
1220 inline ComparisonTypes_t_out(ComparisonTypes_t_var& _s)
1221 : _data(_s._pd_seq) { _s = (ComparisonTypes_t*) 0; }
1222 inline ComparisonTypes_t_out(const ComparisonTypes_t_out& _s) : _data(_s._data) {}
1223 inline ComparisonTypes_t_out& operator = (const ComparisonTypes_t_out& _s) {
1224 _data = _s._data;
1225 return *this;
1226 }
1227 inline ComparisonTypes_t_out& operator = (ComparisonTypes_t* _s) {
1228 _data = _s;
1229 return *this;
1230 }
1231 inline operator ComparisonTypes_t*&() { return _data; }
1232 inline ComparisonTypes_t*& ptr() { return _data; }
1233 inline ComparisonTypes_t* operator->() { return _data; }
1234
1235 inline ComparisonType& operator [] (_CORBA_ULong _i) {
1236 return (*_data)[_i];
1237 }
1238
1239
1240
1241 ComparisonTypes_t*& _data;
1242
1243 private:
1244 ComparisonTypes_t_out();
1245 ComparisonTypes_t_out& operator=(const ComparisonTypes_t_var&);
1246 };
1247
1248 _CORBA_MODULE_END
1249
1250
1251
1252 _CORBA_MODULE POA_hpp
1253 _CORBA_MODULE_BEG
1254
1255 _CORBA_MODULE_END
1256
1257
1258
1259 _CORBA_MODULE OBV_hpp
1260 _CORBA_MODULE_BEG
1261
1262 _CORBA_MODULE_END
1263
1264
1265
1266
1267
1268 #undef _core_attr
1269 #undef _dyn_attr
1270
1271 void operator<<=(::CORBA::Any& _a, const hpp::Names_t& _s);
1272 void operator<<=(::CORBA::Any& _a, hpp::Names_t* _sp);
1273 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, hpp::Names_t*& _sp);
1274 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const hpp::Names_t*& _sp);
1275
1276 void operator<<=(::CORBA::Any& _a, const hpp::stringSeqSeq& _s);
1277 void operator<<=(::CORBA::Any& _a, hpp::stringSeqSeq* _sp);
1278 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, hpp::stringSeqSeq*& _sp);
1279 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const hpp::stringSeqSeq*& _sp);
1280
1281 void operator<<=(::CORBA::Any& _a, const hpp::Error& _s);
1282 void operator<<=(::CORBA::Any& _a, const hpp::Error* _sp);
1283 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const hpp::Error*& _sp);
1284
1285 void operator<<=(::CORBA::Any& _a, const hpp::boolSeq& _s);
1286 void operator<<=(::CORBA::Any& _a, hpp::boolSeq* _sp);
1287 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, hpp::boolSeq*& _sp);
1288 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const hpp::boolSeq*& _sp);
1289
1290 void operator<<=(::CORBA::Any& _a, const hpp::intSeq& _s);
1291 void operator<<=(::CORBA::Any& _a, hpp::intSeq* _sp);
1292 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, hpp::intSeq*& _sp);
1293 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const hpp::intSeq*& _sp);
1294
1295 void operator<<=(::CORBA::Any& _a, const hpp::intSeqSeq& _s);
1296 void operator<<=(::CORBA::Any& _a, hpp::intSeqSeq* _sp);
1297 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, hpp::intSeqSeq*& _sp);
1298 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const hpp::intSeqSeq*& _sp);
1299
1300 void operator<<=(::CORBA::Any& _a, const hpp::floatSeq& _s);
1301 void operator<<=(::CORBA::Any& _a, hpp::floatSeq* _sp);
1302 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, hpp::floatSeq*& _sp);
1303 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const hpp::floatSeq*& _sp);
1304
1305 void operator<<=(::CORBA::Any& _a, const hpp::floatSeqSeq& _s);
1306 void operator<<=(::CORBA::Any& _a, hpp::floatSeqSeq* _sp);
1307 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, hpp::floatSeqSeq*& _sp);
1308 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const hpp::floatSeqSeq*& _sp);
1309
1310 void operator<<=(::CORBA::Any& _a, const hpp::Transform__forany& _s);
1311 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, hpp::Transform__forany& _s);
1312
1313 void operator<<=(::CORBA::Any& _a, const hpp::TransformSeq& _s);
1314 void operator<<=(::CORBA::Any& _a, hpp::TransformSeq* _sp);
1315 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, hpp::TransformSeq*& _sp);
1316 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const hpp::TransformSeq*& _sp);
1317
1318 void operator<<=(::CORBA::Any& _a, const hpp::Quaternion__forany& _s);
1319 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, hpp::Quaternion__forany& _s);
1320
1321 ✗ inline void operator >>=(hpp::ComparisonType _e, cdrStream& s) {
1322 ✗ ::operator>>=((::CORBA::ULong)_e, s);
1323 }
1324
1325 ✗ inline void operator <<= (hpp::ComparisonType& _e, cdrStream& s) {
1326 ::CORBA::ULong _0RL_e;
1327 ✗ ::operator<<=(_0RL_e,s);
1328 ✗ if (_0RL_e <= hpp::Inferior) {
1329 ✗ _e = (hpp::ComparisonType) _0RL_e;
1330 }
1331 else {
1332 ✗ OMNIORB_THROW(MARSHAL,_OMNI_NS(MARSHAL_InvalidEnumValue),
1333 (::CORBA::CompletionStatus)s.completion());
1334 }
1335 }
1336
1337 void operator<<=(::CORBA::Any& _a, hpp::ComparisonType _s);
1338 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, hpp::ComparisonType& _s);
1339
1340 void operator<<=(::CORBA::Any& _a, const hpp::ComparisonTypes_t& _s);
1341 void operator<<=(::CORBA::Any& _a, hpp::ComparisonTypes_t* _sp);
1342 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, hpp::ComparisonTypes_t*& _sp);
1343 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const hpp::ComparisonTypes_t*& _sp);
1344
1345
1346
1347
1348
1349 #ifdef USE_stub_in_nt_dll_NOT_DEFINED_common
1350 # undef USE_stub_in_nt_dll
1351 # undef USE_stub_in_nt_dll_NOT_DEFINED_common
1352 #endif
1353 #ifdef USE_core_stub_in_nt_dll_NOT_DEFINED_common
1354 # undef USE_core_stub_in_nt_dll
1355 # undef USE_core_stub_in_nt_dll_NOT_DEFINED_common
1356 #endif
1357 #ifdef USE_dyn_stub_in_nt_dll_NOT_DEFINED_common
1358 # undef USE_dyn_stub_in_nt_dll
1359 # undef USE_dyn_stub_in_nt_dll_NOT_DEFINED_common
1360 #endif
1361
1362 #endif // __common_hh__
1363
1364