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

Java example source code file (Utility.java)

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

cache_miss, class, classcastexception, classloader, classnotfoundexception, corba, delegate, identityhashtable, object, remote, rmi, string, stub_prefix, stubentry, throwable, tie, util

The Utility.java Java example source code

/*
 * Copyright (c) 1999, 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.
 */

/*
 * Licensed Materials - Property of IBM
 * RMI-IIOP v1.0
 * Copyright IBM Corp. 1998 1999  All Rights Reserved
 *
 */

package com.sun.corba.se.impl.util;

import org.omg.CORBA.SystemException;
import org.omg.CORBA.CompletionStatus;
import org.omg.CORBA.BAD_OPERATION;
import org.omg.CORBA.BAD_INV_ORDER;
import org.omg.CORBA.BAD_PARAM;
import org.omg.CORBA.ORB;
import org.omg.CORBA.Any;
import org.omg.CORBA.TypeCode;
import org.omg.CORBA.Principal;
import org.omg.CORBA.portable.InputStream;
import org.omg.CORBA.portable.OutputStream;
import org.omg.CORBA.portable.BoxedValueHelper;
import org.omg.CORBA.portable.ValueFactory;
import org.omg.CORBA.portable.Streamable;
import org.omg.CORBA.portable.Delegate;


import java.util.Hashtable;
import java.util.NoSuchElementException;

import java.rmi.Remote;
import java.rmi.NoSuchObjectException;
import java.rmi.RemoteException;
import java.rmi.server.RemoteStub;

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

import java.io.Serializable;
import java.io.File;
import java.io.FileInputStream;

import org.omg.PortableServer.POA;

import com.sun.org.omg.SendingContext.CodeBase;

import com.sun.corba.se.spi.logging.CORBALogDomains ;
import com.sun.corba.se.spi.presentation.rmi.PresentationManager;
import com.sun.corba.se.spi.presentation.rmi.StubAdapter ;

import com.sun.corba.se.impl.logging.UtilSystemException ;
import com.sun.corba.se.impl.logging.OMGSystemException ;

/**
 *  Handy class full of static functions.
 */
public final class Utility {

    public static final String STUB_PREFIX = "_";
    public static final String RMI_STUB_SUFFIX = "_Stub";
    public static final String DYNAMIC_STUB_SUFFIX = "_DynamicStub" ;
    public static final String IDL_STUB_SUFFIX = "Stub";
    public static final String TIE_SUFIX = "_Tie";
    private static IdentityHashtable tieCache = new IdentityHashtable();
    private static IdentityHashtable tieToStubCache = new IdentityHashtable();
    private static IdentityHashtable stubToTieCache = new IdentityHashtable();
    private static Object CACHE_MISS = new Object();
    private static UtilSystemException wrapper = UtilSystemException.get(
        CORBALogDomains.UTIL ) ;
    private static OMGSystemException omgWrapper = OMGSystemException.get(
        CORBALogDomains.UTIL ) ;

    /**
     * Ensure that stubs, ties, and implementation objects
     * are 'connected' to the runtime. Converts implementation
     * objects to a type suitable for sending on the wire.
     * @param obj the object to connect.
     * @param orb the ORB to connect to if obj is exported to IIOP.
     * @param convertToStub true if implementation types should be
     * converted to Stubs rather than just org.omg.CORBA.Object.
     * @return the connected object.
     * @exception NoSuchObjectException if obj is an implementation
     * which has not been exported.
     */
    public static Object autoConnect(Object obj, ORB orb, boolean convertToStub)
    {
        if (obj == null) {
            return obj;
        }

        if (StubAdapter.isStub(obj)) {
            try {
                StubAdapter.getDelegate(obj) ;
            } catch (BAD_OPERATION okay) {
                try {
                    StubAdapter.connect( obj, orb ) ;
                } catch (RemoteException e) {
                    // The stub could not be connected because it
                    // has an invalid IOR...
                    throw wrapper.objectNotConnected( e,
                        obj.getClass().getName() ) ;
                }
            }

            return obj;
        }

        if (obj instanceof Remote) {
            Remote remoteObj = (Remote)obj;
            Tie theTie = Util.getTie(remoteObj);
            if (theTie != null) {
                try {
                    theTie.orb();
                } catch (SystemException okay) {
                    theTie.orb(orb);
                }

                if (convertToStub) {
                    Object result = loadStub(theTie,null,null,true);
                    if (result != null) {
                        return result;
                    } else {
                        throw wrapper.couldNotLoadStub(obj.getClass().getName());
                    }
                } else {
                    return StubAdapter.activateTie( theTie );
                }
            } else {
                // This is an implementation object which has not been
                // exported to IIOP OR is a JRMP stub or implementation
                // object which cannot be marshalled into an ORB stream...
                throw wrapper.objectNotExported( obj.getClass().getName() ) ;
            }
        }

        // Didn't need to do anything, just return the input...

        return obj;
    }

