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

TAO_DynArray_i Class Reference

#include <DynArray_i.h>

Inheritance diagram for TAO_DynArray_i:

Inheritance graph
[legend]
Collaboration diagram for TAO_DynArray_i:

Collaboration graph
[legend]
List of all members.

Public Member Functions

 TAO_DynArray_i (void)
 Constructor.

 ~TAO_DynArray_i (void)
 Destructor.

void init (CORBA::TypeCode_ptr tc)
 Initialize using just a TypeCode.

void init (const CORBA::Any &any)
 Initialize using an Any.

virtual DynamicAny::AnySeq * get_elements () throw ( CORBA::SystemException )
virtual void set_elements (const DynamicAny::AnySeq &value) throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue )
virtual DynamicAny::DynAnySeq * get_elements_as_dyn_any () throw ( CORBA::SystemException )
virtual void set_elements_as_dyn_any (const DynamicAny::DynAnySeq &value) throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue )
virtual void from_any (const CORBA::Any &value) throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue )
virtual CORBA::Any * to_any () throw ( CORBA::SystemException )
virtual CORBA::Boolean equal (DynamicAny::DynAny_ptr dyn_any) throw ( CORBA::SystemException )
virtual void destroy () throw ( CORBA::SystemException )
virtual DynamicAny::DynAny_ptr current_component () throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch )

Static Public Member Functions

TAO_DynArray_i * _narrow (CORBA::Object_ptr obj)

Private Member Functions

CORBA::TypeCode_ptr get_element_type ()
 Returns the type of elements contained in the array.

CORBA::ULong get_tc_length (CORBA::TypeCode_ptr tc)
 Gets the length of the array from the typecode.

void init_common (void)
 Called by both versions of init().

 TAO_DynArray_i (const TAO_DynArray_i &src)
TAO_DynArray_i & operator= (const TAO_DynArray_i &src)

Private Attributes

ACE_Array_Base< DynamicAny::DynAny_var > da_members_
 Each component is also a DynAny.

Detailed Description

Implementation of Dynamic Any type for arrays

Definition at line 42 of file DynArray_i.h.

Constructor & Destructor Documentation

TAO_BEGIN_VERSIONED_NAMESPACE_DECL TAO_DynArray_i::TAO_DynArray_i (  void   ) 
 

Constructor.

Definition at line 15 of file DynArray_i.cpp. 

00016 {
00017 }

TAO_DynArray_i::~TAO_DynArray_i (  void   ) 
 

Destructor.

Definition at line 19 of file DynArray_i.cpp. 

00020 {
00021 }

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

Member Function Documentation

TAO_DynArray_i * TAO_DynArray_i::_narrow (  CORBA::Object_ptr  obj  )  [static]
 

Implements DynamicAny::DynArray.

Definition at line 199 of file DynArray_i.cpp.

References CORBA::is_nil().

Referenced by TAO_DynCommon::set_flag(). 

00201 {
00202   if (CORBA::is_nil (_tao_objref))
00203     {
00204       return 0;
00205     }
00206 
00207   return dynamic_cast<TAO_DynArray_i *> (_tao_objref);
00208 }

DynamicAny::DynAny_ptr TAO_DynArray_i::current_component (   )  throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch ) [virtual]
 

Implements DynamicAny::DynAny.

Definition at line 634 of file DynArray_i.cpp.

References DynamicAny::DynAny::_duplicate(), DynamicAny::DynAny::_nil(), ACE_CHECK_RETURN, ACE_ENV_ARG_PARAMETER, and ACE_THROW_RETURN. 

00639 {
00640   if (this->destroyed_)
00641     {
00642       ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
00643                         DynamicAny::DynAny::_nil ());
00644     }
00645 
00646   if (this->current_position_ == -1)
00647     {
00648       return DynamicAny::DynAny::_nil ();
00649     }
00650 
00651   CORBA::ULong index = static_cast<CORBA::ULong> (this->current_position_);
00652 
00653   this->set_flag (this->da_members_[index].in (),
00654                   0
00655                   ACE_ENV_ARG_PARAMETER);
00656   ACE_CHECK_RETURN (DynamicAny::DynAny::_nil ());
00657 
00658   return DynamicAny::DynAny::_duplicate (
00659             this->da_members_[index].in ()
00660           );
00661 }

