cdrinputstream.java

来自「java jdk 1.4的源码」· Java 代码 · 共 531 行 · 第 1/2 页

/*
 * @(#)CDRInputStream.java	1.30 03/01/23
 *
 * Copyright 2003 Sun Microsystems, Inc. All rights reserved.
 * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */
package com.sun.corba.se.internal.iiop;

import java.io.IOException;
import java.io.Serializable;
import java.math.BigDecimal;

import org.omg.CORBA.TypeCode;
import org.omg.CORBA.Principal;
import org.omg.CORBA.Any;
import com.sun.org.omg.SendingContext.CodeBase;
import org.omg.CORBA.BAD_PARAM;
import org.omg.CORBA.INTERNAL;
import org.omg.CORBA.CompletionStatus;

import com.sun.corba.se.internal.core.GIOPVersion;
import com.sun.corba.se.internal.core.CodeSetConversion;
import com.sun.corba.se.internal.core.OSFCodeSetRegistry;
import com.sun.corba.se.internal.orbutil.MinorCodes;

/**
 * This is delegates to the real implementation.
 *
 * NOTE:
 *
 * Before using the stream for valuetype unmarshaling, one must call
 * performORBVersionSpecificInit().
 */
public abstract class CDRInputStream
    extends org.omg.CORBA_2_3.portable.InputStream
    implements com.sun.corba.se.internal.core.MarshalInputStream,
               org.omg.CORBA.DataInputStream
{
    private CDRInputStreamBase impl;

    // We can move this out somewhere later.  For now, it serves its purpose
    // to create a concrete CDR delegate based on the GIOP version.
    private static class InputStreamFactory {
        
        public static CDRInputStreamBase newInputStream(GIOPVersion version)
        {
            switch(version.intValue()) 
            {
                case GIOPVersion.VERSION_1_0:
                    return new CDRInputStream_1_0();
                case GIOPVersion.VERSION_1_1:
                    return new CDRInputStream_1_1();
                case GIOPVersion.VERSION_1_2:
                    return new CDRInputStream_1_2();
                default:
                    // REVISIT - what is appropriate?  INTERNAL exceptions
                    // are really hard to track later.
                    throw new org.omg.CORBA.INTERNAL();
            }
        }
    }

    // Required for the case when a ClientResponseImpl is
    // created with a SystemException due to a dead server/closed
    // connection with no warning.  Note that the stream will
    // not be initialized in this case.
    // 
    // Probably also required by ServerRequestImpl.
    // 
    // REVISIT.
    public CDRInputStream() {
    }

    public CDRInputStream(CDRInputStream is) {
        impl = is.impl.dup();
        impl.setParent(this);
    }

    public CDRInputStream(CDRInputStreamBase impl) {
        this.impl = impl;

        impl.setParent(this);
    }

    public CDRInputStream(org.omg.CORBA.ORB orb, byte[] data, int size, GIOPVersion version) {

        impl = InputStreamFactory.newInputStream(version);

        // A grow strategy is used for decoding encapsulations.
        // streaming behaviour is incorrect.
        BufferManagerRead bufMgr = new BufferManagerReadGrow();

        impl.init(orb, data, size, false, bufMgr);
        impl.setParent(this);
    }

    public CDRInputStream(org.omg.CORBA.ORB orb,
                          byte[] data,
                          int size,
                          boolean littleEndian,
                          GIOPVersion version)
    {
        impl = InputStreamFactory.newInputStream(version);

        BufferManagerRead bufMgr = BufferManagerFactory.newBufferManagerRead(version, orb);

        impl.init(orb, data, size, littleEndian, bufMgr);
        impl.setParent(this);
    }

    public CDRInputStream(org.omg.CORBA.ORB orb,
                          byte[] data,
                          int size,
                          boolean littleEndian,
                          GIOPVersion version,
                          boolean allowFragmentation)
    {
        impl = InputStreamFactory.newInputStream(version);

        BufferManagerRead bufMgr;
        if (!allowFragmentation)
            bufMgr = new BufferManagerReadGrow();
        else
            bufMgr = BufferManagerFactory.newBufferManagerRead(version, orb);

        impl.init(orb, data, size, littleEndian, bufMgr);
        impl.setParent(this);
    }

    public CDRInputStream(org.omg.CORBA.ORB orb,
                          boolean littleEndian,
                          GIOPVersion version,
                          boolean allowFragmentation)
    {
        impl = InputStreamFactory.newInputStream(version);

        BufferManagerRead bufMgr;
        if (!allowFragmentation)
            bufMgr = new BufferManagerReadGrow();
        else
            bufMgr = BufferManagerFactory.newBufferManagerRead(version, orb);

        impl.init(orb, bufMgr, littleEndian);
        impl.setParent(this);
    }

    // org.omg.CORBA.portable.InputStream
    public final boolean read_boolean() {
        return impl.read_boolean();
    }

    public final char read_char() {
        return impl.read_char();
    }

    public final char read_wchar() {
        return impl.read_wchar();
    }

    public final byte read_octet() {
        return impl.read_octet();
    }

    public final short read_short() {
        return impl.read_short();
    }

    public final short read_ushort() {
        return impl.read_ushort();
    }

    public final int read_long() {
        return impl.read_long();
    }

    public final int read_ulong() {
        return impl.read_ulong();
    }

    public final long read_longlong() {
        return impl.read_longlong();
    }

    public final long read_ulonglong() {
        return impl.read_ulonglong();
    }

    public final float read_float() {
        return impl.read_float();
    }

    public final double read_double() {
        return impl.read_double();
    }

    public final String read_string() {
        return impl.read_string();
    }

    public final String read_wstring() {
        return impl.read_wstring();
    }

    public final void read_boolean_array(boolean[] value, int offset, int length) {
        impl.read_boolean_array(value, offset, length);
    }

    public final void read_char_array(char[] value, int offset, int length) {
        impl.read_char_array(value, offset, length);
    }

    public final void read_wchar_array(char[] value, int offset, int length) {
        impl.read_wchar_array(value, offset, length);
    }

    public final void read_octet_array(byte[] value, int offset, int length) {
        impl.read_octet_array(value, offset, length);
    }

    public final void read_short_array(short[] value, int offset, int length) {
        impl.read_short_array(value, offset, length);
    }

    public final void read_ushort_array(short[] value, int offset, int length) {
        impl.read_ushort_array(value, offset, length);
    }

    public final void read_long_array(int[] value, int offset, int length) {
        impl.read_long_array(value, offset, length);
    }

    public final void read_ulong_array(int[] value, int offset, int length) {
        impl.read_ulong_array(value, offset, length);
    }

    public final void read_longlong_array(long[] value, int offset, int length) {
        impl.read_longlong_array(value, offset, length);
    }

    public final void read_ulonglong_array(long[] value, int offset, int length) {
        impl.read_ulonglong_array(value, offset, length);
    }

    public final void read_float_array(float[] value, int offset, int length) {
        impl.read_float_array(value, offset, length);
    }

    public final void read_double_array(double[] value, int offset, int length) {
        impl.read_double_array(value, offset, length);
    }

    public final org.omg.CORBA.Object read_Object() {
        return impl.read_Object();
    }

    public final TypeCode read_TypeCode() {
        return impl.read_TypeCode();
    }
    public final Any read_any() {
        return impl.read_any();
    }

    public final Principal read_Principal() {
        return impl.read_Principal();
    }