    /*
     * Get a new instance of an RMI-IIOP Tie for the
     * given server object.
     */
    public static Tie loadTie(Remote obj) {
        Tie result = null;
        Class objClass = obj.getClass();

        // Have we tried to find this guy before?

        synchronized (tieCache) {

            Object it = tieCache.get(obj);

            if (it == null) {

                // No, so try it...

                try {

                    // First try the classname...

                    result = loadTie(objClass);

                    // If we don't have a valid tie at this point,
                    // walk up the parent chain until we either
                    // load a tie or encounter PortableRemoteObject
                    // or java.lang.Object...

                    while (result == null &&
                           (objClass = objClass.getSuperclass()) != null &&
                           objClass != PortableRemoteObject.class &&
                           objClass != Object.class) {

                        result = loadTie(objClass);
                    }
                } catch (Exception ex) {
                    wrapper.loadTieFailed( ex, objClass.getName() ) ;
                }

                // Did we get it?

                if (result == null) {

                    // Nope, so cache that fact...

                    tieCache.put(obj,CACHE_MISS);

                } else {

                    // Yes, so cache it...

                    tieCache.put(obj,result);
                }
            } else {

                // Yes, return a new instance or fail again if
                // it was a miss last time...

                if (it != CACHE_MISS) {
                    try {
                        result = (Tie) it.getClass().newInstance();
                    } catch (Exception e) {
                    }
                }
            }
        }

        return result;
    }

    /*
     * Load an RMI-IIOP Tie
     */
    private static Tie loadTie(Class theClass)
    {
        return com.sun.corba.se.spi.orb.ORB.getStubFactoryFactory().
            getTie( theClass ) ;
    }

    /*
     * Clear the stub/tie caches. Intended for use by
     * test code.
     */
    public static void clearCaches() {
        synchronized (tieToStubCache) {
            tieToStubCache.clear();
        }
        synchronized (tieCache) {
            tieCache.clear();
        }
        synchronized (stubToTieCache) {
            stubToTieCache.clear();
        }
    }

    /*
     * Load a class and check that it is assignable to a given type.
     * @param className the class name.
     * @param remoteCodebase the codebase to use. May be null.
     * @param loader the class loader of last resort. May be null.
     * @param expectedType the expected type. May be null.
     * @return the loaded class.
     */
    static Class loadClassOfType(String className, String remoteCodebase,
        ClassLoader loader, Class expectedType,
        ClassLoader expectedTypeClassLoader) throws ClassNotFoundException
    {
        Class loadedClass = null;

        try {
            //Sequence finding of the stubs according to spec
            try{
                //If-else is put here for speed up of J2EE.
                //According to the OMG spec, the if clause is not dead code.
                //It can occur if some compiler has allowed generation
                //into org.omg.stub hierarchy for non-offending
                //classes. This will encourage people to
                //produce non-offending class stubs in their own hierarchy.
                if (!PackagePrefixChecker.hasOffendingPrefix(
                    PackagePrefixChecker.withoutPackagePrefix(className))){
                    loadedClass = Util.loadClass(
                        PackagePrefixChecker.withoutPackagePrefix(className),
                        remoteCodebase,
                        loader);
                } else {
                    loadedClass = Util.loadClass(className, remoteCodebase,
                        loader);
                }
            } catch (ClassNotFoundException cnfe) {
                loadedClass = Util.loadClass(className, remoteCodebase,
                    loader);
            }
            if (expectedType == null)
                return loadedClass;
        } catch (ClassNotFoundException cnfe) {
            if (expectedType == null)
                throw cnfe;
        }

        // If no class was loaded, or if the loaded class is not of the
        // correct type, make a further attempt to load the correct class
        // using the classloader of the expected type.
        // _REVISIT_ Is this step necessary, or should the Util,loadClass
        // algorithm always produce a valid class if the setup is correct?
        // Does the OMG standard algorithm need to be changed to include
        // this step?
        if (loadedClass == null || !expectedType.isAssignableFrom(loadedClass)){
            if (expectedType.getClassLoader() != expectedTypeClassLoader)
                throw new IllegalArgumentException(
                    "expectedTypeClassLoader not class loader of "  +
                    "expected Type.");

            if (expectedTypeClassLoader != null)
                loadedClass = expectedTypeClassLoader.loadClass(className);
            else {
                ClassLoader cl = Thread.currentThread().getContextClassLoader();
                if (cl == null)
                    cl = ClassLoader.getSystemClassLoader();

                loadedClass = cl.loadClass(className);
            }
        }

        return loadedClass;
    }

