TAO/tao/DynamicAny/DynArray_i.cpp

   1 // -*- C++ -*-
   2 #include "tao/DynamicAny/DynArray_i.h"
   3 #include "tao/DynamicAny/DynAnyFactory.h"
   4 #include "tao/DynamicAny/DynAnyUtils_T.h"
   5
   6 #include "tao/AnyTypeCode/Marshal.h"
   7 #include "tao/AnyTypeCode/Any_Unknown_IDL_Type.h"
   8 #include "tao/AnyTypeCode/AnyTypeCode_methods.h"
   9
  10 #include "tao/CDR.h"
  11
  12 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
  13
  14 TAO_DynArray_i::TAO_DynArray_i (CORBA::Boolean allow_truncation)
  15   : TAO_DynCommon (allow_truncation)
  16 {
  17 }
  18
  19 TAO_DynArray_i::~TAO_DynArray_i (void)
  20 {
  21 }
  22
  23 void
  24 TAO_DynArray_i::init_common (void)
  25 {
  26   this->ref_to_component_ = false;
  27   this->container_is_destroying_ = false;
  28   this->has_components_ = true;
  29   this->destroyed_ = false;
  30   this->current_position_ = 0;
  31   this->component_count_ = static_cast<CORBA::ULong> (this->da_members_.size ());
  32 }
  33
  34 void
  35 TAO_DynArray_i::init (const CORBA::Any & any)
  36 {
  37   CORBA::TypeCode_var tc = any.type ();
  38
  39   CORBA::TCKind kind = TAO_DynAnyFactory::unalias (tc.in ());
  40
  41   if (kind != CORBA::tk_array)
  42     {
  43       throw DynamicAny::DynAnyFactory::InconsistentTypeCode ();
  44     }
  45
  46   this->type_ = tc;
  47
  48   CORBA::ULong numfields = this->get_tc_length (tc.in ());
  49   // Resize the array.
  50   this->da_members_.size (numfields);
  51
  52   this->init_common ();
  53
  54   // Get the CDR stream of the Any, if there isn't one, make one.
  55   TAO::Any_Impl *impl = any.impl ();
  56   TAO_OutputCDR out;
  57   TAO_InputCDR cdr (static_cast<ACE_Message_Block *> (0));
  58
  59   if (impl->encoded  ())
  60     {
  61       TAO::Unknown_IDL_Type * const unk =
  62         dynamic_cast<TAO::Unknown_IDL_Type *> (impl);
  63
  64       if (!unk)
  65         throw CORBA::INTERNAL ();
  66
  67       cdr = unk->_tao_get_cdr ();
  68     }
  69   else
  70     {
  71       impl->marshal_value (out);
  72       TAO_InputCDR tmp_in (out);
  73       cdr = tmp_in;
  74     }
  75
  76   CORBA::TypeCode_var field_tc =
  77     this->get_element_type ();
  78
  79   for (CORBA::ULong i = 0; i < numfields; ++i)
  80     {
  81       CORBA::Any field_any;
  82       TAO::Unknown_IDL_Type *field_unk = 0;
  83       TAO_InputCDR unk_in (cdr);
  84       ACE_NEW (field_unk,
  85                TAO::Unknown_IDL_Type (field_tc.in (), unk_in));
  86       field_any.replace (field_unk);
  87
  88       // This recursive step will call the correct constructor
  89       // based on the type of field_any.
  90       this->da_members_[i] =
  91         TAO::MakeDynAnyUtils::make_dyn_any_t<const CORBA::Any&> (
  92           field_any._tao_get_typecode (),
  93           field_any,
  94           this->allow_truncation_ );
  95
  96       // Move to the next field in the CDR stream.
  97       (void) TAO_Marshal_Object::perform_skip (field_tc.in (), &cdr);
  98     }
  99 }
 100
 101 void
 102 TAO_DynArray_i::init (CORBA::TypeCode_ptr tc)
 103 {
 104   CORBA::TCKind kind = TAO_DynAnyFactory::unalias (tc);
 105
 106   if (kind != CORBA::tk_array)
 107     {
 108       throw DynamicAny::DynAnyFactory::InconsistentTypeCode ();
 109     }
 110
 111   this->type_ = CORBA::TypeCode::_duplicate (tc);
 112
 113   CORBA::ULong numfields = this->get_tc_length (tc);
 114
 115   // Resize the array.
 116   this->da_members_.size (numfields);
 117
 118   this->init_common ();
 119
 120   CORBA::TypeCode_var elemtype = this->get_element_type ();
 121
 122   for (CORBA::ULong i = 0; i < numfields; ++i)
 123     {
 124       // Recursively initialize each element.
 125       this->da_members_[i] =
 126         TAO::MakeDynAnyUtils::make_dyn_any_t<CORBA::TypeCode_ptr> (
 127           elemtype.in (),
 128           elemtype.in (),
 129           this->allow_truncation_ );
 130     }
 131 }
 132
 133 CORBA::TypeCode_ptr
 134 TAO_DynArray_i::get_element_type (void)
 135 {
 136   CORBA::TypeCode_var element_type =
 137     CORBA::TypeCode::_duplicate (this->type_.in ());
 138
 139   // Strip away aliases (if any) on top of the outer type
 140   CORBA::TCKind kind = element_type->kind ();
 141
 142   while (kind != CORBA::tk_array)
 143     {
 144       element_type = element_type->content_type ();
 145
 146       kind = element_type->kind ();
 147     }
 148
 149   // Return the content type.
 150   return element_type->content_type ();
 151 }
 152
 153 // Get the length from the (possibly aliased) typecode.
 154 CORBA::ULong
 155 TAO_DynArray_i::get_tc_length (CORBA::TypeCode_ptr tc)
 156 {
 157   CORBA::TypeCode_var tctmp = CORBA::TypeCode::_duplicate (tc);
 158   CORBA::TCKind kind = tctmp->kind ();
 159
 160   while (kind == CORBA::tk_alias)
 161     {
 162       tctmp = tctmp->content_type ();
 163       kind = tctmp->kind ();
 164     }
 165
 166   return tctmp->length ();
 167 }
 168
 169 // ****************************************************************
 170
 171 TAO_DynArray_i *
 172 TAO_DynArray_i::_narrow (CORBA::Object_ptr _tao_objref)
 173 {
 174   if (CORBA::is_nil (_tao_objref))
 175     {
 176       return 0;
 177     }
 178
 179   return dynamic_cast<TAO_DynArray_i *> (_tao_objref);
 180 }
 181
 182 // ****************************************************************
 183
 184 DynamicAny::AnySeq *
 185 TAO_DynArray_i::get_elements (void)
 186 {
 187   if (this->destroyed_)
 188     {
 189       throw ::CORBA::OBJECT_NOT_EXIST ();
 190     }
 191
 192   CORBA::ULong length = static_cast<CORBA::ULong> (this->da_members_.size ());
 193
 194   DynamicAny::AnySeq *elements = 0;
 195   ACE_NEW_THROW_EX (elements,
 196                     DynamicAny::AnySeq (length),
 197                     CORBA::NO_MEMORY ());
 198
 199   elements->length (length);
 200   DynamicAny::AnySeq_var safe_retval (elements);
 201
 202   CORBA::Any_var tmp;
 203
 204   // Initialize each Any.
 205   for (CORBA::ULong i = 0; i < length; i++)
 206     {
 207       tmp = this->da_members_[i]->to_any ();
 208
 209       safe_retval[i] = tmp.in ();
 210     }
 211
 212   return safe_retval._retn ();
 213 }
 214
 215 void
 216 TAO_DynArray_i::set_elements (const DynamicAny::AnySeq & value)
 217 {
 218   if (this->destroyed_)
 219     {
 220       throw ::CORBA::OBJECT_NOT_EXIST ();
 221     }
 222
 223   CORBA::ULong const length = value.length ();
 224
 225   if (length != this->da_members_.size ())
 226     {
 227       throw DynamicAny::DynAny::InvalidValue ();
 228     }
 229
 230   CORBA::TypeCode_var value_tc;
 231   CORBA::TypeCode_var element_type = this->get_element_type ();
 232
 233   for (CORBA::ULong i = 0; i < length; i++)
 234     {
 235       // Check each arg element for type match.
 236       value_tc = value[i].type ();
 237       CORBA::Boolean equivalent =
 238         value_tc->equivalent (element_type.in ());
 239
 240       if (equivalent)
 241         {
 242           this->da_members_[i]->destroy ();
 243
 244           this->da_members_[i] =
 245             TAO::MakeDynAnyUtils::make_dyn_any_t<const CORBA::Any&> (
 246               value[i]._tao_get_typecode (),
 247               value[i],
 248               this->allow_truncation_ );
 249         }
 250       else
 251         {
 252           throw DynamicAny::DynAny::TypeMismatch ();
 253         }
 254     }
 255 }
 256
 257 DynamicAny::DynAnySeq *
 258 TAO_DynArray_i::get_elements_as_dyn_any (void)
 259 {
 260   if (this->destroyed_)
 261     {
 262       throw ::CORBA::OBJECT_NOT_EXIST ();
 263     }
 264
 265   DynamicAny::DynAnySeq *retval = 0;
 266   ACE_NEW_THROW_EX (retval,
 267                     DynamicAny::DynAnySeq (this->component_count_),
 268                     CORBA::NO_MEMORY ());
 269
 270   retval->length (this->component_count_);
 271   DynamicAny::DynAnySeq_var safe_retval (retval);
 272
 273   for (CORBA::ULong i = 0; i < this->component_count_; ++i)
 274     {
 275       // A deep copy is made only by copy() (CORBA 2.4.2 section 9.2.3.6).
 276       // Set the flag so the caller can't destroy.
 277       this->set_flag (this->da_members_[i].in (), 0);
 278
 279       safe_retval[i] =
 280         DynamicAny::DynAny::_duplicate (this->da_members_[i].in ());
 281     }
 282
 283   return safe_retval._retn ();
 284 }
 285
 286 void
 287 TAO_DynArray_i::set_elements_as_dyn_any (
 288     const DynamicAny::DynAnySeq & values
 289
 290   )
 291 {
 292   if (this->destroyed_)
 293     {
 294       throw ::CORBA::OBJECT_NOT_EXIST ();
 295     }
 296
 297   CORBA::ULong length = static_cast<CORBA::ULong> (this->da_members_.size ());
 298
 299   if (values.length () != length)
 300     {
 301       throw DynamicAny::DynAny::InvalidValue ();
 302     }
 303
 304   CORBA::TypeCode_var element_type = this->get_element_type ();
 305
 306   CORBA::TypeCode_var val_type;
 307   CORBA::Boolean equivalent;
 308
 309   for (CORBA::ULong i = 0; i < length; ++i)
 310     {
 311       val_type = values[i]->type ();
 312
 313       equivalent = val_type->equivalent (element_type.in ());
 314
 315
 316       if (equivalent)
 317         {
 318           this->da_members_[i] = values[i]->copy ();
 319         }
 320       else
 321         {
 322           throw DynamicAny::DynAny::TypeMismatch ();
 323         }
 324     }
 325 }
 326
 327 // ****************************************************************
 328
 329 void
 330 TAO_DynArray_i::from_any (const CORBA::Any& any)
 331 {
 332   if (this->destroyed_)
 333     {
 334       throw ::CORBA::OBJECT_NOT_EXIST ();
 335     }
 336
 337   CORBA::TypeCode_var tc = any.type ();
 338   CORBA::Boolean equivalent = this->type_.in ()->equivalent (tc.in ());
 339
 340   if (equivalent)
 341     {
 342       // Get the CDR stream of the Any,if there isn't one, make one.
 343       TAO::Any_Impl *impl = any.impl ();
 344       TAO_OutputCDR out;
 345       TAO_InputCDR cdr (static_cast<ACE_Message_Block *> (0));
 346
 347       if (impl->encoded ())
 348         {
 349           TAO::Unknown_IDL_Type * const unk =
 350             dynamic_cast<TAO::Unknown_IDL_Type *> (impl);
 351
 352           if (!unk)
 353             throw CORBA::INTERNAL ();
 354
 355           cdr = unk->_tao_get_cdr ();
 356         }
 357       else
 358         {
 359           impl->marshal_value (out);
 360           TAO_InputCDR tmp_in (out);
 361           cdr = tmp_in;
 362         }
 363
 364       CORBA::ULong length = static_cast<CORBA::ULong> (this->da_members_.size ());
 365       CORBA::ULong arg_length = this->get_tc_length (tc.in ());
 366
 367       if (length != arg_length)
 368         {
 369           throw DynamicAny::DynAny::TypeMismatch ();
 370         }
 371
 372       CORBA::TypeCode_var field_tc = this->get_element_type ();
 373
 374       for (CORBA::ULong i = 0; i < arg_length; ++i)
 375         {
 376           CORBA::Any field_any;
 377           TAO_InputCDR unk_in (cdr);
 378           TAO::Unknown_IDL_Type *field_unk = 0;
 379           ACE_NEW (field_unk,
 380                    TAO::Unknown_IDL_Type (field_tc.in (), unk_in));
 381           field_any.replace (field_unk);
 382
 383           this->da_members_[i]->destroy ();
 384
 385           this->da_members_[i] =
 386             TAO::MakeDynAnyUtils::make_dyn_any_t<const CORBA::Any&> (
 387               field_any._tao_get_typecode (),
 388               field_any,
 389               this->allow_truncation_ );
 390
 391           // Move to the next field in the CDR stream.
 392           (void) TAO_Marshal_Object::perform_skip (field_tc.in (), &cdr);
 393         }
 394
 395       this->current_position_ = arg_length ? 0 : -1;
 396     }
 397   else
 398     {
 399       throw DynamicAny::DynAny::TypeMismatch ();
 400     }
 401 }
 402
 403 CORBA::Any_ptr
 404 TAO_DynArray_i::to_any (void)
 405 {
 406   if (this->destroyed_)
 407     {
 408       throw ::CORBA::OBJECT_NOT_EXIST ();
 409     }
 410
 411   CORBA::TypeCode_var field_tc = this->get_element_type ();
 412
 413   TAO_OutputCDR out_cdr;
 414   CORBA::Any_var field_any;
 415   size_t length = this->da_members_.size ();
 416
 417   for (size_t i = 0; i < length; ++i)
 418     {
 419       // Recursive step.
 420       field_any = this->da_members_[i]->to_any ();
 421
 422       TAO::Any_Impl *field_impl = field_any->impl ();
 423       TAO_OutputCDR field_out;
 424       TAO_InputCDR field_cdr (static_cast<ACE_Message_Block *> (0));
 425
 426       if (field_impl->encoded ())
 427         {
 428           TAO::Unknown_IDL_Type * const field_unk =
 429             dynamic_cast<TAO::Unknown_IDL_Type *> (field_impl);
 430
 431           if (!field_unk)
 432             throw CORBA::INTERNAL ();
 433
 434           field_cdr = field_unk->_tao_get_cdr ();
 435         }
 436       else
 437         {
 438           field_impl->marshal_value (field_out);
 439           TAO_InputCDR tmp_in (field_out);
 440           field_cdr = tmp_in;
 441         }
 442
 443       (void) TAO_Marshal_Object::perform_append (field_tc.in (),
 444                                                  &field_cdr,
 445                                                  &out_cdr);
 446     }
 447
 448   TAO_InputCDR in_cdr (out_cdr);
 449
 450   CORBA::Any_ptr retval = 0;
 451   ACE_NEW_THROW_EX (retval,
 452                     CORBA::Any,
 453                     CORBA::NO_MEMORY ());
 454
 455   TAO::Unknown_IDL_Type *unk = 0;
 456   ACE_NEW_THROW_EX (unk,
 457                     TAO::Unknown_IDL_Type (this->type_.in (),
 458                                            in_cdr),
 459                     CORBA::NO_MEMORY ());
 460
 461   retval->replace (unk);
 462   return retval;
 463 }
 464
 465 CORBA::Boolean
 466 TAO_DynArray_i::equal (DynamicAny::DynAny_ptr rhs)
 467 {
 468   if (this->destroyed_)
 469     {
 470       throw ::CORBA::OBJECT_NOT_EXIST ();
 471     }
 472
 473   CORBA::TypeCode_var tc = rhs->type ();
 474
 475   CORBA::Boolean equivalent = tc->equivalent (this->type_.in ());
 476
 477   if (!equivalent)
 478     {
 479       return false;
 480     }
 481
 482   DynamicAny::DynAny_var tmp;
 483   CORBA::Boolean member_equal;
 484
 485   for (CORBA::ULong i = 0; i < this->component_count_; ++i)
 486     {
 487       rhs->seek (static_cast<CORBA::Long> (i));
 488
 489       tmp = rhs->current_component ();
 490
 491       // Recursive step.
 492       member_equal = tmp->equal (this->da_members_[i].in ());
 493
 494       if (!member_equal)
 495         {
 496           return false;
 497         }
 498     }
 499
 500   return true;
 501 }
 502
 503 void
 504 TAO_DynArray_i::destroy (void)
 505 {
 506   if (this->destroyed_)
 507     {
 508       throw ::CORBA::OBJECT_NOT_EXIST ();
 509     }
 510
 511   if (!this->ref_to_component_ || this->container_is_destroying_)
 512     {
 513       // Do a deep destroy.
 514       for (CORBA::ULong i = 0; i < this->component_count_; ++i)
 515         {
 516           this->set_flag (da_members_[i].in (), 1);
 517
 518           this->da_members_[i]->destroy ();
 519         }
 520
 521       this->destroyed_ = 1;
 522     }
 523 }
 524
 525 DynamicAny::DynAny_ptr
 526 TAO_DynArray_i::current_component (void)
 527 {
 528   if (this->destroyed_)
 529     {
 530       throw ::CORBA::OBJECT_NOT_EXIST ();
 531     }
 532
 533   if (this->current_position_ == -1)
 534     {
 535       return DynamicAny::DynAny::_nil ();
 536     }
 537
 538   CORBA::ULong index = static_cast<CORBA::ULong> (this->current_position_);
 539
 540   this->set_flag (this->da_members_[index].in (), 0);
 541
 542   return DynamicAny::DynAny::_duplicate (this->da_members_[index].in ());
 543 }
 544
 545 TAO_END_VERSIONED_NAMESPACE_DECL