Java Code Examples for javax.rmi.CORBA.Util#loadClass()

public PresentationManager.StubFactory createStubFactory(
    String className, boolean isIDLStub, String remoteCodeBase,
    Class expectedClass, ClassLoader classLoader)
{
    Class cls = null ;

    try {
        cls = Util.loadClass( className, remoteCodeBase, classLoader ) ;
    } catch (ClassNotFoundException exc) {
        throw wrapper.classNotFound3(
            CompletionStatus.COMPLETED_MAYBE, exc, className ) ;
    }

    PresentationManager pm = ORB.getPresentationManager() ;

    if (IDLEntity.class.isAssignableFrom( cls ) &&
        !Remote.class.isAssignableFrom( cls )) {
        // IDL stubs must always use static factories.
        PresentationManager.StubFactoryFactory sff =
            pm.getStubFactoryFactory( false ) ;
        PresentationManager.StubFactory sf =
            sff.createStubFactory( className, true, remoteCodeBase,
                expectedClass, classLoader ) ;
        return sf ;
    } else {
        PresentationManager.ClassData classData = pm.getClassData( cls ) ;
        return makeDynamicStubFactory( pm, classData, classLoader ) ;
    }
}
 

public PresentationManager.StubFactory createStubFactory(
    String className, boolean isIDLStub, String remoteCodeBase,
    Class expectedClass, ClassLoader classLoader)
{
    Class cls = null ;

    try {
        cls = Util.loadClass( className, remoteCodeBase, classLoader ) ;
    } catch (ClassNotFoundException exc) {
        throw wrapper.classNotFound3(
            CompletionStatus.COMPLETED_MAYBE, exc, className ) ;
    }

    PresentationManager pm = ORB.getPresentationManager() ;

    if (IDLEntity.class.isAssignableFrom( cls ) &&
        !Remote.class.isAssignableFrom( cls )) {
        // IDL stubs must always use static factories.
        PresentationManager.StubFactoryFactory sff =
            pm.getStubFactoryFactory( false ) ;
        PresentationManager.StubFactory sf =
            sff.createStubFactory( className, true, remoteCodeBase,
                expectedClass, classLoader ) ;
        return sf ;
    } else {
        PresentationManager.ClassData classData = pm.getClassData( cls ) ;
        return makeDynamicStubFactory( pm, classData, classLoader ) ;
    }
}
 

public final Class getClassFromType()
    throws ClassNotFoundException {
    if (clazz != null)
        return clazz;

    Class specialCase = (Class)kSpecialCasesClasses.get(getClassName());

    if (specialCase != null){
        clazz = specialCase;
        return specialCase;
    }
    else
        {
            try{
                return Util.loadClass(getClassName(), null, null);
            }
            catch(ClassNotFoundException cnfe){
                if (defaultServerURL != null) {
                    try{
                        return getClassFromType(defaultServerURL);
                    }
                    catch(MalformedURLException mue){
                        throw cnfe;
                    }
                }
                else throw cnfe;
            }
        }

}
 

public PresentationManager.StubFactory createStubFactory(
    String className, boolean isIDLStub, String remoteCodeBase,
    Class expectedClass, ClassLoader classLoader)
{
    Class cls = null ;

    try {
        cls = Util.loadClass( className, remoteCodeBase, classLoader ) ;
    } catch (ClassNotFoundException exc) {
        throw wrapper.classNotFound3(
            CompletionStatus.COMPLETED_MAYBE, exc, className ) ;
    }

    PresentationManager pm = ORB.getPresentationManager() ;

    if (IDLEntity.class.isAssignableFrom( cls ) &&
        !Remote.class.isAssignableFrom( cls )) {
        // IDL stubs must always use static factories.
        PresentationManager.StubFactoryFactory sff =
            pm.getStubFactoryFactory( false ) ;
        PresentationManager.StubFactory sf =
            sff.createStubFactory( className, true, remoteCodeBase,
                expectedClass, classLoader ) ;
        return sf ;
    } else {
        PresentationManager.ClassData classData = pm.getClassData( cls ) ;
        return makeDynamicStubFactory( pm, classData, classLoader ) ;
    }
}
 

public final Class getClassFromType()
    throws ClassNotFoundException {
    if (clazz != null)
        return clazz;

    Class specialCase = (Class)kSpecialCasesClasses.get(getClassName());

    if (specialCase != null){
        clazz = specialCase;
        return specialCase;
    }
    else
        {
            try{
                return Util.loadClass(getClassName(), null, null);
            }
            catch(ClassNotFoundException cnfe){
                if (defaultServerURL != null) {
                    try{
                        return getClassFromType(defaultServerURL);
                    }
                    catch(MalformedURLException mue){
                        throw cnfe;
                    }
                }
                else throw cnfe;
            }
        }

}
 

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;
}
 

