Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | File List | Namespace Members | Class Members | File Members | Search for 

TAO_DynAnyFactory Class Reference

#include <DynAnyFactory.h>

Inheritance diagram for TAO_DynAnyFactory:

Inheritance graph
[legend]
Collaboration diagram for TAO_DynAnyFactory:

Collaboration graph
[legend]
List of all members.

Public Member Functions

 TAO_DynAnyFactory (void)
 Constructor.

virtual DynamicAny::DynAny_ptr create_dyn_any (const CORBA::Any &value) throw ( CORBA::SystemException, DynamicAny::DynAnyFactory::InconsistentTypeCode )
virtual DynamicAny::DynAny_ptr create_dyn_any_from_type_code (CORBA::TypeCode_ptr type) throw ( CORBA::SystemException, DynamicAny::DynAnyFactory::InconsistentTypeCode )

Static Public Member Functions

CORBA::TCKind unalias (CORBA::TypeCode_ptr tc)
 Obtain the kind of object, after all aliasing has been removed.

CORBA::TypeCode_ptr strip_alias (CORBA::TypeCode_ptr tc)
DynamicAny::DynAny_ptr make_dyn_any (const CORBA::Any &any)
 Create the correct type of DynAny object for .

DynamicAny::DynAny_ptr make_dyn_any (CORBA::TypeCode_ptr tc)
 Create the correct type of DynAny object for .


Private Member Functions

 TAO_DynAnyFactory (const TAO_DynAnyFactory &src)
TAO_DynAnyFactory & operator= (const TAO_DynAnyFactory &src)

Detailed Description

Implements the DynamicAnyFactory interface and provides several utility functions shared by all the Dynamic Any components.

Definition at line 41 of file DynAnyFactory.h.

Constructor & Destructor Documentation

TAO_BEGIN_VERSIONED_NAMESPACE_DECL TAO_DynAnyFactory::TAO_DynAnyFactory (  void   ) 
 

Constructor.

Definition at line 30 of file DynAnyFactory.cpp. 

00031 {
00032 }

TAO_DynAnyFactory::TAO_DynAnyFactory (  const TAO_DynAnyFactory &  src  )  [private]
 

Member Function Documentation

DynamicAny::DynAny_ptr TAO_DynAnyFactory::create_dyn_any (  const CORBA::Any &  value  )  throw ( CORBA::SystemException, DynamicAny::DynAnyFactory::InconsistentTypeCode ) [virtual]
 

Definition at line 79 of file DynAnyFactory.cpp.

References ACE_ENV_ARG_PARAMETER, and make_dyn_any(). 

00087 {
00088   return TAO_DynAnyFactory::make_dyn_any (value ACE_ENV_ARG_PARAMETER);
00089 }

DynamicAny::DynAny_ptr TAO_DynAnyFactory::create_dyn_any_from_type_code (  CORBA::TypeCode_ptr  type  )  throw ( CORBA::SystemException, DynamicAny::DynAnyFactory::InconsistentTypeCode ) [virtual]
 

Definition at line 92 of file DynAnyFactory.cpp.

References ACE_ENV_ARG_PARAMETER, and make_dyn_any(). 

00100 {
00101   return TAO_DynAnyFactory::make_dyn_any (type ACE_ENV_ARG_PARAMETER);
00102 }

DynamicAny::DynAny_ptr TAO_DynAnyFactory::make_dyn_any (  CORBA::TypeCode_ptr  tc  )  [static]
 

Create the correct type of DynAny object for .

Definition at line 244 of file DynAnyFactory.cpp.

References DynamicAny::DynAny::_nil(), ACE_CHECK_RETURN, ACE_ENV_ARG_PARAMETER, ACE_NEW_THROW_EX, ACE_THROW_RETURN, TAO_DynArray_i::init(), TAO_DynEnum_i::init(), TAO_DynUnion_i::init(), TAO_DynSequence_i::init(), TAO_DynStruct_i::init(), TAO_DynAny_i::init(), ACE_Auto_Basic_Ptr< X >::release(), and unalias(). 

