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

TAO_DynCommon Class Reference

#include <DynCommon.h>

Inheritance diagram for TAO_DynCommon:

Inheritance graph
[legend]
Collaboration diagram for TAO_DynCommon:

Collaboration graph
[legend]
List of all members.

Public Member Functions

 TAO_DynCommon (void)
 Constructor.

virtual ~TAO_DynCommon (void)
 Destructor.

virtual CORBA::TypeCode_ptr type () throw ( CORBA::SystemException )
virtual void assign (DynamicAny::DynAny_ptr dyn_any) throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch )
virtual void insert_boolean (CORBA::Boolean value) throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue )
virtual void insert_octet (CORBA::Octet value) throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue )
virtual void insert_char (CORBA::Char value) throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue )
virtual void insert_short (CORBA::Short value) throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue )
virtual void insert_ushort (CORBA::UShort value) throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue )
virtual void insert_long (CORBA::Long value) throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue )
virtual void insert_ulong (CORBA::ULong value) throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue )
virtual void insert_float (CORBA::Float value) throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue )
virtual void insert_double (CORBA::Double value) throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue )
virtual void insert_string (const char *value) throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue )
virtual void insert_reference (CORBA::Object_ptr value) throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue )
virtual void insert_typecode (CORBA::TypeCode_ptr value) throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue )
virtual void insert_longlong (CORBA::LongLong value) throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue )
virtual void insert_ulonglong (CORBA::ULongLong value) throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue )
virtual void insert_longdouble (CORBA::LongDouble value) throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue )
virtual void insert_wchar (CORBA::WChar value) throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue )
virtual void insert_wstring (const CORBA::WChar *value) throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue )
virtual void insert_any (const CORBA::Any &value) throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue )
virtual void insert_dyn_any (DynamicAny::DynAny_ptr value) throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue )
virtual void insert_val (CORBA::ValueBase *value) throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue )
virtual CORBA::Boolean get_boolean () throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue )
virtual CORBA::Octet get_octet () throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue )
virtual CORBA::Char get_char () throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue )
virtual CORBA::Short get_short () throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue )
virtual CORBA::UShort get_ushort () throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue )
virtual CORBA::Long get_long () throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue )
virtual CORBA::ULong get_ulong () throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue )
virtual CORBA::Float get_float () throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue )
virtual CORBA::Double get_double () throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue )
virtual char * get_string () throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue )
virtual CORBA::Object_ptr get_reference () throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue )
virtual CORBA::TypeCode_ptr get_typecode () throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue )
virtual CORBA::LongLong get_longlong () throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue )
virtual CORBA::ULongLong get_ulonglong () throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue )
virtual CORBA::LongDouble get_longdouble () throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue )
virtual CORBA::WChar get_wchar () throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue )
virtual CORBA::WChar * get_wstring () throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue )
virtual CORBA::Any * get_any () throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue )
virtual DynamicAny::DynAny_ptr get_dyn_any () throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue )
virtual CORBA::ValueBase * get_val () throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue )
virtual CORBA::Boolean seek (CORBA::Long index) throw ( CORBA::SystemException )
virtual void rewind () throw ( CORBA::SystemException )
virtual CORBA::Boolean next () throw ( CORBA::SystemException )
virtual DynamicAny::DynAny_ptr copy () throw ( CORBA::SystemException )
virtual CORBA::ULong component_count () throw ( CORBA::SystemException )

Protected Member Functions

void set_flag (DynamicAny::DynAny_ptr component, CORBA::Boolean destroying) throw ( CORBA::SystemException )

Protected Attributes

CORBA::Boolean ref_to_component_
 Were we created by current_component()?

CORBA::Boolean container_is_destroying_
 Flag to let destroy() call by container override the flag above.

CORBA::Boolean has_components_
 Do we contain other Dynamic Anys?

CORBA::Boolean destroyed_
 Has destroy() been called on us yet?

CORBA::Long current_position_
 Slot of the current component (if any).

CORBA::ULong component_count_
 Number of components, as defined by CORBA 2.4.2.

CORBA::TypeCode_var type_
 Holder for our type code.

CORBA::Any any_

Private Member Functions

DynamicAny::DynAny_ptr check_component () throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue )
void check_type (CORBA::TypeCode_ptr tc) throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch )
CORBA::TypeCode_ptr check_type_and_unalias (CORBA::TypeCode_ptr tc) throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch )

Detailed Description

Contains most of the functionality common to all the Dynamic Any implementation classes.

Definition at line 37 of file DynCommon.h.

Constructor & Destructor Documentation

TAO_BEGIN_VERSIONED_NAMESPACE_DECL TAO_DynCommon::TAO_DynCommon (  void   ) 
 

Constructor.

Definition at line 24 of file DynCommon.cpp. 

00025 {
00026 }

TAO_DynCommon::~TAO_DynCommon (  void   )  [virtual]
 

Destructor.

Definition at line 28 of file DynCommon.cpp. 

00029 {
00030 }

Member Function Documentation

void TAO_DynCommon::assign (  DynamicAny::DynAny_ptr  dyn_any  )  throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch ) [virtual]
 

Definition at line 50 of file DynCommon.cpp.

References ACE_CHECK, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_THROW, and DynamicAny::DynAny_ptr. 

00056 {
00057   if (this->destroyed_)
00058     {
00059       ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
00060     }
00061 
00062   CORBA::TypeCode_var tc = dyn_any->type (ACE_ENV_SINGLE_ARG_PARAMETER);
00063   ACE_CHECK;
00064 
00065   CORBA::Boolean equivalent =
00066     this->type_.in ()->equivalent (tc.in ()
00067                                    ACE_ENV_ARG_PARAMETER);
00068   ACE_CHECK;
00069 
00070   if (equivalent)
00071     {
00072       CORBA::Any_var any = dyn_any->to_any (ACE_ENV_SINGLE_ARG_PARAMETER);
00073       ACE_CHECK;
00074 
00075       this->from_any (any.in ()
00076                       ACE_ENV_ARG_PARAMETER);
00077       ACE_CHECK;
00078     }
00079   else
00080     {
00081       ACE_THROW (DynamicAny::DynAny::TypeMismatch ());
00082     }
00083 }

DynamicAny::DynAny_ptr TAO_DynCommon::check_component (   )  throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue ) [private]
 

Definition at line 1777 of file DynCommon.cpp.

References TAO_Objref_Var_T< T >::_retn(), ACE_CHECK_RETURN, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_THROW_RETURN, DynamicAny::DynAny_var, and TAO_DynAnyFactory::unalias(). 

01783 {
01784   if (this->current_position_ == -1)
01785     {
01786       ACE_THROW_RETURN (DynamicAny::DynAny::InvalidValue (),
01787                         DynamicAny::DynAny::_nil ());
01788     }
01789 
01790   DynamicAny::DynAny_var cc =
01791     this->current_component (ACE_ENV_SINGLE_ARG_PARAMETER);
01792   ACE_CHECK_RETURN (DynamicAny::DynAny::_nil ());
01793 
01794   CORBA::TypeCode_var tc = cc->type (ACE_ENV_SINGLE_ARG_PARAMETER);
01795   ACE_CHECK_RETURN (DynamicAny::DynAny::_nil ());
01796 
01797   CORBA::TCKind kind = TAO_DynAnyFactory::unalias (tc.in ()
01798                                                    ACE_ENV_ARG_PARAMETER);
01799   ACE_CHECK_RETURN (DynamicAny::DynAny::_nil ());
01800 
01801   // We are here because we are a component that is the target of
01802   // an insert_*() call on our container. It is
01803   // illegal to insert anything into a component that itself has
01804   // components.
01805   switch (kind)
01806   {
01807     case CORBA::tk_array:
01808     case CORBA::tk_except:
01809     case CORBA::tk_sequence:
01810     case CORBA::tk_struct:
01811     case CORBA::tk_union:
01812       ACE_THROW_RETURN (DynamicAny::DynAny::TypeMismatch (),
01813                         DynamicAny::DynAny::_nil ());
01814     default:
01815       return cc._retn ();
01816   }
01817 }

