A representation of the structure of a given OMG IDL-declared type. More...

#include <TypeCode.h>

Inheritance diagram for CORBA::TypeCode:

Collaboration diagram for CORBA::TypeCode:

Classes
class	BadKind
	Invalid `TypeCode` operation exception. More...
class	Bounds
	Out-of-bounds member index exception. More...
Public Types
typedef CORBA::TypeCode_ptr	_ptr_type
typedef CORBA::TypeCode_var	_var_type
typedef CORBA::TypeCode_out	_out_type
Public Member Functions
virtual bool	tao_marshal_kind (TAO_OutputCDR &cdr) const
	Marshal the `TypeCode` `TCKind`.
virtual bool	tao_marshal (TAO_OutputCDR &cdr, CORBA::ULong offset) const =0
	Marshal this `TypeCode` into a CDR output stream.
virtual void	tao_duplicate (void)=0
	Increase the reference count on this `TypeCode`.
virtual void	tao_release (void)=0
	Decrease the reference count on this object.
@c CORBA::TypeCode Methods
These methods are part of the public interface of `CORBA::TypeCode` class, as defined by the OMG CORBA specification and C++ mapping. The C++ mapping does not declare the methods in the public `CORBA::TypeCode` API as `virtual`, so work around that by making these methods inlined to forward all calls to the corresponding protected template method (i.e. the design pattern, not the C++ feature) listed below in the `protected` block.
Boolean	equal (TypeCode_ptr tc) const
	Equality of two `TypeCodes`.
Boolean	equivalent (TypeCode_ptr tc) const
	Equivalence of two `TypeCodes`.
TCKind	kind (void) const
	The kind of `TypeCode`.
TypeCode_ptr	get_compact_typecode (void) const
char const *	id (void) const
	The `RepositoryId` globally identifying the type.
char const *	name (void) const
ULong	member_count (void) const
	The type member count.
char const *	member_name (ULong index) const
	The type member name.
TypeCode_ptr	member_type (ULong index) const
	The type member `TypeCode`.
Any *	member_label (ULong index) const
	The union member label.
TypeCode_ptr	discriminator_type (void) const
	The type of all non-default union member labels.
Long	default_index (void) const
	The index of the default union member.
ULong	length (void) const
	The length of the type.
TypeCode_ptr	content_type (void) const
	The underlying content type.
UShort	fixed_digits (void) const
	The number of significant digits.
UShort	fixed_scale (void) const
	The scale factor.
Visibility	member_visibility (ULong index) const
ValueModifier	type_modifier (void) const
TypeCode_ptr	concrete_base_type (void) const
Static Public Member Functions
static CORBA::TypeCode_ptr	_duplicate (CORBA::TypeCode_ptr tc)
	Duplicate this `TypeCode`.
static CORBA::TypeCode_ptr	_nil (void)
	Returns a NULL typecode.
static void	_tao_any_destructor (void *x)
	Destruction callback for Anys.
Static Public Attributes
static CORBA::TypeCode_ptr const	_tc_Bounds
static CORBA::TypeCode_ptr const	_tc_BadKind
Protected Member Functions
	TypeCode (CORBA::TCKind kind)
	Constructor.
virtual	~TypeCode (void)
	Destructor.
@c TypeCode Template Methods
Methods that must be implemented by `CORBA::TypeCode` subclasses if valid for those subclasses. The default implementations of the non-pure virtual methods throw the `CORBA::TypeCode::BadKind` exception since many of these methods are `TypeCode` type-specific. This reduces code duplication and bloat. The `TypeCode` `equal()`, `equivalent()`, `kind()` and `get_compact_typecode()` methods are valid for all `TypeCodes` which is why their template method "@c _i" counterparts are pure virtual.
virtual Boolean	equal_i (TypeCode_ptr tc) const =0
virtual Boolean	equivalent_i (TypeCode_ptr tc) const =0
virtual TypeCode_ptr	get_compact_typecode_i (void) const =0
virtual char const *	id_i (void) const
virtual char const *	name_i (void) const
virtual ULong	member_count_i (void) const
virtual char const *	member_name_i (ULong index) const
virtual TypeCode_ptr	member_type_i (ULong index) const
virtual Any *	member_label_i (ULong index) const
virtual TypeCode_ptr	discriminator_type_i (void) const
virtual Long	default_index_i (void) const
virtual ULong	length_i (void) const
virtual TypeCode_ptr	content_type_i (void) const
virtual UShort	fixed_digits_i (void) const
virtual UShort	fixed_scale_i (void) const
virtual Visibility	member_visibility_i (ULong index) const
virtual ValueModifier	type_modifier_i (void) const
virtual TypeCode_ptr	concrete_base_type_i (void) const
Protected Attributes
TCKind const	kind_
	The kind of TypeCode.
