TAO_DynamicAny: DynAnyFactory.cpp Source File

00001 //=============================================================================
00002 /**
00003  *  @file    DynAnyFactory.cpp
00004  *
00005  *  DynAnyFactory.cpp,v 1.12 2006/03/10 07:19:07 jtc Exp
00006  *
00007  *  @author Carlos O'Ryan <coryan@uci.edu>
00008  */
00009 //=============================================================================
00010 
00011 
00012 #include "tao/DynamicAny/DynAnyFactory.h"
00013 
00014 #include "tao/DynamicAny/DynAny_i.h"
00015 #include "tao/DynamicAny/DynStruct_i.h"
00016 #include "tao/DynamicAny/DynSequence_i.h"
00017 #include "tao/DynamicAny/DynEnum_i.h"
00018 #include "tao/DynamicAny/DynArray_i.h"
00019 #include "tao/DynamicAny/DynUnion_i.h"
00020 
00021 #include "ace/Auto_Ptr.h"
00022 
00023 ACE_RCSID (DynamicAny,
00024            DynAnyFactory,
00025            "DynAnyFactory.cpp,v 1.12 2006/03/10 07:19:07 jtc Exp")
00026 
00027 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
00028 
00029 // Constructor from typecode
00030 TAO_DynAnyFactory::TAO_DynAnyFactory (void)
00031 {
00032 }
00033 
00034 // Utility function called by all the DynAny classes
00035 // to extract the TCKind of possibly aliased types.
00036 CORBA::TCKind
00037 TAO_DynAnyFactory::unalias (CORBA::TypeCode_ptr tc
00038                             ACE_ENV_ARG_DECL)
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 }
00056 
00057 // Same as above, but returns the type code.
00058 CORBA::TypeCode_ptr
00059 TAO_DynAnyFactory::strip_alias (CORBA::TypeCode_ptr tc
00060                                 ACE_ENV_ARG_DECL)
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 }
00077 
00078 DynamicAny::DynAny_ptr
00079 TAO_DynAnyFactory::create_dyn_any (
00080       const CORBA::Any & value
00081       ACE_ENV_ARG_DECL
00082     )
00083   ACE_THROW_SPEC ((
00084       CORBA::SystemException,
00085       DynamicAny::DynAnyFactory::InconsistentTypeCode
00086     ))
00087 {
00088   return TAO_DynAnyFactory::make_dyn_any (value ACE_ENV_ARG_PARAMETER);
00089 }
00090 
00091 DynamicAny::DynAny_ptr
00092 TAO_DynAnyFactory::create_dyn_any_from_type_code (
00093       CORBA::TypeCode_ptr type
00094       ACE_ENV_ARG_DECL
00095     )
00096   ACE_THROW_SPEC ((
00097       CORBA::SystemException,
00098       DynamicAny::DynAnyFactory::InconsistentTypeCode
00099     ))
00100 {
00101   return TAO_DynAnyFactory::make_dyn_any (type ACE_ENV_ARG_PARAMETER);
00102 }
00103 
00104 DynamicAny::DynAny_ptr
00105 TAO_DynAnyFactory::make_dyn_any (const CORBA::Any &any
00106                                  ACE_ENV_ARG_DECL)
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 }
00242 
00243 DynamicAny::DynAny_ptr
00244 TAO_DynAnyFactory::make_dyn_any (CORBA::TypeCode_ptr tc
00245                                  ACE_ENV_ARG_DECL)
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 }
00380 
00381 TAO_END_VERSIONED_NAMESPACE_DECL