void TAO_DynCommon::check_type (  CORBA::TypeCode_ptr  tc  )  throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch ) [private]
 

Definition at line 1820 of file DynCommon.cpp.

References ACE_CHECK, ACE_ENV_ARG_PARAMETER, and ACE_THROW. 

01826 {
01827   CORBA::Boolean equivalent =
01828     this->type_->equivalent (tc
01829                              ACE_ENV_ARG_PARAMETER);
01830   ACE_CHECK;
01831 
01832   if (!equivalent)
01833     {
01834       ACE_THROW (DynamicAny::DynAny::TypeMismatch ());
01835     }
01836 }

CORBA::TypeCode_ptr TAO_DynCommon::check_type_and_unalias (  CORBA::TypeCode_ptr  tc  )  throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch ) [private]
 

Definition at line 1839 of file DynCommon.cpp.

References ACE_CHECK_RETURN, ACE_ENV_ARG_PARAMETER, and TAO_DynAnyFactory::strip_alias(). 

01845 {
01846   this->check_type (tc
01847                     ACE_ENV_ARG_PARAMETER);
01848   ACE_CHECK_RETURN (CORBA::TypeCode::_nil ());
01849 
01850   return TAO_DynAnyFactory::strip_alias (tc
01851                                          ACE_ENV_ARG_PARAMETER);
01852 }

CORBA::ULong TAO_DynCommon::component_count (   )  throw ( CORBA::SystemException ) [virtual]
 

Implements DynamicAny::DynAny.

Definition at line 1632 of file DynCommon.cpp.

References ACE_THROW_RETURN. 

01636 {
01637   if (this->destroyed_)
01638     {
01639       ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
01640                         0);
01641     }
01642 
01643   return this->component_count_;
01644 }

DynamicAny::DynAny_ptr TAO_DynCommon::copy (   )  throw ( CORBA::SystemException ) [virtual]
 

Implements DynamicAny::DynAny.

Definition at line 1609 of file DynCommon.cpp.

References ACE_CHECK_RETURN, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_THROW_RETURN, DynamicAny::DynAny_ptr, and TAO_DynAnyFactory::make_dyn_any(). 

01613 {
01614   if (this->destroyed_)
01615     {
01616       ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
01617                         DynamicAny::DynAny::_nil ());
01618     }
01619 
01620   CORBA::Any_var any = this->to_any (ACE_ENV_SINGLE_ARG_PARAMETER);
01621   ACE_CHECK_RETURN (DynamicAny::DynAny::_nil ());
01622 
01623   DynamicAny::DynAny_ptr retval =
01624     TAO_DynAnyFactory::make_dyn_any (any.in ()
01625                                      ACE_ENV_ARG_PARAMETER);
01626   ACE_CHECK_RETURN (DynamicAny::DynAny::_nil ());
01627 
01628   return retval;
01629 }

CORBA::Any_ptr TAO_DynCommon::get_any (   )  throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue ) [virtual]
 

Implements DynamicAny::DynAny.

Definition at line 1459 of file DynCommon.cpp.

References ACE_CHECK_RETURN, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_NEW_RETURN, ACE_THROW_RETURN, and DynamicAny::DynAny_var. 

01465 {
01466   if (this->destroyed_)
01467     {
01468       ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
01469                         0);
01470     }
01471 
01472   if (this->has_components_)
01473     {
01474       DynamicAny::DynAny_var cc =
01475         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
01476       ACE_CHECK_RETURN (0);
01477 
01478       return cc->get_any (ACE_ENV_SINGLE_ARG_PARAMETER);
01479     }
01480   else
01481     {
01482       const CORBA::Any *tmp = 0;
01483 
01484       if ((this->any_ >>= tmp) == 0)
01485         {
01486           ACE_THROW_RETURN (DynamicAny::DynAny::TypeMismatch (),
01487                             0);
01488         }
01489 
01490       CORBA::Any *retval = 0;
01491       ACE_NEW_RETURN (retval,
01492                       CORBA::Any (*tmp),
01493                       0);
01494       return retval;
01495     }
01496 }

CORBA::Boolean TAO_DynCommon::get_boolean (   )  throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue ) [virtual]
 

Implements DynamicAny::DynAny.

Definition at line 817 of file DynCommon.cpp.

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

00823 {
00824   if (this->destroyed_)
00825     {
00826       ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
00827                         0);
00828     }
00829 
00830   if (this->has_components_)
00831     {
00832       DynamicAny::DynAny_var cc =
00833         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
00834       ACE_CHECK_RETURN (0);
00835 
00836       return cc->get_boolean (ACE_ENV_SINGLE_ARG_PARAMETER);
00837     }
00838   else
00839     {
00840       CORBA::Boolean retval;
00841 
00842       if ((this->any_ >>= CORBA::Any::to_boolean (retval)) == 0)
00843         {
00844           ACE_THROW_RETURN (DynamicAny::DynAny::TypeMismatch (),
00845                             0);
00846         }
00847 
00848       return retval;
00849     }
00850 }

CORBA::Char TAO_DynCommon::get_char (   )  throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue ) [virtual]
 

Implements DynamicAny::DynAny.

Definition at line 889 of file DynCommon.cpp.

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

00895 {
00896   if (this->destroyed_)
00897     {
00898       ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
00899                         0);
00900     }
00901 
00902   if (this->has_components_)
00903     {
00904       DynamicAny::DynAny_var cc =
00905         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
00906       ACE_CHECK_RETURN (0);
00907 
00908       return cc->get_char (ACE_ENV_SINGLE_ARG_PARAMETER);
00909     }
00910   else
00911     {
00912       CORBA::Char retval;
00913 
00914       if ((this->any_ >>= CORBA::Any::to_char (retval)) == 0)
00915         {
00916           ACE_THROW_RETURN (DynamicAny::DynAny::TypeMismatch (),
00917                             0);
00918         }
00919 
00920       return retval;
00921     }
00922 }

CORBA::Double TAO_DynCommon::get_double (   )  throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue ) [virtual]
 

Implements DynamicAny::DynAny.

Definition at line 1105 of file DynCommon.cpp.

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

01111 {
01112   if (this->destroyed_)
01113     {
01114       ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
01115                         0);
01116     }
01117 
01118   if (this->has_components_)
01119     {
01120       DynamicAny::DynAny_var cc =
01121         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
01122       ACE_CHECK_RETURN (0);
01123 
01124       return cc->get_double (ACE_ENV_SINGLE_ARG_PARAMETER);
01125     }
01126   else
01127     {
01128       CORBA::Double retval;
01129 
01130       if ((this->any_ >>= retval) == 0)
01131         {
01132           ACE_THROW_RETURN (DynamicAny::DynAny::TypeMismatch (),
01133                             0);
01134         }
01135 
01136       return retval;
01137     }
01138 }

DynamicAny::DynAny_ptr TAO_DynCommon::get_dyn_any (   )  throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue ) [virtual]
 

