Java example source code file (IDLJavaSerializationOutputStream.java)

This example Java source code file (IDLJavaSerializationOutputStream.java) is included in the alvinalexander.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Learn more about this Java project at its project page.

Java - Java tags/keywords

buffermanagerwrite, bytebuffer, bytebufferwithinfo, corba, exception, idljavaserializationoutputstream, ioexception, ior, marshalobjectoutputstream, nio, object, orb, string, stringbuffer, throwable, typecodeimpl

The IDLJavaSerializationOutputStream.java Java example source code

/*
 * Copyright (c) 2004, 2013, 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.
 */
package com.sun.corba.se.impl.encoding;

import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.ByteArrayOutputStream;

import java.nio.ByteBuffer;

import com.sun.corba.se.spi.orb.ORB;
import com.sun.corba.se.spi.ior.IOR;
import com.sun.corba.se.spi.ior.IORFactories;
import com.sun.corba.se.spi.ior.iiop.GIOPVersion;
import com.sun.corba.se.spi.logging.CORBALogDomains;
import com.sun.corba.se.spi.presentation.rmi.StubAdapter;

import com.sun.corba.se.impl.util.Utility;
import com.sun.corba.se.impl.orbutil.ORBConstants;
import com.sun.corba.se.impl.orbutil.ORBUtility;
import com.sun.corba.se.impl.corba.TypeCodeImpl;
import com.sun.corba.se.impl.logging.ORBUtilSystemException;
import com.sun.corba.se.impl.protocol.giopmsgheaders.Message;

import org.omg.CORBA.Any;
import org.omg.CORBA.TypeCode;
import org.omg.CORBA.Principal;
import org.omg.CORBA.CompletionStatus;

/**
 * Implementation class that uses Java serialization for output streams.
 * This assumes a GIOP version 1.2 message format.
 *
 * This class uses a ByteArrayOutputStream as the underlying buffer. The
 * first 16 bytes are direct writes into the underlying buffer. This allows
 * [GIOPHeader (12 bytes) + requestID (4 bytes)] to be written as bytes.
 * Subsequent write operations on this output stream object uses
 * ObjectOutputStream class to write into the buffer. This allows marshaling
 * complex types and graphs using the ObjectOutputStream implementation.
 *
 * Note, this class assumes a GIOP 1.2 style header. Note, we expect that the
 * first 16 bytes are written only using the write_octet, write_long or
 * write_ulong method calls.
 *
 * @author Ram Jeyaraman
 */
final class IDLJavaSerializationOutputStream extends CDROutputStreamBase {

    private ORB orb;
    private byte encodingVersion;
    private ObjectOutputStream os;
    private _ByteArrayOutputStream bos;
    private BufferManagerWrite bufferManager;

    // [GIOPHeader(12) + requestID(4)] bytes
    private final int directWriteLength = Message.GIOPMessageHeaderLength + 4;

    protected ORBUtilSystemException wrapper;

    class _ByteArrayOutputStream extends ByteArrayOutputStream {

        _ByteArrayOutputStream(int initialSize) {
            super(initialSize);
        }

        byte[] getByteArray() {
            return this.buf;
        }
    }

    class MarshalObjectOutputStream extends ObjectOutputStream {

        ORB orb;

        MarshalObjectOutputStream(java.io.OutputStream out, ORB orb)
                throws IOException {

            super(out);
            this.orb = orb;
            java.security.AccessController.doPrivileged(
                new java.security.PrivilegedAction() {
                    public Object run() {
                        // needs SerializablePermission("enableSubstitution")
                        enableReplaceObject(true);
                        return null;
                    }
                }
            );
        }

        /**
         * Checks for objects that are instances of java.rmi.Remote
         * that need to be serialized as proxy (Stub) objects.
         */
        protected final Object replaceObject(Object obj) throws IOException {
            try {
                if ((obj instanceof java.rmi.Remote) &&
                        !(StubAdapter.isStub(obj))) {
                    return Utility.autoConnect(obj, orb, true);
                }
            } catch (Exception e) {
                IOException ie = new IOException("replaceObject failed");
                ie.initCause(e);
                throw ie;
            }
            return obj;
        }
    }

    public IDLJavaSerializationOutputStream(byte encodingVersion) {
        super();
        this.encodingVersion = encodingVersion;
    }