public PresentationManager.StubFactory createStubFactory(
    String className, boolean isIDLStub, String remoteCodeBase,
    Class expectedClass, ClassLoader classLoader)
{
    Class cls = null ;

    try {
        cls = Util.loadClass( className, remoteCodeBase, classLoader ) ;
    } catch (ClassNotFoundException exc) {
        throw wrapper.classNotFound3(
            CompletionStatus.COMPLETED_MAYBE, exc, className ) ;
    }

    PresentationManager pm = ORB.getPresentationManager() ;

    if (IDLEntity.class.isAssignableFrom( cls ) &&
        !Remote.class.isAssignableFrom( cls )) {
        // IDL stubs must always use static factories.
        PresentationManager.StubFactoryFactory sff =
            pm.getStubFactoryFactory( false ) ;
        PresentationManager.StubFactory sf =
            sff.createStubFactory( className, true, remoteCodeBase,
                expectedClass, classLoader ) ;
        return sf ;
    } else {
        PresentationManager.ClassData classData = pm.getClassData( cls ) ;
        return makeDynamicStubFactory( pm, classData, classLoader ) ;
    }
}
 

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;
}
 

public PresentationManager.StubFactory createStubFactory(
    String className, boolean isIDLStub, String remoteCodeBase,
    Class expectedClass, ClassLoader classLoader)
{
    Class cls = null ;

    try {
        cls = Util.loadClass( className, remoteCodeBase, classLoader ) ;
    } catch (ClassNotFoundException exc) {
        throw wrapper.classNotFound3(
            CompletionStatus.COMPLETED_MAYBE, exc, className ) ;
    }

    PresentationManager pm = ORB.getPresentationManager() ;

    if (IDLEntity.class.isAssignableFrom( cls ) &&
        !Remote.class.isAssignableFrom( cls )) {
        // IDL stubs must always use static factories.
        PresentationManager.StubFactoryFactory sff =
            pm.getStubFactoryFactory( false ) ;
        PresentationManager.StubFactory sf =
            sff.createStubFactory( className, true, remoteCodeBase,
                expectedClass, classLoader ) ;
        return sf ;
    } else {
        PresentationManager.ClassData classData = pm.getClassData( cls ) ;
        return makeDynamicStubFactory( pm, classData, classLoader ) ;
    }
}
 

public final Class getClassFromType()
    throws ClassNotFoundException {
    if (clazz != null)
        return clazz;

    Class specialCase = (Class)kSpecialCasesClasses.get(getClassName());

    if (specialCase != null){
        clazz = specialCase;
        return specialCase;
    }
    else
        {
            try{
                return Util.loadClass(getClassName(), null, null);
            }
            catch(ClassNotFoundException cnfe){
                if (defaultServerURL != null) {
                    try{
                        return getClassFromType(defaultServerURL);
                    }
                    catch(MalformedURLException mue){
                        throw cnfe;
                    }
                }
                else throw cnfe;
            }
        }

}
 

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;
}
 

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;
}
 

public PresentationManager.StubFactory createStubFactory(
    String className, boolean isIDLStub, String remoteCodeBase,
    Class expectedClass, ClassLoader classLoader)
{
    Class cls = null ;

    try {
        cls = Util.loadClass( className, remoteCodeBase, classLoader ) ;
    } catch (ClassNotFoundException exc) {
        throw wrapper.classNotFound3(
            CompletionStatus.COMPLETED_MAYBE, exc, className ) ;
    }

    PresentationManager pm = ORB.getPresentationManager() ;

    if (IDLEntity.class.isAssignableFrom( cls ) &&
        !Remote.class.isAssignableFrom( cls )) {
        // IDL stubs must always use static factories.
        PresentationManager.StubFactoryFactory sff =
            pm.getStubFactoryFactory( false ) ;
        PresentationManager.StubFactory sf =
            sff.createStubFactory( className, true, remoteCodeBase,
                expectedClass, classLoader ) ;
        return sf ;
    } else {
        PresentationManager.ClassData classData = pm.getClassData( cls ) ;
        return makeDynamicStubFactory( pm, classData, classLoader ) ;
    }
}
 

