jdk8-mips64-public/corba: src/share/classes/com/sun/corba/se/impl/corba/TypeCodeImpl.java@6845b95cba6b (annotated)

src/share/classes/com/sun/corba/se/impl/corba/TypeCodeImpl.java@6845b95cba6b (annotated)

src/share/classes/com/sun/corba/se/impl/corba/TypeCodeImpl.java

Thu, 31 Aug 2017 18:10:36 +0800

author: aoqi
date: Thu, 31 Aug 2017 18:10:36 +0800
changeset 748: 6845b95cba6b
parent 478: 80161c61aa68
parent 0: 7ef37b2cdcad
permissions: -rw-r--r--

merge

 /*
  * Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.  Oracle designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Oracle in the LICENSE file that accompanied this code.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */
 package com.sun.corba.se.impl.corba;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Collections;
 import java.util.ArrayList;
 import java.io.IOException;
 import java.io.PrintStream;
 import java.io.ByteArrayOutputStream;
 import java.math.BigDecimal;
 import java.math.BigInteger;
 import org.omg.CORBA.TypeCode ;
 import org.omg.CORBA.StructMember ;
 import org.omg.CORBA.UnionMember ;
 import org.omg.CORBA.ValueMember ;
 import org.omg.CORBA.TCKind ;
 import org.omg.CORBA.Any ;
 import org.omg.CORBA.Principal ;
 import org.omg.CORBA.BAD_TYPECODE ;
 import org.omg.CORBA.BAD_PARAM ;
 import org.omg.CORBA.BAD_OPERATION ;
 import org.omg.CORBA.INTERNAL ;
 import org.omg.CORBA.MARSHAL ;
 import org.omg.CORBA.TypeCodePackage.BadKind ;
 import org.omg.CORBA_2_3.portable.InputStream;
 import org.omg.CORBA_2_3.portable.OutputStream;
 import com.sun.corba.se.spi.ior.iiop.GIOPVersion;
 import com.sun.corba.se.spi.orb.ORB;
 import com.sun.corba.se.spi.logging.CORBALogDomains;
 import com.sun.corba.se.impl.encoding.OSFCodeSetRegistry;
 import com.sun.corba.se.impl.encoding.MarshalInputStream;
 import com.sun.corba.se.impl.encoding.CodeSetConversion;
 import com.sun.corba.se.impl.encoding.CDRInputStream;
 import com.sun.corba.se.impl.encoding.CDROutputStream;
 import com.sun.corba.se.impl.encoding.TypeCodeInputStream;
 import com.sun.corba.se.impl.encoding.TypeCodeOutputStream;
 import com.sun.corba.se.impl.encoding.TypeCodeReader;
 import com.sun.corba.se.impl.encoding.WrapperInputStream;
 import com.sun.corba.se.impl.logging.ORBUtilSystemException;
 // no chance of subclasses, so no problems with runtime helper lookup
 public final class TypeCodeImpl extends TypeCode
 {
     //static final boolean debug = false;
     // the indirection TCKind, needed for recursive typecodes.
     protected static final int tk_indirect = 0xFFFFFFFF;
     // typecode encodings have three different categories that determine
     // how the encoding should be done.
     private static final int EMPTY = 0; // no parameters
     private static final int SIMPLE = 1;        // simple parameters.
     private static final int COMPLEX = 2; // complex parameters. need to
     // use CDR encapsulation for
     // parameters
     // a table storing the encoding category for the various typecodes.
     private static final int typeTable[] = {
         EMPTY,  // tk_null
         EMPTY,  // tk_void
         EMPTY,  // tk_short
         EMPTY,  // tk_long
         EMPTY,  // tk_ushort
         EMPTY,  // tk_ulong
         EMPTY,  // tk_float
         EMPTY,  // tk_double
         EMPTY,  // tk_boolean
         EMPTY,  // tk_char
         EMPTY,  // tk_octet
         EMPTY,  // tk_any
         EMPTY,  // tk_typecode
         EMPTY,  // tk_principal
         COMPLEX,        // tk_objref
         COMPLEX,        // tk_struct
         COMPLEX,        // tk_union
         COMPLEX,        // tk_enum
         SIMPLE, // tk_string
         COMPLEX,        // tk_sequence
         COMPLEX,        // tk_array
         COMPLEX,        // tk_alias
         COMPLEX,        // tk_except
         EMPTY,  // tk_longlong
         EMPTY,  // tk_ulonglong
         EMPTY,  // tk_longdouble
         EMPTY,  // tk_wchar
         SIMPLE, // tk_wstring
         SIMPLE, // tk_fixed
         COMPLEX,        // tk_value
         COMPLEX,        // tk_value_box
         COMPLEX,        // tk_native
         COMPLEX // tk_abstract_interface
     };
     // Maps TCKind values to names
     // This is also used in AnyImpl.
     static final String[] kindNames = {
         "null",
         "void",
         "short",
         "long",
         "ushort",
         "ulong",
         "float",
         "double",
         "boolean",
         "char",
         "octet",
         "any",
         "typecode",
         "principal",
         "objref",
         "struct",
         "union",
         "enum",
         "string",
         "sequence",
         "array",
         "alias",
         "exception",
         "longlong",
         "ulonglong",
         "longdouble",
         "wchar",
         "wstring",
         "fixed",
         "value",
         "valueBox",
         "native",
         "abstractInterface"
     };
     private int                 _kind           = 0;    // the typecode kind
     // data members for representing the various kinds of typecodes.
     private String          _id             = "";   // the typecode repository id
     private String          _name           = "";   // the typecode name
     private int             _memberCount    = 0;    // member count
     private String          _memberNames[]  = null; // names of members
     private TypeCodeImpl    _memberTypes[]  = null; // types of members
     private AnyImpl         _unionLabels[]  = null; // values of union labels
     private TypeCodeImpl    _discriminator  = null; // union discriminator type
     private int             _defaultIndex   = -1;   // union default index
     private int             _length         = 0;    // string/seq/array length
     private TypeCodeImpl    _contentType    = null; // seq/array/alias type
     // fixed
     private short           _digits         = 0;
     private short           _scale          = 0;
     // value type
     // _REVISIT_ We might want to keep references to the ValueMember classes
     // passed in at initialization instead of copying the relevant data.
     // Is the data immutable? What about StructMember, UnionMember etc.?
     private short           _type_modifier  = -1;   // VM_NONE, VM_CUSTOM,
     // VM_ABSTRACT, VM_TRUNCATABLE
     private TypeCodeImpl    _concrete_base  = null; // concrete base type
     private short           _memberAccess[] = null; // visibility of ValueMember
     // recursive sequence support
     private TypeCodeImpl    _parent         = null; // the enclosing type code
     private int             _parentOffset   = 0;    // the level of enclosure
     // recursive type code support
     private TypeCodeImpl    _indirectType   = null;
     // caches the byte buffer written in write_value for quick remarshaling...
     private byte[] outBuffer                = null;
     // ... but only if caching is enabled
     private boolean cachingEnabled          = false;
     // the ORB instance: may be instanceof ORBSingleton or ORB
     private ORB _orb;
     private ORBUtilSystemException wrapper ;
     ///////////////////////////////////////////////////////////////////////////
     // Constructors...
     public TypeCodeImpl(ORB orb)
     {
         // initialized to tk_null
         _orb = orb;
         wrapper = ORBUtilSystemException.get(
             (com.sun.corba.se.spi.orb.ORB)orb, CORBALogDomains.RPC_PRESENTATION ) ;
     }
     public TypeCodeImpl(ORB orb, TypeCode tc)
     // to handle conversion of "remote" typecodes into "native" style.
     // also see the 'convertToNative(ORB orb, TypeCode tc)' function
     {
         this(orb) ;
         // This is a protection against misuse of this constructor.
         // Should only be used if tc is not an instance of this class!
         // Otherwise we run into problems with recursive/indirect type codes.
         // _REVISIT_ We should make this constructor private
         if (tc instanceof TypeCodeImpl) {
             TypeCodeImpl tci = (TypeCodeImpl)tc;
             if (tci._kind == tk_indirect)
                 throw wrapper.badRemoteTypecode() ;
             if (tci._kind == TCKind._tk_sequence && tci._contentType == null)
                 throw wrapper.badRemoteTypecode() ;
         }
         // set up kind
         _kind   = tc.kind().value();
         try {
             // set up parameters
             switch (_kind) {
             case TCKind._tk_value:
                 _type_modifier = tc.type_modifier();
                 // concrete base may be null
                 TypeCode tccb = tc.concrete_base_type();
                 if (tccb != null) {
                     _concrete_base = convertToNative(_orb, tccb);
                 } else {
                     _concrete_base = null;
                 }
                 //_memberAccess = tc._memberAccess;
                 // Need to reconstruct _memberAccess using member_count() and member_visibility()
                 _memberAccess = new short[tc.member_count()];
                 for (int i=0; i < tc.member_count(); i++) {
                     _memberAccess[i] = tc.member_visibility(i);
                 }
             case TCKind._tk_except:
             case TCKind._tk_struct:
             case TCKind._tk_union:
                 // set up member types
                 _memberTypes = new TypeCodeImpl[tc.member_count()];
                 for (int i=0; i < tc.member_count(); i++) {
                     _memberTypes[i] = convertToNative(_orb, tc.member_type(i));
                     _memberTypes[i].setParent(this);
                 }
             case TCKind._tk_enum:
                 // set up member names
                 _memberNames = new String[tc.member_count()];
                 for (int i=0; i < tc.member_count(); i++) {
                     _memberNames[i] = tc.member_name(i);
                 }
                 // set up member count
                 _memberCount = tc.member_count();
             case TCKind._tk_objref:
             case TCKind._tk_alias:
             case TCKind._tk_value_box:
             case TCKind._tk_native:
             case TCKind._tk_abstract_interface:
                 setId(tc.id());
                 _name = tc.name();
                 break;
             }
             // set up stuff for unions
             switch (_kind) {
             case TCKind._tk_union:
                 _discriminator = convertToNative(_orb, tc.discriminator_type());
                 _defaultIndex  = tc.default_index();
                 _unionLabels = new AnyImpl[_memberCount];
                 for (int i=0; i < _memberCount; i++)
                     _unionLabels[i] = new AnyImpl(_orb, tc.member_label(i));
                 break;
             }
             // set up length
             switch (_kind) {
             case TCKind._tk_string:
             case TCKind._tk_wstring:
             case TCKind._tk_sequence:
             case TCKind._tk_array:
                 _length = tc.length();
             }
             // set up content type
             switch (_kind) {
             case TCKind._tk_sequence:
             case TCKind._tk_array:
             case TCKind._tk_alias:
             case TCKind._tk_value_box:
                 _contentType = convertToNative(_orb, tc.content_type());
             }
         } catch (org.omg.CORBA.TypeCodePackage.Bounds e) {} catch (BadKind e) {}
         // dont have to worry about these since code ensures we dont step
         // out of bounds.
     }
     public TypeCodeImpl(ORB orb, int creationKind)
     // for primitive types
     {
         this(orb);
         // private API. dont bother checking that
         //     (creationKind < 0 || creationKind > typeTable.length)
         _kind = creationKind;
         // do initialization for special cases
         switch (_kind) {
         case TCKind._tk_objref:
             {
                 // this is being used to create typecode for CORBA::Object
                 setId("IDL:omg.org/CORBA/Object:1.0");
                 _name = "Object";
                 break;
             }
         case TCKind._tk_string:
         case TCKind._tk_wstring:
             {
                 _length =0;
                 break;
             }
         case TCKind._tk_value:
             {
                 _concrete_base = null;
                 break;
             }
         }
     }
     public TypeCodeImpl(ORB orb,
                         int creationKind,
                         String id,
                         String name,
                         StructMember[] members)
                         // for structs and exceptions
     {
         this(orb);
         if ((creationKind == TCKind._tk_struct) || (creationKind == TCKind._tk_except)) {
             _kind               = creationKind;
             setId(id);
             _name               = name;
             _memberCount        = members.length;
             _memberNames = new String[_memberCount];
             _memberTypes = new TypeCodeImpl[_memberCount];
             for (int i = 0 ; i < _memberCount ; i++) {
                 _memberNames[i] = members[i].name;
                 _memberTypes[i] = convertToNative(_orb, members[i].type);
                 _memberTypes[i].setParent(this);
             }
         } // else initializes to null
     }
     public TypeCodeImpl(ORB orb,
                         int creationKind,
                         String id,
                         String name,
                         TypeCode discriminator_type,
                         UnionMember[] members)
                         // for unions
     {
         this(orb) ;
         if (creationKind == TCKind._tk_union) {
             _kind               = creationKind;
             setId(id);
             _name               = name;
             _memberCount        = members.length;
             _discriminator      = convertToNative(_orb, discriminator_type);
             _memberNames = new String[_memberCount];
             _memberTypes = new TypeCodeImpl[_memberCount];
             _unionLabels = new AnyImpl[_memberCount];
             for (int i = 0 ; i < _memberCount ; i++) {
                 _memberNames[i] = members[i].name;
                 _memberTypes[i] = convertToNative(_orb, members[i].type);
                 _memberTypes[i].setParent(this);
                 _unionLabels[i] = new AnyImpl(_orb, members[i].label);
                 // check whether this is the default branch.
                 if (_unionLabels[i].type().kind() == TCKind.tk_octet) {
                     if (_unionLabels[i].extract_octet() == (byte)0) {
                         _defaultIndex = i;
                     }
                 }
             }
         } // else initializes to null
     }
     public TypeCodeImpl(ORB orb,
                         int creationKind,
                         String id,
                         String name,
                         short type_modifier,
                         TypeCode concrete_base,
                         ValueMember[] members)
                         // for value types
     {
         this(orb) ;
         if (creationKind == TCKind._tk_value) {
             _kind               = creationKind;
             setId(id);
             _name               = name;
             _type_modifier      = type_modifier;
             if (concrete_base != null) {
                 _concrete_base = convertToNative(_orb, concrete_base);
             }
             _memberCount        = members.length;
             _memberNames = new String[_memberCount];
             _memberTypes = new TypeCodeImpl[_memberCount];
             _memberAccess = new short[_memberCount];
             for (int i = 0 ; i < _memberCount ; i++) {
                 _memberNames[i] = members[i].name;
                 _memberTypes[i] = convertToNative(_orb, members[i].type);
                 _memberTypes[i].setParent(this);
                 _memberAccess[i] = members[i].access;
             }
         } // else initializes to null
     }
     public TypeCodeImpl(ORB orb,
                         int creationKind,
                         String id,
                         String name,
                         String[] members)
                         // for enums
     {
         this(orb) ;
         if (creationKind == TCKind._tk_enum)
             {
                 _kind           = creationKind;
                 setId(id);
                 _name           = name;
                 _memberCount    = members.length;
                 _memberNames = new String[_memberCount];
                 for (int i = 0 ; i < _memberCount ; i++)
                     _memberNames[i] = members[i];
             } // else initializes to null
     }
     public TypeCodeImpl(ORB orb,
                         int creationKind,
                         String id,
                         String name,
                         TypeCode original_type)
                         // for aliases and value boxes
     {
         this(orb) ;
         if ( creationKind == TCKind._tk_alias || creationKind == TCKind._tk_value_box )
             {
                 _kind           = creationKind;
                 setId(id);
                 _name           = name;
                 _contentType    = convertToNative(_orb, original_type);
             }
         // else initializes to null
     }
     public TypeCodeImpl(ORB orb,
                         int creationKind,
                         String id,
                         String name)
     {
         this(orb) ;
         if (creationKind == TCKind._tk_objref ||
             creationKind == TCKind._tk_native ||
             creationKind == TCKind._tk_abstract_interface)
             {
                 _kind           = creationKind;
                 setId(id);
                 _name           = name;
             } // else initializes to null
     }
     public TypeCodeImpl(ORB orb,
                         int creationKind,
                         int bound)
                         // for strings
     {
         this(orb) ;
         if (bound < 0)
             throw wrapper.negativeBounds() ;
         if ((creationKind == TCKind._tk_string) || (creationKind == TCKind._tk_wstring)) {
             _kind               = creationKind;
             _length             = bound;
         } // else initializes to null
     }
     public TypeCodeImpl(ORB orb,
                         int creationKind,
                         int bound,
                         TypeCode element_type)
                         // for sequences and arrays
     {
         this(orb) ;
         if ( creationKind == TCKind._tk_sequence || creationKind == TCKind._tk_array ) {
             _kind               = creationKind;
             _length             = bound;
             _contentType        = convertToNative(_orb, element_type);
         } // else initializes to null
     }
     public TypeCodeImpl(ORB orb,
                         int creationKind,
                         int bound,
                         int offset)
                         // for recursive sequences
     {
         this(orb) ;
         if (creationKind == TCKind._tk_sequence) {
             _kind               = creationKind;
             _length             = bound;
             _parentOffset       = offset;
         } // else initializes to null
     }
     public TypeCodeImpl(ORB orb,
                         String id)
                         // for recursive type codes
     {
         this(orb) ;
         _kind   = tk_indirect;
         // This is the type code of the type we stand in for, not our own.
         _id             = id;
         // Try to resolve it now. May return null in which case
         // we try again later (see indirectType()).
         tryIndirectType();
     }
     public TypeCodeImpl(ORB orb,
                         int creationKind,
                         short digits,
                         short scale)
                         // for fixed
     {
         this(orb) ;
         //if (digits < 1 || digits > 31)
         //throw new BAD_TYPECODE();
         if (creationKind == TCKind._tk_fixed) {
             _kind               = creationKind;
             _digits             = digits;
             _scale              = scale;
         } // else initializes to null
     }
     ///////////////////////////////////////////////////////////////////////////
     // Other creation functions...
     // Optimization:
     // If we checked for and returned constant primitive typecodes
     // here we could reduce object creation and also enable more
     // efficient typecode comparisons for primitive typecodes.
     //
     protected static TypeCodeImpl convertToNative(ORB orb,
                                                   TypeCode tc)
     {
         if (tc instanceof TypeCodeImpl)
             return (TypeCodeImpl) tc;
         else
             return new TypeCodeImpl(orb, tc);
     }
     public static CDROutputStream newOutputStream(ORB orb) {
         TypeCodeOutputStream tcos =
             sun.corba.OutputStreamFactory.newTypeCodeOutputStream(orb);
         //if (debug) System.out.println("Created TypeCodeOutputStream " + tcos +
         // " with no parent");
         return tcos;
     }
     // Support for indirect/recursive type codes
     private TypeCodeImpl indirectType() {
         _indirectType = tryIndirectType();
         if (_indirectType == null) {
             // Nothing we can do about that.
             throw wrapper.unresolvedRecursiveTypecode() ;
         }
         return _indirectType;
     }
     private TypeCodeImpl tryIndirectType() {
         // Assert that _kind == tk_indirect
         if (_indirectType != null)
             return _indirectType;
         setIndirectType(_orb.getTypeCode(_id));
         return _indirectType;
     }
     private void setIndirectType(TypeCodeImpl newType) {
         _indirectType = newType;
         if (_indirectType != null) {
             try {
                 _id = _indirectType.id();
             } catch (BadKind e) {
                 // can't happen
                 throw wrapper.badkindCannotOccur() ;
             }
         }
     }
     private void setId(String newID) {
         _id = newID;
         if (_orb instanceof TypeCodeFactory) {
             ((TypeCodeFactory)_orb).setTypeCode(_id, this);
         }
         // check whether return value != this which would indicate that the
         // repository id isn't unique.
     }
     private void setParent(TypeCodeImpl parent) {
         _parent = parent;
     }
     private TypeCodeImpl getParentAtLevel(int level) {
         if (level == 0)
             return this;
         if (_parent == null)
             throw wrapper.unresolvedRecursiveTypecode() ;
         return _parent.getParentAtLevel(level - 1);
     }
     private TypeCodeImpl lazy_content_type() {
         if (_contentType == null) {
             if (_kind == TCKind._tk_sequence && _parentOffset > 0 && _parent != null) {
                 // This is an unresolved recursive sequence tc.
                 // Try to resolve it now if the hierarchy is complete.
                 TypeCodeImpl realParent = getParentAtLevel(_parentOffset);
                 if (realParent != null && realParent._id != null) {
                     // Create a recursive type code object as the content type.
                     // This is when the recursive sequence typecode morphes
                     // into a sequence typecode containing a recursive typecode.
                     _contentType = new TypeCodeImpl((ORB)_orb, realParent._id);
                 }
             }
         }
         return _contentType;
     }
     // Other private functions
     private TypeCode realType(TypeCode aType) {
         TypeCode realType = aType;
         try {
             // Note: Indirect types are handled in kind() method
             while (realType.kind().value() == TCKind._tk_alias) {
                 realType = realType.content_type();
             }
         } catch (BadKind bad) {
             // impossible
             throw wrapper.badkindCannotOccur() ;
         }
         return realType;
     }
     ///////////////////////////////////////////////////////////////////////////
     // TypeCode operations
     public final boolean equal(TypeCode tc)
     // _REVISIT_ for all optional names/ids, we might want to check that
     // they are equal in case both are non-nil.
     {
         if (tc == this)
             return true;
         try {
             if (_kind == tk_indirect) {
                 //return indirectType().equal(tc);
                 if (_id != null && tc.id() != null)
                     return _id.equals(tc.id());
                 return (_id == null && tc.id() == null);
             }
             // make sure kinds are identical.
             if (_kind != tc.kind().value()) {
                 return false;
             }
             switch (typeTable[_kind]) {
             case EMPTY:
                 // no parameters to check.
                 return true;
             case SIMPLE:
                 switch (_kind) {
                 case TCKind._tk_string:
                 case TCKind._tk_wstring:
                     // check for bound.
                     return (_length == tc.length());
                 case TCKind._tk_fixed:
                     return (_digits == tc.fixed_digits() && _scale == tc.fixed_scale());
                 default:
                     return false;
                 }
             case COMPLEX:
                 switch(_kind) {
                 case TCKind._tk_objref:
                     {
                         // check for logical id.
                         if (_id.compareTo(tc.id()) == 0) {
                             return true;
                         }
                         if (_id.compareTo(
                             (_orb.get_primitive_tc(_kind)).id()) == 0)
                         {
                             return true;
                         }
                         if (tc.id().compareTo(
                             (_orb.get_primitive_tc(_kind)).id()) == 0)
                         {
                             return true;
                         }
                         return false;
                     }
                 case TCKind._tk_native:
                 case TCKind._tk_abstract_interface:
                     {
                         // check for logical id.
                         if (_id.compareTo(tc.id()) != 0) {
                             return false;
                         }
                         // ignore name since its optional.
                         return true;
                     }
                 case TCKind._tk_struct:
                 case TCKind._tk_except:
                     {
                         // check for member count
                         if (_memberCount != tc.member_count())
                             return false;
                         // check for repository id
                         if (_id.compareTo(tc.id()) != 0)
                             return false;
                         // check for member types.
                         for (int i = 0 ; i < _memberCount ; i++)
                             if (! _memberTypes[i].equal(tc.member_type(i)))
                                 return false;
                         // ignore id and names since those are optional.
                         return true;
                     }
                 case TCKind._tk_union:
                     {
                         // check for member count
                         if (_memberCount != tc.member_count())
                             return false;
                         // check for repository id
                         if (_id.compareTo(tc.id()) != 0)
                             return false;
                         // check for default index
                         if (_defaultIndex != tc.default_index())
                             return false;
                         // check for discriminator type
                         if (!_discriminator.equal(tc.discriminator_type()))
                             return false;
                         // check for label types and values
                         for (int i = 0 ; i < _memberCount ; i++)
                             if (! _unionLabels[i].equal(tc.member_label(i)))
                                 return false;
                         // check for branch types
                         for (int i = 0 ; i < _memberCount ; i++)
                             if (! _memberTypes[i].equal(tc.member_type(i)))
                                 return false;
                         // ignore id and names since those are optional.
                         return true;
                     }
                 case TCKind._tk_enum:
                     {
                         // check for repository id
                         if (_id.compareTo(tc.id()) != 0)
                             return false;
                         // check member count
                         if (_memberCount != tc.member_count())
                             return false;
                         // ignore names since those are optional.
                         return true;
                     }
                 case TCKind._tk_sequence:
                 case TCKind._tk_array:
                     {
                         // check bound/length
                         if (_length != tc.length()) {
                             return false;
                         }
                         // check content type
                         if (! lazy_content_type().equal(tc.content_type())) {
                             return false;
                         }
                         // ignore id and name since those are optional.
                         return true;
                     }
                 case TCKind._tk_value:
                     {
                         // check for member count
                         if (_memberCount != tc.member_count())
                             return false;
                         // check for repository id
                         if (_id.compareTo(tc.id()) != 0)
                             return false;
                         // check for member types.
                         for (int i = 0 ; i < _memberCount ; i++)
                             if (_memberAccess[i] != tc.member_visibility(i) ||
                                 ! _memberTypes[i].equal(tc.member_type(i)))
                                 return false;
                         if (_type_modifier == tc.type_modifier())
                             return false;
                         // concrete_base may be null
                         TypeCode tccb = tc.concrete_base_type();
                         if ((_concrete_base == null && tccb != null) ||
                             (_concrete_base != null && tccb == null) ||
                             ! _concrete_base.equal(tccb))
                         {
                             return false;
                         }
                         // ignore id and names since those are optional.
                         return true;
                     }
                 case TCKind._tk_alias:
                 case TCKind._tk_value_box:
                     {
                         // check for repository id
                         if (_id.compareTo(tc.id()) != 0) {
                             return false;
                         }
                         // check for equality with the true type
                         return _contentType.equal(tc.content_type());
                     }
                 }
             }
         } catch (org.omg.CORBA.TypeCodePackage.Bounds e) {} catch (BadKind e) {}
         // dont have to worry about these since the code ensures these dont
         // arise.
         return false;
     }
     /**
     * The equivalent operation is used by the ORB when determining type equivalence
     * for values stored in an IDL any.
     */
     public boolean equivalent(TypeCode tc) {
         if (tc == this) {
             return true;
         }
         // If the result of the kind operation on either TypeCode is tk_alias, recursively
         // replace the TypeCode with the result of calling content_type, until the kind
         // is no longer tk_alias.
         // Note: Always resolve indirect types first!
         TypeCode myRealType = (_kind == tk_indirect ? indirectType() : this);
         myRealType = realType(myRealType);
         TypeCode otherRealType = realType(tc);
         // If results of the kind operation on each typecode differ,
         // equivalent returns false.
         if (myRealType.kind().value() != otherRealType.kind().value()) {
             return false;
         }
         String myID = null;
         String otherID = null;
         try {
             myID = this.id();
             otherID = tc.id();
             // At this point the id operation is valid for both TypeCodes.
             // Return true if the results of id for both TypeCodes are non-empty strings
             // and both strings are equal.
             // If both ids are non-empty but are not equal, then equivalent returns FALSE.
             if (myID != null && otherID != null) {
                 return (myID.equals(otherID));
             }
         } catch (BadKind e) {
             // id operation is not valid for either or both TypeCodes
         }
         // If either or both id is an empty string, or the TypeCode kind does not support
         // the id operation, perform a structural comparison of the TypeCodes.
         int myKind = myRealType.kind().value();
         try {
             if (myKind == TCKind._tk_struct ||
                 myKind == TCKind._tk_union ||
                 myKind == TCKind._tk_enum ||
                 myKind == TCKind._tk_except ||
                 myKind == TCKind._tk_value)
             {
                 if (myRealType.member_count() != otherRealType.member_count())
                     return false;
             }
             if (myKind == TCKind._tk_union)
             {
                 if (myRealType.default_index() != otherRealType.default_index())
                     return false;
             }
             if (myKind == TCKind._tk_string ||
                 myKind == TCKind._tk_wstring ||
                 myKind == TCKind._tk_sequence ||
                 myKind == TCKind._tk_array)
             {
                 if (myRealType.length() != otherRealType.length())
                     return false;
             }
             if (myKind == TCKind._tk_fixed)
             {
                 if (myRealType.fixed_digits() != otherRealType.fixed_digits() ||
                     myRealType.fixed_scale() != otherRealType.fixed_scale())
                     return false;
             }
             if (myKind == TCKind._tk_union)
             {
                 for (int i=0; i<myRealType.member_count(); i++) {
                     if (myRealType.member_label(i) != otherRealType.member_label(i))
                         return false;
                 }
                 if ( ! myRealType.discriminator_type().equivalent(
                     otherRealType.discriminator_type()))
                     return false;
             }
             if (myKind == TCKind._tk_alias ||
                 myKind == TCKind._tk_value_box ||
                 myKind == TCKind._tk_sequence ||
                 myKind == TCKind._tk_array)
             {
                 if ( ! myRealType.content_type().equivalent(otherRealType.content_type()))
                     return false;
             }
             if (myKind == TCKind._tk_struct ||
                 myKind == TCKind._tk_union ||
                 myKind == TCKind._tk_except ||
                 myKind == TCKind._tk_value)
             {
                 for (int i=0; i<myRealType.member_count(); i++) {
                     if ( ! myRealType.member_type(i).equivalent(
                         otherRealType.member_type(i)))
                         return false;
                 }
             }
         } catch (BadKind e) {
             // impossible if we checked correctly above
             throw wrapper.badkindCannotOccur() ;
         } catch (org.omg.CORBA.TypeCodePackage.Bounds e) {
             // impossible if we checked correctly above
             throw wrapper.boundsCannotOccur() ;
         }
         // Structural comparison succeeded!
         return true;
     }
     public TypeCode get_compact_typecode() {
         // _REVISIT_ It isn't clear whether this method should operate on this or a copy.
         // For now just return this unmodified because the name and member_name fields
         // aren't used for comparison anyways.
         return this;
     }
     public TCKind kind()
     {
         if (_kind == tk_indirect)
             return indirectType().kind();
         return TCKind.from_int(_kind);
     }
     public boolean is_recursive()
     {
         // Recursive is the only form of indirect type codes right now.
         // Indirection can also be used for repeated type codes.
         return (_kind == tk_indirect);
     }
     public String id()
         throws BadKind
     {
         switch (_kind) {
         case tk_indirect:
             //return indirectType().id(); // same as _id
         case TCKind._tk_except:
         case TCKind._tk_objref:
         case TCKind._tk_struct:
         case TCKind._tk_union:
         case TCKind._tk_enum:
         case TCKind._tk_alias:
         case TCKind._tk_value:
         case TCKind._tk_value_box:
         case TCKind._tk_native:
         case TCKind._tk_abstract_interface:
             // exception and objref typecodes must have a repository id.
             // structs, unions, enums, and aliases may or may not.
             return _id;
         default:
             // all other typecodes throw the BadKind exception.
             throw new BadKind();
         }
     }
     public String name()
         throws BadKind
     {
         switch (_kind) {
         case tk_indirect:
             return indirectType().name();
         case TCKind._tk_except:
         case TCKind._tk_objref:
         case TCKind._tk_struct:
         case TCKind._tk_union:
         case TCKind._tk_enum:
         case TCKind._tk_alias:
         case TCKind._tk_value:
         case TCKind._tk_value_box:
         case TCKind._tk_native:
         case TCKind._tk_abstract_interface:
             return _name;
         default:
             throw new BadKind();
         }
     }
     public int member_count()
         throws BadKind
     {
         switch (_kind) {
         case tk_indirect:
             return indirectType().member_count();
         case TCKind._tk_except:
         case TCKind._tk_struct:
         case TCKind._tk_union:
         case TCKind._tk_enum:
         case TCKind._tk_value:
             return _memberCount;
         default:
             throw new BadKind();
         }
     }
     public String member_name(int index)
         throws BadKind, org.omg.CORBA.TypeCodePackage.Bounds
     {
         switch (_kind) {
         case tk_indirect:
             return indirectType().member_name(index);
         case TCKind._tk_except:
         case TCKind._tk_struct:
         case TCKind._tk_union:
         case TCKind._tk_enum:
         case TCKind._tk_value:
             try {
                 return _memberNames[index];
             } catch (ArrayIndexOutOfBoundsException e) {
                 throw new org.omg.CORBA.TypeCodePackage.Bounds();
             }
         default:
             throw new BadKind();
         }
     }
     public TypeCode member_type(int index)
         throws BadKind, org.omg.CORBA.TypeCodePackage.Bounds
     {
         switch (_kind) {
         case tk_indirect:
             return indirectType().member_type(index);
         case TCKind._tk_except:
         case TCKind._tk_struct:
         case TCKind._tk_union:
         case TCKind._tk_value:
             try {
                 return _memberTypes[index];
             } catch (ArrayIndexOutOfBoundsException e) {
                 throw new org.omg.CORBA.TypeCodePackage.Bounds();
             }
         default:
             throw new BadKind();
         }
     }
     public Any member_label(int index)
         throws BadKind, org.omg.CORBA.TypeCodePackage.Bounds
     {
         switch (_kind) {
         case tk_indirect:
             return indirectType().member_label(index);
         case TCKind._tk_union:
             try {
                 // _REVISIT_ Why create a new Any for this?
                 return new AnyImpl(_orb, _unionLabels[index]);
             } catch (ArrayIndexOutOfBoundsException e) {
                 throw new org.omg.CORBA.TypeCodePackage.Bounds();
             }
         default:
             throw new BadKind();
         }
     }
     public TypeCode discriminator_type()
         throws BadKind
     {
         switch (_kind) {
         case tk_indirect:
             return indirectType().discriminator_type();
         case TCKind._tk_union:
             return _discriminator;
         default:
             throw new BadKind();
         }
     }
     public int default_index()
         throws BadKind
     {
         switch (_kind) {
         case tk_indirect:
             return indirectType().default_index();
         case TCKind._tk_union:
             return _defaultIndex;
         default:
             throw new BadKind();
         }
     }
     public int length()
         throws BadKind
     {
         switch (_kind) {
         case tk_indirect:
             return indirectType().length();
         case TCKind._tk_string:
         case TCKind._tk_wstring:
         case TCKind._tk_sequence:
         case TCKind._tk_array:
             return _length;
         default:
             throw new BadKind();
         }
     }
     public TypeCode content_type()
         throws BadKind
     {
         switch (_kind) {
         case tk_indirect:
             return indirectType().content_type();
         case TCKind._tk_sequence:
             return lazy_content_type();
         case TCKind._tk_array:
         case TCKind._tk_alias:
         case TCKind._tk_value_box:
             return _contentType;
         default:
             throw new BadKind();
         }
     }
     public short fixed_digits() throws BadKind {
         switch (_kind) {
         case TCKind._tk_fixed:
             return _digits;
         default:
             throw new BadKind();
         }
     }
     public short fixed_scale() throws BadKind {
         switch (_kind) {
         case TCKind._tk_fixed:
             return _scale;
         default:
             throw new BadKind();
         }
     }
     public short member_visibility(int index) throws BadKind,
         org.omg.CORBA.TypeCodePackage.Bounds {
         switch (_kind) {
         case tk_indirect:
             return indirectType().member_visibility(index);
         case TCKind._tk_value:
             try {
                 return _memberAccess[index];
             } catch (ArrayIndexOutOfBoundsException e) {
                 throw new org.omg.CORBA.TypeCodePackage.Bounds();
             }
         default:
             throw new BadKind();
         }
     }
     public short type_modifier() throws BadKind {
         switch (_kind) {
         case tk_indirect:
             return indirectType().type_modifier();
         case TCKind._tk_value:
             return _type_modifier;
         default:
             throw new BadKind();
         }
     }
     public TypeCode concrete_base_type() throws BadKind {
         switch (_kind) {
         case tk_indirect:
             return indirectType().concrete_base_type();
         case TCKind._tk_value:
             return _concrete_base;
         default:
             throw new BadKind();
         }
     }
     public void read_value(InputStream is) {
         if (is instanceof TypeCodeReader) {
             // hardly possible unless caller knows our "private" stream classes.
             if (read_value_kind((TypeCodeReader)is))
                 read_value_body(is);
         } else if (is instanceof CDRInputStream) {
             WrapperInputStream wrapper = new WrapperInputStream((CDRInputStream)is);
             //if (debug) System.out.println("Created WrapperInputStream " + wrapper +
             // " with no parent");
             if (read_value_kind((TypeCodeReader)wrapper))
                 read_value_body(wrapper);
         } else {
             read_value_kind(is);
             read_value_body(is);
         }
     }
     private void read_value_recursive(TypeCodeInputStream is) {
         // don't wrap a CDRInputStream reading "inner" TypeCodes.
         if (is instanceof TypeCodeReader) {
             if (read_value_kind((TypeCodeReader)is))
                 read_value_body(is);
         } else {
             read_value_kind((InputStream)is);
             read_value_body(is);
         }
     }
     boolean read_value_kind(TypeCodeReader tcis)
     {
         _kind = tcis.read_long();
         // Bug fix 5034649: allow for padding that precedes the typecode kind.
         int myPosition = tcis.getTopLevelPosition()-4;
         // check validity of kind
         if ((_kind < 0 || _kind > typeTable.length) && _kind != tk_indirect) {
             throw wrapper.cannotMarshalBadTckind() ;
         }
         // Don't do any work if this is native
         if (_kind == TCKind._tk_native)
             throw wrapper.cannotMarshalNative() ;
         // We have to remember the stream and position for EVERY type code
         // in case some recursive or indirect type code references it.
         TypeCodeReader topStream = tcis.getTopLevelStream();
         if (_kind == tk_indirect) {
             int streamOffset = tcis.read_long();
             if (streamOffset > -4)
                 throw wrapper.invalidIndirection( new Integer(streamOffset) ) ;
             // The encoding used for indirection is the same as that used for recursive ,
             // TypeCodes i.e., a 0xffffffff indirection marker followed by a long offset
             // (in units of octets) from the beginning of the long offset.
             int topPos = tcis.getTopLevelPosition();
             // substract 4 to get back to the beginning of the long offset.
             int indirectTypePosition = topPos - 4 + streamOffset;
             // Now we have to find the referenced type
             // by its indirectTypePosition within topStream.
             //if (debug) System.out.println(
             // "TypeCodeImpl looking up indirection at position topPos " +
             //topPos + " - 4 + offset " + streamOffset + " = " + indirectTypePosition);
             TypeCodeImpl type = topStream.getTypeCodeAtPosition(indirectTypePosition);
             if (type == null)
                 throw wrapper.indirectionNotFound( new Integer(indirectTypePosition) ) ;
             setIndirectType(type);
             return false;
         }
         topStream.addTypeCodeAtPosition(this, myPosition);
         return true;
     }
     void read_value_kind(InputStream is) {
         // unmarshal the kind
         _kind = is.read_long();
         // check validity of kind
         if ((_kind < 0 || _kind > typeTable.length) && _kind != tk_indirect) {
             throw wrapper.cannotMarshalBadTckind() ;
         }
         // Don't do any work if this is native
         if (_kind == TCKind._tk_native)
             throw wrapper.cannotMarshalNative() ;
         if (_kind == tk_indirect) {
             throw wrapper.recursiveTypecodeError() ;
         }
     }
     void read_value_body(InputStream is) {
         // start unmarshaling the rest of the typecode, based on the
         // encoding (empty, simple or complex).
         switch (typeTable[_kind]) {
         case EMPTY:
             // nothing to unmarshal
             break;
         case SIMPLE:
             switch (_kind) {
             case TCKind._tk_string:
             case TCKind._tk_wstring:
                 _length = is.read_long();
                 break;
             case TCKind._tk_fixed:
                 _digits = is.read_ushort();
                 _scale = is.read_short();
                 break;
             default:
                 throw wrapper.invalidSimpleTypecode() ;
             }
             break;
         case COMPLEX:
             {
                 TypeCodeInputStream _encap = TypeCodeInputStream.readEncapsulation(is,
                     is.orb());
                 switch(_kind) {
                 case TCKind._tk_objref:
                 case TCKind._tk_abstract_interface:
                     {
                         // get the repository id
                         setId(_encap.read_string());
                         // get the name
                         _name = _encap.read_string();
                     }
                     break;
                 case TCKind._tk_union:
                     {
                         // get the repository id
                         setId(_encap.read_string());
                         // get the name
                         _name = _encap.read_string();
                         // discriminant typecode
                         _discriminator = new TypeCodeImpl((ORB)is.orb());
                         _discriminator.read_value_recursive(_encap);
                         // default index
                         _defaultIndex = _encap.read_long();
                         // get the number of members
                         _memberCount = _encap.read_long();
                         // create arrays for the label values, names and types of members
                         _unionLabels = new AnyImpl[_memberCount];
                         _memberNames = new String[_memberCount];
                         _memberTypes = new TypeCodeImpl[_memberCount];
                         // read off label values, names and types
                         for (int i=0; i < _memberCount; i++) {
                             _unionLabels[i] = new AnyImpl((ORB)is.orb());
                             if (i == _defaultIndex)
                                 // for the default case, read off the zero octet
                                 _unionLabels[i].insert_octet(_encap.read_octet());
                             else {
                                 switch (realType(_discriminator).kind().value()) {
                                 case TCKind._tk_short:
                                     _unionLabels[i].insert_short(_encap.read_short());
                                     break;
                                 case TCKind._tk_long:
                                     _unionLabels[i].insert_long(_encap.read_long());
                                     break;
                                 case TCKind._tk_ushort:
                                     _unionLabels[i].insert_ushort(_encap.read_short());
                                     break;
                                 case TCKind._tk_ulong:
                                     _unionLabels[i].insert_ulong(_encap.read_long());
                                     break;
                                 case TCKind._tk_float:
                                     _unionLabels[i].insert_float(_encap.read_float());
                                     break;
                                 case TCKind._tk_double:
                                     _unionLabels[i].insert_double(_encap.read_double());
                                     break;
                                 case TCKind._tk_boolean:
                                     _unionLabels[i].insert_boolean(_encap.read_boolean());
                                     break;
                                 case TCKind._tk_char:
                                     _unionLabels[i].insert_char(_encap.read_char());
                                     break;
                                 case TCKind._tk_enum:
                                     _unionLabels[i].type(_discriminator);
                                     _unionLabels[i].insert_long(_encap.read_long());
                                     break;
                                 case TCKind._tk_longlong:
                                     _unionLabels[i].insert_longlong(_encap.read_longlong());
                                     break;
                                 case TCKind._tk_ulonglong:
                                     _unionLabels[i].insert_ulonglong(_encap.read_longlong());
                                     break;
                                     // _REVISIT_ figure out long double mapping
                                     // case TCKind.tk_longdouble:
                                     // _unionLabels[i].insert_longdouble(_encap.getDouble());
                                     // break;
                                 case TCKind._tk_wchar:
                                     _unionLabels[i].insert_wchar(_encap.read_wchar());
                                     break;
                                 default:
                                     throw wrapper.invalidComplexTypecode() ;
                                 }
                             }
                             _memberNames[i] = _encap.read_string();
                             _memberTypes[i] = new TypeCodeImpl((ORB)is.orb());
                             _memberTypes[i].read_value_recursive(_encap);
                             _memberTypes[i].setParent(this);
                         }
                     }
                     break;
                 case TCKind._tk_enum:
                     {
                         // get the repository id
                         setId(_encap.read_string());
                         // get the name
                         _name = _encap.read_string();
                         // get the number of members
                         _memberCount = _encap.read_long();
                         // create arrays for the identifier names
                         _memberNames = new String[_memberCount];
                         // read off identifier names
                         for (int i=0; i < _memberCount; i++)
                             _memberNames[i] = _encap.read_string();
                     }
                     break;
                 case TCKind._tk_sequence:
                     {
                         // get the type of the sequence
                         _contentType = new TypeCodeImpl((ORB)is.orb());
                         _contentType.read_value_recursive(_encap);
                         // get the bound on the length of the sequence
                         _length = _encap.read_long();
                     }
                     break;
                 case TCKind._tk_array:
                     {
                         // get the type of the array
                         _contentType = new TypeCodeImpl((ORB)is.orb());
                         _contentType.read_value_recursive(_encap);
                         // get the length of the array
                         _length = _encap.read_long();
                     }
                     break;
                 case TCKind._tk_alias:
                 case TCKind._tk_value_box:
                     {
                         // get the repository id
                         setId(_encap.read_string());
                         // get the name
                         _name = _encap.read_string();
                         // get the type aliased
                         _contentType = new TypeCodeImpl((ORB)is.orb());
                         _contentType.read_value_recursive(_encap);
                     }
                     break;
                 case TCKind._tk_except:
                 case TCKind._tk_struct:
                     {
                         // get the repository id
                         setId(_encap.read_string());
                         // get the name
                         _name = _encap.read_string();
                         // get the number of members
                         _memberCount = _encap.read_long();
                         // create arrays for the names and types of members
                         _memberNames = new String[_memberCount];
                         _memberTypes = new TypeCodeImpl[_memberCount];
                         // read off member names and types
                         for (int i=0; i < _memberCount; i++) {
                             _memberNames[i] = _encap.read_string();
                             _memberTypes[i] = new TypeCodeImpl((ORB)is.orb());
                             //if (debug) System.out.println("TypeCode " + _name +
                             // " reading member " + _memberNames[i]);
                             _memberTypes[i].read_value_recursive(_encap);
                             _memberTypes[i].setParent(this);
                         }
                     }
                     break;
                 case TCKind._tk_value:
                     {
                         // get the repository id
                         setId(_encap.read_string());
                         // get the name
                         _name = _encap.read_string();
                         // get the type modifier
                         _type_modifier = _encap.read_short();
                         // get the type aliased
                         _concrete_base = new TypeCodeImpl((ORB)is.orb());
                         _concrete_base.read_value_recursive(_encap);
                         if (_concrete_base.kind().value() == TCKind._tk_null) {
                             _concrete_base = null;
                         }
                         // get the number of members
                         _memberCount = _encap.read_long();
                         // create arrays for the names, types and visibility of members
                         _memberNames = new String[_memberCount];
                         _memberTypes = new TypeCodeImpl[_memberCount];
                         _memberAccess = new short[_memberCount];
                         // read off value member visibilities
                         for (int i=0; i < _memberCount; i++) {
                             _memberNames[i] = _encap.read_string();
                             _memberTypes[i] = new TypeCodeImpl((ORB)is.orb());
                             //if (debug) System.out.println("TypeCode " + _name +
                             // " reading member " + _memberNames[i]);
                             _memberTypes[i].read_value_recursive(_encap);
                             _memberTypes[i].setParent(this);
                             _memberAccess[i] = _encap.read_short();
                         }
                     }
                     break;
                 default:
                     throw wrapper.invalidTypecodeKindMarshal() ;
                 }
                 break;
             }
         }
     }
     public void write_value(OutputStream os) {
         // Wrap OutputStream into TypeCodeOutputStream.
         // This test shouldn't be necessary according to the Java language spec.
         if (os instanceof TypeCodeOutputStream) {
             this.write_value((TypeCodeOutputStream)os);
         } else {
             TypeCodeOutputStream wrapperOutStream = null;
             if (outBuffer == null) {
                 wrapperOutStream = TypeCodeOutputStream.wrapOutputStream(os);
                 this.write_value(wrapperOutStream);
                 if (cachingEnabled) {
                     // Cache the buffer for repeated writes
                     outBuffer = wrapperOutStream.getTypeCodeBuffer();
                     //if (outBuffer != null)
                         //System.out.println("Caching outBuffer with length = " +
                         //outBuffer.length + " for id = " + _id);
                 }
             } else {
                 //System.out.println("Using cached outBuffer: length = " + outBuffer.length +
                                    //", id = " + _id);
             }
             // Write the first 4 bytes first to trigger alignment.
             // We know that it is the kind.
             if (cachingEnabled && outBuffer != null) {
                 os.write_long(_kind);
                 os.write_octet_array(outBuffer, 0, outBuffer.length);
             } else {
                 //System.out.println("Buffer is empty for " + _id);
                 wrapperOutStream.writeRawBuffer(os, _kind);
             }
         }
     }
     public void write_value(TypeCodeOutputStream tcos) {
         // Don't do any work if this is native
         if (_kind == TCKind._tk_native)
             throw wrapper.cannotMarshalNative() ;
         TypeCodeOutputStream topStream = tcos.getTopLevelStream();
         //if (debug) tcos.printBuffer();
         if (_kind == tk_indirect) {
             //if (debug) System.out.println("Writing indirection " + _name + "to " + _id);
             // The encoding used for indirection is the same as that used for recursive ,
             // TypeCodes i.e., a 0xffffffff indirection marker followed by a long offset
             // (in units of octets) from the beginning of the long offset.
             int pos = topStream.getPositionForID(_id);
             int topPos = tcos.getTopLevelPosition();
             //if (debug) System.out.println("TypeCodeImpl " + tcos +
             // " writing indirection " + _id +
                 //" to position " + pos + " at position " + topPos);
             tcos.writeIndirection(tk_indirect, pos);
             // All that gets written is _kind and offset.
             return;
         }
         // The original approach changed for 5034649
         // topStream.addIDAtPosition(_id, tcos.getTopLevelPosition());
         // marshal the kind
         tcos.write_long(_kind);
         //if (debug) System.out.println("Writing " + _name + " with id " + _id);
         // We have to remember the stream and position for EVERY type code
         // in case some recursive or indirect type code references it.
         //
         // Bug fix 5034649:
         // Do this AFTER the write of the _kind in case the alignment
         // for the long changes the position.
         topStream.addIDAtPosition(_id, tcos.getTopLevelPosition()-4);
         switch (typeTable[_kind]) {
         case EMPTY:
             // nothing more to marshal
             break;
         case SIMPLE:
             switch (_kind) {
             case TCKind._tk_string:
             case TCKind._tk_wstring:
                 // marshal the bound on string length
                 tcos.write_long(_length);
                 break;
             case TCKind._tk_fixed:
                 tcos.write_ushort(_digits);
                 tcos.write_short(_scale);
                 break;
             default:
                 // unknown typecode kind
                 throw wrapper.invalidSimpleTypecode() ;
             }
             break;
         case COMPLEX:
             {
                 // create an encapsulation
                 TypeCodeOutputStream _encap = tcos.createEncapsulation(tcos.orb());
                 switch(_kind) {
                 case TCKind._tk_objref:
                 case TCKind._tk_abstract_interface:
                     {
                         // put the repository id
                         _encap.write_string(_id);
                         // put the name
                         _encap.write_string(_name);
                     }
                     break;
                 case TCKind._tk_union:
                     {
                         // put the repository id
                         _encap.write_string(_id);
                         // put the name
                         _encap.write_string(_name);
                         // discriminant typecode
                         _discriminator.write_value(_encap);
                         // default index
                         _encap.write_long(_defaultIndex);
                         // put the number of members
                         _encap.write_long(_memberCount);
                         // marshal label values, names and types
                         for (int i=0; i < _memberCount; i++) {
                             // for the default case, marshal the zero octet
                             if (i == _defaultIndex)
                                 _encap.write_octet(_unionLabels[i].extract_octet());
                             else {
                                 switch (realType(_discriminator).kind().value()) {
                                 case TCKind._tk_short:
                                     _encap.write_short(_unionLabels[i].extract_short());
                                     break;
                                 case TCKind._tk_long:
                                     _encap.write_long(_unionLabels[i].extract_long());
                                     break;
                                 case TCKind._tk_ushort:
                                     _encap.write_short(_unionLabels[i].extract_ushort());
                                     break;
                                 case TCKind._tk_ulong:
                                     _encap.write_long(_unionLabels[i].extract_ulong());
                                     break;
                                 case TCKind._tk_float:
                                     _encap.write_float(_unionLabels[i].extract_float());
                                     break;
                                 case TCKind._tk_double:
                                     _encap.write_double(_unionLabels[i].extract_double());
                                     break;
                                 case TCKind._tk_boolean:
                                     _encap.write_boolean(_unionLabels[i].extract_boolean());
                                     break;
                                 case TCKind._tk_char:
                                     _encap.write_char(_unionLabels[i].extract_char());
                                     break;
                                 case TCKind._tk_enum:
                                     _encap.write_long(_unionLabels[i].extract_long());
                                     break;
                                 case TCKind._tk_longlong:
                                     _encap.write_longlong(_unionLabels[i].extract_longlong());
                                     break;
                                 case TCKind._tk_ulonglong:
                                     _encap.write_longlong(_unionLabels[i].extract_ulonglong());
                                     break;
                                     // _REVISIT_ figure out long double mapping
                                     // case TCKind.tk_longdouble:
                                     // _encap.putDouble(_unionLabels[i].extract_longdouble());
                                     // break;
                                 case TCKind._tk_wchar:
                                     _encap.write_wchar(_unionLabels[i].extract_wchar());
                                     break;
                                 default:
                                     throw wrapper.invalidComplexTypecode() ;
                                 }
                             }
                             _encap.write_string(_memberNames[i]);
                             _memberTypes[i].write_value(_encap);
                         }
                     }
                     break;
                 case TCKind._tk_enum:
                     {
                         // put the repository id
                         _encap.write_string(_id);
                         // put the name
                         _encap.write_string(_name);
                         // put the number of members
                         _encap.write_long(_memberCount);
                         // marshal identifier names
                         for (int i=0; i < _memberCount; i++)
                             _encap.write_string(_memberNames[i]);
                     }
                     break;
                 case TCKind._tk_sequence:
                     {
                         // put the type of the sequence
                         lazy_content_type().write_value(_encap);
                         // put the bound on the length of the sequence
                         _encap.write_long(_length);
                     }
                     break;
                 case TCKind._tk_array:
                     {
                         // put the type of the array
                         _contentType.write_value(_encap);
                         // put the length of the array
                         _encap.write_long(_length);
                     }
                     break;
                 case TCKind._tk_alias:
                 case TCKind._tk_value_box:
                     {
                         // put the repository id
                         _encap.write_string(_id);
                         // put the name
                         _encap.write_string(_name);
                         // put the type aliased
                         _contentType.write_value(_encap);
                     }
                     break;
                 case TCKind._tk_struct:
                 case TCKind._tk_except:
                     {
                         // put the repository id
                         _encap.write_string(_id);
                         // put the name
                         _encap.write_string(_name);
                         // put the number of members
                         _encap.write_long(_memberCount);
                         // marshal member names and types
                         for (int i=0; i < _memberCount; i++) {
                             _encap.write_string(_memberNames[i]);
                             //if (debug) System.out.println("TypeCode " + _name +
                             // " writing member " + _memberNames[i]);
                             _memberTypes[i].write_value(_encap);
                         }
                     }
                     break;
                 case TCKind._tk_value:
                     {
                         // put the repository id
                         _encap.write_string(_id);
                         // put the name
                         _encap.write_string(_name);
                         // put the type modifier
                         _encap.write_short(_type_modifier);
                         // put the type aliased
                         if (_concrete_base == null) {
                             _orb.get_primitive_tc(TCKind._tk_null).write_value(_encap);
                         } else {
                             _concrete_base.write_value(_encap);
                         }
                         // put the number of members
                         _encap.write_long(_memberCount);
                         // marshal member names and types
                         for (int i=0; i < _memberCount; i++) {
                             _encap.write_string(_memberNames[i]);
                             //if (debug) System.out.println("TypeCode " + _name +
                             // " writing member " + _memberNames[i]);
                             _memberTypes[i].write_value(_encap);
                             _encap.write_short(_memberAccess[i]);
                         }
                     }
                     break;
                 default:
                     throw wrapper.invalidTypecodeKindMarshal() ;
                 }
                 // marshal the encapsulation
                 _encap.writeOctetSequenceTo(tcos);
                 break;
             }
         }
     }
     /**
      * This is not a copy of the TypeCodeImpl objects, but instead it
      * copies the value this type code is representing.
      * See AnyImpl read_value and write_value for usage.
      * The state of this TypeCodeImpl instance isn't changed, only used
      * by the Any to do the correct copy.
      */
     protected void copy(org.omg.CORBA.portable.InputStream src,
         org.omg.CORBA.portable.OutputStream dst)
     {
         switch (_kind) {
         case TCKind._tk_null:
         case TCKind._tk_void:
         case TCKind._tk_native:
         case TCKind._tk_abstract_interface:
             break;
         case TCKind._tk_short:
         case TCKind._tk_ushort:
             dst.write_short(src.read_short());
             break;
         case TCKind._tk_long:
         case TCKind._tk_ulong:
             dst.write_long(src.read_long());
             break;
         case TCKind._tk_float:
             dst.write_float(src.read_float());
             break;
         case TCKind._tk_double:
             dst.write_double(src.read_double());
             break;
         case TCKind._tk_longlong:
         case TCKind._tk_ulonglong:
             dst.write_longlong(src.read_longlong());
             break;
         case TCKind._tk_longdouble:
             throw wrapper.tkLongDoubleNotSupported() ;
         case TCKind._tk_boolean:
             dst.write_boolean(src.read_boolean());
             break;
         case TCKind._tk_char:
             dst.write_char(src.read_char());
             break;
         case TCKind._tk_wchar:
             dst.write_wchar(src.read_wchar());
             break;
         case TCKind._tk_octet:
             dst.write_octet(src.read_octet());
             break;
         case TCKind._tk_string:
             {
                 String s;
                 s = src.read_string();
                 // make sure length bound in typecode is not violated
                 if ((_length != 0) && (s.length() > _length))
                     throw wrapper.badStringBounds( new Integer(s.length()),
                         new Integer(_length) ) ;
                 dst.write_string(s);
             }
             break;
         case TCKind._tk_wstring:
             {
                 String s;
                 s = src.read_wstring();
                 // make sure length bound in typecode is not violated
                 if ((_length != 0) && (s.length() > _length))
                     throw wrapper.badStringBounds( new Integer(s.length()),
                         new Integer(_length) ) ;
                 dst.write_wstring(s);
             }
             break;
         case TCKind._tk_fixed:
             {
                 dst.write_ushort(src.read_ushort());
                 dst.write_short(src.read_short());
             }
             break;
         case TCKind._tk_any:
             {
                 //Any tmp = new AnyImpl(_orb);
                 Any tmp =  ((CDRInputStream)src).orb().create_any();
                 TypeCodeImpl t = new TypeCodeImpl((ORB)dst.orb());
                 t.read_value((org.omg.CORBA_2_3.portable.InputStream)src);
                 t.write_value((org.omg.CORBA_2_3.portable.OutputStream)dst);
                 tmp.read_value(src, t);
                 tmp.write_value(dst);
                 break;
             }
         case TCKind._tk_TypeCode:
             {
                 dst.write_TypeCode(src.read_TypeCode());
                 break;
             }
         case TCKind._tk_Principal:
             {
                 dst.write_Principal(src.read_Principal());
                 break;
             }
         case TCKind._tk_objref:
             {
                 dst.write_Object(src.read_Object());
                 break;
             }
         case TCKind._tk_except:
             // Copy repositoryId
             dst.write_string(src.read_string());
             // Fall into ...
         // _REVISIT_ what about the inherited members of this values concrete base type?
         case TCKind._tk_value:
         case TCKind._tk_struct:
             {
                 // copy each element, using the corresponding member type
                 for (int i=0; i < _memberTypes.length; i++) {
                     _memberTypes[i].copy(src, dst);
                 }
                 break;
             }
         case TCKind._tk_union:
     /* _REVISIT_ More generic code?
             {
                 Any discriminator = new AnyImpl(_orb);
                 discriminator.read_value(src, _discriminator);
                 discriminator.write_value(dst);
                 int labelIndex = currentUnionMemberIndex(discriminator);
                 if (labelIndex == -1) {
                     // check if label has not been found
                     if (_defaultIndex == -1)
                         // throw exception if default was not expected
                         throw new MARSHAL();
                     else
                         // must be of the default branch type
                         _memberTypes[_defaultIndex].copy(src, dst);
                 } else {
                     _memberTypes[labelIndex].copy(src, dst);
                 }
             }
     */
             {
                 Any tagValue = new AnyImpl( (ORB)src.orb());
                 switch  (realType(_discriminator).kind().value()) {
                 case TCKind._tk_short:
                     {
                         short value = src.read_short();
                         tagValue.insert_short(value);
                         dst.write_short(value);
                         break;
                     }
                 case TCKind._tk_long:
                     {
                         int value = src.read_long();
                         tagValue.insert_long(value);
                         dst.write_long(value);
                         break;
                     }
                 case TCKind._tk_ushort:
                     {
                         short value = src.read_short();
                         tagValue.insert_ushort(value);
                         dst.write_short(value);
                         break;
                     }
                 case TCKind._tk_ulong:
                     {
                         int value = src.read_long();
                         tagValue.insert_ulong(value);
                         dst.write_long(value);
                         break;
                     }
                 case TCKind._tk_float:
                     {
                         float value = src.read_float();
                         tagValue.insert_float(value);
                         dst.write_float(value);
                         break;
                     }
                 case TCKind._tk_double:
                     {
                         double value = src.read_double();
                         tagValue.insert_double(value);
                         dst.write_double(value);
                         break;
                     }
                 case TCKind._tk_boolean:
                     {
                         boolean value = src.read_boolean();
                         tagValue.insert_boolean(value);
                         dst.write_boolean(value);
                         break;
                     }
                 case TCKind._tk_char:
                     {
                         char value = src.read_char();
                         tagValue.insert_char(value);
                         dst.write_char(value);
                         break;
                     }
                 case TCKind._tk_enum:
                     {
                         int value = src.read_long();
                         tagValue.type(_discriminator);
                         tagValue.insert_long(value);
                         dst.write_long(value);
                         break;
                     }
                 case TCKind._tk_longlong:
                     {
                         long value = src.read_longlong();
                         tagValue.insert_longlong(value);
                         dst.write_longlong(value);
                         break;
                     }
                 case TCKind._tk_ulonglong:
                     {
                         long value = src.read_longlong();
                         tagValue.insert_ulonglong(value);
                         dst.write_longlong(value);
                         break;
                     }
                     // _REVISIT_ figure out long double mapping
                     // case TCKind.tk_longdouble:
                     // {
                     // double value = src.read_double();
                     //  tagValue.insert_longdouble(value);
                     //  dst.putDouble(value);
                     //  break;
                     //}
                 case TCKind._tk_wchar:
                     {
                         char value = src.read_wchar();
                         tagValue.insert_wchar(value);
                         dst.write_wchar(value);
                         break;
                     }
                 default:
                     throw wrapper.illegalUnionDiscriminatorType() ;
                 }
                 // using the value of the tag, find out the type of the value
                 // following.
                 int labelIndex;
                 for (labelIndex = 0; labelIndex < _unionLabels.length; labelIndex++) {
                     // use equality over anys
                     if (tagValue.equal(_unionLabels[labelIndex])) {
                         _memberTypes[labelIndex].copy(src, dst);
                         break;
                     }
                 }
                 if (labelIndex == _unionLabels.length) {
                     // check if label has not been found
                     if (_defaultIndex != -1)
                         // must be of the default branch type
                         _memberTypes[_defaultIndex].copy(src, dst);
                 }
                 break;
             }
         case TCKind._tk_enum:
             dst.write_long(src.read_long());
             break;
         case TCKind._tk_sequence:
             // get the length of the sequence
             int seqLength = src.read_long();
             // check for sequence bound violated
             if ((_length != 0) && (seqLength > _length))
                 throw wrapper.badSequenceBounds( new Integer(seqLength),
                     new Integer(_length) ) ;
             // write the length of the sequence
             dst.write_long(seqLength);
             // copy each element of the seq using content type
             lazy_content_type(); // make sure it's resolved
             for (int i=0; i < seqLength; i++)
                 _contentType.copy(src, dst);
             break;
         case TCKind._tk_array:
             // copy each element of the array using content type
             for (int i=0; i < _length; i++)
                 _contentType.copy(src, dst);
             break;
         case TCKind._tk_alias:
         case TCKind._tk_value_box:
             // follow the alias
             _contentType.copy(src, dst);
             break;
         case tk_indirect:
             // need to follow offset, get unmarshal typecode from that
             // offset, and use that to do the copy
             // Don't need to read type code before using it to do the copy.
             // It should be fully usable.
             indirectType().copy(src, dst);
             break;
         default:
             throw wrapper.invalidTypecodeKindMarshal() ;
         }
     }
     static protected short digits(java.math.BigDecimal value) {
         if (value == null)
             return 0;
         short length = (short)value.unscaledValue().toString().length();
         if (value.signum() == -1)
             length--;
         return length;
     }
     static protected short scale(java.math.BigDecimal value) {
         if (value == null)
             return 0;
         return (short)value.scale();
     }
     // Utility methods
     // Only for union type. Returns the index of the union member
     // corresponding to the discriminator. If not found returns the
     // default index or -1 if there is no default index.
     int currentUnionMemberIndex(Any discriminatorValue) throws BadKind {
         if (_kind != TCKind._tk_union)
             throw new BadKind();
         try {
             for (int i=0; i<member_count(); i++) {
                 if (member_label(i).equal(discriminatorValue)) {
                     return i;
                 }
             }
             if (_defaultIndex != -1) {
                 return _defaultIndex;
             }
         } catch (BadKind bad) {
         } catch (org.omg.CORBA.TypeCodePackage.Bounds bounds) {
         }
         return -1;
     }
     public String description() {
         return "TypeCodeImpl with kind " + _kind + " and id " + _id;
     }
     public String toString() {
         ByteArrayOutputStream byteOut = new ByteArrayOutputStream(1024);
         PrintStream printOut = new PrintStream(byteOut, true);
         printStream(printOut);
         return super.toString() + " =\n" + byteOut.toString();
     }
     public void printStream(PrintStream s) {
         printStream(s, 0);
     }
     private void printStream(PrintStream s, int level) {
         if (_kind == tk_indirect) {
             s.print("indirect " + _id);
             return;
         }
         switch (_kind) {
             case TCKind._tk_null:
             case TCKind._tk_void:
             case TCKind._tk_short:
             case TCKind._tk_long:
             case TCKind._tk_ushort:
             case TCKind._tk_ulong:
             case TCKind._tk_float:
             case TCKind._tk_double:
             case TCKind._tk_boolean:
             case TCKind._tk_char:
             case TCKind._tk_octet:
             case TCKind._tk_any:
             case TCKind._tk_TypeCode:
             case TCKind._tk_Principal:
             case TCKind._tk_objref:
             case TCKind._tk_longlong:
             case TCKind._tk_ulonglong:
             case TCKind._tk_longdouble:
             case TCKind._tk_wchar:
             case TCKind._tk_native:
                 s.print(kindNames[_kind] + " " + _name);
                 break;
             case TCKind._tk_struct:
             case TCKind._tk_except:
             case TCKind._tk_value:
                 s.println(kindNames[_kind] + " " + _name + " = {");
                 for(int i=0; i<_memberCount; i++) {
                     // memberName might differ from the name of the member.
                     s.print(indent(level + 1));
                     if (_memberTypes[i] != null)
                         _memberTypes[i].printStream(s, level + 1);
                     else
                         s.print("<unknown type>");
                     s.println(" " + _memberNames[i] + ";");
                 }
                 s.print(indent(level) + "}");
                 break;
             case TCKind._tk_union:
                 s.print("union " + _name + "...");
                 break;
             case TCKind._tk_enum:
                 s.print("enum " + _name + "...");
                 break;
             case TCKind._tk_string:
                 if (_length == 0)
                     s.print("unbounded string " + _name);
                 else
                     s.print("bounded string(" + _length + ") " + _name);
                 break;
             case TCKind._tk_sequence:
             case TCKind._tk_array:
                 s.println(kindNames[_kind] + "[" + _length + "] " + _name + " = {");
                 s.print(indent(level + 1));
                 if (lazy_content_type() != null) {
                     lazy_content_type().printStream(s, level + 1);
                 }
                 s.println(indent(level) + "}");
                 break;
             case TCKind._tk_alias:
                 s.print("alias " + _name + " = " +
                     (_contentType != null ? _contentType._name : "<unresolved>"));
                 break;
             case TCKind._tk_wstring:
                 s.print("wstring[" + _length + "] " + _name);
                 break;
             case TCKind._tk_fixed:
                 s.print("fixed(" + _digits + ", " + _scale + ") " + _name);
                 break;
             case TCKind._tk_value_box:
                 s.print("valueBox " + _name + "...");
                 break;
             case TCKind._tk_abstract_interface:
                 s.print("abstractInterface " + _name + "...");
                 break;
             default:
                 s.print("<unknown type>");
                 break;
         }
     }
     private String indent(int level) {
         String indent = "";
         for(int i=0; i<level; i++) {
             indent += "  ";
         }
         return indent;
     }
     protected void setCaching(boolean enableCaching) {
         cachingEnabled = enableCaching;
         if (enableCaching == false)
             outBuffer = null;
     }
 }

Mercurial > jdk8-mips64-public > corba / annotate

src/share/classes/com/sun/corba/se/impl/corba/TypeCodeImpl.java@6845b95cba6b (annotated)

src/share/classes/com/sun/corba/se/impl/corba/TypeCodeImpl.java