/**
* entry method to the TypeCode reader logic
*
* @param logger used to log informational/debug information
* @param in the InputStream from which should be read from
* @param recursiveTCMap Map that should be used to store the buffer positions of not completely
* read in TypeCodes
* @param repeatedTCMap Map that should be used to store the buffer positions of completely read
* in TypeCodes
*/
public TypeCode readTypeCode(
Logger logger, CDRInputStream in, Map recursiveTCMap, Map repeatedTCMap) {
in.mark(0);
final int kind = in.read_long();
final int start_pos = in.get_pos() - 4;
try {
in.reset();
} catch (IOException e) {
assert false;
throw new RuntimeException("should not happen");
}
if (logger.isDebugEnabled()) {
logger.debug(
in.getIndentString() + "read TypeCode kind " + kind + " at startposition " + start_pos);
}
final TypeCode result = doReadTypeCode(in, recursiveTCMap, repeatedTCMap, kind);
if (logger.isDebugEnabled()) {
logger.debug(
in.getIndentString()
+ "return "
+ result
+ " ("
+ result.getClass().getName()
+ "@"
+ System.identityHashCode(result)
+ ")");
}
return result;
}
/**
* check that a type is a legal member type (cf. CORBA 2.4 chapter 10, section 7.3
*
* @throws org.omg.CORBA.BAD_PARAM
*/
private void checkTCMemberType(TypeCode typeCode) throws BAD_TYPECODE {
if (!org.jacorb.orb.TypeCode.isRecursive(typeCode)
&& (typeCode == null
|| typeCode.kind().value() == TCKind._tk_null
|| typeCode.kind().value() == TCKind._tk_void
|| typeCode.kind().value() == TCKind._tk_except)) {
throw new BAD_TYPECODE("Illegal member TypeCode", 2, CompletionStatus.COMPLETED_NO);
}
}
/* */ private TypeCode realType(TypeCode paramTypeCode) {
/* 227 */ TypeCode localTypeCode = paramTypeCode;
/* */ try
/* */ {
/* 230 */ while (localTypeCode.kind().value() == 21)
/* 231 */ localTypeCode = localTypeCode.content_type();
/* */ }
/* */ catch (BadKind localBadKind) {
/* 234 */ throw this.wrapper.badkindCannotOccur(localBadKind);
/* */ }
/* 236 */ return localTypeCode;
/* */ }
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(bad);
}
return realType;
}
/**
* Dumps the description of a given wstring TypeCode.
*
* @param type the <code>TypeCode</code>
* @param output the output stream where the TypeCode will be dumped
* @pre <code>type</code> must be an wstring type.
*/
public static void dump(TypeCode type, java.io.PrintWriter output) throws java.io.IOException {
output.print("[TYPECODE]{wstring");
try {
if (type.length() != 0) {
output.print('<');
output.print(type.length());
output.print('>');
}
} catch (BadKind bk) {
throw new BAD_TYPECODE("Fault in length() operation:" + bk.toString());
}
output.print('}');
}
/** A variant of the insertion operation that takes a typecode argument as well. */
public void insert_Object(org.omg.CORBA.Object o, TypeCode tc) {
// debug.log ("insert_Object2");
try {
if (tc.id().equals("IDL:omg.org/CORBA/Object:1.0") || o._is_a(tc.id())) {
typeCode = TypeCodeImpl.convertToNative(orb, tc);
object = o;
} else {
throw wrapper.insertObjectIncompatible();
}
} catch (Exception ex) {
throw wrapper.insertObjectFailed(ex);
}
isInitialized = true;
}
private static boolean isSystemExceptionTypeCode(TypeCode type, ORB orb) {
StructMember[] systemExceptionMembers = systemExceptionMembers(orb);
try {
return (type.kind().value() == TCKind._tk_except
&& type.member_count() == 3
&& type.member_type(0).equal(systemExceptionMembers[0].type)
&& type.member_type(1).equal(systemExceptionMembers[1].type)
&& type.member_type(2).equal(systemExceptionMembers[2].type));
} catch (BadKind ex) {
return false;
} catch (org.omg.CORBA.TypeCodePackage.Bounds ex) {
return false;
}
}
/* */ public void insert_fixed(BigDecimal paramBigDecimal, TypeCode paramTypeCode)
/* */ {
/* */ try {
/* 1184 */ if ((TypeCodeImpl.digits(paramBigDecimal) > paramTypeCode.fixed_digits())
|| (TypeCodeImpl.scale(paramBigDecimal) > paramTypeCode.fixed_scale()))
/* */ {
/* 1187 */ throw this.wrapper.fixedNotMatch();
/* */ }
/* */ }
/* */ catch (BadKind localBadKind) {
/* 1191 */ throw this.wrapper.fixedBadTypecode(localBadKind);
/* */ }
/* 1193 */ this.typeCode = TypeCodeImpl.convertToNative(this.orb, paramTypeCode);
/* 1194 */ this.object = paramBigDecimal;
/* 1195 */ this.isInitialized = true;
/* */ }
// This is used by the Any type when trying to re-construct the type stored inside a
// CORBA Any.
public QName getIdlType(TypeCode tc) {
String repId = null;
try {
repId = tc.id();
} catch (org.omg.CORBA.TypeCodePackage.BadKind ex) {
// No id has been set.
return null;
}
if (repId == null) {
return null;
}
Set<Map.Entry<String, CorbaTypeImpl>> mapSet = typeMap.entrySet();
for (Iterator<Map.Entry<String, CorbaTypeImpl>> i = mapSet.iterator(); i.hasNext(); ) {
Map.Entry<String, CorbaTypeImpl> entry = i.next();
if (entry.getValue() instanceof NamedType) {
NamedType n = (NamedType) entry.getValue();
if (n.getRepositoryID().equals(repId)) {
return new QName(getTargetNamespace(), entry.getKey());
}
}
}
return null;
}
/**
* Dumps the description of a the marshaled value of a given TypeCode.
*
* @param type the <code>TypeCode</code>
* @param input the input stream where the value is marshaled
* @param output the output stream where the value will be dumped
* @pre the typecode must be a wstring type
* @return <code>true</code> if if has been possible dump the value.
*/
public static boolean dumpValue(TypeCode type, InputStream input, java.io.PrintWriter output)
throws java.io.IOException {
output.print("[VALUE]{wstring");
try {
if (type.length() != 0) {
output.print('<');
output.print(type.length());
output.print('>');
}
} catch (BadKind bk) {
throw new BAD_TYPECODE("Fault in length() operation:" + bk.toString());
}
output.print(": \"");
output.print(input.read_wstring());
output.print("\"}");
return true;
}
/* */ public void insert_Object(org.omg.CORBA.Object paramObject, TypeCode paramTypeCode)
/* */ {
/* */ try
/* */ {
/* 1047 */ if ((paramTypeCode.id().equals("IDL:omg.org/CORBA/Object:1.0"))
|| (paramObject._is_a(paramTypeCode.id())))
/* */ {
/* 1049 */ this.typeCode = TypeCodeImpl.convertToNative(this.orb, paramTypeCode);
/* 1050 */ this.object = paramObject;
/* */ }
/* */ else {
/* 1053 */ throw this.wrapper.insertObjectIncompatible();
/* */ }
/* */ } catch (Exception localException) {
/* 1056 */ throw this.wrapper.insertObjectFailed(localException);
/* */ }
/* 1058 */ this.isInitialized = true;
/* */ }
/* */ public void type(TypeCode paramTypeCode) /* */ {
/* 248 */ this.typeCode = TypeCodeImpl.convertToNative(this.orb, paramTypeCode);
/* */
/* 250 */ this.stream = null;
/* 251 */ this.value = 0L;
/* 252 */ this.object = null;
/* */
/* 254 */ this.isInitialized = (paramTypeCode.kind().value() == 0);
/* */ }
/**
* sets the type of the element to be contained in the Any.
*
* @param tc the TypeCode for the element in the Any
*/
public void type(TypeCode tc) {
// debug.log ("type2");
// set the typecode
typeCode = TypeCodeImpl.convertToNative(orb, tc);
stream = null;
value = 0;
object = null;
// null is the only legal value this Any can have after resetting the type code
isInitialized = (tc.kind().value() == TCKind._tk_null);
}
/* */ public boolean equal(Any paramAny) /* */ {
/* 267 */ if (paramAny == this) {
/* 268 */ return true;
/* */ }
/* */
/* 272 */ if (!this.typeCode.equal(paramAny.type())) {
/* 273 */ return false;
/* */ }
/* */
/* 276 */ TypeCode localTypeCode = realType();
/* */
/* 290 */ switch (localTypeCode.kind().value())
/* */ {
/* */ case 0:
/* */ case 1:
/* 294 */ return true;
/* */ case 2:
/* 296 */ return extract_short() == paramAny.extract_short();
/* */ case 3:
/* 298 */ return extract_long() == paramAny.extract_long();
/* */ case 4:
/* 300 */ return extract_ushort() == paramAny.extract_ushort();
/* */ case 5:
/* 302 */ return extract_ulong() == paramAny.extract_ulong();
/* */ case 6:
/* 304 */ return extract_float() == paramAny.extract_float();
/* */ case 7:
/* 306 */ return extract_double() == paramAny.extract_double();
/* */ case 8:
/* 308 */ return extract_boolean() == paramAny.extract_boolean();
/* */ case 9:
/* 310 */ return extract_char() == paramAny.extract_char();
/* */ case 26:
/* 312 */ return extract_wchar() == paramAny.extract_wchar();
/* */ case 10:
/* 314 */ return extract_octet() == paramAny.extract_octet();
/* */ case 11:
/* 316 */ return extract_any().equal(paramAny.extract_any());
/* */ case 12:
/* 318 */ return extract_TypeCode().equal(paramAny.extract_TypeCode());
/* */ case 18:
/* 320 */ return extract_string().equals(paramAny.extract_string());
/* */ case 27:
/* 322 */ return extract_wstring().equals(paramAny.extract_wstring());
/* */ case 23:
/* 324 */ return extract_longlong() == paramAny.extract_longlong();
/* */ case 24:
/* 326 */ return extract_ulonglong() == paramAny.extract_ulonglong();
/* */ case 14:
/* 329 */ return extract_Object().equals(paramAny.extract_Object());
/* */ case 13:
/* 331 */ return extract_Principal().equals(paramAny.extract_Principal());
/* */ case 17:
/* 334 */ return extract_long() == paramAny.extract_long();
/* */ case 28:
/* 336 */ return extract_fixed().compareTo(paramAny.extract_fixed()) == 0;
/* */ case 15:
/* */ case 16:
/* */ case 19:
/* */ case 20:
/* */ case 22:
/* 342 */ org.omg.CORBA.portable.InputStream localInputStream1 = create_input_stream();
/* 343 */ org.omg.CORBA.portable.InputStream localInputStream2 =
paramAny.create_input_stream();
/* 344 */ return equalMember(localTypeCode, localInputStream1, localInputStream2);
/* */ case 29:
/* */ case 30:
/* 351 */ return extract_Value().equals(paramAny.extract_Value());
/* */ case 21:
/* 354 */ throw this.wrapper.errorResolvingAlias();
/* */ case 25:
/* 358 */ throw this.wrapper.tkLongDoubleNotSupported();
/* */ }
/* */
/* 361 */ throw this.wrapper.typecodeNotSupported();
/* */ }
// Needed for equal() in order to achieve linear performance for complex types.
// Uses up (recursively) copies of the InputStream in both Anys that got created in equal().
private boolean equalMember(TypeCode memberType, InputStream myStream, InputStream otherStream) {
// Resolve aliases here
TypeCode realType = realType(memberType);
try {
switch (realType.kind().value()) {
// handle primitive types
case TCKind._tk_null:
case TCKind._tk_void:
return true;
case TCKind._tk_short:
return (myStream.read_short() == otherStream.read_short());
case TCKind._tk_long:
return (myStream.read_long() == otherStream.read_long());
case TCKind._tk_ushort:
return (myStream.read_ushort() == otherStream.read_ushort());
case TCKind._tk_ulong:
return (myStream.read_ulong() == otherStream.read_ulong());
case TCKind._tk_float:
return (myStream.read_float() == otherStream.read_float());
case TCKind._tk_double:
return (myStream.read_double() == otherStream.read_double());
case TCKind._tk_boolean:
return (myStream.read_boolean() == otherStream.read_boolean());
case TCKind._tk_char:
return (myStream.read_char() == otherStream.read_char());
case TCKind._tk_wchar:
return (myStream.read_wchar() == otherStream.read_wchar());
case TCKind._tk_octet:
return (myStream.read_octet() == otherStream.read_octet());
case TCKind._tk_any:
return myStream.read_any().equal(otherStream.read_any());
case TCKind._tk_TypeCode:
return myStream.read_TypeCode().equal(otherStream.read_TypeCode());
case TCKind._tk_string:
return myStream.read_string().equals(otherStream.read_string());
case TCKind._tk_wstring:
return (myStream.read_wstring().equals(otherStream.read_wstring()));
case TCKind._tk_longlong:
return (myStream.read_longlong() == otherStream.read_longlong());
case TCKind._tk_ulonglong:
return (myStream.read_ulonglong() == otherStream.read_ulonglong());
case TCKind._tk_objref:
return (myStream.read_Object().equals(otherStream.read_Object()));
case TCKind._tk_Principal:
return (myStream.read_Principal().equals(otherStream.read_Principal()));
case TCKind._tk_enum:
return (myStream.read_long() == otherStream.read_long());
case TCKind._tk_fixed:
return (myStream.read_fixed().compareTo(otherStream.read_fixed()) == 0);
case TCKind._tk_except:
case TCKind._tk_struct:
{
int length = realType.member_count();
for (int i = 0; i < length; i++) {
if (!equalMember(realType.member_type(i), myStream, otherStream)) {
return false;
}
}
return true;
}
case TCKind._tk_union:
{
Any myDiscriminator = orb.create_any();
Any otherDiscriminator = orb.create_any();
myDiscriminator.read_value(myStream, realType.discriminator_type());
otherDiscriminator.read_value(otherStream, realType.discriminator_type());
if (!myDiscriminator.equal(otherDiscriminator)) {
return false;
}
TypeCodeImpl realTypeCodeImpl = TypeCodeImpl.convertToNative(orb, realType);
int memberIndex = realTypeCodeImpl.currentUnionMemberIndex(myDiscriminator);
if (memberIndex == -1) throw wrapper.unionDiscriminatorError();
if (!equalMember(realType.member_type(memberIndex), myStream, otherStream)) {
return false;
}
return true;
}
case TCKind._tk_sequence:
{
int length = myStream.read_long();
otherStream.read_long(); // just so that the two stream are in sync
for (int i = 0; i < length; i++) {
if (!equalMember(realType.content_type(), myStream, otherStream)) {
return false;
}
}
return true;
}
case TCKind._tk_array:
{
int length = realType.member_count();
for (int i = 0; i < length; i++) {
if (!equalMember(realType.content_type(), myStream, otherStream)) {
return false;
}
}
return true;
}
// Too complicated to handle value types the way we handle
// other complex types above. Don't try to decompose it here
// for faster comparison, just use Object.equals().
case TCKind._tk_value:
case TCKind._tk_value_box:
org.omg.CORBA_2_3.portable.InputStream mine =
(org.omg.CORBA_2_3.portable.InputStream) myStream;
org.omg.CORBA_2_3.portable.InputStream other =
(org.omg.CORBA_2_3.portable.InputStream) otherStream;
return mine.read_value().equals(other.read_value());
case TCKind._tk_alias:
// error resolving alias above
throw wrapper.errorResolvingAlias();
case TCKind._tk_longdouble:
throw wrapper.tkLongDoubleNotSupported();
default:
throw wrapper.typecodeNotSupported();
}
} catch (BadKind badKind) { // impossible
throw wrapper.badkindCannotOccur();
} catch (Bounds bounds) { // impossible
throw wrapper.boundsCannotOccur();
}
}
/**
* checks for equality between Anys.
*
* @param otherAny the Any to be compared with.
* @result true if the Anys are equal, false otherwise.
*/
public boolean equal(Any otherAny) {
// debug.log ("equal");
if (otherAny == this) return true;
// first check for typecode equality.
// note that this will take aliases into account
if (!typeCode.equal(otherAny.type())) return false;
// Resolve aliases here
TypeCode realType = realType();
// _REVISIT_ Possible optimization for the case where
// otherAny is a AnyImpl and the endianesses match.
// Need implementation of CDRInputStream.equals()
// For now we disable this to encourage testing the generic,
// unoptimized code below.
// Unfortunately this generic code needs to copy the whole stream
// at least once.
// if (AnyImpl.isStreamed[realType.kind().value()]) {
// if (otherAny instanceof AnyImpl) {
// return ((AnyImpl)otherAny).stream.equals(stream);
// }
// }
switch (realType.kind().value()) {
// handle primitive types
case TCKind._tk_null:
case TCKind._tk_void:
return true;
case TCKind._tk_short:
return (extract_short() == otherAny.extract_short());
case TCKind._tk_long:
return (extract_long() == otherAny.extract_long());
case TCKind._tk_ushort:
return (extract_ushort() == otherAny.extract_ushort());
case TCKind._tk_ulong:
return (extract_ulong() == otherAny.extract_ulong());
case TCKind._tk_float:
return (extract_float() == otherAny.extract_float());
case TCKind._tk_double:
return (extract_double() == otherAny.extract_double());
case TCKind._tk_boolean:
return (extract_boolean() == otherAny.extract_boolean());
case TCKind._tk_char:
return (extract_char() == otherAny.extract_char());
case TCKind._tk_wchar:
return (extract_wchar() == otherAny.extract_wchar());
case TCKind._tk_octet:
return (extract_octet() == otherAny.extract_octet());
case TCKind._tk_any:
return extract_any().equal(otherAny.extract_any());
case TCKind._tk_TypeCode:
return extract_TypeCode().equal(otherAny.extract_TypeCode());
case TCKind._tk_string:
return extract_string().equals(otherAny.extract_string());
case TCKind._tk_wstring:
return (extract_wstring().equals(otherAny.extract_wstring()));
case TCKind._tk_longlong:
return (extract_longlong() == otherAny.extract_longlong());
case TCKind._tk_ulonglong:
return (extract_ulonglong() == otherAny.extract_ulonglong());
case TCKind._tk_objref:
return (extract_Object().equals(otherAny.extract_Object()));
case TCKind._tk_Principal:
return (extract_Principal().equals(otherAny.extract_Principal()));
case TCKind._tk_enum:
return (extract_long() == otherAny.extract_long());
case TCKind._tk_fixed:
return (extract_fixed().compareTo(otherAny.extract_fixed()) == 0);
case TCKind._tk_except:
case TCKind._tk_struct:
case TCKind._tk_union:
case TCKind._tk_sequence:
case TCKind._tk_array:
InputStream copyOfMyStream = this.create_input_stream();
InputStream copyOfOtherStream = otherAny.create_input_stream();
return equalMember(realType, copyOfMyStream, copyOfOtherStream);
// Too complicated to handle value types the way we handle
// other complex types above. Don't try to decompose it here
// for faster comparison, just use Object.equals().
case TCKind._tk_value:
case TCKind._tk_value_box:
return extract_Value().equals(otherAny.extract_Value());
case TCKind._tk_alias:
throw wrapper.errorResolvingAlias();
case TCKind._tk_longdouble:
// Unspecified for Java
throw wrapper.tkLongDoubleNotSupported();
default:
throw wrapper.typecodeNotSupported();
}
}
public void testCreateDynamicTypeCode() throws Exception {
TypeCode typeCode = org.jacorb.orb.TypeCode.create_tc(MyClass.class);
assertEquals(2, typeCode.member_count());
assertEquals(typeCode.member_type(0).type_modifier(), typeCode.member_type(1).type_modifier());
}
public void testEquals() {
TypeCode tc = orb.create_string_tc(10);
assertFalse(tc.equals("bla"));
}
private void testArgs(ServerRequestInfo ri, boolean resultAvail) {
String op = ri.operation();
org.omg.Dynamic.Parameter[] args = ri.arguments();
if (op.startsWith("_set_") || op.startsWith("_get_")) {
boolean isstr; // struct or string?
isstr = (op.indexOf("string") != -1);
if (op.startsWith("_get_")) {
TEST(args.length == 0);
if (resultAvail) {
//
// Test: result
//
Any result = ri.result();
if (isstr) {
String str = result.extract_string();
TEST(str.startsWith("TEST"));
} else {
s sp = sHelper.extract(result);
TEST(sp.sval.startsWith("TEST"));
}
}
} else {
TEST(args.length == 1);
TEST(args[0].mode == org.omg.CORBA.ParameterMode.PARAM_IN);
if (resultAvail) {
if (isstr) {
String str = args[0].argument.extract_string();
TEST(str.startsWith("TEST"));
} else {
s sp = sHelper.extract(args[0].argument);
TEST(sp.sval.startsWith("TEST"));
}
}
}
} else if (op.startsWith("one_")) {
String which = op.substring(4); // Which operation?
boolean isstr; // struct or string?
ParameterMode mode; // The parameter mode
if (which.startsWith("string")) isstr = true;
else
// if which.startsWith("struct"))
isstr = false;
which = which.substring(7); // Skip <string|struct>_
if (which.equals("return")) {
TEST(args.length == 0);
if (resultAvail) {
//
// Test: result
//
Any result = ri.result();
if (isstr) {
String str = result.extract_string();
TEST(str.startsWith("TEST"));
} else {
s sp = sHelper.extract(result);
TEST(sp.sval.startsWith("TEST"));
}
}
} else {
TEST(args.length == 1);
if (which.equals("in")) mode = org.omg.CORBA.ParameterMode.PARAM_IN;
else if (which.equals("inout")) mode = org.omg.CORBA.ParameterMode.PARAM_INOUT;
else
// if(which.equals("out"))
mode = org.omg.CORBA.ParameterMode.PARAM_OUT;
TEST(mode == args[0].mode);
if (mode != org.omg.CORBA.ParameterMode.PARAM_OUT || resultAvail) {
if (isstr) {
String str = args[0].argument.extract_string();
TEST(str.startsWith("TEST"));
} else {
s sp = sHelper.extract(args[0].argument);
TEST(sp.sval.startsWith("TEST"));
}
if (resultAvail) {
//
// Test: result
//
Any result = ri.result();
TypeCode tc = result.type();
TEST(tc.kind() == TCKind.tk_void);
}
}
}
} else {
TEST(args.length == 0);
}
if (!resultAvail) {
//
// Test: result is not available
//
try {
Any result = ri.result();
TEST(false);
} catch (BAD_INV_ORDER ex) {
// Expected
}
}
}
static void marshalIn(
org.omg.CORBA.portable.OutputStream s, TypeCode typeCode, long l, Object o) {
switch (typeCode.kind().value()) {
case TCKind._tk_null:
case TCKind._tk_void:
case TCKind._tk_native:
// nothing to write
break;
case TCKind._tk_short:
s.write_short((short) (l & 0xFFFFL));
break;
case TCKind._tk_ushort:
s.write_ushort((short) (l & 0xFFFFL));
break;
case TCKind._tk_enum:
case TCKind._tk_long:
s.write_long((int) (l & 0xFFFFFFFFL));
break;
case TCKind._tk_ulong:
s.write_ulong((int) (l & 0xFFFFFFFFL));
break;
case TCKind._tk_float:
s.write_float(Float.intBitsToFloat((int) (l & 0xFFFFFFFFL)));
break;
case TCKind._tk_double:
s.write_double(Double.longBitsToDouble(l));
break;
case TCKind._tk_boolean:
if (l == 0) s.write_boolean(false);
else s.write_boolean(true);
break;
case TCKind._tk_char:
s.write_char((char) (l & 0xFFFFL));
break;
case TCKind._tk_octet:
s.write_octet((byte) (l & 0xFFL));
break;
case TCKind._tk_any:
s.write_any((Any) o);
break;
case TCKind._tk_TypeCode:
s.write_TypeCode((TypeCode) o);
break;
case TCKind._tk_Principal:
s.write_Principal((Principal) o);
break;
case TCKind._tk_objref:
s.write_Object((org.omg.CORBA.Object) o);
break;
case TCKind._tk_longlong:
s.write_longlong(l);
break;
case TCKind._tk_ulonglong:
s.write_ulonglong(l);
break;
case TCKind._tk_wchar:
s.write_wchar((char) (l & 0xFFFFL));
break;
case TCKind._tk_string:
s.write_string((String) o);
break;
case TCKind._tk_wstring:
s.write_wstring((String) o);
break;
case TCKind._tk_value:
case TCKind._tk_value_box:
((org.omg.CORBA_2_3.portable.OutputStream) s).write_value((Serializable) o);
break;
case TCKind._tk_fixed:
// _REVISIT_ As soon as the java-rtf adds digits and scale parameters to
// OutputStream, this check will be unnecessary
if (s instanceof CDROutputStream) {
try {
((CDROutputStream) s)
.write_fixed((BigDecimal) o, typeCode.fixed_digits(), typeCode.fixed_scale());
} catch (BadKind badKind) { // impossible
}
} else {
s.write_fixed((BigDecimal) o);
}
break;
case TCKind._tk_struct:
case TCKind._tk_union:
case TCKind._tk_sequence:
case TCKind._tk_array:
case TCKind._tk_alias:
case TCKind._tk_except:
((Streamable) o)._write(s);
break;
case TCKind._tk_abstract_interface:
((org.omg.CORBA_2_3.portable.OutputStream) s).write_abstract_interface(o);
break;
case TCKind._tk_longdouble:
// Unspecified for Java
default:
ORBUtilSystemException wrapper =
ORBUtilSystemException.get(
(com.sun.corba.se.spi.orb.ORB) s.orb(), CORBALogDomains.RPC_PRESENTATION);
throw wrapper.typecodeNotSupported();
}
}
static void unmarshalIn(
org.omg.CORBA.portable.InputStream s, TypeCode typeCode, long[] la, Object[] oa) {
int type = typeCode.kind().value();
long l = 0;
Object o = oa[0];
switch (type) {
case TCKind._tk_null:
case TCKind._tk_void:
case TCKind._tk_native:
// Nothing to read
break;
case TCKind._tk_short:
l = s.read_short() & 0xFFFFL;
break;
case TCKind._tk_ushort:
l = s.read_ushort() & 0xFFFFL;
break;
case TCKind._tk_enum:
case TCKind._tk_long:
l = s.read_long() & 0xFFFFFFFFL;
break;
case TCKind._tk_ulong:
l = s.read_ulong() & 0xFFFFFFFFL;
break;
case TCKind._tk_float:
l = Float.floatToIntBits(s.read_float()) & 0xFFFFFFFFL;
break;
case TCKind._tk_double:
l = Double.doubleToLongBits(s.read_double());
break;
case TCKind._tk_char:
l = s.read_char() & 0xFFFFL;
break;
case TCKind._tk_octet:
l = s.read_octet() & 0xFFL;
break;
case TCKind._tk_boolean:
if (s.read_boolean()) l = 1;
else l = 0;
break;
case TCKind._tk_any:
o = s.read_any();
break;
case TCKind._tk_TypeCode:
o = s.read_TypeCode();
break;
case TCKind._tk_Principal:
o = s.read_Principal();
break;
case TCKind._tk_objref:
if (o instanceof Streamable) ((Streamable) o)._read(s);
else o = s.read_Object();
break;
case TCKind._tk_longlong:
l = s.read_longlong();
break;
case TCKind._tk_ulonglong:
l = s.read_ulonglong();
break;
case TCKind._tk_wchar:
l = s.read_wchar() & 0xFFFFL;
break;
case TCKind._tk_string:
o = s.read_string();
break;
case TCKind._tk_wstring:
o = s.read_wstring();
break;
case TCKind._tk_value:
case TCKind._tk_value_box:
o = ((org.omg.CORBA_2_3.portable.InputStream) s).read_value();
break;
case TCKind._tk_fixed:
try {
// _REVISIT_ As soon as the java-rtf adds digits and scale parameters to
// InputStream, this check will be unnecessary
if (s instanceof CDRInputStream) {
o = ((CDRInputStream) s).read_fixed(typeCode.fixed_digits(), typeCode.fixed_scale());
} else {
BigDecimal bigDecimal = s.read_fixed();
o = bigDecimal.movePointLeft((int) typeCode.fixed_scale());
}
} catch (BadKind badKind) { // impossible
}
break;
case TCKind._tk_struct:
case TCKind._tk_union:
case TCKind._tk_sequence:
case TCKind._tk_array:
case TCKind._tk_alias:
case TCKind._tk_except:
((Streamable) o)._read(s);
break;
case TCKind._tk_abstract_interface:
o = ((org.omg.CORBA_2_3.portable.InputStream) s).read_abstract_interface();
break;
case TCKind._tk_longdouble:
// Unspecified for Java
default:
ORBUtilSystemException wrapper =
ORBUtilSystemException.get(
(com.sun.corba.se.spi.orb.ORB) s.orb(), CORBALogDomains.RPC_PRESENTATION);
throw wrapper.typecodeNotSupported();
}
oa[0] = o;
la[0] = l;
}
/**
* Allows the possibility of not checking the name when creating this typecode. This is to cater
* for compact typecodes where the name may not be set. Checking of the name will always be true
* for user driven requests
*
* @param id the id
* @param name the name
* @param discriminator_type the discriminator_type
* @param members the members
* @param checkName the check name
* @return the type code
*/
public TypeCode create_union_tc(
String id,
String name,
TypeCode discriminator_type,
org.omg.CORBA.UnionMember[] members,
boolean checkName) {
checkTCRepositoryId(id);
checkTCName(name, true);
// check discriminator type
TypeCode disc_tc = org.jacorb.orb.TypeCode.originalType(discriminator_type);
if (disc_tc == null
|| !(disc_tc.kind().value() == TCKind._tk_short
|| disc_tc.kind().value() == TCKind._tk_long
|| disc_tc.kind().value() == TCKind._tk_longlong
|| disc_tc.kind().value() == TCKind._tk_ushort
|| disc_tc.kind().value() == TCKind._tk_ulong
|| disc_tc.kind().value() == TCKind._tk_ulonglong
|| disc_tc.kind().value() == TCKind._tk_char
|| disc_tc.kind().value() == TCKind._tk_boolean
|| disc_tc.kind().value() == TCKind._tk_enum)) {
throw new BAD_PARAM("Illegal union discriminator type", 20, CompletionStatus.COMPLETED_NO);
}
// check that member names are legal (they do not need to be unique)
for (int i = 0; i < members.length; i++) {
checkTCMemberType(members[i].type);
if (checkName) {
try {
checkTCName(members[i].name);
} catch (BAD_PARAM e) {
logger.debug("Typecode name check failed", e);
throw new BAD_PARAM(
"Illegal union member name: " + members[i].name, 17, CompletionStatus.COMPLETED_NO);
}
}
// check that member type matches discriminator type or is default
org.omg.CORBA.Any label = members[i].label;
if (!discriminator_type.equivalent(label.type())
&& !(label.type().kind().value() == TCKind._tk_octet
&& label.extract_octet() == (byte) 0)) {
throw new BAD_PARAM(
"Label type does not match discriminator type", 19, CompletionStatus.COMPLETED_NO);
}
// check that member labels are unique
for (int j = 0; j < i; j++) {
if (label.equal(members[j].label)) {
throw new BAD_PARAM("Duplicate union case label", 18, CompletionStatus.COMPLETED_NO);
}
}
}
org.jacorb.orb.TypeCode typeCode =
new org.jacorb.orb.TypeCode(id, name, discriminator_type, members);
// resolve any recursive references to this TypeCode in its members
return typeCode;
}
/* */ private boolean equalMember(
TypeCode paramTypeCode,
org.omg.CORBA.portable.InputStream paramInputStream1,
org.omg.CORBA.portable.InputStream paramInputStream2)
/* */ {
/* 369 */ TypeCode localTypeCode = realType(paramTypeCode);
/* */ try
/* */ {
/* */ int j;
/* */ int m;
/* 372 */ switch (localTypeCode.kind().value())
/* */ {
/* */ case 0:
/* */ case 1:
/* 376 */ return true;
/* */ case 2:
/* 378 */ return paramInputStream1.read_short() == paramInputStream2.read_short();
/* */ case 3:
/* 380 */ return paramInputStream1.read_long() == paramInputStream2.read_long();
/* */ case 4:
/* 382 */ return paramInputStream1.read_ushort() == paramInputStream2.read_ushort();
/* */ case 5:
/* 384 */ return paramInputStream1.read_ulong() == paramInputStream2.read_ulong();
/* */ case 6:
/* 386 */ return paramInputStream1.read_float() == paramInputStream2.read_float();
/* */ case 7:
/* 388 */ return paramInputStream1.read_double() == paramInputStream2.read_double();
/* */ case 8:
/* 390 */ return paramInputStream1.read_boolean() == paramInputStream2.read_boolean();
/* */ case 9:
/* 392 */ return paramInputStream1.read_char() == paramInputStream2.read_char();
/* */ case 26:
/* 394 */ return paramInputStream1.read_wchar() == paramInputStream2.read_wchar();
/* */ case 10:
/* 396 */ return paramInputStream1.read_octet() == paramInputStream2.read_octet();
/* */ case 11:
/* 398 */ return paramInputStream1.read_any().equal(paramInputStream2.read_any());
/* */ case 12:
/* 400 */ return paramInputStream1
.read_TypeCode()
.equal(paramInputStream2.read_TypeCode());
/* */ case 18:
/* 402 */ return paramInputStream1.read_string().equals(paramInputStream2.read_string());
/* */ case 27:
/* 404 */ return paramInputStream1
.read_wstring()
.equals(paramInputStream2.read_wstring());
/* */ case 23:
/* 406 */ return paramInputStream1.read_longlong() == paramInputStream2.read_longlong();
/* */ case 24:
/* 408 */ return paramInputStream1.read_ulonglong()
== paramInputStream2.read_ulonglong();
/* */ case 14:
/* 411 */ return paramInputStream1.read_Object().equals(paramInputStream2.read_Object());
/* */ case 13:
/* 413 */ return paramInputStream1
.read_Principal()
.equals(paramInputStream2.read_Principal());
/* */ case 17:
/* 416 */ return paramInputStream1.read_long() == paramInputStream2.read_long();
/* */ case 28:
/* 418 */ return paramInputStream1.read_fixed().compareTo(paramInputStream2.read_fixed())
== 0;
/* */ case 15:
/* */ case 22:
/* 421 */ int i = localTypeCode.member_count();
/* 422 */ for (int k = 0; k < i; k++) {
/* 423 */ if (!equalMember(
localTypeCode.member_type(k), paramInputStream1, paramInputStream2)) {
/* 424 */ return false;
/* */ }
/* */ }
/* 427 */ return true;
/* */ case 16:
/* 430 */ Any localAny1 = this.orb.create_any();
/* 431 */ Any localAny2 = this.orb.create_any();
/* 432 */ localAny1.read_value(paramInputStream1, localTypeCode.discriminator_type());
/* 433 */ localAny2.read_value(paramInputStream2, localTypeCode.discriminator_type());
/* */
/* 435 */ if (!localAny1.equal(localAny2)) {
/* 436 */ return false;
/* */ }
/* 438 */ TypeCodeImpl localTypeCodeImpl =
TypeCodeImpl.convertToNative(this.orb, localTypeCode);
/* 439 */ int n = localTypeCodeImpl.currentUnionMemberIndex(localAny1);
/* 440 */ if (n == -1) {
/* 441 */ throw this.wrapper.unionDiscriminatorError();
/* */ }
/* 443 */ if (!equalMember(
localTypeCode.member_type(n), paramInputStream1, paramInputStream2)) {
/* 444 */ return false;
/* */ }
/* 446 */ return true;
/* */ case 19:
/* 449 */ j = paramInputStream1.read_long();
/* 450 */ paramInputStream2.read_long();
/* 451 */ for (m = 0; m < j; m++) {
/* 452 */ if (!equalMember(
localTypeCode.content_type(), paramInputStream1, paramInputStream2)) {
/* 453 */ return false;
/* */ }
/* */ }
/* 456 */ return true;
/* */ case 20:
/* 459 */ j = localTypeCode.member_count();
/* 460 */ for (m = 0; m < j; m++) {
/* 461 */ if (!equalMember(
localTypeCode.content_type(), paramInputStream1, paramInputStream2)) {
/* 462 */ return false;
/* */ }
/* */ }
/* 465 */ return true;
/* */ case 29:
/* */ case 30:
/* 473 */ org.omg.CORBA_2_3.portable.InputStream localInputStream1 =
(org.omg.CORBA_2_3.portable.InputStream) paramInputStream1;
/* */
/* 475 */ org.omg.CORBA_2_3.portable.InputStream localInputStream2 =
(org.omg.CORBA_2_3.portable.InputStream) paramInputStream2;
/* */
/* 477 */ return localInputStream1.read_value().equals(localInputStream2.read_value());
/* */ case 21:
/* 481 */ throw this.wrapper.errorResolvingAlias();
/* */ case 25:
/* 484 */ throw this.wrapper.tkLongDoubleNotSupported();
/* */ }
/* */
/* 487 */ throw this.wrapper.typecodeNotSupported();
/* */ }
/* */ catch (BadKind localBadKind) {
/* 490 */ throw this.wrapper.badkindCannotOccur();
} catch (Bounds localBounds) {
/* */ }
/* 492 */ throw this.wrapper.boundsCannotOccur();
/* */ }