00246 {
00247   CORBA::TCKind kind =
00248     TAO_DynAnyFactory::unalias (tc ACE_ENV_ARG_PARAMETER);
00249   ACE_CHECK_RETURN (DynamicAny::DynAny::_nil ());
00250 
00251   switch (kind)
00252     {
00253       case CORBA::tk_null:
00254       case CORBA::tk_void:
00255       case CORBA::tk_short:
00256       case CORBA::tk_long:
00257       case CORBA::tk_ushort:
00258       case CORBA::tk_ulong:
00259       case CORBA::tk_float:
00260       case CORBA::tk_double:
00261       case CORBA::tk_longlong:
00262       case CORBA::tk_ulonglong:
00263       case CORBA::tk_boolean:
00264       case CORBA::tk_char:
00265       case CORBA::tk_wchar:
00266       case CORBA::tk_octet:
00267       case CORBA::tk_any:
00268       case CORBA::tk_TypeCode:
00269       case CORBA::tk_objref:
00270       case CORBA::tk_string:
00271       case CORBA::tk_wstring:
00272         {
00273           TAO_DynAny_i *p = 0;
00274 
00275           ACE_NEW_THROW_EX (p,
00276                             TAO_DynAny_i,
00277                             CORBA::NO_MEMORY ());
00278           ACE_CHECK_RETURN (0);
00279 
00280           ACE_Auto_Basic_Ptr<TAO_DynAny_i> dp (p);
00281           p->init (tc ACE_ENV_ARG_PARAMETER);
00282           ACE_CHECK_RETURN (0);
00283 
00284           return dp.release ();
00285         }
00286       case CORBA::tk_struct:
00287       case CORBA::tk_except:
00288         {
00289           TAO_DynStruct_i *p = 0;
00290 
00291           ACE_NEW_THROW_EX (p,
00292                             TAO_DynStruct_i,
00293                             CORBA::NO_MEMORY ());
00294           ACE_CHECK_RETURN (0);
00295 
00296           ACE_Auto_Basic_Ptr<TAO_DynStruct_i> dp (p);
00297           p->init (tc ACE_ENV_ARG_PARAMETER);
00298           ACE_CHECK_RETURN (0);
00299 
00300           return dp.release ();
00301         }
00302       case CORBA::tk_sequence:
00303         {
00304           TAO_DynSequence_i *p = 0;
00305 
00306           ACE_NEW_THROW_EX (p,
00307                             TAO_DynSequence_i,
00308                             CORBA::NO_MEMORY ());
00309           ACE_CHECK_RETURN (0);
00310 
00311           ACE_Auto_Basic_Ptr<TAO_DynSequence_i> dp (p);
00312           p->init (tc ACE_ENV_ARG_PARAMETER);
00313           ACE_CHECK_RETURN (0);
00314 
00315           return dp.release ();
00316         }
00317       case CORBA::tk_union:
00318         {
00319           TAO_DynUnion_i *p = 0;
00320 
00321           ACE_NEW_THROW_EX (p,
00322                             TAO_DynUnion_i,
00323                             CORBA::NO_MEMORY ());
00324           ACE_CHECK_RETURN (0);
00325 
00326           ACE_Auto_Basic_Ptr<TAO_DynUnion_i> dp (p);
00327           p->init (tc ACE_ENV_ARG_PARAMETER);
00328           ACE_CHECK_RETURN (0);
00329 
00330           return dp.release ();
00331         }
00332       case CORBA::tk_enum:
00333         {
00334           TAO_DynEnum_i *p = 0;
00335 
00336           ACE_NEW_THROW_EX (p,
00337                             TAO_DynEnum_i,
00338                             CORBA::NO_MEMORY ());
00339           ACE_CHECK_RETURN (0);
00340 
00341           ACE_Auto_Basic_Ptr<TAO_DynEnum_i> dp (p);
00342           p->init (tc ACE_ENV_ARG_PARAMETER);
00343           ACE_CHECK_RETURN (0);
00344 
00345           return dp.release ();
00346         }
00347       case CORBA::tk_array:
00348         {
00349           TAO_DynArray_i *p = 0;
00350 
00351           ACE_NEW_THROW_EX (p,
00352                             TAO_DynArray_i,
00353                             CORBA::NO_MEMORY ());
00354           ACE_CHECK_RETURN (0);
00355 
00356           ACE_Auto_Basic_Ptr<TAO_DynArray_i> dp (p);
00357           p->init (tc ACE_ENV_ARG_PARAMETER);
00358           ACE_CHECK_RETURN (0);
00359 
00360           return dp.release ();
00361         }
00362 
00363     case CORBA::tk_fixed:
00364     case CORBA::tk_value:
00365     case CORBA::tk_value_box:
00366     case CORBA::tk_abstract_interface:
00367     case CORBA::tk_component:
00368     case CORBA::tk_home:
00369       ACE_THROW_RETURN (CORBA::NO_IMPLEMENT (),
00370                         DynamicAny::DynAny::_nil ());
00371     case CORBA::tk_native:
00372       ACE_THROW_RETURN (DynamicAny::DynAnyFactory::InconsistentTypeCode (),
00373                         DynamicAny::DynAny::_nil ());
00374     default:
00375       break;
00376     }
00377 
00378   return DynamicAny::DynAny::_nil ();
00379 }