Private Member Functions
	TypeCode (TypeCode const &)
void	operator= (TypeCode const &)

Detailed Description

A representation of the structure of a given OMG IDL-declared type.

TypeCodes are primarily used by CORBA::Anys, the CORBA Interface Repository and the CORBA Dynamic Invocation Interface.

Definition at line 62 of file TypeCode.h.

Member Typedef Documentation

typedef CORBA::TypeCode_out CORBA::TypeCode::_out_type

Definition at line 431 of file TypeCode.h.

typedef CORBA::TypeCode_ptr CORBA::TypeCode::_ptr_type

Definition at line 429 of file TypeCode.h.

typedef CORBA::TypeCode_var CORBA::TypeCode::_var_type

Definition at line 430 of file TypeCode.h.

Constructor & Destructor Documentation

CORBA::TypeCode::TypeCode ( CORBA::TCKind kind ) [protected]

Constructor.

Definition at line 23 of file TypeCode.inl.

  : kind_ (k)
{
}

CORBA::TypeCode::~TypeCode ( void ) [protected, virtual]

Destructor.

Protected destructor to enforce proper memory management through the reference counting mechanism.

Definition at line 23 of file TypeCode.cpp.

{
}

CORBA::TypeCode::TypeCode ( TypeCode const & ) [private]

Member Function Documentation

CORBA::TypeCode_ptr CORBA::TypeCode::_duplicate ( CORBA::TypeCode_ptr tc ) [static]

Duplicate this TypeCode.

Statically instantiated TypeCodes incur no reference count manipulation, i.e. reference counting is a no-op.

Dynamically instantiated TypeCodes will have their reference count incremented by one each time this function is called.

Definition at line 29 of file TypeCode.inl.

{
  if (!CORBA::is_nil (tc))
    tc->tao_duplicate ();

  return tc;
}

CORBA::TypeCode_ptr CORBA::TypeCode::_nil ( void ) [static]

Returns a NULL typecode.

Definition at line 38 of file TypeCode.inl.

{
  return static_cast<CORBA::TypeCode_ptr> (0);
}

void CORBA::TypeCode::_tao_any_destructor ( void * x ) [static]

Destruction callback for Anys.

Definition at line 146 of file TypeCode.inl.

{
  ::CORBA::release (static_cast <CORBA::TypeCode_ptr> (x));
}

CORBA::TypeCode_ptr CORBA::TypeCode::concrete_base_type ( void ) const

The TypeCode corresponding to the concrete base valuetype or eventtype. This method is valid for the following kinds of TypeCodes:

tk_value
tk_event

Returns:: TypeCode corresponding to the concrete base valuetype or eventtype. CORBA::TypeCode::_nil() if no concrete base exists.

Definition at line 140 of file TypeCode.inl.

{
  return this->concrete_base_type_i ();
}

CORBA::TypeCode_ptr CORBA::TypeCode::concrete_base_type_i ( void ) const [protected, virtual]

Reimplemented in TAO::TypeCode::Value< StringType, TypeCodeType, FieldArrayType, RefCountPolicy >, TAO::TypeCode::Value< char const *, CORBA::TypeCode_ptr const *, Value_Field< char const *, CORBA::TypeCode_ptr const * > const *, TAO::Null_RefCount_Policy >, and TAO::TypeCodeFactory::Recursive_TypeCode.

Definition at line 215 of file TypeCode.cpp.

{
  throw ::CORBA::TypeCode::BadKind ();
}

CORBA::TypeCode_ptr CORBA::TypeCode::content_type ( void ) const

The underlying content type.

This method is valid for the following kinds of TypeCodes:

tk_sequence
tk_array
tk_value_box
tk_alias

Definition at line 110 of file TypeCode.inl.

