1 // -*- Mode: C++; -*-
2 // Package : omniORB
3 // DynAny.cc Created on: 12/02/98
4 // Author : Sai-Lai Lo (sll)
5 //
6 // Copyright (C) 2002-2013 Apasphere Ltd
7 // Copyright (C) 1996-1999 AT&T Laboratories Cambridge
8 //
9 // This file is part of the omniORB library
10 //
11 // The omniORB library is free software; you can redistribute it and/or
12 // modify it under the terms of the GNU Lesser General Public
13 // License as published by the Free Software Foundation; either
14 // version 2.1 of the License, or (at your option) any later version.
15 //
16 // This library is distributed in the hope that it will be useful,
17 // but WITHOUT ANY WARRANTY; without even the implied warranty of
18 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 // Lesser General Public License for more details.
20 //
21 // You should have received a copy of the GNU Lesser General Public
22 // License along with this library. If not, see http://www.gnu.org/licenses/
23 //
24 //
25 // Description:
26 // Implementation of type DynAny
27
28 #include <omniORB4/CORBA.h>
29
30 #ifdef HAS_pch
31 #pragma hdrstop
32 #endif
33
34 #include <dynAnyImpl.h>
35 #include <tcParser.h>
36 #include <exceptiondefs.h>
37 #include <initialiser.h>
38 #include <initRefs.h>
39 #include <unknownValue.h>
40
~DynAny()41 DynamicAny::DynAny::~DynAny() { pd_dynmagic = 0; }
~DynFixed()42 DynamicAny::DynFixed::~DynFixed() {}
~DynEnum()43 DynamicAny::DynEnum::~DynEnum() {}
~DynStruct()44 DynamicAny::DynStruct::~DynStruct() {}
~DynUnion()45 DynamicAny::DynUnion::~DynUnion() {}
~DynSequence()46 DynamicAny::DynSequence::~DynSequence() {}
~DynArray()47 DynamicAny::DynArray::~DynArray() {}
~DynValueCommon()48 DynamicAny::DynValueCommon::~DynValueCommon() {}
~DynValue()49 DynamicAny::DynValue::~DynValue() {}
~DynValueBox()50 DynamicAny::DynValueBox::~DynValueBox() {}
~DynAnyFactory()51 DynamicAny::DynAnyFactory::~DynAnyFactory() {}
52
53 const char* DynamicAny::DynAny::
54 _PD_repoId = "IDL:omg.org/DynamicAny/DynAny:1.0";
55
56 const char* DynamicAny::DynFixed::
57 _PD_repoId = "IDL:omg.org/DynamicAny/DynFixed:1.0";
58
59 const char* DynamicAny::DynEnum::
60 _PD_repoId = "IDL:omg.org/DynamicAny/DynEnum:1.0";
61
62 const char* DynamicAny::DynStruct::
63 _PD_repoId = "IDL:omg.org/DynamicAny/DynStruct:1.0";
64
65 const char* DynamicAny::DynUnion::
66 _PD_repoId = "IDL:omg.org/DynamicAny/DynUnion:1.0";
67
68 const char* DynamicAny::DynSequence::
69 _PD_repoId = "IDL:omg.org/DynamicAny/DynSequence:1.0";
70
71 const char* DynamicAny::DynArray::
72 _PD_repoId = "IDL:omg.org/DynamicAny/DynArray:1.0";
73
74 const char* DynamicAny::DynValueCommon::
75 _PD_repoId = "IDL:omg.org/DynamicAny/DynValueCommon:1.0";
76
77 const char* DynamicAny::DynValue::
78 _PD_repoId = "IDL:omg.org/DynamicAny/DynValue:1.0";
79
80 const char* DynamicAny::DynValueBox::
81 _PD_repoId = "IDL:omg.org/DynamicAny/DynValueBox:1.0";
82
83 const char* DynamicAny::DynAnyFactory::
84 _PD_repoId = "IDL:omg.org/DynamicAny/DynAnyFactory:1.0";
85
86 OMNI_NAMESPACE_BEGIN(omni)
87
88 // Fake repository ids for implementation classes
89 const char* DynAnyImplBase::
90 _PD_repoId = "omniorb:DynAnyImplBase";
91
92 const char* DynAnyImpl::
93 _PD_repoId = "omniorb:DynAnyImpl";
94
95 const char* DynAnyConstrBase::
96 _PD_repoId = "omniorb:DynAnyConstrBase";
97
98 const char* DynUnionImpl::
99 _PD_repoId = "omniorb:DynUnionImpl";
100
101
102 // Note:
103 // The constructors in this file NEVER throw exceptions. This
104 // is to avoid a bug in MSVC 4 & 5, which happens when public
105 // virtual inheritance is used.
106
107
108 static DynAnyImplBase*
109 internal_create_dyn_any(TypeCode_base* tc, CORBA::Boolean is_root);
110
111 static DynUnionDisc*
112 internal_create_dyn_any_discriminator(TypeCode_base* tc, DynUnionImpl* du);
113
114 static DynamicAny::DynAny_ptr
115 factory_create_dyn_any(const CORBA::Any& value);
116
117 static DynamicAny::DynAny_ptr
118 factory_create_dyn_any_from_type_code(CORBA::TypeCode_ptr type);
119
120
121
122 //////////////////////////////////////////////////////////////////////
123 /////////////////////////// DynAnyImplBase ///////////////////////////
124 //////////////////////////////////////////////////////////////////////
125
126 #define CHECK_NOT_DESTROYED \
127 do { \
128 if (!DynamicAny::DynAny::PR_is_valid(this)) \
129 OMNIORB_THROW(BAD_PARAM, BAD_PARAM_InvalidDynAny, CORBA::COMPLETED_NO); \
130 if (destroyed()) \
131 OMNIORB_THROW(OBJECT_NOT_EXIST, OBJECT_NOT_EXIST_DynAnyDestroyed, \
132 CORBA::COMPLETED_NO); \
133 } while(0)
134
135
136 omni_tracedmutex DynAnyImplBase::refCountLock("DynAnyImplBase::refCountLock");
137
138
~DynAnyImplBase()139 DynAnyImplBase::~DynAnyImplBase()
140 {
141 CORBA::release(pd_tc);
142 }
143
144 //////////////////////
145 // public interface //
146 //////////////////////
147
148 CORBA::TypeCode_ptr
type() const149 DynAnyImplBase::type() const
150 {
151 CHECK_NOT_DESTROYED;
152 return CORBA::TypeCode::_duplicate(pd_tc);
153 }
154
155 void
from_any(const CORBA::Any & value)156 DynAnyImplBase::from_any(const CORBA::Any& value)
157 {
158 CHECK_NOT_DESTROYED;
159 CORBA::TypeCode_var value_tc = value.type();
160 if( !value_tc->equivalent(tc()) ) throw DynamicAny::DynAny::TypeMismatch();
161
162 try {
163 cdrAnyMemoryStream buf(value.PR_streamToRead(), 1);
164 if( !copy_from(buf) ) throw DynamicAny::DynAny::InvalidValue();
165 }
166 catch (CORBA::BAD_PARAM&) {
167 throw DynamicAny::DynAny::InvalidValue();
168 }
169 }
170
171 CORBA::Any*
to_any()172 DynAnyImplBase::to_any()
173 {
174 CHECK_NOT_DESTROYED;
175 CORBA::Any* a = new CORBA::Any(tc(), 0);
176 cdrAnyMemoryStream& buf = a->PR_streamToWrite();
177
178 // <buf> should already be rewound.
179
180 if( !copy_to(buf) ) {
181 delete a;
182 throw DynamicAny::DynAny::InvalidValue();
183 }
184 return a;
185 }
186
187 void
destroy()188 DynAnyImplBase::destroy()
189 {
190 if (is_root()) {
191 omni_tracedmutex_lock sync(DynAnyImplBase::refCountLock);
192 CHECK_NOT_DESTROYED;
193 pd_destroyed = 1;
194 // We don't actually do anything to destroy the data.
195 }
196 else
197 CHECK_NOT_DESTROYED;
198 }
199
200
201 //////////////
202 // internal //
203 //////////////
204
205 void
onDispose()206 DynAnyImplBase::onDispose()
207 {
208 // no-op
209 }
210
211
212 void
_NP_incrRefCount()213 DynAnyImplBase::_NP_incrRefCount()
214 {
215 omni_tracedmutex_lock sync(DynAnyImplBase::refCountLock);
216 pd_refcount++;
217 }
218
219
220 void
_NP_decrRefCount()221 DynAnyImplBase::_NP_decrRefCount()
222 {
223 int do_delete = 0;
224 {
225 omni_tracedmutex_lock sync(DynAnyImplBase::refCountLock);
226
227 if( pd_refcount > 0 ) pd_refcount--;
228
229 if( pd_refcount == 0 && pd_is_root ) {
230 do_delete = 1;
231 // This hook allows derived types to detach their children
232 // so that they will be destroyed when their ref count goes
233 // to zero.
234 onDispose();
235 }
236 }
237
238 if( do_delete ) delete this;
239 }
240
241 //////////////////////////////////////////////////////////////////////
242 ///////////////////////////// DynAnyImpl /////////////////////////////
243 //////////////////////////////////////////////////////////////////////
244
245
DynAnyImpl(TypeCode_base * tc,int nodetype,CORBA::Boolean is_root)246 DynAnyImpl::DynAnyImpl(TypeCode_base* tc, int nodetype, CORBA::Boolean is_root)
247 : DynAnyImplBase(tc, nodetype, is_root), pd_isValid(0)
248 {
249 }
250
251
~DynAnyImpl()252 DynAnyImpl::~DynAnyImpl()
253 {
254 }
255
256 //////////////////////
257 // public interface //
258 //////////////////////
259
260 void
assign(DynamicAny::DynAny_ptr da)261 DynAnyImpl::assign(DynamicAny::DynAny_ptr da)
262 {
263 CHECK_NOT_DESTROYED;
264
265 if ( !DynamicAny::DynAny::PR_is_valid(da) )
266 OMNIORB_THROW(BAD_PARAM, BAD_PARAM_InvalidDynAny, CORBA::COMPLETED_NO);
267
268 if( CORBA::is_nil(da) )
269 throw DynamicAny::DynAny::InvalidValue();
270
271 DynAnyImplBase* daib = ToDynAnyImplBase(da);
272
273 if( !tc()->equivalent(daib->tc()) )
274 throw DynamicAny::DynAny::TypeMismatch();
275
276 DynAnyImpl* dai = ToDynAnyImpl(daib);
277
278 if( !dai->isValid() ) throw DynamicAny::DynAny::InvalidValue();
279
280 dai->pd_buf.rewindInputPtr();
281 pd_buf.rewindPtrs();
282
283 dai->pd_buf.copy_to(pd_buf,dai->pd_buf.bufSize());
284 setValid();
285 }
286
287
288 DynamicAny::DynAny_ptr
copy()289 DynAnyImpl::copy()
290 {
291 CHECK_NOT_DESTROYED;
292
293 DynAnyImpl* da = new DynAnyImpl(TypeCode_collector::duplicateRef(tc()),
294 dt_any, DYNANY_ROOT);
295 try {
296 da->assign(this);
297 }
298 catch(DynamicAny::DynAny::TypeMismatch&) {
299 OMNIORB_ASSERT(0);
300 // This should never happen since the types always match -- they
301 // are the same TypeCode.
302 }
303 catch(...) {
304 da->_NP_decrRefCount();
305 throw;
306 }
307 return da;
308 }
309
310
311 CORBA::Boolean
equal(DynamicAny::DynAny_ptr dyn_any)312 DynAnyImpl::equal(DynamicAny::DynAny_ptr dyn_any)
313 {
314 CHECK_NOT_DESTROYED;
315
316 if ( !DynamicAny::DynAny::PR_is_valid(dyn_any) )
317 OMNIORB_THROW(BAD_PARAM, BAD_PARAM_InvalidDynAny, CORBA::COMPLETED_NO);
318
319 if( CORBA::is_nil(dyn_any) )
320 return 0;
321
322 DynAnyImplBase* ib = ToDynAnyImplBase(dyn_any);
323 if (!tc()->equivalent(ib->tc()))
324 return 0;
325
326
327 switch (actualTc()->kind()) {
328 case CORBA::tk_any:
329 {
330 DynamicAny::DynAny_var a = get_dyn_any();
331 DynamicAny::DynAny_var b = dyn_any->get_dyn_any();
332 return a->equal(b);
333 }
334
335 case CORBA::tk_TypeCode:
336 {
337 // TypeCodes must be equal, not just equivalent.
338 // We can't just compare the marshalled form, since they may
339 // have different indirections.
340 CORBA::TypeCode_var a = get_typecode();
341 CORBA::TypeCode_var b = dyn_any->get_typecode();
342 return a->equal(b);
343 }
344 case CORBA::tk_objref:
345 {
346 // Compare objrefs for equivalence.
347 CORBA::Object_var a = get_reference();
348 CORBA::Object_var b = dyn_any->get_reference();
349 return a->_is_equivalent(b);
350 }
351 #ifdef HAS_LongDouble
352 case CORBA::tk_longdouble:
353 {
354 // Two identical LongDoubles do not necessarily have the same
355 // marshalled format.
356 CORBA::LongDouble a = get_longdouble();
357 CORBA::LongDouble b = dyn_any->get_longdouble();
358 return a == b;
359 }
360 #endif
361 default:
362 // With all other types supported by this class, it's sufficient
363 // to see if the data in the memory buffers is identical.
364 if (pd_buf.bufSize() != ib->pd_buf.bufSize())
365 return 0;
366 return (!memcmp(pd_buf.bufPtr(), ib->pd_buf.bufPtr(), pd_buf.bufSize()));
367 }
368 }
369
370
371 void
insert_boolean(CORBA::Boolean value)372 DynAnyImpl::insert_boolean(CORBA::Boolean value)
373 {
374 CHECK_NOT_DESTROYED;
375 doWrite(CORBA::tk_boolean).marshalBoolean(value);
376 }
377
378
379 void
insert_octet(CORBA::Octet value)380 DynAnyImpl::insert_octet(CORBA::Octet value)
381 {
382 CHECK_NOT_DESTROYED;
383 doWrite(CORBA::tk_octet).marshalOctet(value);
384 }
385
386
387 void
insert_char(CORBA::Char value)388 DynAnyImpl::insert_char(CORBA::Char value)
389 {
390 CHECK_NOT_DESTROYED;
391 doWrite(CORBA::tk_char).marshalChar(value);
392 }
393
394
395 void
insert_short(CORBA::Short value)396 DynAnyImpl::insert_short(CORBA::Short value)
397 {
398 CHECK_NOT_DESTROYED;
399 value >>= doWrite(CORBA::tk_short);
400 }
401
402
403 void
insert_ushort(CORBA::UShort value)404 DynAnyImpl::insert_ushort(CORBA::UShort value)
405 {
406 CHECK_NOT_DESTROYED;
407 value >>= doWrite(CORBA::tk_ushort);
408 }
409
410
411 void
insert_long(CORBA::Long value)412 DynAnyImpl::insert_long(CORBA::Long value)
413 {
414 CHECK_NOT_DESTROYED;
415 value >>= doWrite(CORBA::tk_long);
416 }
417
418
419 void
insert_ulong(CORBA::ULong value)420 DynAnyImpl::insert_ulong(CORBA::ULong value)
421 {
422 CHECK_NOT_DESTROYED;
423 value >>= doWrite(CORBA::tk_ulong);
424 }
425
426 #ifndef NO_FLOAT
427 void
insert_float(CORBA::Float value)428 DynAnyImpl::insert_float(CORBA::Float value)
429 {
430 CHECK_NOT_DESTROYED;
431 value >>= doWrite(CORBA::tk_float);
432 }
433
434 void
insert_double(CORBA::Double value)435 DynAnyImpl::insert_double(CORBA::Double value)
436 {
437 CHECK_NOT_DESTROYED;
438 value >>= doWrite(CORBA::tk_double);
439 }
440
441 #endif
442
443 void
insert_string(const char * value)444 DynAnyImpl::insert_string(const char* value)
445 {
446 CHECK_NOT_DESTROYED;
447 if( !value )
448 throw DynamicAny::DynAny::InvalidValue();
449
450 if ( tckind() != CORBA::tk_string )
451 throw DynamicAny::DynAny::TypeMismatch();
452
453 CORBA::ULong maxlen = actualTc()->NP_length();
454 cdrAnyMemoryStream& buf = doWrite(CORBA::tk_string);
455 try {
456 buf.marshalString(value,maxlen);
457 }
458 catch (CORBA::MARSHAL& ex) {
459 if (ex.minor() == MARSHAL_StringIsTooLong)
460 throw DynamicAny::DynAny::InvalidValue();
461 else
462 throw;
463 }
464 }
465
466
467 void
insert_reference(CORBA::Object_ptr value)468 DynAnyImpl::insert_reference(CORBA::Object_ptr value)
469 {
470 CHECK_NOT_DESTROYED;
471
472 if ( !CORBA::Object::_PR_is_valid(value) )
473 OMNIORB_THROW(BAD_PARAM, BAD_PARAM_InvalidObjectRef, CORBA::COMPLETED_NO);
474
475 CORBA::Object::_marshalObjRef(value, doWrite(CORBA::tk_objref));
476 }
477
478
479 void
insert_typecode(CORBA::TypeCode_ptr value)480 DynAnyImpl::insert_typecode(CORBA::TypeCode_ptr value)
481 {
482 CHECK_NOT_DESTROYED;
483
484 if ( !CORBA::TypeCode::PR_is_valid(value) )
485 OMNIORB_THROW(BAD_PARAM, BAD_PARAM_InvalidTypeCode, CORBA::COMPLETED_NO);
486
487 if( CORBA::is_nil(value) ) throw DynamicAny::DynAny::InvalidValue();
488
489 CORBA::TypeCode::marshalTypeCode(value, doWrite(CORBA::tk_TypeCode));
490 }
491
492
493 #ifdef HAS_LongLong
494 void
insert_longlong(CORBA::LongLong value)495 DynAnyImpl::insert_longlong(CORBA::LongLong value)
496 {
497 CHECK_NOT_DESTROYED;
498 value >>= doWrite(CORBA::tk_longlong);
499 }
500
501 void
insert_ulonglong(CORBA::ULongLong value)502 DynAnyImpl::insert_ulonglong(CORBA::ULongLong value)
503 {
504 CHECK_NOT_DESTROYED;
505 value >>= doWrite(CORBA::tk_ulonglong);
506 }
507 #endif
508
509 #ifdef HAS_LongDouble
510 void
insert_longdouble(CORBA::LongDouble value)511 DynAnyImpl::insert_longdouble(CORBA::LongDouble value)
512 {
513 CHECK_NOT_DESTROYED;
514 value >>= doWrite(CORBA::tk_longdouble);
515 }
516 #endif
517
518 void
insert_wchar(CORBA::WChar value)519 DynAnyImpl::insert_wchar(CORBA::WChar value)
520 {
521 CHECK_NOT_DESTROYED;
522 doWrite(CORBA::tk_wchar).marshalWChar(value);
523 }
524
525 void
insert_wstring(const CORBA::WChar * value)526 DynAnyImpl::insert_wstring(const CORBA::WChar* value)
527 {
528 if( !value )
529 throw DynamicAny::DynAny::InvalidValue();
530
531 if ( tckind() != CORBA::tk_wstring )
532 throw DynamicAny::DynAny::TypeMismatch();
533
534 CORBA::ULong maxlen = actualTc()->NP_length();
535 cdrAnyMemoryStream& buf = doWrite(CORBA::tk_wstring);
536 try {
537 buf.marshalWString(value,maxlen);
538 }
539 catch (CORBA::MARSHAL& ex) {
540 if (ex.minor() == MARSHAL_WStringIsTooLong)
541 throw DynamicAny::DynAny::InvalidValue();
542 else
543 throw;
544 }
545 }
546
547
548 void
insert_any(const CORBA::Any & value)549 DynAnyImpl::insert_any(const CORBA::Any& value)
550 {
551 CHECK_NOT_DESTROYED;
552 value >>= doWrite(CORBA::tk_any);
553 }
554
555 void
insert_dyn_any(DynamicAny::DynAny_ptr value)556 DynAnyImpl::insert_dyn_any(DynamicAny::DynAny_ptr value)
557 {
558 CHECK_NOT_DESTROYED;
559 CORBA::Any_var a(to_any());
560 a.in() >>= doWrite(CORBA::tk_any);
561 }
562
563 void
insert_val(CORBA::ValueBase * value)564 DynAnyImpl::insert_val(CORBA::ValueBase* value)
565 {
566 CHECK_NOT_DESTROYED;
567 throw DynamicAny::DynAny::TypeMismatch();
568 }
569
570 void
insert_abstract(CORBA::AbstractBase_ptr value)571 DynAnyImpl::insert_abstract(CORBA::AbstractBase_ptr value)
572 {
573 CHECK_NOT_DESTROYED;
574
575 cdrAnyMemoryStream& stream = doWrite(CORBA::tk_abstract_interface);
576
577 CORBA::Object_ptr o = value->_NP_to_object();
578 if (!CORBA::is_nil(o)) {
579 stream.marshalBoolean(1);
580 CORBA::Object::_marshalObjRef(0, stream);
581 }
582 else {
583 CORBA::ValueBase* v = value->_NP_to_value();
584 stream.marshalBoolean(0);
585 CORBA::ValueBase::_NP_marshal(v, stream);
586 }
587 }
588
589
590 CORBA::Boolean
get_boolean()591 DynAnyImpl::get_boolean()
592 {
593 CHECK_NOT_DESTROYED;
594 return doRead(CORBA::tk_boolean).unmarshalBoolean();
595 }
596
597
598 CORBA::Octet
get_octet()599 DynAnyImpl::get_octet()
600 {
601 CHECK_NOT_DESTROYED;
602 return doRead(CORBA::tk_octet).unmarshalOctet();
603 }
604
605
606 CORBA::Char
get_char()607 DynAnyImpl::get_char()
608 {
609 CHECK_NOT_DESTROYED;
610 return doRead(CORBA::tk_char).unmarshalChar();
611 }
612
613
614 CORBA::Short
get_short()615 DynAnyImpl::get_short()
616 {
617 CHECK_NOT_DESTROYED;
618 CORBA::Short value;
619 value <<= doRead(CORBA::tk_short);
620 return value;
621 }
622
623
624 CORBA::UShort
get_ushort()625 DynAnyImpl::get_ushort()
626 {
627 CHECK_NOT_DESTROYED;
628 CORBA::UShort value;
629 value <<= doRead(CORBA::tk_ushort);
630 return value;
631 }
632
633
634 CORBA::Long
get_long()635 DynAnyImpl::get_long()
636 {
637 CHECK_NOT_DESTROYED;
638 CORBA::Long value;
639 value <<= doRead(CORBA::tk_long);
640 return value;
641 }
642
643
644 CORBA::ULong
get_ulong()645 DynAnyImpl::get_ulong()
646 {
647 CHECK_NOT_DESTROYED;
648 CORBA::ULong value;
649 value <<= doRead(CORBA::tk_ulong);
650 return value;
651 }
652
653 #ifndef NO_FLOAT
654 CORBA::Float
get_float()655 DynAnyImpl::get_float()
656 {
657 CHECK_NOT_DESTROYED;
658 CORBA::Float value;
659 value <<= doRead(CORBA::tk_float);
660 return value;
661 }
662
663 CORBA::Double
get_double()664 DynAnyImpl::get_double()
665 {
666 CHECK_NOT_DESTROYED;
667 CORBA::Double value;
668 value <<= doRead(CORBA::tk_double);
669 return value;
670 }
671 #endif
672
673 char*
get_string()674 DynAnyImpl::get_string()
675 {
676 CHECK_NOT_DESTROYED;
677 cdrAnyMemoryStream& buf = doRead(CORBA::tk_string);
678
679 CORBA::ULong maxlen = actualTc()->NP_length();
680 try {
681 char* value = buf.unmarshalString(maxlen);
682 return value;
683 }
684 catch (CORBA::MARSHAL& ex) {
685 if (ex.minor() == MARSHAL_StringIsTooLong)
686 throw DynamicAny::DynAny::InvalidValue();
687 else
688 throw;
689 }
690 #ifndef __DECCXX
691 return 0;
692 #endif
693 }
694
695
696 CORBA::Object_ptr
get_reference()697 DynAnyImpl::get_reference()
698 {
699 CHECK_NOT_DESTROYED;
700 return CORBA::Object::_unmarshalObjRef(doRead(CORBA::tk_objref));
701 }
702
703
704 CORBA::TypeCode_ptr
get_typecode()705 DynAnyImpl::get_typecode()
706 {
707 CHECK_NOT_DESTROYED;
708 return CORBA::TypeCode::unmarshalTypeCode(doRead(CORBA::tk_TypeCode));
709 }
710
711
712 #ifdef HAS_LongLong
713 CORBA::LongLong
get_longlong()714 DynAnyImpl::get_longlong()
715 {
716 CHECK_NOT_DESTROYED;
717 CORBA::LongLong value;
718 value <<= doRead(CORBA::tk_longlong);
719 return value;
720 }
721
722 CORBA::ULongLong
get_ulonglong()723 DynAnyImpl::get_ulonglong()
724 {
725 CHECK_NOT_DESTROYED;
726 CORBA::ULongLong value;
727 value <<= doRead(CORBA::tk_ulonglong);
728 return value;
729 }
730 #endif
731
732 #ifdef HAS_LongDouble
733 CORBA::LongDouble
get_longdouble()734 DynAnyImpl::get_longdouble()
735 {
736 CHECK_NOT_DESTROYED;
737 CORBA::LongDouble value;
738 value <<= doRead(CORBA::tk_longdouble);
739 return value;
740 }
741 #endif
742
743 CORBA::WChar
get_wchar()744 DynAnyImpl::get_wchar()
745 {
746 CHECK_NOT_DESTROYED;
747 return doRead(CORBA::tk_wchar).unmarshalWChar();
748 }
749
750 CORBA::WChar*
get_wstring()751 DynAnyImpl::get_wstring()
752 {
753 CHECK_NOT_DESTROYED;
754 cdrAnyMemoryStream& buf = doRead(CORBA::tk_wstring);
755
756 CORBA::ULong maxlen = actualTc()->NP_length();
757 CORBA::WChar* value = buf.unmarshalWString(maxlen);
758 return value;
759 }
760
761 CORBA::Any*
get_any()762 DynAnyImpl::get_any()
763 {
764 CHECK_NOT_DESTROYED;
765 cdrAnyMemoryStream& buf = doRead(CORBA::tk_any);
766
767 CORBA::Any* value = new CORBA::Any();
768 try {
769 *value <<= buf;
770 }
771 catch (...) {
772 delete value;
773 throw;
774 }
775 return value;
776 }
777
778 DynamicAny::DynAny_ptr
get_dyn_any()779 DynAnyImpl::get_dyn_any()
780 {
781 CHECK_NOT_DESTROYED;
782
783 // This could be made faster by short-cutting the Any step, but it's
784 // probably not worth the effort.
785 cdrAnyMemoryStream& buf = doRead(CORBA::tk_any);
786 CORBA::Any a;
787 a <<= buf;
788 return factory_create_dyn_any(a);
789 }
790
791 CORBA::ValueBase*
get_val()792 DynAnyImpl::get_val()
793 {
794 CHECK_NOT_DESTROYED;
795 throw DynamicAny::DynAny::TypeMismatch();
796 }
797
798 CORBA::AbstractBase_ptr
get_abstract()799 DynAnyImpl::get_abstract()
800 {
801 cdrAnyMemoryStream& stream = doRead(CORBA::tk_abstract_interface);
802
803 CORBA::AbstractBase_ptr a;
804
805 CORBA::Boolean b = stream.unmarshalBoolean();
806 if (b) {
807 CORBA::Object_ptr o = CORBA::Object::_unmarshalObjRef(stream);
808 if (CORBA::is_nil(o))
809 return CORBA::AbstractBase::_nil();
810
811 a = (CORBA::AbstractBase_ptr)o->
812 _ptrToObjRef(CORBA::AbstractBase::_PD_repoId);
813 }
814 else {
815 CORBA::ValueBase* v = CORBA::ValueBase::_NP_unmarshal(stream);
816 a = (CORBA::AbstractBase_ptr)v->
817 _ptrToValue(CORBA::AbstractBase::_PD_repoId);
818 }
819 return a;
820 }
821
822
823 // CORBA 2.5 sequence operations
824
825 #define SEQUENCE_OPS(lcname, ucname) \
826 void \
827 DynAnyImpl::insert_##lcname##_seq(CORBA:: ucname##Seq& value) \
828 { \
829 CHECK_NOT_DESTROYED; \
830 throw DynamicAny::DynAny::TypeMismatch(); \
831 } \
832 \
833 CORBA:: ucname##Seq* \
834 DynAnyImpl::get_##lcname##_seq() \
835 { \
836 CHECK_NOT_DESTROYED; \
837 throw DynamicAny::DynAny::TypeMismatch(); \
838 return 0; \
839 }
840
SEQUENCE_OPS(boolean,Boolean)841 SEQUENCE_OPS(boolean, Boolean)
842 SEQUENCE_OPS(octet, Octet)
843 SEQUENCE_OPS(char, Char)
844 SEQUENCE_OPS(short, Short)
845 SEQUENCE_OPS(ushort, UShort)
846 SEQUENCE_OPS(long, Long)
847 SEQUENCE_OPS(ulong, ULong)
848 #ifndef NO_FLOAT
849 SEQUENCE_OPS(float, Float)
850 SEQUENCE_OPS(double, Double)
851 #endif
852 #ifdef HAS_LongLong
853 SEQUENCE_OPS(longlong, LongLong)
854 SEQUENCE_OPS(ulonglong, ULongLong)
855 #endif
856 #ifdef HAS_LongDouble
857 SEQUENCE_OPS(longdouble, LongDouble)
858 #endif
859 SEQUENCE_OPS(wchar, WChar)
860
861 #undef SEQUENCE_OPS
862
863
864 CORBA::Boolean
865 DynAnyImpl::seek(CORBA::Long index)
866 {
867 return 0;
868 }
869
870
871 void
rewind()872 DynAnyImpl::rewind()
873 {
874 // no-op
875 }
876
877
878 CORBA::Boolean
next()879 DynAnyImpl::next()
880 {
881 return 0;
882 }
883
884 CORBA::ULong
component_count()885 DynAnyImpl::component_count()
886 {
887 return 0;
888 }
889
890
891 DynamicAny::DynAny_ptr
current_component()892 DynAnyImpl::current_component()
893 {
894 // The spec is slightly unclear about whether current_component on
895 // base type DynAny should return nil or raise TypeMismatch. We
896 // choose to raise the exception.
897 throw DynamicAny::DynAny::TypeMismatch();
898 return 0;
899 }
900
901
902
903
904 ///////////////////////////////
905 // exposed private interface //
906 ///////////////////////////////
907
908 int
NP_nodetype() const909 DynAnyImpl::NP_nodetype() const
910 {
911 return dt_any;
912 }
913
914 //////////////
915 // internal //
916 //////////////
917
918 void
set_to_initial_value()919 DynAnyImpl::set_to_initial_value()
920 {
921 switch (actualTc()->kind()) {
922 case CORBA::tk_null:
923 case CORBA::tk_void:
924 ToDynAnyImpl(this)->setValid();
925 break;
926
927 case CORBA::tk_short: insert_short(0); break;
928 case CORBA::tk_long: insert_long(0); break;
929 case CORBA::tk_ushort: insert_ushort(0); break;
930 case CORBA::tk_ulong: insert_ulong(0); break;
931 #ifndef NO_FLOAT
932 case CORBA::tk_float: insert_float(0.0); break;
933 case CORBA::tk_double: insert_double(0.0); break;
934 #endif
935 case CORBA::tk_boolean: insert_boolean(0); break;
936 case CORBA::tk_char: insert_char(0); break;
937 case CORBA::tk_octet: insert_octet(0); break;
938 case CORBA::tk_any:
939 {
940 CORBA::Any a;
941 insert_any(a);
942 break;
943 }
944 case CORBA::tk_TypeCode: insert_typecode(CORBA::_tc_null); break;
945 case CORBA::tk_objref: insert_reference(CORBA::Object::_nil()); break;
946 case CORBA::tk_string:
947 insert_string(_CORBA_String_helper::empty_string);
948 break;
949 #ifdef HAS_LongLong
950 case CORBA::tk_longlong: insert_longlong(0); break;
951 case CORBA::tk_ulonglong: insert_ulonglong(0); break;
952 #endif
953 #ifdef HAS_LongDouble
954 case CORBA::tk_longdouble: insert_longdouble(0.0); break;
955 #endif
956 case CORBA::tk_wchar: insert_wchar(0); break;
957 case CORBA::tk_wstring:
958 insert_wstring(_CORBA_WString_helper::empty_wstring);
959 break;
960 default:
961 // Should never get here.
962 OMNIORB_ASSERT(0);
963 }
964 }
965
966
967 int
copy_to(cdrAnyMemoryStream & mbs)968 DynAnyImpl::copy_to(cdrAnyMemoryStream& mbs)
969 {
970 cdrAnyMemoryStream src(pd_buf);
971 try {
972 tcParser::copyStreamToStream(tc(), src, mbs);
973 }
974 catch(CORBA::MARSHAL&) {
975 return 0;
976 }
977 return 1;
978 }
979
980
981 int
copy_from(cdrAnyMemoryStream & mbs)982 DynAnyImpl::copy_from(cdrAnyMemoryStream& mbs)
983 {
984 try {
985 setInvalid();
986 tcParser::copyStreamToMemStream_flush(tc(), mbs, pd_buf);
987 setValid();
988 }
989 catch(CORBA::MARSHAL&) {
990 return 0;
991 }
992 return 1;
993 }
994
995 void*
_ptrToObjRef(const char * repoId)996 DynAnyImpl::_ptrToObjRef(const char* repoId)
997 {
998 if( omni::ptrStrMatch(repoId, DynAnyImpl::_PD_repoId) )
999 return (DynAnyImpl*) this;
1000
1001 if( omni::ptrStrMatch(repoId, DynAnyImplBase::_PD_repoId) )
1002 return (DynAnyImplBase*) this;
1003
1004 if( omni::ptrStrMatch(repoId, DynamicAny::DynAny::_PD_repoId) )
1005 return (DynamicAny::DynAny_ptr) this;
1006
1007 if( omni::ptrStrMatch(repoId, CORBA::Object::_PD_repoId) )
1008 return (CORBA::Object_ptr) this;
1009
1010 return 0;
1011 }
1012
1013
1014
1015 //////////////////////////////////////////////////////////////////////
1016 //////////////////////////// DynFixedImpl ////////////////////////////
1017 //////////////////////////////////////////////////////////////////////
1018
DynFixedImpl(TypeCode_base * tc,CORBA::Boolean is_root)1019 DynFixedImpl::DynFixedImpl(TypeCode_base* tc, CORBA::Boolean is_root)
1020 : DynAnyImpl(tc, dt_fixed, is_root)
1021 {
1022 }
1023
~DynFixedImpl()1024 DynFixedImpl::~DynFixedImpl() {}
1025
1026 //////////////////////
1027 // public interface //
1028 //////////////////////
1029
1030 DynamicAny::DynAny_ptr
copy()1031 DynFixedImpl::copy()
1032 {
1033 CHECK_NOT_DESTROYED;
1034
1035 DynFixedImpl* da = new DynFixedImpl(TypeCode_collector::duplicateRef(tc()),
1036 DYNANY_ROOT);
1037 try {
1038 da->assign(this);
1039 }
1040 catch(DynamicAny::DynAny::TypeMismatch&) {
1041 OMNIORB_ASSERT(0);
1042 // This should never happen since the types always match -- they
1043 // are the same TypeCode.
1044 }
1045 catch(...) {
1046 da->_NP_decrRefCount();
1047 throw;
1048 }
1049 return da;
1050 }
1051
1052 char*
get_value()1053 DynFixedImpl::get_value()
1054 {
1055 CHECK_NOT_DESTROYED;
1056
1057 CORBA::Fixed f;
1058 f.PR_setLimits(actualTc()->NP_fixed_digits(), actualTc()->NP_fixed_scale());
1059 pd_buf.rewindInputPtr();
1060 f <<= pd_buf;
1061
1062 return f.NP_asString();
1063 }
1064
1065 CORBA::Boolean
set_value(const char * val)1066 DynFixedImpl::set_value(const char* val)
1067 {
1068 CHECK_NOT_DESTROYED;
1069
1070 CORBA::Fixed f;
1071 f.PR_setLimits(actualTc()->NP_fixed_digits(), actualTc()->NP_fixed_scale());
1072
1073 try {
1074 CORBA::Boolean precise = f.NP_fromString(val);
1075 pd_buf.rewindPtrs();
1076 f >>= pd_buf;
1077 setValid();
1078 return precise;
1079 }
1080 catch (CORBA::DATA_CONVERSION& ex) {
1081 if (ex.minor() == DATA_CONVERSION_RangeError) {
1082 // Too many digits
1083 throw DynamicAny::DynAny::InvalidValue();
1084 }
1085 else
1086 throw DynamicAny::DynAny::TypeMismatch();
1087 }
1088 #ifndef __DECCXX
1089 return 0; // Never reach here
1090 #endif
1091 }
1092
1093 ///////////////////////////////
1094 // exposed private interface //
1095 ///////////////////////////////
1096
1097 int
NP_nodetype() const1098 DynFixedImpl::NP_nodetype() const
1099 {
1100 return dt_fixed;
1101 }
1102
1103 void
set_to_initial_value()1104 DynFixedImpl::set_to_initial_value()
1105 {
1106 set_value("0");
1107 }
1108
1109 void
_NP_incrRefCount()1110 DynFixedImpl::_NP_incrRefCount()
1111 {
1112 DynAnyImplBase::_NP_incrRefCount();
1113 }
1114
1115 void
_NP_decrRefCount()1116 DynFixedImpl::_NP_decrRefCount()
1117 {
1118 DynAnyImplBase::_NP_decrRefCount();
1119 }
1120
1121
1122 void*
_ptrToObjRef(const char * repoId)1123 DynFixedImpl::_ptrToObjRef(const char* repoId)
1124 {
1125 if( omni::ptrStrMatch(repoId, DynAnyImpl::_PD_repoId) )
1126 return (DynAnyImpl*) this;
1127
1128 if( omni::ptrStrMatch(repoId, DynAnyImplBase::_PD_repoId) )
1129 return (DynAnyImplBase*) this;
1130
1131 if( omni::ptrStrMatch(repoId, DynamicAny::DynFixed::_PD_repoId) )
1132 return (DynamicAny::DynFixed_ptr) this;
1133
1134 if( omni::ptrStrMatch(repoId, DynamicAny::DynAny::_PD_repoId) )
1135 return (DynamicAny::DynAny_ptr) this;
1136
1137 if( omni::ptrStrMatch(repoId, CORBA::Object::_PD_repoId) )
1138 return (CORBA::Object_ptr) this;
1139
1140 return 0;
1141 }
1142
1143
1144 //////////////////////////////////////////////////////////////////////
1145 ///////////////////////////// DynEnumImpl ////////////////////////////
1146 //////////////////////////////////////////////////////////////////////
1147
DynEnumImpl(TypeCode_base * tc,CORBA::Boolean is_root)1148 DynEnumImpl::DynEnumImpl(TypeCode_base* tc, CORBA::Boolean is_root)
1149 : DynAnyImpl(tc, dt_enum, is_root)
1150 {
1151 }
1152
~DynEnumImpl()1153 DynEnumImpl::~DynEnumImpl() {}
1154
1155 //////////////////////
1156 // public interface //
1157 //////////////////////
1158
1159 DynamicAny::DynAny_ptr
copy()1160 DynEnumImpl::copy()
1161 {
1162 CHECK_NOT_DESTROYED;
1163
1164 DynEnumImpl* da = new DynEnumImpl(TypeCode_collector::duplicateRef(tc()),
1165 DYNANY_ROOT);
1166 try {
1167 da->assign(this);
1168 }
1169 catch(DynamicAny::DynAny::TypeMismatch&) {
1170 OMNIORB_ASSERT(0);
1171 // This should never happen since the types always match -- they
1172 // are the same TypeCode.
1173 }
1174 catch(...) {
1175 da->_NP_decrRefCount();
1176 throw;
1177 }
1178 return da;
1179 }
1180
1181
1182 char*
get_as_string()1183 DynEnumImpl::get_as_string()
1184 {
1185 CHECK_NOT_DESTROYED;
1186
1187 CORBA::ULong val;
1188 {
1189 if( !isValid() )
1190 OMNIORB_THROW(BAD_PARAM, BAD_PARAM_InvalidDynAny, CORBA::COMPLETED_NO);
1191
1192 pd_buf.rewindInputPtr();
1193 val <<= pd_buf;
1194 }
1195
1196 if( val >= actualTc()->NP_member_count() )
1197 OMNIORB_THROW(BAD_PARAM, BAD_PARAM_InvalidDynAny, CORBA::COMPLETED_NO);
1198
1199 return CORBA::string_dup(actualTc()->NP_member_name(val));
1200 }
1201
1202
1203 void
set_as_string(const char * value)1204 DynEnumImpl::set_as_string(const char* value)
1205 {
1206 CHECK_NOT_DESTROYED;
1207
1208 if( !value ) OMNIORB_THROW(BAD_PARAM,
1209 BAD_PARAM_NullStringUnexpected,
1210 CORBA::COMPLETED_NO);
1211
1212 CORBA::Long index = actualTc()->NP_member_index(value);
1213 if( index < 0 ) throw DynamicAny::DynAny::InvalidValue();
1214
1215 pd_buf.rewindPtrs();
1216 CORBA::ULong(index) >>= pd_buf;
1217 setValid();
1218 }
1219
1220
1221 CORBA::ULong
get_as_ulong()1222 DynEnumImpl::get_as_ulong()
1223 {
1224 CHECK_NOT_DESTROYED;
1225
1226 CORBA::ULong val;
1227 {
1228 if( !isValid() )
1229 OMNIORB_THROW(BAD_PARAM, BAD_PARAM_InvalidDynAny, CORBA::COMPLETED_NO);
1230 pd_buf.rewindInputPtr();
1231 val <<= pd_buf;
1232 }
1233
1234 if( val >= actualTc()->NP_member_count() )
1235 OMNIORB_THROW(BAD_PARAM, BAD_PARAM_InvalidDynAny, CORBA::COMPLETED_NO);
1236
1237 return val;
1238 }
1239
1240
1241 void
set_as_ulong(CORBA::ULong value)1242 DynEnumImpl::set_as_ulong(CORBA::ULong value)
1243 {
1244 CHECK_NOT_DESTROYED;
1245
1246 if( value >= actualTc()->NP_member_count() )
1247 throw DynamicAny::DynAny::InvalidValue();
1248
1249 pd_buf.rewindPtrs();
1250 value >>= pd_buf;
1251 setValid();
1252 }
1253
1254 ///////////////////////////////
1255 // exposed private interface //
1256 ///////////////////////////////
1257
1258 int
NP_nodetype() const1259 DynEnumImpl::NP_nodetype() const
1260 {
1261 return dt_enum;
1262 }
1263
1264 void
set_to_initial_value()1265 DynEnumImpl::set_to_initial_value()
1266 {
1267 set_as_ulong(0);
1268 }
1269
1270 void
_NP_incrRefCount()1271 DynEnumImpl::_NP_incrRefCount()
1272 {
1273 DynAnyImplBase::_NP_incrRefCount();
1274 }
1275
1276 void
_NP_decrRefCount()1277 DynEnumImpl::_NP_decrRefCount()
1278 {
1279 DynAnyImplBase::_NP_decrRefCount();
1280 }
1281
1282 void*
_ptrToObjRef(const char * repoId)1283 DynEnumImpl::_ptrToObjRef(const char* repoId)
1284 {
1285 if( omni::ptrStrMatch(repoId, DynAnyImpl::_PD_repoId) )
1286 return (DynAnyImpl*) this;
1287
1288 if( omni::ptrStrMatch(repoId, DynAnyImplBase::_PD_repoId) )
1289 return (DynAnyImplBase*) this;
1290
1291 if( omni::ptrStrMatch(repoId, DynamicAny::DynEnum::_PD_repoId) )
1292 return (DynamicAny::DynEnum_ptr) this;
1293
1294 if( omni::ptrStrMatch(repoId, DynamicAny::DynAny::_PD_repoId) )
1295 return (DynamicAny::DynAny_ptr) this;
1296
1297 if( omni::ptrStrMatch(repoId, CORBA::Object::_PD_repoId) )
1298 return (CORBA::Object_ptr) this;
1299
1300 return 0;
1301 }
1302
1303
1304
1305 //////////////////////////////////////////////////////////////////////
1306 ////////////////////////// DynAnyConstrBase //////////////////////////
1307 //////////////////////////////////////////////////////////////////////
1308
DynAnyConstrBase(TypeCode_base * tc,int nodetype,CORBA::Boolean is_root)1309 DynAnyConstrBase::DynAnyConstrBase(TypeCode_base* tc, int nodetype,
1310 CORBA::Boolean is_root)
1311 : DynAnyImplBase(tc, nodetype, is_root)
1312 {
1313 pd_n_components = 0;
1314 pd_n_in_buf = 0;
1315 pd_n_really_in_buf = 0;
1316 pd_first_in_comp = 0;
1317 pd_curr_index = -1;
1318 pd_read_index = 0;
1319 }
1320
1321
~DynAnyConstrBase()1322 DynAnyConstrBase::~DynAnyConstrBase()
1323 {
1324 for( unsigned i = pd_first_in_comp; i < pd_n_components; i++ ) {
1325 if (pd_components[i])
1326 pd_components[i]->_NP_decrRefCount();
1327 }
1328 }
1329
1330 //////////////////////
1331 // public interface //
1332 //////////////////////
1333
1334 void
assign(DynamicAny::DynAny_ptr da)1335 DynAnyConstrBase::assign(DynamicAny::DynAny_ptr da)
1336 {
1337 CHECK_NOT_DESTROYED;
1338
1339 if ( !DynamicAny::DynAny::PR_is_valid(da) )
1340 OMNIORB_THROW(BAD_PARAM, BAD_PARAM_InvalidDynAny, CORBA::COMPLETED_NO);
1341
1342 if( CORBA::is_nil(da) )
1343 throw DynamicAny::DynAny::InvalidValue();
1344
1345 DynAnyImplBase* daib = ToDynAnyImplBase(da);
1346 if( !tc()->equivalent(daib->tc()) )
1347 throw DynamicAny::DynAny::TypeMismatch();
1348
1349 // We do the copy via an intermediate buffer.
1350
1351 cdrAnyMemoryStream buf;
1352
1353 if( !daib->copy_to(buf) )
1354 throw DynamicAny::DynAny::InvalidValue();
1355
1356 if( !copy_from(buf) )
1357 throw omniORB::fatalException(__FILE__,__LINE__,
1358 "DynAnyConstrBase::assign() - copy_from failed unexpectedly");
1359 }
1360
1361 CORBA::Boolean
equal(DynamicAny::DynAny_ptr da)1362 DynAnyConstrBase::equal(DynamicAny::DynAny_ptr da)
1363 {
1364 CHECK_NOT_DESTROYED;
1365
1366 if ( !DynamicAny::DynAny::PR_is_valid(da) )
1367 OMNIORB_THROW(BAD_PARAM, BAD_PARAM_InvalidDynAny, CORBA::COMPLETED_NO);
1368
1369 if( CORBA::is_nil(da) )
1370 return 0;
1371
1372 DynAnyImplBase* daib = ToDynAnyImplBase(da);
1373 if( !tc()->equivalent(daib->tc()) )
1374 return 0;
1375
1376 DynAnyConstrBase* dacb = ToDynAnyConstrBase(da);
1377
1378 createComponent(0);
1379 dacb->createComponent(0);
1380
1381 for (unsigned i=0; i < pd_n_components; i++) {
1382 if (!pd_components[i]->equal(dacb->pd_components[i]))
1383 return 0;
1384 }
1385 return 1;
1386 }
1387
1388
1389 void
insert_boolean(CORBA::Boolean value)1390 DynAnyConstrBase::insert_boolean(CORBA::Boolean value)
1391 {
1392 CHECK_NOT_DESTROYED;
1393 writeCurrent(CORBA::tk_boolean).marshalBoolean(value);
1394 }
1395
1396
1397 void
insert_octet(CORBA::Octet value)1398 DynAnyConstrBase::insert_octet(CORBA::Octet value)
1399 {
1400 CHECK_NOT_DESTROYED;
1401 writeCurrent(CORBA::tk_octet).marshalOctet(value);
1402 }
1403
1404
1405 void
insert_char(CORBA::Char value)1406 DynAnyConstrBase::insert_char(CORBA::Char value)
1407 {
1408 CHECK_NOT_DESTROYED;
1409 writeCurrent(CORBA::tk_char).marshalChar(value);
1410 }
1411
1412
1413 void
insert_short(CORBA::Short value)1414 DynAnyConstrBase::insert_short(CORBA::Short value)
1415 {
1416 CHECK_NOT_DESTROYED;
1417 value >>= writeCurrent(CORBA::tk_short);
1418 }
1419
1420
1421 void
insert_ushort(CORBA::UShort value)1422 DynAnyConstrBase::insert_ushort(CORBA::UShort value)
1423 {
1424 CHECK_NOT_DESTROYED;
1425 value >>= writeCurrent(CORBA::tk_ushort);
1426 }
1427
1428
1429 void
insert_long(CORBA::Long value)1430 DynAnyConstrBase::insert_long(CORBA::Long value)
1431 {
1432 CHECK_NOT_DESTROYED;
1433 value >>= writeCurrent(CORBA::tk_long);
1434 }
1435
1436
1437 void
insert_ulong(CORBA::ULong value)1438 DynAnyConstrBase::insert_ulong(CORBA::ULong value)
1439 {
1440 CHECK_NOT_DESTROYED;
1441 value >>= writeCurrent(CORBA::tk_ulong);
1442 }
1443
1444 #ifndef NO_FLOAT
1445 void
insert_float(CORBA::Float value)1446 DynAnyConstrBase::insert_float(CORBA::Float value)
1447 {
1448 CHECK_NOT_DESTROYED;
1449 value >>= writeCurrent(CORBA::tk_float);
1450 }
1451
1452
1453 void
insert_double(CORBA::Double value)1454 DynAnyConstrBase::insert_double(CORBA::Double value)
1455 {
1456 CHECK_NOT_DESTROYED;
1457 value >>= writeCurrent(CORBA::tk_double);
1458 }
1459
1460 #endif
1461
1462 void
insert_string(const char * value)1463 DynAnyConstrBase::insert_string(const char* value)
1464 {
1465 CHECK_NOT_DESTROYED;
1466 if( !value || pd_curr_index < 0 )
1467 throw DynamicAny::DynAny::InvalidValue();
1468
1469 TypeCode_base* tc =
1470 (TypeCode_base*) TypeCode_base::NP_expand(nthComponentTC(pd_curr_index));
1471
1472 if( tc->NP_kind() != CORBA::tk_string )
1473 throw DynamicAny::DynAny::TypeMismatch();
1474
1475 CORBA::ULong maxlen = tc->NP_length();
1476 cdrAnyMemoryStream& buf = writeCurrent(CORBA::tk_string);
1477 try {
1478 buf.marshalString(value,maxlen);
1479 }
1480 catch (CORBA::MARSHAL& ex) {
1481 if (ex.minor() == MARSHAL_StringIsTooLong)
1482 throw DynamicAny::DynAny::InvalidValue();
1483 else
1484 throw;
1485 }
1486 }
1487
1488
1489 void
insert_reference(CORBA::Object_ptr value)1490 DynAnyConstrBase::insert_reference(CORBA::Object_ptr value)
1491 {
1492 CHECK_NOT_DESTROYED;
1493 if ( !CORBA::Object::_PR_is_valid(value) )
1494 OMNIORB_THROW(BAD_PARAM, BAD_PARAM_InvalidObjectRef, CORBA::COMPLETED_NO);
1495
1496 CORBA::Object::_marshalObjRef(value, writeCurrent(CORBA::tk_objref));
1497 }
1498
1499
1500 void
insert_typecode(CORBA::TypeCode_ptr value)1501 DynAnyConstrBase::insert_typecode(CORBA::TypeCode_ptr value)
1502 {
1503 CHECK_NOT_DESTROYED;
1504
1505 if ( !CORBA::TypeCode::PR_is_valid(value) )
1506 OMNIORB_THROW(BAD_PARAM, BAD_PARAM_InvalidTypeCode, CORBA::COMPLETED_NO);
1507
1508 if( CORBA::is_nil(value) ) throw DynamicAny::DynAny::InvalidValue();
1509
1510 CORBA::TypeCode::marshalTypeCode(value, writeCurrent(CORBA::tk_TypeCode));
1511 }
1512
1513
1514 #ifdef HAS_LongLong
1515 void
insert_longlong(CORBA::LongLong value)1516 DynAnyConstrBase::insert_longlong(CORBA::LongLong value)
1517 {
1518 CHECK_NOT_DESTROYED;
1519 value >>= writeCurrent(CORBA::tk_longlong);
1520 }
1521
1522 void
insert_ulonglong(CORBA::ULongLong value)1523 DynAnyConstrBase::insert_ulonglong(CORBA::ULongLong value)
1524 {
1525 CHECK_NOT_DESTROYED;
1526 value >>= writeCurrent(CORBA::tk_ulonglong);
1527 }
1528 #endif
1529
1530 #ifdef HAS_LongDouble
1531 void
insert_longdouble(CORBA::LongDouble value)1532 DynAnyConstrBase::insert_longdouble(CORBA::LongDouble value)
1533 {
1534 CHECK_NOT_DESTROYED;
1535 value >>= writeCurrent(CORBA::tk_longdouble);
1536 }
1537 #endif
1538
1539
1540 void
insert_wchar(CORBA::WChar value)1541 DynAnyConstrBase::insert_wchar(CORBA::WChar value)
1542 {
1543 CHECK_NOT_DESTROYED;
1544 writeCurrent(CORBA::tk_wchar).marshalWChar(value);
1545 }
1546
1547 void
insert_wstring(const CORBA::WChar * value)1548 DynAnyConstrBase::insert_wstring(const CORBA::WChar* value)
1549 {
1550 CHECK_NOT_DESTROYED;
1551 if( !value || pd_curr_index < 0 )
1552 throw DynamicAny::DynAny::InvalidValue();
1553
1554 TypeCode_base* tc =
1555 (TypeCode_base*) TypeCode_base::NP_expand(nthComponentTC(pd_curr_index));
1556
1557 if( tc->NP_kind() != CORBA::tk_wstring )
1558 throw DynamicAny::DynAny::TypeMismatch();
1559
1560 CORBA::ULong maxlen = tc->NP_length();
1561 cdrAnyMemoryStream& buf = writeCurrent(CORBA::tk_wstring);
1562 try {
1563 buf.marshalWString(value,maxlen);
1564 }
1565 catch (CORBA::MARSHAL& ex) {
1566 if (ex.minor() == MARSHAL_WStringIsTooLong)
1567 throw DynamicAny::DynAny::InvalidValue();
1568 else
1569 throw;
1570 }
1571 }
1572
1573
1574 void
insert_any(const CORBA::Any & value)1575 DynAnyConstrBase::insert_any(const CORBA::Any& value)
1576 {
1577 CHECK_NOT_DESTROYED;
1578 value >>= writeCurrent(CORBA::tk_any);
1579 }
1580
1581 void
insert_dyn_any(DynamicAny::DynAny_ptr value)1582 DynAnyConstrBase::insert_dyn_any(DynamicAny::DynAny_ptr value)
1583 {
1584 CHECK_NOT_DESTROYED;
1585 CORBA::Any_var a(to_any());
1586 a.in() >>= writeCurrent(CORBA::tk_any);
1587 }
1588
1589 void
insert_val(CORBA::ValueBase * value)1590 DynAnyConstrBase::insert_val(CORBA::ValueBase* value)
1591 {
1592 CHECK_NOT_DESTROYED;
1593
1594 CORBA::Any a;
1595 a <<= value;
1596 getCurrent()->from_any(a);
1597 }
1598
1599 void
insert_abstract(CORBA::AbstractBase_ptr value)1600 DynAnyConstrBase::insert_abstract(CORBA::AbstractBase_ptr value)
1601 {
1602 CHECK_NOT_DESTROYED;
1603
1604 cdrAnyMemoryStream& stream = writeCurrent(CORBA::tk_abstract_interface);
1605
1606 CORBA::Object_ptr o = value->_NP_to_object();
1607 if (!CORBA::is_nil(o)) {
1608 stream.marshalBoolean(1);
1609 CORBA::Object::_marshalObjRef(0, stream);
1610 }
1611 else {
1612 CORBA::ValueBase* v = value->_NP_to_value();
1613 stream.marshalBoolean(0);
1614 CORBA::ValueBase::_NP_marshal(v, stream);
1615 }
1616 }
1617
1618
1619
1620 CORBA::Boolean
get_boolean()1621 DynAnyConstrBase::get_boolean()
1622 {
1623 CHECK_NOT_DESTROYED;
1624 return readCurrent(CORBA::tk_boolean).unmarshalBoolean();
1625 }
1626
1627
1628 CORBA::Octet
get_octet()1629 DynAnyConstrBase::get_octet()
1630 {
1631 CHECK_NOT_DESTROYED;
1632 return readCurrent(CORBA::tk_octet).unmarshalOctet();
1633 }
1634
1635
1636 CORBA::Char
get_char()1637 DynAnyConstrBase::get_char()
1638 {
1639 CHECK_NOT_DESTROYED;
1640 return readCurrent(CORBA::tk_char).unmarshalChar();
1641 }
1642
1643
1644 CORBA::Short
get_short()1645 DynAnyConstrBase::get_short()
1646 {
1647 CHECK_NOT_DESTROYED;
1648 CORBA::Short value;
1649 value <<= readCurrent(CORBA::tk_short);
1650 return value;
1651 }
1652
1653
1654 CORBA::UShort
get_ushort()1655 DynAnyConstrBase::get_ushort()
1656 {
1657 CHECK_NOT_DESTROYED;
1658 CORBA::UShort value;
1659 value <<= readCurrent(CORBA::tk_ushort);
1660 return value;
1661 }
1662
1663
1664 CORBA::Long
get_long()1665 DynAnyConstrBase::get_long()
1666 {
1667 CHECK_NOT_DESTROYED;
1668 CORBA::Long value;
1669 value <<= readCurrent(CORBA::tk_long);
1670 return value;
1671 }
1672
1673
1674 CORBA::ULong
get_ulong()1675 DynAnyConstrBase::get_ulong()
1676 {
1677 CHECK_NOT_DESTROYED;
1678 CORBA::ULong value;
1679 value <<= readCurrent(CORBA::tk_ulong);
1680 return value;
1681 }
1682
1683 #ifndef NO_FLOAT
1684 CORBA::Float
get_float()1685 DynAnyConstrBase::get_float()
1686 {
1687 CHECK_NOT_DESTROYED;
1688 CORBA::Float value;
1689 value <<= readCurrent(CORBA::tk_float);
1690 return value;
1691 }
1692
1693
1694 CORBA::Double
get_double()1695 DynAnyConstrBase::get_double()
1696 {
1697 CHECK_NOT_DESTROYED;
1698 CORBA::Double value;
1699 value <<= readCurrent(CORBA::tk_double);
1700 return value;
1701 }
1702
1703 #endif
1704
1705 char*
get_string()1706 DynAnyConstrBase::get_string()
1707 {
1708 CHECK_NOT_DESTROYED;
1709
1710 cdrAnyMemoryStream& buf = readCurrent(CORBA::tk_string);
1711
1712 TypeCode_base* tc = (TypeCode_base*)TypeCode_base::NP_expand(nthComponentTC(pd_curr_index));
1713 CORBA::ULong maxlen = tc->NP_length();
1714 try {
1715 char* value = buf.unmarshalString(maxlen);
1716 return value;
1717 }
1718 catch (CORBA::MARSHAL& ex) {
1719 if (ex.minor() == MARSHAL_StringIsTooLong)
1720 throw DynamicAny::DynAny::InvalidValue();
1721 else
1722 throw;
1723 }
1724 #ifndef __DECCXX
1725 return 0;
1726 #endif
1727 }
1728
1729
1730 CORBA::Object_ptr
get_reference()1731 DynAnyConstrBase::get_reference()
1732 {
1733 CHECK_NOT_DESTROYED;
1734 return CORBA::Object::_unmarshalObjRef(readCurrent(CORBA::tk_objref));
1735 }
1736
1737
1738 CORBA::TypeCode_ptr
get_typecode()1739 DynAnyConstrBase::get_typecode()
1740 {
1741 CHECK_NOT_DESTROYED;
1742 return CORBA::TypeCode::unmarshalTypeCode(readCurrent(CORBA::tk_TypeCode));
1743 }
1744
1745 #ifdef HAS_LongLong
1746 CORBA::LongLong
get_longlong()1747 DynAnyConstrBase::get_longlong()
1748 {
1749 CHECK_NOT_DESTROYED;
1750 CORBA::LongLong value;
1751 value <<= readCurrent(CORBA::tk_longlong);
1752 return value;
1753 }
1754
1755
1756 CORBA::ULongLong
get_ulonglong()1757 DynAnyConstrBase::get_ulonglong()
1758 {
1759 CHECK_NOT_DESTROYED;
1760 CORBA::ULongLong value;
1761 value <<= readCurrent(CORBA::tk_ulonglong);
1762 return value;
1763 }
1764 #endif
1765
1766
1767 #ifdef HAS_LongDouble
1768 CORBA::LongDouble
get_longdouble()1769 DynAnyConstrBase::get_longdouble()
1770 {
1771 CHECK_NOT_DESTROYED;
1772 CORBA::LongDouble value;
1773 value <<= readCurrent(CORBA::tk_longdouble);
1774 return value;
1775 }
1776 #endif
1777
1778 CORBA::WChar
get_wchar()1779 DynAnyConstrBase::get_wchar()
1780 {
1781 CHECK_NOT_DESTROYED;
1782 return readCurrent(CORBA::tk_wchar).unmarshalWChar();
1783 }
1784
1785 CORBA::WChar*
get_wstring()1786 DynAnyConstrBase::get_wstring()
1787 {
1788 CHECK_NOT_DESTROYED;
1789 cdrAnyMemoryStream& buf = readCurrent(CORBA::tk_wstring);
1790
1791 TypeCode_base* tc = (TypeCode_base*)TypeCode_base::NP_expand(nthComponentTC(pd_curr_index));
1792 CORBA::ULong maxlen = tc->NP_length();
1793 CORBA::WChar* value = buf.unmarshalWString(maxlen);
1794 return value;
1795 }
1796
1797
1798 CORBA::Any*
get_any()1799 DynAnyConstrBase::get_any()
1800 {
1801 CHECK_NOT_DESTROYED;
1802 CORBA::Any* value = new CORBA::Any();
1803 try {
1804 *value <<= readCurrent(CORBA::tk_any);
1805 }
1806 catch(...) {
1807 delete value;
1808 throw;
1809 }
1810 return value;
1811 }
1812
1813 DynamicAny::DynAny_ptr
get_dyn_any()1814 DynAnyConstrBase::get_dyn_any()
1815 {
1816 CHECK_NOT_DESTROYED;
1817 CORBA::Any value;
1818 value <<= readCurrent(CORBA::tk_any);
1819 return factory_create_dyn_any(value);
1820 }
1821
1822 CORBA::ValueBase*
get_val()1823 DynAnyConstrBase::get_val()
1824 {
1825 CORBA::TCKind k = currentKind();
1826
1827 if (k != CORBA::tk_value && k != CORBA::tk_value_box)
1828 throw DynamicAny::DynAny::TypeMismatch();
1829
1830 CORBA::Any_var a = getCurrent()->to_any();
1831 CORBA::ValueBase* v;
1832 a >>= v;
1833 return v;
1834 }
1835
1836 CORBA::AbstractBase_ptr
get_abstract()1837 DynAnyConstrBase::get_abstract()
1838 {
1839 cdrAnyMemoryStream& stream = readCurrent(CORBA::tk_abstract_interface);
1840
1841 CORBA::AbstractBase_ptr a;
1842
1843 CORBA::Boolean b = stream.unmarshalBoolean();
1844 if (b) {
1845 CORBA::Object_ptr o = CORBA::Object::_unmarshalObjRef(stream);
1846 if (CORBA::is_nil(o))
1847 return CORBA::AbstractBase::_nil();
1848
1849 a = (CORBA::AbstractBase_ptr)o->
1850 _ptrToObjRef(CORBA::AbstractBase::_PD_repoId);
1851 }
1852 else {
1853 CORBA::ValueBase* v = CORBA::ValueBase::_NP_unmarshal(stream);
1854 a = (CORBA::AbstractBase_ptr)v->
1855 _ptrToValue(CORBA::AbstractBase::_PD_repoId);
1856 }
1857 return a;
1858 }
1859
1860 //
1861 // CORBA 2.5 sequence operations
1862 //
1863
1864 void
insert_boolean_seq(CORBA::BooleanSeq & value)1865 DynAnyConstrBase::insert_boolean_seq(CORBA::BooleanSeq& value)
1866 {
1867 CHECK_NOT_DESTROYED;
1868
1869 if (prepareSequenceWrite(CORBA::tk_boolean, value.length()) == SEQ_HERE)
1870 pd_buf.put_octet_array((_CORBA_Octet*)value.NP_data(), value.length());
1871 else
1872 getCurrent()->insert_boolean_seq(value);
1873 }
1874
1875 void
insert_octet_seq(CORBA::OctetSeq & value)1876 DynAnyConstrBase::insert_octet_seq(CORBA::OctetSeq& value)
1877 {
1878 CHECK_NOT_DESTROYED;
1879
1880 if (prepareSequenceWrite(CORBA::tk_octet, value.length()) == SEQ_HERE)
1881 pd_buf.put_octet_array((_CORBA_Octet*)value.NP_data(), value.length());
1882 else
1883 getCurrent()->insert_octet_seq(value);
1884 }
1885
1886 void
insert_char_seq(CORBA::CharSeq & value)1887 DynAnyConstrBase::insert_char_seq(CORBA::CharSeq& value)
1888 {
1889 CHECK_NOT_DESTROYED;
1890
1891 if (prepareSequenceWrite(CORBA::tk_char, value.length()) == SEQ_HERE) {
1892 CORBA::Char* data = value.NP_data();
1893 for (CORBA::ULong i=0; i < value.length(); i++)
1894 pd_buf.marshalChar(data[i]);
1895 }
1896 else
1897 getCurrent()->insert_char_seq(value);
1898 }
1899
1900 void
insert_wchar_seq(CORBA::WCharSeq & value)1901 DynAnyConstrBase::insert_wchar_seq(CORBA::WCharSeq& value)
1902 {
1903 CHECK_NOT_DESTROYED;
1904
1905 if (prepareSequenceWrite(CORBA::tk_wchar, value.length()) == SEQ_HERE) {
1906 CORBA::WChar* data = value.NP_data();
1907 for (CORBA::ULong i=0; i < value.length(); i++)
1908 pd_buf.marshalWChar(data[i]);
1909 }
1910 else
1911 getCurrent()->insert_wchar_seq(value);
1912 }
1913
1914
1915 // Too lazy to type all these out...
1916
1917 #define INSERT_SEQ_OP(lcname, ucname, align, size) \
1918 void \
1919 DynAnyConstrBase::insert_##lcname##_seq(CORBA:: ucname##Seq& value) \
1920 { \
1921 CHECK_NOT_DESTROYED; \
1922 \
1923 if (prepareSequenceWrite(CORBA::tk_##lcname, value.length()) == SEQ_HERE) { \
1924 if (!pd_buf.marshal_byte_swap()) { \
1925 pd_buf.put_octet_array((_CORBA_Octet*)value.NP_data(), \
1926 value.length() * size, omni::ALIGN_##align); \
1927 } \
1928 else { \
1929 _CORBA_##ucname* data = value.NP_data(); \
1930 for (CORBA::ULong i=0; i < value.length(); i++) \
1931 data[i] >>= pd_buf; \
1932 } \
1933 } \
1934 else \
1935 getCurrent()->insert_##lcname##_seq(value); \
1936 }
1937
1938 INSERT_SEQ_OP(short, Short, 2, 2)
1939 INSERT_SEQ_OP(ushort, UShort, 2, 2)
1940 INSERT_SEQ_OP(long, Long, 4, 4)
1941 INSERT_SEQ_OP(ulong, ULong, 4, 4)
1942 #ifndef NO_FLOAT
1943 INSERT_SEQ_OP(float, Float, 4, 4)
1944 INSERT_SEQ_OP(double, Double, 8, 8)
1945 #endif
1946 #ifdef HAS_LongLong
1947 INSERT_SEQ_OP(longlong, LongLong, 8, 8)
1948 INSERT_SEQ_OP(ulonglong, ULongLong, 8, 8)
1949 #endif
1950 #ifdef HAS_LongDouble
1951 INSERT_SEQ_OP(longdouble, LongDouble, 8, 16)
1952 #endif
1953
1954 #undef INSERT_SEQ_OP
1955
1956
1957
1958 CORBA::BooleanSeq*
get_boolean_seq()1959 DynAnyConstrBase::get_boolean_seq()
1960 {
1961 CHECK_NOT_DESTROYED;
1962
1963 if (prepareSequenceRead(CORBA::tk_boolean) == SEQ_HERE) {
1964 if (pd_n_in_buf < pd_first_in_comp)
1965 throw DynamicAny::DynAny::InvalidValue();
1966
1967 CORBA::BooleanSeq_var seq = new CORBA::BooleanSeq(pd_n_components);
1968 seq->length(pd_n_components);
1969 CORBA::Boolean* data = seq->NP_data();
1970
1971 if (pd_first_in_comp > 0) {
1972 pd_buf.rewindInputPtr();
1973 pd_buf.get_octet_array((_CORBA_Octet*)data, pd_first_in_comp);
1974 }
1975 for (unsigned i = pd_first_in_comp; i < pd_n_components; i++)
1976 data[i] = pd_components[i]->get_boolean();
1977
1978 return seq._retn();
1979 }
1980 else {
1981 return getCurrent()->get_boolean_seq();
1982 }
1983 }
1984
1985 CORBA::OctetSeq*
get_octet_seq()1986 DynAnyConstrBase::get_octet_seq()
1987 {
1988 CHECK_NOT_DESTROYED;
1989
1990 if (prepareSequenceRead(CORBA::tk_octet) == SEQ_HERE) {
1991 if (pd_n_in_buf < pd_first_in_comp)
1992 throw DynamicAny::DynAny::InvalidValue();
1993
1994 CORBA::OctetSeq_var seq = new CORBA::OctetSeq(pd_n_components);
1995 seq->length(pd_n_components);
1996 CORBA::Octet* data = seq->NP_data();
1997
1998 if (pd_first_in_comp > 0) {
1999 pd_buf.rewindInputPtr();
2000 pd_buf.get_octet_array((_CORBA_Octet*)data, pd_first_in_comp);
2001 }
2002 for (unsigned i = pd_first_in_comp; i < pd_n_components; i++)
2003 data[i] = pd_components[i]->get_octet();
2004
2005 return seq._retn();
2006 }
2007 else {
2008 return getCurrent()->get_octet_seq();
2009 }
2010 }
2011
2012 CORBA::CharSeq*
get_char_seq()2013 DynAnyConstrBase::get_char_seq()
2014 {
2015 CHECK_NOT_DESTROYED;
2016
2017 if (prepareSequenceRead(CORBA::tk_char) == SEQ_HERE) {
2018 if (pd_n_in_buf < pd_first_in_comp)
2019 throw DynamicAny::DynAny::InvalidValue();
2020
2021 CORBA::CharSeq_var seq = new CORBA::CharSeq(pd_n_components);
2022 seq->length(pd_n_components);
2023 CORBA::Char* data = seq->NP_data();
2024
2025 if (pd_first_in_comp > 0) {
2026 pd_buf.rewindInputPtr();
2027
2028 for (unsigned i=0; i < pd_first_in_comp; i++)
2029 data[i] = pd_buf.unmarshalChar();
2030 }
2031 for (unsigned i = pd_first_in_comp; i < pd_n_components; i++)
2032 data[i] = pd_components[i]->get_char();
2033
2034 return seq._retn();
2035 }
2036 else {
2037 return getCurrent()->get_char_seq();
2038 }
2039 }
2040
2041 CORBA::WCharSeq*
get_wchar_seq()2042 DynAnyConstrBase::get_wchar_seq()
2043 {
2044 CHECK_NOT_DESTROYED;
2045
2046 if (prepareSequenceRead(CORBA::tk_wchar) == SEQ_HERE) {
2047 if (pd_n_in_buf < pd_first_in_comp)
2048 throw DynamicAny::DynAny::InvalidValue();
2049
2050 CORBA::WCharSeq_var seq = new CORBA::WCharSeq(pd_n_components);
2051 seq->length(pd_n_components);
2052 CORBA::WChar* data = seq->NP_data();
2053
2054 if (pd_first_in_comp > 0) {
2055 pd_buf.rewindInputPtr();
2056
2057 for (unsigned i=0; i < pd_first_in_comp; i++)
2058 data[i] = pd_buf.unmarshalWChar();
2059 }
2060 for (unsigned i = pd_first_in_comp; i < pd_n_components; i++)
2061 data[i] = pd_components[i]->get_wchar();
2062
2063 return seq._retn();
2064 }
2065 else {
2066 return getCurrent()->get_wchar_seq();
2067 }
2068 }
2069
2070 #define GET_SEQ_OP(lcname, ucname, align, size) \
2071 CORBA:: ucname##Seq* \
2072 DynAnyConstrBase::get_##lcname##_seq() \
2073 { \
2074 CHECK_NOT_DESTROYED; \
2075 \
2076 if (prepareSequenceRead(CORBA::tk_##lcname) == SEQ_HERE) { \
2077 if (pd_n_in_buf < pd_first_in_comp) \
2078 throw DynamicAny::DynAny::InvalidValue(); \
2079 \
2080 CORBA:: ucname##Seq_var seq = new CORBA:: ucname##Seq(pd_n_components); \
2081 seq->length(pd_n_components); \
2082 _CORBA_##ucname * data = seq->NP_data(); \
2083 \
2084 if (pd_first_in_comp > 0) { \
2085 pd_buf.rewindInputPtr(); \
2086 if (!pd_buf.unmarshal_byte_swap()) { \
2087 pd_buf.get_octet_array((_CORBA_Octet*)data, pd_first_in_comp * size, \
2088 omni::ALIGN_##align); \
2089 } \
2090 else { \
2091 for (unsigned i=0; i < pd_first_in_comp; i++) \
2092 data[i] <<= pd_buf; \
2093 } \
2094 } \
2095 for (unsigned i = pd_first_in_comp; i < pd_n_components; i++) \
2096 data[i] = pd_components[i]->get_octet(); \
2097 \
2098 return seq._retn(); \
2099 } \
2100 else { \
2101 return getCurrent()->get_##lcname##_seq(); \
2102 } \
2103 }
2104
2105 GET_SEQ_OP(short, Short, 2, 2)
2106 GET_SEQ_OP(ushort, UShort, 2, 2)
2107 GET_SEQ_OP(long, Long, 4, 4)
2108 GET_SEQ_OP(ulong, ULong, 4, 4)
2109 #ifndef NO_FLOAT
2110 GET_SEQ_OP(float, Float, 4, 4)
2111 GET_SEQ_OP(double, Double, 8, 8)
2112 #endif
2113 #ifdef HAS_LongLong
2114 GET_SEQ_OP(longlong, LongLong, 8, 8)
2115 GET_SEQ_OP(ulonglong, ULongLong, 8, 8)
2116 #endif
2117 #ifdef HAS_LongDouble
2118 GET_SEQ_OP(longdouble, LongDouble, 8, 16)
2119 #endif
2120
2121 #undef GET_SEQ_OP
2122
2123
2124
2125
2126 CORBA::Boolean
seek(CORBA::Long index)2127 DynAnyConstrBase::seek(CORBA::Long index)
2128 {
2129 CHECK_NOT_DESTROYED;
2130 if( index < 0 || index >= (int)pd_n_components ) {
2131 pd_curr_index = -1;
2132 return 0;
2133 }
2134 else {
2135 pd_curr_index = index;
2136 return 1;
2137 }
2138 }
2139
2140
2141 void
rewind()2142 DynAnyConstrBase::rewind()
2143 {
2144 CHECK_NOT_DESTROYED;
2145 pd_curr_index = pd_n_components ? 0 : -1;
2146 }
2147
2148
2149 CORBA::Boolean
next()2150 DynAnyConstrBase::next()
2151 {
2152 CHECK_NOT_DESTROYED;
2153 if( pd_curr_index + 1 < (int)pd_n_components ) pd_curr_index++;
2154 else pd_curr_index = -1;
2155
2156 return pd_curr_index >= 0;
2157 }
2158
2159
2160 CORBA::ULong
component_count()2161 DynAnyConstrBase::component_count()
2162 {
2163 CHECK_NOT_DESTROYED;
2164 return pd_n_components;
2165 }
2166
2167
2168 DynamicAny::DynAny_ptr
current_component()2169 DynAnyConstrBase::current_component()
2170 {
2171 CHECK_NOT_DESTROYED;
2172
2173 if( pd_n_components == 0 ) {
2174 CORBA::TCKind k = actualTc()->kind();
2175 if (k != CORBA::tk_sequence && k != CORBA::tk_value_box)
2176 throw DynamicAny::DynAny::TypeMismatch();
2177 }
2178
2179 if( pd_curr_index < 0 )
2180 return DynamicAny::DynAny::_nil();
2181
2182 DynAnyImplBase* da = getCurrent();
2183 da->_NP_incrRefCount();
2184 return da;
2185 }
2186
2187
2188
2189
2190 //////////////
2191 // internal //
2192 //////////////
2193
2194 void
set_to_initial_value()2195 DynAnyConstrBase::set_to_initial_value()
2196 {
2197 if (pd_n_components > 0) {
2198 createComponent(0);
2199 for (unsigned i=0; i < pd_n_components; i++)
2200 pd_components[i]->set_to_initial_value();
2201 }
2202 pd_curr_index = (pd_n_components == 0) ? -1 : 0;
2203 }
2204
2205 int
copy_to(cdrAnyMemoryStream & mbs)2206 DynAnyConstrBase::copy_to(cdrAnyMemoryStream& mbs)
2207 {
2208 if( pd_n_in_buf != pd_first_in_comp ) return 0;
2209
2210 cdrAnyMemoryStream src(pd_buf);
2211 pd_read_index = -1;
2212
2213 unsigned i;
2214 try {
2215 // Copy the components in the buffer.
2216 for( i = 0; i < pd_n_in_buf; i++ ) {
2217 TypeCode_base* ctc = nthComponentTC(i);
2218 tcParser::copyStreamToStream(ctc, src, mbs);
2219 }
2220 }
2221 catch(CORBA::MARSHAL&) {
2222 return 0;
2223 }
2224
2225 // The rest are in external components.
2226 for( ; i < pd_n_components; i++ ) {
2227 if( !pd_components[i]->copy_to(mbs) )
2228 return 0;
2229 }
2230 return 1;
2231 }
2232
2233
2234 int
copy_from(cdrAnyMemoryStream & mbs)2235 DynAnyConstrBase::copy_from(cdrAnyMemoryStream& mbs)
2236 {
2237 pd_buf.rewindPtrs();
2238 pd_read_index = 0;
2239
2240 unsigned i;
2241 try {
2242 // Copy components into the buffer.
2243 for( i = 0; i < pd_first_in_comp; i++ ) {
2244 TypeCode_base* ctc = nthComponentTC(i);
2245 tcParser::copyStreamToStream(ctc, mbs, pd_buf);
2246 }
2247 }
2248 catch(CORBA::MARSHAL&) {
2249 pd_buf.rewindPtrs();
2250 pd_n_in_buf = 0;
2251 pd_n_really_in_buf = 0;
2252 return 0;
2253 }
2254
2255 // Copy into external components.
2256 for( ; i < pd_n_components; i++ ) {
2257 if( !pd_components[i]->copy_from(mbs) )
2258 return 0;
2259 }
2260
2261 pd_n_really_in_buf = pd_n_in_buf = pd_first_in_comp;
2262 pd_curr_index = (pd_n_components == 0) ? -1 : 0;
2263 return 1;
2264 }
2265
2266
2267 void
onDispose()2268 DynAnyConstrBase::onDispose()
2269 {
2270 for( unsigned i = pd_first_in_comp; i < pd_n_components; i++ )
2271 pd_components[i]->detach();
2272 }
2273
2274
2275 void
setNumComponents(unsigned n)2276 DynAnyConstrBase::setNumComponents(unsigned n)
2277 {
2278 if( n == pd_n_components ) return;
2279
2280 if( n < pd_n_components ) {
2281 // Detach any orphaned components stored in <pd_components>.
2282 unsigned start = pd_first_in_comp > n ? pd_first_in_comp : n;
2283 for( unsigned i = start; i < pd_n_components; i++ ) {
2284 pd_components[i]->detach();
2285 pd_components[i]->_NP_decrRefCount();
2286 }
2287 pd_components.reserve(n);
2288 DynAnyImplBase* tmp = 0;
2289 while( pd_components.size() < n ) pd_components.push_back(tmp);
2290 pd_n_components = n;
2291 if( n < pd_n_in_buf ) pd_n_in_buf = n;
2292 if( (int)n < pd_read_index ) pd_read_index = -1;
2293 if( pd_first_in_comp > pd_n_components )
2294 pd_first_in_comp = pd_n_components;
2295 }
2296 else {
2297 // Add new components.
2298 pd_components.reserve(n);
2299 DynAnyImplBase* tmp = 0;
2300 while( pd_components.size() < n ) pd_components.push_back(tmp);
2301 unsigned old_n_components = pd_n_components;
2302 pd_n_components = n;
2303
2304 OMNIORB_ASSERT(pd_first_in_comp <= old_n_components);
2305
2306 // Add in the new components
2307 for( unsigned i = old_n_components; i < pd_n_components; i++ ) {
2308 CORBA::TypeCode_ptr tc =
2309 CORBA::TypeCode::_duplicate(nthComponentTC(i));
2310 pd_components[i] = internal_create_dyn_any(ToTcBase(tc), DYNANY_CHILD);
2311 pd_components[i]->set_to_initial_value();
2312 }
2313 }
2314 }
2315
2316
2317 void
createComponent(unsigned n)2318 DynAnyConstrBase::createComponent(unsigned n)
2319 {
2320 if( n >= pd_first_in_comp ) return;
2321
2322 // Copy components out of the buffer.
2323 unsigned i;
2324 for( i = n; i < pd_n_in_buf; i++ ) {
2325 CORBA::TypeCode_ptr tc = CORBA::TypeCode::_duplicate(nthComponentTC(i));
2326 DynAnyImplBase* da = internal_create_dyn_any(ToTcBase(tc), DYNANY_CHILD);
2327 if( pd_read_index != (int)i ) seekTo(i);
2328 if( !da->copy_from(pd_buf) ) {
2329 throw omniORB::fatalException(__FILE__,__LINE__,
2330 "DynAnyConstrBase::createComponent() - copy_from() failed");
2331 }
2332 pd_read_index++;
2333 pd_components[i] = da;
2334 }
2335
2336 // Create uninitialised components for those not yet inserted.
2337 for( ; i < pd_first_in_comp; i++ ) {
2338 CORBA::TypeCode_ptr tc = CORBA::TypeCode::_duplicate(nthComponentTC(i));
2339 pd_components[i] = internal_create_dyn_any(ToTcBase(tc), DYNANY_CHILD);
2340 }
2341
2342 pd_first_in_comp = n;
2343 if( n < pd_n_in_buf ) pd_n_in_buf = n;
2344 }
2345
2346 void
seekTo(unsigned n)2347 DynAnyConstrBase::seekTo(unsigned n)
2348 {
2349 // For safety we assume that this would not have been called
2350 // unless a seek really is needed - so we do not just return
2351 // if( pd_read_index == i ).
2352
2353 if( n >= pd_n_in_buf ) {
2354 throw omniORB::fatalException(__FILE__,__LINE__,
2355 "DynAnyConstrBase::seekTo() - <n> out of bounds");
2356 }
2357
2358 pd_buf.rewindInputPtr();
2359
2360 for( unsigned i = 0; i < n; i++ ) {
2361 TypeCode_base* ctc = nthComponentTC(i);
2362 try {
2363 tcParser::skip(ctc, pd_buf);
2364 }
2365 catch(CORBA::MARSHAL&) {
2366 throw omniORB::fatalException(__FILE__,__LINE__,
2367 "DynAnyConstrBase::seekTo() - unexpected exception");
2368 }
2369 }
2370 pd_read_index = n;
2371 }
2372
2373
2374 int
component_to_any(unsigned i,CORBA::Any & a)2375 DynAnyConstrBase::component_to_any(unsigned i, CORBA::Any& a)
2376 {
2377 a.replace(nthComponentTC(i), 0);
2378
2379 if( i < pd_n_in_buf ) {
2380 if( pd_read_index != (int)i ) seekTo(i);
2381 try {
2382 CORBA::TypeCode_var tc = a.type();
2383 tcParser::copyStreamToStream(tc, pd_buf,
2384 a.PR_streamToWrite());
2385 }
2386 catch(CORBA::MARSHAL&) {
2387 throw omniORB::fatalException(__FILE__,__LINE__,
2388 "DynAnyConstrBase::component_to_any() - unexpected exception");
2389 }
2390 pd_read_index++;
2391 return 1;
2392 }
2393 else if( i >= pd_first_in_comp ) {
2394 cdrAnyMemoryStream& buf = a.PR_streamToWrite();
2395 return pd_components[i]->copy_to(buf);
2396 }
2397 else
2398 return 0;
2399 }
2400
2401
2402 int
component_from_any(unsigned i,const CORBA::Any & a)2403 DynAnyConstrBase::component_from_any(unsigned i, const CORBA::Any& a)
2404 {
2405 CORBA::TypeCode_var tc = a.type();
2406 if( !tc->equivalent(nthComponentTC(i)) ) return 0;
2407
2408 if( canAppendComponent(i) ) {
2409 try {
2410 CORBA::TypeCode_var tc = a.type();
2411 cdrAnyMemoryStream src(a.PR_streamToRead(), 1);
2412 tcParser::copyStreamToMemStream_flush(tc, src, pd_buf);
2413 }
2414 catch(CORBA::MARSHAL&) {
2415 // <pd_buf> may have been partly written to, so we can't
2416 // append to it any more. Appends are only allowed if
2417 // pd_n_in_buf == pd_n_really_in_buf so ...
2418 pd_n_really_in_buf++;
2419 return 0;
2420 }
2421 catch (CORBA::BAD_PARAM&) {
2422 throw DynamicAny::DynAny::InvalidValue();
2423 }
2424 pd_n_in_buf++;
2425 pd_n_really_in_buf++;
2426 return 1;
2427 }
2428
2429 if( i < pd_first_in_comp ) createComponent(i);
2430
2431 try {
2432 cdrAnyMemoryStream buf(a.PR_streamToRead(), 1);
2433 return pd_components[i]->copy_from(buf);
2434 }
2435 catch (CORBA::BAD_PARAM&) {
2436 throw DynamicAny::DynAny::InvalidValue();
2437 }
2438 }
2439
2440
2441
2442
2443
2444 //////////////////////////////////////////////////////////////////////
2445 //////////////////////////// DynStructImpl ///////////////////////////
2446 //////////////////////////////////////////////////////////////////////
2447
DynStructImpl(TypeCode_base * tc,CORBA::Boolean is_root)2448 DynStructImpl::DynStructImpl(TypeCode_base* tc, CORBA::Boolean is_root)
2449 : DynAnyConstrBase(tc, dt_struct, is_root)
2450 {
2451 setNumComponents(actualTc()->NP_member_count());
2452 }
2453
2454
~DynStructImpl()2455 DynStructImpl::~DynStructImpl()
2456 {
2457 }
2458
2459 //////////////////////
2460 // public interface //
2461 //////////////////////
2462
2463 DynamicAny::DynAny_ptr
copy()2464 DynStructImpl::copy()
2465 {
2466 CHECK_NOT_DESTROYED;
2467 DynStructImpl* da = new DynStructImpl(TypeCode_collector::duplicateRef(tc()),
2468 DYNANY_ROOT);
2469 try {
2470 da->assign(this);
2471 }
2472 catch(...) {
2473 da->_NP_decrRefCount();
2474 throw;
2475 }
2476 return da;
2477 }
2478
2479 char*
current_member_name()2480 DynStructImpl::current_member_name()
2481 {
2482 CHECK_NOT_DESTROYED;
2483 if( pd_n_components == 0 ) throw DynamicAny::DynAny::TypeMismatch();
2484 if( pd_curr_index < 0 ) throw DynamicAny::DynAny::InvalidValue();
2485
2486 return CORBA::string_dup(actualTc()->NP_member_name(pd_curr_index));
2487 }
2488
2489
2490 CORBA::TCKind
current_member_kind()2491 DynStructImpl::current_member_kind()
2492 {
2493 CHECK_NOT_DESTROYED;
2494 if( pd_n_components == 0 ) throw DynamicAny::DynAny::TypeMismatch();
2495 if( pd_curr_index < 0 ) throw DynamicAny::DynAny::InvalidValue();
2496
2497 return actualTc()->NP_member_type(pd_curr_index)->kind();
2498 }
2499
2500
2501 DynamicAny::NameValuePairSeq*
get_members()2502 DynStructImpl::get_members()
2503 {
2504 CHECK_NOT_DESTROYED;
2505 DynamicAny::NameValuePairSeq* nvps = new DynamicAny::NameValuePairSeq();
2506
2507 nvps->length(pd_n_components);
2508
2509 for( unsigned i = 0; i < pd_n_components; i++ ) {
2510 (*nvps)[i].id = CORBA::string_dup(actualTc()->NP_member_name(i));
2511 if( !component_to_any(i, (*nvps)[i].value) ) {
2512 delete nvps;
2513 OMNIORB_THROW(BAD_INV_ORDER, BAD_INV_ORDER_DynAnyNotInitialised,
2514 CORBA::COMPLETED_NO);
2515 }
2516 }
2517 return nvps;
2518 }
2519
2520
2521 void
set_members(const DynamicAny::NameValuePairSeq & nvps)2522 DynStructImpl::set_members(const DynamicAny::NameValuePairSeq& nvps)
2523 {
2524 CHECK_NOT_DESTROYED;
2525 if( nvps.length() != pd_n_components )
2526 throw DynamicAny::DynAny::InvalidValue();
2527
2528 for( unsigned i = 0; i < pd_n_components; i++ ) {
2529 if( ((const char*)(nvps[i].id))[0] != '\0' &&
2530 strcmp((const char*)(nvps[i].id), actualTc()->NP_member_name(i)) )
2531 throw DynamicAny::DynAny::TypeMismatch();
2532
2533 if( !component_from_any(i, nvps[i].value) )
2534 throw DynamicAny::DynAny::TypeMismatch();
2535 }
2536 pd_curr_index = (pd_n_components == 0) ? -1 : 0;
2537 }
2538
2539
2540 DynamicAny::NameDynAnyPairSeq*
get_members_as_dyn_any()2541 DynStructImpl::get_members_as_dyn_any()
2542 {
2543 CHECK_NOT_DESTROYED;
2544
2545 if (pd_n_in_buf != pd_first_in_comp)
2546 OMNIORB_THROW(BAD_INV_ORDER, BAD_INV_ORDER_DynAnyNotInitialised,
2547 CORBA::COMPLETED_NO);
2548
2549 DynamicAny::NameDynAnyPairSeq* nvps = new DynamicAny::NameDynAnyPairSeq();
2550
2551 nvps->length(pd_n_components);
2552
2553 createComponent(0);
2554 // All components are now in the buffer
2555
2556 for( unsigned i = 0; i < pd_n_components; i++ ) {
2557 (*nvps)[i].id = CORBA::string_dup(actualTc()->NP_member_name(i));
2558 pd_components[i]->_NP_incrRefCount();
2559 (*nvps)[i].value = pd_components[i];
2560 }
2561 return nvps;
2562 }
2563
2564 void
set_members_as_dyn_any(const DynamicAny::NameDynAnyPairSeq & nvps)2565 DynStructImpl::set_members_as_dyn_any(const DynamicAny::NameDynAnyPairSeq& nvps)
2566 {
2567 CHECK_NOT_DESTROYED;
2568
2569 if( nvps.length() != pd_n_components )
2570 throw DynamicAny::DynAny::InvalidValue();
2571
2572 CORBA::TypeCode_var tc;
2573 unsigned i;
2574
2575 for (i = 0; i < pd_n_components; i++) {
2576
2577 if (((const char*)(nvps[i].id))[0] != '\0' &&
2578 strcmp((const char*)(nvps[i].id), actualTc()->NP_member_name(i))) {
2579
2580 throw DynamicAny::DynAny::TypeMismatch();
2581 }
2582
2583 tc = nvps[i].value->type();
2584
2585 if (!tc->equivalent(nthComponentTC(i))) {
2586 throw DynamicAny::DynAny::TypeMismatch();
2587 }
2588 }
2589
2590 pd_n_in_buf = 0;
2591 pd_first_in_comp = 0;
2592
2593 for (i = 0; i < pd_n_components; i++) {
2594
2595 DynAnyImplBase* daib = ToDynAnyImplBase(nvps[i].value);
2596 if (daib->is_root()) {
2597 // Take ownership
2598 daib->_NP_incrRefCount();
2599 }
2600 else {
2601 DynamicAny::DynAny_ptr newda = daib->copy();
2602 daib = ToDynAnyImplBase(newda);
2603 }
2604 daib->attach();
2605
2606 if (pd_components[i]) {
2607 pd_components[i]->detach();
2608 pd_components[i]->_NP_decrRefCount();
2609 }
2610 pd_components[i] = daib;
2611 }
2612 pd_curr_index = (pd_n_components == 0) ? -1 : 0;
2613 }
2614
2615
2616
2617
2618 ///////////////////////////////
2619 // exposed private interface //
2620 ///////////////////////////////
2621
2622 int
NP_nodetype() const2623 DynStructImpl::NP_nodetype() const
2624 {
2625 return dt_struct;
2626 }
2627
2628
2629 //////////////
2630 // internal //
2631 //////////////
2632
2633 TypeCode_base*
nthComponentTC(unsigned n)2634 DynStructImpl::nthComponentTC(unsigned n)
2635 {
2636 if( n >= pd_n_components )
2637 throw omniORB::fatalException(__FILE__,__LINE__,
2638 "DynStructImpl::nthComponentTC() - n out of bounds");
2639
2640 return actualTc()->NP_member_type(n);
2641 }
2642
2643
2644 DynAnyConstrBase::SeqLocation
prepareSequenceWrite(CORBA::TCKind kind,CORBA::ULong len)2645 DynStructImpl::prepareSequenceWrite(CORBA::TCKind kind, CORBA::ULong len)
2646 {
2647 // Note that we ignore then length here. When the insert function
2648 // tries to call insert on the sub-component, that call will check
2649 // the length.
2650
2651 if (pd_curr_index < 0)
2652 throw DynamicAny::DynAny::InvalidValue();
2653
2654 const TypeCode_base* ctc;
2655 ctc = TypeCode_base::NP_expand(nthComponentTC(pd_curr_index));
2656 CORBA::TCKind k = ctc->NP_kind();
2657
2658 if ((k == CORBA::tk_sequence || k == CORBA::tk_array) &&
2659 TypeCode_base::NP_expand(ctc->NP_content_type())->NP_kind() == kind) {
2660 return SEQ_COMPONENT;
2661 }
2662 throw DynamicAny::DynAny::TypeMismatch();
2663 #ifdef NEED_DUMMY_RETURN
2664 return SEQ_COMPONENT;
2665 #endif
2666 }
2667
2668 DynAnyConstrBase::SeqLocation
prepareSequenceRead(CORBA::TCKind kind)2669 DynStructImpl::prepareSequenceRead(CORBA::TCKind kind)
2670 {
2671 if (pd_curr_index < 0)
2672 throw DynamicAny::DynAny::InvalidValue();
2673
2674 const TypeCode_base* ctc;
2675 ctc = TypeCode_base::NP_expand(nthComponentTC(pd_curr_index));
2676 CORBA::TCKind k = ctc->NP_kind();
2677
2678 if ((k == CORBA::tk_sequence || k == CORBA::tk_array) &&
2679 TypeCode_base::NP_expand(ctc->NP_content_type())->NP_kind() == kind) {
2680 return SEQ_COMPONENT;
2681 }
2682 throw DynamicAny::DynAny::TypeMismatch();
2683 #ifdef NEED_DUMMY_RETURN
2684 return SEQ_COMPONENT;
2685 #endif
2686 }
2687
2688
2689 void
_NP_incrRefCount()2690 DynStructImpl::_NP_incrRefCount()
2691 {
2692 DynAnyImplBase::_NP_incrRefCount();
2693 }
2694
2695 void
_NP_decrRefCount()2696 DynStructImpl::_NP_decrRefCount()
2697 {
2698 DynAnyImplBase::_NP_decrRefCount();
2699 }
2700
2701 void*
_ptrToObjRef(const char * repoId)2702 DynStructImpl::_ptrToObjRef(const char* repoId)
2703 {
2704 if( omni::ptrStrMatch(repoId, DynAnyConstrBase::_PD_repoId) )
2705 return (DynAnyConstrBase*) this;
2706
2707 if( omni::ptrStrMatch(repoId, DynAnyImplBase::_PD_repoId) )
2708 return (DynAnyImplBase*) this;
2709
2710 if( omni::ptrStrMatch(repoId, DynAnyImpl::_PD_repoId) )
2711 return (DynAnyImpl*) this;
2712
2713 if( omni::ptrStrMatch(repoId, DynamicAny::DynStruct::_PD_repoId) )
2714 return (DynamicAny::DynStruct_ptr) this;
2715
2716 if( omni::ptrStrMatch(repoId, DynamicAny::DynAny::_PD_repoId) )
2717 return (DynamicAny::DynAny_ptr) this;
2718
2719 if( omni::ptrStrMatch(repoId, CORBA::Object::_PD_repoId) )
2720 return (CORBA::Object_ptr) this;
2721
2722 return 0;
2723 }
2724
2725
2726
2727 //////////////////////////////////////////////////////////////////////
2728 /////////////////////////// DynUnionDisc /////////////////////////////
2729 //////////////////////////////////////////////////////////////////////
2730
~DynUnionDisc()2731 DynUnionDisc::~DynUnionDisc()
2732 {
2733 }
2734
2735
2736 void
assign(DynamicAny::DynAny_ptr da)2737 DynUnionDisc::assign(DynamicAny::DynAny_ptr da)
2738 {
2739 DynAnyImpl::assign(da);
2740 if( pd_union ) pd_union->discriminatorHasChanged();
2741 }
2742
2743 void
insert_boolean(CORBA::Boolean value)2744 DynUnionDisc::insert_boolean(CORBA::Boolean value)
2745 {
2746 CHECK_NOT_DESTROYED;
2747 doWrite(CORBA::tk_boolean).marshalBoolean(value);
2748 if( pd_union ) pd_union->discriminatorHasChanged();
2749 }
2750
2751
2752 void
insert_octet(CORBA::Octet value)2753 DynUnionDisc::insert_octet(CORBA::Octet value)
2754 {
2755 CHECK_NOT_DESTROYED;
2756 // Not a legal discriminator type.
2757 throw DynamicAny::DynAny::InvalidValue();
2758 }
2759
2760
2761 void
insert_char(CORBA::Char value)2762 DynUnionDisc::insert_char(CORBA::Char value)
2763 {
2764 CHECK_NOT_DESTROYED;
2765 doWrite(CORBA::tk_char).marshalChar(value);
2766 if( pd_union ) pd_union->discriminatorHasChanged();
2767 }
2768
2769
2770 void
insert_short(CORBA::Short value)2771 DynUnionDisc::insert_short(CORBA::Short value)
2772 {
2773 CHECK_NOT_DESTROYED;
2774 value >>= doWrite(CORBA::tk_short);
2775 if( pd_union ) pd_union->discriminatorHasChanged();
2776 }
2777
2778
2779 void
insert_ushort(CORBA::UShort value)2780 DynUnionDisc::insert_ushort(CORBA::UShort value)
2781 {
2782 CHECK_NOT_DESTROYED;
2783 value >>= doWrite(CORBA::tk_ushort);
2784 if( pd_union ) pd_union->discriminatorHasChanged();
2785 }
2786
2787
2788 void
insert_long(CORBA::Long value)2789 DynUnionDisc::insert_long(CORBA::Long value)
2790 {
2791 CHECK_NOT_DESTROYED;
2792 value >>= doWrite(CORBA::tk_long);
2793 if( pd_union ) pd_union->discriminatorHasChanged();
2794 }
2795
2796
2797 void
insert_ulong(CORBA::ULong value)2798 DynUnionDisc::insert_ulong(CORBA::ULong value)
2799 {
2800 CHECK_NOT_DESTROYED;
2801 value >>= doWrite(CORBA::tk_ulong);
2802 if( pd_union ) pd_union->discriminatorHasChanged();
2803 }
2804
2805 #ifndef NO_FLOAT
2806 void
insert_float(CORBA::Float value)2807 DynUnionDisc::insert_float(CORBA::Float value)
2808 {
2809 CHECK_NOT_DESTROYED;
2810 // Not a legal discriminator type.
2811 throw DynamicAny::DynAny::InvalidValue();
2812 }
2813
2814
2815 void
insert_double(CORBA::Double value)2816 DynUnionDisc::insert_double(CORBA::Double value)
2817 {
2818 CHECK_NOT_DESTROYED;
2819 // Not a legal discriminator type.
2820 throw DynamicAny::DynAny::InvalidValue();
2821 }
2822
2823 #endif
2824
2825 void
insert_string(const char * value)2826 DynUnionDisc::insert_string(const char* value)
2827 {
2828 CHECK_NOT_DESTROYED;
2829 // Not a legal discriminator type.
2830 throw DynamicAny::DynAny::InvalidValue();
2831 }
2832
2833
2834 void
insert_reference(CORBA::Object_ptr value)2835 DynUnionDisc::insert_reference(CORBA::Object_ptr value)
2836 {
2837 CHECK_NOT_DESTROYED;
2838 // Not a legal discriminator type.
2839 throw DynamicAny::DynAny::InvalidValue();
2840 }
2841
2842
2843 void
insert_typecode(CORBA::TypeCode_ptr value)2844 DynUnionDisc::insert_typecode(CORBA::TypeCode_ptr value)
2845 {
2846 CHECK_NOT_DESTROYED;
2847 // Not a legal discriminator type.
2848 throw DynamicAny::DynAny::InvalidValue();
2849 }
2850
2851
2852 #ifdef HAS_LongLong
2853 void
insert_longlong(CORBA::LongLong value)2854 DynUnionDisc::insert_longlong(CORBA::LongLong value)
2855 {
2856 CHECK_NOT_DESTROYED;
2857 value >>= doWrite(CORBA::tk_longlong);
2858 if( pd_union ) pd_union->discriminatorHasChanged();
2859 }
2860
2861
2862 void
insert_ulonglong(CORBA::ULongLong value)2863 DynUnionDisc::insert_ulonglong(CORBA::ULongLong value)
2864 {
2865 CHECK_NOT_DESTROYED;
2866 value >>= doWrite(CORBA::tk_ulonglong);
2867 if( pd_union ) pd_union->discriminatorHasChanged();
2868 }
2869 #endif
2870
2871 #ifdef HAS_LongDouble
2872 void
insert_longdouble(CORBA::LongDouble value)2873 DynUnionDisc::insert_longdouble(CORBA::LongDouble value)
2874 {
2875 CHECK_NOT_DESTROYED;
2876 // Not a legal discriminator type.
2877 throw DynamicAny::DynAny::InvalidValue();
2878 }
2879 #endif
2880
2881 void
insert_wchar(CORBA::WChar value)2882 DynUnionDisc::insert_wchar(CORBA::WChar value)
2883 {
2884 CHECK_NOT_DESTROYED;
2885 // Not a legal discriminator type.
2886 throw DynamicAny::DynAny::InvalidValue();
2887 }
2888
2889 void
insert_wstring(const CORBA::WChar * value)2890 DynUnionDisc::insert_wstring(const CORBA::WChar* value)
2891 {
2892 CHECK_NOT_DESTROYED;
2893 // Not a legal discriminator type.
2894 throw DynamicAny::DynAny::InvalidValue();
2895 }
2896
2897 void
insert_any(const CORBA::Any & value)2898 DynUnionDisc::insert_any(const CORBA::Any& value)
2899 {
2900 CHECK_NOT_DESTROYED;
2901 // Not a legal discriminator type.
2902 throw DynamicAny::DynAny::InvalidValue();
2903 }
2904
2905 void
insert_dyn_any(DynamicAny::DynAny_ptr value)2906 DynUnionDisc::insert_dyn_any(DynamicAny::DynAny_ptr value)
2907 {
2908 CHECK_NOT_DESTROYED;
2909 // Not a legal discriminator type.
2910 throw DynamicAny::DynAny::InvalidValue();
2911 }
2912
2913 void
insert_val(CORBA::ValueBase * value)2914 DynUnionDisc::insert_val(CORBA::ValueBase* value)
2915 {
2916 CHECK_NOT_DESTROYED;
2917 // Not a legal discriminator type.
2918 throw DynamicAny::DynAny::InvalidValue();
2919 }
2920
2921 void
insert_abstract(CORBA::AbstractBase_ptr value)2922 DynUnionDisc::insert_abstract(CORBA::AbstractBase_ptr value)
2923 {
2924 CHECK_NOT_DESTROYED;
2925 // Not a legal discriminator type.
2926 throw DynamicAny::DynAny::InvalidValue();
2927 }
2928
2929
2930 ///////////////////////////////
2931 // exposed private interface //
2932 ///////////////////////////////
2933
2934 int
NP_nodetype() const2935 DynUnionDisc::NP_nodetype() const
2936 {
2937 return dt_disc;
2938 }
2939
2940 void
set_to_initial_value()2941 DynUnionDisc::set_to_initial_value()
2942 {
2943 // Choose a value corresponding to the first case
2944 OMNIORB_ASSERT(pd_union);
2945 set_value(pd_union->actualTc()->NP_member_label_val(0));
2946 }
2947
2948
2949 void
set_value(TypeCode_union::Discriminator v)2950 DynUnionDisc::set_value(TypeCode_union::Discriminator v)
2951 {
2952 switch( tckind() ) {
2953 case CORBA::tk_char:
2954 insert_char((CORBA::Char)v);
2955 break;
2956 case CORBA::tk_boolean:
2957 insert_boolean((CORBA::Boolean)v);
2958 break;
2959 case CORBA::tk_short:
2960 insert_short((CORBA::Short)v);
2961 break;
2962 case CORBA::tk_ushort:
2963 insert_ushort((CORBA::UShort)v);
2964 break;
2965 case CORBA::tk_long:
2966 insert_long((CORBA::Long)v);
2967 break;
2968 case CORBA::tk_ulong:
2969 insert_ulong((CORBA::ULong)v);
2970 break;
2971 #ifdef HAS_LongLong
2972 case CORBA::tk_longlong:
2973 insert_longlong((CORBA::LongLong)v);
2974 break;
2975 case CORBA::tk_ulonglong:
2976 insert_ulonglong((CORBA::ULongLong)v);
2977 break;
2978 #endif
2979 default:
2980 throw omniORB::fatalException(__FILE__,__LINE__,
2981 "DynUnionDisc::set_value() - illegal disciminator type");
2982 }
2983 }
2984
2985 //////////////////////////////////////////////////////////////////////
2986 ///////////////////////// DynUnionEnumDisc ///////////////////////////
2987 //////////////////////////////////////////////////////////////////////
2988
DynUnionEnumDisc(TypeCode_base * tc,DynUnionImpl * un)2989 DynUnionEnumDisc::DynUnionEnumDisc(TypeCode_base* tc, DynUnionImpl* un)
2990 : DynUnionDisc(tc, dt_enumdisc, un)
2991 {
2992 }
2993
2994
~DynUnionEnumDisc()2995 DynUnionEnumDisc::~DynUnionEnumDisc() {}
2996
2997 //////////////////////
2998 // public interface //
2999 //////////////////////
3000
3001 DynamicAny::DynAny_ptr
copy()3002 DynUnionEnumDisc::copy()
3003 {
3004 CHECK_NOT_DESTROYED;
3005
3006 DynEnumImpl* da = new DynEnumImpl(TypeCode_collector::duplicateRef(tc()),
3007 DYNANY_ROOT);
3008 try {
3009 da->assign(this);
3010 }
3011 catch(DynamicAny::DynAny::TypeMismatch&) {
3012 OMNIORB_ASSERT(0);
3013 // This should never happen since the types always match -- they
3014 // are the same TypeCode.
3015 }
3016 catch(...) {
3017 da->_NP_decrRefCount();
3018 throw;
3019 }
3020 return da;
3021 }
3022
3023
3024 char*
get_as_string()3025 DynUnionEnumDisc::get_as_string()
3026 {
3027 CHECK_NOT_DESTROYED;
3028
3029 CORBA::ULong val;
3030 {
3031 if( !isValid() )
3032 OMNIORB_THROW(BAD_PARAM, BAD_PARAM_InvalidDynAny, CORBA::COMPLETED_NO);
3033
3034 pd_buf.rewindInputPtr();
3035 val <<= pd_buf;
3036 }
3037
3038 if( val >= actualTc()->NP_member_count() )
3039 OMNIORB_THROW(BAD_PARAM, BAD_PARAM_InvalidDynAny, CORBA::COMPLETED_NO);
3040
3041 return CORBA::string_dup(actualTc()->NP_member_name(val));
3042 }
3043
3044 void
set_as_string(const char * value)3045 DynUnionEnumDisc::set_as_string(const char* value)
3046 {
3047 CHECK_NOT_DESTROYED;
3048
3049 if( !value ) OMNIORB_THROW(BAD_PARAM,
3050 BAD_PARAM_NullStringUnexpected,
3051 CORBA::COMPLETED_NO);
3052
3053 CORBA::Long index = actualTc()->NP_member_index(value);
3054 if( index < 0 ) throw DynamicAny::DynAny::InvalidValue();
3055
3056 pd_buf.rewindPtrs();
3057 CORBA::ULong(index) >>= pd_buf;
3058 setValid();
3059 if( pd_union ) pd_union->discriminatorHasChanged();
3060 }
3061
3062
3063 CORBA::ULong
get_as_ulong()3064 DynUnionEnumDisc::get_as_ulong()
3065 {
3066 CHECK_NOT_DESTROYED;
3067
3068 CORBA::ULong val;
3069 {
3070 if( !isValid() )
3071 OMNIORB_THROW(BAD_PARAM, BAD_PARAM_InvalidDynAny, CORBA::COMPLETED_NO);
3072 pd_buf.rewindInputPtr();
3073 val <<= pd_buf;
3074 }
3075
3076 if( val >= actualTc()->NP_member_count() )
3077 OMNIORB_THROW(BAD_PARAM, BAD_PARAM_InvalidDynAny, CORBA::COMPLETED_NO);
3078
3079 return val;
3080 }
3081
3082
3083 void
set_as_ulong(CORBA::ULong value)3084 DynUnionEnumDisc::set_as_ulong(CORBA::ULong value)
3085 {
3086 CHECK_NOT_DESTROYED;
3087
3088 if( value >= actualTc()->NP_member_count() )
3089 OMNIORB_THROW(BAD_PARAM, BAD_PARAM_IndexOutOfRange, CORBA::COMPLETED_NO);
3090
3091 pd_buf.rewindPtrs();
3092 value >>= pd_buf;
3093 setValid();
3094 if( pd_union ) pd_union->discriminatorHasChanged();
3095 }
3096
3097 ///////////////////////////////
3098 // exposed private interface //
3099 ///////////////////////////////
3100
3101 void
set_to_initial_value()3102 DynUnionEnumDisc::set_to_initial_value()
3103 {
3104 // Choose a value corresponding to the first case
3105 OMNIORB_ASSERT(pd_union);
3106 set_value(pd_union->actualTc()->NP_member_label_val(0));
3107 }
3108
3109 int
NP_nodetype() const3110 DynUnionEnumDisc::NP_nodetype() const
3111 {
3112 return dt_enumdisc;
3113 }
3114
3115
3116 void
set_value(TypeCode_union::Discriminator v)3117 DynUnionEnumDisc::set_value(TypeCode_union::Discriminator v)
3118 {
3119 pd_buf.rewindPtrs();
3120 CORBA::ULong(v) >>= pd_buf;
3121 setValid();
3122 if( pd_union ) pd_union->discriminatorHasChanged();
3123 }
3124
3125 void
_NP_incrRefCount()3126 DynUnionEnumDisc::_NP_incrRefCount()
3127 {
3128 DynAnyImplBase::_NP_incrRefCount();
3129 }
3130
3131 void
_NP_decrRefCount()3132 DynUnionEnumDisc::_NP_decrRefCount()
3133 {
3134 DynAnyImplBase::_NP_decrRefCount();
3135 }
3136
3137 void*
_ptrToObjRef(const char * repoId)3138 DynUnionEnumDisc::_ptrToObjRef(const char* repoId)
3139 {
3140 if( omni::ptrStrMatch(repoId, DynAnyImplBase::_PD_repoId) )
3141 return (DynAnyImplBase*) this;
3142
3143 if( omni::ptrStrMatch(repoId, DynAnyImpl::_PD_repoId) )
3144 return (DynAnyImpl*) this;
3145
3146 if( omni::ptrStrMatch(repoId, DynamicAny::DynEnum::_PD_repoId) )
3147 return (DynamicAny::DynEnum_ptr) this;
3148
3149 if( omni::ptrStrMatch(repoId, DynamicAny::DynAny::_PD_repoId) )
3150 return (DynamicAny::DynAny_ptr) this;
3151
3152 if( omni::ptrStrMatch(repoId, CORBA::Object::_PD_repoId) )
3153 return (CORBA::Object_ptr) this;
3154
3155 return 0;
3156 }
3157
3158 //////////////////////////////////////////////////////////////////////
3159 //////////////////////////// DynUnionImpl ////////////////////////////
3160 //////////////////////////////////////////////////////////////////////
3161
DynUnionImpl(TypeCode_base * tc,CORBA::Boolean is_root)3162 DynUnionImpl::DynUnionImpl(TypeCode_base* tc, CORBA::Boolean is_root)
3163 : DynAnyImplBase(tc, dt_union, is_root)
3164 {
3165 CORBA::TypeCode_ptr tcdup =
3166 CORBA::TypeCode::_duplicate(actualTc()->NP_discriminator_type());
3167 pd_disc = internal_create_dyn_any_discriminator(ToTcBase(tcdup), this);
3168 pd_disc_type = ToTcBase(tcdup);
3169 pd_disc_kind = pd_disc_type->kind();
3170 pd_disc_index = -1;
3171
3172 pd_member = 0;
3173 pd_member_kind = CORBA::tk_null;
3174
3175 pd_curr_index = 0;
3176 }
3177
3178
~DynUnionImpl()3179 DynUnionImpl::~DynUnionImpl()
3180 {
3181 pd_disc->_NP_decrRefCount();
3182 if( pd_member ) pd_member->_NP_decrRefCount();
3183 }
3184
3185 //////////////////////
3186 // public interface //
3187 //////////////////////
3188
3189 void
assign(DynamicAny::DynAny_ptr da)3190 DynUnionImpl::assign(DynamicAny::DynAny_ptr da)
3191 {
3192 CHECK_NOT_DESTROYED;
3193
3194 if ( !DynamicAny::DynAny::PR_is_valid(da) )
3195 OMNIORB_THROW(BAD_PARAM, BAD_PARAM_InvalidDynAny, CORBA::COMPLETED_NO);
3196
3197 if( CORBA::is_nil(da) )
3198 throw DynamicAny::DynAny::InvalidValue();
3199
3200 DynAnyImplBase* daib = ToDynAnyImplBase(da);
3201
3202 if( !tc()->equivalent(daib->tc()) )
3203 throw DynamicAny::DynAny::TypeMismatch();
3204
3205 // We do the copy via an intermediate buffer.
3206
3207 cdrAnyMemoryStream buf;
3208
3209 if( !daib->copy_to(buf) )
3210 throw DynamicAny::DynAny::InvalidValue();
3211
3212 if( !copy_from(buf) )
3213 throw omniORB::fatalException(__FILE__,__LINE__,
3214 "DynUnionImpl::assign() - copy_from failed unexpectedly");
3215 }
3216
3217
3218 DynamicAny::DynAny_ptr
copy()3219 DynUnionImpl::copy()
3220 {
3221 CHECK_NOT_DESTROYED;
3222
3223 DynUnionImpl* da = new DynUnionImpl(TypeCode_collector::duplicateRef(tc()),
3224 DYNANY_ROOT);
3225 try {
3226 da->assign(this);
3227 }
3228 catch(DynamicAny::DynAny::TypeMismatch&) {
3229 OMNIORB_ASSERT(0);
3230 // This should never happen since the types always match -- they
3231 // are the same TypeCode.
3232 }
3233 catch(...) {
3234 da->_NP_decrRefCount();
3235 throw;
3236 }
3237 return da;
3238 }
3239
3240
3241 CORBA::Boolean
equal(DynamicAny::DynAny_ptr da)3242 DynUnionImpl::equal(DynamicAny::DynAny_ptr da)
3243 {
3244 CHECK_NOT_DESTROYED;
3245
3246 if ( !DynamicAny::DynAny::PR_is_valid(da) )
3247 OMNIORB_THROW(BAD_PARAM, BAD_PARAM_InvalidDynAny, CORBA::COMPLETED_NO);
3248
3249 if( CORBA::is_nil(da) )
3250 return 0;
3251
3252 DynAnyImplBase* daib = ToDynAnyImplBase(da);
3253 if( !tc()->equivalent(daib->tc()) )
3254 return 0;
3255
3256 DynUnionImpl* daui = ToDynUnionImpl(da);
3257
3258 if (!pd_disc->equal(daui->pd_disc)) return 0;
3259
3260 if (pd_member) return pd_member->equal(daui->pd_member);
3261 return 1;
3262 }
3263
3264 void
insert_boolean(CORBA::Boolean value)3265 DynUnionImpl::insert_boolean(CORBA::Boolean value)
3266 {
3267 CHECK_NOT_DESTROYED;
3268 writeCurrent(CORBA::tk_boolean).marshalBoolean(value);
3269 discriminatorHasChanged();
3270 }
3271
3272
3273 void
insert_octet(CORBA::Octet value)3274 DynUnionImpl::insert_octet(CORBA::Octet value)
3275 {
3276 CHECK_NOT_DESTROYED;
3277 writeCurrent(CORBA::tk_octet).marshalOctet(value);
3278 discriminatorHasChanged();
3279 }
3280
3281
3282 void
insert_char(CORBA::Char value)3283 DynUnionImpl::insert_char(CORBA::Char value)
3284 {
3285 CHECK_NOT_DESTROYED;
3286 writeCurrent(CORBA::tk_char).marshalChar(value);
3287 discriminatorHasChanged();
3288 }
3289
3290
3291 void
insert_short(CORBA::Short value)3292 DynUnionImpl::insert_short(CORBA::Short value)
3293 {
3294 CHECK_NOT_DESTROYED;
3295 value >>= writeCurrent(CORBA::tk_short);
3296 discriminatorHasChanged();
3297 }
3298
3299
3300 void
insert_ushort(CORBA::UShort value)3301 DynUnionImpl::insert_ushort(CORBA::UShort value)
3302 {
3303 CHECK_NOT_DESTROYED;
3304 value >>= writeCurrent(CORBA::tk_ushort);
3305 discriminatorHasChanged();
3306 }
3307
3308
3309 void
insert_long(CORBA::Long value)3310 DynUnionImpl::insert_long(CORBA::Long value)
3311 {
3312 CHECK_NOT_DESTROYED;
3313 value >>= writeCurrent(CORBA::tk_long);
3314 discriminatorHasChanged();
3315 }
3316
3317
3318 void
insert_ulong(CORBA::ULong value)3319 DynUnionImpl::insert_ulong(CORBA::ULong value)
3320 {
3321 CHECK_NOT_DESTROYED;
3322 value >>= writeCurrent(CORBA::tk_ulong);
3323 discriminatorHasChanged();
3324 }
3325
3326 #ifndef NO_FLOAT
3327 void
insert_float(CORBA::Float value)3328 DynUnionImpl::insert_float(CORBA::Float value)
3329 {
3330 CHECK_NOT_DESTROYED;
3331 value >>= writeCurrent(CORBA::tk_float);
3332 discriminatorHasChanged();
3333 }
3334
3335
3336 void
insert_double(CORBA::Double value)3337 DynUnionImpl::insert_double(CORBA::Double value)
3338 {
3339 CHECK_NOT_DESTROYED;
3340 value >>= writeCurrent(CORBA::tk_double);
3341 discriminatorHasChanged();
3342 }
3343
3344 #endif
3345
3346 void
insert_string(const char * value)3347 DynUnionImpl::insert_string(const char* value)
3348 {
3349 CHECK_NOT_DESTROYED;
3350 if( !value || pd_curr_index != 1 )
3351 throw DynamicAny::DynAny::InvalidValue();
3352
3353 if( pd_member_kind != CORBA::tk_string )
3354 throw DynamicAny::DynAny::TypeMismatch();
3355
3356 CORBA::ULong maxlen = pd_member->actualTc()->NP_length();
3357
3358 cdrAnyMemoryStream& buf = writeCurrent(CORBA::tk_string);
3359 try {
3360 buf.marshalString(value,maxlen);
3361 }
3362 catch (CORBA::MARSHAL& ex) {
3363 if (ex.minor() == MARSHAL_StringIsTooLong)
3364 throw DynamicAny::DynAny::InvalidValue();
3365 else
3366 throw;
3367 }
3368 discriminatorHasChanged();
3369 }
3370
3371
3372 void
insert_reference(CORBA::Object_ptr value)3373 DynUnionImpl::insert_reference(CORBA::Object_ptr value)
3374 {
3375 CHECK_NOT_DESTROYED;
3376
3377 if ( !CORBA::Object::_PR_is_valid(value) )
3378 OMNIORB_THROW(BAD_PARAM, BAD_PARAM_InvalidObjectRef, CORBA::COMPLETED_NO);
3379
3380 CORBA::Object::_marshalObjRef(value, writeCurrent(CORBA::tk_objref));
3381 discriminatorHasChanged();
3382 }
3383
3384
3385 void
insert_typecode(CORBA::TypeCode_ptr value)3386 DynUnionImpl::insert_typecode(CORBA::TypeCode_ptr value)
3387 {
3388 CHECK_NOT_DESTROYED;
3389
3390 if ( !CORBA::TypeCode::PR_is_valid(value) )
3391 OMNIORB_THROW(BAD_PARAM, BAD_PARAM_InvalidTypeCode, CORBA::COMPLETED_NO);
3392
3393 if( CORBA::is_nil(value) ) throw DynamicAny::DynAny::InvalidValue();
3394
3395 CORBA::TypeCode::marshalTypeCode(value, writeCurrent(CORBA::tk_TypeCode));
3396 discriminatorHasChanged();
3397 }
3398
3399
3400 #ifdef HAS_LongLong
3401 void
insert_longlong(CORBA::LongLong value)3402 DynUnionImpl::insert_longlong(CORBA::LongLong value)
3403 {
3404 CHECK_NOT_DESTROYED;
3405 value >>= writeCurrent(CORBA::tk_longlong);
3406 discriminatorHasChanged();
3407 }
3408
3409
3410 void
insert_ulonglong(CORBA::ULongLong value)3411 DynUnionImpl::insert_ulonglong(CORBA::ULongLong value)
3412 {
3413 CHECK_NOT_DESTROYED;
3414 value >>= writeCurrent(CORBA::tk_ulonglong);
3415 discriminatorHasChanged();
3416 }
3417 #endif
3418
3419 #ifdef HAS_LongDouble
3420 void
insert_longdouble(CORBA::LongDouble value)3421 DynUnionImpl::insert_longdouble(CORBA::LongDouble value)
3422 {
3423 CHECK_NOT_DESTROYED;
3424 value >>= writeCurrent(CORBA::tk_longdouble);
3425 discriminatorHasChanged();
3426 }
3427 #endif
3428
3429 void
insert_wchar(CORBA::WChar value)3430 DynUnionImpl::insert_wchar(CORBA::WChar value)
3431 {
3432 CHECK_NOT_DESTROYED;
3433 writeCurrent(CORBA::tk_wchar).marshalWChar(value);
3434 discriminatorHasChanged();
3435 }
3436
3437 void
insert_wstring(const CORBA::WChar * value)3438 DynUnionImpl::insert_wstring(const CORBA::WChar* value)
3439 {
3440 CHECK_NOT_DESTROYED;
3441
3442 if( !value || pd_curr_index != 1 )
3443 throw DynamicAny::DynAny::InvalidValue();
3444
3445 if( pd_member_kind != CORBA::tk_wstring )
3446 throw DynamicAny::DynAny::TypeMismatch();
3447
3448 CORBA::ULong maxlen = pd_member->actualTc()->NP_length();
3449
3450 cdrAnyMemoryStream& buf = writeCurrent(CORBA::tk_wstring);
3451 try {
3452 buf.marshalWString(value,maxlen);
3453 }
3454 catch (CORBA::MARSHAL& ex) {
3455 if (ex.minor() == MARSHAL_WStringIsTooLong)
3456 throw DynamicAny::DynAny::InvalidValue();
3457 else
3458 throw;
3459 }
3460 discriminatorHasChanged();
3461 }
3462
3463 void
insert_any(const CORBA::Any & value)3464 DynUnionImpl::insert_any(const CORBA::Any& value)
3465 {
3466 value >>= writeCurrent(CORBA::tk_any);
3467 discriminatorHasChanged();
3468 }
3469
3470 void
insert_dyn_any(DynamicAny::DynAny_ptr value)3471 DynUnionImpl::insert_dyn_any(DynamicAny::DynAny_ptr value)
3472 {
3473 CHECK_NOT_DESTROYED;
3474 CORBA::Any_var a(to_any());
3475 a.in() >>= writeCurrent(CORBA::tk_any);
3476 }
3477
3478 void
insert_val(CORBA::ValueBase * value)3479 DynUnionImpl::insert_val(CORBA::ValueBase* value)
3480 {
3481 CHECK_NOT_DESTROYED;
3482
3483 CORBA::Any a;
3484 a <<= value;
3485
3486 ToDynAnyImpl(pd_member)->setValid();
3487 pd_member->from_any(a);
3488 }
3489
3490 void
insert_abstract(CORBA::AbstractBase_ptr value)3491 DynUnionImpl::insert_abstract(CORBA::AbstractBase_ptr value)
3492 {
3493 CHECK_NOT_DESTROYED;
3494
3495 cdrAnyMemoryStream& stream = writeCurrent(CORBA::tk_abstract_interface);
3496
3497 CORBA::Object_ptr o = value->_NP_to_object();
3498 if (!CORBA::is_nil(o)) {
3499 stream.marshalBoolean(1);
3500 CORBA::Object::_marshalObjRef(0, stream);
3501 }
3502 else {
3503 CORBA::ValueBase* v = value->_NP_to_value();
3504 stream.marshalBoolean(0);
3505 CORBA::ValueBase::_NP_marshal(v, stream);
3506 }
3507 }
3508
3509 CORBA::Boolean
get_boolean()3510 DynUnionImpl::get_boolean()
3511 {
3512 CHECK_NOT_DESTROYED;
3513 return readCurrent(CORBA::tk_boolean).unmarshalBoolean();
3514 }
3515
3516
3517 CORBA::Octet
get_octet()3518 DynUnionImpl::get_octet()
3519 {
3520 CHECK_NOT_DESTROYED;
3521 return readCurrent(CORBA::tk_octet).unmarshalOctet();
3522 }
3523
3524
3525 CORBA::Char
get_char()3526 DynUnionImpl::get_char()
3527 {
3528 CHECK_NOT_DESTROYED;
3529 return readCurrent(CORBA::tk_char).unmarshalChar();
3530 }
3531
3532
3533 CORBA::Short
get_short()3534 DynUnionImpl::get_short()
3535 {
3536 CHECK_NOT_DESTROYED;
3537 CORBA::Short value;
3538 value <<= readCurrent(CORBA::tk_short);
3539 return value;
3540 }
3541
3542
3543 CORBA::UShort
get_ushort()3544 DynUnionImpl::get_ushort()
3545 {
3546 CHECK_NOT_DESTROYED;
3547 CORBA::UShort value;
3548 value <<= readCurrent(CORBA::tk_ushort);
3549 return value;
3550 }
3551
3552
3553 CORBA::Long
get_long()3554 DynUnionImpl::get_long()
3555 {
3556 CHECK_NOT_DESTROYED;
3557 CORBA::Long value;
3558 value <<= readCurrent(CORBA::tk_long);
3559 return value;
3560 }
3561
3562
3563 CORBA::ULong
get_ulong()3564 DynUnionImpl::get_ulong()
3565 {
3566 CHECK_NOT_DESTROYED;
3567 CORBA::ULong value;
3568 value <<= readCurrent(CORBA::tk_ulong);
3569 return value;
3570 }
3571
3572 #ifndef NO_FLOAT
3573 CORBA::Float
get_float()3574 DynUnionImpl::get_float()
3575 {
3576 CHECK_NOT_DESTROYED;
3577 CORBA::Float value;
3578 value <<= readCurrent(CORBA::tk_float);
3579 return value;
3580 }
3581
3582
3583 CORBA::Double
get_double()3584 DynUnionImpl::get_double()
3585 {
3586 CHECK_NOT_DESTROYED;
3587 CORBA::Double value;
3588 value <<= readCurrent(CORBA::tk_double);
3589 return value;
3590 }
3591
3592 #endif
3593
3594 char*
get_string()3595 DynUnionImpl::get_string()
3596 {
3597 CHECK_NOT_DESTROYED;
3598 cdrAnyMemoryStream& buf = readCurrent(CORBA::tk_string);
3599
3600 CORBA::ULong maxlen = pd_member->actualTc()->NP_length();
3601 try {
3602 char* value = buf.unmarshalString(maxlen);
3603 return value;
3604 }
3605 catch (CORBA::MARSHAL& ex) {
3606 if (ex.minor() == MARSHAL_StringIsTooLong)
3607 throw DynamicAny::DynAny::InvalidValue();
3608 else
3609 throw;
3610 }
3611 return 0;
3612 }
3613
3614
3615 CORBA::Object_ptr
get_reference()3616 DynUnionImpl::get_reference()
3617 {
3618 CHECK_NOT_DESTROYED;
3619 return CORBA::Object::_unmarshalObjRef(readCurrent(CORBA::tk_objref));
3620 }
3621
3622
3623 CORBA::TypeCode_ptr
get_typecode()3624 DynUnionImpl::get_typecode()
3625 {
3626 CHECK_NOT_DESTROYED;
3627 return CORBA::TypeCode::unmarshalTypeCode(readCurrent(CORBA::tk_TypeCode));
3628 }
3629
3630
3631
3632 #ifdef HAS_LongLong
3633 CORBA::LongLong
get_longlong()3634 DynUnionImpl::get_longlong()
3635 {
3636 CHECK_NOT_DESTROYED;
3637 CORBA::LongLong value;
3638 value <<= readCurrent(CORBA::tk_longlong);
3639 return value;
3640 }
3641
3642
3643 CORBA::ULongLong
get_ulonglong()3644 DynUnionImpl::get_ulonglong()
3645 {
3646 CHECK_NOT_DESTROYED;
3647 CORBA::ULongLong value;
3648 value <<= readCurrent(CORBA::tk_ulonglong);
3649 return value;
3650 }
3651 #endif
3652
3653 #ifdef HAS_LongDouble
3654 CORBA::LongDouble
get_longdouble()3655 DynUnionImpl::get_longdouble()
3656 {
3657 CHECK_NOT_DESTROYED;
3658 CORBA::LongDouble value;
3659 value <<= readCurrent(CORBA::tk_longdouble);
3660 return value;
3661 }
3662 #endif
3663
3664 CORBA::WChar
get_wchar()3665 DynUnionImpl::get_wchar()
3666 {
3667 CHECK_NOT_DESTROYED;
3668 return readCurrent(CORBA::tk_wchar).unmarshalWChar();
3669 }
3670
3671 CORBA::WChar*
get_wstring()3672 DynUnionImpl::get_wstring()
3673 {
3674 CHECK_NOT_DESTROYED;
3675 cdrAnyMemoryStream& buf = readCurrent(CORBA::tk_wstring);
3676
3677 CORBA::ULong maxlen = pd_member->actualTc()->NP_length();
3678 CORBA::WChar* value = buf.unmarshalWString(maxlen);
3679 return value;
3680 }
3681
3682 CORBA::Any*
get_any()3683 DynUnionImpl::get_any()
3684 {
3685 CHECK_NOT_DESTROYED;
3686 CORBA::Any* value = new CORBA::Any();
3687 try {
3688 *value <<= readCurrent(CORBA::tk_any);
3689 }
3690 catch(...) {
3691 delete value;
3692 throw;
3693 }
3694 return value;
3695 }
3696
3697 DynamicAny::DynAny_ptr
get_dyn_any()3698 DynUnionImpl::get_dyn_any()
3699 {
3700 CHECK_NOT_DESTROYED;
3701 CORBA::Any value;
3702 value <<= readCurrent(CORBA::tk_any);
3703 return factory_create_dyn_any(value);
3704 }
3705
3706 CORBA::ValueBase*
get_val()3707 DynUnionImpl::get_val()
3708 {
3709 CORBA::TypeCode_ptr tc = actualTc();
3710
3711 CORBA::TCKind k = tc->kind();
3712 if (k != CORBA::tk_value && k != CORBA::tk_value_box)
3713 throw DynamicAny::DynAny::TypeMismatch();
3714
3715 CORBA::Any_var a = pd_member->to_any();
3716 CORBA::ValueBase* v;
3717 a >>= v;
3718 return v;
3719 }
3720
3721 CORBA::AbstractBase_ptr
get_abstract()3722 DynUnionImpl::get_abstract()
3723 {
3724 cdrAnyMemoryStream& stream = readCurrent(CORBA::tk_abstract_interface);
3725
3726 CORBA::AbstractBase_ptr a;
3727
3728 CORBA::Boolean b = stream.unmarshalBoolean();
3729 if (b) {
3730 CORBA::Object_ptr o = CORBA::Object::_unmarshalObjRef(stream);
3731 if (CORBA::is_nil(o))
3732 return CORBA::AbstractBase::_nil();
3733
3734 a = (CORBA::AbstractBase_ptr)o->
3735 _ptrToObjRef(CORBA::AbstractBase::_PD_repoId);
3736 }
3737 else {
3738 CORBA::ValueBase* v = CORBA::ValueBase::_NP_unmarshal(stream);
3739 a = (CORBA::AbstractBase_ptr)v->
3740 _ptrToValue(CORBA::AbstractBase::_PD_repoId);
3741 }
3742 return a;
3743 }
3744
3745
3746 #define UNION_SEQUENCE_OPS(lcname, ucname) \
3747 void \
3748 DynUnionImpl::insert_##lcname##_seq(CORBA:: ucname##Seq& value) \
3749 { \
3750 CHECK_NOT_DESTROYED; \
3751 if (pd_curr_index != 1 || !pd_member) \
3752 throw DynamicAny::DynAny::InvalidValue(); \
3753 \
3754 if (pd_member_kind != CORBA::tk_sequence && \
3755 pd_member_kind != CORBA::tk_array) \
3756 throw DynamicAny::DynAny::TypeMismatch(); \
3757 \
3758 pd_member->insert_##lcname##_seq(value); \
3759 }\
3760 \
3761 CORBA:: ucname##Seq* \
3762 DynUnionImpl::get_##lcname##_seq() \
3763 { \
3764 CHECK_NOT_DESTROYED; \
3765 if (pd_curr_index != 1 || !pd_member) \
3766 throw DynamicAny::DynAny::InvalidValue(); \
3767 \
3768 if (pd_member_kind != CORBA::tk_sequence && \
3769 pd_member_kind != CORBA::tk_array) \
3770 throw DynamicAny::DynAny::TypeMismatch(); \
3771 \
3772 return pd_member->get_##lcname##_seq(); \
3773 }
3774
UNION_SEQUENCE_OPS(boolean,Boolean)3775 UNION_SEQUENCE_OPS(boolean, Boolean)
3776 UNION_SEQUENCE_OPS(octet, Octet)
3777 UNION_SEQUENCE_OPS(char, Char)
3778 UNION_SEQUENCE_OPS(short, Short)
3779 UNION_SEQUENCE_OPS(ushort, UShort)
3780 UNION_SEQUENCE_OPS(long, Long)
3781 UNION_SEQUENCE_OPS(ulong, ULong)
3782 #ifndef NO_FLOAT
3783 UNION_SEQUENCE_OPS(float, Float)
3784 UNION_SEQUENCE_OPS(double, Double)
3785 #endif
3786 #ifdef HAS_LongLong
3787 UNION_SEQUENCE_OPS(longlong, LongLong)
3788 UNION_SEQUENCE_OPS(ulonglong, ULongLong)
3789 #endif
3790 #ifdef HAS_LongDouble
3791 UNION_SEQUENCE_OPS(longdouble, LongDouble)
3792 #endif
3793 UNION_SEQUENCE_OPS(wchar, WChar)
3794
3795 #undef UNION_SEQUENCE_OPS
3796
3797
3798
3799
3800
3801
3802 CORBA::Boolean
3803 DynUnionImpl::seek(CORBA::Long index)
3804 {
3805 CHECK_NOT_DESTROYED;
3806
3807 switch( index ) {
3808 case 0:
3809 pd_curr_index = 0;
3810 return 1;
3811 case 1:
3812 if (pd_member) {
3813 pd_curr_index = 1;
3814 return 1;
3815 }
3816 // drop through
3817 default:
3818 pd_curr_index = -1;
3819 return 0;
3820 }
3821 }
3822
3823
3824 void
rewind()3825 DynUnionImpl::rewind()
3826 {
3827 CHECK_NOT_DESTROYED;
3828 pd_curr_index = 0;
3829 }
3830
3831
3832 CORBA::Boolean
next()3833 DynUnionImpl::next()
3834 {
3835 CHECK_NOT_DESTROYED;
3836
3837 switch (pd_curr_index) {
3838 case -1:
3839 pd_curr_index = 0;
3840 return 1;
3841 case 0:
3842 if (pd_member) {
3843 pd_curr_index = 1;
3844 return 1;
3845 }
3846 // drop through
3847 default:
3848 pd_curr_index = -1;
3849 return 0;
3850 }
3851 }
3852
3853 CORBA::ULong
component_count()3854 DynUnionImpl::component_count()
3855 {
3856 CHECK_NOT_DESTROYED;
3857 if (pd_member)
3858 return 2;
3859 else
3860 return 1;
3861 }
3862
3863
3864 DynamicAny::DynAny_ptr
current_component()3865 DynUnionImpl::current_component()
3866 {
3867 CHECK_NOT_DESTROYED;
3868
3869 switch( pd_curr_index ) {
3870 case 0:
3871 pd_disc->_NP_incrRefCount();
3872 return pd_disc;
3873
3874 case 1:
3875 if( pd_member ) {
3876 pd_member->_NP_incrRefCount();
3877 return pd_member;
3878 } else
3879 return DynamicAny::DynAny::_nil();
3880
3881 default:
3882 return DynamicAny::DynAny::_nil();
3883 }
3884 }
3885
3886
3887 DynamicAny::DynAny_ptr
get_discriminator()3888 DynUnionImpl::get_discriminator()
3889 {
3890 CHECK_NOT_DESTROYED;
3891 pd_disc->_NP_incrRefCount();
3892 return pd_disc;
3893 }
3894
3895 void
set_discriminator(DynamicAny::DynAny_ptr d)3896 DynUnionImpl::set_discriminator(DynamicAny::DynAny_ptr d)
3897 {
3898 CHECK_NOT_DESTROYED;
3899 pd_disc->assign(d);
3900 pd_curr_index = pd_member ? 1 : 0;
3901 }
3902
3903 void
set_to_default_member()3904 DynUnionImpl::set_to_default_member()
3905 {
3906 CHECK_NOT_DESTROYED;
3907
3908 CORBA::Long defaulti = actualTc()->NP_default_index();
3909
3910 if (defaulti < 0)
3911 throw DynamicAny::DynAny::TypeMismatch();
3912
3913 pd_disc->set_value(actualTc()->NP_default_value());
3914 pd_curr_index = 0;
3915 }
3916
3917 void
set_to_no_active_member()3918 DynUnionImpl::set_to_no_active_member()
3919 {
3920 CHECK_NOT_DESTROYED;
3921
3922 CORBA::Long defaulti = actualTc()->NP_default_index();
3923
3924 if (defaulti != TYPECODE_UNION_IMPLICIT_DEFAULT)
3925 throw DynamicAny::DynAny::TypeMismatch();
3926
3927 pd_disc->set_value(actualTc()->NP_default_value());
3928 pd_curr_index = 0;
3929 }
3930
3931 CORBA::Boolean
has_no_active_member()3932 DynUnionImpl::has_no_active_member()
3933 {
3934 CHECK_NOT_DESTROYED;
3935
3936 return pd_member == 0;
3937 }
3938
3939 CORBA::TCKind
discriminator_kind()3940 DynUnionImpl::discriminator_kind()
3941 {
3942 CHECK_NOT_DESTROYED;
3943 return pd_disc_kind;
3944 }
3945
3946
3947 DynamicAny::DynAny_ptr
member()3948 DynUnionImpl::member()
3949 {
3950 CHECK_NOT_DESTROYED;
3951 if( !pd_member )
3952 throw DynamicAny::DynAny::InvalidValue();
3953
3954 pd_member->_NP_incrRefCount();
3955 return pd_member;
3956 }
3957
3958
3959 char*
member_name()3960 DynUnionImpl::member_name()
3961 {
3962 CHECK_NOT_DESTROYED;
3963 if( !pd_member )
3964 throw DynamicAny::DynAny::InvalidValue();
3965
3966 return CORBA::string_dup(actualTc()->NP_member_name(pd_disc_index));
3967 }
3968
3969
3970 CORBA::TCKind
member_kind()3971 DynUnionImpl::member_kind()
3972 {
3973 CHECK_NOT_DESTROYED;
3974 if( !pd_member )
3975 throw DynamicAny::DynAny::InvalidValue();
3976
3977 return pd_member_kind;
3978 }
3979
3980 CORBA::Boolean
is_set_to_default_member()3981 DynUnionImpl::is_set_to_default_member()
3982 {
3983 CHECK_NOT_DESTROYED;
3984 return (pd_disc_index >= 0 &&
3985 pd_disc_index == actualTc()->NP_default_index());
3986 }
3987
3988
3989 ///////////////////////////////
3990 // exposed private interface //
3991 ///////////////////////////////
3992
3993 int
NP_nodetype() const3994 DynUnionImpl::NP_nodetype() const
3995 {
3996 return dt_union;
3997 }
3998
3999 //////////////
4000 // internal //
4001 //////////////
4002
4003 void
set_to_initial_value()4004 DynUnionImpl::set_to_initial_value()
4005 {
4006 pd_disc->set_to_initial_value();
4007 if (pd_member)
4008 pd_member->set_to_initial_value();
4009 }
4010
4011
4012 int
copy_to(cdrAnyMemoryStream & mbs)4013 DynUnionImpl::copy_to(cdrAnyMemoryStream& mbs)
4014 {
4015 if( !pd_disc->copy_to(mbs) ) return 0;
4016
4017 return !pd_member || pd_member->copy_to(mbs);
4018 }
4019
4020
4021 int
copy_from(cdrAnyMemoryStream & mbs)4022 DynUnionImpl::copy_from(cdrAnyMemoryStream& mbs)
4023 {
4024 if( !pd_disc->copy_from(mbs) ) return 0;
4025
4026 discriminatorHasChanged();
4027
4028 pd_curr_index = 0;
4029 return !pd_member || pd_member->copy_from(mbs);
4030 }
4031
4032
4033 void
onDispose()4034 DynUnionImpl::onDispose()
4035 {
4036 pd_disc->detach();
4037 if( pd_member ) pd_member->detach();
4038 }
4039
4040
4041 void
discriminatorHasChanged()4042 DynUnionImpl::discriminatorHasChanged()
4043 {
4044 // Retrieve the integer value of the discriminator from
4045 // the buffer of the DynAny which it is stored in.
4046 TypeCode_union::Discriminator newdisc;
4047 try {
4048 pd_disc->pd_buf.rewindInputPtr();
4049 newdisc =
4050 TypeCode_union_helper::unmarshalLabel(pd_disc_type, pd_disc->pd_buf);
4051 }
4052 catch(CORBA::MARSHAL&) {
4053 // Not properly initialised.
4054 if( pd_member ) detachMember();
4055 return;
4056 }
4057
4058 if( pd_member && newdisc == pd_disc_value ) return;
4059
4060 pd_disc_value = newdisc;
4061
4062 CORBA::Long newindex = actualTc()->NP_index_from_discriminator(newdisc);
4063
4064 if( pd_member ) {
4065 if (pd_disc_index >= 0 && newindex >= 0) {
4066 // If the discriminator is set to a value corresponding to the
4067 // same member, we should leave the member value unchanged.
4068 // Unfortunately, there's no foolproof way of checking if the
4069 // member is the same. If we have member names, we compare them;
4070 // if not, we see if the member TypeCodes are equal. Equal
4071 // TypeCodes doesn't necessarily mean the same member, but it's
4072 // the best we can do.
4073
4074 const char* old_member = actualTc()->NP_member_name(pd_disc_index);
4075 const char* new_member = actualTc()->NP_member_name(newindex);
4076
4077 if (*old_member == '\0' || *new_member == '\0') {
4078 CORBA::TypeCode_ptr old_tc = actualTc()->NP_member_type(pd_disc_index);
4079 CORBA::TypeCode_ptr new_tc = actualTc()->NP_member_type(newindex);
4080
4081 if (old_tc->equal(new_tc)) {
4082 pd_disc_index = newindex;
4083 return;
4084 }
4085 }
4086 else if (omni::ptrStrMatch(old_member, new_member)) {
4087 pd_disc_index = newindex;
4088 return;
4089 }
4090 }
4091 detachMember();
4092 }
4093 pd_disc_index = newindex;
4094 if( pd_disc_index < 0 ) {
4095 // Invalid label - implicit default.
4096 return;
4097 }
4098
4099 // Create new member of the appropriate type.
4100 CORBA::TypeCode_ptr mtc = actualTc()->member_type(pd_disc_index);
4101 pd_member = internal_create_dyn_any(ToTcBase(mtc), DYNANY_CHILD);
4102 pd_member->set_to_initial_value();
4103 pd_member_kind = TypeCode_base::NP_expand(ToTcBase(mtc))->NP_kind();
4104 }
4105
4106 void
_NP_incrRefCount()4107 DynUnionImpl::_NP_incrRefCount()
4108 {
4109 DynAnyImplBase::_NP_incrRefCount();
4110 }
4111
4112 void
_NP_decrRefCount()4113 DynUnionImpl::_NP_decrRefCount()
4114 {
4115 DynAnyImplBase::_NP_decrRefCount();
4116 }
4117
4118 void*
_ptrToObjRef(const char * repoId)4119 DynUnionImpl::_ptrToObjRef(const char* repoId)
4120 {
4121 if( omni::ptrStrMatch(repoId, DynUnionImpl::_PD_repoId) )
4122 return (DynUnionImpl*) this;
4123
4124 if( omni::ptrStrMatch(repoId, DynAnyImplBase::_PD_repoId) )
4125 return (DynAnyImplBase*) this;
4126
4127 if( omni::ptrStrMatch(repoId, DynAnyImpl::_PD_repoId) )
4128 return (DynAnyImpl*) this;
4129
4130 if( omni::ptrStrMatch(repoId, DynamicAny::DynUnion::_PD_repoId) )
4131 return (DynamicAny::DynUnion_ptr) this;
4132
4133 if( omni::ptrStrMatch(repoId, DynamicAny::DynAny::_PD_repoId) )
4134 return (DynamicAny::DynAny_ptr) this;
4135
4136 if( omni::ptrStrMatch(repoId, CORBA::Object::_PD_repoId) )
4137 return (CORBA::Object_ptr) this;
4138
4139 return 0;
4140 }
4141
4142
4143 //////////////////////////////////////////////////////////////////////
4144 /////////////////////////// DynSequenceImpl //////////////////////////
4145 //////////////////////////////////////////////////////////////////////
4146
DynSequenceImpl(TypeCode_base * tc,CORBA::Boolean is_root)4147 DynSequenceImpl::DynSequenceImpl(TypeCode_base* tc, CORBA::Boolean is_root)
4148 : DynAnyConstrBase(tc, dt_seq, is_root)
4149 {
4150 pd_bound = actualTc()->NP_length();
4151 }
4152
4153
~DynSequenceImpl()4154 DynSequenceImpl::~DynSequenceImpl()
4155 {
4156 }
4157
4158 //////////////////////
4159 // public interface //
4160 //////////////////////
4161
4162 DynamicAny::DynAny_ptr
copy()4163 DynSequenceImpl::copy()
4164 {
4165 CHECK_NOT_DESTROYED;
4166 DynSequenceImpl* da =
4167 new DynSequenceImpl(TypeCode_collector::duplicateRef(tc()), DYNANY_ROOT);
4168
4169 try {
4170 da->assign(this);
4171 }
4172 catch(...) {
4173 da->_NP_decrRefCount();
4174 throw;
4175 }
4176 return da;
4177 }
4178
4179
4180 CORBA::ULong
get_length()4181 DynSequenceImpl::get_length()
4182 {
4183 CHECK_NOT_DESTROYED;
4184 return pd_n_components;
4185 }
4186
4187
4188 void
set_length(CORBA::ULong value)4189 DynSequenceImpl::set_length(CORBA::ULong value)
4190 {
4191 CHECK_NOT_DESTROYED;
4192 if( pd_bound && value > pd_bound )
4193 throw DynamicAny::DynAny::InvalidValue();
4194
4195 if (pd_n_components == value) return;
4196
4197 unsigned old_n_components = pd_n_components;
4198
4199 setNumComponents(value);
4200
4201 if (value > old_n_components) {
4202 if (pd_curr_index == -1)
4203 pd_curr_index = old_n_components;
4204 }
4205 else {
4206 if (pd_curr_index >= (int)pd_n_components)
4207 pd_curr_index = -1;
4208 }
4209 }
4210
4211
4212 DynamicAny::AnySeq*
get_elements()4213 DynSequenceImpl::get_elements()
4214 {
4215 CHECK_NOT_DESTROYED;
4216 DynamicAny::AnySeq* as = new DynamicAny::AnySeq();
4217 as->length(pd_n_components);
4218
4219 for( unsigned i = 0; i < pd_n_components; i++ ) {
4220 if( !component_to_any(i, (*as)[i]) ) {
4221 delete as;
4222 OMNIORB_THROW(BAD_INV_ORDER, BAD_INV_ORDER_DynAnyNotInitialised,
4223 CORBA::COMPLETED_NO);
4224 }
4225 }
4226 return as;
4227 }
4228
4229
4230 void
set_elements(const DynamicAny::AnySeq & as)4231 DynSequenceImpl::set_elements(const DynamicAny::AnySeq& as)
4232 {
4233 CHECK_NOT_DESTROYED;
4234 if( pd_bound && as.length() > pd_bound )
4235 throw DynamicAny::DynAny::InvalidValue();
4236
4237 if( as.length() != pd_n_components )
4238 setNumComponents(as.length());
4239
4240 if( as.length() == 0 )
4241 pd_curr_index = -1;
4242 else
4243 pd_curr_index = 0;
4244
4245 for( unsigned i = 0; i < pd_n_components; i++ ) {
4246 if( !component_from_any(i, as[i]) )
4247 throw DynamicAny::DynAny::TypeMismatch();
4248 }
4249 }
4250
4251
4252 DynamicAny::DynAnySeq*
get_elements_as_dyn_any()4253 DynSequenceImpl::get_elements_as_dyn_any()
4254 {
4255 CHECK_NOT_DESTROYED;
4256 DynamicAny::DynAnySeq* as = new DynamicAny::DynAnySeq();
4257 as->length(pd_n_components);
4258
4259 createComponent(0);
4260 // All components are now in the buffer
4261
4262 for( unsigned i = 0; i < pd_n_components; i++ ) {
4263 pd_components[i]->_NP_incrRefCount();
4264 (*as)[i] = pd_components[i];
4265 }
4266 return as;
4267 }
4268
4269
4270 void
set_elements_as_dyn_any(const DynamicAny::DynAnySeq & as)4271 DynSequenceImpl::set_elements_as_dyn_any(const DynamicAny::DynAnySeq& as)
4272 {
4273 CHECK_NOT_DESTROYED;
4274
4275 CORBA::TypeCode_var tc;
4276 unsigned i;
4277
4278 if (pd_bound && as.length() > pd_bound)
4279 throw DynamicAny::DynAny::InvalidValue();
4280
4281 for (i=0; i < as.length(); i++) {
4282 tc = as[i]->type();
4283 if (!tc->equivalent(nthComponentTC(i))) {
4284 throw DynamicAny::DynAny::TypeMismatch();
4285 }
4286 }
4287
4288 if (as.length() != pd_n_components)
4289 setNumComponents(as.length());
4290
4291 if (as.length() == 0)
4292 pd_curr_index = -1;
4293 else
4294 pd_curr_index = 0;
4295
4296 pd_n_in_buf = 0;
4297 pd_first_in_comp = 0;
4298
4299 for (i = 0; i < pd_n_components; i++) {
4300 DynAnyImplBase* daib = ToDynAnyImplBase(as[i]);
4301 if (daib->is_root()) {
4302 // Take ownership of the DynAny
4303 daib->_NP_incrRefCount();
4304 }
4305 else {
4306 DynamicAny::DynAny_ptr newda = daib->copy();
4307 daib = ToDynAnyImplBase(newda);
4308 }
4309 daib->attach();
4310
4311 if (pd_components[i]) {
4312 pd_components[i]->detach();
4313 pd_components[i]->_NP_decrRefCount();
4314 }
4315 pd_components[i] = daib;
4316 }
4317 }
4318
4319 ///////////////////////////////
4320 // exposed private interface //
4321 ///////////////////////////////
4322
4323 int
NP_nodetype() const4324 DynSequenceImpl::NP_nodetype() const
4325 {
4326 return dt_seq;
4327 }
4328
4329
4330
4331 //////////////
4332 // internal //
4333 //////////////
4334
4335 int
copy_to(cdrAnyMemoryStream & mbs)4336 DynSequenceImpl::copy_to(cdrAnyMemoryStream& mbs)
4337 {
4338 // Write the length of the sequence.
4339 CORBA::ULong(pd_n_components) >>= mbs;
4340
4341 // Copy the elements.
4342 return DynAnyConstrBase::copy_to(mbs);
4343 }
4344
4345
4346 int
copy_from(cdrAnyMemoryStream & mbs)4347 DynSequenceImpl::copy_from(cdrAnyMemoryStream& mbs)
4348 {
4349 CORBA::ULong len;
4350 try {
4351 // Read the length of the sequence.
4352 len <<= mbs;
4353 }
4354 catch(CORBA::MARSHAL&) {
4355 return 0;
4356 }
4357
4358 if (len > pd_n_components && pd_first_in_comp == pd_n_components) {
4359 // Extend sequence without initialising components
4360 pd_components.reserve(len);
4361 DynAnyImplBase* tmp = 0;
4362 while (pd_components.size() < len) pd_components.push_back(tmp);
4363 pd_n_components = pd_first_in_comp = len;
4364 }
4365 else
4366 setNumComponents(len);
4367
4368 return DynAnyConstrBase::copy_from(mbs);
4369 }
4370
4371
4372 TypeCode_base*
nthComponentTC(unsigned n)4373 DynSequenceImpl::nthComponentTC(unsigned n)
4374 {
4375 return actualTc()->NP_content_type();
4376 }
4377
4378
4379 DynAnyConstrBase::SeqLocation
prepareSequenceWrite(CORBA::TCKind kind,CORBA::ULong len)4380 DynSequenceImpl::prepareSequenceWrite(CORBA::TCKind kind, CORBA::ULong len)
4381 {
4382 const TypeCode_base* tc = actualTc();
4383 const TypeCode_base* ctc;
4384
4385 ctc = TypeCode_base::NP_expand(tc->NP_content_type());
4386 CORBA::TCKind k = ctc->NP_kind();
4387
4388 if (k == kind) {
4389 if (pd_bound && len > pd_bound)
4390 throw DynamicAny::DynAny::InvalidValue();
4391
4392 // Clear old components
4393 setNumComponents(0);
4394
4395 // Create new components in <pd_buf>
4396 pd_components.reserve(len);
4397 DynAnyImplBase* tmp = 0;
4398 while( pd_components.size() < len ) pd_components.push_back(tmp);
4399 pd_n_components = pd_first_in_comp = len;
4400 pd_n_in_buf = pd_n_really_in_buf = len;
4401 pd_buf.rewindPtrs();
4402 return SEQ_HERE;
4403 }
4404
4405 if (pd_curr_index < 0)
4406 throw DynamicAny::DynAny::InvalidValue();
4407
4408 if ((k == CORBA::tk_sequence || k == CORBA::tk_array) &&
4409 TypeCode_base::NP_expand(ctc->NP_content_type())->NP_kind() == kind) {
4410 return SEQ_COMPONENT;
4411 }
4412 throw DynamicAny::DynAny::TypeMismatch();
4413 #ifdef NEED_DUMMY_RETURN
4414 return SEQ_COMPONENT;
4415 #endif
4416 }
4417
4418 DynAnyConstrBase::SeqLocation
prepareSequenceRead(CORBA::TCKind kind)4419 DynSequenceImpl::prepareSequenceRead(CORBA::TCKind kind)
4420 {
4421 const TypeCode_base* tc = actualTc();
4422 const TypeCode_base* ctc;
4423
4424 ctc = TypeCode_base::NP_expand(tc->NP_content_type());
4425 CORBA::TCKind k = ctc->NP_kind();
4426
4427 if (k == kind)
4428 return SEQ_HERE;
4429
4430 if (pd_curr_index < 0)
4431 throw DynamicAny::DynAny::InvalidValue();
4432
4433 if ((k == CORBA::tk_sequence || k == CORBA::tk_array) &&
4434 TypeCode_base::NP_expand(ctc->NP_content_type())->NP_kind() == kind) {
4435 return SEQ_COMPONENT;
4436 }
4437 throw DynamicAny::DynAny::TypeMismatch();
4438 #ifdef NEED_DUMMY_RETURN
4439 return SEQ_COMPONENT;
4440 #endif
4441 }
4442
4443
4444 void
_NP_incrRefCount()4445 DynSequenceImpl::_NP_incrRefCount()
4446 {
4447 DynAnyImplBase::_NP_incrRefCount();
4448 }
4449
4450 void
_NP_decrRefCount()4451 DynSequenceImpl::_NP_decrRefCount()
4452 {
4453 DynAnyImplBase::_NP_decrRefCount();
4454 }
4455
4456 void*
_ptrToObjRef(const char * repoId)4457 DynSequenceImpl::_ptrToObjRef(const char* repoId)
4458 {
4459 if( omni::ptrStrMatch(repoId, DynAnyConstrBase::_PD_repoId) )
4460 return (DynAnyConstrBase*) this;
4461
4462 if( omni::ptrStrMatch(repoId, DynAnyImplBase::_PD_repoId) )
4463 return (DynAnyImplBase*) this;
4464
4465 if( omni::ptrStrMatch(repoId, DynAnyImpl::_PD_repoId) )
4466 return (DynAnyImpl*) this;
4467
4468 if( omni::ptrStrMatch(repoId, DynamicAny::DynSequence::_PD_repoId) )
4469 return (DynamicAny::DynSequence_ptr) this;
4470
4471 if( omni::ptrStrMatch(repoId, DynamicAny::DynAny::_PD_repoId) )
4472 return (DynamicAny::DynAny_ptr) this;
4473
4474 if( omni::ptrStrMatch(repoId, CORBA::Object::_PD_repoId) )
4475 return (CORBA::Object_ptr) this;
4476
4477 return 0;
4478 }
4479
4480
4481 //////////////////////////////////////////////////////////////////////
4482 //////////////////////////// DynArrayImpl ////////////////////////////
4483 //////////////////////////////////////////////////////////////////////
4484
DynArrayImpl(TypeCode_base * tc,CORBA::Boolean is_root)4485 DynArrayImpl::DynArrayImpl(TypeCode_base* tc, CORBA::Boolean is_root)
4486 : DynAnyConstrBase(tc, dt_array, is_root)
4487 {
4488 // Set things up without initialising components
4489 pd_n_components = pd_first_in_comp = actualTc()->NP_length();
4490 DynAnyImplBase* tmp = 0;
4491 while (pd_components.size() < pd_n_components)
4492 pd_components.push_back(tmp);
4493 }
4494
4495
~DynArrayImpl()4496 DynArrayImpl::~DynArrayImpl()
4497 {
4498 }
4499
4500 //////////////////////
4501 // public interface //
4502 //////////////////////
4503
4504 DynamicAny::DynAny_ptr
copy()4505 DynArrayImpl::copy()
4506 {
4507 CHECK_NOT_DESTROYED;
4508
4509 DynArrayImpl* da = new DynArrayImpl(TypeCode_collector::duplicateRef(tc()),
4510 DYNANY_ROOT);
4511 try {
4512 da->assign(this);
4513 }
4514 catch(...) {
4515 da->_NP_decrRefCount();
4516 throw;
4517 }
4518 return da;
4519 }
4520
4521
4522 DynamicAny::AnySeq*
get_elements()4523 DynArrayImpl::get_elements()
4524 {
4525 CHECK_NOT_DESTROYED;
4526
4527 DynamicAny::AnySeq* as = new DynamicAny::AnySeq();
4528 as->length(pd_n_components);
4529
4530 for( unsigned i = 0; i < pd_n_components; i++ ) {
4531 if( !component_to_any(i, (*as)[i]) ) {
4532 delete as;
4533 OMNIORB_THROW(BAD_INV_ORDER, BAD_INV_ORDER_DynAnyNotInitialised,
4534 CORBA::COMPLETED_NO);
4535 }
4536 }
4537 return as;
4538 }
4539
4540
4541 void
set_elements(const DynamicAny::AnySeq & as)4542 DynArrayImpl::set_elements(const DynamicAny::AnySeq& as)
4543 {
4544 CHECK_NOT_DESTROYED;
4545
4546 if( as.length() != pd_n_components )
4547 throw DynamicAny::DynAny::InvalidValue();
4548
4549 for( unsigned i = 0; i < pd_n_components; i++ ) {
4550 if( !component_from_any(i, as[i]) )
4551 throw DynamicAny::DynAny::TypeMismatch();
4552 }
4553 }
4554
4555 DynamicAny::DynAnySeq*
get_elements_as_dyn_any()4556 DynArrayImpl::get_elements_as_dyn_any()
4557 {
4558 CHECK_NOT_DESTROYED;
4559
4560 DynamicAny::DynAnySeq* as = new DynamicAny::DynAnySeq();
4561 as->length(pd_n_components);
4562
4563 createComponent(0);
4564 // All components are now in the buffer
4565
4566 for( unsigned i = 0; i < pd_n_components; i++ ) {
4567 pd_components[i]->_NP_incrRefCount();
4568 (*as)[i] = pd_components[i];
4569 }
4570 return as;
4571 }
4572
4573
4574 void
set_elements_as_dyn_any(const DynamicAny::DynAnySeq & as)4575 DynArrayImpl::set_elements_as_dyn_any(const DynamicAny::DynAnySeq& as)
4576 {
4577 CHECK_NOT_DESTROYED;
4578
4579 if (as.length() != pd_n_components)
4580 throw DynamicAny::DynAny::InvalidValue();
4581
4582 CORBA::TypeCode_var tc;
4583 unsigned i;
4584
4585 for (i=0; i < pd_n_components; i++) {
4586 tc = as[i]->type();
4587 if (!tc->equivalent(nthComponentTC(i))) {
4588 throw DynamicAny::DynAny::TypeMismatch();
4589 }
4590 }
4591
4592 pd_n_in_buf = 0;
4593 pd_first_in_comp = 0;
4594
4595 for (i = 0; i < pd_n_components; i++ ) {
4596 DynAnyImplBase* daib = ToDynAnyImplBase(as[i]);
4597 if (daib->is_root()) {
4598 // Take ownership of the DynAny
4599 daib->_NP_incrRefCount();
4600 }
4601 else {
4602 DynamicAny::DynAny_ptr newda = daib->copy();
4603 daib = ToDynAnyImplBase(newda);
4604 }
4605 daib->attach();
4606
4607 if (pd_components[i]) {
4608 pd_components[i]->detach();
4609 pd_components[i]->_NP_decrRefCount();
4610 }
4611 pd_components[i] = daib;
4612 }
4613 }
4614
4615
4616 ///////////////////////////////
4617 // exposed private interface //
4618 ///////////////////////////////
4619
4620 int
NP_nodetype() const4621 DynArrayImpl::NP_nodetype() const
4622 {
4623 return dt_array;
4624 }
4625
4626
4627 //////////////
4628 // internal //
4629 //////////////
4630
4631 TypeCode_base*
nthComponentTC(unsigned n)4632 DynArrayImpl::nthComponentTC(unsigned n)
4633 {
4634 return actualTc()->NP_content_type();
4635 }
4636
4637
4638 DynAnyConstrBase::SeqLocation
prepareSequenceWrite(CORBA::TCKind kind,CORBA::ULong len)4639 DynArrayImpl::prepareSequenceWrite(CORBA::TCKind kind, CORBA::ULong len)
4640 {
4641 const TypeCode_base* tc = actualTc();
4642 const TypeCode_base* ctc;
4643
4644 ctc = TypeCode_base::NP_expand(tc->NP_content_type());
4645 CORBA::TCKind k = ctc->NP_kind();
4646
4647 if (ctc->NP_kind() == kind) {
4648 if (len != pd_n_components)
4649 throw DynamicAny::DynAny::InvalidValue();
4650
4651 // Clear old components
4652 for (unsigned i = pd_first_in_comp; i < pd_n_components; i++) {
4653 pd_components[i]->detach();
4654 pd_components[i]->_NP_decrRefCount();
4655 }
4656
4657 // Write will fill <pd_buf>
4658 pd_first_in_comp = pd_n_in_buf = pd_n_really_in_buf = len;
4659 pd_buf.rewindPtrs();
4660 return SEQ_HERE;
4661 }
4662
4663 if (pd_curr_index < 0)
4664 throw DynamicAny::DynAny::InvalidValue();
4665
4666 if ((k == CORBA::tk_sequence || k == CORBA::tk_array) &&
4667 TypeCode_base::NP_expand(ctc->NP_content_type())->NP_kind() == kind) {
4668 return SEQ_COMPONENT;
4669 }
4670 throw DynamicAny::DynAny::TypeMismatch();
4671 #ifdef NEED_DUMMY_RETURN
4672 return SEQ_COMPONENT;
4673 #endif
4674 }
4675
4676
4677 DynAnyConstrBase::SeqLocation
prepareSequenceRead(CORBA::TCKind kind)4678 DynArrayImpl::prepareSequenceRead(CORBA::TCKind kind)
4679 {
4680 const TypeCode_base* tc = actualTc();
4681 const TypeCode_base* ctc;
4682
4683 ctc = TypeCode_base::NP_expand(tc->NP_content_type());
4684 CORBA::TCKind k = ctc->NP_kind();
4685
4686 if (ctc->NP_kind() == kind)
4687 return SEQ_HERE;
4688
4689 if (pd_curr_index < 0)
4690 throw DynamicAny::DynAny::InvalidValue();
4691
4692 if ((k == CORBA::tk_sequence || k == CORBA::tk_array) &&
4693 TypeCode_base::NP_expand(ctc->NP_content_type())->NP_kind() == kind) {
4694 return SEQ_COMPONENT;
4695 }
4696 throw DynamicAny::DynAny::TypeMismatch();
4697 #ifdef NEED_DUMMY_RETURN
4698 return SEQ_COMPONENT;
4699 #endif
4700 }
4701
4702
4703 void
_NP_incrRefCount()4704 DynArrayImpl::_NP_incrRefCount()
4705 {
4706 DynAnyImplBase::_NP_incrRefCount();
4707 }
4708
4709 void
_NP_decrRefCount()4710 DynArrayImpl::_NP_decrRefCount()
4711 {
4712 DynAnyImplBase::_NP_decrRefCount();
4713 }
4714
4715 void*
_ptrToObjRef(const char * repoId)4716 DynArrayImpl::_ptrToObjRef(const char* repoId)
4717 {
4718 if( omni::ptrStrMatch(repoId, DynAnyConstrBase::_PD_repoId) )
4719 return (DynAnyConstrBase*) this;
4720
4721 if( omni::ptrStrMatch(repoId, DynAnyImplBase::_PD_repoId) )
4722 return (DynAnyImplBase*) this;
4723
4724 if( omni::ptrStrMatch(repoId, DynAnyImpl::_PD_repoId) )
4725 return (DynAnyImpl*) this;
4726
4727 if( omni::ptrStrMatch(repoId, DynamicAny::DynArray::_PD_repoId) )
4728 return (DynamicAny::DynArray_ptr) this;
4729
4730 if( omni::ptrStrMatch(repoId, DynamicAny::DynAny::_PD_repoId) )
4731 return (DynamicAny::DynAny_ptr) this;
4732
4733 if( omni::ptrStrMatch(repoId, CORBA::Object::_PD_repoId) )
4734 return (CORBA::Object_ptr) this;
4735
4736 return 0;
4737 }
4738
4739
4740
4741 //////////////////////////////////////////////////////////////////////
4742 //////////////////////////// DynValueImpl ////////////////////////////
4743 //////////////////////////////////////////////////////////////////////
4744
4745
4746 static void
setValueComponentTypeCodes(omniTypedefs::TypeCodeSeq & tcs,CORBA::StringSeq & names,CORBA::TypeCode_ptr tc)4747 setValueComponentTypeCodes(omniTypedefs::TypeCodeSeq& tcs,
4748 CORBA::StringSeq& names,
4749 CORBA::TypeCode_ptr tc)
4750 {
4751 CORBA::TypeCode_var base = tc->concrete_base_type();
4752 if (base->kind() == CORBA::tk_value)
4753 setValueComponentTypeCodes(tcs, names, base.in());
4754
4755 CORBA::ULong nmembers = tc->member_count();
4756 CORBA::ULong len = tcs.length();
4757 OMNIORB_ASSERT(names.length() == len);
4758
4759 tcs.length(len + nmembers);
4760 names.length(len + nmembers);
4761
4762 CORBA::ULong i, j;
4763
4764 for (i=0, j=len; i < nmembers; i++, j++) {
4765 tcs[j] = tc->member_type(i);
4766 names[j] = tc->member_name(i);
4767 }
4768 }
4769
DynValueImpl(TypeCode_base * tc,CORBA::Boolean is_root)4770 DynValueImpl::DynValueImpl(TypeCode_base* tc, CORBA::Boolean is_root)
4771 : DynAnyConstrBase(tc, dt_value, is_root),
4772 pd_null(1)
4773 {
4774 setValueComponentTypeCodes(pd_componentTCs, pd_componentNames, tc);
4775 }
4776
4777
~DynValueImpl()4778 DynValueImpl::~DynValueImpl()
4779 {
4780 }
4781
4782 //////////////////////
4783 // public interface //
4784 //////////////////////
4785
4786 CORBA::Boolean
is_null()4787 DynValueImpl::is_null()
4788 {
4789 return pd_null;
4790 }
4791
4792 void
set_to_null()4793 DynValueImpl::set_to_null()
4794 {
4795 if (!pd_null) {
4796 setNumComponents(0);
4797 }
4798 pd_null = 1;
4799 pd_curr_index = -1;
4800 }
4801
4802 void
set_to_value()4803 DynValueImpl::set_to_value()
4804 {
4805 // If we're already set to a value, this is a no-op.
4806 if (pd_null) {
4807 pd_null = 0;
4808 setNumComponents(pd_componentTCs.length());
4809 pd_curr_index = 0;
4810 DynAnyConstrBase::set_to_initial_value();
4811 }
4812 }
4813
4814
4815 DynamicAny::DynAny_ptr
copy()4816 DynValueImpl::copy()
4817 {
4818 CHECK_NOT_DESTROYED;
4819 DynValueImpl* da = new DynValueImpl(TypeCode_collector::duplicateRef(tc()),
4820 DYNANY_ROOT);
4821 try {
4822 da->assign(this);
4823 }
4824 catch(...) {
4825 da->_NP_decrRefCount();
4826 throw;
4827 }
4828 return da;
4829 }
4830
4831 char*
current_member_name()4832 DynValueImpl::current_member_name()
4833 {
4834 CHECK_NOT_DESTROYED;
4835 if( pd_n_components == 0 ) throw DynamicAny::DynAny::TypeMismatch();
4836 if( pd_curr_index < 0 ) throw DynamicAny::DynAny::InvalidValue();
4837
4838 return CORBA::string_dup(pd_componentNames[pd_curr_index]);
4839 }
4840
4841
4842 CORBA::TCKind
current_member_kind()4843 DynValueImpl::current_member_kind()
4844 {
4845 CHECK_NOT_DESTROYED;
4846 if( pd_n_components == 0 ) throw DynamicAny::DynAny::TypeMismatch();
4847 if( pd_curr_index < 0 ) throw DynamicAny::DynAny::InvalidValue();
4848
4849 return pd_componentTCs[pd_curr_index]->kind();
4850 }
4851
4852
4853 DynamicAny::NameValuePairSeq*
get_members()4854 DynValueImpl::get_members()
4855 {
4856 CHECK_NOT_DESTROYED;
4857
4858 if (pd_null)
4859 throw DynamicAny::DynAny::InvalidValue();
4860
4861 DynamicAny::NameValuePairSeq* nvps = new DynamicAny::NameValuePairSeq();
4862 nvps->length(pd_n_components);
4863
4864 for( unsigned i = 0; i < pd_n_components; i++ ) {
4865 (*nvps)[i].id = CORBA::string_dup(pd_componentNames[i]);
4866 if( !component_to_any(i, (*nvps)[i].value) ) {
4867 delete nvps;
4868 OMNIORB_THROW(BAD_INV_ORDER, BAD_INV_ORDER_DynAnyNotInitialised,
4869 CORBA::COMPLETED_NO);
4870 }
4871 }
4872 return nvps;
4873 }
4874
4875
4876 void
set_members(const DynamicAny::NameValuePairSeq & nvps)4877 DynValueImpl::set_members(const DynamicAny::NameValuePairSeq& nvps)
4878 {
4879 CHECK_NOT_DESTROYED;
4880
4881 if (pd_null)
4882 set_to_value();
4883
4884 if( nvps.length() != pd_n_components )
4885 throw DynamicAny::DynAny::InvalidValue();
4886
4887 for( unsigned i = 0; i < pd_n_components; i++ ) {
4888 if( ((const char*)(nvps[i].id))[0] != '\0' &&
4889 strcmp((const char*)(nvps[i].id), pd_componentNames[i]))
4890 throw DynamicAny::DynAny::TypeMismatch();
4891
4892 if( !component_from_any(i, nvps[i].value) )
4893 throw DynamicAny::DynAny::TypeMismatch();
4894 }
4895 pd_curr_index = (pd_n_components == 0) ? -1 : 0;
4896 }
4897
4898
4899 DynamicAny::NameDynAnyPairSeq*
get_members_as_dyn_any()4900 DynValueImpl::get_members_as_dyn_any()
4901 {
4902 CHECK_NOT_DESTROYED;
4903
4904 if (pd_null)
4905 throw DynamicAny::DynAny::InvalidValue();
4906
4907 if (pd_n_in_buf != pd_first_in_comp)
4908 OMNIORB_THROW(BAD_INV_ORDER, BAD_INV_ORDER_DynAnyNotInitialised,
4909 CORBA::COMPLETED_NO);
4910
4911 DynamicAny::NameDynAnyPairSeq* nvps = new DynamicAny::NameDynAnyPairSeq();
4912 nvps->length(pd_n_components);
4913
4914 createComponent(0);
4915 // All components are now in the buffer
4916
4917 for( unsigned i = 0; i < pd_n_components; i++ ) {
4918 (*nvps)[i].id = CORBA::string_dup(pd_componentNames[i]);
4919 pd_components[i]->_NP_incrRefCount();
4920 (*nvps)[i].value = pd_components[i];
4921 }
4922 return nvps;
4923 }
4924
4925 void
set_members_as_dyn_any(const DynamicAny::NameDynAnyPairSeq & nvps)4926 DynValueImpl::set_members_as_dyn_any(const DynamicAny::NameDynAnyPairSeq& nvps)
4927 {
4928 CHECK_NOT_DESTROYED;
4929
4930 if (pd_null)
4931 set_to_value();
4932
4933 if( nvps.length() != pd_n_components )
4934 throw DynamicAny::DynAny::InvalidValue();
4935
4936 CORBA::TypeCode_var tc;
4937 unsigned i;
4938
4939 for (i = 0; i < pd_n_components; i++) {
4940
4941 if (((const char*)(nvps[i].id))[0] != '\0' &&
4942 strcmp((const char*)(nvps[i].id), pd_componentNames[i])) {
4943
4944 throw DynamicAny::DynAny::TypeMismatch();
4945 }
4946
4947 tc = nvps[i].value->type();
4948
4949 if (!tc->equivalent(nthComponentTC(i))) {
4950 throw DynamicAny::DynAny::TypeMismatch();
4951 }
4952 }
4953
4954 pd_n_in_buf = 0;
4955 pd_first_in_comp = 0;
4956
4957 for (i = 0; i < pd_n_components; i++) {
4958
4959 DynAnyImplBase* daib = ToDynAnyImplBase(nvps[i].value);
4960 if (daib->is_root()) {
4961 // Take ownership
4962 daib->_NP_incrRefCount();
4963 }
4964 else {
4965 DynamicAny::DynAny_ptr newda = daib->copy();
4966 daib = ToDynAnyImplBase(newda);
4967 }
4968 daib->attach();
4969
4970 if (pd_components[i]) {
4971 pd_components[i]->detach();
4972 pd_components[i]->_NP_decrRefCount();
4973 }
4974 pd_components[i] = daib;
4975 }
4976 pd_curr_index = (pd_n_components == 0) ? -1 : 0;
4977 }
4978
4979
4980
4981 ///////////////////////////////
4982 // exposed private interface //
4983 ///////////////////////////////
4984
4985 int
NP_nodetype() const4986 DynValueImpl::NP_nodetype() const
4987 {
4988 return dt_value;
4989 }
4990
4991
4992 //////////////
4993 // internal //
4994 //////////////
4995
4996 void
set_to_initial_value()4997 DynValueImpl::set_to_initial_value()
4998 {
4999 set_to_null();
5000 }
5001
5002 int
copy_to(cdrAnyMemoryStream & mbs)5003 DynValueImpl::copy_to(cdrAnyMemoryStream& mbs)
5004 {
5005 // The value in our buffer / components has the separate valuetype
5006 // members; in the destination, we need a reference to a shareable
5007 // valuetype. In the case that some values are in components, we use
5008 // an intermediate memory stream to prepare the data for
5009 // unmarshalling.
5010
5011 if (pd_n_in_buf != pd_first_in_comp) return 0;
5012 pd_read_index = -1;
5013
5014 if (pd_null) {
5015 CORBA::ValueBase::_NP_marshal(0, mbs);
5016 return 1;
5017 }
5018
5019 const char* repoId = actualTc()->NP_id();
5020 CORBA::ULong hash = omniValueType::hash_id(repoId);
5021
5022 CORBA::ValueBase_var v(_omni_ValueFactoryManager::
5023 create_for_unmarshal(repoId, hash));
5024 if (!v.in())
5025 v = new UnknownValue(actualTc());
5026
5027 if (pd_n_in_buf < pd_n_components) {
5028 // Use an intermediate memory stream
5029 cdrAnyMemoryStream src;
5030 DynAnyConstrBase::copy_to(src);
5031 v->_PR_unmarshal_state(src);
5032 }
5033 else {
5034 // Use our buffer directly
5035 cdrAnyMemoryStream src(pd_buf);
5036 v->_PR_unmarshal_state(src);
5037 }
5038
5039 // Now marshal the value into the destination buffer.
5040 CORBA::ValueBase::_NP_marshal(v, mbs);
5041 return 1;
5042 }
5043
5044 int
copy_from(cdrAnyMemoryStream & mbs)5045 DynValueImpl::copy_from(cdrAnyMemoryStream& mbs)
5046 {
5047 CORBA::ValueBase_var v = CORBA::ValueBase::_NP_unmarshal(mbs);
5048 if (v.operator->()) {
5049 set_to_value();
5050 if (pd_n_in_buf < pd_n_components) {
5051 // Use an intermediate memory stream
5052 cdrAnyMemoryStream dst;
5053 v->_PR_marshal_state(dst);
5054 DynAnyConstrBase::copy_from(dst);
5055 }
5056 else {
5057 // Use our buffer directly
5058 cdrAnyMemoryStream dst(pd_buf);
5059 v->_PR_marshal_state(dst);
5060 }
5061 return 1;
5062 }
5063 else {
5064 // Nil
5065 set_to_null();
5066 return 1;
5067 }
5068 }
5069
5070 TypeCode_base*
nthComponentTC(unsigned n)5071 DynValueImpl::nthComponentTC(unsigned n)
5072 {
5073 if( n >= pd_n_components )
5074 throw omniORB::fatalException(__FILE__,__LINE__,
5075 "DynValueImpl::nthComponentTC() - n out of bounds");
5076
5077 return (TypeCode_base*)pd_componentTCs[n]._ptr;
5078 }
5079
5080
5081 DynAnyConstrBase::SeqLocation
prepareSequenceWrite(CORBA::TCKind kind,CORBA::ULong len)5082 DynValueImpl::prepareSequenceWrite(CORBA::TCKind kind, CORBA::ULong len)
5083 {
5084 // Note that we ignore then length here. When the insert function
5085 // tries to call insert on the sub-component, that call will check
5086 // the length.
5087
5088 if (pd_curr_index < 0)
5089 throw DynamicAny::DynAny::InvalidValue();
5090
5091 const TypeCode_base* ctc;
5092 ctc = TypeCode_base::NP_expand(nthComponentTC(pd_curr_index));
5093 CORBA::TCKind k = ctc->NP_kind();
5094
5095 if ((k == CORBA::tk_sequence || k == CORBA::tk_array) &&
5096 TypeCode_base::NP_expand(ctc->NP_content_type())->NP_kind() == kind) {
5097 return SEQ_COMPONENT;
5098 }
5099 throw DynamicAny::DynAny::TypeMismatch();
5100 #ifdef NEED_DUMMY_RETURN
5101 return SEQ_COMPONENT;
5102 #endif
5103 }
5104
5105 DynAnyConstrBase::SeqLocation
prepareSequenceRead(CORBA::TCKind kind)5106 DynValueImpl::prepareSequenceRead(CORBA::TCKind kind)
5107 {
5108 if (pd_curr_index < 0)
5109 throw DynamicAny::DynAny::InvalidValue();
5110
5111 const TypeCode_base* ctc;
5112 ctc = TypeCode_base::NP_expand(nthComponentTC(pd_curr_index));
5113 CORBA::TCKind k = ctc->NP_kind();
5114
5115 if ((k == CORBA::tk_sequence || k == CORBA::tk_array) &&
5116 TypeCode_base::NP_expand(ctc->NP_content_type())->NP_kind() == kind) {
5117 return SEQ_COMPONENT;
5118 }
5119 throw DynamicAny::DynAny::TypeMismatch();
5120 #ifdef NEED_DUMMY_RETURN
5121 return SEQ_COMPONENT;
5122 #endif
5123 }
5124
5125
5126 void
_NP_incrRefCount()5127 DynValueImpl::_NP_incrRefCount()
5128 {
5129 DynAnyImplBase::_NP_incrRefCount();
5130 }
5131
5132 void
_NP_decrRefCount()5133 DynValueImpl::_NP_decrRefCount()
5134 {
5135 DynAnyImplBase::_NP_decrRefCount();
5136 }
5137
5138 void*
_ptrToObjRef(const char * repoId)5139 DynValueImpl::_ptrToObjRef(const char* repoId)
5140 {
5141 if( omni::ptrStrMatch(repoId, DynAnyConstrBase::_PD_repoId) )
5142 return (DynAnyConstrBase*) this;
5143
5144 if( omni::ptrStrMatch(repoId, DynAnyImplBase::_PD_repoId) )
5145 return (DynAnyImplBase*) this;
5146
5147 if( omni::ptrStrMatch(repoId, DynAnyImpl::_PD_repoId) )
5148 return (DynAnyImpl*) this;
5149
5150 if( omni::ptrStrMatch(repoId, DynamicAny::DynValue::_PD_repoId) )
5151 return (DynamicAny::DynValue_ptr) this;
5152
5153 if( omni::ptrStrMatch(repoId, DynamicAny::DynAny::_PD_repoId) )
5154 return (DynamicAny::DynAny_ptr) this;
5155
5156 if( omni::ptrStrMatch(repoId, CORBA::Object::_PD_repoId) )
5157 return (CORBA::Object_ptr) this;
5158
5159 return 0;
5160 }
5161
5162
5163
5164 //////////////////////////////////////////////////////////////////////
5165 //////////////////////////// DynValueBoxImpl /////////////////////////
5166 //////////////////////////////////////////////////////////////////////
5167
DynValueBoxImpl(TypeCode_base * tc,CORBA::Boolean is_root)5168 DynValueBoxImpl::DynValueBoxImpl(TypeCode_base* tc, CORBA::Boolean is_root)
5169 : DynAnyConstrBase(tc, dt_value_box, is_root),
5170 pd_null(1)
5171 {
5172 }
5173
5174
~DynValueBoxImpl()5175 DynValueBoxImpl::~DynValueBoxImpl()
5176 {
5177 }
5178
5179 //////////////////////
5180 // public interface //
5181 //////////////////////
5182
5183 CORBA::Boolean
is_null()5184 DynValueBoxImpl::is_null()
5185 {
5186 return pd_null;
5187 }
5188
5189 void
set_to_null()5190 DynValueBoxImpl::set_to_null()
5191 {
5192 pd_null = 1;
5193 pd_curr_index = -1;
5194 }
5195
5196 void
set_to_value()5197 DynValueBoxImpl::set_to_value()
5198 {
5199 // If we're already set to a value, this is a no-op.
5200 if (pd_null) {
5201 pd_null = 0;
5202 setNumComponents(1);
5203 pd_curr_index = 0;
5204 DynAnyConstrBase::set_to_initial_value();
5205 }
5206 }
5207
5208
5209 DynamicAny::DynAny_ptr
copy()5210 DynValueBoxImpl::copy()
5211 {
5212 CHECK_NOT_DESTROYED;
5213 DynValueBoxImpl* da =
5214 new DynValueBoxImpl(TypeCode_collector::duplicateRef(tc()), DYNANY_ROOT);
5215
5216 try {
5217 da->assign(this);
5218 }
5219 catch(...) {
5220 da->_NP_decrRefCount();
5221 throw;
5222 }
5223 return da;
5224 }
5225
5226 CORBA::Any*
get_boxed_value()5227 DynValueBoxImpl::get_boxed_value()
5228 {
5229 CHECK_NOT_DESTROYED;
5230
5231 if (pd_null)
5232 throw DynamicAny::DynAny::InvalidValue();
5233
5234 CORBA::Any_var a = new CORBA::Any();
5235
5236 if (component_to_any(0, a))
5237 return a._retn();
5238
5239 throw DynamicAny::DynAny::InvalidValue();
5240 }
5241
5242 void
set_boxed_value(const CORBA::Any & value)5243 DynValueBoxImpl::set_boxed_value(const CORBA::Any& value)
5244 {
5245 CHECK_NOT_DESTROYED;
5246
5247 set_to_value();
5248
5249 if (component_from_any(0, value))
5250 return;
5251
5252 throw DynamicAny::DynAny::TypeMismatch();
5253 }
5254
5255 DynamicAny::DynAny_ptr
get_boxed_value_as_dyn_any()5256 DynValueBoxImpl::get_boxed_value_as_dyn_any()
5257 {
5258 CHECK_NOT_DESTROYED;
5259
5260 if (pd_null)
5261 throw DynamicAny::DynAny::InvalidValue();
5262
5263 createComponent(0);
5264 pd_components[0]->_NP_incrRefCount();
5265 return pd_components[0];
5266 }
5267
5268 void
set_boxed_value_as_dyn_any(DynamicAny::DynAny_ptr value)5269 DynValueBoxImpl::set_boxed_value_as_dyn_any(DynamicAny::DynAny_ptr value)
5270 {
5271 CHECK_NOT_DESTROYED;
5272
5273 set_to_value();
5274
5275 pd_n_in_buf = 0;
5276 pd_first_in_comp = 0;
5277
5278 CORBA::TypeCode_var tc = value->type();
5279 if (!tc->equivalent(nthComponentTC(0))) {
5280 pd_curr_index = -1;
5281 throw DynamicAny::DynAny::TypeMismatch();
5282 }
5283
5284 DynAnyImplBase* daib = ToDynAnyImplBase(value);
5285 if (daib->is_root()) {
5286 // Take ownership
5287 daib->_NP_incrRefCount();
5288 }
5289 else {
5290 DynamicAny::DynAny_ptr newda = daib->copy();
5291 daib = ToDynAnyImplBase(newda);
5292 }
5293 daib->attach();
5294
5295 if (pd_components[0]) {
5296 pd_components[0]->detach();
5297 pd_components[0]->_NP_decrRefCount();
5298 }
5299
5300 pd_components[0] = daib;
5301 }
5302
5303 ///////////////////////////////
5304 // exposed private interface //
5305 ///////////////////////////////
5306
5307 int
NP_nodetype() const5308 DynValueBoxImpl::NP_nodetype() const
5309 {
5310 return dt_value_box;
5311 }
5312
5313
5314 //////////////
5315 // internal //
5316 //////////////
5317
5318 void
set_to_initial_value()5319 DynValueBoxImpl::set_to_initial_value()
5320 {
5321 set_to_null();
5322 }
5323
5324 int
copy_to(cdrAnyMemoryStream & mbs)5325 DynValueBoxImpl::copy_to(cdrAnyMemoryStream& mbs)
5326 {
5327 if (pd_n_in_buf != pd_first_in_comp) return 0;
5328 pd_read_index = -1;
5329
5330 if (pd_null) {
5331 CORBA::ValueBase::_NP_marshal(0, mbs);
5332 return 1;
5333 }
5334
5335 const char* repoId = actualTc()->NP_id();
5336 CORBA::ULong hash = omniValueType::hash_id(repoId);
5337
5338 CORBA::ValueBase_var v(_omni_ValueFactoryManager::
5339 create_for_unmarshal(repoId, hash));
5340 if (!v.in())
5341 v = new UnknownValue(actualTc());
5342
5343 if (pd_n_in_buf < pd_n_components) {
5344 // Use an intermediate memory stream
5345 cdrAnyMemoryStream src;
5346 DynAnyConstrBase::copy_to(src);
5347 v->_PR_unmarshal_state(src);
5348 }
5349 else {
5350 // Use our buffer directly
5351 cdrAnyMemoryStream src(pd_buf);
5352 v->_PR_unmarshal_state(src);
5353 }
5354
5355 // Now marshal the value into the destination buffer.
5356 CORBA::ValueBase::_NP_marshal(v, mbs);
5357 return 1;
5358 }
5359
5360 int
copy_from(cdrAnyMemoryStream & mbs)5361 DynValueBoxImpl::copy_from(cdrAnyMemoryStream& mbs)
5362 {
5363 CORBA::ValueBase_var v = CORBA::ValueBase::_NP_unmarshal(mbs);
5364 if (v.operator->()) {
5365 set_to_value();
5366 if (pd_n_in_buf < pd_n_components) {
5367 // Use an intermediate memory stream
5368 cdrAnyMemoryStream dst;
5369 v->_PR_marshal_state(dst);
5370 DynAnyConstrBase::copy_from(dst);
5371 }
5372 else {
5373 // Use our buffer directly
5374 cdrAnyMemoryStream dst(pd_buf);
5375 v->_PR_marshal_state(dst);
5376 }
5377 return 1;
5378 }
5379 else {
5380 // Nil
5381 set_to_null();
5382 return 1;
5383 }
5384 }
5385
5386 TypeCode_base*
nthComponentTC(unsigned n)5387 DynValueBoxImpl::nthComponentTC(unsigned n)
5388 {
5389 if (n > 0)
5390 throw omniORB::fatalException(__FILE__,__LINE__,
5391 "DynValueBoxImpl::nthComponentTC() - n out of bounds");
5392
5393 return (TypeCode_base*)tc()->NP_content_type();
5394 }
5395
5396 DynAnyConstrBase::SeqLocation
prepareSequenceWrite(CORBA::TCKind kind,CORBA::ULong len)5397 DynValueBoxImpl::prepareSequenceWrite(CORBA::TCKind kind, CORBA::ULong len)
5398 {
5399 // Note that we ignore then length here. When the insert function
5400 // tries to call insert on the sub-component, that call will check
5401 // the length.
5402
5403 if (pd_curr_index < 0)
5404 throw DynamicAny::DynAny::InvalidValue();
5405
5406 const TypeCode_base* ctc;
5407 ctc = TypeCode_base::NP_expand(nthComponentTC(pd_curr_index));
5408 CORBA::TCKind k = ctc->NP_kind();
5409
5410 if ((k == CORBA::tk_sequence || k == CORBA::tk_array) &&
5411 TypeCode_base::NP_expand(ctc->NP_content_type())->NP_kind() == kind) {
5412 return SEQ_COMPONENT;
5413 }
5414 throw DynamicAny::DynAny::TypeMismatch();
5415 #ifdef NEED_DUMMY_RETURN
5416 return SEQ_COMPONENT;
5417 #endif
5418 }
5419
5420 DynAnyConstrBase::SeqLocation
prepareSequenceRead(CORBA::TCKind kind)5421 DynValueBoxImpl::prepareSequenceRead(CORBA::TCKind kind)
5422 {
5423 if (pd_curr_index < 0)
5424 throw DynamicAny::DynAny::InvalidValue();
5425
5426 const TypeCode_base* ctc;
5427 ctc = TypeCode_base::NP_expand(nthComponentTC(pd_curr_index));
5428 CORBA::TCKind k = ctc->NP_kind();
5429
5430 if ((k == CORBA::tk_sequence || k == CORBA::tk_array) &&
5431 TypeCode_base::NP_expand(ctc->NP_content_type())->NP_kind() == kind) {
5432 return SEQ_COMPONENT;
5433 }
5434 throw DynamicAny::DynAny::TypeMismatch();
5435 #ifdef NEED_DUMMY_RETURN
5436 return SEQ_COMPONENT;
5437 #endif
5438 }
5439
5440
5441 void
_NP_incrRefCount()5442 DynValueBoxImpl::_NP_incrRefCount()
5443 {
5444 DynAnyImplBase::_NP_incrRefCount();
5445 }
5446
5447 void
_NP_decrRefCount()5448 DynValueBoxImpl::_NP_decrRefCount()
5449 {
5450 DynAnyImplBase::_NP_decrRefCount();
5451 }
5452
5453 void*
_ptrToObjRef(const char * repoId)5454 DynValueBoxImpl::_ptrToObjRef(const char* repoId)
5455 {
5456 if( omni::ptrStrMatch(repoId, DynAnyConstrBase::_PD_repoId) )
5457 return (DynAnyConstrBase*) this;
5458
5459 if( omni::ptrStrMatch(repoId, DynAnyImplBase::_PD_repoId) )
5460 return (DynAnyImplBase*) this;
5461
5462 if( omni::ptrStrMatch(repoId, DynAnyImpl::_PD_repoId) )
5463 return (DynAnyImpl*) this;
5464
5465 if( omni::ptrStrMatch(repoId, DynamicAny::DynValueBox::_PD_repoId) )
5466 return (DynamicAny::DynValueBox_ptr) this;
5467
5468 if( omni::ptrStrMatch(repoId, DynamicAny::DynAny::_PD_repoId) )
5469 return (DynamicAny::DynAny_ptr) this;
5470
5471 if( omni::ptrStrMatch(repoId, CORBA::Object::_PD_repoId) )
5472 return (CORBA::Object_ptr) this;
5473
5474 return 0;
5475 }
5476
5477
5478 OMNI_NAMESPACE_END(omni)
5479
OMNI_USING_NAMESPACE(omni)5480 OMNI_USING_NAMESPACE(omni)
5481
5482
5483
5484 //////////////////////////////////////////////////////////////////////
5485 /////////////////////////////// _narrow //////////////////////////////
5486 //////////////////////////////////////////////////////////////////////
5487
5488 #define DECLARE_NARROW_FN(dynkind) \
5489 DynamicAny::dynkind::_ptr_type \
5490 DynamicAny::dynkind::_narrow(CORBA::Object_ptr o) \
5491 { \
5492 if (CORBA::is_nil(o)) return DynamicAny::dynkind::_nil(); \
5493 \
5494 DynamicAny::dynkind::_ptr_type r = \
5495 (DynamicAny::dynkind::_ptr_type)o-> \
5496 _ptrToObjRef(DynamicAny::dynkind::_PD_repoId); \
5497 \
5498 if (r) return DynamicAny::dynkind::_duplicate(r); \
5499 \
5500 return DynamicAny::dynkind::_nil(); \
5501 }
5502
5503 DECLARE_NARROW_FN(DynAny)
5504 DECLARE_NARROW_FN(DynEnum)
5505 DECLARE_NARROW_FN(DynFixed)
5506 DECLARE_NARROW_FN(DynStruct)
5507 DECLARE_NARROW_FN(DynUnion)
5508 DECLARE_NARROW_FN(DynSequence)
5509 DECLARE_NARROW_FN(DynArray)
5510 DECLARE_NARROW_FN(DynValue)
5511 DECLARE_NARROW_FN(DynValueBox)
5512
5513 #undef DECLARE_NARROW_FN
5514
5515 //////////////////////////////////////////////////////////////////////
5516 ///////////////////////////// _duplicate /////////////////////////////
5517 //////////////////////////////////////////////////////////////////////
5518
5519 #define DECLARE_DUPLICATE_FN(dynkind) \
5520 DynamicAny::dynkind::_ptr_type \
5521 DynamicAny::dynkind::_duplicate(DynamicAny::dynkind::_ptr_type p) \
5522 { \
5523 if ( !DynamicAny::DynAny::PR_is_valid(p) ) \
5524 OMNIORB_THROW(BAD_PARAM, BAD_PARAM_InvalidDynAny, CORBA::COMPLETED_NO); \
5525 \
5526 if( !CORBA::is_nil(p) ) { \
5527 ToDynAnyImplBase(p)->_NP_incrRefCount(); \
5528 return p; \
5529 } \
5530 else \
5531 return DynamicAny::dynkind::_nil(); \
5532 }
5533
5534 DECLARE_DUPLICATE_FN(DynAny)
5535 DECLARE_DUPLICATE_FN(DynEnum)
5536 DECLARE_DUPLICATE_FN(DynFixed)
5537 DECLARE_DUPLICATE_FN(DynStruct)
5538 DECLARE_DUPLICATE_FN(DynUnion)
5539 DECLARE_DUPLICATE_FN(DynSequence)
5540 DECLARE_DUPLICATE_FN(DynArray)
5541 DECLARE_DUPLICATE_FN(DynValue)
5542 DECLARE_DUPLICATE_FN(DynValueBox)
5543
5544 #undef DECLARE_DUPLICATE_FN
5545
5546
5547 //////////////////////////////////////////////////////////////////////
5548 /////////////////////////// DynAny_helper ////////////////////////////
5549 //////////////////////////////////////////////////////////////////////
5550
5551 DynamicAny::DynAny_ptr
5552 DynamicAny::DynAny_Helper::_nil()
5553 {
5554 return DynamicAny::DynAny::_nil();
5555 }
5556
5557 CORBA::Boolean
is_nil(DynamicAny::DynAny_ptr p)5558 DynamicAny::DynAny_Helper::is_nil(DynamicAny::DynAny_ptr p)
5559 {
5560 return CORBA::is_nil(p);
5561 }
5562
5563 void
release(DynamicAny::DynAny_ptr p)5564 DynamicAny::DynAny_Helper::release(DynamicAny::DynAny_ptr p)
5565 {
5566 CORBA::release(p);
5567 }
5568
5569 void
duplicate(DynamicAny::DynAny_ptr p)5570 DynamicAny::DynAny_Helper::duplicate(DynamicAny::DynAny_ptr p)
5571 {
5572 DynamicAny::DynAny::_duplicate(p);
5573 }
5574
5575
5576 //////////////////////////////////////////////////////////////////////
5577 ///////////////////////////// DynAnyFactory //////////////////////////
5578 //////////////////////////////////////////////////////////////////////
5579
OMNI_NAMESPACE_BEGIN(omni)5580 OMNI_NAMESPACE_BEGIN(omni)
5581
5582 // <tc> is consumed. Since 2.8.0 it no longer have to alias-expand
5583 static DynAnyImplBase*
5584 internal_create_dyn_any(TypeCode_base* tc, CORBA::Boolean is_root)
5585 {
5586 if ( !CORBA::TypeCode::PR_is_valid(tc) )
5587 OMNIORB_THROW(BAD_PARAM,BAD_PARAM_InvalidTypeCode,CORBA::COMPLETED_NO);
5588
5589 if( CORBA::is_nil(tc) )
5590 OMNIORB_THROW(BAD_TYPECODE,BAD_TYPECODE_TypeCodeIsNil,CORBA::COMPLETED_NO);
5591
5592 DynAnyImplBase* da = 0;
5593
5594 switch( TypeCode_base::NP_expand(tc)->NP_kind() ) {
5595 case CORBA::tk_void:
5596 case CORBA::tk_null:
5597 case CORBA::tk_short:
5598 case CORBA::tk_long:
5599 case CORBA::tk_ushort:
5600 case CORBA::tk_ulong:
5601 #ifdef HAS_LongLong
5602 case CORBA::tk_longlong:
5603 case CORBA::tk_ulonglong:
5604 #endif
5605 #ifndef NO_FLOAT
5606 case CORBA::tk_float:
5607 case CORBA::tk_double:
5608 #ifdef HAS_LongDouble
5609 case CORBA::tk_longdouble:
5610 #endif
5611 #endif
5612 case CORBA::tk_boolean:
5613 case CORBA::tk_char:
5614 case CORBA::tk_wchar:
5615 case CORBA::tk_octet:
5616 case CORBA::tk_any:
5617 case CORBA::tk_TypeCode:
5618 case CORBA::tk_objref:
5619 case CORBA::tk_string:
5620 case CORBA::tk_wstring:
5621 da = new DynAnyImpl(tc, dt_any, is_root);
5622 break;
5623 case CORBA::tk_fixed:
5624 da = new DynFixedImpl(tc, is_root);
5625 break;
5626 case CORBA::tk_enum:
5627 da = new DynEnumImpl(tc, is_root);
5628 break;
5629 case CORBA::tk_struct:
5630 case CORBA::tk_except:
5631 da = new DynStructImpl(tc, is_root);
5632 break;
5633 case CORBA::tk_union:
5634 da = new DynUnionImpl(tc, is_root);
5635 break;
5636 case CORBA::tk_sequence:
5637 da = new DynSequenceImpl(tc, is_root);
5638 break;
5639 case CORBA::tk_array:
5640 da = new DynArrayImpl(tc, is_root);
5641 break;
5642 case CORBA::tk_value:
5643 da = new DynValueImpl(tc, is_root);
5644 break;
5645 case CORBA::tk_value_box:
5646 da = new DynValueBoxImpl(tc, is_root);
5647 break;
5648 default:
5649 throw DynamicAny::DynAny::TypeMismatch();
5650 }
5651 return da;
5652 }
5653
5654
5655 // <tc> is consumed. Since 2.8.0 we no longer have to alias-expand
5656 static DynUnionDisc*
internal_create_dyn_any_discriminator(TypeCode_base * tc,DynUnionImpl * du)5657 internal_create_dyn_any_discriminator(TypeCode_base* tc, DynUnionImpl* du)
5658 {
5659 if ( !CORBA::TypeCode::PR_is_valid(tc) )
5660 OMNIORB_THROW(BAD_PARAM, BAD_PARAM_InvalidTypeCode, CORBA::COMPLETED_NO);
5661
5662 if( CORBA::is_nil(tc) )
5663 OMNIORB_THROW(BAD_TYPECODE, BAD_TYPECODE_TypeCodeIsNil,
5664 CORBA::COMPLETED_NO);
5665
5666 DynUnionDisc* da = 0;
5667
5668 try {
5669 switch( TypeCode_base::NP_expand(tc)->NP_kind() ) {
5670 case CORBA::tk_enum:
5671 da = new DynUnionEnumDisc(tc, du);
5672 break;
5673 default:
5674 da = new DynUnionDisc(tc, dt_disc, du);
5675 break;
5676 }
5677 }
5678 catch(...) {
5679 CORBA::release(tc);
5680 throw;
5681 }
5682 return da;
5683 }
5684
5685 DynamicAny::DynAny_ptr
factory_create_dyn_any(const CORBA::Any & value)5686 factory_create_dyn_any(const CORBA::Any& value)
5687 {
5688 CORBA::TypeCode_var tc = value.type();
5689 if( CORBA::is_nil(tc) )
5690 OMNIORB_THROW(BAD_TYPECODE, BAD_TYPECODE_TypeCodeIsNil,
5691 CORBA::COMPLETED_NO);
5692
5693 DynAnyImplBase* da = 0;
5694 try {
5695 da = internal_create_dyn_any(ToTcBase_Checked(CORBA::
5696 TypeCode::_duplicate(tc)),
5697 DYNANY_ROOT);
5698 }
5699 catch (DynamicAny::DynAny::TypeMismatch&) {
5700 CORBA::TCKind tck = TypeCode_base::NP_expand(ToTcBase(tc))->NP_kind();
5701 if (tck == CORBA::tk_Principal || tck == CORBA::tk_native)
5702 throw DynamicAny::DynAnyFactory::InconsistentTypeCode();
5703 else
5704 OMNIORB_THROW(BAD_PARAM, BAD_PARAM_InvalidTypeCode, CORBA::COMPLETED_NO);
5705 }
5706 da->from_any(value);
5707 return da;
5708 }
5709
5710
5711 DynamicAny::DynAny_ptr
factory_create_dyn_any_from_type_code(CORBA::TypeCode_ptr tc)5712 factory_create_dyn_any_from_type_code(CORBA::TypeCode_ptr tc)
5713 {
5714 if (!CORBA::TypeCode::PR_is_valid(tc))
5715 OMNIORB_THROW(BAD_PARAM, BAD_PARAM_InvalidTypeCode, CORBA::COMPLETED_NO);
5716
5717 if( CORBA::is_nil(tc) )
5718 OMNIORB_THROW(BAD_TYPECODE, BAD_TYPECODE_TypeCodeIsNil,
5719 CORBA::COMPLETED_NO);
5720
5721 const TypeCode_base* aetc = TypeCode_base::NP_expand(ToTcBase_Checked(tc));
5722
5723 DynAnyImplBase* r;
5724
5725 switch( aetc->kind() ) {
5726 case CORBA::tk_null:
5727 case CORBA::tk_void:
5728 case CORBA::tk_short:
5729 case CORBA::tk_long:
5730 case CORBA::tk_ushort:
5731 case CORBA::tk_ulong:
5732 #ifdef HAS_LongLong
5733 case CORBA::tk_longlong:
5734 case CORBA::tk_ulonglong:
5735 #endif
5736 #ifndef NO_FLOAT
5737 case CORBA::tk_float:
5738 case CORBA::tk_double:
5739 #ifdef HAS_LongDouble
5740 case CORBA::tk_longdouble:
5741 #endif
5742 #endif
5743 case CORBA::tk_boolean:
5744 case CORBA::tk_char:
5745 case CORBA::tk_wchar:
5746 case CORBA::tk_octet:
5747 case CORBA::tk_any:
5748 case CORBA::tk_TypeCode:
5749 case CORBA::tk_objref:
5750 case CORBA::tk_string:
5751 case CORBA::tk_wstring:
5752 r = new DynAnyImpl(ToTcBase_Checked(CORBA::TypeCode::_duplicate(tc)),
5753 dt_any, DYNANY_ROOT);
5754 r->set_to_initial_value();
5755 return r;
5756
5757 case CORBA::tk_fixed:
5758 r = new DynFixedImpl(ToTcBase_Checked(CORBA::TypeCode::_duplicate(tc)),
5759 DYNANY_ROOT);
5760 r->set_to_initial_value();
5761 return r;
5762
5763 case CORBA::tk_enum:
5764 r = new DynEnumImpl(ToTcBase_Checked(CORBA::TypeCode::_duplicate(tc)),
5765 DYNANY_ROOT);
5766 r->set_to_initial_value();
5767 return r;
5768
5769 case CORBA::tk_struct:
5770 case CORBA::tk_except:
5771 r = new DynStructImpl(ToTcBase_Checked(CORBA::TypeCode::_duplicate(tc)),
5772 DYNANY_ROOT);
5773 r->set_to_initial_value();
5774 return r;
5775
5776 case CORBA::tk_union:
5777 r = new DynUnionImpl(ToTcBase_Checked(CORBA::TypeCode::_duplicate(tc)),
5778 DYNANY_ROOT);
5779 r->set_to_initial_value();
5780 return r;
5781
5782 case CORBA::tk_sequence:
5783 r = new DynSequenceImpl(ToTcBase_Checked(CORBA::TypeCode::_duplicate(tc)),
5784 DYNANY_ROOT);
5785 r->set_to_initial_value();
5786 return r;
5787
5788 case CORBA::tk_array:
5789 r = new DynArrayImpl(ToTcBase_Checked(CORBA::TypeCode::_duplicate(tc)),
5790 DYNANY_ROOT);
5791 r->set_to_initial_value();
5792 return r;
5793
5794 case CORBA::tk_value:
5795 r = new DynValueImpl(ToTcBase_Checked(CORBA::TypeCode::_duplicate(tc)),
5796 DYNANY_ROOT);
5797 r->set_to_initial_value();
5798 return r;
5799
5800 case CORBA::tk_value_box:
5801 r = new DynValueBoxImpl(ToTcBase_Checked(CORBA::TypeCode::_duplicate(tc)),
5802 DYNANY_ROOT);
5803 r->set_to_initial_value();
5804 return r;
5805
5806 case CORBA::tk_Principal:
5807 case CORBA::tk_native:
5808 throw DynamicAny::DynAnyFactory::InconsistentTypeCode();
5809
5810 default:
5811 OMNIORB_THROW(BAD_PARAM, BAD_PARAM_InvalidTypeCode, CORBA::COMPLETED_NO);
5812 }
5813 return 0;
5814 }
5815
5816
~DynAnyFactoryImpl()5817 DynAnyFactoryImpl::~DynAnyFactoryImpl()
5818 {
5819 }
5820
5821 DynamicAny::DynAny_ptr
create_dyn_any(const CORBA::Any & value)5822 DynAnyFactoryImpl::create_dyn_any(const CORBA::Any& value)
5823 {
5824 return factory_create_dyn_any(value);
5825 }
5826
5827 DynamicAny::DynAny_ptr
create_dyn_any_from_type_code(CORBA::TypeCode_ptr t)5828 DynAnyFactoryImpl::create_dyn_any_from_type_code(CORBA::TypeCode_ptr t)
5829 {
5830 return factory_create_dyn_any_from_type_code(t);
5831 }
5832
5833 static DynAnyFactoryImpl* theDynAnyFactory;
5834
5835
5836 void
_NP_incrRefCount()5837 DynAnyFactoryImpl::_NP_incrRefCount()
5838 {
5839 omni::poRcLock->lock();
5840 pd_refCount++;
5841 omni::poRcLock->unlock();
5842 }
5843
5844 void
_NP_decrRefCount()5845 DynAnyFactoryImpl::_NP_decrRefCount()
5846 {
5847 omni::poRcLock->lock();
5848 int dead = --pd_refCount == 0;
5849 if (dead) theDynAnyFactory = 0;
5850 omni::poRcLock->unlock();
5851
5852 if( !dead ) return;
5853
5854 delete this;
5855 }
5856
5857 DynamicAny::DynAnyFactory_ptr
theFactory()5858 DynAnyFactoryImpl::theFactory()
5859 {
5860 omni_tracedmutex_lock l(*omni::poRcLock);
5861
5862 if (!theDynAnyFactory) {
5863 theDynAnyFactory = new DynAnyFactoryImpl();
5864 return theDynAnyFactory;
5865 }
5866
5867 theDynAnyFactory->pd_refCount++;
5868 return theDynAnyFactory;
5869 }
5870
5871
5872 void*
_ptrToObjRef(const char * repoId)5873 DynAnyFactoryImpl::_ptrToObjRef(const char* repoId)
5874 {
5875 if( omni::ptrStrMatch(repoId, DynamicAny::DynAnyFactory::_PD_repoId) )
5876 return (DynamicAny::DynAnyFactory_ptr) this;
5877
5878 if( omni::ptrStrMatch(repoId, CORBA::Object::_PD_repoId) )
5879 return (CORBA::Object_ptr) this;
5880
5881 return 0;
5882 }
5883
OMNI_NAMESPACE_END(omni)5884 OMNI_NAMESPACE_END(omni)
5885
5886 DynamicAny::DynAnyFactory_ptr
5887 DynamicAny::DynAnyFactory::_narrow(CORBA::Object_ptr o)
5888 {
5889 if (CORBA::is_nil(o)) return DynamicAny::DynAnyFactory::_nil();
5890
5891 DynamicAny::DynAnyFactory_ptr r;
5892 r = (DynamicAny::DynAnyFactory_ptr)o->
5893 _ptrToObjRef(DynamicAny::DynAnyFactory::_PD_repoId);
5894
5895 if (r) return DynamicAny::DynAnyFactory::_duplicate(r);
5896 return DynamicAny::DynAnyFactory::_nil();
5897 }
5898
5899 DynamicAny::DynAnyFactory_ptr
_duplicate(DynamicAny::DynAnyFactory_ptr p)5900 DynamicAny::DynAnyFactory::_duplicate(DynamicAny::DynAnyFactory_ptr p)
5901 {
5902 if (!CORBA::is_nil(p)) {
5903 p->_NP_incrRefCount();
5904 return p;
5905 }
5906 else
5907 return DynamicAny::DynAnyFactory::_nil();
5908 }
5909
OMNI_NAMESPACE_BEGIN(omni)5910 OMNI_NAMESPACE_BEGIN(omni)
5911
5912 static CORBA::Object_ptr resolveDynAnyFactoryFn() {
5913 return DynAnyFactoryImpl::theFactory();
5914 }
5915
5916 class omni_dynAny_initialiser : public omniInitialiser {
5917 public:
omni_dynAny_initialiser()5918 omni_dynAny_initialiser() {
5919 omniInitialReferences::registerPseudoObjFn("DynAnyFactory",
5920 resolveDynAnyFactoryFn);
5921 }
5922
attach()5923 void attach() { }
detach()5924 void detach() { }
5925 };
5926
5927 static omni_dynAny_initialiser initialiser;
5928
5929 omniInitialiser& omni_dynAny_initialiser_ = initialiser;
5930
5931
5932 OMNI_NAMESPACE_END(omni)
5933