DynamicAny::DynAny_ptr TAO_DynAnyFactory::make_dyn_any (  const CORBA::Any &  any  )  [static]
 

Create the correct type of DynAny object for .

Definition at line 105 of file DynAnyFactory.cpp.

References DynamicAny::DynAny::_nil(), ACE_CHECK_RETURN, ACE_ENV_ARG_PARAMETER, ACE_NEW_THROW_EX, ACE_THROW_RETURN, TAO_DynArray_i::init(), TAO_DynEnum_i::init(), TAO_DynUnion_i::init(), TAO_DynSequence_i::init(), TAO_DynStruct_i::init(), TAO_DynAny_i::init(), ACE_Auto_Basic_Ptr< X >::release(), DynamicAny::DynAny::type(), and unalias().

Referenced by TAO_DynCommon::copy(), create_dyn_any(), create_dyn_any_from_type_code(), TAO_DynAny_i::equal(), TAO_DynStruct_i::from_any(), TAO_DynSequence_i::from_any(), TAO_DynArray_i::from_any(), TAO_DynCommon::get_dyn_any(), TAO_DynUnion_i::init(), TAO_DynStruct_i::init(), TAO_DynSequence_i::init(), TAO_DynArray_i::init(), TAO_DynUnion_i::set_discriminator(), TAO_DynSequence_i::set_elements(), TAO_DynArray_i::set_elements(), TAO_DynUnion_i::set_from_any(), TAO_DynStruct_i::set_from_any(), TAO_DynSequence_i::set_length(), TAO_DynStruct_i::set_members(), and TAO_DynUnion_i::set_to_default_member(). 