{
  return this->content_type_i ();
}

CORBA::TypeCode_ptr CORBA::TypeCode::content_type_i ( void ) const [protected, virtual]

Reimplemented in TAO::TypeCode::Alias< StringType, TypeCodeType, RefCountPolicy >, TAO::TypeCode::Alias< char const *, CORBA::TypeCode_ptr const *, TAO::Null_RefCount_Policy >, TAO::TypeCode::Sequence< TypeCodeType, RefCountPolicy >, and TAO::TypeCode::Sequence< CORBA::TypeCode_ptr const *, TAO::Null_RefCount_Policy >.

Definition at line 185 of file TypeCode.cpp.

{
  throw ::CORBA::TypeCode::BadKind ();
}

CORBA::Long CORBA::TypeCode::default_index ( void ) const

The index of the default union member.

This method is valid for the following kinds of TypeCodes:

tk_union

Definition at line 98 of file TypeCode.inl.

{
  return this->default_index_i ();
}

CORBA::Long CORBA::TypeCode::default_index_i ( void ) const [protected, virtual]

Reimplemented in TAO::TypeCode::Union< StringType, TypeCodeType, CaseArrayType, RefCountPolicy >, TAO::TypeCode::Union< char const *, CORBA::TypeCode_ptr const *, Case< char const *, CORBA::TypeCode_ptr const * > const *const *, TAO::Null_RefCount_Policy >, and TAO::TypeCodeFactory::Recursive_TypeCode.

Definition at line 173 of file TypeCode.cpp.

{
  throw ::CORBA::TypeCode::BadKind ();
}

CORBA::TypeCode_ptr CORBA::TypeCode::discriminator_type ( void ) const

The type of all non-default union member labels.

This method is valid for the following kinds of TypeCodes:

tk_union

Definition at line 92 of file TypeCode.inl.

{
  return this->discriminator_type_i ();
}

CORBA::TypeCode_ptr CORBA::TypeCode::discriminator_type_i ( void ) const [protected, virtual]

Reimplemented in TAO::TypeCode::Union< StringType, TypeCodeType, CaseArrayType, RefCountPolicy >, TAO::TypeCode::Union< char const *, CORBA::TypeCode_ptr const *, Case< char const *, CORBA::TypeCode_ptr const * > const *const *, TAO::Null_RefCount_Policy >, and TAO::TypeCodeFactory::Recursive_TypeCode.

Definition at line 167 of file TypeCode.cpp.

{
  throw ::CORBA::TypeCode::BadKind ();
}

CORBA::Boolean CORBA::TypeCode::equal ( TypeCode_ptr tc ) const

Equality of two TypeCodes.

Returns:: true if and only if the set of legal operations is the same and invoking any operation on the this TypeCode and tc returns identical results.

Definition at line 34 of file TypeCode.cpp.

{
  if (this == tc)
    {
      return true;
    }
  else if (CORBA::is_nil (tc))
    {
      throw ::CORBA::BAD_PARAM (CORBA::OMGVMCID | 13, CORBA::COMPLETED_NO);
    }

  CORBA::TCKind const tc_kind = tc->kind ();

  if (tc_kind != this->kind_)
    return false;

  try
    {
      char const * const tc_id = tc->id ();

      char const * const this_id = this->id ();

      if (ACE_OS::strcmp (this_id, tc_id) != 0)
        return false;

      char const * const tc_name = tc->name ();

      char const * const this_name = this->name ();

      if (ACE_OS::strcmp (this_name, tc_name) != 0)
        return false;
    }
  catch (const ::CORBA::TypeCode::BadKind&)
    {
      // Some TypeCodes do not support the id() and name()
      // operations.  Ignore the failure, and continue equality
      // verification using TypeCode subclass-specific techniques
      // below.
    }

  return this->equal_i (tc);
}

virtual Boolean CORBA::TypeCode::equal_i ( TypeCode_ptr tc ) const [protected, pure virtual]

CORBA::Boolean CORBA::TypeCode::equivalent ( TypeCode_ptr tc ) const

Equivalence of two TypeCodes.

Equivalence of two TypeCodes satisfies a subset of the requirements necessary for equality.

See also:: equal

Definition at line 78 of file TypeCode.cpp.

