public abstract class TypeCode extends Object implements IDLEntity
 TypeCode objects are used:
 
NamedValue objects are used to represent arguments and
 return values.  One of their components is an Any
 object, which in turn has as one of its components a
 TypeCode object.
 
 The representation of a TypeCode object is opaque,
 but abstractly, a TypeCode object consists of:
 
kind field, which is set to an instance
 of the class TCKind
 TypeCode object
 describing the OMG IDL type 1ong has kind
 TCKind.tk_long and no additional fields.
 The TypeCode describing OMG IDL type
 sequence<boolean, 10> has a kind field
 with the value
 TCKind.tk_sequence and also fields with the values
 boolean and 10 for the
 type of sequence elements and the length of the sequence. 
TypeCode objects can be obtained in various ways:
 Any.insert_X, where X is
 a basic IDL type.  This method creates a TypeCode object
 for type X and assigns it to the Any object's
 type field.
 For example, the following creates a TypeCode
 object for a string with a maximum of 30 characters:
 
org.omg.CORBA.TypeCode tcString = orb.create_string_tc(30);
 The following creates a TypeCode
 object for an array of five strings:
 
   org.omg.CORBA.TypeCode tcArray = orb.create_array_tc(
                                       5, TCKind.tk_string);
 
  The following creates a TypeCode
 object for an interface named "Account":
 
   org.omg.CORBA.TypeCode tcInterface = orb.create_interface_tc(
                                                 "thisId", "Account");
 
 _type method
 in Holder classes for user-defined
 IDL types.  These Holder classes are generated
 by the idltojava compiler.
 
 Most of the methods in the class TypeCode
 are accessors, and the information contained in a TypeCode
 object is specific to a particular type.  Therefore, methods
 must be invoked
 only on the kind of type codes to which they apply.  If an
 accessor method
 tries to access information from an inappropriate kind of
 type code, it will throw
 the exception TypeCodePackage.BadKind.  For example,
 if the method discriminator_type is called on anything
 other than a union, it will throw BadKind
 because only unions have a discriminator.
 The following list shows which methods apply to which kinds of
 type codes:
 
 These methods may be invoked on all TypeCode kinds:
 
equal
 kind
 
 These methods may be invoked on objref, struct,
 union, enum,
 alias, exception, value,
 value_box, native,
 and abstract_interface:
 
id
 name
 
 These methods may be invoked on struct,
 union, enum,
 and exception:
 
member_count
 member_name
 
 These methods may be invoked on struct,
 union, and exception:
 
member_type(int index)
 
 These methods may be invoked on union:
 
member_label
 discriminator_type
 default_index
 
 These methods may be invoked on string,
 sequence, and array:
 
length
 
 These methods may be invoked on alias,
 sequence, array, and value_box:
 
content_type
 
 Unlike other CORBA pseudo-objects, TypeCode
 objects can be passed as general IDL parameters. 
 The methods parameter and param_count,
 which are deprecated, are not mapped.  
 Java IDL extends the CORBA specification to allow all operations permitted
 on a struct TypeCode to be permitted
 on an exception TypeCode as well. 
| Constructor and Description | 
|---|
| TypeCode() | 
| Modifier and Type | Method and Description | 
|---|---|
| abstract TypeCode | concrete_base_type()Returns the  TypeCodeobject that describes the concrete base type
 of the value type that thisTypeCodeobject describes. | 
| abstract TypeCode | content_type()Returns the  TypeCodeobject representing the
 IDL type for the members of the object described by thisTypeCodeobject. | 
| abstract int | default_index()Returns the index of the
 default member, or -1 if there is no default member. | 
| abstract TypeCode | discriminator_type()Returns a  TypeCodeobject describing
 all non-default member labels. | 
| abstract boolean | equal(TypeCode tc)Compares this  TypeCodeobject with the given one,
 testing for equality. | 
| abstract boolean | equivalent(TypeCode tc)Tests to see if the given  TypeCodeobject is
 equivalent to thisTypeCodeobject. | 
| abstract short | fixed_digits()Returns the number of digits in the fixed type described by this
  TypeCodeobject. | 
| abstract short | fixed_scale()Returns the scale of the fixed type described by this
  TypeCodeobject. | 
| abstract TypeCode | get_compact_typecode()Strips out all optional name and member name fields,
 but leaves all alias typecodes intact. | 
