| /* |
| * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| /* |
| * Licensed Materials - Property of IBM |
| * RMI-IIOP v1.0 |
| * Copyright IBM Corp. 1998 1999 All Rights Reserved |
| * |
| */ |
| |
| package com.sun.corba.se.impl.encoding; |
| |
| import java.io.ByteArrayOutputStream; |
| import java.io.IOException; |
| import java.io.Serializable; |
| import java.io.ByteArrayOutputStream; |
| import java.io.ObjectOutputStream; |
| import java.io.IOException; |
| import java.lang.reflect.Method; |
| import java.lang.reflect.InvocationTargetException; |
| import java.math.BigDecimal; |
| import java.nio.ByteBuffer; |
| import java.rmi.Remote; |
| import java.security.AccessController; |
| import java.security.PrivilegedExceptionAction; |
| import java.security.PrivilegedActionException; |
| import java.util.Hashtable; |
| import java.util.Stack; |
| |
| import javax.rmi.CORBA.Util; |
| import javax.rmi.CORBA.ValueHandler; |
| import javax.rmi.CORBA.ValueHandlerMultiFormat; |
| |
| import org.omg.CORBA.CustomMarshal; |
| import org.omg.CORBA.DataOutputStream; |
| import org.omg.CORBA.TypeCodePackage.BadKind; |
| import org.omg.CORBA.SystemException; |
| import org.omg.CORBA.CompletionStatus; |
| import org.omg.CORBA.Object; |
| import org.omg.CORBA.Principal; |
| import org.omg.CORBA.TypeCode; |
| import org.omg.CORBA.Any; |
| import org.omg.CORBA.VM_CUSTOM; |
| import org.omg.CORBA.VM_TRUNCATABLE; |
| import org.omg.CORBA.VM_NONE; |
| import org.omg.CORBA.portable.IDLEntity; |
| import org.omg.CORBA.portable.CustomValue; |
| import org.omg.CORBA.portable.StreamableValue; |
| import org.omg.CORBA.portable.BoxedValueHelper; |
| import org.omg.CORBA.portable.OutputStream; |
| import org.omg.CORBA.portable.ValueBase; |
| |
| import com.sun.org.omg.CORBA.portable.ValueHelper; |
| |
| import com.sun.corba.se.pept.protocol.MessageMediator; |
| import com.sun.corba.se.pept.transport.ByteBufferPool; |
| |
| import com.sun.corba.se.spi.ior.iiop.GIOPVersion; |
| import com.sun.corba.se.spi.ior.IOR; |
| import com.sun.corba.se.spi.ior.IORFactories; |
| import com.sun.corba.se.spi.orb.ORB; |
| import com.sun.corba.se.spi.orb.ORBVersionFactory; |
| import com.sun.corba.se.spi.orb.ORBVersion; |
| import com.sun.corba.se.spi.protocol.CorbaMessageMediator; |
| import com.sun.corba.se.spi.logging.CORBALogDomains; |
| |
| import com.sun.corba.se.impl.encoding.ByteBufferWithInfo; |
| import com.sun.corba.se.impl.encoding.MarshalOutputStream; |
| import com.sun.corba.se.impl.encoding.CodeSetConversion; |
| import com.sun.corba.se.impl.corba.TypeCodeImpl; |
| import com.sun.corba.se.impl.orbutil.CacheTable; |
| import com.sun.corba.se.impl.orbutil.ORBUtility; |
| import com.sun.corba.se.impl.orbutil.RepositoryIdStrings; |
| import com.sun.corba.se.impl.orbutil.RepositoryIdUtility; |
| import com.sun.corba.se.impl.orbutil.RepositoryIdFactory; |
| import com.sun.corba.se.impl.util.Utility; |
| import com.sun.corba.se.impl.logging.ORBUtilSystemException; |
| |
| public class CDROutputStream_1_0 extends CDROutputStreamBase |
| { |
| private static final int INDIRECTION_TAG = 0xffffffff; |
| |
| protected boolean littleEndian; |
| protected BufferManagerWrite bufferManagerWrite; |
| ByteBufferWithInfo bbwi; |
| |
| protected ORB orb; |
| protected ORBUtilSystemException wrapper ; |
| |
| protected boolean debug = false; |
| |
| protected int blockSizeIndex = -1; |
| protected int blockSizePosition = 0; |
| |
| protected byte streamFormatVersion; |
| |
| private static final int DEFAULT_BUFFER_SIZE = 1024; |
| private static final String kWriteMethod = "write"; |
| |
| // Codebase cache |
| private CacheTable codebaseCache = null; |
| |
| // Value cache |
| private CacheTable valueCache = null; |
| |
| // Repository ID cache |
| private CacheTable repositoryIdCache = null; |
| |
| // Write end flag |
| private int end_flag = 0; |
| |
| // Beginning with the resolution to interop issue 3526, |
| // only enclosing chunked valuetypes are taken into account |
| // when computing the nesting level. However, we still need |
| // the old computation around for interoperability with our |
| // older ORBs. |
| private int chunkedValueNestingLevel = 0; |
| |
| private boolean mustChunk = false; |
| |
| // In block marker |
| protected boolean inBlock = false; |
| |
| // Last end tag position |
| private int end_flag_position = 0; |
| private int end_flag_index = 0; |
| |
| // ValueHandler |
| private ValueHandler valueHandler = null; |
| |
| // Repository ID handlers |
| private RepositoryIdUtility repIdUtil; |
| private RepositoryIdStrings repIdStrs; |
| |
| // Code set converters (created when first needed) |
| private CodeSetConversion.CTBConverter charConverter; |
| private CodeSetConversion.CTBConverter wcharConverter; |
| |
| // REVISIT - This should be re-factored so that including whether |
| // to use pool byte buffers or not doesn't need to be known. |
| public void init(org.omg.CORBA.ORB orb, |
| boolean littleEndian, |
| BufferManagerWrite bufferManager, |
| byte streamFormatVersion, |
| boolean usePooledByteBuffers) |
| { |
| // ORB must not be null. See CDROutputStream constructor. |
| this.orb = (ORB)orb; |
| this.wrapper = ORBUtilSystemException.get( this.orb, |
| CORBALogDomains.RPC_ENCODING ) ; |
| debug = this.orb.transportDebugFlag; |
| |
| this.littleEndian = littleEndian; |
| this.bufferManagerWrite = bufferManager; |
| this.bbwi = new ByteBufferWithInfo(orb, bufferManager, usePooledByteBuffers); |
| this.streamFormatVersion = streamFormatVersion; |
| |
| createRepositoryIdHandlers(); |
| } |
| |
| public void init(org.omg.CORBA.ORB orb, |
| boolean littleEndian, |
| BufferManagerWrite bufferManager, |
| byte streamFormatVersion) |
| { |
| init(orb, littleEndian, bufferManager, streamFormatVersion, true); |
| } |
| |
| private final void createRepositoryIdHandlers() |
| { |
| repIdUtil = RepositoryIdFactory.getRepIdUtility(); |
| repIdStrs = RepositoryIdFactory.getRepIdStringsFactory(); |
| } |
| |
| public BufferManagerWrite getBufferManager() |
| { |
| return bufferManagerWrite; |
| } |
| |
| public byte[] toByteArray() { |
| byte[] it; |
| |
| it = new byte[bbwi.position()]; |
| |
| // Micro-benchmarks show ByteBuffer.get(int) out perform the bulk |
| // ByteBuffer.get(byte[], offset, length). |
| for (int i = 0; i < bbwi.position(); i++) |
| it[i] = bbwi.byteBuffer.get(i); |
| |
| return it; |
| } |
| |
| public GIOPVersion getGIOPVersion() { |
| return GIOPVersion.V1_0; |
| } |
| |
| // Called by Request and Reply message. Valid for GIOP versions >= 1.2 only. |
| // Illegal for GIOP versions < 1.2. |
| void setHeaderPadding(boolean headerPadding) { |
| throw wrapper.giopVersionError(); |
| } |
| |
| protected void handleSpecialChunkBegin(int requiredSize) |
| { |
| // No-op for GIOP 1.0 |
| } |
| |
| protected void handleSpecialChunkEnd() |
| { |
| // No-op for GIOP 1.0 |
| } |
| |
| protected final int computeAlignment(int align) { |
| if (align > 1) { |
| int incr = bbwi.position() & (align - 1); |
| if (incr != 0) |
| return align - incr; |
| } |
| |
| return 0; |
| } |
| |
| protected void alignAndReserve(int align, int n) { |
| |
| bbwi.position(bbwi.position() + computeAlignment(align)); |
| |
| if (bbwi.position() + n > bbwi.buflen) |
| grow(align, n); |
| } |
| |
| // |
| // Default implementation of grow. Subclassers may override this. |
| // Always grow the single buffer. This needs to delegate |
| // fragmentation policy for IIOP 1.1. |
| // |
| protected void grow(int align, int n) |
| { |
| bbwi.needed = n; |
| |
| bufferManagerWrite.overflow(bbwi); |
| } |
| |
| public final void putEndian() throws SystemException { |
| write_boolean(littleEndian); |
| } |
| |
| public final boolean littleEndian() { |
| return littleEndian; |
| } |
| |
| void freeInternalCaches() { |
| if (codebaseCache != null) |
| codebaseCache.done(); |
| |
| if (valueCache != null) |
| valueCache.done(); |
| |
| if (repositoryIdCache != null) |
| repositoryIdCache.done(); |
| } |
| |
| // No such type in java |
| public final void write_longdouble(double x) |
| { |
| throw wrapper.longDoubleNotImplemented( |
| CompletionStatus.COMPLETED_MAYBE ) ; |
| } |
| |
| public void write_octet(byte x) |
| { |
| // The 'if' stmt is commented out since we need the alignAndReserve to |
| // be called, particularly when the first body byte is written, |
| // to induce header padding to align the body on a 8-octet boundary, |
| // for GIOP versions 1.2 and above. Refer to internalWriteOctetArray() |
| // method that also has a similar change. |
| //if (bbwi.position() + 1 > bbwi.buflen) |
| alignAndReserve(1, 1); |
| |
| // REVISIT - Should just use ByteBuffer.put(byte) and let it |
| // increment the ByteBuffer position. This is true |
| // for all write operations in this file. |
| |
| bbwi.byteBuffer.put(bbwi.position(), x); |
| bbwi.position(bbwi.position() + 1); |
| |
| } |
| |
| public final void write_boolean(boolean x) |
| { |
| write_octet(x? (byte)1:(byte)0); |
| } |
| |
| public void write_char(char x) |
| { |
| CodeSetConversion.CTBConverter converter = getCharConverter(); |
| |
| converter.convert(x); |
| |
| // CORBA formal 99-10-07 15.3.1.6: "In the case of multi-byte encodings |
| // of characters, a single instance of the char type may only |
| // hold one octet of any multi-byte character encoding." |
| if (converter.getNumBytes() > 1) |
| throw wrapper.invalidSingleCharCtb(CompletionStatus.COMPLETED_MAYBE); |
| |
| write_octet(converter.getBytes()[0]); |
| } |
| |
| // These wchar methods are only used when talking to |
| // legacy ORBs, now. |
| private final void writeLittleEndianWchar(char x) { |
| bbwi.byteBuffer.put(bbwi.position(), (byte)(x & 0xFF)); |
| bbwi.byteBuffer.put(bbwi.position() + 1, (byte)((x >>> 8) & 0xFF)); |
| bbwi.position(bbwi.position() + 2); |
| } |
| |
| private final void writeBigEndianWchar(char x) { |
| bbwi.byteBuffer.put(bbwi.position(), (byte)((x >>> 8) & 0xFF)); |
| bbwi.byteBuffer.put(bbwi.position() + 1, (byte)(x & 0xFF)); |
| bbwi.position(bbwi.position() + 2); |
| } |
| |
| private final void writeLittleEndianShort(short x) { |
| bbwi.byteBuffer.put(bbwi.position(), (byte)(x & 0xFF)); |
| bbwi.byteBuffer.put(bbwi.position() + 1, (byte)((x >>> 8) & 0xFF)); |
| bbwi.position(bbwi.position() + 2); |
| } |
| |
| private final void writeBigEndianShort(short x) { |
| bbwi.byteBuffer.put(bbwi.position(), (byte)((x >>> 8) & 0xFF)); |
| bbwi.byteBuffer.put(bbwi.position() + 1, (byte)(x & 0xFF)); |
| bbwi.position(bbwi.position() + 2); |
| } |
| |
| private final void writeLittleEndianLong(int x) { |
| bbwi.byteBuffer.put(bbwi.position(), (byte)(x & 0xFF)); |
| bbwi.byteBuffer.put(bbwi.position() + 1, (byte)((x >>> 8) & 0xFF)); |
| bbwi.byteBuffer.put(bbwi.position() + 2, (byte)((x >>> 16) & 0xFF)); |
| bbwi.byteBuffer.put(bbwi.position() + 3, (byte)((x >>> 24) & 0xFF)); |
| bbwi.position(bbwi.position() + 4); |
| } |
| |
| private final void writeBigEndianLong(int x) { |
| bbwi.byteBuffer.put(bbwi.position(), (byte)((x >>> 24) & 0xFF)); |
| bbwi.byteBuffer.put(bbwi.position() + 1, (byte)((x >>> 16) & 0xFF)); |
| bbwi.byteBuffer.put(bbwi.position() + 2, (byte)((x >>> 8) & 0xFF)); |
| bbwi.byteBuffer.put(bbwi.position() + 3, (byte)(x & 0xFF)); |
| bbwi.position(bbwi.position() + 4); |
| } |
| |
| private final void writeLittleEndianLongLong(long x) { |
| bbwi.byteBuffer.put(bbwi.position(), (byte)(x & 0xFF)); |
| bbwi.byteBuffer.put(bbwi.position() + 1, (byte)((x >>> 8) & 0xFF)); |
| bbwi.byteBuffer.put(bbwi.position() + 2, (byte)((x >>> 16) & 0xFF)); |
| bbwi.byteBuffer.put(bbwi.position() + 3, (byte)((x >>> 24) & 0xFF)); |
| bbwi.byteBuffer.put(bbwi.position() + 4, (byte)((x >>> 32) & 0xFF)); |
| bbwi.byteBuffer.put(bbwi.position() + 5, (byte)((x >>> 40) & 0xFF)); |
| bbwi.byteBuffer.put(bbwi.position() + 6, (byte)((x >>> 48) & 0xFF)); |
| bbwi.byteBuffer.put(bbwi.position() + 7, (byte)((x >>> 56) & 0xFF)); |
| bbwi.position(bbwi.position() + 8); |
| } |
| |
| private final void writeBigEndianLongLong(long x) { |
| bbwi.byteBuffer.put(bbwi.position(), (byte)((x >>> 56) & 0xFF)); |
| bbwi.byteBuffer.put(bbwi.position() + 1, (byte)((x >>> 48) & 0xFF)); |
| bbwi.byteBuffer.put(bbwi.position() + 2, (byte)((x >>> 40) & 0xFF)); |
| bbwi.byteBuffer.put(bbwi.position() + 3, (byte)((x >>> 32) & 0xFF)); |
| bbwi.byteBuffer.put(bbwi.position() + 4, (byte)((x >>> 24) & 0xFF)); |
| bbwi.byteBuffer.put(bbwi.position() + 5, (byte)((x >>> 16) & 0xFF)); |
| bbwi.byteBuffer.put(bbwi.position() + 6, (byte)((x >>> 8) & 0xFF)); |
| bbwi.byteBuffer.put(bbwi.position() + 7, (byte)(x & 0xFF)); |
| bbwi.position(bbwi.position() + 8); |
| } |
| |
| public void write_wchar(char x) |
| { |
| // Don't allow transmission of wchar/wstring data with |
| // foreign ORBs since it's against the spec. |
| if (ORBUtility.isForeignORB(orb)) { |
| throw wrapper.wcharDataInGiop10(CompletionStatus.COMPLETED_MAYBE); |
| } |
| |
| // If it's one of our legacy ORBs, do what they did: |
| alignAndReserve(2, 2); |
| |
| if (littleEndian) { |
| writeLittleEndianWchar(x); |
| } else { |
| writeBigEndianWchar(x); |
| } |
| } |
| |
| public void write_short(short x) |
| { |
| alignAndReserve(2, 2); |
| |
| if (littleEndian) { |
| writeLittleEndianShort(x); |
| } else { |
| writeBigEndianShort(x); |
| } |
| } |
| |
| public final void write_ushort(short x) |
| { |
| write_short(x); |
| } |
| |
| public void write_long(int x) |
| { |
| alignAndReserve(4, 4); |
| |
| if (littleEndian) { |
| writeLittleEndianLong(x); |
| } else { |
| writeBigEndianLong(x); |
| } |
| } |
| |
| public final void write_ulong(int x) |
| { |
| write_long(x); |
| } |
| |
| public void write_longlong(long x) |
| { |
| alignAndReserve(8, 8); |
| |
| if (littleEndian) { |
| writeLittleEndianLongLong(x); |
| } else { |
| writeBigEndianLongLong(x); |
| } |
| } |
| |
| public final void write_ulonglong(long x) |
| { |
| write_longlong(x); |
| } |
| |
| public final void write_float(float x) |
| { |
| write_long(Float.floatToIntBits(x)); |
| } |
| |
| public final void write_double(double x) |
| { |
| write_longlong(Double.doubleToLongBits(x)); |
| } |
| |
| public void write_string(String value) |
| { |
| writeString(value); |
| } |
| |
| protected int writeString(String value) |
| { |
| if (value == null) { |
| throw wrapper.nullParam(CompletionStatus.COMPLETED_MAYBE); |
| } |
| |
| CodeSetConversion.CTBConverter converter = getCharConverter(); |
| |
| converter.convert(value); |
| |
| // A string is encoded as an unsigned CORBA long for the |
| // number of bytes to follow (including a terminating null). |
| // There is only one octet per character in the string. |
| int len = converter.getNumBytes() + 1; |
| |
| handleSpecialChunkBegin(computeAlignment(4) + 4 + len); |
| |
| write_long(len); |
| int indirection = get_offset() - 4; |
| |
| internalWriteOctetArray(converter.getBytes(), 0, converter.getNumBytes()); |
| |
| // Write the null ending |
| write_octet((byte)0); |
| |
| handleSpecialChunkEnd(); |
| return indirection; |
| } |
| |
| public void write_wstring(String value) |
| { |
| if (value == null) |
| throw wrapper.nullParam(CompletionStatus.COMPLETED_MAYBE); |
| |
| // Don't allow transmission of wchar/wstring data with |
| // foreign ORBs since it's against the spec. |
| if (ORBUtility.isForeignORB(orb)) { |
| throw wrapper.wcharDataInGiop10(CompletionStatus.COMPLETED_MAYBE); |
| } |
| |
| // When talking to our legacy ORBs, do what they did: |
| int len = value.length() + 1; |
| |
| // This will only have an effect if we're already chunking |
| handleSpecialChunkBegin(4 + (len * 2) + computeAlignment(4)); |
| |
| write_long(len); |
| |
| for (int i = 0; i < len - 1; i++) |
| write_wchar(value.charAt(i)); |
| |
| // Write the null ending |
| write_short((short)0); |
| |
| // This will only have an effect if we're already chunking |
| handleSpecialChunkEnd(); |
| } |
| |
| // Performs no checks and doesn't tamper with chunking |
| void internalWriteOctetArray(byte[] value, int offset, int length) |
| { |
| int n = offset; |
| |
| // This flag forces the alignAndReserve method to be called the |
| // first time an octet is written. This is necessary to ensure |
| // that the body is aligned on an 8-octet boundary. Note the 'if' |
| // condition inside the 'while' loop below. Also, refer to the |
| // write_octet() method that has a similar change. |
| boolean align = true; |
| |
| while (n < length+offset) { |
| int avail; |
| int bytes; |
| int wanted; |
| |
| if ((bbwi.position() + 1 > bbwi.buflen) || align) { |
| align = false; |
| alignAndReserve(1, 1); |
| } |
| avail = bbwi.buflen - bbwi.position(); |
| wanted = (length + offset) - n; |
| bytes = (wanted < avail) ? wanted : avail; |
| for (int i = 0; i < bytes; i++) |
| bbwi.byteBuffer.put(bbwi.position() + i, value[n+i]); |
| bbwi.position(bbwi.position() + bytes); |
| n += bytes; |
| } |
| } |
| |
| public final void write_octet_array(byte b[], int offset, int length) |
| { |
| if ( b == null ) |
| throw wrapper.nullParam(CompletionStatus.COMPLETED_MAYBE); |
| |
| // This will only have an effect if we're already chunking |
| handleSpecialChunkBegin(length); |
| |
| internalWriteOctetArray(b, offset, length); |
| |
| // This will only have an effect if we're already chunking |
| handleSpecialChunkEnd(); |
| } |
| |
| public void write_Principal(Principal p) |
| { |
| write_long(p.name().length); |
| write_octet_array(p.name(), 0, p.name().length); |
| } |
| |
| public void write_any(Any any) |
| { |
| if ( any == null ) |
| throw wrapper.nullParam(CompletionStatus.COMPLETED_MAYBE); |
| |
| write_TypeCode(any.type()); |
| any.write_value(parent); |
| } |
| |
| public void write_TypeCode(TypeCode tc) |
| { |
| if ( tc == null ) { |
| throw wrapper.nullParam(CompletionStatus.COMPLETED_MAYBE); |
| } |
| TypeCodeImpl tci; |
| if (tc instanceof TypeCodeImpl) { |
| tci = (TypeCodeImpl)tc; |
| } |
| else { |
| tci = new TypeCodeImpl(orb, tc); |
| } |
| |
| tci.write_value((org.omg.CORBA_2_3.portable.OutputStream)parent); |
| } |
| |
| public void write_Object(org.omg.CORBA.Object ref) |
| { |
| if (ref == null) { |
| IOR nullIOR = IORFactories.makeIOR( orb ) ; |
| nullIOR.write(parent); |
| return; |
| } |
| |
| // IDL to Java formal 01-06-06 1.21.4.2 |
| if (ref instanceof org.omg.CORBA.LocalObject) |
| throw wrapper.writeLocalObject(CompletionStatus.COMPLETED_MAYBE); |
| |
| IOR ior = ORBUtility.connectAndGetIOR( orb, ref ) ; |
| ior.write(parent); |
| return; |
| } |
| |
| // ------------ RMI related methods -------------------------- |
| |
| public void write_abstract_interface(java.lang.Object obj) { |
| boolean corbaObject = false; // Assume value type. |
| org.omg.CORBA.Object theObject = null; |
| |
| // Is it a CORBA.Object? |
| |
| if (obj != null && obj instanceof org.omg.CORBA.Object) { |
| |
| // Yes. |
| |
| theObject = (org.omg.CORBA.Object)obj; |
| corbaObject = true; |
| } |
| |
| // Write our flag... |
| |
| write_boolean(corbaObject); |
| |
| // Now write out the object... |
| |
| if (corbaObject) { |
| write_Object(theObject); |
| } else { |
| try { |
| write_value((java.io.Serializable)obj); |
| } catch(ClassCastException cce) { |
| if (obj instanceof java.io.Serializable) |
| throw cce; |
| else |
| ORBUtility.throwNotSerializableForCorba(obj.getClass().getName()); |
| } |
| } |
| } |
| |
| public void write_value(Serializable object, Class clz) { |
| |
| write_value(object); |
| } |
| |
| private void writeWStringValue(String string) { |
| |
| int indirection = writeValueTag(mustChunk, true, null); |
| |
| // Write WStringValue's repository ID |
| write_repositoryId(repIdStrs.getWStringValueRepId()); |
| |
| // Add indirection for object to indirection table |
| updateIndirectionTable(indirection, string, string); |
| |
| // Write Value chunk |
| if (mustChunk) { |
| start_block(); |
| end_flag--; |
| chunkedValueNestingLevel--; |
| } else |
| end_flag--; |
| |
| write_wstring(string); |
| |
| if (mustChunk) |
| end_block(); |
| |
| // Write end tag |
| writeEndTag(mustChunk); |
| } |
| |
| private void writeArray(Serializable array, Class clazz) { |
| |
| if (valueHandler == null) |
| valueHandler = ORBUtility.createValueHandler(); //d11638 |
| |
| // Write value_tag |
| int indirection = writeValueTag(mustChunk, true, |
| Util.getCodebase(clazz)); |
| |
| // Write repository ID |
| write_repositoryId(repIdStrs.createSequenceRepID(clazz)); |
| |
| // Add indirection for object to indirection table |
| updateIndirectionTable(indirection, array, array); |
| |
| // Write Value chunk |
| if (mustChunk) { |
| start_block(); |
| end_flag--; |
| chunkedValueNestingLevel--; |
| } else |
| end_flag--; |
| |
| if (valueHandler instanceof ValueHandlerMultiFormat) { |
| ValueHandlerMultiFormat vh = (ValueHandlerMultiFormat)valueHandler; |
| vh.writeValue(parent, array, streamFormatVersion); |
| } else |
| valueHandler.writeValue(parent, array); |
| |
| if (mustChunk) |
| end_block(); |
| |
| // Write end tag |
| writeEndTag(mustChunk); |
| } |
| |
| private void writeValueBase(org.omg.CORBA.portable.ValueBase object, |
| Class clazz) { |
| // _REVISIT_ could check to see whether chunking really needed |
| mustChunk = true; |
| |
| // Write value_tag |
| int indirection = writeValueTag(true, true, Util.getCodebase(clazz)); |
| |
| // Get rep id |
| String repId = ((ValueBase)object)._truncatable_ids()[0]; |
| |
| // Write rep id |
| write_repositoryId(repId); |
| |
| // Add indirection for object to indirection table |
| updateIndirectionTable(indirection, object, object); |
| |
| // Write Value chunk |
| start_block(); |
| end_flag--; |
| chunkedValueNestingLevel--; |
| writeIDLValue(object, repId); |
| end_block(); |
| |
| // Write end tag |
| writeEndTag(true); |
| } |
| |
| private void writeRMIIIOPValueType(Serializable object, Class clazz) { |
| if (valueHandler == null) |
| valueHandler = ORBUtility.createValueHandler(); //d11638 |
| |
| Serializable key = object; |
| |
| // Allow the ValueHandler to call writeReplace on |
| // the Serializable (if the method is present) |
| object = valueHandler.writeReplace(key); |
| |
| if (object == null) { |
| // Write null tag and return |
| write_long(0); |
| return; |
| } |
| |
| if (object != key) { |
| if (valueCache != null && valueCache.containsKey(object)) { |
| writeIndirection(INDIRECTION_TAG, valueCache.getVal(object)); |
| return; |
| } |
| |
| clazz = object.getClass(); |
| } |
| |
| if (mustChunk || valueHandler.isCustomMarshaled(clazz)) { |
| mustChunk = true; |
| } |
| |
| // Write value_tag |
| int indirection = writeValueTag(mustChunk, true, Util.getCodebase(clazz)); |
| |
| // Write rep. id |
| write_repositoryId(repIdStrs.createForJavaType(clazz)); |
| |
| // Add indirection for object to indirection table |
| updateIndirectionTable(indirection, object, key); |
| |
| if (mustChunk) { |
| // Write Value chunk |
| end_flag--; |
| chunkedValueNestingLevel--; |
| start_block(); |
| } else |
| end_flag--; |
| |
| if (valueHandler instanceof ValueHandlerMultiFormat) { |
| ValueHandlerMultiFormat vh = (ValueHandlerMultiFormat)valueHandler; |
| vh.writeValue(parent, object, streamFormatVersion); |
| } else |
| valueHandler.writeValue(parent, object); |
| |
| if (mustChunk) |
| end_block(); |
| |
| // Write end tag |
| writeEndTag(mustChunk); |
| } |
| |
| public void write_value(Serializable object, String repository_id) { |
| |
| // Handle null references |
| if (object == null) { |
| // Write null tag and return |
| write_long(0); |
| return; |
| } |
| |
| // Handle shared references |
| if (valueCache != null && valueCache.containsKey(object)) { |
| writeIndirection(INDIRECTION_TAG, valueCache.getVal(object)); |
| return; |
| } |
| |
| Class clazz = object.getClass(); |
| boolean oldMustChunk = mustChunk; |
| |
| if (mustChunk) |
| mustChunk = true; |
| |
| if (inBlock) |
| end_block(); |
| |
| if (clazz.isArray()) { |
| // Handle arrays |
| writeArray(object, clazz); |
| } else if (object instanceof org.omg.CORBA.portable.ValueBase) { |
| // Handle IDL Value types |
| writeValueBase((org.omg.CORBA.portable.ValueBase)object, clazz); |
| } else if (shouldWriteAsIDLEntity(object)) { |
| writeIDLEntity((IDLEntity)object); |
| } else if (object instanceof java.lang.String) { |
| writeWStringValue((String)object); |
| } else if (object instanceof java.lang.Class) { |
| writeClass(repository_id, (Class)object); |
| } else { |
| // RMI-IIOP value type |
| writeRMIIIOPValueType(object, clazz); |
| } |
| |
| mustChunk = oldMustChunk; |
| |
| // Check to see if we need to start another block for a |
| // possible outer value |
| if (mustChunk) |
| start_block(); |
| |
| } |
| |
| public void write_value(Serializable object) |
| { |
| write_value(object, (String)null); |
| } |
| |
| public void write_value(Serializable object, org.omg.CORBA.portable.BoxedValueHelper factory) |
| { |
| // Handle null references |
| if (object == null) { |
| // Write null tag and return |
| write_long(0); |
| return; |
| } |
| |
| // Handle shared references |
| if ((valueCache != null) && valueCache.containsKey(object)) { |
| writeIndirection(INDIRECTION_TAG, valueCache.getVal(object)); |
| return; |
| } |
| |
| boolean oldMustChunk = mustChunk; |
| |
| boolean isCustom = false; |
| if (factory instanceof ValueHelper) { |
| short modifier; |
| try { |
| modifier = ((ValueHelper)factory).get_type().type_modifier(); |
| } catch(BadKind ex) { // tk_value_box |
| modifier = VM_NONE.value; |
| } |
| if (object instanceof CustomMarshal && |
| modifier == VM_CUSTOM.value) { |
| isCustom = true; |
| mustChunk = true; |
| } |
| if (modifier == VM_TRUNCATABLE.value) |
| mustChunk = true; |
| } |
| |
| if (mustChunk) { |
| |
| if (inBlock) |
| end_block(); |
| |
| // Write value_tag |
| int indirection = writeValueTag(true, |
| orb.getORBData().useRepId(), |
| Util.getCodebase(object.getClass()) |
| ); |
| |
| if (orb.getORBData().useRepId()) { |
| write_repositoryId(factory.get_id()); |
| } |
| |
| // Add indirection for object to indirection table |
| updateIndirectionTable(indirection, object, object); |
| |
| // Write Value chunk |
| start_block(); |
| end_flag--; |
| chunkedValueNestingLevel--; |
| if (isCustom) |
| ((CustomMarshal)object).marshal(parent); |
| else |
| factory.write_value(parent, object); |
| end_block(); |
| |
| // Write end tag |
| writeEndTag(true); |
| } |
| else { |
| // Write value_tag |
| int indirection = writeValueTag(false, |
| orb.getORBData().useRepId(), |
| Util.getCodebase(object.getClass()) |
| ); |
| |
| if (orb.getORBData().useRepId()) { |
| write_repositoryId(factory.get_id()); |
| } |
| |
| // Add indirection for object to indirection table |
| updateIndirectionTable(indirection, object, object); |
| |
| // Write Value chunk |
| end_flag--; |
| // no need to test for custom on the non-chunked path |
| factory.write_value(parent, object); |
| |
| // Write end tag |
| writeEndTag(false); |
| } |
| |
| mustChunk = oldMustChunk; |
| |
| // Check to see if we need to start another block for a |
| // possible outer value |
| if (mustChunk) |
| start_block(); |
| |
| } |
| |
| public int get_offset() { |
| return bbwi.position(); |
| } |
| |
| public void start_block() { |
| if (debug) { |
| dprint("CDROutputStream_1_0 start_block, position" + bbwi.position()); |
| } |
| |
| //Move inBlock=true to after write_long since write_long might |
| //trigger grow which will lead to erroneous behavior with a |
| //missing blockSizeIndex. |
| //inBlock = true; |
| |
| // Save space in the buffer for block size |
| write_long(0); |
| |
| //Has to happen after write_long since write_long could |
| //trigger grow which is overridden by supper classes to |
| //depend on inBlock. |
| inBlock = true; |
| |
| blockSizePosition = get_offset(); |
| |
| // Remember where to put the size of the endblock less 4 |
| blockSizeIndex = bbwi.position(); |
| |
| if (debug) { |
| dprint("CDROutputStream_1_0 start_block, blockSizeIndex " |
| + blockSizeIndex); |
| } |
| |
| } |
| |
| // Utility method which will hopefully decrease chunking complexity |
| // by allowing us to end_block and update chunk lengths without |
| // calling alignAndReserve. Otherwise, it's possible to get into |
| // recursive scenarios which lose the chunking state. |
| protected void writeLongWithoutAlign(int x) { |
| if (littleEndian) { |
| writeLittleEndianLong(x); |
| } else { |
| writeBigEndianLong(x); |
| } |
| } |
| |
| public void end_block() { |
| if (debug) { |
| dprint("CDROutputStream_1_0.java end_block"); |
| } |
| |
| if (!inBlock) |
| return; |
| |
| if (debug) { |
| dprint("CDROutputStream_1_0.java end_block, in a block"); |
| } |
| |
| inBlock = false; |
| |
| // Test to see if the block was of zero length |
| // If so, remove the block instead of ending it |
| // (This can happen if the last field written |
| // in a value was another value) |
| if (get_offset() == blockSizePosition) { |
| // Need to assert that blockSizeIndex == bbwi.position()? REVISIT |
| |
| bbwi.position(bbwi.position() - 4); |
| blockSizeIndex = -1; |
| blockSizePosition = -1; |
| return; |
| } |
| |
| int oldSize = bbwi.position(); |
| bbwi.position(blockSizeIndex - 4); |
| |
| writeLongWithoutAlign(oldSize - blockSizeIndex); |
| |
| bbwi.position(oldSize); |
| blockSizeIndex = -1; |
| blockSizePosition = -1; |
| |
| // System.out.println(" post end_block: " + get_offset() + " " + bbwi.position()); |
| } |
| |
| public org.omg.CORBA.ORB orb() |
| { |
| return orb; |
| } |
| |
| // ------------ End RMI related methods -------------------------- |
| |
| public final void write_boolean_array(boolean[]value, int offset, int length) { |
| if ( value == null ) |
| throw wrapper.nullParam(CompletionStatus.COMPLETED_MAYBE); |
| |
| // This will only have an effect if we're already chunking |
| handleSpecialChunkBegin(length); |
| |
| for (int i = 0; i < length; i++) |
| write_boolean(value[offset + i]); |
| |
| // This will only have an effect if we're already chunking |
| handleSpecialChunkEnd(); |
| } |
| |
| public final void write_char_array(char[]value, int offset, int length) { |
| if ( value == null ) |
| throw wrapper.nullParam(CompletionStatus.COMPLETED_MAYBE); |
| |
| // This will only have an effect if we're already chunking |
| handleSpecialChunkBegin(length); |
| |
| for (int i = 0; i < length; i++) |
| write_char(value[offset + i]); |
| |
| // This will only have an effect if we're already chunking |
| handleSpecialChunkEnd(); |
| } |
| |
| public void write_wchar_array(char[]value, int offset, int length) { |
| if ( value == null ) |
| throw wrapper.nullParam(CompletionStatus.COMPLETED_MAYBE); |
| |
| // This will only have an effect if we're already chunking |
| handleSpecialChunkBegin(computeAlignment(2) + (length * 2)); |
| |
| for (int i = 0; i < length; i++) |
| write_wchar(value[offset + i]); |
| |
| // This will only have an effect if we're already chunking |
| handleSpecialChunkEnd(); |
| } |
| |
| public final void write_short_array(short[]value, int offset, int length) { |
| if ( value == null ) |
| throw wrapper.nullParam(CompletionStatus.COMPLETED_MAYBE); |
| |
| // This will only have an effect if we're already chunking |
| handleSpecialChunkBegin(computeAlignment(2) + (length * 2)); |
| |
| for (int i = 0; i < length; i++) |
| write_short(value[offset + i]); |
| |
| // This will only have an effect if we're already chunking |
| handleSpecialChunkEnd(); |
| } |
| |
| public final void write_ushort_array(short[]value, int offset, int length) { |
| write_short_array(value, offset, length); |
| } |
| |
| public final void write_long_array(int[]value, int offset, int length) { |
| if ( value == null ) |
| throw wrapper.nullParam(CompletionStatus.COMPLETED_MAYBE); |
| |
| // This will only have an effect if we're already chunking |
| handleSpecialChunkBegin(computeAlignment(4) + (length * 4)); |
| |
| for (int i = 0; i < length; i++) |
| write_long(value[offset + i]); |
| |
| // This will only have an effect if we're already chunking |
| handleSpecialChunkEnd(); |
| } |
| |
| public final void write_ulong_array(int[]value, int offset, int length) { |
| write_long_array(value, offset, length); |
| } |
| |
| public final void write_longlong_array(long[]value, int offset, int length) { |
| if ( value == null ) |
| throw wrapper.nullParam(CompletionStatus.COMPLETED_MAYBE); |
| |
| // This will only have an effect if we're already chunking |
| handleSpecialChunkBegin(computeAlignment(8) + (length * 8)); |
| |
| for (int i = 0; i < length; i++) |
| write_longlong(value[offset + i]); |
| |
| // This will only have an effect if we're already chunking |
| handleSpecialChunkEnd(); |
| } |
| |
| public final void write_ulonglong_array(long[]value, int offset, int length) { |
| write_longlong_array(value, offset, length); |
| } |
| |
| public final void write_float_array(float[]value, int offset, int length) { |
| if ( value == null ) |
| throw wrapper.nullParam(CompletionStatus.COMPLETED_MAYBE); |
| |
| // This will only have an effect if we're already chunking |
| handleSpecialChunkBegin(computeAlignment(4) + (length * 4)); |
| |
| for (int i = 0; i < length; i++) |
| write_float(value[offset + i]); |
| |
| // This will only have an effect if we're already chunking |
| handleSpecialChunkEnd(); |
| } |
| |
| public final void write_double_array(double[]value, int offset, int length) { |
| if ( value == null ) |
| throw wrapper.nullParam(CompletionStatus.COMPLETED_MAYBE); |
| |
| // This will only have an effect if we're already chunking |
| handleSpecialChunkBegin(computeAlignment(8) + (length * 8)); |
| |
| for (int i = 0; i < length; i++) |
| write_double(value[offset + i]); |
| |
| // This will only have an effect if we're already chunking |
| handleSpecialChunkEnd(); |
| } |
| |
| public void write_string_array(String[] value, int offset, int length) { |
| if ( value == null ) |
| throw wrapper.nullParam(CompletionStatus.COMPLETED_MAYBE); |
| |
| for(int i = 0; i < length; i++) |
| write_string(value[offset + i]); |
| } |
| |
| public void write_wstring_array(String[] value, int offset, int length) { |
| if ( value == null ) |
| throw wrapper.nullParam(CompletionStatus.COMPLETED_MAYBE); |
| |
| for(int i = 0; i < length; i++) |
| write_wstring(value[offset + i]); |
| } |
| |
| public final void write_any_array(org.omg.CORBA.Any value[], int offset, int length) |
| { |
| for(int i = 0; i < length; i++) |
| write_any(value[offset + i]); |
| } |
| |
| //--------------------------------------------------------------------// |
| // CDROutputStream state management. |
| // |
| |
| public void writeTo(java.io.OutputStream s) |
| throws java.io.IOException |
| { |
| byte[] tmpBuf = null; |
| |
| if (bbwi.byteBuffer.hasArray()) |
| { |
| tmpBuf = bbwi.byteBuffer.array(); |
| } |
| else |
| { |
| int size = bbwi.position(); |
| tmpBuf = new byte[size]; |
| // Micro-benchmarks are showing a loop of ByteBuffer.get(int) is |
| // faster than ByteBuffer.get(byte[], offset, length) |
| for (int i = 0; i < size; i++) |
| tmpBuf[i] = bbwi.byteBuffer.get(i); |
| } |
| |
| s.write(tmpBuf, 0, bbwi.position()); |
| } |
| |
| public void writeOctetSequenceTo(org.omg.CORBA.portable.OutputStream s) { |
| |
| byte[] buf = null; |
| |
| if (bbwi.byteBuffer.hasArray()) |
| { |
| buf = bbwi.byteBuffer.array(); |
| } |
| else |
| { |
| int size = bbwi.position(); |
| buf = new byte[size]; |
| // Micro-benchmarks are showing a loop of ByteBuffer.get(int) is |
| // faster than ByteBuffer.get(byte[], offset, length) |
| for (int i = 0; i < size; i++) |
| buf[i] = bbwi.byteBuffer.get(i); |
| } |
| |
| s.write_long(bbwi.position()); |
| s.write_octet_array(buf, 0, bbwi.position()); |
| |
| } |
| |
| public final int getSize() { |
| return bbwi.position(); |
| } |
| |
| public int getIndex() { |
| return bbwi.position(); |
| } |
| |
| public boolean isLittleEndian() { |
| return littleEndian; |
| } |
| |
| public void setIndex(int value) { |
| bbwi.position(value); |
| } |
| |
| public ByteBufferWithInfo getByteBufferWithInfo() { |
| return bbwi; |
| } |
| |
| public void setByteBufferWithInfo(ByteBufferWithInfo bbwi) { |
| this.bbwi = bbwi; |
| } |
| |
| public ByteBuffer getByteBuffer() { |
| ByteBuffer result = null;; |
| if (bbwi != null) { |
| result = bbwi.byteBuffer; |
| } |
| return result; |
| } |
| |
| public void setByteBuffer(ByteBuffer byteBuffer) { |
| bbwi.byteBuffer = byteBuffer; |
| } |
| |
| private final void updateIndirectionTable(int indirection, java.lang.Object object, |
| java.lang.Object key) { |
| // int indirection = get_offset(); |
| if (valueCache == null) |
| valueCache = new CacheTable(orb,true); |
| valueCache.put(object, indirection); |
| if (key != object) |
| valueCache.put(key, indirection); |
| } |
| |
| private final void write_repositoryId(String id) { |
| // Use an indirection if available |
| if (repositoryIdCache != null && repositoryIdCache.containsKey(id)) { |
| writeIndirection(INDIRECTION_TAG, repositoryIdCache.getVal(id)); |
| return; |
| } |
| |
| // Write it as a string. Note that we have already done the |
| // special case conversion of non-Latin-1 characters to escaped |
| // Latin-1 sequences in RepositoryId. |
| |
| // It's not a good idea to cache them now that we can have |
| // multiple code sets. |
| int indirection = writeString(id); |
| |
| // Add indirection for id to indirection table |
| if (repositoryIdCache == null) |
| repositoryIdCache = new CacheTable(orb,true); |
| repositoryIdCache.put(id, indirection); |
| } |
| |
| private void write_codebase(String str, int pos) { |
| if (codebaseCache != null && codebaseCache.containsKey(str)) { |
| writeIndirection(INDIRECTION_TAG, codebaseCache.getVal(str)); |
| } |
| else { |
| write_string(str); |
| if (codebaseCache == null) |
| codebaseCache = new CacheTable(orb,true); |
| codebaseCache.put(str, pos); |
| } |
| } |
| |
| private final int writeValueTag(boolean chunkIt, boolean useRepId, |
| String codebase) { |
| int indirection = 0; |
| if (chunkIt && !useRepId){ |
| if (codebase == null) { |
| write_long(repIdUtil.getStandardRMIChunkedNoRepStrId()); |
| indirection = get_offset() - 4; |
| } else { |
| write_long(repIdUtil.getCodeBaseRMIChunkedNoRepStrId()); |
| indirection = get_offset() - 4; |
| write_codebase(codebase, get_offset()); |
| } |
| } else if (chunkIt && useRepId){ |
| if (codebase == null) { |
| write_long(repIdUtil.getStandardRMIChunkedId()); |
| indirection = get_offset() - 4; |
| } else { |
| write_long(repIdUtil.getCodeBaseRMIChunkedId()); |
| indirection = get_offset() - 4; |
| write_codebase(codebase, get_offset()); |
| } |
| } else if (!chunkIt && !useRepId) { |
| if (codebase == null) { |
| write_long(repIdUtil.getStandardRMIUnchunkedNoRepStrId()); |
| indirection = get_offset() - 4; |
| } else { |
| write_long(repIdUtil.getCodeBaseRMIUnchunkedNoRepStrId()); |
| indirection = get_offset() - 4; |
| write_codebase(codebase, get_offset()); |
| } |
| } else if (!chunkIt && useRepId) { |
| if (codebase == null) { |
| write_long(repIdUtil.getStandardRMIUnchunkedId()); |
| indirection = get_offset() - 4; |
| } else { |
| write_long(repIdUtil.getCodeBaseRMIUnchunkedId()); |
| indirection = get_offset() - 4; |
| write_codebase(codebase, get_offset()); |
| } |
| } |
| return indirection; |
| } |
| |
| private void writeIDLValue(Serializable object, String repID) |
| { |
| if (object instanceof StreamableValue) { |
| ((StreamableValue)object)._write(parent); |
| |
| } else if (object instanceof CustomValue) { |
| ((CustomValue)object).marshal(parent); |
| |
| } else { |
| BoxedValueHelper helper = Utility.getHelper(object.getClass(), null, repID); |
| boolean isCustom = false; |
| if (helper instanceof ValueHelper && object instanceof CustomMarshal) { |
| try { |
| if (((ValueHelper)helper).get_type().type_modifier() == VM_CUSTOM.value) |
| isCustom = true; |
| } catch(BadKind ex) { |
| throw wrapper.badTypecodeForCustomValue( CompletionStatus.COMPLETED_MAYBE, |
| ex ) ; |
| } |
| } |
| if (isCustom) |
| ((CustomMarshal)object).marshal(parent); |
| else |
| helper.write_value(parent, object); |
| } |
| } |
| |
| // Handles end tag compaction... |
| private void writeEndTag(boolean chunked){ |
| |
| if (chunked) { |
| if (get_offset() == end_flag_position) { |
| |
| if (bbwi.position() == end_flag_index) { |
| |
| // We are exactly at the same position and index as the |
| // end of the last end tag. Thus, we can back up over it |
| // and compact the tags. |
| bbwi.position(bbwi.position() - 4); |
| |
| } else { |
| |
| // Special case in which we're at the beginning of a new |
| // fragment, but the position is the same. We can't back up, |
| // so we just write the new end tag without compaction. This |
| // occurs when a value ends and calls start_block to open a |
| // continuation chunk, but it's called at the very end of |
| // a fragment. |
| } |
| } |
| |
| writeNestingLevel(); |
| |
| // Remember the last index and position. These are only used when chunking. |
| end_flag_index = bbwi.position(); |
| end_flag_position = get_offset(); |
| |
| chunkedValueNestingLevel++; |
| } |
| |
| // Increment the nesting level |
| end_flag++; |
| } |
| |
| /** |
| * Handles ORB versioning of the end tag. Should only |
| * be called if chunking. |
| * |
| * If talking to our older ORBs (Standard Extension, |
| * Kestrel, and Ladybird), write the end flag that takes |
| * into account all enclosing valuetypes. |
| * |
| * If talking a newer or foreign ORB, or if the orb |
| * instance is null, write the end flag that only takes |
| * into account the enclosing chunked valuetypes. |
| */ |
| private void writeNestingLevel() { |
| if (orb == null || |
| ORBVersionFactory.getFOREIGN().equals(orb.getORBVersion()) || |
| ORBVersionFactory.getNEWER().compareTo(orb.getORBVersion()) <= 0) { |
| |
| write_long(chunkedValueNestingLevel); |
| |
| } else { |
| write_long(end_flag); |
| } |
| } |
| |
| private void writeClass(String repository_id, Class clz) { |
| |
| if (repository_id == null) |
| repository_id = repIdStrs.getClassDescValueRepId(); |
| |
| // Write value_tag |
| int indirection = writeValueTag(mustChunk, true, null); |
| updateIndirectionTable(indirection, clz, clz); |
| |
| write_repositoryId(repository_id); |
| |
| if (mustChunk) { |
| // Write Value chunk |
| start_block(); |
| end_flag--; |
| chunkedValueNestingLevel--; |
| } else |
| end_flag--; |
| |
| writeClassBody(clz); |
| |
| if (mustChunk) |
| end_block(); |
| |
| // Write end tag |
| writeEndTag(mustChunk); |
| } |
| |
| // Pre-Merlin/J2EE 1.3 ORBs wrote the repository ID |
| // and codebase strings in the wrong order. This handles |
| // backwards compatibility. |
| private void writeClassBody(Class clz) { |
| if (orb == null || |
| ORBVersionFactory.getFOREIGN().equals(orb.getORBVersion()) || |
| ORBVersionFactory.getNEWER().compareTo(orb.getORBVersion()) <= 0) { |
| |
| write_value(Util.getCodebase(clz)); |
| write_value(repIdStrs.createForAnyType(clz)); |
| } else { |
| |
| write_value(repIdStrs.createForAnyType(clz)); |
| write_value(Util.getCodebase(clz)); |
| } |
| } |
| |
| // Casts and returns an Object as a Serializable |
| // This is required for JDK 1.1 only to avoid VerifyErrors when |
| // passing arrays as Serializable |
| // private java.io.Serializable make_serializable(java.lang.Object object) |
| // { |
| // return (java.io.Serializable)object; |
| // } |
| |
| private boolean shouldWriteAsIDLEntity(Serializable object) |
| { |
| return ((object instanceof IDLEntity) && (!(object instanceof ValueBase)) && |
| (!(object instanceof org.omg.CORBA.Object))); |
| |
| } |
| |
| private void writeIDLEntity(IDLEntity object) { |
| |
| // _REVISIT_ could check to see whether chunking really needed |
| mustChunk = true; |
| |
| String repository_id = repIdStrs.createForJavaType(object); |
| Class clazz = object.getClass(); |
| String codebase = Util.getCodebase(clazz); |
| |
| // Write value_tag |
| int indirection = writeValueTag(true, true, codebase); |
| updateIndirectionTable(indirection, object, object); |
| |
| // Write rep. id |
| write_repositoryId(repository_id); |
| |
| // Write Value chunk |
| end_flag--; |
| chunkedValueNestingLevel--; |
| start_block(); |
| |
| // Write the IDLEntity using reflection |
| try { |
| ClassLoader clazzLoader = (clazz == null ? null : clazz.getClassLoader()); |
| final Class helperClass = Utility.loadClassForClass(clazz.getName()+"Helper", codebase, |
| clazzLoader, clazz, clazzLoader); |
| final Class argTypes[] = {org.omg.CORBA.portable.OutputStream.class, clazz}; |
| // getDeclaredMethod requires RuntimePermission accessDeclaredMembers |
| // if a different class loader is used (even though the javadoc says otherwise) |
| Method writeMethod = null; |
| try { |
| writeMethod = (Method)AccessController.doPrivileged( |
| new PrivilegedExceptionAction() { |
| public java.lang.Object run() throws NoSuchMethodException { |
| return helperClass.getDeclaredMethod(kWriteMethod, argTypes); |
| } |
| } |
| ); |
| } catch (PrivilegedActionException pae) { |
| // this gets caught below |
| throw (NoSuchMethodException)pae.getException(); |
| } |
| java.lang.Object args[] = {parent, object}; |
| writeMethod.invoke(null, args); |
| } catch (ClassNotFoundException cnfe) { |
| throw wrapper.errorInvokingHelperWrite( CompletionStatus.COMPLETED_MAYBE, cnfe ) ; |
| } catch(NoSuchMethodException nsme) { |
| throw wrapper.errorInvokingHelperWrite( CompletionStatus.COMPLETED_MAYBE, nsme ) ; |
| } catch(IllegalAccessException iae) { |
| throw wrapper.errorInvokingHelperWrite( CompletionStatus.COMPLETED_MAYBE, iae ) ; |
| } catch(InvocationTargetException ite) { |
| throw wrapper.errorInvokingHelperWrite( CompletionStatus.COMPLETED_MAYBE, ite ) ; |
| } |
| end_block(); |
| |
| // Write end tag |
| writeEndTag(true); |
| } |
| |
| /* DataOutputStream methods */ |
| |
| public void write_Abstract (java.lang.Object value) { |
| write_abstract_interface(value); |
| } |
| |
| public void write_Value (java.io.Serializable value) { |
| write_value(value); |
| } |
| |
| // This will stay a custom add-on until the java-rtf issue is resolved. |
| // Then it should be declared in org.omg.CORBA.portable.OutputStream. |
| // |
| // Pads the string representation of bigDecimal with zeros to fit the given |
| // digits and scale before it gets written to the stream. |
| public void write_fixed(java.math.BigDecimal bigDecimal, short digits, short scale) { |
| String string = bigDecimal.toString(); |
| String integerPart; |
| String fractionPart; |
| StringBuffer stringBuffer; |
| |
| // Get rid of the sign |
| if (string.charAt(0) == '-' || string.charAt(0) == '+') { |
| string = string.substring(1); |
| } |
| |
| // Determine integer and fraction parts |
| int dotIndex = string.indexOf('.'); |
| if (dotIndex == -1) { |
| integerPart = string; |
| fractionPart = null; |
| } else if (dotIndex == 0 ) { |
| integerPart = null; |
| fractionPart = string; |
| } else { |
| integerPart = string.substring(0, dotIndex); |
| fractionPart = string.substring(dotIndex + 1); |
| } |
| |
| // Pad both parts with zeros as necessary |
| stringBuffer = new StringBuffer(digits); |
| if (fractionPart != null) { |
| stringBuffer.append(fractionPart); |
| } |
| while (stringBuffer.length() < scale) { |
| stringBuffer.append('0'); |
| } |
| if (integerPart != null) { |
| stringBuffer.insert(0, integerPart); |
| } |
| while (stringBuffer.length() < digits) { |
| stringBuffer.insert(0, '0'); |
| } |
| |
| // This string contains no sign or dot |
| this.write_fixed(stringBuffer.toString(), bigDecimal.signum()); |
| } |
| |
| // This method should be remove by the java-rtf issue. |
| // Right now the scale and digits information of the type code is lost. |
| public void write_fixed(java.math.BigDecimal bigDecimal) { |
| // This string might contain sign and/or dot |
| this.write_fixed(bigDecimal.toString(), bigDecimal.signum()); |
| } |
| |
| // The string may contain a sign and dot |
| public void write_fixed(String string, int signum) { |
| int stringLength = string.length(); |
| // Each octet contains (up to) two decimal digits |
| byte doubleDigit = 0; |
| char ch; |
| byte digit; |
| |
| // First calculate the length of the string without optional sign and dot |
| int numDigits = 0; |
| for (int i=0; i<stringLength; i++) { |
| ch = string.charAt(i); |
| if (ch == '-' || ch == '+' || ch == '.') |
| continue; |
| numDigits++; |
| } |
| for (int i=0; i<stringLength; i++) { |
| ch = string.charAt(i); |
| if (ch == '-' || ch == '+' || ch == '.') |
| continue; |
| digit = (byte)Character.digit(ch, 10); |
| if (digit == -1) { |
| throw wrapper.badDigitInFixed( CompletionStatus.COMPLETED_MAYBE ) ; |
| } |
| // If the fixed type has an odd number of decimal digits, |
| // then the representation begins with the first (most significant) digit. |
| // Otherwise, this first half-octet is all zero, and the first digit |
| // is in the second half-octet. |
| if (numDigits % 2 == 0) { |
| doubleDigit |= digit; |
| this.write_octet(doubleDigit); |
| doubleDigit = 0; |
| } else { |
| doubleDigit |= (digit << 4); |
| } |
| numDigits--; |
| } |
| // The sign configuration, in the last half-octet of the representation, |
| // is 0xD for negative numbers and 0xC for positive and zero values |
| if (signum == -1) { |
| doubleDigit |= 0xd; |
| } else { |
| doubleDigit |= 0xc; |
| } |
| this.write_octet(doubleDigit); |
| } |
| |
| private final static String _id = "IDL:omg.org/CORBA/DataOutputStream:1.0"; |
| private final static String[] _ids = { _id }; |
| |
| public String[] _truncatable_ids() { |
| if (_ids == null) |
| return null; |
| |
| return (String[])_ids.clone(); |
| } |
| |
| /* for debugging */ |
| |
| public void printBuffer() { |
| CDROutputStream_1_0.printBuffer(this.bbwi); |
| } |
| |
| public static void printBuffer(ByteBufferWithInfo bbwi) { |
| |
| System.out.println("+++++++ Output Buffer ++++++++"); |
| System.out.println(); |
| System.out.println("Current position: " + bbwi.position()); |
| System.out.println("Total length : " + bbwi.buflen); |
| System.out.println(); |
| |
| char[] charBuf = new char[16]; |
| |
| try { |
| |
| for (int i = 0; i < bbwi.position(); i += 16) { |
| |
| int j = 0; |
| |
| // For every 16 bytes, there is one line |
| // of output. First, the hex output of |
| // the 16 bytes with each byte separated |
| // by a space. |
| while (j < 16 && j + i < bbwi.position()) { |
| int k = bbwi.byteBuffer.get(i + j); |
| if (k < 0) |
| k = 256 + k; |
| String hex = Integer.toHexString(k); |
| if (hex.length() == 1) |
| hex = "0" + hex; |
| System.out.print(hex + " "); |
| j++; |
| } |
| |
| // Add any extra spaces to align the |
| // text column in case we didn't end |
| // at 16 |
| while (j < 16) { |
| System.out.print(" "); |
| j++; |
| } |
| |
| // Now output the ASCII equivalents. Non-ASCII |
| // characters are shown as periods. |
| int x = 0; |
| |
| while (x < 16 && x + i < bbwi.position()) { |
| if (ORBUtility.isPrintable((char)bbwi.byteBuffer.get(i + x))) |
| charBuf[x] = (char)bbwi.byteBuffer.get(i + x); |
| else |
| charBuf[x] = '.'; |
| x++; |
| } |
| System.out.println(new String(charBuf, 0, x)); |
| } |
| } catch (Throwable t) { |
| t.printStackTrace(); |
| } |
| System.out.println("++++++++++++++++++++++++++++++"); |
| } |
| |
| public void writeIndirection(int tag, int posIndirectedTo) |
| { |
| // Must ensure that there are no chunks between the tag |
| // and the actual indirection value. This isn't talked about |
| // in the spec, but seems to cause headaches in our code. |
| // At the very least, this method isolates the indirection code |
| // that was duplicated so often. |
| |
| handleSpecialChunkBegin(computeAlignment(4) + 8); |
| |
| // write indirection tag |
| write_long(tag); |
| |
| // write indirection |
| // Use parent.getRealIndex() so that it can be overridden by TypeCodeOutputStreams |
| /* |
| System.out.println("CDROutputStream_1_0 writing indirection pos " + posIndirectedTo + |
| " - real index " + parent.getRealIndex(get_offset()) + " = " + |
| (posIndirectedTo - parent.getRealIndex(get_offset()))); |
| */ |
| write_long(posIndirectedTo - parent.getRealIndex(get_offset())); |
| |
| handleSpecialChunkEnd(); |
| } |
| |
| protected CodeSetConversion.CTBConverter getCharConverter() { |
| if (charConverter == null) |
| charConverter = parent.createCharCTBConverter(); |
| |
| return charConverter; |
| } |
| |
| protected CodeSetConversion.CTBConverter getWCharConverter() { |
| if (wcharConverter == null) |
| wcharConverter = parent.createWCharCTBConverter(); |
| |
| return wcharConverter; |
| } |
| |
| protected void dprint(String msg) { |
| if (debug) |
| ORBUtility.dprint(this, msg); |
| } |
| |
| void alignOnBoundary(int octetBoundary) { |
| alignAndReserve(octetBoundary, 0); |
| } |
| |
| public void start_value(String rep_id) { |
| |
| if (debug) { |
| dprint("start_value w/ rep id " |
| + rep_id |
| + " called at pos " |
| + get_offset() |
| + " position " |
| + bbwi.position()); |
| } |
| |
| if (inBlock) |
| end_block(); |
| |
| // Write value_tag |
| writeValueTag(true, true, null); |
| |
| // Write rep. id |
| write_repositoryId(rep_id); |
| |
| // Write Value chunk |
| end_flag--; |
| chunkedValueNestingLevel--; |
| |
| // Make sure to chunk the custom data |
| start_block(); |
| } |
| |
| public void end_value() { |
| |
| if (debug) { |
| dprint("end_value called at pos " |
| + get_offset() |
| + " position " |
| + bbwi.position()); |
| } |
| |
| end_block(); |
| |
| writeEndTag(true); |
| |
| // Check to see if we need to start another block for a |
| // possible outer value. Since we're in the stream |
| // format 2 custom type contained by another custom |
| // type, mustChunk should always be true. |
| // |
| // Here's why we need to open a continuation chunk: |
| // |
| // We need to enclose the default data of the |
| // next subclass down in chunks. There won't be |
| // an end tag separating the superclass optional |
| // data and the subclass's default data. |
| |
| if (debug) { |
| dprint("mustChunk is " + mustChunk); |
| } |
| |
| if (mustChunk) { |
| start_block(); |
| } |
| } |
| |
| public void close() throws IOException |
| { |
| // tell BufferManagerWrite to release any ByteBuffers |
| getBufferManager().close(); |
| |
| // It's possible bbwi.byteBuffer is shared between |
| // this OutputStream and an InputStream. Thus, we check |
| // if the Input/Output streams are using the same ByteBuffer. |
| // If they sharing the same ByteBuffer we need to ensure only |
| // one of those ByteBuffers are released to the ByteBufferPool. |
| |
| if (getByteBufferWithInfo() != null && getByteBuffer() != null) |
| { |
| MessageMediator messageMediator = parent.getMessageMediator(); |
| if (messageMediator != null) |
| { |
| CDRInputObject inputObj = |
| (CDRInputObject)messageMediator.getInputObject(); |
| if (inputObj != null) |
| { |
| if (inputObj.isSharing(getByteBuffer())) |
| { |
| // Set InputStream's ByteBuffer and bbwi to null |
| // so its ByteBuffer cannot be released to the pool |
| inputObj.setByteBuffer(null); |
| inputObj.setByteBufferWithInfo(null); |
| } |
| } |
| } |
| |
| // release this stream's ByteBuffer to the pool |
| ByteBufferPool byteBufferPool = orb.getByteBufferPool(); |
| if (debug) |
| { |
| // print address of ByteBuffer being released |
| int bbAddress = System.identityHashCode(bbwi.byteBuffer); |
| StringBuffer sb = new StringBuffer(80); |
| sb.append(".close - releasing ByteBuffer id ("); |
| sb.append(bbAddress).append(") to ByteBufferPool."); |
| String msg = sb.toString(); |
| dprint(msg); |
| } |
| byteBufferPool.releaseByteBuffer(getByteBuffer()); |
| bbwi.byteBuffer = null; |
| bbwi = null; |
| } |
| } |
| } |