Implements DynamicAny::DynAny.

Definition at line 1501 of file DynCommon.cpp.

References ACE_CHECK_RETURN, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_THROW_RETURN, and TAO_DynAnyFactory::make_dyn_any(). 

01507 {
01508   if (this->destroyed_)
01509     {
01510       ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
01511                         0);
01512     }
01513 
01514   CORBA::Any_var any = this->get_any (ACE_ENV_SINGLE_ARG_PARAMETER);
01515   ACE_CHECK_RETURN (0);
01516 
01517   return TAO_DynAnyFactory::make_dyn_any (any.in ()
01518                                           ACE_ENV_ARG_PARAMETER);
01519 }

CORBA::Float TAO_DynCommon::get_float (   )  throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue ) [virtual]
 

Implements DynamicAny::DynAny.

Definition at line 1069 of file DynCommon.cpp.

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

01075 {
01076   if (this->destroyed_)
01077     {
01078       ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
01079                         0);
01080     }
01081 
01082   if (this->has_components_)
01083     {
01084       DynamicAny::DynAny_var cc =
01085         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
01086       ACE_CHECK_RETURN (0);
01087 
01088       return cc->get_float (ACE_ENV_SINGLE_ARG_PARAMETER);
01089     }
01090   else
01091     {
01092       CORBA::Float retval;
01093 
01094       if ((this->any_ >>= retval) == 0)
01095         {
01096           ACE_THROW_RETURN (DynamicAny::DynAny::TypeMismatch (),
01097                             0);
01098         }
01099 
01100       return retval;
01101     }
01102 }

CORBA::Long TAO_DynCommon::get_long (   )  throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue ) [virtual]
 

Implements DynamicAny::DynAny.

Definition at line 997 of file DynCommon.cpp.

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

01003 {
01004   if (this->destroyed_)
01005     {
01006       ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
01007                         0);
01008     }
01009 
01010   if (this->has_components_)
01011     {
01012       DynamicAny::DynAny_var cc =
01013         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
01014       ACE_CHECK_RETURN (0);
01015 
01016       return cc->get_long (ACE_ENV_SINGLE_ARG_PARAMETER);
01017     }
01018   else
01019     {
01020       CORBA::Long retval;
01021 
01022       if ((this->any_ >>= retval) == 0)
01023         {
01024           ACE_THROW_RETURN (DynamicAny::DynAny::TypeMismatch (),
01025                             0);
01026         }
01027 
01028       return retval;
01029     }
01030 }

CORBA::LongDouble TAO_DynCommon::get_longdouble (   )  throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue ) [virtual]
 

Implements DynamicAny::DynAny.

Definition at line 1342 of file DynCommon.cpp.

References ACE_CDR_LONG_DOUBLE_INITIALIZER, ACE_CHECK_RETURN, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_THROW_RETURN, and DynamicAny::DynAny_var. 

01348 {
01349   CORBA::LongDouble retval = ACE_CDR_LONG_DOUBLE_INITIALIZER;
01350 
01351   if (this->destroyed_)
01352     {
01353       ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
01354                         retval);
01355     }
01356 
01357   if (this->has_components_)
01358     {
01359       DynamicAny::DynAny_var cc =
01360         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
01361       ACE_CHECK_RETURN (retval);
01362 
01363       return cc->get_longdouble (ACE_ENV_SINGLE_ARG_PARAMETER);
01364     }
01365   else
01366     {
01367       if ((this->any_ >>= retval) == 0)
01368         {
01369           ACE_THROW_RETURN (DynamicAny::DynAny::TypeMismatch (),
01370                             retval);
01371         }
01372 
01373       return retval;
01374     }
01375 }

CORBA::LongLong TAO_DynCommon::get_longlong (   )  throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue ) [virtual]
 

Implements DynamicAny::DynAny.

Definition at line 1270 of file DynCommon.cpp.

References ACE_CDR_LONGLONG_INITIALIZER, ACE_CHECK_RETURN, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_THROW_RETURN, and DynamicAny::DynAny_var. 

01276 {
01277   CORBA::LongLong retval = ACE_CDR_LONGLONG_INITIALIZER;
01278 
01279   if (this->destroyed_)
01280     {
01281       ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
01282                         retval);
01283     }
01284 
01285   if (this->has_components_)
01286     {
01287       DynamicAny::DynAny_var cc =
01288         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
01289       ACE_CHECK_RETURN (retval);
01290 
01291       return cc->get_longlong (ACE_ENV_SINGLE_ARG_PARAMETER);
01292     }
01293   else
01294     {
01295       if ((this->any_ >>= retval) == 0)
01296         {
01297           ACE_THROW_RETURN (DynamicAny::DynAny::TypeMismatch (),
01298                             retval);
01299         }
01300 
01301       return retval;
01302     }
01303 }

CORBA::Octet TAO_DynCommon::get_octet (   )  throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue ) [virtual]
 

Implements DynamicAny::DynAny.

Definition at line 853 of file DynCommon.cpp.

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

00859 {
00860   if (this->destroyed_)
00861     {
00862       ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
00863                         0);
00864     }
00865 
00866   if (this->has_components_)
00867     {
00868       DynamicAny::DynAny_var cc =
00869         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
00870       ACE_CHECK_RETURN (0);
00871 
00872       return cc->get_octet (ACE_ENV_SINGLE_ARG_PARAMETER);
00873     }
00874   else
00875     {
00876       CORBA::Octet retval;
00877 
00878       if ((this->any_ >>= CORBA::Any::to_octet (retval)) == 0)
00879         {
00880           ACE_THROW_RETURN (DynamicAny::DynAny::TypeMismatch (),
00881                             0);
00882         }
00883 
00884       return retval;
00885     }
00886 }

CORBA::Object_ptr TAO_DynCommon::get_reference (   )  throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue ) [virtual]
 

Implements DynamicAny::DynAny.

Definition at line 1198 of file DynCommon.cpp.

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

01204 {
01205   if (this->destroyed_)
01206     {
01207       ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
01208                         CORBA::Object::_nil ());
01209     }
01210 
01211   if (this->has_components_)
01212     {
01213       DynamicAny::DynAny_var cc =
01214         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
01215       ACE_CHECK_RETURN (CORBA::Object::_nil ());
01216 
01217       return cc->get_reference (ACE_ENV_SINGLE_ARG_PARAMETER);
01218     }
01219   else
01220     {
01221       CORBA::Object_var retval;
01222 
01223       if ((this->any_ >>= CORBA::Any::to_object (retval.inout ())) == 0)
01224         {
01225           ACE_THROW_RETURN (DynamicAny::DynAny::TypeMismatch (),
01226                             CORBA::Object::_nil ());
01227         }
01228 
01229       return retval._retn ();
01230     }
01231 }

CORBA::Short TAO_DynCommon::get_short (   )  throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue ) [virtual]
 

Implements DynamicAny::DynAny.

Definition at line 925 of file DynCommon.cpp.

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

00931 {
00932   if (this->destroyed_)
00933     {
00934       ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
00935                         0);
00936     }
00937 
00938   if (this->has_components_)
00939     {
00940       DynamicAny::DynAny_var cc =
00941         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
00942       ACE_CHECK_RETURN (0);
00943 
00944       return cc->get_short (ACE_ENV_SINGLE_ARG_PARAMETER);
00945     }
00946   else
00947     {
00948       CORBA::Short retval;
00949 
00950       if ((this->any_ >>= retval) == 0)
00951         {
00952           ACE_THROW_RETURN (DynamicAny::DynAny::TypeMismatch (),
00953                             0);
00954         }
00955 
00956       return retval;
00957     }
00958 }