    /*
     * Load a class and check that it is compatible with a given type.
     * @param className the class name.
     * @param remoteCodebase the codebase to use. May be null.
     * @param loadingContext the loading context. May be null.
     * @param relatedType the related type. May be null.
     * @return the loaded class.
     */
    public static Class loadClassForClass (String className,
                                           String remoteCodebase,
                                           ClassLoader loader,
                                           Class relatedType,
                                           ClassLoader relatedTypeClassLoader)
        throws ClassNotFoundException
    {
        if (relatedType == null)
            return Util.loadClass(className, remoteCodebase, loader);

        Class loadedClass = null;
        try {
            loadedClass = Util.loadClass(className, remoteCodebase, loader);
        } catch (ClassNotFoundException cnfe) {
            if (relatedType.getClassLoader() == null)
                throw cnfe;
        }

        // If no class was not loaded, or if the loaded class is not of the
        // correct type, make a further attempt to load the correct class
        // using the classloader of the related type.
        // _REVISIT_ Is this step necessary, or should the Util,loadClass
        // algorithm always produce a valid class if the setup is correct?
        // Does the OMG standard algorithm need to be changed to include
        // this step?
        if (loadedClass == null ||
            (loadedClass.getClassLoader() != null &&
             loadedClass.getClassLoader().loadClass(relatedType.getName()) !=
                 relatedType))
        {
            if (relatedType.getClassLoader() != relatedTypeClassLoader)
                throw new IllegalArgumentException(
                    "relatedTypeClassLoader not class loader of relatedType.");

            if (relatedTypeClassLoader != null)
                loadedClass = relatedTypeClassLoader.loadClass(className);
        }

        return loadedClass;
    }

    /**
     * Get the helper for an IDLValue
     *
     * Throws MARSHAL exception if no helper found.
     */
    public static BoxedValueHelper getHelper(Class clazz, String codebase,
        String repId)
    {
        String className = null;
        if (clazz != null) {
            className = clazz.getName();
            if (codebase == null)
                codebase = Util.getCodebase(clazz);
        } else {
            if (repId != null)
                className = RepositoryId.cache.getId(repId).getClassName();
            if (className == null) // no repId or unrecognized repId
                throw wrapper.unableLocateValueHelper(
                    CompletionStatus.COMPLETED_MAYBE);
        }

        try {
            ClassLoader clazzLoader =
                (clazz == null ? null : clazz.getClassLoader());
            Class helperClass =
                loadClassForClass(className+"Helper", codebase, clazzLoader,
                clazz, clazzLoader);
            return (BoxedValueHelper)helperClass.newInstance();

        } catch (ClassNotFoundException cnfe) {
            throw wrapper.unableLocateValueHelper( CompletionStatus.COMPLETED_MAYBE,
                cnfe );
        } catch (IllegalAccessException iae) {
            throw wrapper.unableLocateValueHelper( CompletionStatus.COMPLETED_MAYBE,
                iae );
        } catch (InstantiationException ie) {
            throw wrapper.unableLocateValueHelper( CompletionStatus.COMPLETED_MAYBE,
                ie );
        } catch (ClassCastException cce) {
            throw wrapper.unableLocateValueHelper( CompletionStatus.COMPLETED_MAYBE,
                cce );
        }
    }