    public void init(org.omg.CORBA.ORB orb, boolean littleEndian,
                     BufferManagerWrite bufferManager,
                     byte streamFormatVersion,
                     boolean usePooledByteBuffers) {
        this.orb = (ORB) orb;
        this.bufferManager = bufferManager;
        wrapper = ORBUtilSystemException.get((ORB) orb,
                                             CORBALogDomains.RPC_ENCODING);
        bos =
            new _ByteArrayOutputStream(ORBConstants.GIOP_DEFAULT_BUFFER_SIZE);
    }

    // Called from read_octet or read_long or read_ulong method.
    private void initObjectOutputStream() {
        //System.out.print(" os ");
        if (os != null) {
            throw wrapper.javaStreamInitFailed();
        }
        try {
            os = new MarshalObjectOutputStream(bos, orb);
        } catch (Exception e) {
            throw wrapper.javaStreamInitFailed(e);
        }
    }

    // org.omg.CORBA.portable.OutputStream

    // Primitive types.

    public final void write_boolean(boolean value) {
        try {
            os.writeBoolean(value);
        } catch (Exception e) {
            throw wrapper.javaSerializationException(e, "write_boolean");
        }
    }

    public final void write_char(char value) {
        try {
            os.writeChar(value);
        } catch (Exception e) {
            throw wrapper.javaSerializationException(e, "write_char");
        }
    }

    public final void write_wchar(char value) {
        this.write_char(value);
    }

    public final void write_octet(byte value) {

        // check if size < [ GIOPHeader(12) + requestID(4)] bytes
        if (bos.size() < directWriteLength) {
            bos.write(value); // direct write.
            if (bos.size() == directWriteLength) {
                initObjectOutputStream();
            }
            return;
        }

        try {
            os.writeByte(value);
        } catch (Exception e) {
            throw wrapper.javaSerializationException(e, "write_octet");
        }
    }

    public final void write_short(short value) {
        try {
            os.writeShort(value);
        } catch (Exception e) {
            throw wrapper.javaSerializationException(e, "write_short");
        }
    }

    public final void write_ushort(short value) {
        this.write_short(value);
    }

    public final void write_long(int value) {

        // check if size < [ GIOPHeader(12) + requestID(4)] bytes
        if (bos.size() < directWriteLength) {

            // Use big endian (network byte order). This is fixed.
            // Both the writer and reader use the same byte order.
            bos.write((byte)((value >>> 24) & 0xFF));
            bos.write((byte)((value >>> 16) & 0xFF));
            bos.write((byte)((value >>> 8) & 0xFF));
            bos.write((byte)((value >>> 0) & 0xFF));

            if (bos.size() == directWriteLength) {
                initObjectOutputStream();
            } else if (bos.size() > directWriteLength) {
                // Cannot happen. All direct writes are contained
                // within the first 16 bytes.
                wrapper.javaSerializationException("write_long");
            }
            return;
        }

        try {
            os.writeInt(value);
        } catch (Exception e) {
            throw wrapper.javaSerializationException(e, "write_long");
        }
    }

    public final void write_ulong(int value) {
        this.write_long(value);
    }

    public final void write_longlong(long value) {
        try {
            os.writeLong(value);
        } catch (Exception e) {
            throw wrapper.javaSerializationException(e, "write_longlong");
        }
    }

    public final void write_ulonglong(long value) {
        this.write_longlong(value);
    }

    public final void write_float(float value) {
        try {
            os.writeFloat(value);
        } catch (Exception e) {
            throw wrapper.javaSerializationException(e, "write_float");
        }
    }

    public final void write_double(double value) {
        try {
            os.writeDouble(value);
        } catch (Exception e) {
            throw wrapper.javaSerializationException(e, "write_double");
        }
    }

    // String types.

    public final void write_string(String value) {
        try {
            os.writeUTF(value);
        } catch (Exception e) {
            throw wrapper.javaSerializationException(e, "write_string");
        }
    }

    public final void write_wstring(String value) {
        try {
            os.writeObject(value);
        } catch (Exception e) {
            throw wrapper.javaSerializationException(e, "write_wstring");
        }
    }

    // Array types.