char * TAO_DynCommon::get_string (   )  throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue ) [virtual]
 

Implements DynamicAny::DynAny.

Definition at line 1141 of file DynCommon.cpp.

References ACE_CHECK_RETURN, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_THROW_RETURN, DynamicAny::DynAny_var, CORBA::string_dup(), and TAO_DynAnyFactory::strip_alias(). 

01147 {
01148   if (this->destroyed_)
01149     {
01150       ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
01151                         0);
01152     }
01153 
01154   if (this->has_components_)
01155     {
01156       DynamicAny::DynAny_var cc =
01157         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
01158       ACE_CHECK_RETURN (0);
01159 
01160       return cc->get_string (ACE_ENV_SINGLE_ARG_PARAMETER);
01161     }
01162   else
01163     {
01164       CORBA::TypeCode_var unaliased_tc =
01165         TAO_DynAnyFactory::strip_alias (this->type_.in ()
01166                                         ACE_ENV_ARG_PARAMETER);
01167       ACE_CHECK_RETURN (0);
01168 
01169       CORBA::TCKind kind =
01170         unaliased_tc->kind (ACE_ENV_SINGLE_ARG_PARAMETER);
01171       ACE_CHECK_RETURN (0);
01172 
01173       if (kind != CORBA::tk_string)
01174         {
01175           ACE_THROW_RETURN (DynamicAny::DynAny::TypeMismatch (),
01176                             0);
01177         }
01178 
01179       char *retval = 0;
01180 
01181       CORBA::ULong bound =
01182         unaliased_tc->length (ACE_ENV_SINGLE_ARG_PARAMETER);
01183       ACE_CHECK_RETURN (0);
01184 
01185       // We will have caught a type mismatch above, so if this fails,
01186       // it must be for some other reason.
01187       if ((this->any_ >>= CORBA::Any::to_string (retval, bound)) == 0)
01188         {
01189           ACE_THROW_RETURN (DynamicAny::DynAny::InvalidValue (),
01190                             0);
01191         }
01192 
01193       return CORBA::string_dup (retval);
01194     }
01195 }

CORBA::TypeCode_ptr TAO_DynCommon::get_typecode (   )  throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue ) [virtual]
 

Implements DynamicAny::DynAny.

Definition at line 1234 of file DynCommon.cpp.

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

01240 {
01241   if (this->destroyed_)
01242     {
01243       ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
01244                         CORBA::TypeCode::_nil ());
01245     }
01246 
01247   if (this->has_components_)
01248     {
01249       DynamicAny::DynAny_var cc =
01250         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
01251       ACE_CHECK_RETURN (0);
01252 
01253       return cc->get_typecode (ACE_ENV_SINGLE_ARG_PARAMETER);
01254     }
01255   else
01256     {
01257       CORBA::TypeCode_ptr retval;
01258 
01259       if ((this->any_ >>= retval) == 0)
01260         {
01261           ACE_THROW_RETURN (DynamicAny::DynAny::TypeMismatch (),
01262                             CORBA::TypeCode::_nil ());
01263         }
01264 
01265       return CORBA::TypeCode::_duplicate (retval);
01266     }
01267 }

CORBA::ULong TAO_DynCommon::get_ulong (   )  throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue ) [virtual]
 

Implements DynamicAny::DynAny.

Definition at line 1033 of file DynCommon.cpp.

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

01039 {
01040   if (this->destroyed_)
01041     {
01042       ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
01043                         0);
01044     }
01045 
01046   if (this->has_components_)
01047     {
01048       DynamicAny::DynAny_var cc =
01049         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
01050       ACE_CHECK_RETURN (0);
01051 
01052       return cc->get_ulong (ACE_ENV_SINGLE_ARG_PARAMETER);
01053     }
01054   else
01055     {
01056       CORBA::ULong retval;
01057 
01058       if ((this->any_ >>= retval) == 0)
01059         {
01060           ACE_THROW_RETURN (DynamicAny::DynAny::TypeMismatch (),
01061                             0);
01062         }
01063 
01064       return retval;
01065     }
01066 }

CORBA::ULongLong TAO_DynCommon::get_ulonglong (   )  throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue ) [virtual]
 

Implements DynamicAny::DynAny.

Definition at line 1306 of file DynCommon.cpp.

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

01312 {
01313   CORBA::ULongLong retval = 0;
01314 
01315   if (this->destroyed_)
01316     {
01317       ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
01318                         retval);
01319     }
01320 
01321   if (this->has_components_)
01322     {
01323       DynamicAny::DynAny_var cc =
01324         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
01325       ACE_CHECK_RETURN (retval);
01326 
01327       return cc->get_ulonglong (ACE_ENV_SINGLE_ARG_PARAMETER);
01328     }
01329   else
01330     {
01331       if ((this->any_ >>= retval) == 0)
01332         {
01333           ACE_THROW_RETURN (DynamicAny::DynAny::TypeMismatch (),
01334                             retval);
01335         }
01336 
01337       return retval;
01338     }
01339 }

CORBA::UShort TAO_DynCommon::get_ushort (   )  throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue ) [virtual]
 

Implements DynamicAny::DynAny.

Definition at line 961 of file DynCommon.cpp.

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

00967 {
00968   if (this->destroyed_)
00969     {
00970       ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
00971                         0);
00972     }
00973 
00974   if (this->has_components_)
00975     {
00976       DynamicAny::DynAny_var cc =
00977         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
00978       ACE_CHECK_RETURN (0);
00979 
00980       return cc->get_ushort (ACE_ENV_SINGLE_ARG_PARAMETER);
00981     }
00982   else
00983     {
00984       CORBA::UShort retval;
00985 
00986       if ((this->any_ >>= retval) == 0)
00987         {
00988           ACE_THROW_RETURN (DynamicAny::DynAny::TypeMismatch (),
00989                             0);
00990         }
00991 
00992       return retval;
00993     }
00994 }

CORBA::ValueBase * TAO_DynCommon::get_val (   )  throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue ) [virtual]
 

Implements DynamicAny::DynAny.

Definition at line 1522 of file DynCommon.cpp.

References ACE_THROW_RETURN. 

01528 {
01529   ACE_THROW_RETURN (CORBA::NO_IMPLEMENT (),
01530                     0);
01531 }

CORBA::WChar TAO_DynCommon::get_wchar (   )  throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue ) [virtual]
 

Implements DynamicAny::DynAny.

Definition at line 1378 of file DynCommon.cpp.

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

01384 {
01385   if (this->destroyed_)
01386     {
01387       ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
01388                         0);
01389     }
01390 
01391   if (this->has_components_)
01392     {
01393       DynamicAny::DynAny_var cc =
01394         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
01395       ACE_CHECK_RETURN (0);
01396 
01397       return cc->get_wchar (ACE_ENV_SINGLE_ARG_PARAMETER);
01398     }
01399   else
01400     {
01401       CORBA::WChar retval;
01402 
01403       if ((this->any_ >>= CORBA::Any::to_wchar (retval)) == 0)
01404         {
01405           ACE_THROW_RETURN (DynamicAny::DynAny::TypeMismatch (),
01406                             0);
01407         }
01408 
01409       return retval;
01410     }
01411 }

CORBA::WChar * TAO_DynCommon::get_wstring (   )  throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue ) [virtual]
 

Implements DynamicAny::DynAny.

Definition at line 1414 of file DynCommon.cpp.

References ACE_CHECK_RETURN, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_THROW_RETURN, DynamicAny::DynAny_var, and CORBA::wstring_dup(). 