{
  if (this == tc)
    {
      return true;
    }
  else if (CORBA::is_nil (tc))
    {
      throw ::CORBA::BAD_PARAM (CORBA::OMGVMCID | 13, CORBA::COMPLETED_NO);
    }

  CORBA::TypeCode_ptr const mutable_this =
    const_cast<CORBA::TypeCode_ptr> (this);

  CORBA::TypeCode_var unaliased_this = TAO::unaliased_typecode (mutable_this);

  CORBA::TypeCode_var unaliased_tc = TAO::unaliased_typecode (tc);

  CORBA::TCKind const this_kind = unaliased_this->kind ();

  CORBA::TCKind const tc_kind = unaliased_tc->kind ();

  if (tc_kind != this_kind)
    return false;

  try
    {
      char const * const this_id = unaliased_this->id ();

      char const * const tc_id = unaliased_tc->id ();

      if (ACE_OS::strlen (this_id) == 0
          || ACE_OS::strlen (tc_id) == 0)
        {
          return unaliased_this->equivalent_i (unaliased_tc.in ());
        }
      else if (ACE_OS::strcmp (this_id, tc_id) != 0)
        {
          return false;
        }
    }
  catch (const ::CORBA::TypeCode::BadKind&)
    {
      // Some TypeCodes do not support the id() operation.  Ignore the
      // failure, and continue equivalence verification using TypeCode
      // subclass-specific techniques.
      return unaliased_this->equivalent_i (unaliased_tc.in ());
    }

  return true;
}

virtual Boolean CORBA::TypeCode::equivalent_i ( TypeCode_ptr tc ) const [protected, pure virtual]

CORBA::UShort CORBA::TypeCode::fixed_digits ( void ) const

The number of significant digits.

This method is valid for the following kinds of TypeCodes:

tk_fixed

Definition at line 116 of file TypeCode.inl.

{
  return this->fixed_digits_i ();
}

CORBA::UShort CORBA::TypeCode::fixed_digits_i ( void ) const [protected, virtual]

Reimplemented in TAO::TypeCode::Fixed< RefCountPolicy >.

Definition at line 191 of file TypeCode.cpp.

{
  throw ::CORBA::TypeCode::BadKind ();
}

CORBA::UShort CORBA::TypeCode::fixed_scale ( void ) const

The scale factor.

This method is valid for the following kinds of TypeCodes:

tk_fixed

Definition at line 122 of file TypeCode.inl.

{
  return this->fixed_scale_i ();
}

CORBA::UShort CORBA::TypeCode::fixed_scale_i ( void ) const [protected, virtual]

Reimplemented in TAO::TypeCode::Fixed< RefCountPolicy >.

Definition at line 197 of file TypeCode.cpp.

{
  throw ::CORBA::TypeCode::BadKind ();
}

CORBA::TypeCode_ptr CORBA::TypeCode::get_compact_typecode ( void ) const

Return TypeCode stripped of optional name and member_name fields.

Note:: Calling this method will incur additional run-time memory consumption since TAO's implementation relies on the TypeCodeFactory to dynamically create a compact TypeCode; the exception being TypeCodes with empty parameter lists. Those TypeCodes are already compact, meaning that call this method on such TypeCodes incurs no additional run-time memory requirements.

Unless you need to send compact TypeCodes "over-the-wire" or your TypeCode corresponds to a type with a large number of members, try to stick with the existing potentially non-compact TypeCode.

Note:: Compact TypeCodes may also be generated statically by the TAO_IDL compiler by invoking it with its "-Gt" (i.e. enable optimized TypeCodes) command line option.

Definition at line 50 of file TypeCode.inl.

{
  return this->get_compact_typecode_i ();
}

virtual TypeCode_ptr CORBA::TypeCode::get_compact_typecode_i ( void ) const [protected, pure virtual]

char const * CORBA::TypeCode::id ( void ) const

The RepositoryId globally identifying the type.

This method is valid for the following kinds of TypeCodes:

tk_objref
tk_struct
tk_union
tk_enum
tk_alias
tk_value
tk_value_box
tk_native
tk_abstract_interface
tk_local_interface
tk_except
tk_component
tk_home
tk_event

Note:: CORBA::TypeCode::id() does not follow the usual parameter passing rules defined by the C++ mapping. This behavior is required by the C++ mapping. In particular, ownership is maintained by the TypeCode.