void TAO_DynArray_i::destroy (   )  throw ( CORBA::SystemException ) [virtual]
 

Implements DynamicAny::DynAny.

Definition at line 605 of file DynArray_i.cpp.

References ACE_CHECK, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_PARAMETER, and ACE_THROW. 

00609 {
00610   if (this->destroyed_)
00611     {
00612       ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
00613     }
00614 
00615   if (!this->ref_to_component_ || this->container_is_destroying_)
00616     {
00617       // Do a deep destroy.
00618       for (CORBA::ULong i = 0; i < this->component_count_; ++i)
00619         {
00620           this->set_flag (da_members_[i].in (),
00621                           1
00622                           ACE_ENV_ARG_PARAMETER);
00623           ACE_CHECK;
00624 
00625           this->da_members_[i]->destroy (ACE_ENV_SINGLE_ARG_PARAMETER);
00626           ACE_CHECK;
00627         }
00628 
00629       this->destroyed_ = 1;
00630     }
00631 }

CORBA::Boolean TAO_DynArray_i::equal (  DynamicAny::DynAny_ptr  dyn_any  )  throw ( CORBA::SystemException ) [virtual]
 

Definition at line 554 of file DynArray_i.cpp.

References ACE_CHECK_RETURN, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_THROW_RETURN, DynamicAny::DynAny_ptr, and DynamicAny::DynAny_var. 

00559 {
00560   if (this->destroyed_)
00561     {
00562       ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
00563                         0);
00564     }
00565 
00566   CORBA::TypeCode_var tc = rhs->type (ACE_ENV_SINGLE_ARG_PARAMETER);
00567   ACE_CHECK_RETURN (0);
00568 
00569   CORBA::Boolean equivalent = tc->equivalent (this->type_.in ()
00570                                               ACE_ENV_ARG_PARAMETER);
00571   ACE_CHECK_RETURN (0);
00572 
00573   if (!equivalent)
00574     {
00575       return 0;
00576     }
00577 
00578   DynamicAny::DynAny_var tmp;
00579   CORBA::Boolean member_equal;
00580 
00581   for (CORBA::ULong i = 0; i < this->component_count_; ++i)
00582     {
00583       rhs->seek (static_cast<CORBA::Long> (i)
00584                  ACE_ENV_ARG_PARAMETER);
00585       ACE_CHECK_RETURN (0);
00586 
00587       tmp = rhs->current_component (ACE_ENV_SINGLE_ARG_PARAMETER);
00588       ACE_CHECK_RETURN (0);
00589 
00590       // Recursive step.
00591       member_equal = tmp->equal (this->da_members_[i].in ()
00592                                  ACE_ENV_ARG_PARAMETER);
00593       ACE_CHECK_RETURN (0);
00594 
00595       if (!member_equal)
00596         {
00597           return 0;
00598         }
00599     }
00600 
00601   return 1;
00602 }

void TAO_DynArray_i::from_any (  const CORBA::Any &  value  )  throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue ) [virtual]
 

Definition at line 395 of file DynArray_i.cpp.

References ACE_CHECK, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_NEW, ACE_THROW, and TAO_DynAnyFactory::make_dyn_any(). 