| abstract String | id()Retrieves the RepositoryId globally identifying the type
 of this  TypeCodeobject. | 
| abstract TCKind | kind()Retrieves the kind of this  TypeCodeobject. | 
| abstract int | length()Returns the number of elements in the type described by
 this  TypeCodeobject. | 
| abstract int | member_count()Retrieves the number of members in the type described by
 this  TypeCodeobject. | 
| abstract Any | member_label(int index)Retrieves the label of the union member
 identified by the given index. | 
| abstract String | member_name(int index)Retrieves the simple name of the member identified by
 the given index. | 
| abstract TypeCode | member_type(int index)Retrieves the  TypeCodeobject describing the type
 of the member identified by the given index. | 
| abstract short | member_visibility(int index)Returns the constant that indicates the visibility of the member
 at the given index. | 
| abstract String | name()Retrieves the simple name identifying this  TypeCodeobject within its
 enclosing scope. | 
| abstract short | type_modifier()Returns a constant indicating the modifier of the value type
 that this  TypeCodeobject describes. | 
public abstract boolean equal(TypeCode tc)
TypeCode object with the given one,
 testing for equality. TypeCode objects are equal if
 they are interchangeable and give identical results when
 TypeCode operations are applied to them.tc - the TypeCode object to compare againsttrue if the type codes are equal;
                false otherwisepublic abstract boolean equivalent(TypeCode tc)
TypeCode object is
 equivalent to this TypeCode object.
 tc - the typecode to compare with this typecodetrue if the given typecode is equivalent to
         this typecode; false otherwisepublic abstract TypeCode get_compact_typecode()
TypeCode object with optional name and
         member name fields stripped out, except for alias typecodes,
         which are left intactCORBA package
      comments for unimplemented featurespublic abstract TCKind kind()
TypeCode object.
 The kind of a type code determines which TypeCode
 methods may legally be invoked on it.
 
 The method kind may be invoked on any
 TypeCode object.
TCKind instance indicating the
            value of the kind field of this
                  TypeCode objectpublic abstract String id() throws BadKind
TypeCode object.
 
 The method id can be invoked on object reference,
 structure, union, enumeration, alias, exception, valuetype,
 boxed valuetype, native, and abstract interface type codes.
 Object reference, exception, valuetype, boxed valuetype,
 native, and abstract interface TypeCode objects
 always have a RepositoryId.
 Structure, union, enumeration, and alias TypeCode objects
 obtained from the Interface Repository or the method
 ORB.create_operation_list
 also always have a RepositoryId. If there is no RepositoryId, the
 method can return an empty string.
TypeCode object
                or an empty string if there is no RepositoryIDBadKind - if the method
           is invoked on an inappropriate kind ofTypeCode
           objectpublic abstract String name() throws BadKind
TypeCode
 object within its
 enclosing scope. Since names are local to a Repository, the
 name returned from a TypeCode object
 may not match the name of the
 type in any particular Repository, and may even be an empty
 string.
 
 The method name can be invoked on object reference,
 structure, union, enumeration, alias, exception, valuetype,
 boxed valuetype, native, and abstract interface
 TypeCode objects.
TypeCode object
                or an empty stringBadKind - if the method
           is invoked on an inappropriate kind ofTypeCode
           objectpublic abstract int member_count()
                          throws BadKind
TypeCode object.
 
 The method member_count can be invoked on
 structure, union, and enumeration TypeCode objects.
 Java IDL extends the CORBA specification to allow this method to
 operate on exceptions as well.
TypeCode objectBadKind - if the method
           is invoked on an inappropriate kind of TypeCode
           objectpublic abstract String member_name(int index) throws BadKind, Bounds
TypeCode object
 may not match the name of the member in any particular
 Repository, and may even be an empty string.
 
 The  method member_name can be invoked on structure, union,
 and enumeration TypeCode objects.
 Java IDL extends the CORBA specification to allow this method to
 operate on exceptions as well.
index - index of the member for which a name is being reqestedBounds - if the index is equal
            to or greater than
                  the number of members constituting the typeBadKind - if the method
           is invoked on an inappropriate kind of TypeCode
           objectpublic abstract TypeCode member_type(int index) throws BadKind, Bounds
TypeCode object describing the type
 of the member identified by the given index.
 
 The method member_type can be invoked on structure
 and union TypeCode objects.
 Java IDL extends the CORBA specification to allow this method to
 operate on exceptions as well.
