/** * 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; }
// 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(); } }
/** * Copies and remarshals the given typecode value marshaled in an InputStream to a <code> * es.tid.TIDorbj.core.CDRInputStream</code>. This method will alwais be invoked by this stream. * * @param type the value <code>TypeCode</code> * @param input the <code>InputStream</code> where the value is marshaled * @param output the <code>es.tid.TIDorbj.core.CDRInputStream</code> * @pre the <code>TypeCode</code> must be an wstring type */ public static void remarshalValue(TypeCode type, InputStream input, OutputStream output) { output.write_wstring(input.read_wstring()); }
/** * Compares two InputStream marshaled values of a given TypeCode to a <code> * es.tid.TIDorbj.core.CDRInputStream</code>. This method will alwais be invoked by this stream. * * @param type the value <code>TypeCode</code> * @param input_a the <code>InputStream</code> where one value is marshaled * @param input_b the <code>InputStream</code> where the value value is marshaled * @pre <code>type</code> must be a wstring type. */ public static boolean valuesEqual( org.omg.CORBA.TypeCode type, InputStream input_a, InputStream input_b) { return (input_a.read_wstring()).equals(input_a.read_wstring()); }