01420 {
01421   if (this->destroyed_)
01422     {
01423       ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
01424                         0);
01425     }
01426 
01427   if (this->has_components_)
01428     {
01429       DynamicAny::DynAny_var cc =
01430         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
01431       ACE_CHECK_RETURN (0);
01432 
01433       return cc->get_wstring (ACE_ENV_SINGLE_ARG_PARAMETER);
01434     }
01435   else
01436     {
01437       // @@@ (JP) Someday try to find a way to avoid checking for
01438       // type code equivalence twice without risking a throw of
01439       // BadKind.
01440       CORBA::TypeCode_var unaliased_tc =
01441         this->check_type_and_unalias (CORBA::_tc_wstring
01442                                       ACE_ENV_ARG_PARAMETER);
01443       ACE_CHECK_RETURN (0);
01444 
01445       CORBA::WChar *retval = 0;
01446 
01447       CORBA::ULong bound =
01448         unaliased_tc->length (ACE_ENV_SINGLE_ARG_PARAMETER);
01449       ACE_CHECK_RETURN (0);
01450 
01451       (void) (this->any_ >>= CORBA::Any::to_wstring (retval,
01452                                                      bound));
01453 
01454       return CORBA::wstring_dup (retval);
01455     }
01456 }

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

Definition at line 745 of file DynCommon.cpp.

References ACE_CHECK, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_THROW, and DynamicAny::DynAny_var. 

00752 {
00753   if (this->destroyed_)
00754     {
00755       ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
00756     }
00757 
00758   if (this->has_components_)
00759     {
00760       DynamicAny::DynAny_var cc =
00761         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
00762       ACE_CHECK;
00763 
00764       cc->insert_any (value
00765                       ACE_ENV_ARG_PARAMETER);
00766       ACE_CHECK;
00767     }
00768   else
00769     {
00770       this->check_type (CORBA::_tc_any
00771                         ACE_ENV_ARG_PARAMETER);
00772       ACE_CHECK;
00773 
00774       this->any_ <<= value;
00775     }
00776 }

void TAO_DynCommon::insert_boolean (  CORBA::Boolean  value  )  throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue ) [virtual]
 

Definition at line 86 of file DynCommon.cpp.

References ACE_CHECK, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_THROW, and DynamicAny::DynAny_var. 

00093 {
00094   if (this->destroyed_)
00095     {
00096       ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
00097     }
00098 
00099   if (this->has_components_)
00100     {
00101       DynamicAny::DynAny_var cc =
00102         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
00103       ACE_CHECK;
00104 
00105       cc->insert_boolean (value
00106                           ACE_ENV_ARG_PARAMETER);
00107       ACE_CHECK;
00108     }
00109   else
00110     {
00111       this->check_type (CORBA::_tc_boolean
00112                         ACE_ENV_ARG_PARAMETER);
00113       ACE_CHECK;
00114 
00115       this->any_ <<= CORBA::Any::from_boolean (value);
00116     }
00117 }

void TAO_DynCommon::insert_char (  CORBA::Char  value  )  throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue ) [virtual]
 

Definition at line 154 of file DynCommon.cpp.

References ACE_CHECK, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_THROW, and DynamicAny::DynAny_var. 

00161 {
00162   if (this->destroyed_)
00163     {
00164       ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
00165     }
00166 
00167   if (this->has_components_)
00168     {
00169       DynamicAny::DynAny_var cc =
00170         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
00171       ACE_CHECK;
00172 
00173       cc->insert_char (value
00174                        ACE_ENV_ARG_PARAMETER);
00175       ACE_CHECK;
00176     }
00177   else
00178     {
00179       this->check_type (CORBA::_tc_char
00180                         ACE_ENV_ARG_PARAMETER);
00181       ACE_CHECK;
00182 
00183       this->any_ <<= CORBA::Any::from_char (value);
00184     }
00185 }

void TAO_DynCommon::insert_double (  CORBA::Double  value  )  throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue ) [virtual]
 

Definition at line 358 of file DynCommon.cpp.

References ACE_CHECK, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_THROW, and DynamicAny::DynAny_var. 

00365 {
00366   if (this->destroyed_)
00367     {
00368       ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
00369     }
00370 
00371   if (this->has_components_)
00372     {
00373       DynamicAny::DynAny_var cc =
00374         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
00375       ACE_CHECK;
00376 
00377       cc->insert_double (value
00378                          ACE_ENV_ARG_PARAMETER);
00379       ACE_CHECK;
00380     }
00381   else
00382     {
00383       this->check_type (CORBA::_tc_double
00384                         ACE_ENV_ARG_PARAMETER);
00385       ACE_CHECK;
00386 
00387       this->any_ <<= value;
00388     }
00389 }

void TAO_DynCommon::insert_dyn_any (  DynamicAny::DynAny_ptr  value  )  throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue ) [virtual]
 

Definition at line 781 of file DynCommon.cpp.

References ACE_CHECK, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_THROW, and DynamicAny::DynAny_ptr. 

00788 {
00789   if (this->destroyed_)
00790     {
00791       ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
00792     }
00793 
00794   CORBA::Any_var any = value->to_any (ACE_ENV_SINGLE_ARG_PARAMETER);
00795   ACE_CHECK;
00796 
00797   this->insert_any (any.in ()
00798                     ACE_ENV_ARG_PARAMETER);
00799   ACE_CHECK;
00800 }

void TAO_DynCommon::insert_float (  CORBA::Float  value  )  throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue ) [virtual]
 

Definition at line 324 of file DynCommon.cpp.

References ACE_CHECK, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_THROW, and DynamicAny::DynAny_var. 

00331 {
00332   if (this->destroyed_)
00333     {
00334       ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
00335     }
00336 
00337   if (this->has_components_)
00338     {
00339       DynamicAny::DynAny_var cc =
00340         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
00341       ACE_CHECK;
00342 
00343       cc->insert_float (value
00344                         ACE_ENV_ARG_PARAMETER);
00345       ACE_CHECK;
00346     }
00347   else
00348     {
00349       this->check_type (CORBA::_tc_float
00350                         ACE_ENV_ARG_PARAMETER);
00351       ACE_CHECK;
00352 
00353       this->any_ <<= value;
00354     }
00355 }

void TAO_DynCommon::insert_long (  CORBA::Long  value  )  throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue ) [virtual]
 

Definition at line 256 of file DynCommon.cpp.

References ACE_CHECK, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_THROW, and DynamicAny::DynAny_var. 

00263 {
00264   if (this->destroyed_)
00265     {
00266       ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
00267     }
00268 
00269   if (this->has_components_)
00270     {
00271       DynamicAny::DynAny_var cc =
00272         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
00273       ACE_CHECK;
00274 
00275       cc->insert_long (value
00276                        ACE_ENV_ARG_PARAMETER);
00277       ACE_CHECK;
00278     }
00279   else
00280     {
00281       this->check_type (CORBA::_tc_long
00282                         ACE_ENV_ARG_PARAMETER);
00283       ACE_CHECK;
00284 
00285       this->any_ <<= value;
00286     }
00287 }

void TAO_DynCommon::insert_longdouble (  CORBA::LongDouble  value  )  throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue ) [virtual]
 

Definition at line 633 of file DynCommon.cpp.

References ACE_CHECK, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_THROW, and DynamicAny::DynAny_var. 

