jdk8-mips64-public/corba: src/share/classes/com/sun/corba/se/impl/io/OutputStreamHook.java@303fd9eb7e21 (annotated)

src/share/classes/com/sun/corba/se/impl/io/OutputStreamHook.java@303fd9eb7e21 (annotated)

src/share/classes/com/sun/corba/se/impl/io/OutputStreamHook.java

Tue, 19 May 2015 21:51:03 +0100

author: msheppar
date: Tue, 19 May 2015 21:51:03 +0100
changeset 940: 303fd9eb7e21
parent 754: 20e2e121586b
child 1022: 6081f57a0021
permissions: -rw-r--r--

8068721: RMI-IIOP communication fails when ConcurrentHashMap is passed to remote method
Reviewed-by: chegar, alanb

 /*
  * Copyright (c) 1999, 2015, 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.io;
 import java.io.IOException;
 import java.io.NotActiveException;
 import java.io.OutputStream;
 import java.io.ObjectOutputStream;
 import java.io.ObjectOutput;
 import java.util.Map;
 import java.util.HashMap;
 import org.omg.CORBA.INTERNAL;
 public abstract class OutputStreamHook extends ObjectOutputStream
 {
     private HookPutFields putFields = null;
     /**
      * Since ObjectOutputStream.PutField methods specify no exceptions,
      * we are not checking for null parameters on put methods.
      */
     private class HookPutFields extends ObjectOutputStream.PutField
     {
         private Map<String,Object> fields = new HashMap<>();
         /**
          * Put the value of the named boolean field into the persistent field.
          */
         public void put(String name, boolean value){
             fields.put(name, new Boolean(value));
         }
         /**
          * Put the value of the named char field into the persistent fields.
          */
         public void put(String name, char value){
             fields.put(name, new Character(value));
         }
         /**
          * Put the value of the named byte field into the persistent fields.
          */
         public void put(String name, byte value){
             fields.put(name, new Byte(value));
         }
         /**
          * Put the value of the named short field into the persistent fields.
          */
         public void put(String name, short value){
             fields.put(name, new Short(value));
         }
         /**
          * Put the value of the named int field into the persistent fields.
          */
         public void put(String name, int value){
             fields.put(name, new Integer(value));
         }
         /**
          * Put the value of the named long field into the persistent fields.
          */
         public void put(String name, long value){
             fields.put(name, new Long(value));
         }
         /**
          * Put the value of the named float field into the persistent fields.
          *
          */
         public void put(String name, float value){
             fields.put(name, new Float(value));
         }
         /**
          * Put the value of the named double field into the persistent field.
          */
         public void put(String name, double value){
             fields.put(name, new Double(value));
         }
         /**
          * Put the value of the named Object field into the persistent field.
          */
         public void put(String name, Object value){
             fields.put(name, value);
         }
         /**
          * Write the data and fields to the specified ObjectOutput stream.
          */
         public void write(ObjectOutput out) throws IOException {
             OutputStreamHook hook = (OutputStreamHook)out;
             ObjectStreamField[] osfields = hook.getFieldsNoCopy();
             // Write the fields to the stream in the order
             // provided by the ObjectStreamClass.  (They should
             // be sorted appropriately already.)
             for (int i = 0; i < osfields.length; i++) {
                 Object value = fields.get(osfields[i].getName());
                 hook.writeField(osfields[i], value);
             }
         }
     }
     abstract void writeField(ObjectStreamField field, Object value) throws IOException;
     public OutputStreamHook()
         throws java.io.IOException {
         super();
     }
     public void defaultWriteObject() throws IOException {
         writeObjectState.defaultWriteObject(this);
         defaultWriteObjectDelegate();
     }
     public abstract void defaultWriteObjectDelegate();
     public ObjectOutputStream.PutField putFields()
         throws IOException {
         if (putFields == null) {
             putFields = new HookPutFields();
         }
         return putFields;
     }
     // Stream format version, saved/restored during recursive calls
     protected byte streamFormatVersion = 1;
     // Return the stream format version currently being used
     // to serialize an object
     public byte getStreamFormatVersion() {
         return streamFormatVersion;
     }
     abstract ObjectStreamField[] getFieldsNoCopy();
     // User uses PutFields to simulate default data.
     // See java.io.ObjectOutputStream.PutFields
     public void writeFields()
         throws IOException {
         writeObjectState.defaultWriteObject(this);
         if (putFields != null) {
             putFields.write(this);
         } else {
             throw new NotActiveException("no current PutField object");
         }
     }
     abstract org.omg.CORBA_2_3.portable.OutputStream getOrbStream();
     protected abstract void beginOptionalCustomData();
     // The following is a State pattern implementation of what
     // should be done when a Serializable has a
     // writeObject method.  This was especially necessary for
     // RMI-IIOP stream format version 2.  Please see the
     // state diagrams in the docs directory of the workspace.
     protected WriteObjectState writeObjectState = NOT_IN_WRITE_OBJECT;
     protected void setState(WriteObjectState newState) {
         writeObjectState = newState;
     }
     // Description of possible actions
     protected static class WriteObjectState {
         public void enterWriteObject(OutputStreamHook stream) throws IOException {}
         public void exitWriteObject(OutputStreamHook stream) throws IOException {}
         public void defaultWriteObject(OutputStreamHook stream) throws IOException {}
         public void writeData(OutputStreamHook stream) throws IOException {}
     }
     protected static class DefaultState extends WriteObjectState {
         public void enterWriteObject(OutputStreamHook stream) throws IOException {
             stream.setState(IN_WRITE_OBJECT);
         }
     }
     protected static final WriteObjectState NOT_IN_WRITE_OBJECT = new DefaultState();
     protected static final WriteObjectState IN_WRITE_OBJECT = new InWriteObjectState();
     protected static final WriteObjectState WROTE_DEFAULT_DATA = new WroteDefaultDataState();
     protected static final WriteObjectState WROTE_CUSTOM_DATA = new WroteCustomDataState();
     protected static class InWriteObjectState extends WriteObjectState {
         public void enterWriteObject(OutputStreamHook stream) throws IOException {
             // XXX I18N, logging needed.
             throw new IOException("Internal state failure: Entered writeObject twice");
         }
         public void exitWriteObject(OutputStreamHook stream) throws IOException {
             // We didn't write any data, so write the
             // called defaultWriteObject indicator as false
             stream.getOrbStream().write_boolean(false);
             // If we're in stream format verison 2, we must
             // put the "null" marker to say that there isn't
             // any optional data
             if (stream.getStreamFormatVersion() == 2)
                 stream.getOrbStream().write_long(0);
             stream.setState(NOT_IN_WRITE_OBJECT);
         }
         public void defaultWriteObject(OutputStreamHook stream) throws IOException {
             // The writeObject method called defaultWriteObject
             // or writeFields, so put the called defaultWriteObject
             // indicator as true
             stream.getOrbStream().write_boolean(true);
             stream.setState(WROTE_DEFAULT_DATA);
         }
         public void writeData(OutputStreamHook stream) throws IOException {
             // The writeObject method first called a direct
             // write operation.  Write the called defaultWriteObject
             // indicator as false, put the special stream format
             // version 2 header (if stream format version 2, of course),
             // and write the data
             stream.getOrbStream().write_boolean(false);
             stream.beginOptionalCustomData();
             stream.setState(WROTE_CUSTOM_DATA);
         }
     }
     protected static class WroteDefaultDataState extends InWriteObjectState {
         public void exitWriteObject(OutputStreamHook stream) throws IOException {
             // We only wrote default data, so if in stream format
             // version 2, put the null indicator to say that there
             // is no optional data
             if (stream.getStreamFormatVersion() == 2)
                 stream.getOrbStream().write_long(0);
             stream.setState(NOT_IN_WRITE_OBJECT);
         }
         public void defaultWriteObject(OutputStreamHook stream) throws IOException {
             // XXX I18N, logging needed.
             throw new IOException("Called defaultWriteObject/writeFields twice");
         }
         public void writeData(OutputStreamHook stream) throws IOException {
             // The writeObject method called a direct write operation.
             // If in stream format version 2, put the fake valuetype
             // header.
             stream.beginOptionalCustomData();
             stream.setState(WROTE_CUSTOM_DATA);
         }
     }
     protected static class WroteCustomDataState extends InWriteObjectState {
         public void exitWriteObject(OutputStreamHook stream) throws IOException {
             // In stream format version 2, we must tell the ORB
             // stream to close the fake custom valuetype.
             if (stream.getStreamFormatVersion() == 2)
                 ((org.omg.CORBA.portable.ValueOutputStream)stream.getOrbStream()).end_value();
             stream.setState(NOT_IN_WRITE_OBJECT);
         }
         public void defaultWriteObject(OutputStreamHook stream) throws IOException {
             // XXX I18N, logging needed.
             throw new IOException("Cannot call defaultWriteObject/writeFields after writing custom data in RMI-IIOP");
         }
         // We don't have to do anything special here, just let
         // the stream write the data.
         public void writeData(OutputStreamHook stream) throws IOException {}
     }
 }

Mercurial > jdk8-mips64-public > corba / annotate

src/share/classes/com/sun/corba/se/impl/io/OutputStreamHook.java@303fd9eb7e21 (annotated)

src/share/classes/com/sun/corba/se/impl/io/OutputStreamHook.java