alvinalexander.com | career | drupal | java | mac | mysql | perl | scala | uml | unix  

Java example source code file (DynamicMethodMarshallerImpl.java)

This example Java source code file (DynamicMethodMarshallerImpl.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

boolean, character, class, corba, double, float, inputstream, long, method, object, outputstream, readerwriter, readerwriterbase, reflection, rmi, short, string

The DynamicMethodMarshallerImpl.java Java example source code

/*
 * Copyright (c) 2003, 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.presentation.rmi ;

import java.io.Serializable ;
import java.io.Externalizable ;

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

import org.omg.CORBA.portable.IDLEntity ;

import org.omg.CORBA_2_3.portable.InputStream ;
import org.omg.CORBA_2_3.portable.OutputStream ;
import org.omg.CORBA.portable.ApplicationException ;

import java.lang.reflect.Method ;

import java.rmi.RemoteException ;

import com.sun.corba.se.spi.orb.ORB ;

import com.sun.corba.se.spi.presentation.rmi.DynamicMethodMarshaller ;

public class DynamicMethodMarshallerImpl implements DynamicMethodMarshaller
{
    Method method ;
    ExceptionHandler ehandler ;
    boolean hasArguments = true ;
    boolean hasVoidResult = true ;
    boolean needsArgumentCopy ;         // true if copyObjects call needs for args
    boolean needsResultCopy ;           // true if copyObject call needs for result
    ReaderWriter[] argRWs = null ;
    ReaderWriter resultRW = null ;

    private static boolean isAnyClass( Class cls )
    {
        return cls.equals( Object.class ) || cls.equals( Serializable.class ) ||
            cls.equals( Externalizable.class ) ;
    }

    // Assume that cls is not Remote, !isAnyClass(cls), and
    // !org.omg.CORBA.Object.class.isAssignableFrom( cls ).
    // Then return whether cls is an RMI-IIOP abstract interface.
    private static boolean isAbstractInterface( Class cls )
    {
        // Either cls is an interface that extends IDLEntity, or else
        // cls does not extend java.rmi.Remote and all of its methods
        // throw RemoteException.
        if (IDLEntity.class.isAssignableFrom( cls ))
            return cls.isInterface() ;
        else
            return cls.isInterface() && allMethodsThrowRemoteException( cls ) ;
    }

    private static boolean allMethodsThrowRemoteException( Class cls )
    {
        Method[] methods = cls.getMethods() ;

        // Check that all methods (other than those declared in java.lang.Object)
        // throw an exception that is a subclass of RemoteException.
        for (int ctr=0; ctr<methods.length; ctr++) {
            Method method = methods[ctr] ;
            if (method.getDeclaringClass() != Object.class)
                if (!throwsRemote( method ))
                    return false ;
        }

        return true ;
    }

    private static boolean throwsRemote( Method method )
    {
        Class[] exceptionTypes = method.getExceptionTypes() ;

        // Check that some exceptionType is a subclass of RemoteException
        for (int ctr=0; ctr<exceptionTypes.length; ctr++) {
            Class exceptionType = exceptionTypes[ctr] ;
            if (java.rmi.RemoteException.class.isAssignableFrom( exceptionType ))
                return true ;
        }

        return false ;
    }

    public interface ReaderWriter
    {
        Object read( InputStream is ) ;

        void write( OutputStream os, Object value ) ;
    }

    abstract static class ReaderWriterBase implements ReaderWriter
    {
        String name ;

        public ReaderWriterBase( String name )
        {
            this.name = name ;
        }

        public String toString()
        {
            return "ReaderWriter[" + name + "]" ;
        }
    }

    private static ReaderWriter booleanRW = new ReaderWriterBase( "boolean" )
    {
        public Object read( InputStream is )
        {
            boolean value = is.read_boolean() ;
            return new Boolean( value ) ;
        }

        public void write( OutputStream os, Object value )
        {
            Boolean val = (Boolean)value ;
            os.write_boolean( val.booleanValue() ) ;
        }
    } ;

    private static ReaderWriter byteRW = new ReaderWriterBase( "byte" )
    {
        public Object read( InputStream is )
        {
            byte value = is.read_octet() ;
            return new Byte( value ) ;
        }

        public void write( OutputStream os, Object value )
        {
            Byte val = (Byte)value ;
            os.write_octet( val.byteValue() ) ;
        }
    } ;

    private static ReaderWriter charRW = new ReaderWriterBase( "char" )
    {
        public Object read( InputStream is )
        {
            char value = is.read_wchar() ;
            return new Character( value ) ;
        }

        public void write( OutputStream os, Object value )
        {
            Character val = (Character)value ;
            os.write_wchar( val.charValue() ) ;
        }
    } ;

    private static ReaderWriter shortRW = new ReaderWriterBase( "short" )
    {
        public Object read( InputStream is )
        {
            short value = is.read_short() ;
            return new Short( value ) ;
        }

        public void write( OutputStream os, Object value )
        {
            Short val = (Short)value ;
            os.write_short( val.shortValue() ) ;
        }
    } ;

    private static ReaderWriter intRW = new ReaderWriterBase( "int" )
    {
        public Object read( InputStream is )
        {
            int value = is.read_long() ;
            return new Integer( value ) ;
        }

        public void write( OutputStream os, Object value )
        {
            Integer val = (Integer)value ;
            os.write_long( val.intValue() ) ;
        }
    } ;

    private static ReaderWriter longRW = new ReaderWriterBase( "long" )
    {
        public Object read( InputStream is )
        {
            long value = is.read_longlong() ;
            return new Long( value ) ;
        }

        public void write( OutputStream os, Object value )
        {
            Long val = (Long)value ;
            os.write_longlong( val.longValue() ) ;
        }
    } ;

    private static ReaderWriter floatRW = new ReaderWriterBase( "float" )
    {
        public Object read( InputStream is )
        {
            float value = is.read_float() ;
            return new Float( value ) ;
        }

        public void write( OutputStream os, Object value )
        {
            Float val = (Float)value ;
            os.write_float( val.floatValue() ) ;
        }
    } ;

    private static ReaderWriter doubleRW = new ReaderWriterBase( "double" )
    {
        public Object read( InputStream is )
        {
            double value = is.read_double() ;
            return new Double( value ) ;
        }

        public void write( OutputStream os, Object value )
        {
            Double val = (Double)value ;
            os.write_double( val.doubleValue() ) ;
        }
    } ;

    private static ReaderWriter corbaObjectRW = new ReaderWriterBase(
        "org.omg.CORBA.Object" )
    {
        public Object read( InputStream is )
        {
            return is.read_Object() ;
        }

        public void write( OutputStream os, Object value )
        {
            os.write_Object( (org.omg.CORBA.Object)value ) ;
        }
    } ;

    private static ReaderWriter anyRW = new ReaderWriterBase( "any" )
    {
        public Object read( InputStream is )
        {
            return Util.readAny(is) ;
        }

        public void write( OutputStream os, Object value )
        {
            Util.writeAny( os, value ) ;
        }
    } ;

    private static ReaderWriter abstractInterfaceRW = new ReaderWriterBase(
        "abstract_interface"  )
    {
        public Object read( InputStream is )
        {
            return is.read_abstract_interface() ;
        }

        public void write( OutputStream os, Object value )
        {
            Util.writeAbstractObject( os, value ) ;
        }
    } ;


    public static ReaderWriter makeReaderWriter( final Class cls )
    {
        if (cls.equals( boolean.class ))
            return booleanRW ;
        else if (cls.equals( byte.class ))
            return byteRW ;
        else if (cls.equals( char.class ))
            return charRW ;
        else if (cls.equals( short.class ))
            return shortRW ;
        else if (cls.equals( int.class ))
            return intRW ;
        else if (cls.equals( long.class ))
            return longRW ;
        else if (cls.equals( float.class ))
            return floatRW ;
        else if (cls.equals( double.class ))
            return doubleRW ;
        else if (java.rmi.Remote.class.isAssignableFrom( cls ))
            return new ReaderWriterBase( "remote(" + cls.getName() + ")" )
            {
                public Object read( InputStream is )
                {
                    return PortableRemoteObject.narrow( is.read_Object(),
                        cls ) ;
                }

                public void write( OutputStream os, Object value )
                {
                    Util.writeRemoteObject( os, value ) ;
                }
            } ;
        else if (cls.equals(org.omg.CORBA.Object.class))
            return corbaObjectRW ;
        else if (org.omg.CORBA.Object.class.isAssignableFrom( cls ))
            return new ReaderWriterBase( "org.omg.CORBA.Object(" +
                cls.getName() + ")" )
            {
                public Object read( InputStream is )
                {
                    return is.read_Object(cls) ;
                }

                public void write( OutputStream os, Object value )
                {
                    os.write_Object( (org.omg.CORBA.Object)value ) ;
                }
            } ;
        else if (isAnyClass(cls))
            return anyRW ;
        else if (isAbstractInterface(cls))
            return abstractInterfaceRW ;

        // For anything else, just read it as a value type.
        return new ReaderWriterBase( "value(" + cls.getName() + ")" )
        {
            public Object read( InputStream is )
            {
                return is.read_value(cls) ;
            }

            public void write( OutputStream os, Object value )
            {
                os.write_value( (Serializable)value, cls ) ;
            }
        } ;
    }

    public DynamicMethodMarshallerImpl( Method method )
    {
        this.method = method ;
        ehandler = new ExceptionHandlerImpl( method.getExceptionTypes() ) ;
        needsArgumentCopy = false ;

        Class[] argTypes = method.getParameterTypes() ;
        hasArguments = argTypes.length > 0 ;
        if (hasArguments) {
            argRWs = new ReaderWriter[ argTypes.length ] ;
            for (int ctr=0; ctr<argTypes.length; ctr++ ) {
                // This could be further optimized to avoid
                // copying if argTypes contains at most one
                // immutable object type.
                if (!argTypes[ctr].isPrimitive())
                    needsArgumentCopy = true ;
                argRWs[ctr] = makeReaderWriter( argTypes[ctr] ) ;
            }
        }

        Class resultType = method.getReturnType() ;
        needsResultCopy = false ;
        hasVoidResult = resultType.equals( void.class ) ;
        if (!hasVoidResult) {
            needsResultCopy = !resultType.isPrimitive() ;
            resultRW = makeReaderWriter( resultType ) ;
        }
    }

    public Method getMethod()
    {
        return method ;
    }

    public Object[] copyArguments( Object[] args,
        ORB orb ) throws RemoteException
    {
        if (needsArgumentCopy)
            return Util.copyObjects( args, orb ) ;
        else
            return args ;
    }

    public Object[] readArguments( InputStream is )
    {
        Object[] result = null ;

        if (hasArguments) {
            result = new Object[ argRWs.length ] ;
            for (int ctr=0; ctr<argRWs.length; ctr++ )
                result[ctr] = argRWs[ctr].read( is ) ;
        }

        return result ;
    }

    public void writeArguments( OutputStream os, Object[] args )
    {
        if (hasArguments) {
            if (args.length != argRWs.length)
                throw new IllegalArgumentException( "Expected " + argRWs.length +
                    " arguments, but got " + args.length + " arguments." ) ;

            for (int ctr=0; ctr<argRWs.length; ctr++ )
                argRWs[ctr].write( os, args[ctr] ) ;
        }
    }

    public Object copyResult( Object result, ORB orb ) throws RemoteException
    {
        if (needsResultCopy)
            return Util.copyObject( result, orb ) ;
        else
            return result ;
    }

    public Object readResult( InputStream is )
    {
        if (hasVoidResult)
            return null ;
        else
            return resultRW.read( is ) ;
    }

    public void writeResult( OutputStream os, Object result )
    {
        if (!hasVoidResult)
            resultRW.write( os, result ) ;
    }

    public boolean isDeclaredException( Throwable thr )
    {
        return ehandler.isDeclaredException( thr.getClass() ) ;
    }

    public void writeException( OutputStream os, Exception ex )
    {
        ehandler.writeException( os, ex ) ;
    }

    public Exception readException( ApplicationException ae )
    {
        return ehandler.readException( ae ) ;
    }
}

Other Java examples (source code examples)

Here is a short list of links related to this Java DynamicMethodMarshallerImpl.java source code file:

... this post is sponsored by my books ...

#1 New Release!

FP Best Seller

 

new blog posts

 

Copyright 1998-2021 Alvin Alexander, alvinalexander.com
All Rights Reserved.

A percentage of advertising revenue from
pages under the /java/jwarehouse URI on this website is
paid back to open source projects.