    public final void write_boolean_array(boolean[] value,
                                          int offset, int length) {
        for (int i = 0; i < length; i++) {
            write_boolean(value[offset + i]);
        }
    }

    public final void write_char_array(char[] value, int offset, int length) {
        for (int i = 0; i < length; i++) {
            write_char(value[offset + i]);
        }
    }

    public final void write_wchar_array(char[] value, int offset, int length) {
        write_char_array(value, offset, length);
    }

    public final void write_octet_array(byte[] value, int offset, int length) {
        try {
            os.write(value, offset, length);
        } catch (Exception e) {
            throw wrapper.javaSerializationException(e, "write_octet_array");
        }
    }

    public final void write_short_array(short[] value,
                                        int offset, int length) {
        for (int i = 0; i < length; i++) {
            write_short(value[offset + i]);
        }
    }

    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) {
        for (int i = 0; i < length; i++) {
            write_long(value[offset + i]);
        }
    }

    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) {
        for (int i = 0; i < length; i++) {
            write_longlong(value[offset + i]);
        }
    }

    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) {
        for (int i = 0; i < length; i++) {
            write_float(value[offset + i]);
        }
    }

    public final void write_double_array(double[] value,
                                         int offset, int length) {
        for (int i = 0; i < length; i++) {
            write_double(value[offset + i]);
        }
    }

    // Complex types (objects and graphs).

    public final void write_Object(org.omg.CORBA.Object value) {
        if (value == null) {
            IOR nullIOR = IORFactories.makeIOR(orb);
            nullIOR.write(parent);
            return;
        }
        // IDL to Java formal 01-06-06 1.21.4.2
        if (value instanceof org.omg.CORBA.LocalObject) {
            throw wrapper.writeLocalObject(CompletionStatus.COMPLETED_MAYBE);
        }
        IOR ior = ORBUtility.connectAndGetIOR(orb, value);
        ior.write(parent);
        return;
    }

    public final 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 final void write_any(Any any) {
        if (any == null) {
            throw wrapper.nullParam(CompletionStatus.COMPLETED_MAYBE);
        }
        write_TypeCode(any.type());
        any.write_value(parent);
    }

    public final void write_Principal(Principal p) {
        // We don't need an implementation for this method, since principal
        // is absent in GIOP version 1.2 or above.
        write_long(p.name().length);
        write_octet_array(p.name(), 0, p.name().length);
    }

    public final 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
    private 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 string length 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);
    }

    public final org.omg.CORBA.ORB orb() {
        return this.orb;
    }

    // org.omg.CORBA_2_3.portable.OutputStream

    public final void write_value(java.io.Serializable value) {
        write_value(value, (String) null);
    }

    public final void write_value(java.io.Serializable value,
                                  java.lang.Class clz) {
        write_value(value);
    }

    public final void write_value(java.io.Serializable value,
                                  String repository_id) {
        try {
            os.writeObject(value);
        } catch (Exception e) {
            throw wrapper.javaSerializationException(e, "write_value");
        }
    }

    public final void write_value(java.io.Serializable value,
                             org.omg.CORBA.portable.BoxedValueHelper factory) {
        this.write_value(value, (String) null);
    }

    public final void write_abstract_interface(java.lang.Object obj) {

        boolean isCorbaObject = false; // Assume value type.
        org.omg.CORBA.Object theCorbaObject = null;

        // Is it a CORBA.Object?
        if (obj != null && obj instanceof org.omg.CORBA.Object) {
            theCorbaObject = (org.omg.CORBA.Object)obj;
            isCorbaObject = true;
        }

        // Write the boolean flag.
        this.write_boolean(isCorbaObject);

        // Now write out the object.
        if (isCorbaObject) {
            write_Object(theCorbaObject);
        } 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());
                }
            }
        }
    }

    // com.sun.corba.se.os.encoding.MarshalOutputStream

    public final void start_block() {
        throw wrapper.giopVersionError();
    }

    public final void end_block() {
        throw wrapper.giopVersionError();
    }

    public final void putEndian() {
        throw wrapper.giopVersionError();
    }

    public void writeTo(java.io.OutputStream s) throws IOException {
        try {
            os.flush();
            bos.writeTo(s);
        } catch (Exception e) {
            throw wrapper.javaSerializationException(e, "writeTo");
        }
    }

    public final byte[] toByteArray() {
        try {
            os.flush();
            return bos.toByteArray(); // new copy.
        } catch (Exception e) {
            throw wrapper.javaSerializationException(e, "toByteArray");
        }
    }

    // org.omg.CORBA.DataOutputStream

    public final void write_Abstract (java.lang.Object value) {
        write_abstract_interface(value);
    }

    public final void write_Value(java.io.Serializable value) {
        write_value(value);
    }

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

    // org.omg.CORBA.portable.ValueBase

    public final String[] _truncatable_ids() {
        throw wrapper.giopVersionError();
    }

    // Other.

    public final int getSize() {
        try {
            os.flush();
            return bos.size();
        } catch (Exception e) {
            throw wrapper.javaSerializationException(e, "write_boolean");
        }
    }

    public final int getIndex() {
        return getSize();
    }

    protected int getRealIndex(int index) {
        return getSize();
    }

    public final void setIndex(int value) {
        throw wrapper.giopVersionError();
    }

    public final ByteBuffer getByteBuffer() {
        throw wrapper.giopVersionError();
    }

    public final void setByteBuffer(ByteBuffer byteBuffer) {
        throw wrapper.giopVersionError();
    }

    public final boolean isLittleEndian() {
        // Java serialization uses network byte order, that is, big-endian.
        return false;
    }

    public ByteBufferWithInfo getByteBufferWithInfo() {
        try {
            os.flush();
        } catch (Exception e) {
            throw wrapper.javaSerializationException(
                                            e, "getByteBufferWithInfo");
        }
        ByteBuffer byteBuffer = ByteBuffer.wrap(bos.getByteArray());
        byteBuffer.limit(bos.size());
        return new ByteBufferWithInfo(this.orb, byteBuffer, bos.size());
    }

    public void setByteBufferWithInfo(ByteBufferWithInfo bbwi) {
        throw wrapper.giopVersionError();
    }

    public final BufferManagerWrite getBufferManager() {
        return bufferManager;
    }

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

    public final void writeOctetSequenceTo(
            org.omg.CORBA.portable.OutputStream s) {
        byte[] buf = this.toByteArray(); // new copy.
        s.write_long(buf.length);
        s.write_octet_array(buf, 0, buf.length);
    }

    public final GIOPVersion getGIOPVersion() {
        return GIOPVersion.V1_2;
    }

    public final void writeIndirection(int tag, int posIndirectedTo) {
        throw wrapper.giopVersionError();
    }

    void freeInternalCaches() {}

    void printBuffer() {
        byte[] buf = this.toByteArray();

        System.out.println("+++++++ Output Buffer ++++++++");
        System.out.println();
        System.out.println("Current position: " + buf.length);
        //System.out.println("Total length : " + buf.length);
        System.out.println();

        char[] charBuf = new char[16];

        try {

            for (int i = 0; i < buf.length; 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 < buf.length) {
                    int k = buf[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 < buf.length) {
                    if (ORBUtility.isPrintable((char)buf[i + x])) {
                        charBuf[x] = (char) buf[i + x];
                    } else {
                        charBuf[x] = '.';
                    }
                    x++;
                }
                System.out.println(new String(charBuf, 0, x));
            }
        } catch (Throwable t) {
            t.printStackTrace();
        }
        System.out.println("++++++++++++++++++++++++++++++");
    }

    public void alignOnBoundary(int octetBoundary) {
        throw wrapper.giopVersionError();
    }

    // Needed by request and reply messages for GIOP versions >= 1.2 only.
    public void setHeaderPadding(boolean headerPadding) {
        // no-op. We don't care about body alignment while using
        // Java serialization. What the GIOP spec states does not apply here.
    }

    // ValueOutputStream -----------------------------

    public void start_value(String rep_id) {
        throw wrapper.giopVersionError();
    }

    public void end_value() {
        throw wrapper.giopVersionError();
    }

    // java.io.OutputStream

    // Note: These methods are defined in the super class and accessible.

    //public abstract void write(byte b[]) throws IOException;
    //public abstract void write(byte b[], int off, int len)
    //    throws IOException;
    //public abstract void flush() throws IOException;
    //public abstract void close() throws IOException;
}