valuehandlerimpl.java

java jdk 1.4的源码

/*
 * @(#)ValueHandlerImpl.java	1.44 03/01/23
 *
 * Copyright 2003 Sun Microsystems, Inc. All rights reserved.
 * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */
/*
 * Licensed Materials - Property of IBM
 * RMI-IIOP v1.0
 * Copyright IBM Corp. 1998 1999  All Rights Reserved
 *
 * US Government Users Restricted Rights - Use, duplication or
 * disclosure restricted by GSA ADP Schedule Contract with IBM Corp.
 */

package com.sun.corba.se.internal.io;

import javax.rmi.CORBA.Util;
import javax.rmi.PortableRemoteObject;

import java.util.Hashtable;
import java.util.Stack;
import java.io.IOException;
import java.util.EmptyStackException;

import com.sun.corba.se.internal.util.Utility;
import com.sun.corba.se.internal.io.IIOPInputStream;
import com.sun.corba.se.internal.io.IIOPOutputStream;
import com.sun.corba.se.internal.util.MinorCodes;
import com.sun.corba.se.internal.util.RepositoryId;
import com.sun.corba.se.internal.util.Utility;

import org.omg.CORBA.TCKind;

import org.omg.CORBA.MARSHAL;
import org.omg.CORBA.CompletionStatus;
import org.omg.CORBA.portable.IndirectionException;
import com.sun.org.omg.SendingContext.CodeBase;
import com.sun.org.omg.SendingContext.CodeBaseHelper;

import java.security.AccessController;
import java.security.PrivilegedAction;
 
import com.sun.corba.se.internal.io.IIOPInputStream.ActiveRecursionManager;

public class ValueHandlerImpl implements javax.rmi.CORBA.ValueHandler {

    public static final short kRemoteType = 0;
    public static final short kAbstractType = 1;
    public static final short kValueType = 2;

    private Hashtable inputStreamPairs = null;
    private Hashtable outputStreamPairs = null;
    private CodeBase codeBase = null;
    private static boolean libraryManagerLoaded = false;
    private boolean useHashtables = true;
    private boolean isInputStream = true;
    private IIOPOutputStream outputStreamBridge = null;
    private IIOPInputStream inputStreamBridge = null;

    public ValueHandlerImpl(){
	if (!libraryManagerLoaded) {
        com.sun.corba.se.internal.io.LibraryManager.load();
	    libraryManagerLoaded = true;
        }
    }

    public ValueHandlerImpl(boolean isInputStream) {
	this();
	useHashtables = false;
	this.isInputStream = isInputStream;
    }

    /**
     * Writes the value to the stream using java semantics.
     * @param out The stream to write the value to
     * @param value The value to be written to the stream
     **/
    public void writeValue(org.omg.CORBA.portable.OutputStream _out, java.io.Serializable value) {
	org.omg.CORBA_2_3.portable.OutputStream out =
	    (org.omg.CORBA_2_3.portable.OutputStream) _out;

	if (!useHashtables)
	    {
		if (outputStreamBridge == null)
		    {
			outputStreamBridge = createOutputStream();
			outputStreamBridge.setOrbStream(out);
		    }
		try {
		    outputStreamBridge.increaseRecursionDepth();
		    writeValueInternal(outputStreamBridge, out, value);
		}
		finally
		    {
			outputStreamBridge.decreaseRecursionDepth();
		    }
		return;
	    }
		
        IIOPOutputStream jdkToOrbOutputStreamBridge = null;

	if (outputStreamPairs == null)
	    outputStreamPairs = new Hashtable();
		
	    jdkToOrbOutputStreamBridge = (IIOPOutputStream)outputStreamPairs.get(_out);
	    if (jdkToOrbOutputStreamBridge == null)
		{
		jdkToOrbOutputStreamBridge = createOutputStream();
		    jdkToOrbOutputStreamBridge.setOrbStream(out);
		    outputStreamPairs.put(_out, jdkToOrbOutputStreamBridge);
		}

        try {
	    jdkToOrbOutputStreamBridge.increaseRecursionDepth();
	    writeValueInternal(jdkToOrbOutputStreamBridge, out, value);
		}
        finally
	    {
		if (jdkToOrbOutputStreamBridge.decreaseRecursionDepth() == 0)
		    {
			outputStreamPairs.remove(_out);
		    }
	    }
    }

