public TypeCodeImpl(ORB orb) 
{
    ///////////////////////////////////////////////////////////////////////////
    // Constructors...
        // 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) 
{
        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) 
{
        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,
    String id) 
{
        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,
    int bound) 
{
        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,
    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,
    TypeCode element_type) 
{
        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) 
{
        this(orb) ;
        if (creationKind == TCKind._tk_sequence) {
            _kind               = creationKind;
            _length             = bound;
            _parentOffset       = offset;
        } // else initializes to null
}

 public TypeCodeImpl(ORB orb,
    int creationKind,
    short digits,
    short scale) 
{
        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
}

 public TypeCodeImpl(ORB orb,
    int creationKind,
    String id,
    String name,
    StructMember[] members) 
{
        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,
    String[] members) 
{
        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) 
{
        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,
    TypeCode discriminator_type,
    UnionMember[] members) 
{
        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) 
{
        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 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 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();
        }
}

 protected static TypeCodeImpl convertToNative(ORB orb,
    TypeCode tc) 
{
        if (tc instanceof TypeCodeImpl)
            return (TypeCodeImpl) tc;
        else
            return new TypeCodeImpl(orb, tc);
}

 protected  void copy(InputStream src,
    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)
                        // throw exception if default was not expected
                        throw wrapper.unexpectedUnionDefault() ;
                    else
                        // 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() ;
        }
}

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.

 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 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 String description() 
{
        return "TypeCodeImpl with kind " + _kind + " and id " + _id;
}

 protected static short digits(BigDecimal value) 
{
        if (value == null)
            return 0;
        short length = (short)value.unscaledValue().toString().length();
        if (value.signum() == -1)
            length--;
        return length;
}

 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 final boolean equal(TypeCode tc) 
{
        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;
}

 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;
}

The equivalent operation is used by the ORB when determining type equivalence for values stored in an IDL any.

 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 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 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 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 TCKind kind() 
{
        if (_kind == tk_indirect)
            return indirectType().kind();
        return TCKind.from_int(_kind);
}

 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 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 Any member_label(int index) throws BadKind, 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 String member_name(int index) throws BadKind, 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, 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 short member_visibility(int index) throws BadKind, 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 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 static CDROutputStream newOutputStream(ORB orb) 
{
        TypeCodeOutputStream tcos = new TypeCodeOutputStream((ORB)orb);
        //if (debug) System.out.println("Created TypeCodeOutputStream " + tcos +
        // " with no parent");
        return tcos;
}

 public  void printStream(PrintStream s) 
{
        printStream(s, 0);
}

 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);
        }
}

  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;
            }
        }
}

 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() ;
        }
}

 protected static short scale(BigDecimal value) 
{
        if (value == null)
            return 0;
        return (short)value.scale();
}

 protected  void setCaching(boolean enableCaching) 
{
        cachingEnabled = enableCaching;
        if (enableCaching == false)
            outBuffer = null;
}

 public String toString() 
{
        ByteArrayOutputStream byteOut = new ByteArrayOutputStream(1024);
        PrintStream printOut = new PrintStream(byteOut, true);
        printStream(printOut);
        return super.toString() + " =\n" + byteOut.toString();
}

 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  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;
            }
        }
}