index - index of the member for which type information
                is begin requestedTypeCode object describing the
                member at the given indexBounds - if the index is
                equal to or greater than
                      the number of members constituting the typeBadKind - if the method
           is invoked on an inappropriate kind of TypeCode
           objectpublic abstract Any member_label(int index) throws BadKind, Bounds
 The method member_label can only be invoked on union
 TypeCode objects.
index - index of the union member for which the
                label is being requestedAny object describing the label of
                the requested union member or the zero octet for
                the default memberBounds - if the index is
                equal to or greater than
                      the number of members constituting the unionBadKind - if the method
           is invoked on a non-union TypeCode
           objectpublic abstract TypeCode discriminator_type() throws BadKind
TypeCode object describing
 all non-default member labels.
 The method discriminator_type can be invoked only
 on union TypeCode objects.TypeCode object describing
                the non-default member labelsBadKind - if the method
           is invoked on a non-union TypeCode
           objectpublic abstract int default_index()
                           throws BadKind
 The method default_index can be invoked only on union
 TypeCode objects.
BadKind - if the method
           is invoked on a non-union TypeCode
           objectpublic abstract int length()
                    throws BadKind
TypeCode object.
 For strings and sequences, it returns the
 bound, with zero indicating an unbounded string or sequence.
 For arrays, it returns the number of elements in the array.
 
 The method length can be invoked on string, sequence, and
 array TypeCode objects.
BadKind - if the method
           is invoked on an inappropriate kind of TypeCode
           objectpublic abstract TypeCode content_type() throws BadKind
TypeCode object representing the
 IDL type for the members of the object described by this
 TypeCode object.
 For sequences and arrays, it returns the
 element type. For aliases, it returns the original type. Note
 that multidimensional arrays are represented by nesting
 TypeCode objects, one per dimension.
 For boxed valuetypes, it returns the boxed type.
 The method content_type can be invoked on sequence, array,
 alias, and boxed valuetype TypeCode objects.
TypeCode object representing
            the element type for sequences and arrays, the
          original type for aliases, or the
            boxed type for boxed valuetypes.BadKind - if the method
           is invoked on an inappropriate kind of TypeCode
           objectpublic abstract short fixed_digits()
                            throws BadKind
TypeCode object. For example, the typecode for
 the number 3000.275d could be fixed<7,3>, where
 7 is the precision and 3 is the scale.BadKind - if this method
           is invoked on an inappropriate kind of TypeCode
           objectpublic abstract short fixed_scale()
                           throws BadKind
TypeCode object. A positive number indicates the
 number of digits to the right of the decimal point.
 For example, the number 3000d could have the
 typecode fixed<4,0>, where the first number is
 the precision and the second number is the scale.
 A negative number is also possible and adds zeroes to the
 left of the decimal point.  In this case, fixed<1,-3>,
 could be the typecode for the number 3000d.TypeCode object describesBadKind - if this method
           is invoked on an inappropriate kind of TypeCode
           objectpublic abstract short member_visibility(int index)
                                 throws BadKind,
                                        Bounds
TypeCode objects.index - an int indicating the index into the
               valuePRIVATE_MEMBER.value or
          PUBLIC_MEMBER.valueBadKind - if this method
           is invoked on a non-value type TypeCode
           objectBounds - if the given index is out of boundsCORBA package
      comments for unimplemented featurespublic abstract short type_modifier()
                             throws BadKind
TypeCode object describes.  The constant
 returned must be one of the following: VM_NONE.value,
 VM_ABSTRACT.value, VM_CUSTOM.value,
 or VM_TRUNCATABLE.value,TypeCode object describesBadKind - if this method
           is invoked on a non-value type TypeCode
           objectCORBA package
      comments for unimplemented featurespublic abstract TypeCode concrete_base_type() throws BadKind
TypeCode object that describes the concrete base type
 of the value type that this TypeCode object describes.
 Returns null if it doesn't have a concrete base type.TypeCode object that describes the
 concrete base type of the value type
 that this TypeCode object describesBadKind - if this method
           is invoked on a non-boxed value type TypeCode objectCORBA package
      comments for unimplemented features Submit a bug or feature 
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
 Copyright © 1993, 2017, Oracle and/or its affiliates.  All rights reserved. Use is subject to license terms. Also see the documentation redistribution policy.