Definition at line 56 of file TypeCode.inl.

{
  return this->id_i ();
}

char const * CORBA::TypeCode::id_i ( void ) const [protected, virtual]

Definition at line 131 of file TypeCode.cpp.

{
  throw ::CORBA::TypeCode::BadKind ();
}

CORBA::TCKind CORBA::TypeCode::kind ( void ) const

The kind of TypeCode.

Definition at line 44 of file TypeCode.inl.

{
  return this->kind_;
}

CORBA::ULong CORBA::TypeCode::length ( void ) const

The length of the type.

This method is valid for the following kinds of TypeCodes:

tk_string
tk_wstring
tk_sequence
tk_array

Definition at line 104 of file TypeCode.inl.

{
  return this->length_i ();
}

CORBA::ULong CORBA::TypeCode::length_i ( void ) const [protected, virtual]

Reimplemented in TAO::TypeCode::Sequence< TypeCodeType, RefCountPolicy >, TAO::TypeCode::Sequence< CORBA::TypeCode_ptr const *, TAO::Null_RefCount_Policy >, TAO::TypeCode::String< RefCountPolicy >, and TAO::TypeCode::String< TAO::Null_RefCount_Policy >.

Definition at line 179 of file TypeCode.cpp.

{
  throw ::CORBA::TypeCode::BadKind ();
}

CORBA::ULong CORBA::TypeCode::member_count ( void ) const

The type member count.

This method is valid for the following kinds of TypeCodes:

tk_struct
tk_union
tk_enum
tk_value
tk_except
tk_event

Definition at line 68 of file TypeCode.inl.

{
  return this->member_count_i ();
}

CORBA::ULong CORBA::TypeCode::member_count_i ( void ) const [protected, virtual]

Reimplemented in TAO::TypeCode::Enum< StringType, EnumeratorArrayType, RefCountPolicy >, TAO::TypeCode::Enum< char const *, char const *const *, TAO::Null_RefCount_Policy >, TAO::TypeCode::Struct< StringType, TypeCodeType, FieldArrayType, RefCountPolicy >, TAO::TypeCode::Struct< char const *, CORBA::TypeCode_ptr const *, Struct_Field< char const *, CORBA::TypeCode_ptr const * > const *, TAO::Null_RefCount_Policy >, TAO::TypeCode::Union< StringType, TypeCodeType, CaseArrayType, RefCountPolicy >, TAO::TypeCode::Union< char const *, CORBA::TypeCode_ptr const *, Case< char const *, CORBA::TypeCode_ptr const * > const *const *, TAO::Null_RefCount_Policy >, TAO::TypeCode::Value< StringType, TypeCodeType, FieldArrayType, RefCountPolicy >, TAO::TypeCode::Value< char const *, CORBA::TypeCode_ptr const *, Value_Field< char const *, CORBA::TypeCode_ptr const * > const *, TAO::Null_RefCount_Policy >, and TAO::TypeCodeFactory::Recursive_TypeCode.

Definition at line 143 of file TypeCode.cpp.

{
  throw ::CORBA::TypeCode::BadKind ();
}

CORBA::Any * CORBA::TypeCode::member_label ( ULong index ) const

The union member label.

This method is valid for the following kinds of TypeCodes:

tk_union

Definition at line 86 of file TypeCode.inl.

{
  return this->member_label_i (index);
}

CORBA::Any * CORBA::TypeCode::member_label_i ( CORBA::ULong index ) const [protected, virtual]

Reimplemented in TAO::TypeCode::Union< StringType, TypeCodeType, CaseArrayType, RefCountPolicy >, TAO::TypeCode::Union< char const *, CORBA::TypeCode_ptr const *, Case< char const *, CORBA::TypeCode_ptr const * > const *const *, TAO::Null_RefCount_Policy >, and TAO::TypeCodeFactory::Recursive_TypeCode.

Definition at line 161 of file TypeCode.cpp.

{
  throw ::CORBA::TypeCode::BadKind ();
}

char const * CORBA::TypeCode::member_name ( ULong index ) const

The type member name.

This method is valid for the following kinds of TypeCodes:

tk_struct
tk_union
tk_enum
tk_value
tk_except
tk_event