    private void writeValueInternal(IIOPOutputStream bridge,
				    org.omg.CORBA_2_3.portable.OutputStream out,
				    java.io.Serializable value)
    {
	Class clazz = value.getClass();

        if (clazz.isArray())
            write_Array(out, value, clazz.getComponentType());
        else
            bridge.simpleWriteObject(value);
    }

    /**
     * Reads a value from the stream using java semantics.
     * @param in The stream to read the value from
     * @param clazz The type of the value to be read in
     * @param sender The sending context runtime
     **/
    public java.io.Serializable readValue(org.omg.CORBA.portable.InputStream _in,
					  int offset, 
					  java.lang.Class clazz, 
					  String repositoryID,
					  org.omg.SendingContext.RunTime _sender)
    {
        // Must use narrow rather than a direct cast to a com.sun
        // class.  Fix for bug 4379539.
	CodeBase sender = CodeBaseHelper.narrow(_sender);

	org.omg.CORBA_2_3.portable.InputStream in = 
	    (org.omg.CORBA_2_3.portable.InputStream) _in;

	if (!useHashtables)
	    {
		if (inputStreamBridge == null)
		    {
			inputStreamBridge = createInputStream();
		        inputStreamBridge.setOrbStream(in);
		        inputStreamBridge.setSender(sender); //d11638
	                // backward compatability 4365188
		        inputStreamBridge.setValueHandler(this); 
		    }
			
		java.io.Serializable result = null;
    	try {
		    inputStreamBridge.increaseRecursionDepth();
		    result = (java.io.Serializable) readValueInternal(inputStreamBridge, in, offset, clazz, repositoryID, sender);
		}
		finally
		    {
			if (inputStreamBridge.decreaseRecursionDepth() == 0)
			    {
                                // Indirections are resolved immediately since
                                // the change to the active recursion manager,
                                // so this will never happen.
                                //
				//if (!inputStreamBridge.recursionManager.isEmpty())
				//    throw new org.omg.CORBA.MARSHAL("Dangling recursive references");
			    }
		    }
		return result;
	    }
            
        IIOPInputStream jdkToOrbInputStreamBridge = null;
        if (inputStreamPairs == null)
            inputStreamPairs = new Hashtable();
		
	    jdkToOrbInputStreamBridge = (IIOPInputStream)inputStreamPairs.get(_in);
	    if (jdkToOrbInputStreamBridge == null)
		{
		jdkToOrbInputStreamBridge = createInputStream();
		    jdkToOrbInputStreamBridge.setOrbStream(in);
		    jdkToOrbInputStreamBridge.setSender(sender); //d11638
	            // backward compatability 4365188
		    jdkToOrbInputStreamBridge.setValueHandler(this); 
		    inputStreamPairs.put(_in, jdkToOrbInputStreamBridge);
		}

	java.io.Serializable result = null;
		
    	try {
			
	    jdkToOrbInputStreamBridge.increaseRecursionDepth();
	    result = (java.io.Serializable) readValueInternal(jdkToOrbInputStreamBridge, in, offset, clazz, repositoryID, sender);
			}
        finally
		    {
		if (jdkToOrbInputStreamBridge.decreaseRecursionDepth() == 0)
			    {
			inputStreamPairs.remove(_in);
			    }
			
		    }

	    return result;
	}

    private java.io.Serializable readValueInternal(IIOPInputStream bridge,
						  org.omg.CORBA_2_3.portable.InputStream in,
						  int offset,
						  java.lang.Class clazz,
						  String repositoryID,
						  com.sun.org.omg.SendingContext.CodeBase sender)
	    {
	java.io.Serializable result = null;
		
	if (clazz == null) {
	    // clazz == null indicates an FVD situation for a nonexistant class
	    if (isArray(repositoryID)){
		read_Array(bridge, in, null, sender, offset);
	    } else {
		bridge.simpleSkipObject(repositoryID, sender);
	    }
	    return result;
	}
		
        if (clazz.isArray())
		    {
		result = (java.io.Serializable)read_Array(bridge, in, clazz, sender, offset);
	    } else
		{
		    result = (java.io.Serializable)bridge.simpleReadObject(clazz, repositoryID, sender, offset);
		    }

	if (result != null)
	    {
		// bridge.recursionManager.handleRecursions(offset, result);
	    }

	return result;
    }

