TAO_DynamicAny: DynCommon.cpp Source File

00001 // DynCommon.cpp,v 1.42 2006/03/10 07:19:08 jtc Exp
00002 
00003 #include "tao/DynamicAny/DynCommon.h"
00004 #include "tao/DynamicAny/DynAnyFactory.h"
00005 #include "tao/DynamicAny/DynAny_i.h"
00006 #include "tao/DynamicAny/DynArray_i.h"
00007 #include "tao/DynamicAny/DynEnum_i.h"
00008 #include "tao/DynamicAny/DynSequence_i.h"
00009 #include "tao/DynamicAny/DynStruct_i.h"
00010 #include "tao/DynamicAny/DynUnion_i.h"
00011 #include "tao/AnyTypeCode/Any_Unknown_IDL_Type.h"
00012 #include "tao/CDR.h"
00013 #include "ace/OS_NS_wchar.h"
00014 #include "ace/OS_NS_string.h"
00015 
00016 
00017 ACE_RCSID (DynamicAny,
00018            DynCommon,
00019            "DynCommon.cpp,v 1.42 2006/03/10 07:19:08 jtc Exp")
00020 
00021 
00022 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
00023 
00024 TAO_DynCommon::TAO_DynCommon (void)
00025 {
00026 }
00027 
00028 TAO_DynCommon::~TAO_DynCommon (void)
00029 {
00030 }
00031 
00032 // *****************************************************************
00033 
00034 CORBA::TypeCode_ptr
00035 TAO_DynCommon::type (ACE_ENV_SINGLE_ARG_DECL)
00036   ACE_THROW_SPEC ((
00037       CORBA::SystemException
00038     ))
00039 {
00040   if (this->destroyed_)
00041     {
00042       ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
00043                         CORBA::TypeCode::_nil ());
00044     }
00045 
00046   return CORBA::TypeCode::_duplicate (this->type_.in ());
00047 }
00048 
00049 void
00050 TAO_DynCommon::assign (DynamicAny::DynAny_ptr dyn_any
00051                        ACE_ENV_ARG_DECL)
00052   ACE_THROW_SPEC ((
00053       CORBA::SystemException,
00054       DynamicAny::DynAny::TypeMismatch
00055     ))
00056 {
00057   if (this->destroyed_)
00058     {
00059       ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
00060     }
00061 
00062   CORBA::TypeCode_var tc = dyn_any->type (ACE_ENV_SINGLE_ARG_PARAMETER);
00063   ACE_CHECK;
00064 
00065   CORBA::Boolean equivalent =
00066     this->type_.in ()->equivalent (tc.in ()
00067                                    ACE_ENV_ARG_PARAMETER);
00068   ACE_CHECK;
00069 
00070   if (equivalent)
00071     {
00072       CORBA::Any_var any = dyn_any->to_any (ACE_ENV_SINGLE_ARG_PARAMETER);
00073       ACE_CHECK;
00074 
00075       this->from_any (any.in ()
00076                       ACE_ENV_ARG_PARAMETER);
00077       ACE_CHECK;
00078     }
00079   else
00080     {
00081       ACE_THROW (DynamicAny::DynAny::TypeMismatch ());
00082     }
00083 }
00084 
00085 void
00086 TAO_DynCommon::insert_boolean (CORBA::Boolean value
00087                                ACE_ENV_ARG_DECL)
00088   ACE_THROW_SPEC ((
00089       CORBA::SystemException,
00090       DynamicAny::DynAny::TypeMismatch,
00091       DynamicAny::DynAny::InvalidValue
00092     ))
00093 {
00094   if (this->destroyed_)
00095     {
00096       ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
00097     }
00098 
00099   if (this->has_components_)
00100     {
00101       DynamicAny::DynAny_var cc =
00102         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
00103       ACE_CHECK;
00104 
00105       cc->insert_boolean (value
00106                           ACE_ENV_ARG_PARAMETER);
00107       ACE_CHECK;
00108     }
00109   else
00110     {
00111       this->check_type (CORBA::_tc_boolean
00112                         ACE_ENV_ARG_PARAMETER);
00113       ACE_CHECK;
00114 
00115       this->any_ <<= CORBA::Any::from_boolean (value);
00116     }
00117 }
00118 
00119 void
00120 TAO_DynCommon::insert_octet (CORBA::Octet value
00121                              ACE_ENV_ARG_DECL)
00122   ACE_THROW_SPEC ((
00123       CORBA::SystemException,
00124       DynamicAny::DynAny::TypeMismatch,
00125       DynamicAny::DynAny::InvalidValue
00126     ))
00127 {
00128   if (this->destroyed_)
00129     {
00130       ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
00131     }
00132 
00133   if (this->has_components_)
00134     {
00135       DynamicAny::DynAny_var cc =
00136         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
00137       ACE_CHECK;
00138 
00139       cc->insert_octet (value
00140                         ACE_ENV_ARG_PARAMETER);
00141       ACE_CHECK;
00142     }
00143   else
00144     {
00145       this->check_type (CORBA::_tc_octet
00146                         ACE_ENV_ARG_PARAMETER);
00147       ACE_CHECK;
00148 
00149       this->any_ <<= CORBA::Any::from_octet (value);
00150     }
00151 }
00152 
00153 void
00154 TAO_DynCommon::insert_char (CORBA::Char value
00155                             ACE_ENV_ARG_DECL)
00156   ACE_THROW_SPEC ((
00157       CORBA::SystemException,
00158       DynamicAny::DynAny::TypeMismatch,
00159       DynamicAny::DynAny::InvalidValue
00160     ))
00161 {
00162   if (this->destroyed_)
00163     {
00164       ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
00165     }
00166 
00167   if (this->has_components_)
00168     {
00169       DynamicAny::DynAny_var cc =
00170         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
00171       ACE_CHECK;
00172 
00173       cc->insert_char (value
00174                        ACE_ENV_ARG_PARAMETER);
00175       ACE_CHECK;
00176     }
00177   else
00178     {
00179       this->check_type (CORBA::_tc_char
00180                         ACE_ENV_ARG_PARAMETER);
00181       ACE_CHECK;
00182 
00183       this->any_ <<= CORBA::Any::from_char (value);
00184     }
00185 }
00186 
00187 void
00188 TAO_DynCommon::insert_short (CORBA::Short value
00189                              ACE_ENV_ARG_DECL)
00190   ACE_THROW_SPEC ((
00191       CORBA::SystemException,
00192       DynamicAny::DynAny::TypeMismatch,
00193       DynamicAny::DynAny::InvalidValue
00194     ))
00195 {
00196   if (this->destroyed_)
00197     {
00198       ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
00199     }
00200 
00201   if (this->has_components_)
00202     {
00203       DynamicAny::DynAny_var cc =
00204         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
00205       ACE_CHECK;
00206 
00207       cc->insert_short (value
00208                         ACE_ENV_ARG_PARAMETER);
00209       ACE_CHECK;
00210     }
00211   else
00212     {
00213       this->check_type (CORBA::_tc_short
00214                         ACE_ENV_ARG_PARAMETER);
00215       ACE_CHECK;
00216 
00217       this->any_ <<= value;
00218     }
00219 }
00220 
00221 void
00222 TAO_DynCommon::insert_ushort (CORBA::UShort value
00223                               ACE_ENV_ARG_DECL)
00224   ACE_THROW_SPEC ((
00225       CORBA::SystemException,
00226       DynamicAny::DynAny::TypeMismatch,
00227       DynamicAny::DynAny::InvalidValue
00228     ))
00229 {
00230   if (this->destroyed_)
00231     {
00232       ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
00233     }
00234 
00235   if (this->has_components_)
00236     {
00237       DynamicAny::DynAny_var cc =
00238         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
00239       ACE_CHECK;
00240 
00241       cc->insert_ushort (value
00242                          ACE_ENV_ARG_PARAMETER);
00243       ACE_CHECK;
00244     }
00245   else
00246     {
00247       this->check_type (CORBA::_tc_ushort
00248                         ACE_ENV_ARG_PARAMETER);
00249       ACE_CHECK;
00250 
00251       this->any_ <<= value;
00252     }
00253 }
00254 
00255 void
00256 TAO_DynCommon::insert_long (CORBA::Long value
00257                             ACE_ENV_ARG_DECL)
00258   ACE_THROW_SPEC ((
00259       CORBA::SystemException,
00260       DynamicAny::DynAny::TypeMismatch,
00261       DynamicAny::DynAny::InvalidValue
00262     ))
00263 {
00264   if (this->destroyed_)
00265     {
00266       ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
00267     }
00268 
00269   if (this->has_components_)
00270     {
00271       DynamicAny::DynAny_var cc =
00272         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
00273       ACE_CHECK;
00274 
00275       cc->insert_long (value
00276                        ACE_ENV_ARG_PARAMETER);
00277       ACE_CHECK;
00278     }
00279   else
00280     {
00281       this->check_type (CORBA::_tc_long
00282                         ACE_ENV_ARG_PARAMETER);
00283       ACE_CHECK;
00284 
00285       this->any_ <<= value;
00286     }
00287 }
00288 
00289 void
00290 TAO_DynCommon::insert_ulong (CORBA::ULong value
00291                              ACE_ENV_ARG_DECL)
00292   ACE_THROW_SPEC ((
00293       CORBA::SystemException,
00294       DynamicAny::DynAny::TypeMismatch,
00295       DynamicAny::DynAny::InvalidValue
00296     ))
00297 {
00298   if (this->destroyed_)
00299     {
00300       ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
00301     }
00302 
00303   if (this->has_components_)
00304     {
00305       DynamicAny::DynAny_var cc =
00306         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
00307       ACE_CHECK;
00308 
00309       cc->insert_ulong (value
00310                         ACE_ENV_ARG_PARAMETER);
00311       ACE_CHECK;
00312     }
00313   else
00314     {
00315       this->check_type (CORBA::_tc_ulong
00316                         ACE_ENV_ARG_PARAMETER);
00317       ACE_CHECK;
00318 
00319       this->any_ <<= value;
00320     }
00321 }
00322 
00323 void
00324 TAO_DynCommon::insert_float (CORBA::Float value
00325                              ACE_ENV_ARG_DECL)
00326   ACE_THROW_SPEC ((
00327       CORBA::SystemException,
00328       DynamicAny::DynAny::TypeMismatch,
00329       DynamicAny::DynAny::InvalidValue
00330     ))
00331 {
00332   if (this->destroyed_)
00333     {
00334       ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
00335     }
00336 
00337   if (this->has_components_)
00338     {
00339       DynamicAny::DynAny_var cc =
00340         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
00341       ACE_CHECK;
00342 
00343       cc->insert_float (value
00344                         ACE_ENV_ARG_PARAMETER);
00345       ACE_CHECK;
00346     }
00347   else
00348     {
00349       this->check_type (CORBA::_tc_float
00350                         ACE_ENV_ARG_PARAMETER);
00351       ACE_CHECK;
00352 
00353       this->any_ <<= value;
00354     }
00355 }
00356 
00357 void
00358 TAO_DynCommon::insert_double (CORBA::Double value
00359                               ACE_ENV_ARG_DECL)
00360   ACE_THROW_SPEC ((
00361       CORBA::SystemException,
00362       DynamicAny::DynAny::TypeMismatch,
00363       DynamicAny::DynAny::InvalidValue
00364     ))
00365 {
00366   if (this->destroyed_)
00367     {
00368       ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
00369     }
00370 
00371   if (this->has_components_)
00372     {
00373       DynamicAny::DynAny_var cc =
00374         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
00375       ACE_CHECK;
00376 
00377       cc->insert_double (value
00378                          ACE_ENV_ARG_PARAMETER);
00379       ACE_CHECK;
00380     }
00381   else
00382     {
00383       this->check_type (CORBA::_tc_double
00384                         ACE_ENV_ARG_PARAMETER);
00385       ACE_CHECK;
00386 
00387       this->any_ <<= value;
00388     }
00389 }
00390 
00391 void
00392 TAO_DynCommon::insert_string (const char * value
00393                               ACE_ENV_ARG_DECL)
00394   ACE_THROW_SPEC ((
00395       CORBA::SystemException,
00396       DynamicAny::DynAny::TypeMismatch,
00397       DynamicAny::DynAny::InvalidValue
00398     ))
00399 {
00400   if (this->destroyed_)
00401     {
00402       ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
00403     }
00404 
00405   if (this->has_components_)
00406     {
00407       DynamicAny::DynAny_var cc =
00408         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
00409       ACE_CHECK;
00410 
00411       cc->insert_string (value
00412                          ACE_ENV_ARG_PARAMETER);
00413       ACE_CHECK;
00414     }
00415   else
00416     {
00417       CORBA::TypeCode_var unaliased_tc =
00418         TAO_DynAnyFactory::strip_alias (this->type_.in ()
00419                                         ACE_ENV_ARG_PARAMETER);
00420       ACE_CHECK;
00421 
00422       CORBA::TCKind kind =
00423         unaliased_tc->kind (ACE_ENV_SINGLE_ARG_PARAMETER);
00424       ACE_CHECK;
00425 
00426       if (kind != CORBA::tk_string)
00427         {
00428           ACE_THROW (DynamicAny::DynAny::TypeMismatch ());
00429         }
00430 
00431       CORBA::ULong bound =
00432         unaliased_tc->length (ACE_ENV_SINGLE_ARG_PARAMETER);
00433       ACE_CHECK;
00434 
00435       if (bound > 0 && bound < ACE_OS::strlen (value))
00436         {
00437           ACE_THROW (DynamicAny::DynAny::InvalidValue ());
00438         }
00439 
00440       this->any_ <<= CORBA::Any::from_string (const_cast<char *> (value),
00441                                               bound);
00442     }
00443 }
00444 
00445 void
00446 TAO_DynCommon::insert_reference (CORBA::Object_ptr value
00447                                  ACE_ENV_ARG_DECL)
00448   ACE_THROW_SPEC ((
00449       CORBA::SystemException,
00450       DynamicAny::DynAny::TypeMismatch,
00451       DynamicAny::DynAny::InvalidValue
00452     ))
00453 {
00454   if (this->destroyed_)
00455     {
00456       ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
00457     }
00458 
00459   if (this->has_components_)
00460     {
00461       DynamicAny::DynAny_var cc =
00462         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
00463       ACE_CHECK;
00464 
00465       cc->insert_reference (value
00466                             ACE_ENV_ARG_PARAMETER);
00467       ACE_CHECK;
00468     }
00469   else
00470     {
00471       CORBA::Boolean good_type = 1;
00472       CORBA::TCKind kind =
00473         TAO_DynAnyFactory::unalias (this->type_.in ()
00474                                     ACE_ENV_ARG_PARAMETER);
00475       ACE_CHECK;
00476 
00477       if (kind != CORBA::tk_objref)
00478         {
00479           good_type = 0;
00480         }
00481       else if (!CORBA::is_nil (value))
00482         {
00483           const char *value_id = value->_interface_repository_id ();
00484 
00485           if (ACE_OS::strcmp (value_id, "IDL:omg.org/CORBA/Object:1.0") != 0)
00486             {
00487               const char *my_id =
00488                 this->type_->id (ACE_ENV_SINGLE_ARG_PARAMETER);
00489               ACE_CHECK;
00490 
00491               if (ACE_OS::strcmp (value_id, my_id) != 0)
00492                 {
00493                   good_type = value->_is_a (my_id
00494                                             ACE_ENV_ARG_PARAMETER);
00495                   ACE_CHECK;
00496                 }
00497             }
00498         }
00499 
00500       if (good_type)
00501         {
00502           TAO_OutputCDR cdr;
00503 
00504           if (CORBA::is_nil (value))
00505             {
00506               // Empty type hint, no profile.
00507               cdr.write_ulong (1);
00508               cdr.write_char ('\0');
00509               cdr.write_ulong (0);
00510             }
00511           else
00512             {
00513               value->marshal (cdr);
00514             }
00515 
00516           TAO_InputCDR in (cdr);
00517           TAO::Unknown_IDL_Type *unk = 0;
00518           ACE_NEW (unk,
00519                    TAO::Unknown_IDL_Type (this->type_.in (),
00520                                           in));
00521           this->any_.replace (unk);
00522         }
00523       else
00524         {
00525           ACE_THROW (DynamicAny::DynAny::TypeMismatch ());
00526         }
00527     }
00528 }
00529 
00530 void
00531 TAO_DynCommon::insert_typecode (CORBA::TypeCode_ptr value
00532                                 ACE_ENV_ARG_DECL)
00533   ACE_THROW_SPEC ((
00534       CORBA::SystemException,
00535       DynamicAny::DynAny::TypeMismatch,
00536       DynamicAny::DynAny::InvalidValue
00537     ))
00538 {
00539   if (this->destroyed_)
00540     {
00541       ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
00542     }
00543 
00544   if (this->has_components_)
00545     {
00546       DynamicAny::DynAny_var cc =
00547         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
00548       ACE_CHECK;
00549 
00550       cc->insert_typecode (value
00551                            ACE_ENV_ARG_PARAMETER);
00552       ACE_CHECK;
00553     }
00554   else
00555     {
00556       this->check_type (CORBA::_tc_TypeCode
00557                         ACE_ENV_ARG_PARAMETER);
00558       ACE_CHECK;
00559 
00560       this->any_ <<= value;
00561     }
00562 }
00563 
00564 void
00565 TAO_DynCommon::insert_longlong (CORBA::LongLong value
00566                                 ACE_ENV_ARG_DECL)
00567   ACE_THROW_SPEC ((
00568       CORBA::SystemException,
00569       DynamicAny::DynAny::TypeMismatch,
00570       DynamicAny::DynAny::InvalidValue
00571     ))
00572 {
00573   if (this->destroyed_)
00574     {
00575       ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
00576     }
00577 
00578   if (this->has_components_)
00579     {
00580       DynamicAny::DynAny_var cc =
00581         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
00582       ACE_CHECK;
00583 
00584       cc->insert_longlong (value
00585                            ACE_ENV_ARG_PARAMETER);
00586       ACE_CHECK;
00587     }
00588   else
00589     {
00590       this->check_type (CORBA::_tc_longlong
00591                         ACE_ENV_ARG_PARAMETER);
00592       ACE_CHECK;
00593 
00594       this->any_ <<= value;
00595     }
00596 }
00597 
00598 void
00599 TAO_DynCommon::insert_ulonglong (CORBA::ULongLong value
00600                                  ACE_ENV_ARG_DECL)
00601   ACE_THROW_SPEC ((
00602       CORBA::SystemException,
00603       DynamicAny::DynAny::TypeMismatch,
00604       DynamicAny::DynAny::InvalidValue
00605     ))
00606 {
00607   if (this->destroyed_)
00608     {
00609       ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
00610     }
00611 
00612   if (this->has_components_)
00613     {
00614       DynamicAny::DynAny_var cc =
00615         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
00616       ACE_CHECK;
00617 
00618       cc->insert_ulonglong (value
00619                             ACE_ENV_ARG_PARAMETER);
00620       ACE_CHECK;
00621     }
00622   else
00623     {
00624       this->check_type (CORBA::_tc_ulonglong
00625                         ACE_ENV_ARG_PARAMETER);
00626       ACE_CHECK;
00627 
00628       this->any_ <<= value;
00629     }
00630 }
00631 
00632 void
00633 TAO_DynCommon::insert_longdouble (CORBA::LongDouble value
00634                                   ACE_ENV_ARG_DECL)
00635   ACE_THROW_SPEC ((
00636       CORBA::SystemException,
00637       DynamicAny::DynAny::TypeMismatch,
00638       DynamicAny::DynAny::InvalidValue
00639     ))
00640 {
00641   if (this->destroyed_)
00642     {
00643       ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
00644     }
00645 
00646   if (this->has_components_)
00647     {
00648       DynamicAny::DynAny_var cc =
00649         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
00650       ACE_CHECK;
00651 
00652       cc->insert_longdouble (value
00653                              ACE_ENV_ARG_PARAMETER);
00654       ACE_CHECK;
00655     }
00656   else
00657     {
00658       this->check_type (CORBA::_tc_longdouble
00659                         ACE_ENV_ARG_PARAMETER);
00660       ACE_CHECK;
00661 
00662       this->any_ <<= value;
00663     }
00664 }
00665 
00666 void
00667 TAO_DynCommon::insert_wchar (CORBA::WChar value
00668                              ACE_ENV_ARG_DECL)
00669   ACE_THROW_SPEC ((
00670       CORBA::SystemException,
00671       DynamicAny::DynAny::TypeMismatch,
00672       DynamicAny::DynAny::InvalidValue
00673     ))
00674 {
00675   if (this->destroyed_)
00676     {
00677       ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
00678     }
00679 
00680   if (this->has_components_)
00681     {
00682       DynamicAny::DynAny_var cc =
00683         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
00684       ACE_CHECK;
00685 
00686       cc->insert_wchar (value
00687                         ACE_ENV_ARG_PARAMETER);
00688       ACE_CHECK;
00689     }
00690   else
00691     {
00692       this->check_type (CORBA::_tc_wchar
00693                         ACE_ENV_ARG_PARAMETER);
00694       ACE_CHECK;
00695 
00696       this->any_ <<= CORBA::Any::from_wchar (value);
00697     }
00698 }
00699 
00700 void
00701 TAO_DynCommon::insert_wstring (const CORBA::WChar * value
00702                                ACE_ENV_ARG_DECL)
00703   ACE_THROW_SPEC ((
00704       CORBA::SystemException,
00705       DynamicAny::DynAny::TypeMismatch,
00706       DynamicAny::DynAny::InvalidValue
00707     ))
00708 {
00709   if (this->destroyed_)
00710     {
00711       ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
00712     }
00713 
00714   if (this->has_components_)
00715     {
00716       DynamicAny::DynAny_var cc =
00717         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
00718       ACE_CHECK;
00719 
00720       cc->insert_wstring (value
00721                           ACE_ENV_ARG_PARAMETER);
00722       ACE_CHECK;
00723     }
00724   else
00725     {
00726       CORBA::TypeCode_var unaliased_tc =
00727         this->check_type_and_unalias (CORBA::_tc_wstring
00728                                       ACE_ENV_ARG_PARAMETER);
00729       ACE_CHECK;
00730 
00731       CORBA::ULong bound = unaliased_tc->length (ACE_ENV_SINGLE_ARG_PARAMETER);
00732       ACE_CHECK;
00733 
00734       if (bound > 0 && bound < ACE_OS::wslen (value))
00735         {
00736           ACE_THROW (DynamicAny::DynAny::InvalidValue ());
00737         }
00738 
00739       this->any_ <<= CORBA::Any::from_wstring (const_cast<CORBA::WChar *> (value),
00740                                                bound);
00741     }
00742 }
00743 
00744 void
00745 TAO_DynCommon::insert_any (const CORBA::Any &value
00746                            ACE_ENV_ARG_DECL)
00747   ACE_THROW_SPEC ((
00748       CORBA::SystemException,
00749       DynamicAny::DynAny::TypeMismatch,
00750       DynamicAny::DynAny::InvalidValue
00751     ))
00752 {
00753   if (this->destroyed_)
00754     {
00755       ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
00756     }
00757 
00758   if (this->has_components_)
00759     {
00760       DynamicAny::DynAny_var cc =
00761         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
00762       ACE_CHECK;
00763 
00764       cc->insert_any (value
00765                       ACE_ENV_ARG_PARAMETER);
00766       ACE_CHECK;
00767     }
00768   else
00769     {
00770       this->check_type (CORBA::_tc_any
00771                         ACE_ENV_ARG_PARAMETER);
00772       ACE_CHECK;
00773 
00774       this->any_ <<= value;
00775     }
00776 }
00777 
00778 // @@@ (JP) TODO - optimize - this version was intended by the OMG to
00779 // have fewer Any/DynAny conversions than insert_any, not more.
00780 void
00781 TAO_DynCommon::insert_dyn_any (DynamicAny::DynAny_ptr value
00782                                ACE_ENV_ARG_DECL)
00783   ACE_THROW_SPEC ((
00784       CORBA::SystemException,
00785       DynamicAny::DynAny::TypeMismatch,
00786       DynamicAny::DynAny::InvalidValue
00787     ))
00788 {
00789   if (this->destroyed_)
00790     {
00791       ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
00792     }
00793 
00794   CORBA::Any_var any = value->to_any (ACE_ENV_SINGLE_ARG_PARAMETER);
00795   ACE_CHECK;
00796 
00797   this->insert_any (any.in ()
00798                     ACE_ENV_ARG_PARAMETER);
00799   ACE_CHECK;
00800 }
00801 
00802 void
00803 TAO_DynCommon::insert_val (CORBA::ValueBase *
00804                            ACE_ENV_ARG_DECL)
00805   ACE_THROW_SPEC ((
00806       CORBA::SystemException,
00807       DynamicAny::DynAny::TypeMismatch,
00808       DynamicAny::DynAny::InvalidValue
00809     ))
00810 {
00811   ACE_THROW (CORBA::NO_IMPLEMENT ());
00812 }
00813 
00814 // ****************************************************************
00815 
00816 CORBA::Boolean
00817 TAO_DynCommon::get_boolean (ACE_ENV_SINGLE_ARG_DECL)
00818   ACE_THROW_SPEC ((
00819       CORBA::SystemException,
00820       DynamicAny::DynAny::TypeMismatch,
00821       DynamicAny::DynAny::InvalidValue
00822     ))
00823 {
00824   if (this->destroyed_)
00825     {
00826       ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
00827                         0);
00828     }
00829 
00830   if (this->has_components_)
00831     {
00832       DynamicAny::DynAny_var cc =
00833         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
00834       ACE_CHECK_RETURN (0);
00835 
00836       return cc->get_boolean (ACE_ENV_SINGLE_ARG_PARAMETER);
00837     }
00838   else
00839     {
00840       CORBA::Boolean retval;
00841 
00842       if ((this->any_ >>= CORBA::Any::to_boolean (retval)) == 0)
00843         {
00844           ACE_THROW_RETURN (DynamicAny::DynAny::TypeMismatch (),
00845                             0);
00846         }
00847 
00848       return retval;
00849     }
00850 }
00851 
00852 CORBA::Octet
00853 TAO_DynCommon::get_octet (ACE_ENV_SINGLE_ARG_DECL)
00854   ACE_THROW_SPEC ((
00855       CORBA::SystemException,
00856       DynamicAny::DynAny::TypeMismatch,
00857       DynamicAny::DynAny::InvalidValue
00858     ))
00859 {
00860   if (this->destroyed_)
00861     {
00862       ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
00863                         0);
00864     }
00865 
00866   if (this->has_components_)
00867     {
00868       DynamicAny::DynAny_var cc =
00869         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
00870       ACE_CHECK_RETURN (0);
00871 
00872       return cc->get_octet (ACE_ENV_SINGLE_ARG_PARAMETER);
00873     }
00874   else
00875     {
00876       CORBA::Octet retval;
00877 
00878       if ((this->any_ >>= CORBA::Any::to_octet (retval)) == 0)
00879         {
00880           ACE_THROW_RETURN (DynamicAny::DynAny::TypeMismatch (),
00881                             0);
00882         }
00883 
00884       return retval;
00885     }
00886 }
00887 
00888 CORBA::Char
00889 TAO_DynCommon::get_char (ACE_ENV_SINGLE_ARG_DECL)
00890   ACE_THROW_SPEC ((
00891       CORBA::SystemException,
00892       DynamicAny::DynAny::TypeMismatch,
00893       DynamicAny::DynAny::InvalidValue
00894     ))
00895 {
00896   if (this->destroyed_)
00897     {
00898       ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
00899                         0);
00900     }
00901 
00902   if (this->has_components_)
00903     {
00904       DynamicAny::DynAny_var cc =
00905         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
00906       ACE_CHECK_RETURN (0);
00907 
00908       return cc->get_char (ACE_ENV_SINGLE_ARG_PARAMETER);
00909     }
00910   else
00911     {
00912       CORBA::Char retval;
00913 
00914       if ((this->any_ >>= CORBA::Any::to_char (retval)) == 0)
00915         {
00916           ACE_THROW_RETURN (DynamicAny::DynAny::TypeMismatch (),
00917                             0);
00918         }
00919 
00920       return retval;
00921     }
00922 }
00923 
00924 CORBA::Short
00925 TAO_DynCommon::get_short (ACE_ENV_SINGLE_ARG_DECL)
00926   ACE_THROW_SPEC ((
00927       CORBA::SystemException,
00928       DynamicAny::DynAny::TypeMismatch,
00929       DynamicAny::DynAny::InvalidValue
00930     ))
00931 {
00932   if (this->destroyed_)
00933     {
00934       ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
00935                         0);
00936     }
00937 
00938   if (this->has_components_)
00939     {
00940       DynamicAny::DynAny_var cc =
00941         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
00942       ACE_CHECK_RETURN (0);
00943 
00944       return cc->get_short (ACE_ENV_SINGLE_ARG_PARAMETER);
00945     }
00946   else
00947     {
00948       CORBA::Short retval;
00949 
00950       if ((this->any_ >>= retval) == 0)
00951         {
00952           ACE_THROW_RETURN (DynamicAny::DynAny::TypeMismatch (),
00953                             0);
00954         }
00955 
00956       return retval;
00957     }
00958 }
00959 
00960 CORBA::UShort
00961 TAO_DynCommon::get_ushort (ACE_ENV_SINGLE_ARG_DECL)
00962   ACE_THROW_SPEC ((
00963       CORBA::SystemException,
00964       DynamicAny::DynAny::TypeMismatch,
00965       DynamicAny::DynAny::InvalidValue
00966     ))
00967 {
00968   if (this->destroyed_)
00969     {
00970       ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
00971                         0);
00972     }
00973 
00974   if (this->has_components_)
00975     {
00976       DynamicAny::DynAny_var cc =
00977         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
00978       ACE_CHECK_RETURN (0);
00979 
00980       return cc->get_ushort (ACE_ENV_SINGLE_ARG_PARAMETER);
00981     }
00982   else
00983     {
00984       CORBA::UShort retval;
00985 
00986       if ((this->any_ >>= retval) == 0)
00987         {
00988           ACE_THROW_RETURN (DynamicAny::DynAny::TypeMismatch (),
00989                             0);
00990         }
00991 
00992       return retval;
00993     }
00994 }
00995 
00996 CORBA::Long
00997 TAO_DynCommon::get_long (ACE_ENV_SINGLE_ARG_DECL)
00998   ACE_THROW_SPEC ((
00999       CORBA::SystemException,
01000       DynamicAny::DynAny::TypeMismatch,
01001       DynamicAny::DynAny::InvalidValue
01002     ))
01003 {
01004   if (this->destroyed_)
01005     {
01006       ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
01007                         0);
01008     }
01009 
01010   if (this->has_components_)
01011     {
01012       DynamicAny::DynAny_var cc =
01013         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
01014       ACE_CHECK_RETURN (0);
01015 
01016       return cc->get_long (ACE_ENV_SINGLE_ARG_PARAMETER);
01017     }
01018   else
01019     {
01020       CORBA::Long retval;
01021 
01022       if ((this->any_ >>= retval) == 0)
01023         {
01024           ACE_THROW_RETURN (DynamicAny::DynAny::TypeMismatch (),
01025                             0);
01026         }
01027 
01028       return retval;
01029     }
01030 }
01031 
01032 CORBA::ULong
01033 TAO_DynCommon::get_ulong (ACE_ENV_SINGLE_ARG_DECL)
01034   ACE_THROW_SPEC ((
01035       CORBA::SystemException,
01036       DynamicAny::DynAny::TypeMismatch,
01037       DynamicAny::DynAny::InvalidValue
01038     ))
01039 {
01040   if (this->destroyed_)
01041     {
01042       ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
01043                         0);
01044     }
01045 
01046   if (this->has_components_)
01047     {
01048       DynamicAny::DynAny_var cc =
01049         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
01050       ACE_CHECK_RETURN (0);
01051 
01052       return cc->get_ulong (ACE_ENV_SINGLE_ARG_PARAMETER);
01053     }
01054   else
01055     {
01056       CORBA::ULong retval;
01057 
01058       if ((this->any_ >>= retval) == 0)
01059         {
01060           ACE_THROW_RETURN (DynamicAny::DynAny::TypeMismatch (),
01061                             0);
01062         }
01063 
01064       return retval;
01065     }
01066 }
01067 
01068 CORBA::Float
01069 TAO_DynCommon::get_float (ACE_ENV_SINGLE_ARG_DECL)
01070   ACE_THROW_SPEC ((
01071       CORBA::SystemException,
01072       DynamicAny::DynAny::TypeMismatch,
01073       DynamicAny::DynAny::InvalidValue
01074     ))
01075 {
01076   if (this->destroyed_)
01077     {
01078       ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
01079                         0);
01080     }
01081 
01082   if (this->has_components_)
01083     {
01084       DynamicAny::DynAny_var cc =
01085         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
01086       ACE_CHECK_RETURN (0);
01087 
01088       return cc->get_float (ACE_ENV_SINGLE_ARG_PARAMETER);
01089     }
01090   else
01091     {
01092       CORBA::Float retval;
01093 
01094       if ((this->any_ >>= retval) == 0)
01095         {
01096           ACE_THROW_RETURN (DynamicAny::DynAny::TypeMismatch (),
01097                             0);
01098         }
01099 
01100       return retval;
01101     }
01102 }
01103 
01104 CORBA::Double
01105 TAO_DynCommon::get_double (ACE_ENV_SINGLE_ARG_DECL)
01106   ACE_THROW_SPEC ((
01107       CORBA::SystemException,
01108       DynamicAny::DynAny::TypeMismatch,
01109       DynamicAny::DynAny::InvalidValue
01110     ))
01111 {
01112   if (this->destroyed_)
01113     {
01114       ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
01115                         0);
01116     }
01117 
01118   if (this->has_components_)
01119     {
01120       DynamicAny::DynAny_var cc =
01121         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
01122       ACE_CHECK_RETURN (0);
01123 
01124       return cc->get_double (ACE_ENV_SINGLE_ARG_PARAMETER);
01125     }
01126   else
01127     {
01128       CORBA::Double retval;
01129 
01130       if ((this->any_ >>= retval) == 0)
01131         {
01132           ACE_THROW_RETURN (DynamicAny::DynAny::TypeMismatch (),
01133                             0);
01134         }
01135 
01136       return retval;
01137     }
01138 }
01139 
01140 char *
01141 TAO_DynCommon::get_string (ACE_ENV_SINGLE_ARG_DECL)
01142   ACE_THROW_SPEC ((
01143       CORBA::SystemException,
01144       DynamicAny::DynAny::TypeMismatch,
01145       DynamicAny::DynAny::InvalidValue
01146     ))
01147 {
01148   if (this->destroyed_)
01149     {
01150       ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
01151                         0);
01152     }
01153 
01154   if (this->has_components_)
01155     {
01156       DynamicAny::DynAny_var cc =
01157         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
01158       ACE_CHECK_RETURN (0);
01159 
01160       return cc->get_string (ACE_ENV_SINGLE_ARG_PARAMETER);
01161     }
01162   else
01163     {
01164       CORBA::TypeCode_var unaliased_tc =
01165         TAO_DynAnyFactory::strip_alias (this->type_.in ()
01166                                         ACE_ENV_ARG_PARAMETER);
01167       ACE_CHECK_RETURN (0);
01168 
01169       CORBA::TCKind kind =
01170         unaliased_tc->kind (ACE_ENV_SINGLE_ARG_PARAMETER);
01171       ACE_CHECK_RETURN (0);
01172 
01173       if (kind != CORBA::tk_string)
01174         {
01175           ACE_THROW_RETURN (DynamicAny::DynAny::TypeMismatch (),
01176                             0);
01177         }
01178 
01179       char *retval = 0;
01180 
01181       CORBA::ULong bound =
01182         unaliased_tc->length (ACE_ENV_SINGLE_ARG_PARAMETER);
01183       ACE_CHECK_RETURN (0);
01184 
01185       // We will have caught a type mismatch above, so if this fails,
01186       // it must be for some other reason.
01187       if ((this->any_ >>= CORBA::Any::to_string (retval, bound)) == 0)
01188         {
01189           ACE_THROW_RETURN (DynamicAny::DynAny::InvalidValue (),
01190                             0);
01191         }
01192 
01193       return CORBA::string_dup (retval);
01194     }
01195 }
01196 
01197 CORBA::Object_ptr
01198 TAO_DynCommon::get_reference (ACE_ENV_SINGLE_ARG_DECL)
01199   ACE_THROW_SPEC ((
01200       CORBA::SystemException,
01201       DynamicAny::DynAny::TypeMismatch,
01202       DynamicAny::DynAny::InvalidValue
01203     ))
01204 {
01205   if (this->destroyed_)
01206     {
01207       ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
01208                         CORBA::Object::_nil ());
01209     }
01210 
01211   if (this->has_components_)
01212     {
01213       DynamicAny::DynAny_var cc =
01214         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
01215       ACE_CHECK_RETURN (CORBA::Object::_nil ());
01216 
01217       return cc->get_reference (ACE_ENV_SINGLE_ARG_PARAMETER);
01218     }
01219   else
01220     {
01221       CORBA::Object_var retval;
01222 
01223       if ((this->any_ >>= CORBA::Any::to_object (retval.inout ())) == 0)
01224         {
01225           ACE_THROW_RETURN (DynamicAny::DynAny::TypeMismatch (),
01226                             CORBA::Object::_nil ());
01227         }
01228 
01229       return retval._retn ();
01230     }
01231 }
01232 
01233 CORBA::TypeCode_ptr
01234 TAO_DynCommon::get_typecode (ACE_ENV_SINGLE_ARG_DECL)
01235   ACE_THROW_SPEC ((
01236       CORBA::SystemException,
01237       DynamicAny::DynAny::TypeMismatch,
01238       DynamicAny::DynAny::InvalidValue
01239     ))
01240 {
01241   if (this->destroyed_)
01242     {
01243       ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
01244                         CORBA::TypeCode::_nil ());
01245     }
01246 
01247   if (this->has_components_)
01248     {
01249       DynamicAny::DynAny_var cc =
01250         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
01251       ACE_CHECK_RETURN (0);
01252 
01253       return cc->get_typecode (ACE_ENV_SINGLE_ARG_PARAMETER);
01254     }
01255   else
01256     {
01257       CORBA::TypeCode_ptr retval;
01258 
01259       if ((this->any_ >>= retval) == 0)
01260         {
01261           ACE_THROW_RETURN (DynamicAny::DynAny::TypeMismatch (),
01262                             CORBA::TypeCode::_nil ());
01263         }
01264 
01265       return CORBA::TypeCode::_duplicate (retval);
01266     }
01267 }
01268 
01269 CORBA::LongLong
01270 TAO_DynCommon::get_longlong (ACE_ENV_SINGLE_ARG_DECL)
01271   ACE_THROW_SPEC ((
01272       CORBA::SystemException,
01273       DynamicAny::DynAny::TypeMismatch,
01274       DynamicAny::DynAny::InvalidValue
01275     ))
01276 {
01277   CORBA::LongLong retval = ACE_CDR_LONGLONG_INITIALIZER;
01278 
01279   if (this->destroyed_)
01280     {
01281       ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
01282                         retval);
01283     }
01284 
01285   if (this->has_components_)
01286     {
01287       DynamicAny::DynAny_var cc =
01288         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
01289       ACE_CHECK_RETURN (retval);
01290 
01291       return cc->get_longlong (ACE_ENV_SINGLE_ARG_PARAMETER);
01292     }
01293   else
01294     {
01295       if ((this->any_ >>= retval) == 0)
01296         {
01297           ACE_THROW_RETURN (DynamicAny::DynAny::TypeMismatch (),
01298                             retval);
01299         }
01300 
01301       return retval;
01302     }
01303 }
01304 
01305 CORBA::ULongLong
01306 TAO_DynCommon::get_ulonglong (ACE_ENV_SINGLE_ARG_DECL)
01307   ACE_THROW_SPEC ((
01308       CORBA::SystemException,
01309       DynamicAny::DynAny::TypeMismatch,
01310       DynamicAny::DynAny::InvalidValue
01311     ))
01312 {
01313   CORBA::ULongLong retval = 0;
01314 
01315   if (this->destroyed_)
01316     {
01317       ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
01318                         retval);
01319     }
01320 
01321   if (this->has_components_)
01322     {
01323       DynamicAny::DynAny_var cc =
01324         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
01325       ACE_CHECK_RETURN (retval);
01326 
01327       return cc->get_ulonglong (ACE_ENV_SINGLE_ARG_PARAMETER);
01328     }
01329   else
01330     {
01331       if ((this->any_ >>= retval) == 0)
01332         {
01333           ACE_THROW_RETURN (DynamicAny::DynAny::TypeMismatch (),
01334                             retval);
01335         }
01336 
01337       return retval;
01338     }
01339 }
01340 
01341 CORBA::LongDouble
01342 TAO_DynCommon::get_longdouble (ACE_ENV_SINGLE_ARG_DECL)
01343   ACE_THROW_SPEC ((
01344       CORBA::SystemException,
01345       DynamicAny::DynAny::TypeMismatch,
01346       DynamicAny::DynAny::InvalidValue
01347     ))
01348 {
01349   CORBA::LongDouble retval = ACE_CDR_LONG_DOUBLE_INITIALIZER;
01350 
01351   if (this->destroyed_)
01352     {
01353       ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
01354                         retval);
01355     }
01356 
01357   if (this->has_components_)
01358     {
01359       DynamicAny::DynAny_var cc =
01360         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
01361       ACE_CHECK_RETURN (retval);
01362 
01363       return cc->get_longdouble (ACE_ENV_SINGLE_ARG_PARAMETER);
01364     }
01365   else
01366     {
01367       if ((this->any_ >>= retval) == 0)
01368         {
01369           ACE_THROW_RETURN (DynamicAny::DynAny::TypeMismatch (),
01370                             retval);
01371         }
01372 
01373       return retval;
01374     }
01375 }
01376 
01377 CORBA::WChar
01378 TAO_DynCommon::get_wchar (ACE_ENV_SINGLE_ARG_DECL)
01379   ACE_THROW_SPEC ((
01380       CORBA::SystemException,
01381       DynamicAny::DynAny::TypeMismatch,
01382       DynamicAny::DynAny::InvalidValue
01383     ))
01384 {
01385   if (this->destroyed_)
01386     {
01387       ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
01388                         0);
01389     }
01390 
01391   if (this->has_components_)
01392     {
01393       DynamicAny::DynAny_var cc =
01394         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
01395       ACE_CHECK_RETURN (0);
01396 
01397       return cc->get_wchar (ACE_ENV_SINGLE_ARG_PARAMETER);
01398     }
01399   else
01400     {
01401       CORBA::WChar retval;
01402 
01403       if ((this->any_ >>= CORBA::Any::to_wchar (retval)) == 0)
01404         {
01405           ACE_THROW_RETURN (DynamicAny::DynAny::TypeMismatch (),
01406                             0);
01407         }
01408 
01409       return retval;
01410     }
01411 }
01412 
01413 CORBA::WChar *
01414 TAO_DynCommon::get_wstring (ACE_ENV_SINGLE_ARG_DECL)
01415   ACE_THROW_SPEC ((
01416       CORBA::SystemException,
01417       DynamicAny::DynAny::TypeMismatch,
01418       DynamicAny::DynAny::InvalidValue
01419     ))
01420 {
01421   if (this->destroyed_)
01422     {
01423       ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
01424                         0);
01425     }
01426 
01427   if (this->has_components_)
01428     {
01429       DynamicAny::DynAny_var cc =
01430         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
01431       ACE_CHECK_RETURN (0);
01432 
01433       return cc->get_wstring (ACE_ENV_SINGLE_ARG_PARAMETER);
01434     }
01435   else
01436     {
01437       // @@@ (JP) Someday try to find a way to avoid checking for
01438       // type code equivalence twice without risking a throw of
01439       // BadKind.
01440       CORBA::TypeCode_var unaliased_tc =
01441         this->check_type_and_unalias (CORBA::_tc_wstring
01442                                       ACE_ENV_ARG_PARAMETER);
01443       ACE_CHECK_RETURN (0);
01444 
01445       CORBA::WChar *retval = 0;
01446 
01447       CORBA::ULong bound =
01448         unaliased_tc->length (ACE_ENV_SINGLE_ARG_PARAMETER);
01449       ACE_CHECK_RETURN (0);
01450 
01451       (void) (this->any_ >>= CORBA::Any::to_wstring (retval,
01452                                                      bound));
01453 
01454       return CORBA::wstring_dup (retval);
01455     }
01456 }
01457 
01458 CORBA::Any_ptr
01459 TAO_DynCommon::get_any (ACE_ENV_SINGLE_ARG_DECL)
01460   ACE_THROW_SPEC ((
01461       CORBA::SystemException,
01462       DynamicAny::DynAny::TypeMismatch,
01463       DynamicAny::DynAny::InvalidValue
01464     ))
01465 {
01466   if (this->destroyed_)
01467     {
01468       ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
01469                         0);
01470     }
01471 
01472   if (this->has_components_)
01473     {
01474       DynamicAny::DynAny_var cc =
01475         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
01476       ACE_CHECK_RETURN (0);
01477 
01478       return cc->get_any (ACE_ENV_SINGLE_ARG_PARAMETER);
01479     }
01480   else
01481     {
01482       const CORBA::Any *tmp = 0;
01483 
01484       if ((this->any_ >>= tmp) == 0)
01485         {
01486           ACE_THROW_RETURN (DynamicAny::DynAny::TypeMismatch (),
01487                             0);
01488         }
01489 
01490       CORBA::Any *retval = 0;
01491       ACE_NEW_RETURN (retval,
01492                       CORBA::Any (*tmp),
01493                       0);
01494       return retval;
01495     }
01496 }
01497 
01498 // @@@ (JP) TODO - optimize - this version was intended by the OMG to
01499 // have fewer Any/DynAny conversions than get_any, not more.
01500 DynamicAny::DynAny_ptr
01501 TAO_DynCommon::get_dyn_any (ACE_ENV_SINGLE_ARG_DECL)
01502   ACE_THROW_SPEC ((
01503       CORBA::SystemException,
01504       DynamicAny::DynAny::TypeMismatch,
01505       DynamicAny::DynAny::InvalidValue
01506     ))
01507 {
01508   if (this->destroyed_)
01509     {
01510       ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
01511                         0);
01512     }
01513 
01514   CORBA::Any_var any = this->get_any (ACE_ENV_SINGLE_ARG_PARAMETER);
01515   ACE_CHECK_RETURN (0);
01516 
01517   return TAO_DynAnyFactory::make_dyn_any (any.in ()
01518                                           ACE_ENV_ARG_PARAMETER);
01519 }
01520 
01521 CORBA::ValueBase *
01522 TAO_DynCommon::get_val (ACE_ENV_SINGLE_ARG_DECL)
01523   ACE_THROW_SPEC ((
01524       CORBA::SystemException,
01525       DynamicAny::DynAny::TypeMismatch,
01526       DynamicAny::DynAny::InvalidValue
01527     ))
01528 {
01529   ACE_THROW_RETURN (CORBA::NO_IMPLEMENT (),
01530                     0);
01531 }
01532 
01533 // ****************************************************************
01534 
01535 CORBA::Boolean
01536 TAO_DynCommon::seek (CORBA::Long slot
01537                      ACE_ENV_ARG_DECL)
01538   ACE_THROW_SPEC ((
01539       CORBA::SystemException
01540     ))
01541 {
01542   if (this->destroyed_)
01543     {
01544       ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
01545                         0);
01546     }
01547 
01548   if (this->has_components_ == 0)
01549     {
01550       ACE_UNUSED_ARG (slot);
01551       this->current_position_ = -1;
01552       return 0;
01553     }
01554   else if (slot < 0 || slot >= static_cast<CORBA::Long> (this->component_count_))
01555     {
01556       this->current_position_ = -1;
01557       return 0;
01558     }
01559   else
01560     {
01561       this->current_position_ = slot;
01562       return 1;
01563     }
01564 }
01565 
01566 void
01567 TAO_DynCommon::rewind (ACE_ENV_SINGLE_ARG_DECL)
01568   ACE_THROW_SPEC ((
01569       CORBA::SystemException
01570     ))
01571 {
01572   if (this->destroyed_)
01573     {
01574       ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
01575     }
01576 
01577   (void) this->seek (0
01578                      ACE_ENV_ARG_PARAMETER);
01579   ACE_CHECK;
01580 }
01581 
01582 CORBA::Boolean
01583 TAO_DynCommon::next (ACE_ENV_SINGLE_ARG_DECL)
01584   ACE_THROW_SPEC ((
01585       CORBA::SystemException
01586     ))
01587 {
01588   if (this->destroyed_)
01589     {
01590       ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
01591                         0);
01592     }
01593 
01594   if (this->has_components_ == 0
01595       || this->current_position_ + 1 >= static_cast<CORBA::Long> (this->component_count_
01596                                           ))
01597     {
01598       this->current_position_ = -1;
01599       return 0;
01600     }
01601   else
01602     {
01603       ++this->current_position_;
01604       return 1;
01605     }
01606 }
01607 
01608 DynamicAny::DynAny_ptr
01609 TAO_DynCommon::copy (ACE_ENV_SINGLE_ARG_DECL)
01610   ACE_THROW_SPEC ((
01611       CORBA::SystemException
01612     ))
01613 {
01614   if (this->destroyed_)
01615     {
01616       ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
01617                         DynamicAny::DynAny::_nil ());
01618     }
01619 
01620   CORBA::Any_var any = this->to_any (ACE_ENV_SINGLE_ARG_PARAMETER);
01621   ACE_CHECK_RETURN (DynamicAny::DynAny::_nil ());
01622 
01623   DynamicAny::DynAny_ptr retval =
01624     TAO_DynAnyFactory::make_dyn_any (any.in ()
01625                                      ACE_ENV_ARG_PARAMETER);
01626   ACE_CHECK_RETURN (DynamicAny::DynAny::_nil ());
01627 
01628   return retval;
01629 }
01630 
01631 CORBA::ULong
01632 TAO_DynCommon::component_count (ACE_ENV_SINGLE_ARG_DECL)
01633   ACE_THROW_SPEC ((
01634       CORBA::SystemException
01635     ))
01636 {
01637   if (this->destroyed_)
01638     {
01639       ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
01640                         0);
01641     }
01642 
01643   return this->component_count_;
01644 }
01645 
01646 void
01647 TAO_DynCommon::set_flag (DynamicAny::DynAny_ptr component,
01648                          CORBA::Boolean destroying
01649                          ACE_ENV_ARG_DECL)
01650   ACE_THROW_SPEC ((
01651       CORBA::SystemException
01652     ))
01653 {
01654   CORBA::TypeCode_var tc = component->type (ACE_ENV_SINGLE_ARG_PARAMETER);
01655   ACE_CHECK;
01656 
01657   CORBA::TCKind tk = TAO_DynAnyFactory::unalias (tc.in ()
01658                                                  ACE_ENV_ARG_PARAMETER);
01659   ACE_CHECK;
01660 
01661   switch (tk)
01662   {
01663     case CORBA::tk_array:
01664       {
01665         TAO_DynArray_i *tmp =
01666           TAO_DynArray_i::_narrow (component
01667                                    ACE_ENV_ARG_PARAMETER);
01668         ACE_CHECK;
01669 
01670         if (destroying)
01671           {
01672             tmp->container_is_destroying_ = 1;
01673           }
01674         else
01675           {
01676             tmp->ref_to_component_ = 1;
01677           }
01678 
01679         break;
01680       }
01681     case CORBA::tk_enum:
01682       {
01683         TAO_DynEnum_i *tmp = TAO_DynEnum_i::_narrow (component
01684                                                      ACE_ENV_ARG_PARAMETER);
01685         ACE_CHECK;
01686 
01687         if (destroying)
01688           {
01689             tmp->container_is_destroying_ = 1;
01690           }
01691         else
01692           {
01693             tmp->ref_to_component_ = 1;
01694           }
01695 
01696         break;
01697       }
01698     case CORBA::tk_sequence:
01699       {
01700         TAO_DynSequence_i *tmp =
01701           TAO_DynSequence_i::_narrow (component
01702                                       ACE_ENV_ARG_PARAMETER);
01703         ACE_CHECK;
01704 
01705         if (destroying)
01706           {
01707             tmp->container_is_destroying_ = 1;
01708           }
01709         else
01710           {
01711             tmp->ref_to_component_ = 1;
01712           }
01713 
01714         break;
01715       }
01716     case CORBA::tk_struct:
01717       {
01718         TAO_DynStruct_i *tmp =
01719           TAO_DynStruct_i::_narrow (component
01720                                     ACE_ENV_ARG_PARAMETER);
01721         ACE_CHECK;
01722 
01723         if (destroying)
01724           {
01725             tmp->container_is_destroying_ = 1;
01726           }
01727         else
01728           {
01729             tmp->ref_to_component_ = 1;
01730           }
01731 
01732         break;
01733       }
01734     case CORBA::tk_union:
01735       {
01736         TAO_DynUnion_i *tmp =
01737           TAO_DynUnion_i::_narrow (component
01738                                    ACE_ENV_ARG_PARAMETER);
01739         ACE_CHECK;
01740 
01741         if (destroying)
01742           {
01743             tmp->container_is_destroying_ = 1;
01744           }
01745         else
01746           {
01747             tmp->ref_to_component_ = 1;
01748           }
01749 
01750         break;
01751       }
01752     case CORBA::tk_fixed:
01753     case CORBA::tk_value:
01754     case CORBA::tk_value_box:
01755       ACE_THROW (CORBA::NO_IMPLEMENT ());
01756     default:
01757       {
01758         TAO_DynAny_i *tmp = TAO_DynAny_i::_narrow (component
01759                                                    ACE_ENV_ARG_PARAMETER);
01760         ACE_CHECK;
01761 
01762         if (destroying)
01763           {
01764             tmp->container_is_destroying_ = 1;
01765           }
01766         else
01767           {
01768             tmp->ref_to_component_ = 1;
01769           }
01770 
01771         break;
01772       }
01773   }
01774 }
01775 
01776 DynamicAny::DynAny_ptr
01777 TAO_DynCommon::check_component (ACE_ENV_SINGLE_ARG_DECL)
01778   ACE_THROW_SPEC ((
01779       CORBA::SystemException,
01780       DynamicAny::DynAny::TypeMismatch,
01781       DynamicAny::DynAny::InvalidValue
01782     ))
01783 {
01784   if (this->current_position_ == -1)
01785     {
01786       ACE_THROW_RETURN (DynamicAny::DynAny::InvalidValue (),
01787                         DynamicAny::DynAny::_nil ());
01788     }
01789 
01790   DynamicAny::DynAny_var cc =
01791     this->current_component (ACE_ENV_SINGLE_ARG_PARAMETER);
01792   ACE_CHECK_RETURN (DynamicAny::DynAny::_nil ());
01793 
01794   CORBA::TypeCode_var tc = cc->type (ACE_ENV_SINGLE_ARG_PARAMETER);
01795   ACE_CHECK_RETURN (DynamicAny::DynAny::_nil ());
01796 
01797   CORBA::TCKind kind = TAO_DynAnyFactory::unalias (tc.in ()
01798                                                    ACE_ENV_ARG_PARAMETER);
01799   ACE_CHECK_RETURN (DynamicAny::DynAny::_nil ());
01800 
01801   // We are here because we are a component that is the target of
01802   // an insert_*() call on our container. It is
01803   // illegal to insert anything into a component that itself has
01804   // components.
01805   switch (kind)
01806   {
01807     case CORBA::tk_array:
01808     case CORBA::tk_except:
01809     case CORBA::tk_sequence:
01810     case CORBA::tk_struct:
01811     case CORBA::tk_union:
01812       ACE_THROW_RETURN (DynamicAny::DynAny::TypeMismatch (),
01813                         DynamicAny::DynAny::_nil ());
01814     default:
01815       return cc._retn ();
01816   }
01817 }
01818 
01819 void
01820 TAO_DynCommon::check_type (CORBA::TypeCode_ptr tc
01821                            ACE_ENV_ARG_DECL)
01822   ACE_THROW_SPEC ((
01823       CORBA::SystemException,
01824       DynamicAny::DynAny::TypeMismatch
01825     ))
01826 {
01827   CORBA::Boolean equivalent =
01828     this->type_->equivalent (tc
01829                              ACE_ENV_ARG_PARAMETER);
01830   ACE_CHECK;
01831 
01832   if (!equivalent)
01833     {
01834       ACE_THROW (DynamicAny::DynAny::TypeMismatch ());
01835     }
01836 }
01837 
01838 CORBA::TypeCode_ptr
01839 TAO_DynCommon::check_type_and_unalias (CORBA::TypeCode_ptr tc
01840                                        ACE_ENV_ARG_DECL)
01841   ACE_THROW_SPEC ((
01842       CORBA::SystemException,
01843       DynamicAny::DynAny::TypeMismatch
01844     ))
01845 {
01846   this->check_type (tc
01847                     ACE_ENV_ARG_PARAMETER);
01848   ACE_CHECK_RETURN (CORBA::TypeCode::_nil ());
01849 
01850   return TAO_DynAnyFactory::strip_alias (tc
01851                                          ACE_ENV_ARG_PARAMETER);
01852 }
01853 
01854 TAO_END_VERSIONED_NAMESPACE_DECL