TAO/tao/DynamicAny/DynCommon.cpp

   1 // -*- C++ -*-
   2 #include "tao/AnyTypeCode/AnyTypeCode_methods.h"
   3 #include "tao/Valuetype/AbstractBase.h"
   4
   5 #include "tao/DynamicAny/DynCommon.h"
   6
   7 #include "tao/DynamicAny/DynAnyFactory.h"
   8 #include "tao/DynamicAny/DynAny_i.h"
   9 #include "tao/DynamicAny/DynArray_i.h"
  10 #include "tao/DynamicAny/DynEnum_i.h"
  11 #include "tao/DynamicAny/DynSequence_i.h"
  12 #include "tao/DynamicAny/DynStruct_i.h"
  13 #include "tao/DynamicAny/DynUnion_i.h"
  14 #include "tao/DynamicAny/DynAnyUtils_T.h"
  15
  16 #include "tao/AnyTypeCode/Any_Unknown_IDL_Type.h"
  17 #include "tao/AnyTypeCode/AnyTypeCode_methods.h"
  18
  19 #include "tao/CDR.h"
  20
  21 #include "ace/OS_NS_wchar.h"
  22 #include "ace/OS_NS_string.h"
  23
  24 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
  25
  26 TAO_DynCommon::TAO_DynCommon (CORBA::Boolean allow_truncation)
  27   : ref_to_component_ (false)
  28   , container_is_destroying_ (false)
  29   , has_components_ (false)
  30   , destroyed_ (false)
  31   , current_position_ (-1)
  32   , component_count_ (0)
  33   , allow_truncation_ (allow_truncation)
  34 {
  35 }
  36
  37 TAO_DynCommon::~TAO_DynCommon (void)
  38 {
  39 }
  40
  41 CORBA::TypeCode_ptr
  42 TAO_DynCommon::type (void)
  43 {
  44   if (this->destroyed_)
  45     {
  46       throw ::CORBA::OBJECT_NOT_EXIST ();
  47     }
  48
  49   return CORBA::TypeCode::_duplicate (this->type_.in ());
  50 }
  51
  52 void
  53 TAO_DynCommon::assign (DynamicAny::DynAny_ptr dyn_any)
  54 {
  55   if (this->destroyed_)
  56     {
  57       throw ::CORBA::OBJECT_NOT_EXIST ();
  58     }
  59
  60   CORBA::TypeCode_var tc = dyn_any->type ();
  61
  62   CORBA::Boolean const equivalent = this->type_.in ()->equivalent (tc.in ());
  63
  64   if (equivalent)
  65     {
  66       CORBA::Any_var any = dyn_any->to_any ();
  67
  68       this->from_any (any.in ());
  69     }
  70   else
  71     {
  72       throw DynamicAny::DynAny::TypeMismatch ();
  73     }
  74 }
  75
  76 void
  77 TAO_DynCommon::insert_boolean (CORBA::Boolean value)
  78 {
  79   TAO::DynAnyBasicTypeUtils<CORBA::Boolean>::insert_value (value, this);
  80 }
  81
  82 void
  83 TAO_DynCommon::insert_octet (CORBA::Octet value)
  84 {
  85   TAO::DynAnyBasicTypeUtils<CORBA::Octet>::insert_value (value, this);
  86 }
  87
  88 void
  89 TAO_DynCommon::insert_char (CORBA::Char value)
  90 {
  91   TAO::DynAnyBasicTypeUtils<CORBA::Char>::insert_value (value, this);
  92 }
  93
  94 void
  95 TAO_DynCommon::insert_short (CORBA::Short value)
  96 {
  97   TAO::DynAnyBasicTypeUtils<CORBA::Short>::insert_value (value, this);
  98 }
  99
 100 void
 101 TAO_DynCommon::insert_ushort (CORBA::UShort value)
 102 {
 103   TAO::DynAnyBasicTypeUtils<CORBA::UShort>::insert_value (value, this);
 104 }
 105
 106 void
 107 TAO_DynCommon::insert_long (CORBA::Long value)
 108 {
 109   TAO::DynAnyBasicTypeUtils<CORBA::Long>::insert_value (value, this);
 110 }
 111
 112 void
 113 TAO_DynCommon::insert_ulong (CORBA::ULong value)
 114 {
 115   TAO::DynAnyBasicTypeUtils<CORBA::ULong>::insert_value (value, this);
 116 }
 117
 118 void
 119 TAO_DynCommon::insert_float (CORBA::Float value)
 120 {
 121   TAO::DynAnyBasicTypeUtils<CORBA::Float>::insert_value (value, this);
 122 }
 123
 124 void
 125 TAO_DynCommon::insert_double (CORBA::Double value)
 126 {
 127   TAO::DynAnyBasicTypeUtils<CORBA::Double>::insert_value (value, this);
 128 }
 129
 130 void
 131 TAO_DynCommon::insert_string (const char * value)
 132 {
 133   if (this->destroyed_)
 134     {
 135       throw ::CORBA::OBJECT_NOT_EXIST ();
 136     }
 137
 138   if (this->has_components_)
 139     {
 140       DynamicAny::DynAny_var cc =
 141         this->check_component ();
 142
 143       cc->insert_string (value);
 144     }
 145   else
 146     {
 147       CORBA::TypeCode_var unaliased_tc =
 148         TAO_DynAnyFactory::strip_alias (this->type_.in ());
 149
 150       CORBA::TCKind const kind =
 151         unaliased_tc->kind ();
 152
 153       if (kind != CORBA::tk_string)
 154         {
 155           throw DynamicAny::DynAny::TypeMismatch ();
 156         }
 157
 158       CORBA::ULong const bound =
 159         unaliased_tc->length ();
 160
 161       if (bound > 0 && bound < ACE_OS::strlen (value))
 162         {
 163           throw DynamicAny::DynAny::InvalidValue ();
 164         }
 165
 166       this->any_ <<= CORBA::Any::from_string (const_cast<char *> (value),
 167                                               bound);
 168     }
 169 }
 170
 171 void
 172 TAO_DynCommon::insert_reference (CORBA::Object_ptr value)
 173 {
 174   if (this->destroyed_)
 175     {
 176       throw ::CORBA::OBJECT_NOT_EXIST ();
 177     }
 178
 179   if (this->has_components_)
 180     {
 181       DynamicAny::DynAny_var cc =
 182         this->check_component ();
 183
 184       cc->insert_reference (value);
 185     }
 186   else
 187     {
 188       CORBA::Boolean good_type = true;
 189       CORBA::TCKind const kind =
 190         TAO_DynAnyFactory::unalias (this->type_.in ());
 191
 192       if (kind != CORBA::tk_objref)
 193         {
 194           good_type = false;
 195         }
 196       else if (!CORBA::is_nil (value))
 197         {
 198           const char *value_id = value->_interface_repository_id ();
 199
 200           if (ACE_OS::strcmp (value_id, "IDL:omg.org/CORBA/Object:1.0") != 0)
 201             {
 202               const char *my_id =
 203                 this->type_->id ();
 204
 205               if (ACE_OS::strcmp (value_id, my_id) != 0)
 206                 {
 207                   good_type = value->_is_a (my_id);
 208                 }
 209             }
 210         }
 211
 212       if (good_type)
 213         {
 214           TAO_OutputCDR cdr;
 215
 216           if (CORBA::is_nil (value))
 217             {
 218               // Empty type hint, no profile.
 219               cdr.write_ulong (1);
 220               cdr.write_char ('\0');
 221               cdr.write_ulong (0);
 222             }
 223           else
 224             {
 225               if (!value->marshal (cdr))
 226                 {
 227                   throw DynamicAny::DynAny::InvalidValue ();
 228                 }
 229             }
 230
 231           TAO_InputCDR in (cdr);
 232           TAO::Unknown_IDL_Type *unk = 0;
 233           ACE_NEW (unk,
 234                    TAO::Unknown_IDL_Type (this->type_.in (),
 235                                           in));
 236           this->any_.replace (unk);
 237         }
 238       else
 239         {
 240           throw DynamicAny::DynAny::TypeMismatch ();
 241         }
 242     }
 243 }
 244
 245 void
 246 TAO_DynCommon::insert_typecode (CORBA::TypeCode_ptr value)
 247 {
 248   TAO::DynAnyBasicTypeUtils<CORBA::TypeCode_ptr>::insert_value (value, this);
 249 }
 250
 251 void
 252 TAO_DynCommon::insert_longlong (CORBA::LongLong value)
 253 {
 254   TAO::DynAnyBasicTypeUtils<CORBA::LongLong>::insert_value (value, this);
 255 }
 256
 257 void
 258 TAO_DynCommon::insert_ulonglong (CORBA::ULongLong value)
 259 {
 260   TAO::DynAnyBasicTypeUtils<CORBA::ULongLong>::insert_value (value, this);
 261 }
 262
 263 void
 264 TAO_DynCommon::insert_longdouble (CORBA::LongDouble value)
 265 {
 266   TAO::DynAnyBasicTypeUtils<CORBA::LongDouble>::insert_value (value,
 267                                                               this);
 268 }
 269
 270 void
 271 TAO_DynCommon::insert_wchar (CORBA::WChar value)
 272 {
 273   TAO::DynAnyBasicTypeUtils<CORBA::WChar>::insert_value (value,
 274                                                          this);
 275 }
 276
 277 void
 278 TAO_DynCommon::insert_wstring (const CORBA::WChar * value)
 279 {
 280   if (this->destroyed_)
 281     {
 282       throw ::CORBA::OBJECT_NOT_EXIST ();
 283     }
 284
 285   if (this->has_components_)
 286     {
 287       DynamicAny::DynAny_var cc =
 288         this->check_component ();
 289
 290       cc->insert_wstring (value);
 291     }
 292   else
 293     {
 294       CORBA::TypeCode_var unaliased_tc =
 295         this->check_type_and_unalias (CORBA::_tc_wstring);
 296
 297       CORBA::ULong const bound = unaliased_tc->length ();
 298
 299       if (bound > 0 && bound < ACE_OS::wslen (value))
 300         {
 301           throw DynamicAny::DynAny::InvalidValue ();
 302         }
 303
 304       this->any_ <<= CORBA::Any::from_wstring (const_cast<CORBA::WChar *> (value),
 305                                                bound);
 306     }
 307 }
 308
 309 void
 310 TAO_DynCommon::insert_any (const CORBA::Any &value)
 311 {
 312   TAO::DynAnyBasicTypeUtils<CORBA::Any>::insert_value (value,
 313                                                        this);
 314 }
 315
 316 // @@@ (JP) TODO - optimize - this version was intended by the OMG to
 317 // have fewer Any/DynAny conversions than insert_any, not more.
 318 void
 319 TAO_DynCommon::insert_dyn_any (DynamicAny::DynAny_ptr value)
 320 {
 321   if (this->destroyed_)
 322     {
 323       throw ::CORBA::OBJECT_NOT_EXIST ();
 324     }
 325
 326   CORBA::Any_var any = value->to_any ();
 327
 328   this->insert_any (any.in ());
 329 }
 330
 331 void
 332 TAO_DynCommon::insert_val (CORBA::ValueBase *value)
 333 {
 334   if (this->destroyed_)
 335     {
 336       throw ::CORBA::OBJECT_NOT_EXIST ();
 337     }
 338
 339   if (this->has_components_)
 340     {
 341       DynamicAny::DynAny_var cc =
 342         this->check_component (true);
 343
 344       cc->insert_val (value);
 345     }
 346   else
 347     {
 348       CORBA::TCKind kind =
 349         TAO_DynAnyFactory::unalias (this->type_.in ());
 350
 351       if (kind != CORBA::tk_value)
 352         {
 353           throw DynamicAny::DynAny::TypeMismatch ();
 354         }
 355
 356       // If the arg is 0 we can't do this kind of type checking,
 357       // and the call to _tao_marshal() below will handle the
 358       // null value correctly.
 359       if (value != 0)
 360         {
 361           const char *value_id = value->_tao_obv_repository_id ();
 362           const char *my_id =
 363             this->type_->id ();
 364
 365           // Valuetypes, unlike interfaces, don't have a virtual
 366           // method to check for a more derived type when the
 367           // repo ids don't match. Valuetypes have only
 368           // a static _downcast() method, which can't be used
 369           // here, so if the repo ids don't match, we're hosed.
 370           if (ACE_OS::strcmp (value_id, my_id) != 0)
 371             {
 372               throw DynamicAny::DynAny::TypeMismatch ();
 373             }
 374         }
 375
 376       // This will handle null values correctly, or otherwise
 377       // make a virtual call to marshal the state.
 378       TAO_OutputCDR out;
 379       CORBA::Boolean const good_insert =
 380         CORBA::ValueBase::_tao_marshal (out, value);
 381
 382       if (!good_insert)
 383         {
 384           throw DynamicAny::DynAny::InvalidValue ();
 385         }
 386
 387       TAO_InputCDR in (out);
 388       TAO::Unknown_IDL_Type *unk = 0;
 389       ACE_NEW (unk,
 390                TAO::Unknown_IDL_Type (this->type_.in (), in));
 391       this->any_.replace (unk);
 392     }
 393 }
 394
 395 // ****************************************************************
 396
 397 CORBA::Boolean
 398 TAO_DynCommon::get_boolean (void)
 399 {
 400   return TAO::DynAnyBasicTypeUtils<CORBA::Boolean>::get_value (this);
 401 }
 402
 403 CORBA::Octet
 404 TAO_DynCommon::get_octet (void)
 405 {
 406   return TAO::DynAnyBasicTypeUtils<CORBA::Octet>::get_value (this);
 407 }
 408
 409 CORBA::Char
 410 TAO_DynCommon::get_char (void)
 411 {
 412   return TAO::DynAnyBasicTypeUtils<CORBA::Char>::get_value (this);
 413 }
 414
 415 CORBA::Short
 416 TAO_DynCommon::get_short (void)
 417 {
 418   return TAO::DynAnyBasicTypeUtils<CORBA::Short>::get_value (this);
 419 }
 420
 421 CORBA::UShort
 422 TAO_DynCommon::get_ushort (void)
 423 {
 424   return TAO::DynAnyBasicTypeUtils<CORBA::UShort>::get_value (this);
 425 }
 426
 427 CORBA::Long
 428 TAO_DynCommon::get_long (void)
 429 {
 430   return TAO::DynAnyBasicTypeUtils<CORBA::Long>::get_value (this);
 431 }
 432
 433 CORBA::ULong
 434 TAO_DynCommon::get_ulong (void)
 435 {
 436   return TAO::DynAnyBasicTypeUtils<CORBA::ULong>::get_value (this);
 437 }
 438
 439 CORBA::Float
 440 TAO_DynCommon::get_float (void)
 441 {
 442   return TAO::DynAnyBasicTypeUtils<CORBA::Float>::get_value (this);
 443 }
 444
 445 CORBA::Double
 446 TAO_DynCommon::get_double (void)
 447 {
 448   return TAO::DynAnyBasicTypeUtils<CORBA::Double>::get_value (this);
 449 }
 450
 451 char *
 452 TAO_DynCommon::get_string (void)
 453 {
 454   if (this->destroyed_)
 455     {
 456       throw ::CORBA::OBJECT_NOT_EXIST ();
 457     }
 458
 459   if (this->has_components_)
 460     {
 461       DynamicAny::DynAny_var cc =
 462         this->check_component ();
 463
 464       return cc->get_string ();
 465     }
 466   else
 467     {
 468       CORBA::TypeCode_var unaliased_tc =
 469         TAO_DynAnyFactory::strip_alias (this->type_.in ());
 470
 471       CORBA::TCKind kind =
 472         unaliased_tc->kind ();
 473
 474       if (kind != CORBA::tk_string)
 475         {
 476           throw DynamicAny::DynAny::TypeMismatch ();
 477         }
 478
 479       char *retval = 0;
 480
 481       CORBA::ULong const bound =
 482         unaliased_tc->length ();
 483
 484       // We will have caught a type mismatch above, so if this fails,
 485       // it must be for some other reason.
 486       if ((this->any_ >>= CORBA::Any::to_string (retval, bound)) == 0)
 487         {
 488           throw DynamicAny::DynAny::InvalidValue ();
 489         }
 490
 491       return CORBA::string_dup (retval);
 492     }
 493 }
 494
 495 CORBA::Object_ptr
 496 TAO_DynCommon::get_reference (void)
 497 {
 498   if (this->destroyed_)
 499     {
 500       throw ::CORBA::OBJECT_NOT_EXIST ();
 501     }
 502
 503   if (this->has_components_)
 504     {
 505       DynamicAny::DynAny_var cc =
 506         this->check_component ();
 507
 508       return cc->get_reference ();
 509     }
 510   else
 511     {
 512       CORBA::Object_var retval;
 513
 514       if ((this->any_ >>= CORBA::Any::to_object (retval.inout ())) == 0)
 515         {
 516           throw DynamicAny::DynAny::TypeMismatch ();
 517         }
 518
 519       return retval._retn ();
 520     }
 521 }
 522
 523 CORBA::TypeCode_ptr
 524 TAO_DynCommon::get_typecode (void)
 525 {
 526   if (this->destroyed_)
 527     {
 528       throw ::CORBA::OBJECT_NOT_EXIST ();
 529     }
 530
 531   if (this->has_components_)
 532     {
 533       DynamicAny::DynAny_var cc = this->check_component ();
 534
 535       return cc->get_typecode ();
 536     }
 537   else
 538     {
 539       CORBA::TypeCode_ptr retval;
 540
 541       if ((this->any_ >>= retval) == 0)
 542         {
 543           throw DynamicAny::DynAny::TypeMismatch ();
 544         }
 545
 546       return CORBA::TypeCode::_duplicate (retval);
 547     }
 548 }
 549
 550 CORBA::LongLong
 551 TAO_DynCommon::get_longlong (void)
 552 {
 553   return TAO::DynAnyBasicTypeUtils<CORBA::LongLong>::get_value (this);
 554 }
 555
 556 CORBA::ULongLong
 557 TAO_DynCommon::get_ulonglong (void)
 558 {
 559   return TAO::DynAnyBasicTypeUtils<CORBA::ULongLong>::get_value (this);
 560 }
 561
 562 CORBA::LongDouble
 563 TAO_DynCommon::get_longdouble (void)
 564 {
 565   return TAO::DynAnyBasicTypeUtils<CORBA::LongDouble>::get_value (this);
 566 }
 567
 568 CORBA::WChar
 569 TAO_DynCommon::get_wchar (void)
 570 {
 571   if (this->destroyed_)
 572     {
 573       throw ::CORBA::OBJECT_NOT_EXIST ();
 574     }
 575
 576   if (this->has_components_)
 577     {
 578       DynamicAny::DynAny_var cc = this->check_component ();
 579
 580       return cc->get_wchar ();
 581     }
 582   else
 583     {
 584       CORBA::WChar retval;
 585
 586       if ((this->any_ >>= CORBA::Any::to_wchar (retval)) == 0)
 587         {
 588           throw DynamicAny::DynAny::TypeMismatch ();
 589         }
 590
 591       return retval;
 592     }
 593 }
 594
 595 CORBA::WChar *
 596 TAO_DynCommon::get_wstring (void)
 597 {
 598   if (this->destroyed_)
 599     {
 600       throw ::CORBA::OBJECT_NOT_EXIST ();
 601     }
 602
 603   if (this->has_components_)
 604     {
 605       DynamicAny::DynAny_var cc =
 606         this->check_component ();
 607
 608       return cc->get_wstring ();
 609     }
 610   else
 611     {
 612       // @@@ (JP) Someday try to find a way to avoid checking for
 613       // type code equivalence twice without risking a throw of
 614       // BadKind.
 615       CORBA::TypeCode_var unaliased_tc =
 616         this->check_type_and_unalias (CORBA::_tc_wstring);
 617
 618       CORBA::WChar *retval = 0;
 619
 620       CORBA::ULong bound =
 621         unaliased_tc->length ();
 622
 623       (void) (this->any_ >>= CORBA::Any::to_wstring (retval, bound));
 624
 625       return CORBA::wstring_dup (retval);
 626     }
 627 }
 628
 629 CORBA::Any_ptr
 630 TAO_DynCommon::get_any (void)
 631 {
 632   if (this->destroyed_)
 633     {
 634       throw ::CORBA::OBJECT_NOT_EXIST ();
 635     }
 636
 637   if (this->has_components_)
 638     {
 639       DynamicAny::DynAny_var cc =
 640         this->check_component ();
 641
 642       return cc->get_any ();
 643     }
 644   else
 645     {
 646       const CORBA::Any *tmp = 0;
 647
 648       if ((this->any_ >>= tmp) == 0)
 649         {
 650           throw DynamicAny::DynAny::TypeMismatch ();
 651         }
 652
 653       CORBA::Any *retval = 0;
 654       ACE_NEW_RETURN (retval,
 655                       CORBA::Any (*tmp),
 656                       0);
 657       return retval;
 658     }
 659 }
 660
 661 // @@@ (JP) TODO - optimize - this version was intended by the OMG to
 662 // have fewer Any/DynAny conversions than get_any, not more.
 663 DynamicAny::DynAny_ptr
 664 TAO_DynCommon::get_dyn_any (void)
 665 {
 666   if (this->destroyed_)
 667     {
 668       throw ::CORBA::OBJECT_NOT_EXIST ();
 669     }
 670
 671   CORBA::Any_var any = this->get_any ();
 672
 673   return
 674     TAO::MakeDynAnyUtils::make_dyn_any_t<const CORBA::Any&> (
 675       any.in ()._tao_get_typecode (),
 676       any.in (),
 677       this->allow_truncation_ );
 678 }
 679
 680 CORBA::ValueBase *
 681 TAO_DynCommon::get_val (void)
 682 {
 683   if (this->destroyed_)
 684     {
 685       throw ::CORBA::OBJECT_NOT_EXIST ();
 686     }
 687
 688   if (this->has_components_)
 689     {
 690       DynamicAny::DynAny_var cc =
 691         this->check_component (true);
 692
 693       return cc->get_val ();
 694     }
 695   else
 696     {
 697       CORBA::TCKind kind =
 698         TAO_DynAnyFactory::unalias (this->type_.in ());
 699
 700       if (kind != CORBA::tk_value)
 701         {
 702           throw DynamicAny::DynAny::TypeMismatch ();
 703         }
 704
 705       CORBA::ValueBase_var retval;
 706       TAO::Any_Impl *any_impl = this->any_.impl ();
 707
 708       if (any_impl == 0)
 709         {
 710           throw DynamicAny::DynAny::InvalidValue ();
 711         }
 712
 713       // This should always be non-zero for dynamic anys.
 714       TAO::Unknown_IDL_Type *unk =
 715         dynamic_cast<TAO::Unknown_IDL_Type *> (any_impl);
 716
 717       // Demarshal from a copy so we can retain ownership of our contents.
 718       TAO_InputCDR for_reading (unk->_tao_get_cdr ());
 719
 720       CORBA::Boolean good_extract =
 721         CORBA::ValueBase::_tao_unmarshal (for_reading,
 722                                           retval.inout ());
 723
 724       if (!good_extract)
 725         {
 726           throw DynamicAny::DynAny::InvalidValue ();
 727         }
 728
 729       return retval._retn ();
 730     }
 731 }
 732
 733 // ****************************************************************
 734
 735 CORBA::Boolean
 736 TAO_DynCommon::seek (CORBA::Long slot)
 737 {
 738   if (this->destroyed_)
 739     {
 740       throw ::CORBA::OBJECT_NOT_EXIST ();
 741     }
 742
 743   if (this->has_components_ == 0)
 744     {
 745       ACE_UNUSED_ARG (slot);
 746       this->current_position_ = -1;
 747       return false;
 748     }
 749   else if (slot < 0 || slot >= static_cast<CORBA::Long> (this->component_count_))
 750     {
 751       this->current_position_ = -1;
 752       return false;
 753     }
 754   else
 755     {
 756       this->current_position_ = slot;
 757       return true;
 758     }
 759 }
 760
 761 void
 762 TAO_DynCommon::rewind (void)
 763 {
 764   if (this->destroyed_)
 765     {
 766       throw ::CORBA::OBJECT_NOT_EXIST ();
 767     }
 768
 769   (void) this->seek (0);
 770 }
 771
 772 CORBA::Boolean
 773 TAO_DynCommon::next (void)
 774 {
 775   if (this->destroyed_)
 776     {
 777       throw ::CORBA::OBJECT_NOT_EXIST ();
 778     }
 779
 780   CORBA::Long component_count = static_cast<CORBA::Long> (this->component_count_);
 781
 782   if (this->has_components_ == 0
 783       || this->current_position_ + 1 >= component_count)
 784     {
 785       this->current_position_ = -1;
 786       return false;
 787     }
 788   else
 789     {
 790       ++this->current_position_;
 791       return true;
 792     }
 793 }
 794
 795 DynamicAny::DynAny_ptr
 796 TAO_DynCommon::copy (void)
 797 {
 798   if (this->destroyed_)
 799     {
 800       throw ::CORBA::OBJECT_NOT_EXIST ();
 801     }
 802
 803   CORBA::Any_var any = this->to_any ();
 804
 805   DynamicAny::DynAny_ptr retval =
 806     TAO::MakeDynAnyUtils::make_dyn_any_t<const CORBA::Any&> (
 807       any.in ()._tao_get_typecode (),
 808       any.in (),
 809       this->allow_truncation_ );
 810
 811   return retval;
 812 }
 813
 814 CORBA::ULong
 815 TAO_DynCommon::component_count (void)
 816 {
 817   if (this->destroyed_)
 818     {
 819       throw ::CORBA::OBJECT_NOT_EXIST ();
 820     }
 821
 822   return this->component_count_;
 823 }
 824
 825 // ****************************************************************
 826
 827 void
 828 TAO_DynCommon::insert_abstract (CORBA::AbstractBase_ptr value)
 829 {
 830   if (this->destroyed_)
 831     {
 832       throw ::CORBA::OBJECT_NOT_EXIST ();
 833     }
 834
 835   if (this->has_components_)
 836     {
 837       DynamicAny::DynAny_var cc =
 838         this->check_component ();
 839
 840       cc->insert_abstract (value);
 841     }
 842   else
 843     {
 844       CORBA::Boolean good_type = true;
 845       CORBA::TCKind kind =
 846         TAO_DynAnyFactory::unalias (this->type_.in ());
 847
 848       if (kind != CORBA::tk_abstract_interface)
 849         {
 850           good_type = false;
 851         }
 852       else if (!CORBA::is_nil (value))
 853         {
 854           const char *value_id = value->_interface_repository_id ();
 855           int cmp =
 856             ACE_OS::strcmp (value_id, "IDL:omg.org/CORBA/AbstractBase:1.0");
 857
 858           if (cmp != 0)
 859             {
 860               const char *my_id =
 861                 this->type_->id ();
 862
 863               if (ACE_OS::strcmp (value_id, my_id) != 0)
 864                 {
 865                   // If 'value' is an objref, this will be a virtual
 866                   // call. If not, it will just compare to the repo id
 867                   // above, which we already know won't match. We see
 868                   // in insert_val() (see comment there) that there
 869                   // is no way to check for derived valuetypes w/o
 870                   // type knowledge at compile time.
 871                   good_type = value->_is_a (my_id);
 872                 }
 873             }
 874         }
 875
 876       if (good_type)
 877         {
 878           TAO_OutputCDR out;
 879
 880           // The CDR insertion operator for AbstractBase handles
 881           // all cases - nil, objref and valuetype - polymorphically.
 882           if (!(out << value))
 883             {
 884               throw DynamicAny::DynAny::InvalidValue ();
 885             }
 886
 887           TAO_InputCDR in (out);
 888           TAO::Unknown_IDL_Type *unk = 0;
 889           ACE_NEW (unk,
 890                    TAO::Unknown_IDL_Type (this->type_.in (), in));
 891           this->any_.replace (unk);
 892         }
 893       else
 894         {
 895           throw DynamicAny::DynAny::TypeMismatch ();
 896         }
 897     }
 898 }
 899
 900 CORBA::AbstractBase_ptr
 901 TAO_DynCommon::get_abstract (void)
 902 {
 903   if (this->destroyed_)
 904     {
 905       throw ::CORBA::OBJECT_NOT_EXIST ();
 906     }
 907
 908   if (this->has_components_)
 909     {
 910       DynamicAny::DynAny_var cc =
 911         this->check_component ();
 912
 913       return cc->get_abstract ();
 914     }
 915   else
 916     {
 917       CORBA::TCKind kind =
 918         TAO_DynAnyFactory::unalias (this->type_.in ());
 919
 920       if (kind != CORBA::tk_abstract_interface)
 921         {
 922           throw DynamicAny::DynAny::TypeMismatch ();
 923         }
 924
 925       CORBA::AbstractBase_var retval;
 926       TAO::Any_Impl *any_impl = this->any_.impl ();
 927
 928       if (any_impl == 0)
 929         {
 930           throw DynamicAny::DynAny::InvalidValue ();
 931         }
 932
 933       // This should always be non-zero for dynamic anys.
 934       TAO::Unknown_IDL_Type *unk =
 935         dynamic_cast<TAO::Unknown_IDL_Type *> (any_impl);
 936
 937       // Make a copy to extract from so we retain ownership of contents.
 938       TAO_InputCDR for_reading (unk->_tao_get_cdr ());
 939
 940       // The CDR extraction operator for AbstractBase handles
 941       // all cases.
 942       if (!(for_reading >> retval.inout ()))
 943         {
 944           throw DynamicAny::DynAny::InvalidValue ();
 945         }
 946
 947       return retval._retn ();
 948     }
 949 }
 950
 951 // ****************************************************************
 952
 953 void
 954 TAO_DynCommon::insert_boolean_seq (const CORBA::BooleanSeq &value)
 955 {
 956   TAO::DynAnyBasicTypeUtils<CORBA::BooleanSeq>::insert_value (value, this);
 957 }
 958
 959 void
 960 TAO_DynCommon::insert_octet_seq (const CORBA::OctetSeq &value)
 961 {
 962   TAO::DynAnyBasicTypeUtils<CORBA::OctetSeq>::insert_value (value, this);
 963 }
 964
 965 void
 966 TAO_DynCommon::insert_char_seq (const CORBA::CharSeq &value)
 967 {
 968   TAO::DynAnyBasicTypeUtils<CORBA::CharSeq>::insert_value (value, this);
 969 }
 970
 971 void
 972 TAO_DynCommon::insert_short_seq (const CORBA::ShortSeq &value)
 973 {
 974   TAO::DynAnyBasicTypeUtils<CORBA::ShortSeq>::insert_value (value, this);
 975 }
 976
 977 void
 978 TAO_DynCommon::insert_ushort_seq (const CORBA::UShortSeq &value)
 979 {
 980   TAO::DynAnyBasicTypeUtils<CORBA::UShortSeq>::insert_value (value, this);
 981 }
 982
 983 void
 984 TAO_DynCommon::insert_long_seq (const CORBA::LongSeq &value)
 985 {
 986   TAO::DynAnyBasicTypeUtils<CORBA::LongSeq>::insert_value (value, this);
 987 }
 988
 989 void
 990 TAO_DynCommon::insert_ulong_seq (const CORBA::ULongSeq &value)
 991 {
 992   TAO::DynAnyBasicTypeUtils<CORBA::ULongSeq>::insert_value (value, this);
 993 }
 994
 995 void
 996 TAO_DynCommon::insert_float_seq (const CORBA::FloatSeq &value)
 997 {
 998   TAO::DynAnyBasicTypeUtils<CORBA::FloatSeq>::insert_value (value, this);
 999 }