00402 {
00403   if (this->destroyed_)
00404     {
00405       ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
00406     }
00407 
00408   CORBA::TypeCode_var tc = any.type ();
00409   CORBA::Boolean equivalent =
00410     this->type_.in ()->equivalent (tc.in ()
00411                                    ACE_ENV_ARG_PARAMETER);
00412   ACE_CHECK;
00413 
00414   if (equivalent)
00415     {
00416       // Get the CDR stream of the Any,if there isn't one, make one.
00417       TAO::Any_Impl *impl = any.impl ();
00418       TAO_OutputCDR out;
00419       TAO_InputCDR cdr (static_cast<ACE_Message_Block *> (0));
00420 
00421       if (impl->encoded ())
00422         {
00423           TAO::Unknown_IDL_Type *unk =
00424             dynamic_cast<TAO::Unknown_IDL_Type *> (impl);
00425 
00426           cdr = unk->_tao_get_cdr ();
00427         }
00428       else
00429         {
00430           impl->marshal_value (out);
00431           TAO_InputCDR tmp_in (out);
00432           cdr = tmp_in;
00433         }
00434 
00435       CORBA::ULong length = static_cast<CORBA::ULong> (this->da_members_.size ());
00436       CORBA::ULong arg_length = this->get_tc_length (tc.in ()
00437                                                      ACE_ENV_ARG_PARAMETER);
00438       ACE_CHECK;
00439 
00440       if (length != arg_length)
00441         {
00442           ACE_THROW (DynamicAny::DynAny::TypeMismatch ());
00443         }
00444 
00445       CORBA::TypeCode_var field_tc =
00446         this->get_element_type (ACE_ENV_SINGLE_ARG_PARAMETER);
00447       ACE_CHECK;
00448 
00449       for (CORBA::ULong i = 0; i < arg_length; ++i)
00450         {
00451           CORBA::Any field_any;
00452           TAO_InputCDR unk_in (cdr);
00453           TAO::Unknown_IDL_Type *field_unk = 0;
00454           ACE_NEW (field_unk,
00455                    TAO::Unknown_IDL_Type (field_tc.in (),
00456                                           unk_in));
00457           field_any.replace (field_unk);
00458 
00459           this->da_members_[i]->destroy (ACE_ENV_SINGLE_ARG_PARAMETER);
00460           ACE_CHECK;
00461 
00462           this->da_members_[i] =
00463             TAO_DynAnyFactory::make_dyn_any (field_any
00464                                           ACE_ENV_ARG_PARAMETER);
00465           ACE_CHECK;
00466 
00467           // Move to the next field in the CDR stream.
00468           (void) TAO_Marshal_Object::perform_skip (field_tc.in (),
00469                                                    &cdr
00470                                                    ACE_ENV_ARG_PARAMETER);
00471           ACE_CHECK;
00472         }
00473 
00474       this->current_position_ = arg_length ? 0 : -1;
00475     }
00476   else
00477     {
00478       ACE_THROW (DynamicAny::DynAny::TypeMismatch ());
00479     }
00480 }

CORBA::TypeCode_ptr TAO_DynArray_i::get_element_type (   )  [private]
 

Returns the type of elements contained in the array.

Definition at line 146 of file DynArray_i.cpp.

References ACE_CHECK_RETURN, and ACE_ENV_SINGLE_ARG_PARAMETER.

Referenced by init(). 

00147 {
00148   CORBA::TypeCode_var element_type =
00149     CORBA::TypeCode::_duplicate (this->type_.in ());
00150 
00151   // Strip away aliases (if any) on top of the outer type
00152   CORBA::TCKind kind = element_type->kind (ACE_ENV_SINGLE_ARG_PARAMETER);
00153   ACE_CHECK_RETURN (CORBA::TypeCode::_nil ());
00154 
00155   while (kind != CORBA::tk_array)
00156     {
00157       element_type =
00158         element_type->content_type (ACE_ENV_SINGLE_ARG_PARAMETER);
00159       ACE_CHECK_RETURN (CORBA::TypeCode::_nil ());
00160 
00161       kind = element_type->kind (ACE_ENV_SINGLE_ARG_PARAMETER);
00162       ACE_CHECK_RETURN (CORBA::TypeCode::_nil ());
00163     }
00164 
00165   // Return the content type.
00166   CORBA::TypeCode_ptr retval =
00167     element_type->content_type (ACE_ENV_SINGLE_ARG_PARAMETER);
00168   ACE_CHECK_RETURN (CORBA::TypeCode::_nil ());
00169 
00170   return retval;
00171 }

DynamicAny::AnySeq * TAO_DynArray_i::get_elements (   )  throw ( CORBA::SystemException ) [virtual]
 

Implements DynamicAny::DynArray.

Definition at line 213 of file DynArray_i.cpp.

