Contents

17.1 The IDL Type TypeCode

17.2 Implementation of TypeCode in OrbixWeb

17.2.1 The TypeCode.IT_create() Method

17.3 Use of TypeCode

17.3.1 Use of TypeCode in Type any

17.3.2 Use of TypeCode when Interrogating the Interface Repository

TypeCode is used for many purposes in the system:

• As a component of an object of type Any (defined in package IE.Iona.Orbix2.CORBA). This is covered in detail later in this chapter.
  
• As a parameter to some of the operations of the Interface Repository, as explained later in this chapter.
  

 #include <orb.idl>

In an IDL specification, a TypeCode can be used as an attribute type, or as the type of a parameter or return value to an operation. The IDL TypeCode interface is implemented by the Java class TypeCode (defined in package IE.Iona.Orbix2.CORBA).

The class TypeCode is particularly useful when querying the type of an instance of Any. The class Any has a public member variable, type, of type TypeCode. This variable can be queried at runtime to determine the type of the Any.

17.1 The IDL Type TypeCode

Each TypeCode consists of a kind and a sequence of parameters. The kind specifies the overall classification of the TypeCode: for example, whether it is a basic type, a struct, a sequence, and so on. The parameters give the details of the type definition. For example, the IDL type sequence<long,20> has the kind tk_sequence and has two parameters–the first parameter is a TypeCode for long, the second parameter is 20.

The IDL interface for TypeCode is defined as follows:

 // IDL
 // in module CORBA
 enum TCKind {
 	tk_null, tk_void,
 	tk_short, tk_long, tk_ushort, tk_ulong,
 	tk_float, tk_double, tk_boolean, tk_char,
 	tk_octet, tk_any, tk_TypeCode, tk_Principal,
 	tk_objref, tk_struct, tk_union, tk_enum,
 	tk_string, tk_sequence, tk_array
 };
 
 exception Bounds {};
 pseudo interface TypeCode {
 	TCKind kind();
 	long param_count();
 	any parameter(in long index) raises(Bounds);
 	boolean equal(in TypeCode tc);
 };

 // Java
 // in package IE.Iona.Orbix2.CORBA,
 // in class TypeCode
 public int kind();
 public Any parameter(int index) throws Bounds;

The number of parameters which a TypeCode has varies with the kind of the TypeCode. This number is returned by the param_count() operation of the TypeCode interface. The generated signature of this operation is as follows:

 // Java
 // in package IE.Iona.Orbix2.CORBA,
 // in class TypeCode
 public int param_count();

• A TypeCode of kind tk_struct has one parameter giving the struct name, and then two parameters for each member of the struct: the first giving the member's name and the second giving its TypeCode. A struct with N members has 2N+1 parameters.
  
• A TypeCode of kind tk_string has one parameter–an integer giving the maximum length of the string. A 0 length indicates an unbounded string.
  

The IDL compiler can generate constant declarations for TypeCode pseudo object references from named type definitions that appear in an IDL file–that is from the following types:

 typedef
 struct
 union
 enum

 struct Useful {
 	long l;
 };

 Useful._tc_Useful

In addition, a number of predefined TypeCode pseudo object reference constants are always available to allow the user to access TypeCodes for standard types. These are exhaustively listed in Part II, "Class and Interface Reference" of the OrbixWeb Reference Guide, under the entry for TypeCode.

Each constant is defined in the Java class _CORBA (in package IE.Iona.Orbix2), and is named after the convention _tc_<type>. For example:

_CORBA._tc_float is an object reference for a float TypeCode.

_CORBA._tc_string is an object reference for a string TypeCode.

_CORBA._tc_TypeCode is an object reference for a TypeCode TypeCode.

• Constructors:
  

   public TypeCode();
   public TypeCode(TypeCode tc);
   public TypeCode(String tc_info);
  

• A copy() method.
  
• Method equals() which allows comparisons of objects of type TypeCode.
  
• A _tc_string member variable which holds the object reference string for the TypeCode, and a toString() method which returns the value of this variable.
  
• Method kind() which returns an int value from the constants defined in type TCKind.
  
• Method param_count() which returns the number of parameters of the TypeCode.
  
• Method parameter() which returns an individual parameter. This takes the parameter index as an argument.
  

 // Java
 // in package IE.Iona.Orbix2.CORBA,
 // in class TypeCode
 public static TypeCode IT_create();
 public static TypeCode IT_create(TypeCode tc);
 public static TypeCode IT_create(String tc_info);
 public static TypeCode _nil();

17.3 Use of TypeCode

17.3.1 Use of TypeCode in Type any

 // IDL
 struct Example {
 	long l;
 };

 // IDL
 interface Test {
 	void op(in any a);
 };
 
 // Java
 // in file Client.java
 import IE.Iona.Orbix2.CORBA.SystemException;
 import IE.Iona.Orbix2.CORBA.Any;
 
 public class Client {
 	public static void main (String args[]) {
 		_TestRef tRef;
 		Any a;
 
 		try {
 			tRef = Test._bind ();
 
 			// We shall see how to initialise 'a' in 
 			// a later section.
 			tRef.op (a);
 		}
 		catch (SystemException se){
 			...
 		}
 	}
 }

 // Java
 // in file Client.java,
 // in class Client
 
 IE.Iona.Orbix2.CORBA.TypeCode t (a.type());
 
 if(t.equals(Test._tc_Example)) {
 	...
 }

Use of TypeCode in type Any is explained fully in Chapter 18, "Type any".

17.3.2 Use of TypeCode when Interrogating the Interface Repository