TAO/tao/AnyTypeCode/TypeCode.cpp

   1 #include "tao/AnyTypeCode/TypeCode.h"
   2
   3 #if !defined (__ACE_INLINE__)
   4 # include "tao/AnyTypeCode/TypeCode.inl"
   5 #endif /* ! __ACE_INLINE__ */
   6
   7 #include "tao/CDR.h"
   8 #include "tao/ORB_Constants.h"
   9 #include "tao/debug.h"
  10 #include "tao/SystemException.h"
  11
  12 #include "ace/OS_NS_string.h"
  13 #include <cstring>
  14
  15 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
  16
  17 CORBA::TypeCode::~TypeCode ()
  18 {
  19 }
  20
  21 bool
  22 CORBA::TypeCode::tao_marshal_kind (TAO_OutputCDR & cdr) const
  23 {
  24   return cdr << this->kind_;
  25 }
  26
  27 CORBA::Boolean
  28 CORBA::TypeCode::equal (TypeCode_ptr tc) const
  29 {
  30   if (this == tc)
  31     {
  32       return true;
  33     }
  34   else if (CORBA::is_nil (tc))
  35     {
  36       throw ::CORBA::BAD_PARAM (CORBA::OMGVMCID | 13, CORBA::COMPLETED_NO);
  37     }
  38
  39   CORBA::TCKind const tc_kind = tc->kind ();
  40
  41   if (tc_kind != this->kind_)
  42     return false;
  43
  44   try
  45     {
  46       char const * const tc_id = tc->id ();
  47
  48       char const * const this_id = this->id ();
  49
  50       if (std::strcmp (this_id, tc_id) != 0)
  51         return false;
  52
  53       char const * const tc_name = tc->name ();
  54
  55       char const * const this_name = this->name ();
  56
  57       if (std::strcmp (this_name, tc_name) != 0)
  58         return false;
  59     }
  60   catch (const ::CORBA::TypeCode::BadKind&)
  61     {
  62       // Some TypeCodes do not support the id() and name()
  63       // operations.  Ignore the failure, and continue equality
  64       // verification using TypeCode subclass-specific techniques
  65       // below.
  66     }
  67
  68   return this->equal_i (tc);
  69 }
  70
  71 CORBA::Boolean
  72 CORBA::TypeCode::equivalent (TypeCode_ptr tc) const
  73 {
  74   if (this == tc)
  75     {
  76       return true;
  77     }
  78   else if (CORBA::is_nil (tc))
  79     {
  80       throw ::CORBA::BAD_PARAM (CORBA::OMGVMCID | 13, CORBA::COMPLETED_NO);
  81     }
  82
  83   CORBA::TypeCode_ptr const mutable_this =
  84     const_cast<CORBA::TypeCode_ptr> (this);
  85
  86   CORBA::TypeCode_var unaliased_this = TAO::unaliased_typecode (mutable_this);
  87   CORBA::TypeCode_var unaliased_tc = TAO::unaliased_typecode (tc);
  88
  89   CORBA::TCKind const this_kind = unaliased_this->kind ();
  90   CORBA::TCKind const tc_kind = unaliased_tc->kind ();
  91
  92   if (tc_kind != this_kind)
  93     return false;
  94
  95   try
  96     {
  97       char const * const this_id = unaliased_this->id ();
  98       char const * const tc_id = unaliased_tc->id ();
  99
 100       if (std::strlen (this_id) != 0
 101           && std::strlen (tc_id) != 0)
 102         {
 103           return std::strcmp (this_id, tc_id) == 0;
 104         }
 105     }
 106   catch (const ::CORBA::TypeCode::BadKind&)
 107     {
 108       // Some TypeCodes do not support the id() operation.  Ignore the
 109       // failure, and continue equivalence verification using TypeCode
 110       // subclass-specific techniques.
 111     }
 112
 113   return unaliased_this->equivalent_i (unaliased_tc.in ());
 114 }
 115
 116 char const *
 117 CORBA::TypeCode::id_i () const
 118 {
 119   throw ::CORBA::TypeCode::BadKind ();
 120 }
 121
 122 char const *
 123 CORBA::TypeCode::name_i () const
 124 {
 125   throw ::CORBA::TypeCode::BadKind ();
 126 }
 127
 128 CORBA::ULong
 129 CORBA::TypeCode::member_count_i () const
 130 {
 131   throw ::CORBA::TypeCode::BadKind ();
 132 }
 133
 134 char const *
 135 CORBA::TypeCode::member_name_i (CORBA::ULong /* index */) const
 136 {
 137   throw ::CORBA::TypeCode::BadKind ();
 138 }
 139
 140 CORBA::TypeCode_ptr
 141 CORBA::TypeCode::member_type_i (CORBA::ULong /* index */) const
 142 {
 143   throw ::CORBA::TypeCode::BadKind ();
 144 }
 145
 146 CORBA::Any *
 147 CORBA::TypeCode::member_label_i (CORBA::ULong /* index */) const
 148 {
 149   throw ::CORBA::TypeCode::BadKind ();
 150 }
 151
 152 CORBA::TypeCode_ptr
 153 CORBA::TypeCode::discriminator_type_i () const
 154 {
 155   throw ::CORBA::TypeCode::BadKind ();
 156 }
 157
 158 CORBA::Long
 159 CORBA::TypeCode::default_index_i () const
 160 {
 161   throw ::CORBA::TypeCode::BadKind ();
 162 }
 163
 164 CORBA::ULong
 165 CORBA::TypeCode::length_i () const
 166 {
 167   throw ::CORBA::TypeCode::BadKind ();
 168 }
 169
 170 CORBA::TypeCode_ptr
 171 CORBA::TypeCode::content_type_i () const
 172 {
 173   throw ::CORBA::TypeCode::BadKind ();
 174 }
 175
 176 CORBA::UShort
 177 CORBA::TypeCode::fixed_digits_i () const
 178 {
 179   throw ::CORBA::TypeCode::BadKind ();
 180 }
 181
 182 CORBA::UShort
 183 CORBA::TypeCode::fixed_scale_i () const
 184 {
 185   throw ::CORBA::TypeCode::BadKind ();
 186 }
 187
 188 CORBA::Visibility
 189 CORBA::TypeCode::member_visibility_i (CORBA::ULong /* index */) const
 190 {
 191   throw ::CORBA::TypeCode::BadKind ();
 192 }
 193
 194 CORBA::ValueModifier
 195 CORBA::TypeCode::type_modifier_i () const
 196 {
 197   throw ::CORBA::TypeCode::BadKind ();
 198 }
 199
 200 CORBA::TypeCode_ptr
 201 CORBA::TypeCode::concrete_base_type_i () const
 202 {
 203   throw ::CORBA::TypeCode::BadKind ();
 204 }
 205
 206 // ---------------------------------------------------------------
 207
 208 CORBA::TypeCode::Bounds::Bounds ()
 209   : CORBA::UserException ("IDL:omg.org/CORBA/TypeCode/Bounds:1.0",
 210                           "Bounds")
 211 {
 212 }
 213
 214 CORBA::TypeCode::Bounds*
 215 CORBA::TypeCode::Bounds::_downcast (CORBA::Exception *ex)
 216 {
 217    return dynamic_cast <CORBA::TypeCode::Bounds*> (ex);
 218 }
 219
 220 CORBA::Exception *
 221 CORBA::TypeCode::Bounds::_alloc ()
 222 {
 223   CORBA::Exception *retval = 0;
 224   ACE_NEW_RETURN (retval, ::CORBA::TypeCode::Bounds, 0);
 225   return retval;
 226 }
 227
 228 CORBA::Exception *
 229 CORBA::TypeCode::Bounds::_tao_duplicate () const
 230 {
 231   CORBA::Exception *result;
 232   ACE_NEW_RETURN (result,
 233                   CORBA::TypeCode::Bounds (*this),
 234                   0);
 235   return result;
 236 }
 237
 238 void
 239 CORBA::TypeCode::Bounds::_raise () const
 240 {
 241   throw *this;
 242 }
 243
 244 void
 245 CORBA::TypeCode::Bounds::_tao_encode (TAO_OutputCDR &cdr) const
 246 {
 247   if (cdr << this->_rep_id ())
 248     {
 249       return;
 250     }
 251
 252   throw ::CORBA::MARSHAL ();
 253 }
 254
 255 void
 256 CORBA::TypeCode::Bounds::_tao_decode (TAO_InputCDR &)
 257 {
 258 }
 259
 260 // ****************************************************************
 261
 262 CORBA::TypeCode::BadKind::BadKind ()
 263   : CORBA::UserException ("IDL:omg.org/CORBA/TypeCode/BadKind:1.0",
 264                           "BadKind")
 265 {
 266 }
 267
 268 CORBA::TypeCode::BadKind*
 269 CORBA::TypeCode::BadKind::_downcast (CORBA::Exception *ex)
 270 {
 271   return dynamic_cast <CORBA::TypeCode::BadKind*> (ex);
 272 }
 273
 274 CORBA::Exception *
 275 CORBA::TypeCode::BadKind::_tao_duplicate () const
 276 {
 277   CORBA::Exception *result = 0;
 278   ACE_NEW_RETURN (result,
 279                   CORBA::TypeCode::BadKind (*this),
 280                   0);
 281   return result;
 282 }
 283
 284 void
 285 CORBA::TypeCode::BadKind::_raise () const
 286 {
 287   throw *this;
 288 }
 289
 290 void
 291 CORBA::TypeCode::BadKind::_tao_encode (TAO_OutputCDR &cdr) const
 292 {
 293   if (cdr << this->_rep_id ())
 294     {
 295       return;
 296     }
 297
 298   throw ::CORBA::MARSHAL ();
 299 }
 300
 301 void
 302 CORBA::TypeCode::BadKind::_tao_decode (TAO_InputCDR &)
 303 {
 304 }
 305
 306 // ---------------------------------------------------------------
 307
 308 bool
 309 TAO::TypeCode::marshal (TAO_OutputCDR & cdr,
 310                         CORBA::TypeCode_ptr tc,
 311                         CORBA::ULong offset)
 312 {
 313   // Marshal the TypeCode TCKind and TypeCode body.
 314   //
 315   // Update the offset value in case a recursive TypeCode is being
 316   // marshaled.
 317
 318   return
 319     tc != 0
 320     && tc->tao_marshal_kind (cdr)
 321     && tc->tao_marshal (cdr, aligned_offset (offset) + sizeof (CORBA::ULong));
 322 }
 323
 324 CORBA::ULong
 325 TAO::TypeCode::aligned_offset (CORBA::ULong offset)
 326 {
 327   ptrdiff_t const unaligned_offset =
 328     static_cast<ptrdiff_t> (offset);
 329
 330   return
 331     static_cast<CORBA::ULong> (ACE_align_binary (unaligned_offset,
 332                                                  ACE_CDR::LONG_ALIGN));
 333 }
 334
 335 // ---------------------------------------------------------------
 336
 337 CORBA::Boolean
 338 operator<< (TAO_OutputCDR & cdr,
 339             const CORBA::TypeCode_ptr tc)
 340 {
 341   return TAO::TypeCode::marshal (cdr, tc, 0);
 342 }
 343
 344 // ---------------------------------------------------------------
 345
 346 #if defined (GEN_OSTREAM_OPS)
 347
 348 std::ostream &
 349 operator<< (std::ostream & strm,
 350             const CORBA::TypeCode_ptr)
 351 {
 352   return strm << "CORBA::TypeCode";
 353 }
 354
 355 #endif /* GEN_OSTREAM_OPS */
 356
 357 // ---------------------------------------------------------------
 358
 359 CORBA::TypeCode_ptr
 360 TAO::unaliased_typecode (CORBA::TypeCode_ptr tc)
 361 {
 362   if (CORBA::is_nil (tc))
 363     {
 364       throw ::CORBA::BAD_PARAM (CORBA::OMGVMCID | 13, CORBA::COMPLETED_NO);
 365     }
 366
 367   CORBA::TCKind tc_kind = tc->kind ();
 368
 369   if (tc_kind == CORBA::tk_alias)
 370     {
 371       CORBA::TypeCode_var tc_content = CORBA::TypeCode::_duplicate (tc);
 372
 373       // Iterate until we get to the actual unaliased type.
 374       do
 375         {
 376           tc_content = tc_content->content_type ();
 377
 378           tc_kind = tc_content->kind ();
 379         }
 380       while (tc_kind == CORBA::tk_alias);
 381
 382       return tc_content._retn ();
 383     }
 384
 385   return CORBA::TypeCode::_duplicate (tc);
 386 }
 387
 388 // =========================================================
 389
 390 // Traits specializations for CORBA::TypeCode.
 391 namespace TAO
 392 {
 393   CORBA::TypeCode_ptr
 394   Objref_Traits<CORBA::TypeCode>::duplicate (CORBA::TypeCode_ptr p)
 395   {
 396     return CORBA::TypeCode::_duplicate (p);
 397   }
 398
 399   void
 400   Objref_Traits<CORBA::TypeCode>::release (CORBA::TypeCode_ptr p)
 401   {
 402     ::CORBA::release (p);
 403   }
 404
 405   CORBA::TypeCode_ptr
 406   Objref_Traits<CORBA::TypeCode>::nil ()
 407   {
 408     return CORBA::TypeCode::_nil ();
 409   }
 410
 411   CORBA::Boolean
 412   Objref_Traits<CORBA::TypeCode>::marshal (CORBA::TypeCode_ptr p,
 413                                            TAO_OutputCDR & cdr)
 414   {
 415     return cdr << p;
 416   }
 417
 418   void
 419   In_Object_Argument_Cloner_T<CORBA::TypeCode_ptr>::duplicate (
 420                                                 CORBA::TypeCode_ptr p)
 421   {
 422     CORBA::TypeCode::_duplicate (p);
 423   }
 424
 425   void
 426   In_Object_Argument_Cloner_T<CORBA::TypeCode_ptr>::release (
 427                                                 CORBA::TypeCode_ptr p)
 428   {
 429     CORBA::release (p);
 430   }
 431 }
 432
 433 // =========================================================
 434
 435 CORBA::TCKind
 436 TAO::unaliased_kind (CORBA::TypeCode_ptr tc)
 437 {
 438   CORBA::TypeCode_var unaliased_tc = TAO::unaliased_typecode (tc);
 439
 440   return unaliased_tc->kind ();
 441 }
 442
 443 TAO_END_VERSIONED_NAMESPACE_DECL