public PresentationManager.StubFactory createStubFactory(
    String className, boolean isIDLStub, String remoteCodeBase, Class
    expectedClass, ClassLoader classLoader)
{
    String stubName = null ;

    if (isIDLStub)
        stubName = Utility.idlStubName( className ) ;
    else
        stubName = Utility.stubNameForCompiler( className ) ;

    ClassLoader expectedTypeClassLoader =
        (expectedClass == null ? classLoader :
        expectedClass.getClassLoader());

    // The old code was optimized to try to guess which way to load classes
    // first.  The real stub class name could either be className or
    // "org.omg.stub." + className.  We will compute this as follows:
    // If stubName starts with a "forbidden" package, try the prefixed
    // version first, otherwise try the non-prefixed version first.
    // In any case, try both forms if necessary.

    String firstStubName = stubName ;
    String secondStubName = stubName ;

    if (PackagePrefixChecker.hasOffendingPrefix(stubName))
        firstStubName = PackagePrefixChecker.packagePrefix() + stubName ;
    else
        secondStubName = PackagePrefixChecker.packagePrefix() + stubName ;

    Class clz = null;

    try {
        clz = Util.loadClass( firstStubName, remoteCodeBase,
            expectedTypeClassLoader ) ;
    } catch (ClassNotFoundException e1) {
        // log only at FINE level
        wrapper.classNotFound1( CompletionStatus.COMPLETED_MAYBE,
            e1, firstStubName ) ;
        try {
            clz = Util.loadClass( secondStubName, remoteCodeBase,
                expectedTypeClassLoader ) ;
        } catch (ClassNotFoundException e2) {
            throw wrapper.classNotFound2(
                CompletionStatus.COMPLETED_MAYBE, e2, secondStubName ) ;
        }
    }

    // XXX 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 ((clz == null) ||
        ((expectedClass != null) && !expectedClass.isAssignableFrom(clz))) {
        try {
            ClassLoader cl = Thread.currentThread().getContextClassLoader();
            if (cl == null)
                cl = ClassLoader.getSystemClassLoader();

            clz = cl.loadClass(className);
        } catch (Exception exc) {
            // XXX make this a system exception
            IllegalStateException ise = new IllegalStateException(
                "Could not load class " + stubName ) ;
            ise.initCause( exc ) ;
            throw ise ;
        }
    }

    return new StubFactoryStaticImpl( clz ) ;
}
 

public final Class getClassFromType(String url)
    throws ClassNotFoundException, MalformedURLException {
    return Util.loadClass(getClassName(), url, null);
}
 

public PresentationManager.StubFactory createStubFactory(
    String className, boolean isIDLStub, String remoteCodeBase, Class
    expectedClass, ClassLoader classLoader)
{
    String stubName = null ;

    if (isIDLStub)
        stubName = Utility.idlStubName( className ) ;
    else
        stubName = Utility.stubNameForCompiler( className ) ;

    ClassLoader expectedTypeClassLoader =
        (expectedClass == null ? classLoader :
        expectedClass.getClassLoader());

    // The old code was optimized to try to guess which way to load classes
    // first.  The real stub class name could either be className or
    // "org.omg.stub." + className.  We will compute this as follows:
    // If stubName starts with a "forbidden" package, try the prefixed
    // version first, otherwise try the non-prefixed version first.
    // In any case, try both forms if necessary.

    String firstStubName = stubName ;
    String secondStubName = stubName ;

    if (PackagePrefixChecker.hasOffendingPrefix(stubName))
        firstStubName = PackagePrefixChecker.packagePrefix() + stubName ;
    else
        secondStubName = PackagePrefixChecker.packagePrefix() + stubName ;

    Class clz = null;

    try {
        clz = Util.loadClass( firstStubName, remoteCodeBase,
            expectedTypeClassLoader ) ;
    } catch (ClassNotFoundException e1) {
        // log only at FINE level
        wrapper.classNotFound1( CompletionStatus.COMPLETED_MAYBE,
            e1, firstStubName ) ;
        try {
            clz = Util.loadClass( secondStubName, remoteCodeBase,
                expectedTypeClassLoader ) ;
        } catch (ClassNotFoundException e2) {
            throw wrapper.classNotFound2(
                CompletionStatus.COMPLETED_MAYBE, e2, secondStubName ) ;
        }
    }

    // XXX 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 ((clz == null) ||
        ((expectedClass != null) && !expectedClass.isAssignableFrom(clz))) {
        try {
            ClassLoader cl = Thread.currentThread().getContextClassLoader();
            if (cl == null)
                cl = ClassLoader.getSystemClassLoader();

            clz = cl.loadClass(className);
        } catch (Exception exc) {
            // XXX make this a system exception
            IllegalStateException ise = new IllegalStateException(
                "Could not load class " + stubName ) ;
            ise.initCause( exc ) ;
            throw ise ;
        }
    }

    return new StubFactoryStaticImpl( clz ) ;
}
 

public final Class getClassFromType(String url)
    throws ClassNotFoundException, MalformedURLException {
    return Util.loadClass(getClassName(), url, null);
}
 