00107 {
00108   CORBA::TypeCode_var tc = any.type ();
00109   CORBA::TCKind kind = TAO_DynAnyFactory::unalias (tc.in ()
00110                                                    ACE_ENV_ARG_PARAMETER);
00111   ACE_CHECK_RETURN (DynamicAny::DynAny::_nil ());
00112 
00113   switch (kind)
00114     {
00115       case CORBA::tk_null:
00116       case CORBA::tk_void:
00117       case CORBA::tk_short:
00118       case CORBA::tk_long:
00119       case CORBA::tk_ushort:
00120       case CORBA::tk_ulong:
00121       case CORBA::tk_float:
00122       case CORBA::tk_double:
00123       case CORBA::tk_longlong:
00124       case CORBA::tk_ulonglong:
00125       case CORBA::tk_boolean:
00126       case CORBA::tk_char:
00127       case CORBA::tk_wchar:
00128       case CORBA::tk_octet:
00129       case CORBA::tk_any:
00130       case CORBA::tk_TypeCode:
00131       case CORBA::tk_objref:
00132       case CORBA::tk_string:
00133       case CORBA::tk_wstring:
00134         {
00135           TAO_DynAny_i *p = 0;
00136 
00137           ACE_NEW_THROW_EX (p,
00138                             TAO_DynAny_i,
00139                             CORBA::NO_MEMORY ());
00140           ACE_CHECK_RETURN (0);
00141 
00142           ACE_Auto_Basic_Ptr<TAO_DynAny_i> dp (p);
00143           p->init (any ACE_ENV_ARG_PARAMETER);
00144           ACE_CHECK_RETURN (0);
00145 
00146           return dp.release ();
00147         }
00148       case CORBA::tk_struct:
00149       case CORBA::tk_except:
00150         {
00151           TAO_DynStruct_i *p = 0;
00152 
00153           ACE_NEW_THROW_EX (p,
00154                             TAO_DynStruct_i,
00155                             CORBA::NO_MEMORY ());
00156           ACE_CHECK_RETURN (0);
00157 
00158           ACE_Auto_Basic_Ptr<TAO_DynStruct_i> dp (p);
00159           p->init (any ACE_ENV_ARG_PARAMETER);
00160           ACE_CHECK_RETURN (0);
00161 
00162           return dp.release ();
00163         }
00164       case CORBA::tk_sequence:
00165         {
00166           TAO_DynSequence_i *p = 0;
00167 
00168           ACE_NEW_THROW_EX (p,
00169                             TAO_DynSequence_i,
00170                             CORBA::NO_MEMORY ());
00171           ACE_CHECK_RETURN (0);
00172 
00173           ACE_Auto_Basic_Ptr<TAO_DynSequence_i> dp (p);
00174           p->init (any ACE_ENV_ARG_PARAMETER);
00175           ACE_CHECK_RETURN (0);
00176 
00177           return dp.release ();
00178         }
00179       case CORBA::tk_union:
00180         {
00181           TAO_DynUnion_i *p = 0;
00182 
00183           ACE_NEW_THROW_EX (p,
00184                             TAO_DynUnion_i,
00185                             CORBA::NO_MEMORY ());
00186           ACE_CHECK_RETURN (0);
00187 
00188           ACE_Auto_Basic_Ptr<TAO_DynUnion_i> dp (p);
00189           p->init (any ACE_ENV_ARG_PARAMETER);
00190           ACE_CHECK_RETURN (0);
00191 
00192           return dp.release ();
00193         }
00194       case CORBA::tk_enum:
00195         {
00196           TAO_DynEnum_i *p = 0;
00197 
00198           ACE_NEW_THROW_EX (p,
00199                             TAO_DynEnum_i,
00200                             CORBA::NO_MEMORY ());
00201           ACE_CHECK_RETURN (0);
00202 
00203           ACE_Auto_Basic_Ptr<TAO_DynEnum_i> dp (p);
00204           p->init (any ACE_ENV_ARG_PARAMETER);
00205           ACE_CHECK_RETURN (0);
00206 
00207           return dp.release ();
00208         }
00209       case CORBA::tk_array:
00210         {
00211           TAO_DynArray_i *p = 0;
00212 
00213           ACE_NEW_THROW_EX (p,
00214                             TAO_DynArray_i,
00215                             CORBA::NO_MEMORY ());
00216           ACE_CHECK_RETURN (0);
00217 
00218           ACE_Auto_Basic_Ptr<TAO_DynArray_i> dp (p);
00219           p->init (any ACE_ENV_ARG_PARAMETER);
00220           ACE_CHECK_RETURN (0);
00221 
00222           return dp.release ();
00223         }
00224 
00225     case CORBA::tk_fixed:
00226     case CORBA::tk_value:
00227     case CORBA::tk_value_box:
00228     case CORBA::tk_abstract_interface:
00229     case CORBA::tk_component:
00230     case CORBA::tk_home:
00231       ACE_THROW_RETURN (CORBA::NO_IMPLEMENT (),
00232                         DynamicAny::DynAny::_nil ());
00233     case CORBA::tk_native:
00234       ACE_THROW_RETURN (DynamicAny::DynAnyFactory::InconsistentTypeCode (),
00235                         DynamicAny::DynAny::_nil ());
00236     default:
00237       break;
00238     }
00239 
00240   return DynamicAny::DynAny::_nil ();
00241 }

TAO_DynAnyFactory& TAO_DynAnyFactory::operator= (  const TAO_DynAnyFactory &  src  )  [private]
 

CORBA::TypeCode_ptr TAO_DynAnyFactory::strip_alias (  CORBA::TypeCode_ptr  tc  )  [static]
 

Same as above, but returns type code instead of TCKind. Caller must release the return value.

