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