References TAO_Seq_Var_Base_T< T >::_retn(), ACE_CHECK_RETURN, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_NEW_THROW_EX, ACE_THROW_RETURN, DynamicAny::AnySeq_var, TAO_Seq_Var_Base_T< T >::in(), and TAO::unbounded_value_sequence< T >::length(). 

00217 {
00218   if (this->destroyed_)
00219     {
00220       ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
00221                         0);
00222     }
00223 
00224   CORBA::ULong length = static_cast<CORBA::ULong> (this->da_members_.size ());
00225 
00226   DynamicAny::AnySeq *elements = 0;
00227   ACE_NEW_THROW_EX (elements,
00228                     DynamicAny::AnySeq (length),
00229                     CORBA::NO_MEMORY ());
00230   ACE_CHECK_RETURN (0);
00231 
00232   elements->length (length);
00233   DynamicAny::AnySeq_var safe_retval (elements);
00234 
00235   CORBA::Any_var tmp;
00236 
00237   // Initialize each Any.
00238   for (CORBA::ULong i = 0; i < length; i++)
00239     {
00240       tmp = this->da_members_[i]->to_any (ACE_ENV_SINGLE_ARG_PARAMETER);
00241       ACE_CHECK_RETURN (0);
00242 
00243       safe_retval[i] = tmp.in ();
00244     }
00245 
00246   return safe_retval._retn ();
00247 }

DynamicAny::DynAnySeq * TAO_DynArray_i::get_elements_as_dyn_any (   )  throw ( CORBA::SystemException ) [virtual]
 

Implements DynamicAny::DynArray.

Definition at line 302 of file DynArray_i.cpp.

References DynamicAny::DynAny::_duplicate(), TAO_Seq_Var_Base_T< T >::_retn(), ACE_CHECK_RETURN, ACE_ENV_ARG_PARAMETER, ACE_NEW_THROW_EX, ACE_THROW_RETURN, DynamicAny::DynAnySeq_var, and TAO::unbounded_object_reference_sequence< DynAny, DynAny_var >::length(). 

00306 {
00307   if (this->destroyed_)
00308     {
00309       ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
00310                         0);
00311     }
00312 
00313   DynamicAny::DynAnySeq *retval = 0;
00314   ACE_NEW_THROW_EX (retval,
00315                     DynamicAny::DynAnySeq (this->component_count_),
00316                     CORBA::NO_MEMORY ());
00317   ACE_CHECK_RETURN (0);
00318 
00319   retval->length (this->component_count_);
00320   DynamicAny::DynAnySeq_var safe_retval (retval);
00321 
00322   for (CORBA::ULong i = 0; i < this->component_count_; ++i)
00323     {
00324       // A deep copy is made only by copy() (CORBA 2.4.2 section 9.2.3.6).
00325       // Set the flag so the caller can't destroy.
00326       this->set_flag (this->da_members_[i].in (),
00327                       0
00328                       ACE_ENV_ARG_PARAMETER);
00329       ACE_CHECK_RETURN (0);
00330 
00331       safe_retval[i] =
00332         DynamicAny::DynAny::_duplicate (this->da_members_[i].in ());
00333       ACE_CHECK_RETURN (0);
00334     }
00335 
00336   return safe_retval._retn ();
00337 }

CORBA::ULong TAO_DynArray_i::get_tc_length (  CORBA::TypeCode_ptr  tc  )  [private]
 

Gets the length of the array from the typecode.

Definition at line 175 of file DynArray_i.cpp.

References ACE_CHECK_RETURN, and ACE_ENV_SINGLE_ARG_PARAMETER.

Referenced by init(). 

00177 {
00178   CORBA::TypeCode_var tctmp = CORBA::TypeCode::_duplicate (tc);
00179   CORBA::TCKind kind = tctmp->kind (ACE_ENV_SINGLE_ARG_PARAMETER);
00180   ACE_CHECK_RETURN (0);
00181 
00182   while (kind == CORBA::tk_alias)
00183     {
00184       tctmp = tctmp->content_type (ACE_ENV_SINGLE_ARG_PARAMETER);
00185       ACE_CHECK_RETURN (0);
00186       kind = tctmp->kind (ACE_ENV_SINGLE_ARG_PARAMETER);
00187       ACE_CHECK_RETURN (0);
00188     }
00189 
00190   CORBA::ULong retval = tctmp->length (ACE_ENV_SINGLE_ARG_PARAMETER);
00191   ACE_CHECK_RETURN (0);
00192 
00193   return retval;
00194 }