00640 {
00641   if (this->destroyed_)
00642     {
00643       ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
00644     }
00645 
00646   if (this->has_components_)
00647     {
00648       DynamicAny::DynAny_var cc =
00649         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
00650       ACE_CHECK;
00651 
00652       cc->insert_longdouble (value
00653                              ACE_ENV_ARG_PARAMETER);
00654       ACE_CHECK;
00655     }
00656   else
00657     {
00658       this->check_type (CORBA::_tc_longdouble
00659                         ACE_ENV_ARG_PARAMETER);
00660       ACE_CHECK;
00661 
00662       this->any_ <<= value;
00663     }
00664 }

void TAO_DynCommon::insert_longlong (  CORBA::LongLong  value  )  throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue ) [virtual]
 

Definition at line 565 of file DynCommon.cpp.

References ACE_CHECK, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_THROW, and DynamicAny::DynAny_var. 

00572 {
00573   if (this->destroyed_)
00574     {
00575       ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
00576     }
00577 
00578   if (this->has_components_)
00579     {
00580       DynamicAny::DynAny_var cc =
00581         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
00582       ACE_CHECK;
00583 
00584       cc->insert_longlong (value
00585                            ACE_ENV_ARG_PARAMETER);
00586       ACE_CHECK;
00587     }
00588   else
00589     {
00590       this->check_type (CORBA::_tc_longlong
00591                         ACE_ENV_ARG_PARAMETER);
00592       ACE_CHECK;
00593 
00594       this->any_ <<= value;
00595     }
00596 }

void TAO_DynCommon::insert_octet (  CORBA::Octet  value  )  throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue ) [virtual]
 

Definition at line 120 of file DynCommon.cpp.

References ACE_CHECK, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_THROW, and DynamicAny::DynAny_var. 

00127 {
00128   if (this->destroyed_)
00129     {
00130       ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
00131     }
00132 
00133   if (this->has_components_)
00134     {
00135       DynamicAny::DynAny_var cc =
00136         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
00137       ACE_CHECK;
00138 
00139       cc->insert_octet (value
00140                         ACE_ENV_ARG_PARAMETER);
00141       ACE_CHECK;
00142     }
00143   else
00144     {
00145       this->check_type (CORBA::_tc_octet
00146                         ACE_ENV_ARG_PARAMETER);
00147       ACE_CHECK;
00148 
00149       this->any_ <<= CORBA::Any::from_octet (value);
00150     }
00151 }

void TAO_DynCommon::insert_reference (  CORBA::Object_ptr  value  )  throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue ) [virtual]
 

Definition at line 446 of file DynCommon.cpp.

References ACE_CHECK, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_NEW, ACE_THROW, DynamicAny::DynAny_var, CORBA::is_nil(), ACE_OS::strcmp(), TAO_DynAnyFactory::unalias(), ACE_OutputCDR::write_char(), and ACE_OutputCDR::write_ulong(). 

00453 {
00454   if (this->destroyed_)
00455     {
00456       ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
00457     }
00458 
00459   if (this->has_components_)
00460     {
00461       DynamicAny::DynAny_var cc =
00462         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
00463       ACE_CHECK;
00464 
00465       cc->insert_reference (value
00466                             ACE_ENV_ARG_PARAMETER);
00467       ACE_CHECK;
00468     }
00469   else
00470     {
00471       CORBA::Boolean good_type = 1;
00472       CORBA::TCKind kind =
00473         TAO_DynAnyFactory::unalias (this->type_.in ()
00474                                     ACE_ENV_ARG_PARAMETER);
00475       ACE_CHECK;
00476 
00477       if (kind != CORBA::tk_objref)
00478         {
00479           good_type = 0;
00480         }
00481       else if (!CORBA::is_nil (value))
00482         {
00483           const char *value_id = value->_interface_repository_id ();
00484 
00485           if (ACE_OS::strcmp (value_id, "IDL:omg.org/CORBA/Object:1.0") != 0)
00486             {
00487               const char *my_id =
00488                 this->type_->id (ACE_ENV_SINGLE_ARG_PARAMETER);
00489               ACE_CHECK;
00490 
00491               if (ACE_OS::strcmp (value_id, my_id) != 0)
00492                 {
00493                   good_type = value->_is_a (my_id
00494                                             ACE_ENV_ARG_PARAMETER);
00495                   ACE_CHECK;
00496                 }
00497             }
00498         }
00499 
00500       if (good_type)
00501         {
00502           TAO_OutputCDR cdr;
00503 
00504           if (CORBA::is_nil (value))
00505             {
00506               // Empty type hint, no profile.
00507               cdr.write_ulong (1);
00508               cdr.write_char ('\0');
00509               cdr.write_ulong (0);
00510             }
00511           else
00512             {
00513               value->marshal (cdr);
00514             }
00515 
00516           TAO_InputCDR in (cdr);
00517           TAO::Unknown_IDL_Type *unk = 0;
00518           ACE_NEW (unk,
00519                    TAO::Unknown_IDL_Type (this->type_.in (),
00520                                           in));
00521           this->any_.replace (unk);
00522         }
00523       else
00524         {
00525           ACE_THROW (DynamicAny::DynAny::TypeMismatch ());
00526         }
00527     }
00528 }

void TAO_DynCommon::insert_short (  CORBA::Short  value  )  throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue ) [virtual]
 

Definition at line 188 of file DynCommon.cpp.

References ACE_CHECK, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_THROW, and DynamicAny::DynAny_var. 

00195 {
00196   if (this->destroyed_)
00197     {
00198       ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
00199     }
00200 
00201   if (this->has_components_)
00202     {
00203       DynamicAny::DynAny_var cc =
00204         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
00205       ACE_CHECK;
00206 
00207       cc->insert_short (value
00208                         ACE_ENV_ARG_PARAMETER);
00209       ACE_CHECK;
00210     }
00211   else
00212     {
00213       this->check_type (CORBA::_tc_short
00214                         ACE_ENV_ARG_PARAMETER);
00215       ACE_CHECK;
00216 
00217       this->any_ <<= value;
00218     }
00219 }

void TAO_DynCommon::insert_string (  const char *  value  )  throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue ) [virtual]
 

Implements DynamicAny::DynAny.

Definition at line 392 of file DynCommon.cpp.

References ACE_CHECK, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_THROW, DynamicAny::DynAny_var, TAO_DynAnyFactory::strip_alias(), and ACE_OS::strlen(). 

00399 {
00400   if (this->destroyed_)
00401     {
00402       ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
00403     }
00404 
00405   if (this->has_components_)
00406     {
00407       DynamicAny::DynAny_var cc =
00408         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
00409       ACE_CHECK;
00410 
00411       cc->insert_string (value
00412                          ACE_ENV_ARG_PARAMETER);
00413       ACE_CHECK;
00414     }
00415   else
00416     {
00417       CORBA::TypeCode_var unaliased_tc =
00418         TAO_DynAnyFactory::strip_alias (this->type_.in ()
00419                                         ACE_ENV_ARG_PARAMETER);
00420       ACE_CHECK;
00421 
00422       CORBA::TCKind kind =
00423         unaliased_tc->kind (ACE_ENV_SINGLE_ARG_PARAMETER);
00424       ACE_CHECK;
00425 
00426       if (kind != CORBA::tk_string)
00427         {
00428           ACE_THROW (DynamicAny::DynAny::TypeMismatch ());
00429         }
00430 
00431       CORBA::ULong bound =
00432         unaliased_tc->length (ACE_ENV_SINGLE_ARG_PARAMETER);
00433       ACE_CHECK;
00434 
00435       if (bound > 0 && bound < ACE_OS::strlen (value))
00436         {
00437           ACE_THROW (DynamicAny::DynAny::InvalidValue ());
00438         }
00439 
00440       this->any_ <<= CORBA::Any::from_string (const_cast<char *> (value),
00441                                               bound);
00442     }
00443 }