    /**
     * Get the factory for an IDLValue
     *
     * Throws MARSHAL exception if no factory found.
     */
    public static ValueFactory getFactory(Class clazz, String codebase,
                               ORB orb, String repId)
    {
        ValueFactory factory = null;
        if ((orb != null) && (repId != null)) {
            try {
                factory = ((org.omg.CORBA_2_3.ORB)orb).lookup_value_factory(
                    repId);
            } catch (org.omg.CORBA.BAD_PARAM ex) {
                // Try other way
            }
        }

        String className = null;
        if (clazz != null) {
            className = clazz.getName();
            if (codebase == null)
                codebase = Util.getCodebase(clazz);
        } else {
            if (repId != null)
                className = RepositoryId.cache.getId(repId).getClassName();
            if (className == null) // no repId or unrecognized repId
                throw omgWrapper.unableLocateValueFactory(
                    CompletionStatus.COMPLETED_MAYBE);
        }

        // if earlier search found a non-default factory, or the same default
        // factory that loadClassForClass would return, bale out now...
        if (factory != null &&
            (!factory.getClass().getName().equals(className+"DefaultFactory") ||
             (clazz == null && codebase == null)))
            return factory;

        try {
            ClassLoader clazzLoader =
                (clazz == null ? null : clazz.getClassLoader());
            Class factoryClass =
                loadClassForClass(className+"DefaultFactory", codebase,
                clazzLoader, clazz, clazzLoader);
            return (ValueFactory)factoryClass.newInstance();

        } catch (ClassNotFoundException cnfe) {
            throw omgWrapper.unableLocateValueFactory(
                CompletionStatus.COMPLETED_MAYBE, cnfe);
        } catch (IllegalAccessException iae) {
            throw omgWrapper.unableLocateValueFactory(
                CompletionStatus.COMPLETED_MAYBE, iae);
        } catch (InstantiationException ie) {
            throw omgWrapper.unableLocateValueFactory(
                CompletionStatus.COMPLETED_MAYBE, ie);
        } catch (ClassCastException cce) {
            throw omgWrapper.unableLocateValueFactory(
                CompletionStatus.COMPLETED_MAYBE, cce);
        }
    }

    /*
     * Load an RMI-IIOP Stub given a Tie.
     * @param tie the tie.
     * @param stubClass the stub class. May be null.
     * @param remoteCodebase the codebase to use. May be null.
     * @param onlyMostDerived if true, will fail if cannot load a stub for the
     * first repID in the tie. If false, will walk all repIDs.
     * @return the stub or null if not found.
     */

    public static Remote loadStub(Tie tie,
                                  PresentationManager.StubFactory stubFactory,
                                  String remoteCodebase,
                                  boolean onlyMostDerived)
    {
        StubEntry entry = null;

        // Do we already have it cached?
        synchronized (tieToStubCache) {
            Object cached = tieToStubCache.get(tie);
            if (cached == null) {
                // No, so go try to load it...
                entry = loadStubAndUpdateCache(
                        tie, stubFactory, remoteCodebase, onlyMostDerived);
            } else {
                // Yes, is it a stub?  If not, it was a miss last
                // time, so return null again...
                if (cached != CACHE_MISS) {
                    // It's a stub.
                    entry = (StubEntry) cached;

                    // Does the cached stub meet the requirements
                    // of the caller? If the caller does not require
                    // the most derived stub and does not require
                    // a specific stub type, we don't have to check
                    // any further because the cached type is good
                    // enough...
                    if (!entry.mostDerived && onlyMostDerived) {
                        // We must reload because we do not have
                        // the most derived cached already...
                        // The stubFactory arg must be null here
                        // to force onlyMostDerived=true to work
                        // correctly.
                        entry = loadStubAndUpdateCache(tie,null,
                            remoteCodebase,true);
                    } else if (stubFactory != null &&
                        !StubAdapter.getTypeIds(entry.stub)[0].equals(
                            stubFactory.getTypeIds()[0]) )
                    {
                        // We do not have exactly the right stub. First, try to
                        // upgrade the cached stub by forcing it to the most
                        // derived stub...
                        entry = loadStubAndUpdateCache(tie,null,
                            remoteCodebase,true);

                        // If that failed, try again with the exact type
                        // we need...
                        if (entry == null) {
                            entry = loadStubAndUpdateCache(tie,stubFactory,
                                    remoteCodebase,onlyMostDerived);
                        }
                    } else {
                        // Use the cached stub. Is the delegate set?
                        try {
                            Delegate stubDel = StubAdapter.getDelegate(
                                entry.stub ) ;
                        } catch (Exception e2) {
                            // No, so set it if we can...
                            try {
                                Delegate del = StubAdapter.getDelegate(
                                    tie ) ;
                                StubAdapter.setDelegate( entry.stub,
                                    del ) ;
                            } catch (Exception e) {}
                        }
                    }
                }
            }
        }

        if (entry != null) {
            return (Remote)entry.stub;
        } else {
            return null;
        }
    }