void TAO_DynArray_i::init (  const CORBA::Any &  any  ) 
 

Initialize using an Any.

Definition at line 35 of file DynArray_i.cpp.

References ACE_CHECK, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_NEW, ACE_THROW, da_members_, get_element_type(), get_tc_length(), init_common(), TAO_DynAnyFactory::make_dyn_any(), and TAO_DynAnyFactory::unalias(). 

00037 {
00038   CORBA::TypeCode_var tc = any.type ();
00039 
00040   CORBA::TCKind kind = TAO_DynAnyFactory::unalias (tc.in ()
00041                                                    ACE_ENV_ARG_PARAMETER);
00042   ACE_CHECK;
00043 
00044   if (kind != CORBA::tk_array)
00045     {
00046       ACE_THROW (DynamicAny::DynAnyFactory::InconsistentTypeCode ());
00047     }
00048 
00049   this->type_ = tc;
00050 
00051   CORBA::ULong numfields = this->get_tc_length (tc.in ()
00052                                                 ACE_ENV_ARG_PARAMETER);
00053   ACE_CHECK;
00054   // Resize the array.
00055   this->da_members_.size (numfields);
00056 
00057   this->init_common ();
00058 
00059   // Get the CDR stream of the Any, if there isn't one, make one.
00060   TAO::Any_Impl *impl = any.impl ();
00061   TAO_OutputCDR out;
00062   TAO_InputCDR cdr (static_cast<ACE_Message_Block *> (0));
00063 
00064   if (impl->encoded  ())
00065     {
00066       TAO::Unknown_IDL_Type *unk =
00067         dynamic_cast<TAO::Unknown_IDL_Type *> (impl);
00068 
00069       cdr = unk->_tao_get_cdr ();
00070     }
00071   else
00072     {
00073       impl->marshal_value (out);
00074       TAO_InputCDR tmp_in (out);
00075       cdr = tmp_in;
00076     }
00077 
00078   CORBA::TypeCode_var field_tc =
00079     this->get_element_type (ACE_ENV_SINGLE_ARG_PARAMETER);
00080   ACE_CHECK;
00081 
00082   for (CORBA::ULong i = 0; i < numfields; ++i)
00083     {
00084       CORBA::Any field_any;
00085       TAO::Unknown_IDL_Type *field_unk = 0;
00086       TAO_InputCDR unk_in (cdr);
00087       ACE_NEW (field_unk,
00088                TAO::Unknown_IDL_Type (field_tc.in (),
00089                                       unk_in));
00090       field_any.replace (field_unk);
00091 
00092       // This recursive step will call the correct constructor
00093       // based on the type of field_any.
00094       this->da_members_[i] =
00095         TAO_DynAnyFactory::make_dyn_any (field_any
00096                                          ACE_ENV_ARG_PARAMETER);
00097       ACE_CHECK;
00098 
00099       // Move to the next field in the CDR stream.
00100       (void) TAO_Marshal_Object::perform_skip (field_tc.in (),
00101                                                &cdr
00102                                                ACE_ENV_ARG_PARAMETER);
00103       ACE_CHECK;
00104     }
00105 }

void TAO_DynArray_i::init (  CORBA::TypeCode_ptr  tc  ) 
 

Initialize using just a TypeCode.

Definition at line 108 of file DynArray_i.cpp.

References ACE_CHECK, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_THROW, da_members_, get_element_type(), get_tc_length(), init_common(), TAO_DynAnyFactory::make_dyn_any(), and TAO_DynAnyFactory::unalias().

Referenced by TAO_DynAnyFactory::make_dyn_any(). 