void TAO_DynCommon::insert_typecode (  CORBA::TypeCode_ptr  value  )  throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue ) [virtual]
 

Definition at line 531 of file DynCommon.cpp.

References ACE_CHECK, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_THROW, and DynamicAny::DynAny_var. 

00538 {
00539   if (this->destroyed_)
00540     {
00541       ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
00542     }
00543 
00544   if (this->has_components_)
00545     {
00546       DynamicAny::DynAny_var cc =
00547         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
00548       ACE_CHECK;
00549 
00550       cc->insert_typecode (value
00551                            ACE_ENV_ARG_PARAMETER);
00552       ACE_CHECK;
00553     }
00554   else
00555     {
00556       this->check_type (CORBA::_tc_TypeCode
00557                         ACE_ENV_ARG_PARAMETER);
00558       ACE_CHECK;
00559 
00560       this->any_ <<= value;
00561     }
00562 }

void TAO_DynCommon::insert_ulong (  CORBA::ULong  value  )  throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue ) [virtual]
 

Definition at line 290 of file DynCommon.cpp.

References ACE_CHECK, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_THROW, and DynamicAny::DynAny_var. 

00297 {
00298   if (this->destroyed_)
00299     {
00300       ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
00301     }
00302 
00303   if (this->has_components_)
00304     {
00305       DynamicAny::DynAny_var cc =
00306         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
00307       ACE_CHECK;
00308 
00309       cc->insert_ulong (value
00310                         ACE_ENV_ARG_PARAMETER);
00311       ACE_CHECK;
00312     }
00313   else
00314     {
00315       this->check_type (CORBA::_tc_ulong
00316                         ACE_ENV_ARG_PARAMETER);
00317       ACE_CHECK;
00318 
00319       this->any_ <<= value;
00320     }
00321 }

void TAO_DynCommon::insert_ulonglong (  CORBA::ULongLong  value  )  throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue ) [virtual]
 

Definition at line 599 of file DynCommon.cpp.

References ACE_CHECK, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_THROW, and DynamicAny::DynAny_var. 

00606 {
00607   if (this->destroyed_)
00608     {
00609       ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
00610     }
00611 
00612   if (this->has_components_)
00613     {
00614       DynamicAny::DynAny_var cc =
00615         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
00616       ACE_CHECK;
00617 
00618       cc->insert_ulonglong (value
00619                             ACE_ENV_ARG_PARAMETER);
00620       ACE_CHECK;
00621     }
00622   else
00623     {
00624       this->check_type (CORBA::_tc_ulonglong
00625                         ACE_ENV_ARG_PARAMETER);
00626       ACE_CHECK;
00627 
00628       this->any_ <<= value;
00629     }
00630 }

void TAO_DynCommon::insert_ushort (  CORBA::UShort  value  )  throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue ) [virtual]
 

Definition at line 222 of file DynCommon.cpp.

References ACE_CHECK, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_THROW, and DynamicAny::DynAny_var. 

00229 {
00230   if (this->destroyed_)
00231     {
00232       ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
00233     }
00234 
00235   if (this->has_components_)
00236     {
00237       DynamicAny::DynAny_var cc =
00238         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
00239       ACE_CHECK;
00240 
00241       cc->insert_ushort (value
00242                          ACE_ENV_ARG_PARAMETER);
00243       ACE_CHECK;
00244     }
00245   else
00246     {
00247       this->check_type (CORBA::_tc_ushort
00248                         ACE_ENV_ARG_PARAMETER);
00249       ACE_CHECK;
00250 
00251       this->any_ <<= value;
00252     }
00253 }

void TAO_DynCommon::insert_val (  CORBA::ValueBase *  value  )  throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue ) [virtual]
 

Definition at line 803 of file DynCommon.cpp.

References ACE_THROW. 

00810 {
00811   ACE_THROW (CORBA::NO_IMPLEMENT ());
00812 }

void TAO_DynCommon::insert_wchar (  CORBA::WChar  value  )  throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue ) [virtual]
 

Definition at line 667 of file DynCommon.cpp.

References ACE_CHECK, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_THROW, and DynamicAny::DynAny_var. 

00674 {
00675   if (this->destroyed_)
00676     {
00677       ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
00678     }
00679 
00680   if (this->has_components_)
00681     {
00682       DynamicAny::DynAny_var cc =
00683         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
00684       ACE_CHECK;
00685 
00686       cc->insert_wchar (value
00687                         ACE_ENV_ARG_PARAMETER);
00688       ACE_CHECK;
00689     }
00690   else
00691     {
00692       this->check_type (CORBA::_tc_wchar
00693                         ACE_ENV_ARG_PARAMETER);
00694       ACE_CHECK;
00695 
00696       this->any_ <<= CORBA::Any::from_wchar (value);
00697     }
00698 }

void TAO_DynCommon::insert_wstring (  const CORBA::WChar *  value  )  throw ( CORBA::SystemException, DynamicAny::DynAny::TypeMismatch, DynamicAny::DynAny::InvalidValue ) [virtual]
 

Implements DynamicAny::DynAny.

Definition at line 701 of file DynCommon.cpp.

References ACE_CHECK, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_THROW, DynamicAny::DynAny_var, and ACE_OS::wslen(). 

00708 {
00709   if (this->destroyed_)
00710     {
00711       ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
00712     }
00713 
00714   if (this->has_components_)
00715     {
00716       DynamicAny::DynAny_var cc =
00717         this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
00718       ACE_CHECK;
00719 
00720       cc->insert_wstring (value
00721                           ACE_ENV_ARG_PARAMETER);
00722       ACE_CHECK;
00723     }
00724   else
00725     {
00726       CORBA::TypeCode_var unaliased_tc =
00727         this->check_type_and_unalias (CORBA::_tc_wstring
00728                                       ACE_ENV_ARG_PARAMETER);
00729       ACE_CHECK;
00730 
00731       CORBA::ULong bound = unaliased_tc->length (ACE_ENV_SINGLE_ARG_PARAMETER);
00732       ACE_CHECK;
00733 
00734       if (bound > 0 && bound < ACE_OS::wslen (value))
00735         {
00736           ACE_THROW (DynamicAny::DynAny::InvalidValue ());
00737         }
00738 
00739       this->any_ <<= CORBA::Any::from_wstring (const_cast<CORBA::WChar *> (value),
00740                                                bound);
00741     }
00742 }

CORBA::Boolean TAO_DynCommon::next (   )  throw ( CORBA::SystemException ) [virtual]
 

Implements DynamicAny::DynAny.

Definition at line 1583 of file DynCommon.cpp.

References ACE_THROW_RETURN. 

01587 {
01588   if (this->destroyed_)
01589     {
01590       ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
01591                         0);
01592     }
01593 
01594   if (this->has_components_ == 0
01595       || this->current_position_ + 1 >= static_cast<CORBA::Long> (this->component_count_
01596                                           ))
01597     {
01598       this->current_position_ = -1;
01599       return 0;
01600     }
01601   else
01602     {
01603       ++this->current_position_;
01604       return 1;
01605     }
01606 }

void TAO_DynCommon::rewind (   )  throw ( CORBA::SystemException ) [virtual]
 

Implements DynamicAny::DynAny.

Definition at line 1567 of file DynCommon.cpp.

References ACE_CHECK, ACE_ENV_ARG_PARAMETER, and ACE_THROW. 

