jdk8-mips64-public/corba: src/share/classes/com/sun/corba/se/impl/encoding/IDLJavaSerializationInputStream.java@7ef37b2cdcad (annotated)

src/share/classes/com/sun/corba/se/impl/encoding/IDLJavaSerializationInputStream.java@7ef37b2cdcad (annotated)

src/share/classes/com/sun/corba/se/impl/encoding/IDLJavaSerializationInputStream.java

Wed, 27 Apr 2016 01:21:28 +0800

author: aoqi
date: Wed, 27 Apr 2016 01:21:28 +0800
changeset 0: 7ef37b2cdcad
child 748: 6845b95cba6b
permissions: -rw-r--r--

Initial load
http://hg.openjdk.java.net/jdk8u/jdk8u/corba/
changeset: 765:f46df0af2ca8
tag: jdk8u25-b17

 /*
  * Copyright (c) 2004, 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.Serializable;
 import java.io.ObjectInputStream;
 import java.io.ByteArrayInputStream;
 import java.io.IOException;
 import java.nio.ByteBuffer;
 import java.math.BigDecimal;
 import java.util.LinkedList;
 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.spi.presentation.rmi.PresentationManager;
 import com.sun.corba.se.spi.presentation.rmi.PresentationDefaults;
 import com.sun.corba.se.impl.util.Utility;
 import com.sun.corba.se.impl.orbutil.ORBUtility;
 import com.sun.corba.se.impl.corba.TypeCodeImpl;
 import com.sun.corba.se.impl.util.RepositoryId;
 import com.sun.corba.se.impl.orbutil.ORBConstants;
 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.portable.IDLEntity;
 /**
  * Implementation class that uses Java serialization for input streams.
  * This assumes a GIOP version 1.2 message format.
  *
  * This class uses a ByteArrayInputStream as the underlying buffer. The
  * first 16 bytes are directly read out of the underlying buffer. This allows
  * [GIOPHeader (12 bytes) + requestID (4 bytes)] to be read as bytes.
  * Subsequent write operations on this output stream object uses
  * ObjectInputStream class to read into the buffer. This allows unmarshaling
  * complex types and graphs using the ObjectInputStream implementation.
  *
  * Note, this class assumes a GIOP 1.2 style header. Further, the first
  * 12 bytes, that is, the GIOPHeader is read directly from the received
  * message, before this stream object is called. So, this class effectively
  * reads only the requestID (4 bytes) directly, and uses the
  * ObjectInputStream for further unmarshaling.
  *
  * @author Ram Jeyaraman
  */
 public class IDLJavaSerializationInputStream extends CDRInputStreamBase {
     private ORB orb;
     private int bufSize;
     private ByteBuffer buffer;
     private byte encodingVersion;
     private ObjectInputStream is;
     private _ByteArrayInputStream bis;
     private BufferManagerRead bufferManager;
     // [GIOPHeader(12) + requestID(4)] bytes
     private final int directReadLength = Message.GIOPMessageHeaderLength + 4;
     // Used for mark / reset operations.
     private boolean markOn;
     private int peekIndex, peekCount;
     private LinkedList markedItemQ = new LinkedList();
     protected ORBUtilSystemException wrapper;
     class _ByteArrayInputStream extends ByteArrayInputStream {
         _ByteArrayInputStream(byte[] buf) {
             super(buf);
         }
         int getPosition() {
             return this.pos;
         }
         void setPosition(int value) {
             if (value < 0 || value > count) {
                 throw new IndexOutOfBoundsException();
             }
             this.pos = value;
         }
     }
     class MarshalObjectInputStream extends ObjectInputStream {
         ORB orb;
         MarshalObjectInputStream(java.io.InputStream out, ORB orb)
                 throws IOException {
             super(out);
             this.orb = orb;
             java.security.AccessController.doPrivileged(
                 new java.security.PrivilegedAction() {
                     public Object run() {
                         // needs SerializablePermission("enableSubstitution")
                         enableResolveObject(true);
                         return null;
                     }
                 }
             );
         }
         /**
          * Connect the Stub to the ORB.
          */
         protected final Object resolveObject(Object obj) throws IOException {
             try {
                 if (StubAdapter.isStub(obj)) {
                     StubAdapter.connect(obj, orb);
                 }
             } catch (java.rmi.RemoteException re) {
                 IOException ie = new IOException("resolveObject failed");
                 ie.initCause(re);
                 throw ie;
             }
             return obj;
         }
     }
     public IDLJavaSerializationInputStream(byte encodingVersion) {
         super();
         this.encodingVersion = encodingVersion;
     }
     public void init(org.omg.CORBA.ORB orb,
                      ByteBuffer byteBuffer,
                      int bufSize,
                      boolean littleEndian,
                      BufferManagerRead bufferManager) {
         this.orb = (ORB) orb;
         this.bufSize = bufSize;
         this.bufferManager = bufferManager;
         buffer = byteBuffer;
         wrapper =
             ORBUtilSystemException.get((ORB)orb, CORBALogDomains.RPC_ENCODING);
         byte[] buf;
         if (buffer.hasArray()) {
             buf = buffer.array();
         } else {
             buf = new byte[bufSize];
             buffer.get(buf);
         }
         // Note: at this point, the buffer position is zero. The setIndex()
         // method call can be used to set a desired read index.
         bis = new _ByteArrayInputStream(buf);
     }
     // Called from read_octet or read_long or read_ulong method.
     private void initObjectInputStream() {
         //System.out.print(" is ");
         if (is != null) {
             throw wrapper.javaStreamInitFailed();
         }
         try {
             is = new MarshalObjectInputStream(bis, orb);
         } catch (Exception e) {
             throw wrapper.javaStreamInitFailed(e);
         }
     }
     // org.omg.CORBA.portable.InputStream
     // Primitive types.
     public boolean read_boolean() {
         if (!markOn && !(markedItemQ.isEmpty())) { // dequeue
             return ((Boolean)markedItemQ.removeFirst()).booleanValue();
         }
         if (markOn && !(markedItemQ.isEmpty()) &&
                 (peekIndex < peekCount)) { // peek
             return ((Boolean)markedItemQ.get(peekIndex++)).booleanValue();
         }
         try {
             boolean value = is.readBoolean();
             if (markOn) { // enqueue
                 markedItemQ.addLast(Boolean.valueOf(value));
             }
             return value;
         } catch (Exception e) {
             throw wrapper.javaSerializationException(e, "read_boolean");
         }
     }
     public char read_char() {
         if (!markOn && !(markedItemQ.isEmpty())) { // dequeue
             return ((Character)markedItemQ.removeFirst()).charValue();
         }
         if (markOn && !(markedItemQ.isEmpty()) &&
                 (peekIndex < peekCount)) { // peek
             return ((Character)markedItemQ.get(peekIndex++)).charValue();
         }
         try {
             char value = is.readChar();
             if (markOn) { // enqueue
                 markedItemQ.addLast(new Character(value));
             }
             return value;
         } catch (Exception e) {
             throw wrapper.javaSerializationException(e, "read_char");
         }
     }
     public char read_wchar() {
         return this.read_char();
     }
     public byte read_octet() {
         // check if size < [ GIOPHeader(12) + requestID(4)] bytes
         if (bis.getPosition() < directReadLength) {
             byte b = (byte) bis.read();
             if (bis.getPosition() == directReadLength) {
                 initObjectInputStream();
             }
             return b;
         }
         if (!markOn && !(markedItemQ.isEmpty())) { // dequeue
             return ((Byte)markedItemQ.removeFirst()).byteValue();
         }
         if (markOn && !(markedItemQ.isEmpty()) &&
                 (peekIndex < peekCount)) { // peek
             return ((Byte)markedItemQ.get(peekIndex++)).byteValue();
         }
         try {
             byte value = is.readByte();
             if (markOn) { // enqueue
                 //markedItemQ.addLast(Byte.valueOf(value)); // only in JDK 1.5
                 markedItemQ.addLast(new Byte(value));
             }
             return value;
         } catch (Exception e) {
             throw wrapper.javaSerializationException(e, "read_octet");
         }
     }
     public short read_short() {
         if (!markOn && !(markedItemQ.isEmpty())) { // dequeue
             return ((Short)markedItemQ.removeFirst()).shortValue();
         }
         if (markOn && !(markedItemQ.isEmpty()) &&
                 (peekIndex < peekCount)) { // peek
             return ((Short)markedItemQ.get(peekIndex++)).shortValue();
         }
         try {
             short value = is.readShort();
             if (markOn) { // enqueue
                 markedItemQ.addLast(new Short(value));
             }
             return value;
         } catch (Exception e) {
             throw wrapper.javaSerializationException(e, "read_short");
         }
     }
     public short read_ushort() {
         return this.read_short();
     }
     public int read_long() {
         // check if size < [ GIOPHeader(12) + requestID(4)] bytes
         if (bis.getPosition() < directReadLength) {
             // Use big endian (network byte order). This is fixed.
             // Both the writer and reader use the same byte order.
             int b1 = (bis.read() << 24) & 0xFF000000;
             int b2 = (bis.read() << 16) & 0x00FF0000;
             int b3 = (bis.read() << 8)  & 0x0000FF00;
             int b4 = (bis.read() << 0)  & 0x000000FF;
             if (bis.getPosition() == directReadLength) {
                 initObjectInputStream();
             } else if (bis.getPosition() > directReadLength) {
                 // Cannot happen. All direct reads are contained
                 // within the first 16 bytes.
                 wrapper.javaSerializationException("read_long");
             }
             return (b1 | b2 | b3 | b4);
         }
         if (!markOn && !(markedItemQ.isEmpty())) { // dequeue
             return ((Integer)markedItemQ.removeFirst()).intValue();
         }
         if (markOn && !(markedItemQ.isEmpty()) &&
                 (peekIndex < peekCount)) { // peek
             return ((Integer)markedItemQ.get(peekIndex++)).intValue();
         }
         try {
             int value = is.readInt();
             if (markOn) { // enqueue
                 markedItemQ.addLast(new Integer(value));
             }
             return value;
         } catch (Exception e) {
             throw wrapper.javaSerializationException(e, "read_long");
         }
     }
     public int read_ulong() {
         return this.read_long();
     }
     public long read_longlong() {
         if (!markOn && !(markedItemQ.isEmpty())) { // dequeue
             return ((Long)markedItemQ.removeFirst()).longValue();
         }
         if (markOn && !(markedItemQ.isEmpty()) &&
                 (peekIndex < peekCount)) { // peek
             return ((Long)markedItemQ.get(peekIndex++)).longValue();
         }
         try {
             long value = is.readLong();
             if (markOn) { // enqueue
                 markedItemQ.addLast(new Long(value));
             }
             return value;
         } catch (Exception e) {
             throw wrapper.javaSerializationException(e, "read_longlong");
         }
     }
     public long read_ulonglong() {
         return read_longlong();
     }
     public float read_float() {
         if (!markOn && !(markedItemQ.isEmpty())) { // dequeue
             return ((Float)markedItemQ.removeFirst()).floatValue();
         }
         if (markOn && !(markedItemQ.isEmpty()) &&
                 (peekIndex < peekCount)) { // peek
             return ((Float)markedItemQ.get(peekIndex++)).floatValue();
         }
         try {
             float value = is.readFloat();
             if (markOn) { // enqueue
                 markedItemQ.addLast(new Float(value));
             }
             return value;
         } catch (Exception e) {
             throw wrapper.javaSerializationException(e, "read_float");
         }
     }
     public double read_double() {
         if (!markOn && !(markedItemQ.isEmpty())) { // dequeue
             return ((Double)markedItemQ.removeFirst()).doubleValue();
         }
         if (markOn && !(markedItemQ.isEmpty()) &&
                 (peekIndex < peekCount)) { // peek
             return ((Double)markedItemQ.get(peekIndex++)).doubleValue();
         }
         try {
             double value = is.readDouble();
             if (markOn) { // enqueue
                 markedItemQ.addLast(new Double(value));
             }
             return value;
         } catch (Exception e) {
             throw wrapper.javaSerializationException(e, "read_double");
         }
     }
     // String types.
     public String read_string() {
         if (!markOn && !(markedItemQ.isEmpty())) { // dequeue
             return (String) markedItemQ.removeFirst();
         }
         if (markOn && !(markedItemQ.isEmpty()) &&
             (peekIndex < peekCount)) { // peek
             return (String) markedItemQ.get(peekIndex++);
         }
         try {
             String value = is.readUTF();
             if (markOn) { // enqueue
                 markedItemQ.addLast(value);
             }
             return value;
         } catch (Exception e) {
             throw wrapper.javaSerializationException(e, "read_string");
         }
     }
     public String read_wstring() {
         if (!markOn && !(markedItemQ.isEmpty())) { // dequeue
             return (String) markedItemQ.removeFirst();
         }
         if (markOn && !(markedItemQ.isEmpty()) &&
                 (peekIndex < peekCount)) { // peek
             return (String) markedItemQ.get(peekIndex++);
         }
         try {
             String value = (String) is.readObject();
             if (markOn) { // enqueue
                 markedItemQ.addLast(value);
             }
             return value;
         } catch (Exception e) {
             throw wrapper.javaSerializationException(e, "read_wstring");
         }
     }
     // Array types.
     public void read_boolean_array(boolean[] value, int offset, int length){
         for(int i = 0; i < length; i++) {
             value[i+offset] = read_boolean();
         }
     }
     public void read_char_array(char[] value, int offset, int length) {
         for(int i=0; i < length; i++) {
             value[i+offset] = read_char();
         }
     }
     public void read_wchar_array(char[] value, int offset, int length) {
         read_char_array(value, offset, length);
     }
     public void read_octet_array(byte[] value, int offset, int length) {
         for(int i=0; i < length; i++) {
             value[i+offset] = read_octet();
         }
         /* // Cannot use this efficient read due to mark/reset support.
         try {
             while (length > 0) {
                 int n = is.read(value, offset, length);
                 offset += n;
                 length -= n;
             }
         } catch (Exception e) {
             throw wrapper.javaSerializationException(e, "read_octet_array");
         }
         */
     }
     public void read_short_array(short[] value, int offset, int length) {
         for(int i=0; i < length; i++) {
             value[i+offset] = read_short();
         }
     }
     public void read_ushort_array(short[] value, int offset, int length) {
         read_short_array(value, offset, length);
     }
     public void read_long_array(int[] value, int offset, int length) {
         for(int i=0; i < length; i++) {
             value[i+offset] = read_long();
         }
     }
     public void read_ulong_array(int[] value, int offset, int length) {
         read_long_array(value, offset, length);
     }
     public void read_longlong_array(long[] value, int offset, int length) {
         for(int i=0; i < length; i++) {
             value[i+offset] = read_longlong();
         }
     }
     public void read_ulonglong_array(long[] value, int offset, int length) {
         read_longlong_array(value, offset, length);
     }
     public void read_float_array(float[] value, int offset, int length) {
         for(int i=0; i < length; i++) {
             value[i+offset] = read_float();
         }
     }
     public void read_double_array(double[] value, int offset, int length) {
         for(int i=0; i < length; i++) {
             value[i+offset] = read_double();
         }
     }
     // Complex types.
     public org.omg.CORBA.Object read_Object() {
         return read_Object(null);
     }
     public TypeCode read_TypeCode() {
         TypeCodeImpl tc = new TypeCodeImpl(orb);
         tc.read_value(parent);
         return tc;
     }
     public Any read_any() {
         Any any = orb.create_any();
         TypeCodeImpl tc = new TypeCodeImpl(orb);
         // read off the typecode
         // REVISIT We could avoid this try-catch if we could peek the typecode
         // kind off this stream and see if it is a tk_value.
         // Looking at the code we know that for tk_value the Any.read_value()
         // below ignores the tc argument anyway (except for the kind field).
         // But still we would need to make sure that the whole typecode,
         // including encapsulations, is read off.
         try {
             tc.read_value(parent);
         } catch (org.omg.CORBA.MARSHAL ex) {
             if (tc.kind().value() != org.omg.CORBA.TCKind._tk_value) {
                 throw ex;
             }
             // We can be sure that the whole typecode encapsulation has been
             // read off.
             ex.printStackTrace();
         }
         // read off the value of the any.
         any.read_value(parent, tc);
         return any;
     }
     public Principal read_Principal() {
         // We don't need an implementation for this method, since principal
         // is absent in GIOP version 1.2 or above.
         int len = read_long();
         byte[] pvalue = new byte[len];
         read_octet_array(pvalue,0,len);
         Principal p = new com.sun.corba.se.impl.corba.PrincipalImpl();
         p.name(pvalue);
         return p;
     }
     public BigDecimal read_fixed() {
         return new BigDecimal(read_fixed_buffer().toString());
     }
     // Each octet contains (up to) two decimal digits. 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.
     // The sign configuration, in the last half-octet of the representation,
     // is 0xD for negative numbers and 0xC for positive and zero values.
     private StringBuffer read_fixed_buffer() {
         StringBuffer buffer = new StringBuffer(64);
         byte doubleDigit;
         int firstDigit;
         int secondDigit;
         boolean wroteFirstDigit = false;
         boolean more = true;
         while (more) {
             doubleDigit = read_octet();
             firstDigit = (int)((doubleDigit & 0xf0) >> 4);
             secondDigit = (int)(doubleDigit & 0x0f);
             if (wroteFirstDigit || firstDigit != 0) {
                 buffer.append(Character.forDigit(firstDigit, 10));
                 wroteFirstDigit = true;
             }
             if (secondDigit == 12) {
                 // positive number or zero
                 if ( ! wroteFirstDigit) {
                     // zero
                     return new StringBuffer("0.0");
                 } else {
                     // positive number
                     // done
                 }
                 more = false;
             } else if (secondDigit == 13) {
                 // negative number
                 buffer.insert(0, '-');
                 more = false;
             } else {
                 buffer.append(Character.forDigit(secondDigit, 10));
                 wroteFirstDigit = true;
             }
         }
         return buffer;
     }
     public org.omg.CORBA.Object read_Object(java.lang.Class clz) {
         // In any case, we must first read the IOR.
         IOR ior = IORFactories.makeIOR(parent) ;
         if (ior.isNil()) {
             return null;
         }
         PresentationManager.StubFactoryFactory sff =
             ORB.getStubFactoryFactory();
         String codeBase = ior.getProfile().getCodebase();
         PresentationManager.StubFactory stubFactory = null;
         if (clz == null) {
             RepositoryId rid = RepositoryId.cache.getId(ior.getTypeId() );
             String className = rid.getClassName();
             boolean isIDLInterface = rid.isIDLType();
             if (className == null || className.equals( "" )) {
                 stubFactory = null;
             } else {
                 try {
                     stubFactory = sff.createStubFactory(className,
                         isIDLInterface, codeBase, (Class) null,
                         (ClassLoader) null);
                 } catch (Exception exc) {
                     // Could not create stubFactory, so use null.
                     // XXX stubFactory handling is still too complex:
                     // Can we resolve the stubFactory question once in
                     // a single place?
                     stubFactory = null ;
                 }
             }
         } else if (StubAdapter.isStubClass(clz)) {
             stubFactory = PresentationDefaults.makeStaticStubFactory(clz);
         } else {
             // clz is an interface class
             boolean isIDL = IDLEntity.class.isAssignableFrom(clz);
             stubFactory = sff.createStubFactory(
                  clz.getName(), isIDL, codeBase, clz, clz.getClassLoader());
         }
         return CDRInputStream_1_0.internalIORToObject(ior, stubFactory, orb);
     }
     public org.omg.CORBA.ORB orb() {
         return this.orb;
     }
     // org.omg.CORBA_2_3.portable.InputStream
     public java.io.Serializable read_value() {
         if (!markOn && !(markedItemQ.isEmpty())) { // dequeue
             return (Serializable) markedItemQ.removeFirst();
         }
         if (markOn && !(markedItemQ.isEmpty()) &&
                 (peekIndex < peekCount)) { // peek
             return (Serializable) markedItemQ.get(peekIndex++);
         }
         try {
             Serializable value = (java.io.Serializable) is.readObject();
             if (markOn) { // enqueue
                 markedItemQ.addLast(value);
             }
             return value;
         } catch (Exception e) {
             throw wrapper.javaSerializationException(e, "read_value");
         }
     }
     public java.io.Serializable read_value(java.lang.Class clz) {
         return read_value();
     }
     public java.io.Serializable read_value(
             org.omg.CORBA.portable.BoxedValueHelper factory) {
         return read_value();
     }
     public java.io.Serializable read_value(java.lang.String rep_id) {
         return read_value();
     }
     public java.io.Serializable read_value(java.io.Serializable value) {
         return read_value();
     }
     public java.lang.Object read_abstract_interface() {
         return read_abstract_interface(null);
     }
     public java.lang.Object read_abstract_interface(java.lang.Class clz) {
         boolean isObject = read_boolean();
         if (isObject) {
             return read_Object(clz);
         } else {
             return read_value();
         }
     }
     // com.sun.corba.se.impl.encoding.MarshalInputStream
     public void consumeEndian() {
         throw wrapper.giopVersionError();
     }
     public int getPosition() {
         try {
             return bis.getPosition();
         } catch (Exception e) {
             throw wrapper.javaSerializationException(e, "getPosition");
         }
     }
     // org.omg.CORBA.DataInputStream
     public java.lang.Object read_Abstract() {
         return read_abstract_interface();
     }
     public java.io.Serializable read_Value() {
         return read_value();
     }
     public void read_any_array (org.omg.CORBA.AnySeqHolder seq,
                                 int offset, int length) {
         read_any_array(seq.value, offset, length);
     }
     private final void read_any_array(org.omg.CORBA.Any[] value,
                                      int offset, int length) {
         for(int i=0; i < length; i++) {
             value[i+offset] = read_any();
         }
     }
     public void read_boolean_array (org.omg.CORBA.BooleanSeqHolder seq,
                                     int offset, int length){
         read_boolean_array(seq.value, offset, length);
     }
     public void read_char_array (org.omg.CORBA.CharSeqHolder seq,
                                  int offset, int length){
         read_char_array(seq.value, offset, length);
     }
     public void read_wchar_array (org.omg.CORBA.WCharSeqHolder seq,
                                   int offset, int length){
         read_wchar_array(seq.value, offset, length);
     }
     public void read_octet_array (org.omg.CORBA.OctetSeqHolder seq,
                                   int offset, int length){
         read_octet_array(seq.value, offset, length);
     }
     public void read_short_array (org.omg.CORBA.ShortSeqHolder seq,
                                   int offset, int length){
         read_short_array(seq.value, offset, length);
     }
     public void read_ushort_array (org.omg.CORBA.UShortSeqHolder seq,
                                    int offset, int length){
         read_ushort_array(seq.value, offset, length);
     }
     public void read_long_array (org.omg.CORBA.LongSeqHolder seq,
                                  int offset, int length){
         read_long_array(seq.value, offset, length);
     }
     public void read_ulong_array (org.omg.CORBA.ULongSeqHolder seq,
                                   int offset, int length){
         read_ulong_array(seq.value, offset, length);
     }
     public void read_ulonglong_array (org.omg.CORBA.ULongLongSeqHolder seq,
                                       int offset, int length){
         read_ulonglong_array(seq.value, offset, length);
     }
     public void read_longlong_array (org.omg.CORBA.LongLongSeqHolder seq,
                                      int offset, int length){
         read_longlong_array(seq.value, offset, length);
     }
     public void read_float_array (org.omg.CORBA.FloatSeqHolder seq,
                                   int offset, int length){
         read_float_array(seq.value, offset, length);
     }
     public void read_double_array (org.omg.CORBA.DoubleSeqHolder seq,
                                    int offset, int length){
         read_double_array(seq.value, offset, length);
     }
     // org.omg.CORBA.portable.ValueBase
     public String[] _truncatable_ids() {
         throw wrapper.giopVersionError();
     }
     // java.io.InputStream
     // REVISIT - should we make these throw UnsupportedOperationExceptions?
     // Right now, they'll go up to the java.io versions!
     //     public int read(byte b[]) throws IOException;
     //     public int read(byte b[], int off, int len) throws IOException
     //     public long skip(long n) throws IOException;
     //     public int available() throws IOException;
     //     public void close() throws IOException;
     public void mark(int readLimit) {
         // Nested mark disallowed.
         // Further, mark is not supported until first 16 bytes are read.
         if (markOn || is == null) {
             throw wrapper.javaSerializationException("mark");
         }
         markOn = true;
         if (!(markedItemQ.isEmpty())) {
             peekIndex = 0;
             peekCount = markedItemQ.size();
         }
         /*
         // Note: only ByteArrayInputStream supports mark/reset.
         if (is == null || is.markSupported() == false) {
             throw wrapper.javaSerializationException("mark");
         }
         is.mark(readLimit);
         */
     }
     public void reset() {
         markOn = false;
         peekIndex = 0;
         peekCount = 0;
         /*
         // Note: only ByteArrayInputStream supports mark/reset.
         if (is == null || is.markSupported() == false) {
             throw wrapper.javaSerializationException("mark");
         }
         try {
             is.reset();
         } catch (Exception e) {
             throw wrapper.javaSerializationException(e, "reset");
         }
         */
     }
     // This should return false so that outside users (people using the JDK)
     // don't have any guarantees that mark/reset will work in their
     // custom marshaling code.  This is necessary since they could do things
     // like expect obj1a == obj1b in the following code:
     //
     // is.mark(10000);
     // Object obj1a = is.readObject();
     // is.reset();
     // Object obj1b = is.readObject();
     //
     public boolean markSupported() {
         return true;
     }
     // Needed by AnyImpl and ServiceContexts
     public CDRInputStreamBase dup() {
         CDRInputStreamBase result = null ;
         try {
             result = (CDRInputStreamBase) this.getClass().newInstance();
         } catch (Exception e) {
             throw wrapper.couldNotDuplicateCdrInputStream(e);
         }
         result.init(this.orb, this.buffer, this.bufSize, false, null);
         // Set the buffer position.
         ((IDLJavaSerializationInputStream)result).skipBytes(getPosition());
         // Set mark related data.
         ((IDLJavaSerializationInputStream)result).
             setMarkData(markOn, peekIndex, peekCount,
                         (LinkedList) markedItemQ.clone());
         return result;
     }
     // Used exclusively by the dup() method.
     void skipBytes(int len) {
         try {
             is.skipBytes(len);
         } catch (Exception e) {
             throw wrapper.javaSerializationException(e, "skipBytes");
         }
     }
     // Used exclusively by the dup() method.
     void setMarkData(boolean markOn, int peekIndex, int peekCount,
                      LinkedList markedItemQ) {
         this.markOn = markOn;
         this.peekIndex = peekIndex;
         this.peekCount = peekCount;
         this.markedItemQ = markedItemQ;
     }
     // Needed by TCUtility
     public java.math.BigDecimal read_fixed(short digits, short scale) {
         // digits isn't really needed here
         StringBuffer buffer = read_fixed_buffer();
         if (digits != buffer.length())
             throw wrapper.badFixed( new Integer(digits),
                 new Integer(buffer.length()) ) ;
         buffer.insert(digits - scale, '.');
         return new BigDecimal(buffer.toString());
     }
     // Needed by TypeCodeImpl
     public boolean isLittleEndian() {
         throw wrapper.giopVersionError();
     }
     // Needed by request and reply messages for GIOP versions >= 1.2 only.
     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.
     }
     // Needed by IIOPInputStream and other subclasses
     public ByteBuffer getByteBuffer() {
         throw wrapper.giopVersionError();
     }
     public void setByteBuffer(ByteBuffer byteBuffer) {
         throw wrapper.giopVersionError();
     }
     public void setByteBufferWithInfo(ByteBufferWithInfo bbwi) {
         throw wrapper.giopVersionError();
     }
     public int getBufferLength() {
         return bufSize;
     }
     public void setBufferLength(int value) {
         // this is redundant, since buffer size was already specified
         // as part of the init call. So, ignore.
     }
     public int getIndex() {
         return bis.getPosition();
     }
     public void setIndex(int value) {
         try {
             bis.setPosition(value);
         } catch (IndexOutOfBoundsException e) {
             throw wrapper.javaSerializationException(e, "setIndex");
         }
     }
     public void orb(org.omg.CORBA.ORB orb) {
         this.orb = (ORB) orb;
     }
     public BufferManagerRead getBufferManager() {
         return bufferManager;
     }
     public GIOPVersion getGIOPVersion() {
         return GIOPVersion.V1_2;
     }
     com.sun.org.omg.SendingContext.CodeBase getCodeBase() {
         return parent.getCodeBase();
     }
     void printBuffer() {
         byte[] buf = this.buffer.array();
         System.out.println("+++++++ Input Buffer ++++++++");
         System.out.println();
         System.out.println("Current position: " + getPosition());
         System.out.println("Total length : " + this.bufSize);
         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("++++++++++++++++++++++++++++++");
     }
     void alignOnBoundary(int octetBoundary) {
         throw wrapper.giopVersionError();
     }
     void performORBVersionSpecificInit() {
         // No-op.
     }
     public void resetCodeSetConverters() {
         // No-op.
     }
     // ValueInputStream -------------------------
     public void start_value() {
         throw wrapper.giopVersionError();
     }
     public void end_value() {
         throw wrapper.giopVersionError();
     }
 }

Mercurial > jdk8-mips64-public > corba / annotate

src/share/classes/com/sun/corba/se/impl/encoding/IDLJavaSerializationInputStream.java@7ef37b2cdcad (annotated)

src/share/classes/com/sun/corba/se/impl/encoding/IDLJavaSerializationInputStream.java