00110 {
00111   CORBA::TCKind kind = TAO_DynAnyFactory::unalias (tc
00112                                                    ACE_ENV_ARG_PARAMETER);
00113   ACE_CHECK;
00114 
00115   if (kind != CORBA::tk_array)
00116     {
00117       ACE_THROW (DynamicAny::DynAnyFactory::InconsistentTypeCode ());
00118     }
00119 
00120   this->type_ = CORBA::TypeCode::_duplicate (tc);
00121 
00122   CORBA::ULong numfields = this->get_tc_length (tc
00123                                                 ACE_ENV_ARG_PARAMETER);
00124   ACE_CHECK;
00125 
00126   // Resize the array.
00127   this->da_members_.size (numfields);
00128 
00129   this->init_common ();
00130 
00131   CORBA::TypeCode_var elemtype =
00132     this->get_element_type (ACE_ENV_SINGLE_ARG_PARAMETER);
00133   ACE_CHECK;
00134 
00135   for (CORBA::ULong i = 0; i < numfields; ++i)
00136     {
00137       // Recursively initialize each element.
00138       this->da_members_[i] =
00139         TAO_DynAnyFactory::make_dyn_any (elemtype.in ()
00140                                          ACE_ENV_ARG_PARAMETER);
00141       ACE_CHECK;
00142     }
00143 }

void TAO_DynArray_i::init_common (  void   )  [private]
 

Called by both versions of init().

Definition at line 24 of file DynArray_i.cpp.

References da_members_.

Referenced by init(). 

00025 {
00026   this->ref_to_component_ = 0;
00027   this->container_is_destroying_ = 0;
00028   this->has_components_ = 1;
00029   this->destroyed_ = 0;
00030   this->current_position_ = 0;
00031   this->component_count_ = static_cast<CORBA::ULong> (this->da_members_.size ());
00032 }

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

void TAO_DynArray_i::set_elements (  const DynamicAny::AnySeq &  value  )  throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue ) [virtual]
 

Definition at line 250 of file DynArray_i.cpp.

References ACE_CHECK, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_THROW, and TAO_DynAnyFactory::make_dyn_any(). 

00257 {
00258   if (this->destroyed_)
00259     {
00260       ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
00261     }
00262 
00263   CORBA::ULong length = value.length ();
00264 
00265   if (length != this->da_members_.size ())
00266     {
00267       ACE_THROW (DynamicAny::DynAny::InvalidValue ());
00268     }
00269 
00270   CORBA::TypeCode_var value_tc;
00271   CORBA::TypeCode_var element_type =
00272     this->get_element_type (ACE_ENV_SINGLE_ARG_PARAMETER);
00273   ACE_CHECK;
00274 
00275   for (CORBA::ULong i = 0; i < length; i++)
00276     {
00277       // Check each arg element for type match.
00278       value_tc = value[i].type ();
00279       CORBA::Boolean equivalent =
00280         value_tc->equivalent (element_type.in ()
00281                               ACE_ENV_ARG_PARAMETER);
00282       ACE_CHECK;
00283 
00284       if (equivalent)
00285         {
00286           this->da_members_[i]->destroy (ACE_ENV_SINGLE_ARG_PARAMETER);
00287           ACE_CHECK;
00288 
00289           this->da_members_[i] =
00290             TAO_DynAnyFactory::make_dyn_any (value[i]
00291                                              ACE_ENV_ARG_PARAMETER);
00292           ACE_CHECK;
00293         }
00294       else
00295         {
00296           ACE_THROW (DynamicAny::DynAny::TypeMismatch ());
00297         }
00298     }
00299 }

void TAO_DynArray_i::set_elements_as_dyn_any (  const DynamicAny::DynAnySeq &  value  )  throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue ) [virtual]
 

Definition at line 340 of file DynArray_i.cpp.

References ACE_CHECK, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_PARAMETER, and ACE_THROW. 