    /*
     * Load an RMI-IIOP Stub given a Tie, but do not look in the cache.
     * This method must be called with the lock held for tieToStubCache.
     * @param tie the tie.
     * @param stubFactory the stub factory. May be null.
     * @param remoteCodebase the codebase to use. May be null.
     * @param onlyMostDerived if true, will fail if cannot load a stub for the
     * first repID in the tie. If false, will walk all repIDs.
     * @return the StubEntry or null if not found.
     */
    private static StubEntry loadStubAndUpdateCache (
        Tie tie, PresentationManager.StubFactory  stubFactory,
        String remoteCodebase, boolean onlyMostDerived)
    {
        org.omg.CORBA.Object stub = null;
        StubEntry entry = null;
        boolean tieIsStub = StubAdapter.isStub( tie ) ;

        if (stubFactory != null) {
            try {
                stub = stubFactory.makeStub();
            } catch (Throwable e) {
                wrapper.stubFactoryCouldNotMakeStub( e ) ;
                if (e instanceof ThreadDeath) {
                    throw (ThreadDeath) e;
                }
            }
        } else {
            String[] ids = null;
            if (tieIsStub) {
                ids = StubAdapter.getTypeIds( tie ) ;
            } else {
                // This will throw an exception if the tie
                // is not a Servant.  XXX Handle this better?
                ids = ((org.omg.PortableServer.Servant)tie).
                      _all_interfaces( null, null );
            }

            if (remoteCodebase == null) {
                remoteCodebase = Util.getCodebase(tie.getClass());
            }

            if (ids.length == 0) {
                stub = new org.omg.stub.java.rmi._Remote_Stub();
            } else {
                // Now walk all the RepIDs till we find a stub or fail...
                for (int i = 0; i < ids.length; i++) {
                    if (ids[i].length() == 0) {
                        stub = new org.omg.stub.java.rmi._Remote_Stub();
                        break;
                    }

                    try {
                        PresentationManager.StubFactoryFactory stubFactoryFactory =
                            com.sun.corba.se.spi.orb.ORB.getStubFactoryFactory();
                        RepositoryId rid = RepositoryId.cache.getId( ids[i] ) ;
                        String className = rid.getClassName() ;
                        boolean isIDLInterface = rid.isIDLType() ;
                        stubFactory = stubFactoryFactory.createStubFactory(
                            className, isIDLInterface, remoteCodebase, null,
                            tie.getClass().getClassLoader() ) ;
                        stub = stubFactory.makeStub();
                        break;
                    } catch (Exception e) {
                        wrapper.errorInMakeStubFromRepositoryId( e ) ;
                    }

                    if (onlyMostDerived)
                        break;
                }
            }
        }

        if (stub == null) {
            // Stub == null, so cache the miss...
            tieToStubCache.put(tie,CACHE_MISS);
        } else {
            if (tieIsStub) {
                try {
                    Delegate del = StubAdapter.getDelegate( tie ) ;
                    StubAdapter.setDelegate( stub, del ) ;
                } catch( Exception e1 ) {
                    // The tie does not have a delegate set, so stash
                    // this tie away using the stub as a key so that
                    // later, when the stub is connected, we can find
                    // and connect the tie as well...

                    synchronized (stubToTieCache) {
                        stubToTieCache.put(stub,tie);
                    }
                }
            } else {
                // Tie extends Servant
                try {
                    Delegate delegate = StubAdapter.getDelegate( tie ) ;
                    StubAdapter.setDelegate( stub, delegate ) ;
                } catch( org.omg.CORBA.BAD_INV_ORDER bad) {
                    synchronized (stubToTieCache) {
                        stubToTieCache.put(stub,tie);
                    }
                } catch( Exception e ) {
                    // Exception is caught because of any of the
                    // following reasons
                    // 1) POA is not associated with the TIE
                    // 2) POA Policies for the tie-associated POA
                    //    does not support _this_object() call.
                    throw wrapper.noPoa( e ) ;
                }
            }
            // Update the cache...
            entry = new StubEntry(stub,onlyMostDerived);
            tieToStubCache.put(tie,entry);
        }

        return entry;
    }