1000
1001 void
1002 TAO_DynCommon::insert_double_seq (const CORBA::DoubleSeq &value)
1003 {
1004   TAO::DynAnyBasicTypeUtils<CORBA::DoubleSeq>::insert_value (value, this);
1005 }
1006
1007 void
1008 TAO_DynCommon::insert_longlong_seq (const CORBA::LongLongSeq &value)
1009 {
1010   TAO::DynAnyBasicTypeUtils<CORBA::LongLongSeq>::insert_value (value, this);
1011 }
1012
1013 void
1014 TAO_DynCommon::insert_ulonglong_seq (const CORBA::ULongLongSeq &value)
1015 {
1016   TAO::DynAnyBasicTypeUtils<CORBA::ULongLongSeq>::insert_value (value, this);
1017 }
1018
1019 void
1020 TAO_DynCommon::insert_longdouble_seq (const CORBA::LongDoubleSeq &value)
1021 {
1022   TAO::DynAnyBasicTypeUtils<CORBA::LongDoubleSeq>::insert_value (value, this);
1023 }
1024
1025 void
1026 TAO_DynCommon::insert_wchar_seq (const CORBA::WCharSeq &value)
1027 {
1028   TAO::DynAnyBasicTypeUtils<CORBA::WCharSeq>::insert_value (value, this);
1029 }
1030
1031 // ****************************************************************
1032
1033 CORBA::BooleanSeq *
1034 TAO_DynCommon::get_boolean_seq (void)
1035 {
1036   const CORBA::BooleanSeq *owned =
1037     TAO::DynAnyBasicTypeUtils<CORBA::BooleanSeq>::get_value (this);
1038   return new CORBA::BooleanSeq (*owned);
1039 }
1040
1041 CORBA::OctetSeq *
1042 TAO_DynCommon::get_octet_seq (void)
1043 {
1044   const CORBA::OctetSeq *owned =
1045     TAO::DynAnyBasicTypeUtils<CORBA::OctetSeq>::get_value (this);
1046   return new CORBA::OctetSeq (*owned);
1047 }
1048
1049 CORBA::CharSeq *
1050 TAO_DynCommon::get_char_seq (void)
1051 {
1052   const CORBA::CharSeq *owned =
1053     TAO::DynAnyBasicTypeUtils<CORBA::CharSeq>::get_value (this);
1054   return new CORBA::CharSeq (*owned);
1055 }
1056
1057 CORBA::ShortSeq *
1058 TAO_DynCommon::get_short_seq (void)
1059 {
1060   const CORBA::ShortSeq *owned =
1061     TAO::DynAnyBasicTypeUtils<CORBA::ShortSeq>::get_value (this);
1062   return new CORBA::ShortSeq (*owned);
1063 }
1064
1065 CORBA::UShortSeq *
1066 TAO_DynCommon::get_ushort_seq (void)
1067 {
1068   const CORBA::UShortSeq *owned =
1069     TAO::DynAnyBasicTypeUtils<CORBA::UShortSeq>::get_value (this);
1070   return new CORBA::UShortSeq (*owned);
1071 }
1072
1073 CORBA::LongSeq *
1074 TAO_DynCommon::get_long_seq (void)
1075 {
1076   const CORBA::LongSeq *owned =
1077     TAO::DynAnyBasicTypeUtils<CORBA::LongSeq>::get_value (this);
1078   return new CORBA::LongSeq (*owned);
1079 }
1080
1081 CORBA::ULongSeq *
1082 TAO_DynCommon::get_ulong_seq (void)
1083 {
1084   const CORBA::ULongSeq *owned =
1085     TAO::DynAnyBasicTypeUtils<CORBA::ULongSeq>::get_value (this);
1086   return new CORBA::ULongSeq (*owned);
1087 }
1088
1089 CORBA::FloatSeq *
1090 TAO_DynCommon::get_float_seq (void)
1091 {
1092   const CORBA::FloatSeq *owned =
1093     TAO::DynAnyBasicTypeUtils<CORBA::FloatSeq>::get_value (this);
1094   return new CORBA::FloatSeq (*owned);
1095 }
1096
1097 CORBA::DoubleSeq *
1098 TAO_DynCommon::get_double_seq (void)
1099 {
1100   const CORBA::DoubleSeq *owned =
1101     TAO::DynAnyBasicTypeUtils<CORBA::DoubleSeq>::get_value (this);
1102   return new CORBA::DoubleSeq (*owned);
1103 }
1104
1105 CORBA::LongLongSeq *
1106 TAO_DynCommon::get_longlong_seq (void)
1107 {
1108   const CORBA::LongLongSeq *owned =
1109     TAO::DynAnyBasicTypeUtils<CORBA::LongLongSeq>::get_value (this);
1110   return new CORBA::LongLongSeq (*owned);
1111 }
1112
1113 CORBA::ULongLongSeq *
1114 TAO_DynCommon::get_ulonglong_seq (void)
1115 {
1116   const CORBA::ULongLongSeq *owned =
1117     TAO::DynAnyBasicTypeUtils<CORBA::ULongLongSeq>::get_value (this);
1118   return new CORBA::ULongLongSeq (*owned);
1119 }
1120
1121 CORBA::LongDoubleSeq *
1122 TAO_DynCommon::get_longdouble_seq (void)
1123 {
1124   const CORBA::LongDoubleSeq *owned =
1125     TAO::DynAnyBasicTypeUtils<CORBA::LongDoubleSeq>::get_value (this);
1126   return new CORBA::LongDoubleSeq (*owned);
1127 }
1128
1129 CORBA::WCharSeq *
1130 TAO_DynCommon::get_wchar_seq (void)
1131 {
1132   const CORBA::WCharSeq *owned =
1133     TAO::DynAnyBasicTypeUtils<CORBA::WCharSeq>::get_value (this);
1134   return new CORBA::WCharSeq (*owned);
1135 }
1136
1137 // ****************************************************************
1138
1139 void
1140 TAO_DynCommon::set_flag (DynamicAny::DynAny_ptr component,
1141                          CORBA::Boolean destroying)
1142 {
1143   CORBA::TypeCode_var tc = component->type ();
1144
1145   CORBA::TCKind tk = TAO_DynAnyFactory::unalias (tc.in ());
1146
1147   switch (tk)
1148   {
1149     case CORBA::tk_array:
1150       TAO::DynAnyFlagUtils<TAO_DynArray_i>::set_flag_t (component,
1151                                                         destroying);
1152       break;
1153     case CORBA::tk_enum:
1154       TAO::DynAnyFlagUtils<TAO_DynEnum_i>::set_flag_t (component,
1155                                                        destroying);
1156       break;
1157     case CORBA::tk_sequence:
1158       if (TAO_DynCommon::is_basic_type_seq (tc.in ()))
1159         {
1160           TAO::DynAnyFlagUtils<TAO_DynAny_i>::set_flag_t (component,
1161                                                           destroying);
1162         }
1163       else
1164         {
1165           TAO::DynAnyFlagUtils<TAO_DynSequence_i>::set_flag_t (component,
1166                                                                destroying);
1167         }
1168       break;
1169     case CORBA::tk_struct:
1170       TAO::DynAnyFlagUtils<TAO_DynStruct_i>::set_flag_t (component,
1171                                                          destroying);
1172       break;
1173     case CORBA::tk_union:
1174       TAO::DynAnyFlagUtils<TAO_DynUnion_i>::set_flag_t (component,
1175                                                         destroying);
1176       break;
1177     case CORBA::tk_value:
1178       TAO::DynAnyFlagUtils<TAO_DynValue_i>::set_flag_t (component,
1179                                                         destroying);
1180       break;
1181     case CORBA::tk_value_box:
1182       TAO::DynAnyFlagUtils<TAO_DynValueBox_i>::set_flag_t (component,
1183                                                            destroying);
1184       break;
1185     case CORBA::tk_fixed:
1186       throw ::CORBA::NO_IMPLEMENT ();
1187     default:
1188       TAO::DynAnyFlagUtils<TAO_DynAny_i>::set_flag_t (component,
1189                                                       destroying);
1190       break;
1191   }
1192 }
1193
1194 DynamicAny::DynAny_ptr
1195 TAO_DynCommon::check_component (CORBA::Boolean isValueType)
1196 {
1197   if (this->current_position_ == -1)
1198     {
1199       throw DynamicAny::DynAny::InvalidValue ();
1200     }
1201
1202   DynamicAny::DynAny_var cc =
1203     this->current_component ();
1204
1205   CORBA::TypeCode_var tc = cc->type ();
1206
1207   // We are here because we are a component that is the target of
1208   // an insert_*() call on our container. It is
1209   // illegal to insert anything into a component that itself has
1210   // components.
1211   switch (TAO_DynAnyFactory::unalias (tc.in ()))
1212     {
1213     case CORBA::tk_array:
1214     case CORBA::tk_except:
1215     case CORBA::tk_struct:
1216     case CORBA::tk_union:
1217       throw DynamicAny::DynAny::TypeMismatch ();
1218
1219     case CORBA::tk_value:
1220       if (!isValueType)
1221         {
1222           throw DynamicAny::DynAny::TypeMismatch ();
1223         }
1224       break;
1225
1226     case CORBA::tk_sequence:
1227       if (!TAO_DynCommon::is_basic_type_seq (tc.in ()))
1228         {
1229           throw DynamicAny::DynAny::TypeMismatch ();
1230         }
1231       break;
1232
1233     default:
1234       break;
1235     }
1236
1237   return cc._retn ();
1238 }
1239
1240 void
1241 TAO_DynCommon::check_type (CORBA::TypeCode_ptr tc)
1242 {
1243   CORBA::Boolean const equivalent =
1244     this->type_->equivalent (tc);
1245
1246   if (!equivalent)
1247     {
1248       throw DynamicAny::DynAny::TypeMismatch ();
1249     }
1250 }
1251
1252 bool
1253 TAO_DynCommon::is_basic_type_seq (CORBA::TypeCode_ptr tc)
1254 {
1255   return (tc->equal (CORBA::_tc_BooleanSeq)
1256           || tc->equal (CORBA::_tc_OctetSeq)
1257           || tc->equal (CORBA::_tc_CharSeq)
1258           || tc->equal (CORBA::_tc_WCharSeq)
1259           || tc->equal (CORBA::_tc_ShortSeq)
1260           || tc->equal (CORBA::_tc_UShortSeq)
1261           || tc->equal (CORBA::_tc_LongSeq)
1262           || tc->equal (CORBA::_tc_ULongSeq)
1263           || tc->equal (CORBA::_tc_LongLongSeq)
1264           || tc->equal (CORBA::_tc_ULongLongSeq)
1265           || tc->equal (CORBA::_tc_FloatSeq)
1266           || tc->equal (CORBA::_tc_DoubleSeq)
1267           || tc->equal (CORBA::_tc_LongDoubleSeq));
1268 }
1269
1270 CORBA::Boolean
1271 TAO_DynCommon::has_components (void) const
1272 {
1273   return this->has_components_;
1274 }
1275
1276 CORBA::Boolean
1277 TAO_DynCommon::destroyed (void) const
1278 {
1279   return this->destroyed_;
1280 }
1281
1282 CORBA::Any &
1283 TAO_DynCommon::the_any (void)
1284 {
1285   return this->any_;
1286 }
1287
1288 void
1289 TAO_DynCommon::container_is_destroying (CORBA::Boolean val)
1290 {
1291   this->container_is_destroying_ = val;
1292 }
1293
1294 void
1295 TAO_DynCommon::ref_to_component (CORBA::Boolean val)
1296 {
1297   this->ref_to_component_ = val;
1298 }
1299
1300 CORBA::TypeCode_ptr
1301 TAO_DynCommon::check_type_and_unalias (CORBA::TypeCode_ptr tc)
1302 {
1303   this->check_type (tc);
1304
1305   return TAO_DynAnyFactory::strip_alias (tc);
1306 }
1307
1308 TAO_END_VERSIONED_NAMESPACE_DECL