00349 {
00350   if (this->destroyed_)
00351     {
00352       ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
00353     }
00354 
00355   CORBA::ULong length = static_cast<CORBA::ULong> (this->da_members_.size ());
00356 
00357   if (values.length () != length)
00358     {
00359       ACE_THROW (DynamicAny::DynAny::InvalidValue ());
00360     }
00361 
00362   CORBA::TypeCode_var element_type =
00363     this->get_element_type (ACE_ENV_SINGLE_ARG_PARAMETER);
00364   ACE_CHECK;
00365 
00366   CORBA::TypeCode_var val_type;
00367   CORBA::Boolean equivalent;
00368 
00369   for (CORBA::ULong i = 0; i < length; ++i)
00370     {
00371       val_type = values[i]->type (ACE_ENV_SINGLE_ARG_PARAMETER);
00372       ACE_CHECK;
00373 
00374       equivalent = val_type->equivalent (element_type.in ()
00375                                          ACE_ENV_ARG_PARAMETER);
00376 
00377       ACE_CHECK;
00378 
00379       if (equivalent)
00380         {
00381           this->da_members_[i] =
00382             values[i]->copy (ACE_ENV_SINGLE_ARG_PARAMETER);
00383           ACE_CHECK;
00384         }
00385       else
00386         {
00387           ACE_THROW (DynamicAny::DynAny::TypeMismatch ());
00388         }
00389     }
00390 }

CORBA::Any_ptr TAO_DynArray_i::to_any (   )  throw ( CORBA::SystemException ) [virtual]
 

Implements DynamicAny::DynAny.

Definition at line 483 of file DynArray_i.cpp.

References ACE_CHECK_RETURN, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_NEW_THROW_EX, and ACE_THROW_RETURN. 

00487 {
00488   if (this->destroyed_)
00489     {
00490       ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
00491                         0);
00492     }
00493 
00494   CORBA::TypeCode_var field_tc =
00495     this->get_element_type (ACE_ENV_SINGLE_ARG_PARAMETER);
00496   ACE_CHECK_RETURN (0);
00497 
00498   TAO_OutputCDR out_cdr;
00499   CORBA::Any_var field_any;
00500   size_t length = this->da_members_.size ();
00501 
00502   for (size_t i = 0; i < length; ++i)
00503     {
00504       // Recursive step.
00505       field_any =
00506         this->da_members_[i]->to_any (ACE_ENV_SINGLE_ARG_PARAMETER);
00507       ACE_CHECK_RETURN (0);
00508 
00509       TAO::Any_Impl *field_impl = field_any->impl ();
00510       TAO_OutputCDR field_out;
00511       TAO_InputCDR field_cdr (static_cast<ACE_Message_Block *> (0));
00512 
00513       if (field_impl->encoded ())
00514         {
00515           TAO::Unknown_IDL_Type *field_unk =
00516             dynamic_cast<TAO::Unknown_IDL_Type *> (field_impl);
00517 
00518           field_cdr = field_unk->_tao_get_cdr ();
00519         }
00520       else
00521         {
00522           field_impl->marshal_value (field_out);
00523           TAO_InputCDR tmp_in (field_out);
00524           field_cdr = tmp_in;
00525         }
00526 
00527       (void) TAO_Marshal_Object::perform_append (field_tc.in (),
00528                                                  &field_cdr,
00529                                                  &out_cdr
00530                                                  ACE_ENV_ARG_PARAMETER);
00531       ACE_CHECK_RETURN (0);
00532     }
00533 
00534   TAO_InputCDR in_cdr (out_cdr);
00535 
00536   CORBA::Any_ptr retval = 0;
00537   ACE_NEW_THROW_EX (retval,
00538                     CORBA::Any,
00539                     CORBA::NO_MEMORY ());
00540   ACE_CHECK_RETURN (0);
00541 
00542   TAO::Unknown_IDL_Type *unk = 0;
00543   ACE_NEW_THROW_EX (unk,
00544                     TAO::Unknown_IDL_Type (this->type_.in (),
00545                                            in_cdr),
00546                     CORBA::NO_MEMORY ());
00547   ACE_CHECK_RETURN (0);
00548 
00549   retval->replace (unk);
00550   return retval;
00551 }

Member Data Documentation

ACE_Array_Base<DynamicAny::DynAny_var> TAO_DynArray_i::da_members_ [private]
 

Each component is also a DynAny.

Definition at line 162 of file DynArray_i.h.

Referenced by init(), and init_common().

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