01571 {
01572   if (this->destroyed_)
01573     {
01574       ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
01575     }
01576 
01577   (void) this->seek (0
01578                      ACE_ENV_ARG_PARAMETER);
01579   ACE_CHECK;
01580 }

CORBA::Boolean TAO_DynCommon::seek (  CORBA::Long  index  )  throw ( CORBA::SystemException ) [virtual]
 

Definition at line 1536 of file DynCommon.cpp.

References ACE_THROW_RETURN. 

01541 {
01542   if (this->destroyed_)
01543     {
01544       ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
01545                         0);
01546     }
01547 
01548   if (this->has_components_ == 0)
01549     {
01550       ACE_UNUSED_ARG (slot);
01551       this->current_position_ = -1;
01552       return 0;
01553     }
01554   else if (slot < 0 || slot >= static_cast<CORBA::Long> (this->component_count_))
01555     {
01556       this->current_position_ = -1;
01557       return 0;
01558     }
01559   else
01560     {
01561       this->current_position_ = slot;
01562       return 1;
01563     }
01564 }

void TAO_DynCommon::set_flag (  DynamicAny::DynAny_ptr  component,
CORBA::Boolean  destroying
)  throw ( CORBA::SystemException ) [protected]
 

This sets one of two flags in this base class. CORBA 2.4.2 requires that destroy() do nothing if it is called on the result of current_component(), the only non-deep-copying method in the Dynamic Any API. If the boolean arg below is 0, the call is from inside current_component(), and the flag ref_to_component_ is set. If the boolean arg is 1, the call is from inside destroy(), and the container_is_destroying_ flag is set, overriding the first flag in the component's destroy() method.

Definition at line 1647 of file DynCommon.cpp.

References TAO_DynAny_i::_narrow(), TAO_DynUnion_i::_narrow(), TAO_DynStruct_i::_narrow(), TAO_DynSequence_i::_narrow(), TAO_DynEnum_i::_narrow(), TAO_DynArray_i::_narrow(), ACE_CHECK, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_THROW, container_is_destroying_, DynamicAny::DynAny_ptr, ref_to_component_, and TAO_DynAnyFactory::unalias(). 

01653 {
01654   CORBA::TypeCode_var tc = component->type (ACE_ENV_SINGLE_ARG_PARAMETER);
01655   ACE_CHECK;
01656 
01657   CORBA::TCKind tk = TAO_DynAnyFactory::unalias (tc.in ()
01658                                                  ACE_ENV_ARG_PARAMETER);
01659   ACE_CHECK;
01660 
01661   switch (tk)
01662   {
01663     case CORBA::tk_array:
01664       {
01665         TAO_DynArray_i *tmp =
01666           TAO_DynArray_i::_narrow (component
01667                                    ACE_ENV_ARG_PARAMETER);
01668         ACE_CHECK;
01669 
01670         if (destroying)
01671           {
01672             tmp->container_is_destroying_ = 1;
01673           }
01674         else
01675           {
01676             tmp->ref_to_component_ = 1;
01677           }
01678 
01679         break;
01680       }
01681     case CORBA::tk_enum:
01682       {
01683         TAO_DynEnum_i *tmp = TAO_DynEnum_i::_narrow (component
01684                                                      ACE_ENV_ARG_PARAMETER);
01685         ACE_CHECK;
01686 
01687         if (destroying)
01688           {
01689             tmp->container_is_destroying_ = 1;
01690           }
01691         else
01692           {
01693             tmp->ref_to_component_ = 1;
01694           }
01695 
01696         break;
01697       }
01698     case CORBA::tk_sequence:
01699       {
01700         TAO_DynSequence_i *tmp =
01701           TAO_DynSequence_i::_narrow (component
01702                                       ACE_ENV_ARG_PARAMETER);
01703         ACE_CHECK;
01704 
01705         if (destroying)
01706           {
01707             tmp->container_is_destroying_ = 1;
01708           }
01709         else
01710           {
01711             tmp->ref_to_component_ = 1;
01712           }
01713 
01714         break;
01715       }
01716     case CORBA::tk_struct:
01717       {
01718         TAO_DynStruct_i *tmp =
01719           TAO_DynStruct_i::_narrow (component
01720                                     ACE_ENV_ARG_PARAMETER);
01721         ACE_CHECK;
01722 
01723         if (destroying)
01724           {
01725             tmp->container_is_destroying_ = 1;
01726           }
01727         else
01728           {
01729             tmp->ref_to_component_ = 1;
01730           }
01731 
01732         break;
01733       }
01734     case CORBA::tk_union:
01735       {
01736         TAO_DynUnion_i *tmp =
01737           TAO_DynUnion_i::_narrow (component
01738                                    ACE_ENV_ARG_PARAMETER);
01739         ACE_CHECK;
01740 
01741         if (destroying)
01742           {
01743             tmp->container_is_destroying_ = 1;
01744           }
01745         else
01746           {
01747             tmp->ref_to_component_ = 1;
01748           }
01749 
01750         break;
01751       }
01752     case CORBA::tk_fixed:
01753     case CORBA::tk_value:
01754     case CORBA::tk_value_box:
01755       ACE_THROW (CORBA::NO_IMPLEMENT ());
01756     default:
01757       {
01758         TAO_DynAny_i *tmp = TAO_DynAny_i::_narrow (component
01759                                                    ACE_ENV_ARG_PARAMETER);
01760         ACE_CHECK;
01761 
01762         if (destroying)
01763           {
01764             tmp->container_is_destroying_ = 1;
01765           }
01766         else
01767           {
01768             tmp->ref_to_component_ = 1;
01769           }
01770 
01771         break;
01772       }
01773   }
01774 }

CORBA::TypeCode_ptr TAO_DynCommon::type (   )  throw ( CORBA::SystemException ) [virtual]
 

Implements DynamicAny::DynAny.

Definition at line 35 of file DynCommon.cpp.

References ACE_THROW_RETURN. 

00039 {
00040   if (this->destroyed_)
00041     {
00042       ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
00043                         CORBA::TypeCode::_nil ());
00044     }
00045 
00046   return CORBA::TypeCode::_duplicate (this->type_.in ());
00047 }

Member Data Documentation

CORBA::Any TAO_DynCommon::any_ [protected]
 

Gets a value only for basic types, but used in insert_* and get_*, defined in this base class.

Definition at line 524 of file DynCommon.h.

Referenced by TAO_DynAny_i::equal().

CORBA::ULong TAO_DynCommon::component_count_ [protected]
 

Number of components, as defined by CORBA 2.4.2.

Definition at line 517 of file DynCommon.h.

CORBA::Boolean TAO_DynCommon::container_is_destroying_ [protected]
 

Flag to let destroy() call by container override the flag above.

Definition at line 505 of file DynCommon.h.

Referenced by set_flag().

CORBA::Long TAO_DynCommon::current_position_ [protected]
 

Slot of the current component (if any).

Definition at line 514 of file DynCommon.h.

CORBA::Boolean TAO_DynCommon::destroyed_ [protected]
 

Has destroy() been called on us yet?

Definition at line 511 of file DynCommon.h.

CORBA::Boolean TAO_DynCommon::has_components_ [protected]
 

Do we contain other Dynamic Anys?

Definition at line 508 of file DynCommon.h.

CORBA::Boolean TAO_DynCommon::ref_to_component_ [protected]
 

Were we created by current_component()?

Definition at line 502 of file DynCommon.h.

Referenced by set_flag().

CORBA::TypeCode_var TAO_DynCommon::type_ [protected]
 

Holder for our type code.

Definition at line 520 of file DynCommon.h.

Referenced by TAO_DynUnion_i::equal(), and TAO_DynAny_i::equal().

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