Note:: CORBA::TypeCode::member_name() does not follow the usual parameter passing rules defined by the C++ mapping. This behavior is required by the C++ mapping. In particular, ownership is maintained by the TypeCode.

Definition at line 74 of file TypeCode.inl.

{
  return this->member_name_i (index);
}

char const * CORBA::TypeCode::member_name_i ( CORBA::ULong index ) const [protected, virtual]

Reimplemented in TAO::TypeCode::Enum< StringType, EnumeratorArrayType, RefCountPolicy >, TAO::TypeCode::Enum< char const *, char const *const *, TAO::Null_RefCount_Policy >, TAO::TypeCode::Struct< StringType, TypeCodeType, FieldArrayType, RefCountPolicy >, TAO::TypeCode::Struct< char const *, CORBA::TypeCode_ptr const *, Struct_Field< char const *, CORBA::TypeCode_ptr const * > const *, TAO::Null_RefCount_Policy >, TAO::TypeCode::Union< StringType, TypeCodeType, CaseArrayType, RefCountPolicy >, TAO::TypeCode::Union< char const *, CORBA::TypeCode_ptr const *, Case< char const *, CORBA::TypeCode_ptr const * > const *const *, TAO::Null_RefCount_Policy >, TAO::TypeCode::Value< StringType, TypeCodeType, FieldArrayType, RefCountPolicy >, TAO::TypeCode::Value< char const *, CORBA::TypeCode_ptr const *, Value_Field< char const *, CORBA::TypeCode_ptr const * > const *, TAO::Null_RefCount_Policy >, and TAO::TypeCodeFactory::Recursive_TypeCode.

Definition at line 149 of file TypeCode.cpp.

{
  throw ::CORBA::TypeCode::BadKind ();
}

CORBA::TypeCode_ptr CORBA::TypeCode::member_type ( ULong index ) const

The type member TypeCode.

This method is valid for the following kinds of TypeCodes:

tk_struct
tk_union
tk_value
tk_except
tk_event

Definition at line 80 of file TypeCode.inl.

{
  return this->member_type_i (index);
}

CORBA::TypeCode_ptr CORBA::TypeCode::member_type_i ( CORBA::ULong index ) const [protected, virtual]

Reimplemented in TAO::TypeCode::Struct< StringType, TypeCodeType, FieldArrayType, RefCountPolicy >, TAO::TypeCode::Struct< char const *, CORBA::TypeCode_ptr const *, Struct_Field< char const *, CORBA::TypeCode_ptr const * > const *, TAO::Null_RefCount_Policy >, TAO::TypeCode::Union< StringType, TypeCodeType, CaseArrayType, RefCountPolicy >, TAO::TypeCode::Union< char const *, CORBA::TypeCode_ptr const *, Case< char const *, CORBA::TypeCode_ptr const * > const *const *, TAO::Null_RefCount_Policy >, TAO::TypeCode::Value< StringType, TypeCodeType, FieldArrayType, RefCountPolicy >, TAO::TypeCode::Value< char const *, CORBA::TypeCode_ptr const *, Value_Field< char const *, CORBA::TypeCode_ptr const * > const *, TAO::Null_RefCount_Policy >, and TAO::TypeCodeFactory::Recursive_TypeCode.

Definition at line 155 of file TypeCode.cpp.

{
  throw ::CORBA::TypeCode::BadKind ();
}

CORBA::Visibility CORBA::TypeCode::member_visibility ( ULong index ) const

The Visibility of the valuetype or eventtype member corresponding to index index. This method is valid for the following kinds of TypeCodes:

tk_value
tk_event

Definition at line 128 of file TypeCode.inl.

{
  return this->member_visibility_i (index);
}

CORBA::Visibility CORBA::TypeCode::member_visibility_i ( CORBA::ULong index ) const [protected, virtual]

Reimplemented in TAO::TypeCode::Value< StringType, TypeCodeType, FieldArrayType, RefCountPolicy >, TAO::TypeCode::Value< char const *, CORBA::TypeCode_ptr const *, Value_Field< char const *, CORBA::TypeCode_ptr const * > const *, TAO::Null_RefCount_Policy >, and TAO::TypeCodeFactory::Recursive_TypeCode.

