/*
* @(#)TypeCodeImpl.java 1.96 06/08/28
*
* Copyright 2006 Sun Microsystems, Inc. All rights reserved.
* SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*/
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 = new TypeCodeOutputStream((ORB)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)
// 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() ;
}
}
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;
}
}
|