    /*
     * If we loadStub(Tie,...) stashed away a tie which was
     * not connected, remove it from the cache and return
     * it.
     */
    public static Tie getAndForgetTie (org.omg.CORBA.Object stub) {
        synchronized (stubToTieCache) {
            return (Tie) stubToTieCache.remove(stub);
        }
    }

    /*
     * Remove any cached Stub for the given tie.
     */
    public static void purgeStubForTie (Tie tie) {
        StubEntry entry;
        synchronized (tieToStubCache) {
            entry = (StubEntry)tieToStubCache.remove(tie);
        }
        if (entry != null) {
            synchronized (stubToTieCache) {
                stubToTieCache.remove(entry.stub);
            }
        }
    }

    /*
     * Remove cached tie/servant pair.
     */
    public static void purgeTieAndServant (Tie tie) {
        synchronized (tieCache) {
            Object target = tie.getTarget();
            if (target != null)
                tieCache.remove(target);
        }
    }

    /*
     * Convert a RepId to a stubName...
     */
    public static String stubNameFromRepID (String repID) {

        // Convert the typeid to a RepositoryId instance, get
        // the className and mangle it as needed...

        RepositoryId id = RepositoryId.cache.getId(repID);
        String className = id.getClassName();

        if (id.isIDLType()) {
            className = idlStubName(className);
        } else {
            className = stubName(className);
        }
        return className;
    }


    /*
     * Load an RMI-IIOP Stub.  This is used in PortableRemoteObject.narrow.
     */
    public static Remote loadStub (org.omg.CORBA.Object narrowFrom,
                                   Class narrowTo)
    {
        Remote result = null;

        try {
            // Get the codebase from the delegate to use when loading
            // the new stub, if possible...
            String codebase = null;
            try {
                // We can't assume that narrowFrom is a CORBA_2_3 stub, yet
                // it may have a 2_3 Delegate that provides a codebase.  Swallow
                // the ClassCastException otherwise.
                Delegate delegate = StubAdapter.getDelegate( narrowFrom ) ;
                codebase = ((org.omg.CORBA_2_3.portable.Delegate)delegate).
                    get_codebase(narrowFrom);

            } catch (ClassCastException e) {
                wrapper.classCastExceptionInLoadStub( e ) ;
            }

            PresentationManager.StubFactoryFactory sff =
                com.sun.corba.se.spi.orb.ORB.getStubFactoryFactory() ;
            PresentationManager.StubFactory sf = sff.createStubFactory(
                narrowTo.getName(), false, codebase, narrowTo,
                narrowTo.getClassLoader() ) ;
            result = (Remote)sf.makeStub() ;
            StubAdapter.setDelegate( result,
                StubAdapter.getDelegate( narrowFrom ) ) ;
        } catch (Exception err) {
            wrapper.exceptionInLoadStub( err ) ;
        }

        return result;
    }

    /*
     * Load an RMI-IIOP Stub class.  This is used in the
     * StaticStubFactoryFactory code.
     */
    public static Class loadStubClass(String repID,
                                      String remoteCodebase,
                                      Class expectedType)
        throws ClassNotFoundException
    {
        // Get the repID and check for "" special case.
        // We should never be called with it (See CDRInputStream
        // and the loadStub() method)...

        if (repID.length() == 0) {
            throw new ClassNotFoundException();
        }

        // Get the stubname from the repID and load
        // the class. If we have a valid 'sender', fall
        // back to using its codebase if we need to...
        String className = Utility.stubNameFromRepID(repID);
        ClassLoader expectedTypeClassLoader = (expectedType == null ? null :
            expectedType.getClassLoader());

        try {
              return loadClassOfType(className,
                                       remoteCodebase,
                                       expectedTypeClassLoader,
                                       expectedType,
                                       expectedTypeClassLoader);
        } catch (ClassNotFoundException e) {
            return loadClassOfType(PackagePrefixChecker.packagePrefix() + className,
                                   remoteCodebase,
                                   expectedTypeClassLoader,
                                   expectedType,
                                   expectedTypeClassLoader);
        }
    }

    /**
     * Create an RMI stub name.
     */
    public static String stubName (String className)
    {
        return stubName( className, false ) ;
    }

    public static String dynamicStubName( String className )
    {
        return stubName( className, true ) ;
    }