Definition at line 59 of file DynAnyFactory.cpp.

References ACE_CHECK_RETURN, and ACE_ENV_SINGLE_ARG_PARAMETER.

Referenced by TAO_DynCommon::check_type_and_unalias(), TAO_DynStruct_i::current_member_kind(), TAO_DynStruct_i::current_member_name(), TAO_DynAny_i::equal(), TAO_DynStruct_i::get_members(), TAO_DynStruct_i::get_members_as_dyn_any(), TAO_DynCommon::get_string(), TAO_DynUnion_i::init(), TAO_DynStruct_i::init(), TAO_DynCommon::insert_string(), TAO_DynUnion_i::set_discriminator(), TAO_DynSequence_i::set_elements(), TAO_DynSequence_i::set_elements_as_dyn_any(), TAO_DynUnion_i::set_from_any(), TAO_DynStruct_i::set_from_any(), TAO_DynSequence_i::set_length(), TAO_DynStruct_i::set_members(), TAO_DynStruct_i::set_members_as_dyn_any(), TAO_DynUnion_i::set_to_default_member(), and TAO_DynUnion_i::set_to_no_active_member(). 

00061 {
00062   CORBA::TypeCode_var retval = CORBA::TypeCode::_duplicate (tc);
00063   CORBA::TCKind tck = retval->kind (ACE_ENV_SINGLE_ARG_PARAMETER);
00064   ACE_CHECK_RETURN (CORBA::TypeCode::_nil ());
00065 
00066   while (tck == CORBA::tk_alias)
00067     {
00068       retval = retval->content_type (ACE_ENV_SINGLE_ARG_PARAMETER);
00069       ACE_CHECK_RETURN (CORBA::TypeCode::_nil ());
00070 
00071       tck = retval->kind (ACE_ENV_SINGLE_ARG_PARAMETER);
00072       ACE_CHECK_RETURN (CORBA::TypeCode::_nil ());
00073     }
00074 
00075   return retval._retn ();
00076 }

CORBA::TCKind TAO_DynAnyFactory::unalias (  CORBA::TypeCode_ptr  tc  )  [static]
 

Obtain the kind of object, after all aliasing has been removed.

Definition at line 37 of file DynAnyFactory.cpp.

References ACE_CHECK_RETURN, ACE_ENV_ARG_PARAMETER, and ACE_ENV_SINGLE_ARG_PARAMETER.

Referenced by TAO_DynCommon::check_component(), TAO_DynStruct_i::check_typecode(), TAO_DynAny_i::check_typecode(), TAO_DynStruct_i::current_member_kind(), TAO_DynUnion_i::discriminator_kind(), TAO_DynAny_i::equal(), TAO_DynStruct_i::from_any(), TAO_DynEnum_i::from_any(), TAO_DynUnion_i::init(), TAO_DynSequence_i::init(), TAO_DynEnum_i::init(), TAO_DynArray_i::init(), TAO_DynCommon::insert_reference(), TAO_DynUnion_i::label_match(), make_dyn_any(), TAO_DynUnion_i::member_kind(), TAO_DynCommon::set_flag(), TAO_DynStruct_i::set_from_any(), TAO_DynAny_i::set_to_default_value(), TAO_DynUnion_i::set_to_no_active_member(), and TAO_DynStruct_i::to_any(). 

00039 {
00040   CORBA::TCKind tck = tc->kind (ACE_ENV_SINGLE_ARG_PARAMETER);
00041   ACE_CHECK_RETURN (CORBA::tk_null);
00042 
00043   while (tck == CORBA::tk_alias)
00044     {
00045       CORBA::TypeCode_var temp =
00046         tc->content_type (ACE_ENV_SINGLE_ARG_PARAMETER);
00047       ACE_CHECK_RETURN (CORBA::tk_null);
00048 
00049       tck = TAO_DynAnyFactory::unalias (temp.in ()
00050                                         ACE_ENV_ARG_PARAMETER);
00051       ACE_CHECK_RETURN (CORBA::tk_null);
00052     }
00053 
00054   return tck;
00055 }

The documentation for this class was generated from the following files:
Generated on Thu Nov 9 13:02:34 2006 for TAO_DynamicAny by doxygen 1.3.6