Definition at line 203 of file TypeCode.cpp.

{
  throw ::CORBA::TypeCode::BadKind ();
}

char const * CORBA::TypeCode::name ( void ) const

The simple name identifying the type within its enclosing scope. This method is valid for the following kinds of TypeCodes:

tk_objref
tk_struct
tk_union
tk_enum
tk_alias
tk_value
tk_value_box
tk_native
tk_abstract_interface
tk_local_interface
tk_except
tk_component
tk_home
tk_event

Note:: CORBA::TypeCode::name() does not follow the usual parameter passing rules defined by the C++ mapping. This behavior is required by the C++ mapping. In particular, ownership is maintained by the TypeCode.

Definition at line 62 of file TypeCode.inl.

{
  return this->name_i ();
}

char const * CORBA::TypeCode::name_i ( void ) const [protected, virtual]

Definition at line 137 of file TypeCode.cpp.

{
  throw ::CORBA::TypeCode::BadKind ();
}

void CORBA::TypeCode::operator= ( TypeCode const & ) [private]

virtual void CORBA::TypeCode::tao_duplicate ( void ) [pure virtual]

Increase the reference count on this TypeCode.

virtual bool CORBA::TypeCode::tao_marshal	(	TAO_OutputCDR &	cdr,
		CORBA::ULong	offset
	)			const `[pure virtual]`

Marshal this TypeCode into a CDR output stream.

Marshal this TypeCode into the cdr output CDR stream, excluding the TypeCode kind. Existing cdr contents will not be altered. The marshaled TypeCode will be appended to the given cdr CDR output stream.

Parameters:

	cdr	Output CDR stream into which the `TypeCode` will be marshaled.
	offset	Number of bytes currently in the output CDR stream, including the top-level TypeCode `TCKind`. This argument is useful for recursive `TypeCodes`. `TypeCodes` that contain other `TypeCodes` should pass an updated offset value to the marshaling operation for those contained `TypeCodes`.

Returns:: true if marshaling was successful.

Note:: This is a TAO-specific method that is not part of the standard CORBA::TypeCode interface.; If this method returns false, the contents of the cdr output CDR stream are undefined.

bool CORBA::TypeCode::tao_marshal_kind ( TAO_OutputCDR & cdr ) const [virtual]

Marshal the TypeCode TCKind.

Reimplemented in TAO::TypeCodeFactory::Recursive_TypeCode.

Definition at line 28 of file TypeCode.cpp.

{
  return cdr << this->kind_;
}

virtual void CORBA::TypeCode::tao_release ( void ) [pure virtual]

Decrease the reference count on this object.

CORBA::ValueModifier CORBA::TypeCode::type_modifier ( void ) const

The ValueModifier of the valuetype of eventtype represented by this TypeCode. This method is valid for the following kinds of TypeCodes:

tk_value
tk_event

Definition at line 134 of file TypeCode.inl.

{
  return this->type_modifier_i ();
}

CORBA::ValueModifier CORBA::TypeCode::type_modifier_i ( void ) const [protected, virtual]

Reimplemented in TAO::TypeCode::Value< StringType, TypeCodeType, FieldArrayType, RefCountPolicy >, TAO::TypeCode::Value< char const *, CORBA::TypeCode_ptr const *, Value_Field< char const *, CORBA::TypeCode_ptr const * > const *, TAO::Null_RefCount_Policy >, and TAO::TypeCodeFactory::Recursive_TypeCode.

Definition at line 209 of file TypeCode.cpp.

{
  throw ::CORBA::TypeCode::BadKind ();
}

Member Data Documentation

CORBA::TypeCode_ptr const CORBA::TypeCode::_tc_BadKind [static]

Initial value:

  &TAO::TypeCode::tc_BadKind

Definition at line 120 of file TypeCode.h.

CORBA::TypeCode_ptr const CORBA::TypeCode::_tc_Bounds [static]

Initial value:

  &TAO::TypeCode::tc_Bounds

Definition at line 119 of file TypeCode.h.

TCKind const CORBA::TypeCode::kind_ [protected]

The kind of TypeCode.

Definition at line 492 of file TypeCode.h.

The documentation for this class was generated from the following files:

CORBA::TypeCode Class Reference

Classes

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Protected Attributes

Private Member Functions

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation