TAO/tao/DynamicAny/DynAny_i.cpp

   1 // -*- C++ -*-
   2 #include "tao/AnyTypeCode/TypeCode.h"
   3 #include "tao/AnyTypeCode/Any_Unknown_IDL_Type.h"
   4 #include "tao/AnyTypeCode/AnyTypeCode_methods.h"
   5
   6 #include "tao/DynamicAny/DynAny_i.h"
   7 #include "tao/DynamicAny/DynAnyFactory.h"
   8
   9 #include "tao/DynamicAny/DynAnyUtils_T.h"
  10
  11 #include "tao/CDR.h"
  12
  13 #include "ace/OS_NS_wchar.h"
  14 #include "ace/OS_NS_string.h"
  15
  16 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
  17
  18 TAO_DynAny_i::TAO_DynAny_i (CORBA::Boolean allow_truncation)
  19   : TAO_DynCommon (allow_truncation)
  20 {
  21 }
  22
  23 TAO_DynAny_i::~TAO_DynAny_i ()
  24 {
  25 }
  26
  27 void
  28 TAO_DynAny_i::check_typecode (CORBA::TypeCode_ptr tc)
  29 {
  30   // Check to see if it's a simple type.
  31   CORBA::TCKind tk = TAO_DynAnyFactory::unalias (tc);
  32
  33   switch (tk)
  34   {
  35     case CORBA::tk_null:
  36     case CORBA::tk_void:
  37     case CORBA::tk_short:
  38     case CORBA::tk_long:
  39     case CORBA::tk_ushort:
  40     case CORBA::tk_ulong:
  41     case CORBA::tk_float:
  42     case CORBA::tk_double:
  43     case CORBA::tk_longlong:
  44     case CORBA::tk_ulonglong:
  45     case CORBA::tk_boolean:
  46     case CORBA::tk_char:
  47     case CORBA::tk_wchar:
  48     case CORBA::tk_octet:
  49     case CORBA::tk_any:
  50     case CORBA::tk_TypeCode:
  51     case CORBA::tk_objref:
  52     case CORBA::tk_string:
  53     case CORBA::tk_wstring:
  54     case CORBA::tk_longdouble:
  55       break;
  56     case CORBA::tk_sequence:
  57       if (tc->equivalent (CORBA::_tc_BooleanSeq)
  58         || tc->equivalent (CORBA::_tc_OctetSeq)
  59         || tc->equivalent (CORBA::_tc_CharSeq)
  60         || tc->equivalent (CORBA::_tc_WCharSeq)
  61         || tc->equivalent (CORBA::_tc_ShortSeq)
  62         || tc->equivalent (CORBA::_tc_UShortSeq)
  63         || tc->equivalent (CORBA::_tc_LongSeq)
  64         || tc->equivalent (CORBA::_tc_ULongSeq)
  65         || tc->equivalent (CORBA::_tc_LongLongSeq)
  66         || tc->equivalent (CORBA::_tc_ULongLongSeq)
  67         || tc->equivalent (CORBA::_tc_FloatSeq)
  68         || tc->equivalent (CORBA::_tc_DoubleSeq)
  69         || tc->equivalent (CORBA::_tc_LongDoubleSeq))
  70         {
  71           // Otherwise fall through.
  72           break;
  73         }
  74       ACE_FALLTHROUGH;
  75     default:
  76       throw DynamicAny::DynAnyFactory::InconsistentTypeCode ();
  77   }
  78 }
  79
  80 void
  81 TAO_DynAny_i::set_to_default_value (CORBA::TypeCode_ptr tc)
  82 {
  83   CORBA::TCKind tk = TAO_DynAnyFactory::unalias (tc);
  84
  85   switch (tk)
  86   {
  87     case CORBA::tk_null:
  88       break;
  89     case CORBA::tk_void:
  90       this->any_._tao_set_typecode (CORBA::_tc_void);
  91       break;
  92     case CORBA::tk_short:
  93       this->any_ <<= static_cast<CORBA::Short> (0);
  94       break;
  95     case CORBA::tk_long:
  96       this->any_ <<= static_cast<CORBA::Long> (0);
  97       break;
  98     case CORBA::tk_ushort:
  99       this->any_ <<= static_cast<CORBA::UShort> (0);
 100       break;
 101     case CORBA::tk_ulong:
 102       this->any_ <<= static_cast<CORBA::ULong> (0);
 103       break;
 104     case CORBA::tk_longlong:
 105       this->any_ <<= static_cast<CORBA::LongLong> (0);
 106       break;
 107     case CORBA::tk_ulonglong:
 108       this->any_ <<= static_cast<CORBA::ULongLong> (0);
 109       break;
 110     case CORBA::tk_boolean:
 111       this->any_ <<= CORBA::Any::from_boolean (0);
 112       break;
 113     case CORBA::tk_octet:
 114       this->any_ <<= CORBA::Any::from_octet (0);
 115       break;
 116     case CORBA::tk_char:
 117       this->any_ <<= CORBA::Any::from_char (0);
 118       break;
 119     case CORBA::tk_wchar:
 120       this->any_ <<= CORBA::Any::from_wchar (0);
 121       break;
 122     case CORBA::tk_float:
 123       this->any_ <<= static_cast<CORBA::Float> (0);
 124       break;
 125     case CORBA::tk_double:
 126       this->any_ <<= static_cast<CORBA::Double> (0);
 127       break;
 128     case CORBA::tk_longdouble:
 129       {
 130         CORBA::LongDouble temp = ACE_CDR_LONG_DOUBLE_INITIALIZER;
 131         this->any_ <<= temp;
 132         break;
 133       }
 134     case CORBA::tk_any:
 135       this->any_._tao_set_typecode (CORBA::_tc_null);
 136       break;
 137     case CORBA::tk_TypeCode:
 138       this->any_ <<= CORBA::_tc_null;
 139       break;
 140     case CORBA::tk_objref:
 141       {
 142         TAO_OutputCDR stream;
 143         stream << CORBA::Object::_nil ();
 144         TAO_InputCDR in (stream);
 145         TAO::Unknown_IDL_Type *unk = 0;
 146         ACE_NEW (unk,
 147                  TAO::Unknown_IDL_Type (tc, in));
 148         this->any_.replace (unk);
 149         break;
 150       }
 151     case CORBA::tk_string:
 152       this->any_ <<= "";
 153       break;
 154     case CORBA::tk_wstring:
 155       {
 156         CORBA::WChar wstr[1];
 157         wstr[0] = 0;
 158         this->any_ <<= wstr;
 159         break;
 160       }
 161     default:
 162       // Should never get here - check_typecode() has already been called.
 163       break;
 164   }
 165 }
 166
 167 void
 168 TAO_DynAny_i::init_common ()
 169 {
 170   this->ref_to_component_ = false;
 171   this->container_is_destroying_ = false;
 172   this->has_components_ = false;
 173   this->destroyed_ = false;
 174   this->current_position_ = -1;
 175   this->component_count_ = 0;
 176 }
 177
 178 void
 179 TAO_DynAny_i::init (CORBA::TypeCode_ptr tc)
 180 {
 181   this->check_typecode (tc);
 182
 183   this->set_to_default_value (tc);
 184
 185   this->init_common ();
 186
 187   this->type_ = CORBA::TypeCode::_duplicate (tc);
 188 }
 189
 190 void
 191 TAO_DynAny_i::init (const CORBA::Any& any)
 192 {
 193   this->type_ = any.type ();
 194   this->check_typecode (this->type_.in ());
 195
 196   this->init_common ();
 197
 198   this->any_ = any;
 199 }
 200
 201 // ****************************************************************
 202
 203 TAO_DynAny_i *
 204 TAO_DynAny_i::_narrow (CORBA::Object_ptr _tao_objref)
 205 {
 206   if (CORBA::is_nil (_tao_objref))
 207     {
 208       return 0;
 209     }
 210
 211   return dynamic_cast<TAO_DynAny_i *> (_tao_objref);
 212 }
 213
 214 // ****************************************************************
 215
 216 void
 217 TAO_DynAny_i::from_any (const CORBA::Any &any)
 218 {
 219   if (this->destroyed_)
 220     {
 221       throw ::CORBA::OBJECT_NOT_EXIST ();
 222     }
 223
 224   CORBA::TypeCode_var any_tc = any.type ();
 225
 226   if (!this->type_->equivalent (any_tc.in ()))
 227     {
 228       throw DynamicAny::DynAny::TypeMismatch ();
 229     }
 230
 231 // @@@ (JP) Spec also says we should check for illegal Any
 232 // value here, and throw InvalidValue if we find one.
 233 // Something like a null string will be caught in the constructor.
 234
 235   this->any_ = any;
 236 }
 237
 238 CORBA::Any_ptr
 239 TAO_DynAny_i::to_any ()
 240 {
 241   if (this->destroyed_)
 242     {
 243       throw ::CORBA::OBJECT_NOT_EXIST ();
 244     }
 245
 246   CORBA::Any_ptr retval;
 247
 248   ACE_NEW_THROW_EX (retval,
 249                     CORBA::Any (this->any_),
 250                     CORBA::NO_MEMORY ());
 251
 252   return retval;
 253 }
 254
 255 CORBA::Boolean
 256 TAO_DynAny_i::equal (DynamicAny::DynAny_ptr rhs)
 257 {
 258   if (this->destroyed_)
 259     {
 260       throw ::CORBA::OBJECT_NOT_EXIST ();
 261     }
 262
 263   TAO_DynAny_i *rhs_n = TAO_DynAny_i::_narrow (rhs);
 264
 265   if (rhs_n == 0)
 266     {
 267       return false;
 268     }
 269
 270   if (!this->type_->equivalent (rhs_n->type_.in ()))
 271     {
 272       return false;
 273     }
 274
 275   CORBA::TCKind tk = TAO_DynAnyFactory::unalias (this->type_.in ());
 276
 277   switch (tk)
 278     {
 279     case CORBA::tk_null:
 280     case CORBA::tk_void:
 281       return true;
 282     case CORBA::tk_short:
 283       {
 284         CORBA::Short rhs_v;
 285         rhs_n->any_ >>= rhs_v;
 286         CORBA::Short lhs_v;
 287         this->any_ >>= lhs_v;
 288         return (lhs_v == rhs_v);
 289       }
 290     case CORBA::tk_long:
 291       {
 292         CORBA::Long rhs_v;
 293         rhs_n->any_ >>= rhs_v;
 294         CORBA::Long lhs_v;
 295         this->any_ >>= lhs_v;
 296         return (lhs_v == rhs_v);
 297       }
 298     case CORBA::tk_ushort:
 299       {
 300         CORBA::UShort rhs_v;
 301         rhs_n->any_ >>= rhs_v;
 302         CORBA::UShort lhs_v;
 303         this->any_ >>= lhs_v;
 304         return (lhs_v == rhs_v);
 305       }
 306     case CORBA::tk_ulong:
 307       {
 308         CORBA::ULong rhs_v;
 309         rhs_n->any_ >>= rhs_v;
 310         CORBA::ULong lhs_v;
 311         this->any_ >>= lhs_v;
 312         return (lhs_v == rhs_v);
 313       }
 314     case CORBA::tk_float:
 315       {
 316         CORBA::Float rhs_v;
 317         rhs_n->any_ >>= rhs_v;
 318         CORBA::Float lhs_v;
 319         this->any_ >>= lhs_v;
 320         return ACE::is_equal (lhs_v, rhs_v);
 321       }
 322     case CORBA::tk_double:
 323       {
 324         CORBA::Double rhs_v;
 325         rhs_n->any_ >>= rhs_v;
 326         CORBA::Double lhs_v;
 327         this->any_ >>= lhs_v;
 328         return ACE::is_equal (lhs_v, rhs_v);
 329       }
 330     case CORBA::tk_longdouble:
 331       {
 332         CORBA::LongDouble rhs_v;
 333         rhs_n->any_ >>= rhs_v;
 334         CORBA::LongDouble lhs_v;
 335         this->any_ >>= lhs_v;
 336         return ACE::is_equal (lhs_v, rhs_v);
 337       }
 338     case CORBA::tk_longlong:
 339       {
 340         CORBA::LongLong rhs_v;
 341         rhs_n->any_ >>= rhs_v;
 342         CORBA::LongLong lhs_v;
 343         this->any_ >>= lhs_v;
 344         return (lhs_v == rhs_v);
 345       }
 346     case CORBA::tk_ulonglong:
 347       {
 348         CORBA::ULongLong rhs_v;
 349         rhs_n->any_ >>= rhs_v;
 350         CORBA::ULongLong lhs_v;
 351         this->any_ >>= lhs_v;
 352         return (lhs_v == rhs_v);
 353       }
 354     case CORBA::tk_boolean:
 355       {
 356         CORBA::Boolean rhs_v;
 357         rhs_n->any_ >>= CORBA::Any::to_boolean (rhs_v);
 358         CORBA::Boolean lhs_v;
 359         this->any_ >>= CORBA::Any::to_boolean (lhs_v);
 360         return (lhs_v == rhs_v);
 361       }
 362     case CORBA::tk_char:
 363       {
 364         CORBA::Char rhs_v;
 365         rhs_n->any_ >>= CORBA::Any::to_char (rhs_v);
 366         CORBA::Char lhs_v;
 367         this->any_ >>= CORBA::Any::to_char (lhs_v);
 368         return (lhs_v == rhs_v);
 369       }
 370     case CORBA::tk_wchar:
 371       {
 372         CORBA::WChar rhs_v;
 373         rhs_n->any_ >>= CORBA::Any::to_wchar (rhs_v);
 374         CORBA::WChar lhs_v;
 375         this->any_ >>= CORBA::Any::to_wchar (lhs_v);
 376         return (lhs_v == rhs_v);
 377       }
 378     case CORBA::tk_octet:
 379       {
 380         CORBA::Octet rhs_v;
 381         rhs_n->any_ >>= CORBA::Any::to_octet (rhs_v);
 382         CORBA::Octet lhs_v;
 383         this->any_ >>= CORBA::Any::to_octet (lhs_v);
 384         return (lhs_v == rhs_v);
 385       }
 386     case CORBA::tk_any:
 387       {
 388         const CORBA::Any *rhs_v;
 389         rhs_n->any_ >>= rhs_v;
 390         const CORBA::Any *lhs_v;
 391         this->any_ >>= lhs_v;
 392
 393         DynamicAny::DynAny_var rhs_dyn =
 394           TAO::MakeDynAnyUtils::make_dyn_any_t<const CORBA::Any&> (
 395             rhs_v->_tao_get_typecode (),
 396             *rhs_v,
 397             this->allow_truncation_ );
 398
 399         DynamicAny::DynAny_var lhs_dyn =
 400           TAO::MakeDynAnyUtils::make_dyn_any_t<const CORBA::Any&> (
 401             lhs_v->_tao_get_typecode (),
 402             *lhs_v,
 403             this->allow_truncation_ );
 404
 405         CORBA::Boolean const b = rhs_dyn->equal (lhs_dyn.in ());
 406
 407         rhs_dyn->destroy ();
 408
 409         lhs_dyn->destroy ();
 410
 411         return b;
 412       }
 413     case CORBA::tk_TypeCode:
 414       {
 415         CORBA::TypeCode_ptr rhs_v;
 416         rhs_n->any_ >>= rhs_v;
 417         CORBA::TypeCode_ptr lhs_v;
 418         this->any_ >>= lhs_v;
 419         // See CORBA 2.4.2 - must use equal() here.
 420         return lhs_v->equal (lhs_v);
 421       }
 422     case CORBA::tk_objref:
 423       {
 424         CORBA::Object_ptr rhs_v;
 425         rhs_n->any_ >>= CORBA::Any::to_object (rhs_v);
 426         CORBA::Object_ptr lhs_v;
 427         this->any_ >>= CORBA::Any::to_object (lhs_v);
 428         return lhs_v->_is_equivalent (lhs_v);
 429       }
 430     case CORBA::tk_string:
 431       {
 432         CORBA::TypeCode_var unaliased_tc =
 433           TAO_DynAnyFactory::strip_alias (this->type_.in ());
 434
 435         CORBA::ULong bound =
 436           unaliased_tc->length ();
 437
 438         const char *rhs_v, *lhs_v;
 439         CORBA::Boolean rstatus, lstatus;
 440
 441         if (bound == 0)
 442           {
 443             rstatus = rhs_n->any_ >>= rhs_v;
 444             lstatus = this->any_ >>= lhs_v;
 445
 446             if ((rstatus && lstatus) == 0)
 447               {
 448                 return 0;
 449               }
 450           }
 451         else
 452           {
 453             rstatus = rhs_n->any_ >>= CORBA::Any::to_string (rhs_v, bound);
 454             lstatus = this->any_ >>= CORBA::Any::to_string (lhs_v, bound);
 455
 456             if ((rstatus && lstatus) == 0)
 457               {
 458                 return 0;
 459               }
 460           }
 461
 462         return ACE_OS::strcmp (rhs_v, lhs_v) == 0;
 463       }
 464     case CORBA::tk_wstring:
 465       {
 466         CORBA::TypeCode_var unaliased_tc =
 467           TAO_DynAnyFactory::strip_alias (this->type_.in ());
 468
 469         CORBA::ULong bound =
 470           unaliased_tc->length ();
 471
 472         const CORBA::WChar *rhs_v, *lhs_v;
 473         CORBA::Boolean rstatus, lstatus;
 474
 475         if (bound == 0)
 476           {
 477             rstatus = rhs_n->any_ >>= rhs_v;
 478             lstatus = this->any_ >>= lhs_v;
 479
 480             if ((rstatus && lstatus) == 0)
 481               {
 482                 return 0;
 483               }
 484           }
 485         else
 486           {
 487             rstatus = rhs_n->any_ >>= CORBA::Any::to_wstring (rhs_v,
 488                                                               bound);
 489             lstatus = this->any_ >>= CORBA::Any::to_wstring (lhs_v,
 490                                                              bound);
 491
 492             if ((rstatus && lstatus) == 0)
 493               {
 494                 return 0;
 495               }
 496           }
 497
 498         return ACE_OS::wscmp (rhs_v, lhs_v) == 0;
 499       }
 500     case CORBA::tk_sequence:
 501       {
 502         // The only way we can get here is if we have a basic sequence (see check_typecode)
 503         CORBA::TypeCode_var unaliased_tc =
 504           TAO_DynAnyFactory::strip_alias (this->type_.in ());
 505
 506         CORBA::TCKind tk_content = TAO_DynAnyFactory::unalias (unaliased_tc->content_type());
 507
 508         switch (tk_content)
 509           {
 510             case CORBA::tk_short:
 511               {
 512                 CORBA::ShortSeq_var lvalues(this->get_short_seq());
 513                 CORBA::ShortSeq_var rvalues(rhs_n->get_short_seq());
 514
 515                 if (lvalues->length() != rvalues->length())
 516                   {
 517                     return 0;
 518                   }
 519
 520                 for (CORBA::ULong i = 0; i < lvalues->length(); ++i)
 521                   {
 522                     if (lvalues[i] != rvalues[i])
 523                       return 0;
 524                   }
 525                 return 1; // If we get to here, all was equal
 526               }
 527               break;
 528
 529             case CORBA::tk_long:
 530               {
 531                 CORBA::LongSeq_var lvalues(this->get_long_seq());
 532                 CORBA::LongSeq_var rvalues(rhs_n->get_long_seq());
 533
 534                 if (lvalues->length() != rvalues->length())
 535                   {
 536                     return 0;
 537                   }
 538
 539                 for (CORBA::ULong i = 0; i < lvalues->length(); ++i)
 540                   {
 541                     if (lvalues[i] != rvalues[i])
 542                       {
 543                         return 0;
 544                       }
 545                   }
 546                 return 1; // If we get to here, all was equal
 547               }
 548               break;
 549
 550             case CORBA::tk_ushort:
 551               {
 552                 CORBA::UShortSeq_var lvalues(this->get_ushort_seq());
 553                 CORBA::UShortSeq_var rvalues(rhs_n->get_ushort_seq());
 554
 555                 if (lvalues->length() != rvalues->length())
 556                   {
 557                     return 0;
 558                   }
 559
 560                 for (CORBA::ULong i = 0; i < lvalues->length(); ++i)
 561                   {
 562                     if (lvalues[i] != rvalues[i])
 563                       {
 564                         return 0;
 565                       }
 566                   }
 567                 return 1; // If we get to here, all was equal
 568               }
 569               break;
 570
 571             case CORBA::tk_ulong:
 572               {
 573                 CORBA::ULongSeq_var lvalues(this->get_ulong_seq());
 574                 CORBA::ULongSeq_var rvalues(rhs_n->get_ulong_seq());
 575
 576                 if (lvalues->length() != rvalues->length())
 577                   {
 578                     return 0;
 579                   }
 580
 581                 for (CORBA::ULong i = 0; i < lvalues->length(); ++i)
 582                   {
 583                     if (lvalues[i] != rvalues[i])
 584                       {
 585                         return 0;
 586                       }
 587                   }
 588                 return 1; // If we get to here, all was equal
 589               }
 590               break;
 591
 592             case CORBA::tk_float:
 593               {
 594                 CORBA::FloatSeq_var lvalues(this->get_float_seq());
 595                 CORBA::FloatSeq_var rvalues(rhs_n->get_float_seq());
 596
 597                 if (lvalues->length() != rvalues->length())
 598                   {
 599                     return 0;
 600                   }
 601
 602                 for (CORBA::ULong i = 0; i < lvalues->length(); ++i)
 603                   {
 604                     if (ACE::is_inequal (lvalues[i], rvalues[i]))
 605                       {
 606                         return 0;
 607                       }
 608                   }
 609                 return 1; // If we get to here, all was equal
 610               }
 611               break;
 612
 613             case CORBA::tk_double:
 614               {
 615                 CORBA::DoubleSeq_var lvalues(this->get_double_seq());
 616                 CORBA::DoubleSeq_var rvalues(rhs_n->get_double_seq());
 617
 618                 if (lvalues->length() != rvalues->length())
 619                   {
 620                     return 0;
 621                   }
 622
 623                 for (CORBA::ULong i = 0; i < lvalues->length(); ++i)
 624                   {
 625                     if (ACE::is_inequal (lvalues[i], rvalues[i]))
 626                       {
 627                         return 0;
 628                       }
 629                   }
 630                 return 1; // If we get to here, all was equal
 631               }
 632               break;
 633
 634             case CORBA::tk_longlong:
 635               {
 636                 CORBA::LongLongSeq_var lvalues(this->get_longlong_seq());
 637                 CORBA::LongLongSeq_var rvalues(rhs_n->get_longlong_seq());
 638
 639                 if (lvalues->length() != rvalues->length())
 640                   {
 641                     return 0;
 642                   }
 643
 644                 for (CORBA::ULong i = 0; i < lvalues->length(); ++i)
 645                   {
 646                     if (lvalues[i] != rvalues[i])
 647                       {
 648                         return 0;
 649                       }
 650                   }
 651                 return 1; // If we get to here, all was equal
 652               }
 653               break;
 654
 655             case CORBA::tk_ulonglong:
 656               {
 657                 CORBA::ULongLongSeq_var lvalues(this->get_ulonglong_seq());
 658                 CORBA::ULongLongSeq_var rvalues(rhs_n->get_ulonglong_seq());
 659
 660                 if (lvalues->length() != rvalues->length())
 661                   {
 662                     return 0;
 663                   }
 664
 665                 for (CORBA::ULong i = 0; i < lvalues->length(); ++i)
 666                   {
 667                     if (lvalues[i] != rvalues[i])
 668                       {
 669                         return 0;
 670                       }
 671                   }
 672                 return 1; // If we get to here, all was equal
 673               }
 674               break;
 675
 676             case CORBA::tk_boolean:
 677               {
 678                 CORBA::BooleanSeq_var lvalues(this->get_boolean_seq());
 679                 CORBA::BooleanSeq_var rvalues(rhs_n->get_boolean_seq());
 680
 681                 if (lvalues->length() != rvalues->length())
 682                   {
 683                     return 0;
 684                   }
 685
 686                 for (CORBA::ULong i = 0; i < lvalues->length(); ++i)
 687                   {
 688                     if (lvalues[i] != rvalues[i])
 689                       {
 690                         return 0;
 691                       }
 692                   }
 693                 return 1; // If we get to here, all was equal
 694               }
 695               break;
 696
 697             case CORBA::tk_char:
 698               {
 699                 CORBA::CharSeq_var lvalues(this->get_char_seq());
 700                 CORBA::CharSeq_var rvalues(rhs_n->get_char_seq());
 701
 702                 if (lvalues->length() != rvalues->length())
 703                   {
 704                     return 0;
 705                   }
 706
 707                 for (CORBA::ULong i = 0; i < lvalues->length(); ++i)
 708                   {
 709                     if (lvalues[i] != rvalues[i])
 710                       {
 711                         return 0;
 712                       }
 713                   }
 714                 return 1; // If we get to here, all was equal
 715               }
 716               break;
 717
 718             case CORBA::tk_wchar:
 719               {
 720                 CORBA::WCharSeq_var lvalues(this->get_wchar_seq());
 721                 CORBA::WCharSeq_var rvalues(rhs_n->get_wchar_seq());
 722
 723                 if (lvalues->length() != rvalues->length())
 724                   {
 725                     return 0;
 726                   }
 727
 728                 for (CORBA::ULong i = 0; i < lvalues->length(); ++i)
 729                   {
 730                     if (lvalues[i] != rvalues[i])
 731                       {
 732                         return 0;
 733                       }
 734                   }
 735                 return 1; // If we get to here, all was equal
 736               }
 737               break;
 738
 739             case CORBA::tk_octet:
 740               {
 741                 CORBA::OctetSeq_var lvalues(this->get_octet_seq());
 742                 CORBA::OctetSeq_var rvalues(rhs_n->get_octet_seq());
 743
 744                 if (lvalues->length() != rvalues->length())
 745                   {
 746                     return 0;
 747                   }
 748
 749                 for (CORBA::ULong i = 0; i < lvalues->length(); ++i)
 750                   {
 751                     if (lvalues[i] != rvalues[i])
 752                       {
 753                         return 0;
 754                       }
 755                   }
 756                 return 1; // If we get to here, all was equal
 757               }
 758               break;
 759
 760
 761             case CORBA::tk_longdouble:
 762               {
 763                 CORBA::LongDoubleSeq_var lvalues(this->get_longdouble_seq());
 764                 CORBA::LongDoubleSeq_var rvalues(rhs_n->get_longdouble_seq());
 765
 766                 if (lvalues->length() != rvalues->length())
 767                   {
 768                     return 0;
 769                   }
 770
 771                 for (CORBA::ULong i = 0; i < lvalues->length(); ++i)
 772                   {
 773                     if (lvalues[i] != rvalues[i])
 774                       {
 775                         return 0;
 776                       }
 777                   }
 778                 return 1; // If we get to here, all was equal
 779               }
 780               break;
 781
 782             default:
 783             // Should never get here
 784             break;
 785           }
 786       }
 787
 788       break;
 789     default:
 790       break; // Cannot happen...
 791     }
 792
 793   return 0;
 794 }
 795
 796 void
 797 TAO_DynAny_i::destroy ()
 798 {
 799   if (this->destroyed_)
 800     {
 801       throw ::CORBA::OBJECT_NOT_EXIST ();
 802     }
 803
 804   if (!this->ref_to_component_ || this->container_is_destroying_)
 805     {
 806       this->destroyed_ = 1;
 807     }
 808 }
 809
 810
 811 DynamicAny::DynAny_ptr
 812 TAO_DynAny_i::current_component ()
 813 {
 814   if (this->destroyed_)
 815     {
 816       throw ::CORBA::OBJECT_NOT_EXIST ();
 817     }
 818
 819   throw DynamicAny::DynAny::TypeMismatch ();
 820 }
 821
 822 TAO_END_VERSIONED_NAMESPACE_DECL