/*
* 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 org.jboss.com.sun.corba.se.impl.util;
import java.rmi.NoSuchObjectException;
import java.rmi.Remote;
import java.rmi.RemoteException;
import java.security.AccessController;
import java.security.PrivilegedAction;
import javax.rmi.PortableRemoteObject;
import javax.rmi.CORBA.Tie;
import javax.rmi.CORBA.Util;
import org.jboss.com.sun.corba.se.impl.logging.OMGSystemException;
import org.jboss.com.sun.corba.se.impl.logging.UtilSystemException;
import org.jboss.com.sun.corba.se.spi.logging.CORBALogDomains;
import org.jboss.com.sun.corba.se.spi.presentation.rmi.PresentationManager;
import org.jboss.com.sun.corba.se.spi.presentation.rmi.StubAdapter;
import org.omg.CORBA.BAD_OPERATION;
import org.omg.CORBA.CompletionStatus;
import org.omg.CORBA.ORB;
import org.omg.CORBA.SystemException;
import org.omg.CORBA.portable.BoxedValueHelper;
import org.omg.CORBA.portable.Delegate;
import org.omg.CORBA.portable.InputStream;
import org.omg.CORBA.portable.ValueFactory;
/**
* 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 org.jboss.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
{
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 = org.jboss.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.getTarget().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 Object loadStub(org.omg.CORBA.Object narrowFrom, final Class<?> narrowTo)
{
Object 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)
{
throw wrapper.classCastExceptionInLoadStub(e);
}
ClassLoader classLoader = AccessController.doPrivileged(new PrivilegedAction<ClassLoader>() {
public ClassLoader run() {
return narrowTo.getClassLoader();
}
});
PresentationManager.StubFactoryFactory sff = org.jboss.com.sun.corba.se.spi.orb.ORB.getStubFactoryFactory();
PresentationManager.StubFactory sf = sff.createStubFactory(narrowTo.getName(), false, codebase, narrowTo,
classLoader);
result = sf.makeStub();
StubAdapter.setDelegate(result, StubAdapter.getDelegate(narrowFrom));
}
catch (Exception err)
{
throw 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;
}
}