public PresentationManager.StubFactory createStubFactory(
    String className, boolean isIDLStub, String remoteCodeBase, Class
    expectedClass, ClassLoader classLoader)
{
    String stubName = null ;

    if (isIDLStub)
        stubName = Utility.idlStubName( className ) ;
    else
        stubName = Utility.stubNameForCompiler( className ) ;

    ClassLoader expectedTypeClassLoader =
        (expectedClass == null ? classLoader :
        expectedClass.getClassLoader());

    // The old code was optimized to try to guess which way to load classes
    // first.  The real stub class name could either be className or
    // "org.omg.stub." + className.  We will compute this as follows:
    // If stubName starts with a "forbidden" package, try the prefixed
    // version first, otherwise try the non-prefixed version first.
    // In any case, try both forms if necessary.

    String firstStubName = stubName ;
    String secondStubName = stubName ;

    if (PackagePrefixChecker.hasOffendingPrefix(stubName))
        firstStubName = PackagePrefixChecker.packagePrefix() + stubName ;
    else
        secondStubName = PackagePrefixChecker.packagePrefix() + stubName ;

    Class clz = null;

    try {
        clz = Util.loadClass( firstStubName, remoteCodeBase,
            expectedTypeClassLoader ) ;
    } catch (ClassNotFoundException e1) {
        // log only at FINE level
        wrapper.classNotFound1( CompletionStatus.COMPLETED_MAYBE,
            e1, firstStubName ) ;
        try {
            clz = Util.loadClass( secondStubName, remoteCodeBase,
                expectedTypeClassLoader ) ;
        } catch (ClassNotFoundException e2) {
            throw wrapper.classNotFound2(
                CompletionStatus.COMPLETED_MAYBE, e2, secondStubName ) ;
        }
    }

    // XXX 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 ((clz == null) ||
        ((expectedClass != null) && !expectedClass.isAssignableFrom(clz))) {
        try {
            ClassLoader cl = Thread.currentThread().getContextClassLoader();
            if (cl == null)
                cl = ClassLoader.getSystemClassLoader();

            clz = cl.loadClass(className);
        } catch (Exception exc) {
            // XXX make this a system exception
            IllegalStateException ise = new IllegalStateException(
                "Could not load class " + stubName ) ;
            ise.initCause( exc ) ;
            throw ise ;
        }
    }

    return new StubFactoryStaticImpl( clz ) ;
}
 

public PresentationManager.StubFactory createStubFactory(
    String className, boolean isIDLStub, String remoteCodeBase, Class
    expectedClass, ClassLoader classLoader)
{
    String stubName = null ;

    if (isIDLStub)
        stubName = Utility.idlStubName( className ) ;
    else
        stubName = Utility.stubNameForCompiler( className ) ;

    ClassLoader expectedTypeClassLoader =
        (expectedClass == null ? classLoader :
        expectedClass.getClassLoader());

    // The old code was optimized to try to guess which way to load classes
    // first.  The real stub class name could either be className or
    // "org.omg.stub." + className.  We will compute this as follows:
    // If stubName starts with a "forbidden" package, try the prefixed
    // version first, otherwise try the non-prefixed version first.
    // In any case, try both forms if necessary.

    String firstStubName = stubName ;
    String secondStubName = stubName ;

    if (PackagePrefixChecker.hasOffendingPrefix(stubName))
        firstStubName = PackagePrefixChecker.packagePrefix() + stubName ;
    else
        secondStubName = PackagePrefixChecker.packagePrefix() + stubName ;

    Class clz = null;

    try {
        clz = Util.loadClass( firstStubName, remoteCodeBase,
            expectedTypeClassLoader ) ;
    } catch (ClassNotFoundException e1) {
        // log only at FINE level
        wrapper.classNotFound1( CompletionStatus.COMPLETED_MAYBE,
            e1, firstStubName ) ;
        try {
            clz = Util.loadClass( secondStubName, remoteCodeBase,
                expectedTypeClassLoader ) ;
        } catch (ClassNotFoundException e2) {
            throw wrapper.classNotFound2(
                CompletionStatus.COMPLETED_MAYBE, e2, secondStubName ) ;
        }
    }

    // XXX 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 ((clz == null) ||
        ((expectedClass != null) && !expectedClass.isAssignableFrom(clz))) {
        try {
            ClassLoader cl = Thread.currentThread().getContextClassLoader();
            if (cl == null)
                cl = ClassLoader.getSystemClassLoader();

            clz = cl.loadClass(className);
        } catch (Exception exc) {
            // XXX make this a system exception
            IllegalStateException ise = new IllegalStateException(
                "Could not load class " + stubName ) ;
            ise.initCause( exc ) ;
            throw ise ;
        }
    }

    return new StubFactoryStaticImpl( clz ) ;
}
 

public final Class getClassFromType(String url)
    throws ClassNotFoundException, MalformedURLException {
    return Util.loadClass(getClassName(), url, null);
}