    /**
     * Returns the repository ID for the given RMI value Class.
     * @param clz The class to return a repository ID for.
     * @return the repository ID of the Class.
     **/
    public java.lang.String getRMIRepositoryID(java.lang.Class clz) {
	return RepositoryId.createForJavaType(clz);
    }

    /**
     * Indicates whether the given Class performs custom or
     * default marshaling.
     * @param clz The class to test for custom marshaling.
     * @return True if the class performs custom marshaling, false
     * if it does not.
     **/
    public boolean isCustomMarshaled(java.lang.Class clz) {
	return ObjectStreamClass.lookup(clz).isCustomMarshaled();
    }

    /**
     * Returns the CodeBase for this ValueHandler.  This is used by
     * the ORB runtime.  The server sends the service context containing
     * the IOR for this CodeBase on the first GIOP reply.  The clients
     * do the same on the first GIOP request.
     * @return the SendingContext.CodeBase of this ValueHandler.
     **/
    public org.omg.SendingContext.RunTime getRunTimeCodeBase() {
	if (codeBase != null)
	    return codeBase;
	else {
	    codeBase = new FVDCodeBaseImpl();

	    // backward compatability 4365188
            // set the valueHandler so that correct/incorrect RepositoryID
            // calculations can be done based on the ORB version
            FVDCodeBaseImpl fvdImpl = (FVDCodeBaseImpl) codeBase;
            fvdImpl.setValueHandler(this);
	    return codeBase;
	}
    }


    // methods supported for backward compatability so that the appropriate
    // Rep-id calculations take place based on the ORB version

    /**
     *  Returns a boolean of whether or not RepositoryId indicates
     *  FullValueDescriptor.
     *  used for backward compatability
     */

     public boolean useFullValueDescription(Class clazz, String repositoryID)
	throws IOException
     {
	return RepositoryId.useFullValueDescription(clazz, repositoryID);
     }

     public String getClassName(String id)
     {
        RepositoryId repID = RepositoryId.cache.getId(id);
        return repID.getClassName();
     }

     public Class getClassFromType(String id)
        throws ClassNotFoundException
     {
        RepositoryId repId = RepositoryId.cache.getId(id);
        return repId.getClassFromType();
     }

     public Class getAnyClassFromType(String id)
        throws ClassNotFoundException
     {
        RepositoryId repId = RepositoryId.cache.getId(id);
        return repId.getAnyClassFromType();
     }

     public String createForAnyType(Class cl)
     {
        return RepositoryId.createForAnyType(cl);
     }

     public String getDefinedInId(String id)
     {
        RepositoryId repId = RepositoryId.cache.getId(id);
        return repId.getDefinedInId();
     }

     public String getUnqualifiedName(String id)
     {
        RepositoryId repId = RepositoryId.cache.getId(id);
        return repId.getUnqualifiedName();
     }

     public String getSerialVersionUID(String id)
     {
        RepositoryId repId = RepositoryId.cache.getId(id);
        return repId.getSerialVersionUID();
     }


     public boolean isAbstractBase(Class clazz)
     {
        return RepositoryId.isAbstractBase(clazz);
     }

     public boolean isSequence(String id)
     {
        RepositoryId repId = RepositoryId.cache.getId(id);
        return repId.isSequence();
     }

    /**
     * If the value contains a writeReplace method then the result
     * is returned.  Otherwise, the value itself is returned.
     * @return the true value to marshal on the wire.
     **/
    public java.io.Serializable writeReplace(java.io.Serializable value) {
	return ObjectStreamClass.lookup(value.getClass()).writeReplace(value);
    }

    /**
     * Encapsulates writing of Java char arrays so that the 1.3 subclass
     * can override it without exposing internals across packages.  This
     * is a fix for bug 4367783.
     */
    protected void writeCharArray(org.omg.CORBA_2_3.portable.OutputStream out,
                                char[] array,
                                int offset,
                                int length)
    {
        out.write_wchar_array(array, offset, length);
    }

    private void write_Array(org.omg.CORBA_2_3.portable.OutputStream out, java.io.Serializable obj, Class type) {

        int i, length;

        if (type.isPrimitive()) {
            if (type == Integer.TYPE) {
		int[] array = (int[])((Object)obj);
		length = array.length;
		out.write_ulong(length);
		out.write_long_array(array, 0, length);
            } else if (type == Byte.TYPE) {
		byte[] array = (byte[])((Object)obj);
		length = array.length;
		out.write_ulong(length);