    private static String stubName( String className,
        boolean isDynamic )
    {
        String name = stubNameForCompiler( className, isDynamic ) ;
        if (PackagePrefixChecker.hasOffendingPrefix( name ))
            name = PackagePrefixChecker.packagePrefix() + name ;
        return name ;
    }

    public static String stubNameForCompiler (String className)
    {
        return stubNameForCompiler( className, false ) ;
    }

    private static String stubNameForCompiler( String className,
        boolean isDynamic )
    {
        int index = className.indexOf('$');
        if (index < 0) {
            index = className.lastIndexOf('.');
        }

        String suffix = isDynamic ? DYNAMIC_STUB_SUFFIX :
            RMI_STUB_SUFFIX ;

        if (index > 0) {
            return className.substring(0,index+1) + STUB_PREFIX +
                className.substring(index+1) + suffix;
        } else {
            return STUB_PREFIX + className + suffix;
        }
    }

    /**
     * Create an RMI tie name.
     */
    public static String tieName (String className)
    {
        return
            PackagePrefixChecker.hasOffendingPrefix(tieNameForCompiler(className)) ?
            PackagePrefixChecker.packagePrefix() + tieNameForCompiler(className) :
            tieNameForCompiler(className);
    }

    public static String tieNameForCompiler (String className)
    {
        int index = className.indexOf('$');
        if (index < 0) {
            index = className.lastIndexOf('.');
        }
        if (index > 0) {
            return className.substring(0,index+1) +
                STUB_PREFIX +
                className.substring(index+1) +
                TIE_SUFIX;
        } else {
            return STUB_PREFIX +
                className +
                TIE_SUFIX;
        }
    }

    /**
     * Throws the CORBA equivalent of a java.io.NotSerializableException
     */
    public static void throwNotSerializableForCorba(String className) {
        throw omgWrapper.notSerializable( CompletionStatus.COMPLETED_MAYBE,
            className ) ;
    }

    /**
     * Create an IDL stub name.
     */
    public static String idlStubName(String className)
    {
        String result = null;
        int index = className.lastIndexOf('.');
        if (index > 0) {
            result = className.substring(0,index+1) +
                STUB_PREFIX +
                className.substring(index+1) +
                IDL_STUB_SUFFIX;
        } else {
            result = STUB_PREFIX +
                className +
                IDL_STUB_SUFFIX;
        }
        return result;
    }

    public static void printStackTrace()
    {
        Throwable thr = new Throwable( "Printing stack trace:" ) ;
        thr.fillInStackTrace() ;
        thr.printStackTrace() ;
    }

    /**
     * Read an object reference from the input stream and narrow
     * it to the desired type.
     * @param in the stream to read from.
     * @throws ClassCastException if narrowFrom cannot be cast to narrowTo.
     */
    public static Object readObjectAndNarrow(InputStream in,
                                             Class narrowTo)
        throws ClassCastException
    {
        Object result = in.read_Object();
        if (result != null)
            return PortableRemoteObject.narrow(result, narrowTo);
        else
            return null;
    }

    /**
     * Read an abstract interface type from the input stream and narrow
     * it to the desired type.
     * @param in the stream to read from.
     * @throws ClassCastException if narrowFrom cannot be cast to narrowTo.
     */
    public static Object readAbstractAndNarrow(
        org.omg.CORBA_2_3.portable.InputStream in, Class narrowTo)
        throws ClassCastException
    {
        Object result = in.read_abstract_interface();
        if (result != null)
            return PortableRemoteObject.narrow(result, narrowTo);
        else
            return null;
    }


    /** Converts an Ascii Character into Hexadecimal digit
     */
    static int hexOf( char x )
    {
        int val;

        val = x - '0';
        if (val >=0 && val <= 9)
            return val;

        val = (x - 'a') + 10;
        if (val >= 10 && val <= 15)
            return val;

        val = (x - 'A') + 10;
        if (val >= 10 && val <= 15)
            return val;

        throw wrapper.badHexDigit() ;
    }
}

class StubEntry {
    org.omg.CORBA.Object stub;
    boolean mostDerived;

    StubEntry(org.omg.CORBA.Object stub, boolean mostDerived) {
        this.stub = stub;
        this.mostDerived = mostDerived;
    }
}

Other Java examples (source code examples)

Here is a short list of links related to this Java Utility.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.