1. /*

  2.  * @(#)TypeCodeImpl.java	1.91 03/01/23

  3.  *

  4.  * Copyright 2003 Sun Microsystems, Inc. All rights reserved.

  5.  * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.

  6.  */

  7. 

  8. package com.sun.corba.se.internal.corba;

  9. 

  10. import org.omg.CORBA.*;

  11. import org.omg.CORBA.TypeCodePackage.*;

  12. 

  13. import org.omg.CORBA_2_3.portable.InputStream;

  14. import org.omg.CORBA_2_3.portable.OutputStream;

  15. 

  16. import com.sun.corba.se.internal.core.*;

  17. import com.sun.corba.se.internal.iiop.CDRInputStream;

  18. import com.sun.corba.se.internal.iiop.CDROutputStream;

  19. 

  20. import java.util.HashMap;

  21. import java.util.Map;

  22. import java.util.Iterator;

  23. import java.util.List;

  24. import java.util.Collections;

  25. import java.util.ArrayList;

  26. import java.io.IOException;

  27. import java.io.PrintStream;

  28. import java.io.ByteArrayOutputStream;

  29. import java.math.BigDecimal;

  30. import java.math.BigInteger;

  31. 

  32. class WrapperInputStream extends org.omg.CORBA_2_3.portable.InputStream implements TypeCodeReader

  33. {

  34.     private CDRInputStream stream;

  35.     private Map typeMap = null;

  36.     private int startPos = 0;

  37. 

  38.     public WrapperInputStream(CDRInputStream s) {

  39.         super();

  40.         stream = s;

  41.         startPos = stream.getPosition();

  42.     }

  43. 

  44.     public int read() throws IOException { return stream.read(); }

  45.     public int read(byte b[]) throws IOException { return stream.read(b); }

  46.     public int read(byte b[], int off, int len) throws IOException {

  47. 	return stream.read(b, off, len);

  48.     }

  49.     public long skip(long n) throws IOException { return stream.skip(n); }

  50.     public int available() throws IOException { return stream.available(); }

  51.     public void close() throws IOException { stream.close(); }

  52.     public void mark(int readlimit) { stream.mark(readlimit); }

  53.     public void reset() { stream.reset(); }

  54.     public boolean markSupported() { return stream.markSupported(); }

  55.     public int getPosition() { return stream.getPosition(); }

  56.     public void consumeEndian() { stream.consumeEndian(); }

  57.     public boolean read_boolean() { return stream.read_boolean(); }

  58.     public char read_char() { return stream.read_char(); }

  59.     public char read_wchar() { return stream.read_wchar(); }

  60.     public byte read_octet() { return stream.read_octet(); }

  61.     public short read_short() { return stream.read_short(); }

  62.     public short read_ushort() { return stream.read_ushort(); }

  63.     public int read_long() { return stream.read_long(); }

  64.     public int read_ulong() { return stream.read_ulong(); }

  65.     public long read_longlong() { return stream.read_longlong(); }

  66.     public long read_ulonglong() { return stream.read_ulonglong(); }

  67.     public float read_float() { return stream.read_float(); }

  68.     public double read_double() { return stream.read_double(); }

  69.     public String read_string() { return stream.read_string(); }

  70.     public String read_wstring() { return stream.read_wstring(); }

  71. 

  72.     public void read_boolean_array(boolean[] value, int offset, int length) {

  73. 	stream.read_boolean_array(value, offset, length);

  74.     }

  75.     public void read_char_array(char[] value, int offset, int length) {

  76. 	stream.read_char_array(value, offset, length);

  77.     }

  78.     public void read_wchar_array(char[] value, int offset, int length) {

  79. 	stream.read_wchar_array(value, offset, length);

  80.     }

  81.     public void read_octet_array(byte[] value, int offset, int length) {

  82. 	stream.read_octet_array(value, offset, length);

  83.     }

  84.     public void read_short_array(short[] value, int offset, int length) {

  85. 	stream.read_short_array(value, offset, length);

  86.     }

  87.     public void read_ushort_array(short[] value, int offset, int length) {

  88. 	stream.read_ushort_array(value, offset, length);

  89.     }

  90.     public void read_long_array(int[] value, int offset, int length) {

  91. 	stream.read_long_array(value, offset, length);

  92.     }

  93.     public void read_ulong_array(int[] value, int offset, int length) {

  94. 	stream.read_ulong_array(value, offset, length);

  95.     }

  96.     public void read_longlong_array(long[] value, int offset, int length) {

  97. 	stream.read_longlong_array(value, offset, length);

  98.     }

  99.     public void read_ulonglong_array(long[] value, int offset, int length) {

  100. 	stream.read_ulonglong_array(value, offset, length);

  101.     }

  102.     public void read_float_array(float[] value, int offset, int length) {

  103. 	stream.read_float_array(value, offset, length);

  104.     }

  105.     public void read_double_array(double[] value, int offset, int length) {

  106. 	stream.read_double_array(value, offset, length);

  107.     }

  108. 

  109.     public org.omg.CORBA.Object read_Object() { return stream.read_Object(); }

  110.     public java.io.Serializable read_value() {return stream.read_value();}

  111.     public TypeCode read_TypeCode() { return stream.read_TypeCode(); }

  112.     public Any read_any() { return stream.read_any(); }

  113.     public Principal read_Principal() { return stream.read_Principal(); }

  114.     public java.math.BigDecimal read_fixed() { return stream.read_fixed(); }

  115.     public org.omg.CORBA.Context read_Context() { return stream.read_Context(); }

  116. 

  117.     public org.omg.CORBA.ORB orb() { return stream.orb(); }

  118. 

  119.     public void addTypeCodeAtPosition(TypeCodeImpl tc, int position) {

  120.         if (typeMap == null) {

  121.             //if (TypeCodeImpl.debug) System.out.println("Creating typeMap");

  122.             typeMap = new HashMap(16);

  123.         }

  124.         //if (TypeCodeImpl.debug) System.out.println(this + " adding tc " + tc + " at position " + position);

  125.         typeMap.put(new Integer(position), tc);

  126.     }

  127. 

  128.     public TypeCodeImpl getTypeCodeAtPosition(int position) {

  129.         if (typeMap == null)

  130. 	    return null;

  131.         //if (TypeCodeImpl.debug) System.out.println("Getting tc " + (TypeCodeImpl)typeMap.get(new Integer(position)) +

  132.             //" at position " + position);

  133.         return (TypeCodeImpl)typeMap.get(new Integer(position));

  134.     }

  135. 

  136.     public void setEnclosingInputStream(InputStream enclosure) {

  137.         // WrapperInputStream has no enclosure

  138.     }

  139. 

  140.     public TypeCodeReader getTopLevelStream() {

  141.         // WrapperInputStream has no enclosure

  142.         return this;

  143.     }

  144. 

  145.     public int getTopLevelPosition() {

  146.         //if (TypeCodeImpl.debug) System.out.println("WrapperInputStream.getTopLevelPosition " +

  147.             //"returning getPosition " + getPosition() + " - startPos " + startPos +

  148.             //" = " + (getPosition() - startPos));

  149.         return getPosition() - startPos;

  150.     }

  151. 

  152.     public void performORBVersionSpecificInit() {

  153.         // This is never actually called on a WrapperInputStream, but

  154.         // exists to satisfy the interface requirement.

  155.         stream.performORBVersionSpecificInit();

  156.     }

  157. 

  158.     public void resetCodeSetConverters() {

  159.         stream.resetCodeSetConverters();

  160.     }

  161. 

  162.     //public void printBuffer() { stream.printBuffer(); }

  163. 

  164.     public void printTypeMap() {

  165.         System.out.println("typeMap = {");

  166.         List sortedKeys = new ArrayList(typeMap.keySet());

  167.         Collections.sort(sortedKeys);

  168.         Iterator i = sortedKeys.iterator();

  169.         while (i.hasNext()) {

  170.             Integer pos = (Integer)i.next();

  171.             TypeCodeImpl tci = (TypeCodeImpl)typeMap.get(pos);

  172.             System.out.println("  key = " + pos.intValue() + ", value = " + tci.description());

  173.         }

  174.         System.out.println("}");

  175.     }

  176. }

  177. 

  178. interface TypeCodeReader extends MarshalInputStream {

  179.     public void addTypeCodeAtPosition(TypeCodeImpl tc, int position);

  180.     public TypeCodeImpl getTypeCodeAtPosition(int position);

  181.     public void setEnclosingInputStream(InputStream enclosure);

  182.     public TypeCodeReader getTopLevelStream();

  183.     public int getTopLevelPosition();

  184.     // for debugging

  185.     //public void printBuffer();

  186.     public int getPosition();

  187.     public void printTypeMap();

  188. }

  189. 

  190. class TypeCodeInputStream extends EncapsInputStream implements TypeCodeReader

  191. {

  192.     private Map typeMap = null;

  193.     private InputStream enclosure = null;

  194.     private boolean isEncapsulation = false;

  195. 

  196.     public TypeCodeInputStream(org.omg.CORBA.ORB orb, byte[] data, int size) {

  197.         super(orb, data, size);

  198.     }

  199. 

  200.     public TypeCodeInputStream(org.omg.CORBA.ORB orb, byte[] data, int size,

  201.                                boolean littleEndian) {

  202.         super(orb, data, size, littleEndian);

  203.     }

  204. 

  205.     public void addTypeCodeAtPosition(TypeCodeImpl tc, int position) {

  206.         if (typeMap == null) {

  207.             //if (TypeCodeImpl.debug) System.out.println("Creating typeMap");

  208.             typeMap = new HashMap(16);

  209.         }

  210.         //if (TypeCodeImpl.debug) System.out.println(this + " adding tc " + tc + " at position " + position);

  211.         typeMap.put(new Integer(position), tc);

  212.     }

  213. 

  214.     public TypeCodeImpl getTypeCodeAtPosition(int position) {

  215.         if (typeMap == null)

  216. 	    return null;

  217.         //if (TypeCodeImpl.debug) {

  218.             //System.out.println("Getting tc " + (TypeCode)typeMap.get(new Integer(position)) +

  219.                                //" at position " + position);

  220.         //}

  221.         return (TypeCodeImpl)typeMap.get(new Integer(position));

  222.     }

  223. 

  224.     public void setEnclosingInputStream(InputStream enclosure) {

  225.         this.enclosure = enclosure;

  226.     }

  227. 

  228.     public TypeCodeReader getTopLevelStream() {

  229.         if (enclosure == null)

  230.             return this;

  231.         if (enclosure instanceof TypeCodeReader)

  232.             return ((TypeCodeReader)enclosure).getTopLevelStream();

  233.         return this;

  234.     }

  235. 

  236.     public int getTopLevelPosition() {

  237.         if (enclosure != null && enclosure instanceof TypeCodeReader) {

  238.             // The enclosed stream has to consider if the enclosing stream

  239.             // had to read the enclosed stream completely when creating it.

  240.             // This is why the size of the enclosed stream needs to be substracted.

  241.             int topPos = ((TypeCodeReader)enclosure).getTopLevelPosition();

  242.             // Substract getBufferLength from the parents pos because it read this stream

  243.             // from its own when creating it

  244.             int pos = topPos - getBufferLength() + getPosition();

  245.             //if (TypeCodeImpl.debug) {

  246.                 //System.out.println("TypeCodeInputStream.getTopLevelPosition using getTopLevelPosition " + topPos +

  247.                     //(isEncapsulation ? " - encaps length 4" : "") +

  248.                     //" - getBufferLength() " + getBufferLength() +

  249.                     //" + getPosition() " + getPosition() + " = " + pos);

  250.             //}

  251.             return pos;

  252.         }

  253.         //if (TypeCodeImpl.debug) {

  254.             //System.out.println("TypeCodeInputStream.getTopLevelPosition returning getPosition() = " +

  255.                                //getPosition() + " because enclosure is " + enclosure);

  256.         //}

  257.         return getPosition();

  258.     }

  259. 

  260.     public static TypeCodeInputStream readEncapsulation(InputStream is, org.omg.CORBA.ORB _orb) {

  261. 	// _REVISIT_ Would be nice if we didn't have to copy the buffer!

  262. 	TypeCodeInputStream encap;

  263. 

  264.         int encapLength = is.read_long();

  265. 

  266.         // read off part of the buffer corresponding to the encapsulation

  267. 	byte[] encapBuffer = new byte[encapLength];

  268. 	is.read_octet_array(encapBuffer, 0, encapBuffer.length);

  269. 

  270. 	// create an encapsulation using the marshal buffer

  271.         if (is instanceof CDRInputStream) {

  272.             encap = new TypeCodeInputStream(_orb, encapBuffer, encapBuffer.length,

  273.                                             ((CDRInputStream)is).isLittleEndian());

  274.         } else {

  275.             encap = new TypeCodeInputStream(_orb, encapBuffer, encapBuffer.length);

  276.         }

  277. 	encap.setEnclosingInputStream(is);

  278.         encap.makeEncapsulation();

  279.         //if (TypeCodeImpl.debug) {

  280.             //System.out.println("Created TypeCodeInputStream " + encap + " with parent " + is);

  281.             //encap.printBuffer();

  282.         //}

  283. 	return encap;

  284.     }

  285. 

  286.     protected void makeEncapsulation() {

  287.         // first entry in an encapsulation is the endianess

  288.         consumeEndian();

  289.         isEncapsulation = true;

  290.     }

  291. 

  292.     public void printTypeMap() {

  293.         System.out.println("typeMap = {");

  294.         Iterator i = typeMap.keySet().iterator();

  295.         while (i.hasNext()) {

  296.             Integer pos = (Integer)i.next();

  297.             TypeCodeImpl tci = (TypeCodeImpl)typeMap.get(pos);

  298.             System.out.println("  key = " + pos.intValue() + ", value = " + tci.description());

  299.         }

  300.         System.out.println("}");

  301.     }

  302. }

  303. 

  304. final class TypeCodeOutputStream extends EncapsOutputStream {

  305. 

  306.     private OutputStream enclosure = null;

  307.     private Map typeMap = null;

  308.     private boolean isEncapsulation = false;

  309. 

  310.     public TypeCodeOutputStream(org.omg.CORBA.ORB orb) {

  311.         super(orb, false);

  312.     }

  313. 

  314.     public TypeCodeOutputStream(org.omg.CORBA.ORB orb, boolean littleEndian) {

  315.         super(orb, littleEndian);

  316.     }

  317. 

  318.     public org.omg.CORBA.portable.InputStream create_input_stream()

  319.     {

  320.         //return new TypeCodeInputStream(orb(), getByteBuffer(), getIndex(), isLittleEndian());

  321.         TypeCodeInputStream tcis = new TypeCodeInputStream(orb(), getByteBuffer(), getIndex(), isLittleEndian());

  322.         //if (TypeCodeImpl.debug) {

  323.             //System.out.println("Created TypeCodeInputStream " + tcis + " with no parent");

  324.             //tcis.printBuffer();

  325.         //}

  326.         return tcis;

  327.     }

  328. 

  329.     public void setEnclosingOutputStream(OutputStream enclosure) {

  330.         this.enclosure = enclosure;

  331.     }

  332. 

  333.     /*

  334.       public boolean isEncapsulatedIn(TypeCodeOutputStream outerEnclosure) {

  335.       if (outerEnclosure == this)

  336.       return true;

  337.       if (enclosure == null)

  338.       return false;

  339.       if (enclosure instanceof TypeCodeOutputStream)

  340.       return ((TypeCodeOutputStream)enclosure).isEncapsulatedIn(outerEnclosure);

  341.       // Last chance! Recursion ends with first non TypeCodeOutputStream.

  342.       return (enclosure == outerEnclosure);

  343.       }

  344.     */

  345. 

  346.     public TypeCodeOutputStream getTopLevelStream() {

  347.         if (enclosure == null)

  348.             return this;

  349.         if (enclosure instanceof TypeCodeOutputStream)

  350.             return ((TypeCodeOutputStream)enclosure).getTopLevelStream();

  351.         return this;

  352.     }

  353. 

  354.     public int getTopLevelPosition() {

  355.         if (enclosure != null && enclosure instanceof TypeCodeOutputStream) {

  356.             int pos = ((TypeCodeOutputStream)enclosure).getTopLevelPosition() + getPosition();

  357.             // Add four bytes for the encaps length, not another 4 for the byte order

  358.             // which is included in getPosition().

  359.             if (isEncapsulation) pos += 4;

  360.             //if (TypeCodeImpl.debug) {

  361.                 //System.out.println("TypeCodeOutputStream.getTopLevelPosition using getTopLevelPosition " +

  362.                     //((TypeCodeOutputStream)enclosure).getTopLevelPosition() +

  363.                     //" + getPosition() " + getPosition() +

  364.                     //(isEncapsulation ? " + encaps length 4" : "") +

  365.                     //" = " + pos);

  366.             //}

  367.             return pos;

  368.         }

  369.         //if (TypeCodeImpl.debug) {

  370.             //System.out.println("TypeCodeOutputStream.getTopLevelPosition returning getPosition() = " +

  371.                                //getPosition() + ", enclosure is " + enclosure);

  372.         //}

  373.         return getPosition();

  374.     }

  375. 

  376.     public void addIDAtPosition(String id, int position) {

  377.         if (typeMap == null)

  378.             typeMap = new HashMap(16);

  379.         //if (TypeCodeImpl.debug) System.out.println(this + " adding id " + id + " at position " + position);

  380.         typeMap.put(id, new Integer(position));

  381.     }

  382. 

  383.     public int getPositionForID(String id) {

  384.         if (typeMap == null)

  385. 	    throw new MARSHAL("Referenced type of indirect type not marshaled!");

  386.         //if (TypeCodeImpl.debug) System.out.println("Getting position " + ((Integer)typeMap.get(id)).intValue() +

  387.             //" for id " + id);

  388.         return ((Integer)typeMap.get(id)).intValue();

  389.     }

  390. 

  391.     public void writeRawBuffer(org.omg.CORBA.portable.OutputStream s, int firstLong) {

  392.         // Writes this streams buffer to the given OutputStream

  393.         // without byte order flag and length as is the case for encapsulations.

  394. 

  395.         // Make sure to align s to 4 byte boundaries.

  396.         // Unfortunately we can't do just this:

  397.         // s.alignAndReserve(4, 4);

  398.         // So we have to take the first four bytes given in firstLong and write them

  399.         // with a call to write_long which will trigger the alignment.

  400.         // Then write the rest of the byte array.

  401. 

  402.         //if (TypeCodeImpl.debug) {

  403.             //System.out.println(this + ".writeRawBuffer(" + s + ", " + firstLong + ")");

  404.             //if (s instanceof CDROutputStream) {

  405.                 //System.out.println("Parent position before writing kind = " + ((CDROutputStream)s).getIndex());

  406.             //}

  407.         //}

  408.         s.write_long(firstLong);

  409.         //if (TypeCodeImpl.debug) {

  410.             //if (s instanceof CDROutputStream) {

  411.                 //System.out.println("Parent position after writing kind = " + ((CDROutputStream)s).getIndex());

  412.             //}

  413.         //}

  414.         s.write_octet_array(getByteBuffer(), 4, getIndex() - 4);

  415.         //if (TypeCodeImpl.debug) {

  416.             //if (s instanceof CDROutputStream) {

  417.                 //System.out.println("Parent position after writing all " + getIndex() + " bytes = " + ((CDROutputStream)s).getIndex());

  418.             //}

  419.         //}

  420.     }

  421. 

  422.     public TypeCodeOutputStream createEncapsulation(org.omg.CORBA.ORB _orb) {

  423. 	TypeCodeOutputStream encap = new TypeCodeOutputStream(_orb, isLittleEndian());

  424. 	encap.setEnclosingOutputStream(this);

  425.         encap.makeEncapsulation();

  426.         //if (TypeCodeImpl.debug) System.out.println("Created TypeCodeOutputStream " + encap + " with parent " + this);

  427. 	return encap;

  428.     }

  429. 

  430.     protected void makeEncapsulation() {

  431.         // first entry in an encapsulation is the endianess

  432.         putEndian();

  433.         isEncapsulation = true;

  434.     }

  435. 

  436.     public static TypeCodeOutputStream wrapOutputStream(OutputStream os) {

  437.         boolean littleEndian = ((os instanceof CDROutputStream) ? ((CDROutputStream)os).isLittleEndian() : false);

  438.         TypeCodeOutputStream wrapper = new TypeCodeOutputStream(os.orb(), littleEndian);

  439.         wrapper.setEnclosingOutputStream(os);

  440.         //if (TypeCodeImpl.debug) System.out.println("Created TypeCodeOutputStream " + wrapper + " with parent " + os);

  441.         return wrapper;

  442.     }

  443. 

  444.     public int getPosition() {

  445.         return getIndex();

  446.     }

  447. 

  448.     public int getRealIndex(int index) {

  449.         int topPos = getTopLevelPosition();

  450.         //if (TypeCodeImpl.debug) System.out.println("TypeCodeOutputStream.getRealIndex using getTopLevelPosition " +

  451.             //topPos + " instead of getPosition " + getPosition());

  452. 	return topPos;

  453.     }

  454. /*

  455.     protected void printBuffer() {

  456.         super.printBuffer();

  457.     }

  458. */

  459.     byte[] getTypeCodeBuffer() {

  460.         // Returns the buffer trimmed of the trailing zeros and without the

  461.         // known _kind value at the beginning.

  462.         byte[] theBuffer = getByteBuffer();

  463.         //System.out.println("outBuffer length = " + (getIndex() - 4));

  464.         byte[] tcBuffer = new byte[getIndex() - 4];

  465.         System.arraycopy(theBuffer, 4, tcBuffer, 0, getIndex() - 4);

  466.         return tcBuffer;

  467.     }

  468. 

  469.     public void printTypeMap() {

  470.         System.out.println("typeMap = {");

  471.         Iterator i = typeMap.keySet().iterator();

  472.         while (i.hasNext()) {

  473.             String id = (String)i.next();

  474.             Integer pos = (Integer)typeMap.get(id);

  475.             System.out.println("  key = " + id + ", value = " + pos);

  476.         }

  477.         System.out.println("}");

  478.     }

  479. }

  480. 

  481. // no chance of subclasses, so no problems with runtime helper lookup

  482. public final class TypeCodeImpl extends TypeCode 

  483. {

  484.     //static final boolean debug = false;

  485. 

  486.     // the predefined typecode constants

  487. 

  488.     private static final TypeCodeImpl primitiveConstants[] = {

  489. 	new TypeCodeImpl(TCKind._tk_null),			// tk_null      

  490. 	new TypeCodeImpl(TCKind._tk_void),			// tk_void      

  491. 	new TypeCodeImpl(TCKind._tk_short),			// tk_short     

  492. 	new TypeCodeImpl(TCKind._tk_long),			// tk_long      

  493. 	new TypeCodeImpl(TCKind._tk_ushort),		// tk_ushort    

  494. 	new TypeCodeImpl(TCKind._tk_ulong),			// tk_ulong     

  495. 	new TypeCodeImpl(TCKind._tk_float),			// tk_float     

  496. 	new TypeCodeImpl(TCKind._tk_double),		// tk_double    

  497. 	new TypeCodeImpl(TCKind._tk_boolean),		// tk_boolean   

  498. 	new TypeCodeImpl(TCKind._tk_char),			// tk_char      

  499. 	new TypeCodeImpl(TCKind._tk_octet),			// tk_octet     

  500. 	new TypeCodeImpl(TCKind._tk_any),			// tk_any       

  501. 	new TypeCodeImpl(TCKind._tk_TypeCode),		// tk_typecode  

  502. 	new TypeCodeImpl(TCKind._tk_Principal),		// tk_principal 

  503. 	new TypeCodeImpl(TCKind._tk_objref),		// tk_objref    

  504. 	null,						// tk_struct    

  505. 	null,						// tk_union     

  506. 	null,						// tk_enum      

  507. 	new TypeCodeImpl(TCKind._tk_string),		// tk_string    

  508. 	null,						// tk_sequence  

  509. 	null,						// tk_array     

  510. 	null,						// tk_alias     

  511. 	null,						// tk_except    

  512. 	new TypeCodeImpl(TCKind._tk_longlong),		// tk_longlong  

  513. 	new TypeCodeImpl(TCKind._tk_ulonglong),		// tk_ulonglong 

  514. 	new TypeCodeImpl(TCKind._tk_longdouble),		// tk_longdouble

  515. 	new TypeCodeImpl(TCKind._tk_wchar),			// tk_wchar     

  516. 	new TypeCodeImpl(TCKind._tk_wstring),		// tk_wstring

  517. 	new TypeCodeImpl(TCKind._tk_fixed),         // tk_fixed

  518. 	new TypeCodeImpl(TCKind._tk_value),			// tk_value

  519. 	new TypeCodeImpl(TCKind._tk_value_box),		// tk_value_box

  520. 	new TypeCodeImpl(TCKind._tk_native),		// tk_native

  521. 	new TypeCodeImpl(TCKind._tk_abstract_interface)	// tk_abstract_interface   

  522.     };

  523. 

  524.     // the indirection TCKind, needed for recursive typecodes. 

  525.     protected static final int tk_indirect = 0xFFFFFFFF;

  526.   

  527.     // typecode encodings have three different categories that determine

  528.     // how the encoding should be done.

  529.   

  530.     private static final int EMPTY = 0;	// no parameters

  531.     private static final int SIMPLE = 1;	// simple parameters.

  532.     private static final int COMPLEX = 2; // complex parameters. need to

  533.     // use CDR encapsulation for

  534.     // parameters 

  535.   

  536.     // a table storing the encoding category for the various typecodes.

  537.   

  538.     private static final int typeTable[] = {

  539. 	EMPTY,	// tk_null      

  540. 	EMPTY,	// tk_void      

  541. 	EMPTY,	// tk_short     

  542. 	EMPTY,	// tk_long      

  543. 	EMPTY,	// tk_ushort    

  544. 	EMPTY,	// tk_ulong     

  545. 	EMPTY,	// tk_float     

  546. 	EMPTY,	// tk_double    

  547. 	EMPTY,	// tk_boolean   

  548. 	EMPTY,	// tk_char      

  549. 	EMPTY,	// tk_octet     

  550. 	EMPTY,	// tk_any       

  551. 	EMPTY,	// tk_typecode  

  552. 	EMPTY,	// tk_principal 

  553. 	COMPLEX,	// tk_objref    

  554. 	COMPLEX,	// tk_struct    

  555. 	COMPLEX,	// tk_union     

  556. 	COMPLEX,	// tk_enum      

  557. 	SIMPLE,	// tk_string    

  558. 	COMPLEX,	// tk_sequence  

  559. 	COMPLEX,	// tk_array     

  560. 	COMPLEX,	// tk_alias     

  561. 	COMPLEX,	// tk_except    

  562. 	EMPTY,	// tk_longlong  

  563. 	EMPTY,	// tk_ulonglong 

  564. 	EMPTY,	// tk_longdouble

  565. 	EMPTY,	// tk_wchar     

  566. 	SIMPLE,	// tk_wstring

  567. 	SIMPLE,	// tk_fixed

  568. 	COMPLEX,	// tk_value

  569. 	COMPLEX,	// tk_value_box

  570. 	COMPLEX,	// tk_native

  571. 	COMPLEX	// tk_abstract_interface

  572.     };

  573. 

  574.     // Maps TCKind values to names

  575.     private static final String[] kindNames = {

  576.         "null",

  577.         "void",

  578.         "short",

  579.         "long",

  580.         "ushort",

  581.         "ulong",

  582.         "float",

  583.         "double",

  584.         "boolean",

  585.         "char",

  586.         "octet",

  587.         "any",

  588.         "typecode",

  589.         "principal",

  590.         "objref",

  591.         "struct",

  592.         "union",

  593.         "enum",

  594.         "string",

  595.         "sequence",

  596.         "array",

  597.         "alias",

  598.         "exception",

  599.         "longlong",

  600.         "ulonglong",

  601.         "longdouble",

  602.         "wchar",

  603.         "wstring",

  604.         "fixed",

  605.         "value",

  606.         "valueBox",

  607.         "native",

  608.         "abstractInterface"

  609.     };

  610. 

  611. private int 		_kind		= 0;	// the typecode kind

  612. 

  613. // data members for representing the various kinds of typecodes. 

  614. 

  615. private String          _id             = "";   // the typecode repository id

  616. private String          _name           = "";   // the typecode name

  617. private int             _memberCount    = 0;    // member count

  618. private String          _memberNames[]  = null; // names of members

  619. private TypeCodeImpl    _memberTypes[]  = null; // types of members

  620. private AnyImpl         _unionLabels[]  = null; // values of union labels

  621. private TypeCodeImpl    _discriminator  = null; // union discriminator type

  622. private int             _defaultIndex   = -1;   // union default index

  623. private int             _length         = 0;    // string/seq/array length

  624. private TypeCodeImpl    _contentType    = null; // seq/array/alias type

  625. // fixed

  626. private short           _digits         = 0;

  627. private short           _scale          = 0;

  628. // value type

  629. // _REVISIT_ We might want to keep references to the ValueMember classes

  630. // passed in at initialization instead of copying the relevant data.

  631. // Is the data immutable? What about StructMember, UnionMember etc.?

  632. private short           _type_modifier  = -1;   // VM_NONE, VM_CUSTOM,

  633. // VM_ABSTRACT, VM_TRUNCATABLE

  634. private TypeCodeImpl    _concrete_base  = null; // concrete base type

  635. private short           _memberAccess[] = null; // visibility of ValueMember

  636. // recursive sequence support

  637. private TypeCodeImpl    _parent         = null; // the enclosing type code

  638. private int             _parentOffset   = 0;    // the level of enclosure

  639. // recursive type code support

  640. private TypeCodeImpl    _indirectType   = null;

  641. 

  642. // caches the byte buffer written in write_value for quick remarshaling...

  643. private byte[] outBuffer                = null;

  644. // ... but only if caching is enabled

  645. private boolean cachingEnabled          = false;

  646. 

  647. // the ORB instance: may be instanceof ORBSingleton or ORB

  648. private org.omg.CORBA.ORB _orb; 		

  649. 

  650. ///////////////////////////////////////////////////////////////////////////

  651. // Constructors...

  652. 

  653. public TypeCodeImpl(org.omg.CORBA.ORB orb) 

  654. {

  655.     // initialized to tk_null

  656.     _orb = orb;

  657. }

  658.   

  659. public TypeCodeImpl(org.omg.CORBA.ORB orb, TypeCode tc)

  660. // to handle conversion of "remote" typecodes into "native" style.

  661. // also see the 'convertToNative(ORB orb, TypeCode tc)' function

  662. {

  663.     // the orb object

  664.     _orb = orb;

  665. 

  666.     // This is a protection against misuse of this constructor.

  667.     // Should only be used if tc is not an instance of this class!

  668.     // Otherwise we run into problems with recursive/indirect type codes.

  669.     // _REVISIT_ We should make this constructor private

  670.     if (tc instanceof TypeCodeImpl) {

  671. 	TypeCodeImpl tci = (TypeCodeImpl)tc;

  672. 	if (tci._kind == tk_indirect)

  673. 	    throw new BAD_TYPECODE();

  674. 	if (tci._kind == TCKind._tk_sequence && tci._contentType == null)

  675. 	    throw new BAD_TYPECODE();

  676.     }

  677. 

  678.     // set up kind

  679.     _kind 	= tc.kind().value();

  680. 

  681.     try {

  682. 	// set up parameters

  683. 	switch (_kind) {

  684. 	case TCKind._tk_value:

  685. 	    _type_modifier = tc.type_modifier();

  686. 	    // concrete base may be null

  687. 	    TypeCode tccb = tc.concrete_base_type();

  688. 	    if (tccb != null) {

  689. 		_concrete_base = convertToNative(_orb, tccb);

  690. 	    } else {

  691. 		_concrete_base = null;

  692. 	    }

  693. 	    //_memberAccess = tc._memberAccess;

  694. 	    // Need to reconstruct _memberAccess using member_count() and member_visibility()

  695. 	    _memberAccess = new short[tc.member_count()];

  696. 	    for (int i=0; i < tc.member_count(); i++) {

  697. 		_memberAccess[i] = tc.member_visibility(i);

  698. 	    }

  699. 	case TCKind._tk_except:

  700. 	case TCKind._tk_struct:

  701. 	case TCKind._tk_union:

  702. 	    // set up member types

  703. 	    _memberTypes = new TypeCodeImpl[tc.member_count()];

  704. 	    for (int i=0; i < tc.member_count(); i++) {

  705. 	        _memberTypes[i] = convertToNative(_orb, tc.member_type(i));

  706. 		_memberTypes[i].setParent(this);

  707. 	    }

  708. 	case TCKind._tk_enum:

  709. 	    // set up member names

  710. 	    _memberNames = new String[tc.member_count()];

  711. 	    for (int i=0; i < tc.member_count(); i++) {

  712. 	        _memberNames[i] = tc.member_name(i);

  713. 	    }

  714. 	    // set up member count

  715. 	    _memberCount = tc.member_count();

  716. 	case TCKind._tk_objref:

  717. 	case TCKind._tk_alias:

  718. 	case TCKind._tk_value_box:

  719. 	case TCKind._tk_native:

  720. 	case TCKind._tk_abstract_interface:

  721. 	    setId(tc.id());

  722. 	    _name = tc.name();

  723. 	    break;

  724. 	}

  725.       

  726. 	// set up stuff for unions

  727. 	switch (_kind) {

  728. 	case TCKind._tk_union:

  729. 	    _discriminator = convertToNative(_orb, tc.discriminator_type());

  730. 	    _defaultIndex  = tc.default_index();

  731. 	    _unionLabels = new AnyImpl[_memberCount];

  732. 	    for (int i=0; i < _memberCount; i++)

  733. 		_unionLabels[i] = new AnyImpl(_orb, tc.member_label(i));

  734. 	    break;

  735. 	}

  736.       

  737. 	// set up length

  738. 	switch (_kind) {

  739. 	case TCKind._tk_string:

  740. 	case TCKind._tk_wstring:

  741. 	case TCKind._tk_sequence:

  742. 	case TCKind._tk_array:

  743. 	    _length = tc.length();

  744. 	}

  745.       

  746. 	// set up content type

  747. 	switch (_kind) {

  748. 	case TCKind._tk_sequence:

  749. 	case TCKind._tk_array:

  750. 	case TCKind._tk_alias:

  751. 	case TCKind._tk_value_box:

  752. 	    _contentType = convertToNative(_orb, tc.content_type());

  753. 	}

  754.     } catch (org.omg.CORBA.TypeCodePackage.Bounds e) {} catch (BadKind e) {}

  755.     // dont have to worry about these since code ensures we dont step

  756.     // out of bounds.

  757. }

  758.     

  759. public TypeCodeImpl(int creationKind)

  760. // for primitive types

  761. {

  762.     // the orb object

  763.     _orb = null;

  764. 

  765.     // private API. dont bother checking that

  766.     //     (creationKind < 0 || creationKind > typeTable.length)

  767. 

  768.     _kind = creationKind;

  769. 

  770.     // do initialization for special cases

  771.     switch (_kind) {

  772.     case TCKind._tk_objref:

  773. 	{

  774. 	    // this is being used to create typecode for CORBA::Object

  775. 	    setId("IDL:omg.org/CORBA/Object:1.0");

  776. 	    _name = "Object";

  777. 	    break;

  778. 	}

  779. 

  780.     case TCKind._tk_string:

  781.     case TCKind._tk_wstring:

  782. 	{

  783. 	    _length =0;

  784. 	    break;

  785. 	}

  786. 

  787.     case TCKind._tk_value:

  788. 	{

  789. 	    _concrete_base = null;

  790. 	    break;

  791. 	}

  792.     }

  793. }

  794. 

  795. public TypeCodeImpl(org.omg.CORBA.ORB orb,

  796. 		    int creationKind,

  797. 		    String id,

  798. 		    String name,

  799. 		    StructMember[] members)

  800. 		    // for structs and exceptions

  801. {

  802.     // the orb object

  803.     _orb = orb;

  804. 

  805.     if ((creationKind == TCKind._tk_struct) || (creationKind == TCKind._tk_except))

  806. 	{

  807. 	

  808. 	    _kind		= creationKind;

  809. 	    setId(id);

  810. 	    _name		= name;

  811. 	    _memberCount	= members.length;

  812. 	

  813. 	    _memberNames = new String[_memberCount];

  814. 	    _memberTypes = new TypeCodeImpl[_memberCount];

  815. 

  816. 	    for (int i = 0 ; i < _memberCount ; i++) {

  817. 		_memberNames[i] = members[i].name;

  818. 		_memberTypes[i] = convertToNative(_orb, members[i].type);

  819. 		_memberTypes[i].setParent(this);

  820. 	    }

  821. 	} // else initializes to null

  822. }

  823. 

  824. public TypeCodeImpl(org.omg.CORBA.ORB orb, 

  825. 		    int creationKind,

  826. 		    String id,

  827. 		    String name,

  828. 		    TypeCode discriminator_type,

  829. 		    UnionMember[] members)

  830. 		    // for unions

  831. {

  832.     // the orb object

  833.     _orb = orb;

  834. 

  835.     if (creationKind == TCKind._tk_union) {

  836.         _kind		= creationKind;

  837.         setId(id);

  838.         _name		= name;

  839.         _memberCount	= members.length;

  840.         _discriminator	= convertToNative(_orb, discriminator_type);

  841. 

  842.         _memberNames = new String[_memberCount];

  843.         _memberTypes = new TypeCodeImpl[_memberCount];

  844.         _unionLabels = new AnyImpl[_memberCount];

  845. 

  846.         for (int i = 0 ; i < _memberCount ; i++) {

  847.             _memberNames[i] = members[i].name;

  848.             _memberTypes[i] = convertToNative(_orb, members[i].type);

  849.             _memberTypes[i].setParent(this);

  850.             _unionLabels[i] = new AnyImpl(_orb, members[i].label);

  851.             // check whether this is the default branch.

  852.             if (_unionLabels[i].type().kind() == TCKind.tk_octet) {

  853.                 if (_unionLabels[i].extract_octet() == (byte)0) {

  854.                     _defaultIndex = i;

  855.                 }

  856.             }

  857.         }

  858.     } // else initializes to null

  859. }

  860. 

  861. public TypeCodeImpl(org.omg.CORBA.ORB orb,

  862. 		    int creationKind,

  863. 		    String id,

  864. 		    String name,

  865. 		    short type_modifier,

  866. 		    TypeCode concrete_base,

  867. 		    ValueMember[] members)

  868. 		    // for value types

  869. {

  870.     // the orb object

  871.     _orb = orb;

  872. 

  873.     if (creationKind == TCKind._tk_value) {

  874.         _kind		= creationKind;

  875.         setId(id);

  876.         _name		= name;

  877.         _type_modifier	= type_modifier;

  878.         if (_concrete_base != null) {

  879.             _concrete_base = convertToNative(_orb, concrete_base);

  880.         }

  881.         _memberCount	= members.length;

  882. 

  883.         _memberNames = new String[_memberCount];

  884.         _memberTypes = new TypeCodeImpl[_memberCount];

  885.         _memberAccess = new short[_memberCount];

  886. 

  887.         for (int i = 0 ; i < _memberCount ; i++) {

  888. 	    _memberNames[i] = members[i].name;

  889. 	    _memberTypes[i] = convertToNative(_orb, members[i].type);

  890. 	    _memberTypes[i].setParent(this);

  891. 	    _memberAccess[i] = members[i].access;

  892.         }

  893.     } // else initializes to null

  894. }

  895. 

  896. 

  897. public TypeCodeImpl(org.omg.CORBA.ORB orb,

  898. 		    int creationKind,

  899. 		    String id,

  900. 		    String name,

  901. 		    String[] members)

  902. 		    // for enums

  903. {

  904.     // the orb object

  905.     _orb = orb;

  906. 

  907.     if (creationKind == TCKind._tk_enum)

  908. 	{

  909. 	    _kind		= creationKind;

  910. 	    setId(id);

  911. 	    _name		= name;

  912. 	    _memberCount	= members.length;

  913. 

  914. 	    _memberNames = new String[_memberCount];

  915. 

  916. 	    for (int i = 0 ; i < _memberCount ; i++)

  917. 		_memberNames[i] = members[i];

  918. 	} // else initializes to null

  919. }

  920. 

  921. public TypeCodeImpl(org.omg.CORBA.ORB orb, 

  922. 		    int creationKind,

  923. 		    String id,

  924. 		    String name,

  925. 		    TypeCode original_type)

  926. 		    // for aliases and value boxes

  927. {

  928.     // the orb object

  929.     _orb = orb;

  930. 

  931.     if ( creationKind == TCKind._tk_alias || creationKind == TCKind._tk_value_box )

  932. 	{

  933. 	    _kind		= creationKind;

  934. 	    setId(id);

  935. 	    _name		= name;

  936. 	    _contentType	= convertToNative(_orb, original_type);

  937. 	}

  938.     // else initializes to null

  939. 

  940. }

  941. 

  942. public TypeCodeImpl(org.omg.CORBA.ORB orb, 

  943. 		    int creationKind,

  944. 		    String id,

  945. 		    String name)

  946. {

  947.     // the orb object

  948.     _orb = orb;

  949. 

  950.     if (creationKind == TCKind._tk_objref ||

  951.         creationKind == TCKind._tk_native ||

  952.         creationKind == TCKind._tk_abstract_interface)

  953. 	{

  954. 	    _kind		= creationKind;

  955. 	    setId(id);

  956. 	    _name		= name;

  957. 	} // else initializes to null

  958. }

  959. 

  960.   

  961. public TypeCodeImpl(org.omg.CORBA.ORB orb, 

  962. 		    int creationKind,

  963. 		    int bound)

  964. 		    // for strings

  965. {

  966.     if (bound < 0)

  967.         throw new BAD_PARAM("bound can not be negative!");

  968. 

  969.     // the orb object

  970.     _orb = orb;

  971. 

  972.     if ((creationKind == TCKind._tk_string) || (creationKind == TCKind._tk_wstring))

  973. 	{

  974. 	    _kind		= creationKind;

  975. 	    _length		= bound;

  976. 	} // else initializes to null

  977. }

  978. 

  979. public TypeCodeImpl(org.omg.CORBA.ORB orb, 

  980. 		    int creationKind,

  981. 		    int bound,

  982. 		    TypeCode element_type)

  983. 		    // for sequences and arrays

  984. {

  985.     // the orb object

  986.     _orb = orb;

  987. 

  988.     if ( creationKind == TCKind._tk_sequence || creationKind == TCKind._tk_array )

  989. 	{

  990. 	    _kind		= creationKind;

  991. 	    _length		= bound;

  992. 	    _contentType	= convertToNative(_orb, element_type);

  993. 	} // else initializes to null

  994. }

  995.   

  996. public TypeCodeImpl(org.omg.CORBA.ORB orb,

  997. 		    int creationKind,

  998. 		    int bound,

  999. 		    int offset)

  1000. 		    // for recursive sequences

  1001. {

  1002.     // the orb object

  1003.     _orb = orb;

  1004. 

  1005.     if (creationKind == TCKind._tk_sequence) {

  1006.         _kind		= creationKind;

  1007.         _length		= bound;

  1008.         _parentOffset	= offset;

  1009.     } // else initializes to null

  1010. }

  1011. 

  1012. public TypeCodeImpl(org.omg.CORBA.ORB orb,

  1013. 		    String id)

  1014. 		    // for recursive type codes

  1015. {

  1016.     // the orb object

  1017.     _orb = orb;

  1018. 

  1019.     _kind	= tk_indirect;

  1020.     // This is the type code of the type we stand in for, not our own.

  1021.     _id		= id;

  1022.     // Try to resolve it now. May return null in which case

  1023.     // we try again later (see indirectType()).

  1024.     tryIndirectType();

  1025. }

  1026. 

  1027. public TypeCodeImpl(org.omg.CORBA.ORB orb,

  1028. 		    int creationKind,

  1029. 		    short digits,

  1030. 		    short scale)

  1031. 		    // for fixed

  1032. {

  1033.     // the orb object

  1034.     _orb = orb;

  1035. 

  1036.     //if (digits < 1 || digits > 31)

  1037.     //throw new BAD_TYPECODE();

  1038. 

  1039.     if (creationKind == TCKind._tk_fixed) {

  1040.         _kind		= creationKind;

  1041.         _digits		= digits;

  1042.         _scale		= scale;

  1043.     } // else initializes to null

  1044. }

  1045. 

  1046. ///////////////////////////////////////////////////////////////////////////

  1047. // Other creation functions...

  1048. 

  1049. public static TypeCodeImpl get_primitive_tc(TCKind tcKind)

  1050. {

  1051.     try {

  1052. 	return primitiveConstants[tcKind.value()];

  1053.     } catch (Throwable t) {

  1054. 	throw new BAD_OPERATION("Invalid or unavailable typecode for kind = "+tcKind.value());

  1055.     }

  1056. }

  1057. 

  1058. public static TypeCodeImpl get_primitive_tc(int val)

  1059. {

  1060.     try {

  1061. 	return primitiveConstants[val];

  1062.     } catch (Throwable t) {

  1063. 	throw new BAD_OPERATION("Invalid or unavailable typecode for kind = "+val);

  1064.     }

  1065. }

  1066. 

  1067. // Optimization:

  1068. // If we checked for and returned constant primitive typecodes

  1069. // here we could reduce object creation and also enable more

  1070. // efficient typecode comparisons for primitive typecodes.

  1071. //

  1072. protected static TypeCodeImpl convertToNative(org.omg.CORBA.ORB orb,

  1073. 					      TypeCode tc) 

  1074. {

  1075.     if (tc instanceof TypeCodeImpl)

  1076. 	return (TypeCodeImpl) tc;

  1077.     else

  1078. 	return new TypeCodeImpl(orb, tc);

  1079. }

  1080. 

  1081. public static CDROutputStream newOutputStream(org.omg.CORBA.ORB orb) {

  1082.     TypeCodeOutputStream tcos = new TypeCodeOutputStream(orb);

  1083.     //if (debug) System.out.println("Created TypeCodeOutputStream " + tcos + " with no parent");

  1084.     return tcos;

  1085. }

  1086. 

  1087. // Support for indirect/recursive type codes

  1088. 

  1089. private TypeCodeImpl indirectType() {

  1090.     _indirectType = tryIndirectType();

  1091.     if (_indirectType == null) {

  1092.         // Nothing we can do about that.

  1093.         throw new BAD_TYPECODE("Invoked operation on unresolved recursive type code!");

  1094.     }

  1095.     return _indirectType;

  1096. }

  1097. 

  1098. private TypeCodeImpl tryIndirectType() {

  1099.     // Assert that _kind == tk_indirect

  1100.     if (_indirectType != null)

  1101.         return _indirectType;

  1102. 

  1103.     if (_orb instanceof TypeCodeFactory) {

  1104.         setIndirectType(((TypeCodeFactory)_orb).getTypeCode(_id));

  1105.     } else {

  1106.         throw new BAD_TYPECODE("ORB not supporting recursive type codes!");

  1107.     }

  1108.     return _indirectType;

  1109. }

  1110. 

  1111. private void setIndirectType(TypeCodeImpl newType) {

  1112.     _indirectType = newType;

  1113.     if (_indirectType != null) {

  1114. 	try {

  1115. 	    _id = _indirectType.id();

  1116. 	} catch (BadKind e) {} // can't happen

  1117.     }

  1118. }

  1119. 

  1120. private void setId(String newID) {

  1121.     _id = newID;

  1122.     if (_orb instanceof TypeCodeFactory) {

  1123.         ((TypeCodeFactory)_orb).setTypeCode(_id, this);

  1124.     }

  1125.     // check whether return value != this which would indicate that the

  1126.     // repository id isn't unique.

  1127. }

  1128. 

  1129. private void setParent(TypeCodeImpl parent) {

  1130.     _parent = parent;

  1131. }

  1132. 

  1133. private TypeCodeImpl getParentAtLevel(int level) {

  1134.     if (level == 0)

  1135.         return this;

  1136.     if (_parent == null)

  1137.         throw new BAD_TYPECODE("Invoked operation on unresolved recursive type code!");

  1138.     return _parent.getParentAtLevel(level - 1);

  1139. }

  1140. 

  1141. private TypeCodeImpl lazy_content_type() {

  1142.     if (_contentType == null) {

  1143.         if (_kind == TCKind._tk_sequence && _parentOffset > 0 && _parent != null) {

  1144. 	    // This is an unresolved recursive sequence tc.

  1145. 	    // Try to resolve it now if the hierarchy is complete.

  1146. 	    TypeCodeImpl realParent = getParentAtLevel(_parentOffset);

  1147. 	    if (realParent != null && realParent._id != null) {

  1148. 		// Create a recursive type code object as the content type.

  1149. 		// This is when the recursive sequence typecode morphes

  1150. 		// into a sequence typecode containing a recursive typecode.

  1151. 		_contentType = new TypeCodeImpl(_orb, realParent._id);

  1152. 	    }

  1153.         }

  1154.     }

  1155.     return _contentType;

  1156. }

  1157. 

  1158. // Other private functions

  1159. 

  1160. private TypeCode realType(TypeCode aType) {

  1161.     TypeCode realType = aType;

  1162.     try {

  1163.         // Note: Indirect types are handled in kind() method

  1164.         while (realType.kind().value() == TCKind._tk_alias) {

  1165.             realType = realType.content_type();

  1166.         }

  1167.     } catch (BadKind bad) { // impossible

  1168.     }

  1169.     return realType;

  1170. }

  1171. 

  1172. ///////////////////////////////////////////////////////////////////////////

  1173. // TypeCode operations

  1174. 

  1175. public final boolean equal(TypeCode tc)

  1176. // _REVISIT_ for all optional names/ids, we might want to check that

  1177. // they are equal in case both are non-nil.

  1178. {

  1179.     if (tc == this)

  1180.         return true;

  1181. 

  1182.     try {

  1183. 

  1184. 	if (_kind == tk_indirect) {

  1185. 	    //return indirectType().equal(tc);

  1186. 	    if (_id != null && tc.id() != null)

  1187. 		return _id.equals(tc.id());

  1188. 	    return (_id == null && tc.id() == null);

  1189. 	}

  1190. 

  1191. 	// make sure kinds are identical.

  1192. 	if (_kind != tc.kind().value()) {

  1193. 	    return false;

  1194. 	}

  1195. 

  1196. 	switch (typeTable[_kind]) {

  1197. 	case EMPTY:

  1198. 	    // no parameters to check.

  1199. 	    return true;

  1200.       

  1201. 	case SIMPLE:

  1202. 	    switch (_kind) {

  1203. 	    case TCKind._tk_string:

  1204. 	    case TCKind._tk_wstring:

  1205. 		// check for bound.

  1206. 		return (_length == tc.length());

  1207. 

  1208. 	    case TCKind._tk_fixed:

  1209. 		return (_digits == tc.fixed_digits() && _scale == tc.fixed_scale());

  1210. 	    default:

  1211. 		return false;

  1212. 	    }

  1213.       

  1214. 	case COMPLEX:

  1215. 

  1216. 	    switch(_kind) {

  1217. 

  1218. 	    case TCKind._tk_objref:

  1219. 		{

  1220. 		    // check for logical id.

  1221. 		    if (_id.compareTo(tc.id()) == 0) {

  1222. 			return true;

  1223. 		    }

  1224. 

  1225. 		    if (_id.compareTo(get_primitive_tc(_kind).id()) == 0) {

  1226. 			return true;

  1227. 		    }

  1228. 

  1229. 		    if (tc.id().compareTo(get_primitive_tc(_kind).id()) == 0) {

  1230. 			return true;

  1231. 		    }

  1232. 

  1233. 		    return false;

  1234. 		}

  1235. 

  1236. 	    case TCKind._tk_native:

  1237. 	    case TCKind._tk_abstract_interface:

  1238. 		{

  1239. 		    // check for logical id.

  1240. 		    if (_id.compareTo(tc.id()) != 0) {

  1241. 			return false;

  1242. 

  1243. 		    }

  1244. 		    // ignore name since its optional.

  1245. 		    return true;

  1246. 		}

  1247. 

  1248. 	    case TCKind._tk_struct:

  1249. 	    case TCKind._tk_except:

  1250. 		{

  1251. 		    // check for member count

  1252. 		    if (_memberCount != tc.member_count())

  1253. 			return false;

  1254. 		    // check for repository id

  1255. 		    if (_id.compareTo(tc.id()) != 0)

  1256. 			return false;

  1257. 		    // check for member types.

  1258. 		    for (int i = 0 ; i < _memberCount ; i++)

  1259. 			if (! _memberTypes[i].equal(tc.member_type(i)))

  1260. 			    return false;

  1261. 		    // ignore id and names since those are optional.

  1262. 		    return true;

  1263. 		}

  1264. 

  1265. 	    case TCKind._tk_union:

  1266. 		{

  1267. 		    // check for member count

  1268. 		    if (_memberCount != tc.member_count())

  1269. 			return false;

  1270. 		    // check for repository id

  1271. 		    if (_id.compareTo(tc.id()) != 0)

  1272. 			return false;

  1273. 		    // check for default index

  1274. 		    if (_defaultIndex != tc.default_index())

  1275. 			return false;

  1276. 		    // check for discriminator type

  1277. 		    if (!_discriminator.equal(tc.discriminator_type()))

  1278. 			return false;

  1279. 		    // check for label types and values

  1280. 		    for (int i = 0 ; i < _memberCount ; i++)

  1281. 			if (! _unionLabels[i].equal(tc.member_label(i)))

  1282. 			    return false;

  1283. 		    // check for branch types

  1284. 		    for (int i = 0 ; i < _memberCount ; i++)

  1285. 			if (! _memberTypes[i].equal(tc.member_type(i)))

  1286. 			    return false;

  1287. 		    // ignore id and names since those are optional.

  1288. 		    return true;

  1289. 		}

  1290. 

  1291. 	    case TCKind._tk_enum:

  1292. 		{

  1293. 		    // check for repository id

  1294. 		    if (_id.compareTo(tc.id()) != 0)

  1295. 			return false;

  1296. 		    // check member count

  1297.