public ExtensionClassLoader() 
{

}

 public ExtensionClassLoader(ClassLoader parent) 
{
        super(parent);
}

 public  void add(String file) 
{
        add(new File(file));
}

 public  void add(File[] files) 
{
        for (int i = 0; i <  files.length; i++) {
            add(files[i]);
        }
}

 public  void add(File file) 
{
        if (!file.exists()) {
            throw new IllegalArgumentException("Classpath " +
                file.getAbsolutePath() + " doesn't exist!");
        } else if (!file.canRead()) {
            throw new IllegalArgumentException(
                "Don't have read access for file " + file.getAbsolutePath());
        }
        // Check that it is a directory or jar file
        if (!(file.isDirectory() || isJarArchive(file))) {
            throw new IllegalArgumentException(file.getAbsolutePath() +
                " is not a directory or jar file" +
                " or if it's a jar file then it is corrupted.");
        }
        log.info("Adding " + file.getAbsolutePath() +
            " to the extension classpath");
        this.classpath.add(file);
}

 public Class findClass(String name) throws ClassNotFoundException 
{
        // The class object that will be returned.
        Class c = null;
        // Use the cached value, if this class is already loaded into
        // this classloader.
        ClassCacheEntry entry = (ClassCacheEntry) cache.get(name);
        if (entry != null) {
            if (log.isDebugEnabled()) {
                log.debug("Loaded " + name + " from cache");
            }
            // Class found in our cache
            c = entry.loadedClass;
            resolveClass(c);
            return c;
        }
        // Try to load it from each classpath
        Iterator it = classpath.iterator();
        // Cache entry.
        ClassCacheEntry classCache = new ClassCacheEntry();
        while (it.hasNext()) {
            byte[] classData;
            File file = (File) it.next();
            try {
                if (file.isDirectory()) {
                    classData = loadClassFromDirectory(file, name, classCache);
                } else {
                    classData = loadClassFromZipfile(file, name, classCache);
                }
            } catch (IOException ioe) {
                // Error while reading in data, consider it as not found
                classData = null;
            }
            if (classData != null) {
                // Does the package exist?
                String packageName = "";
                if (name.lastIndexOf(".")  > 0) {
                    packageName = name.substring(0, name.lastIndexOf("."));
                }
                if (!packageName.equals("") &&
                        !packages.containsKey(packageName)) {
                    packages.put(packageName,
                        definePackage(packageName, "", "", "", "", "", "", null));
                    // Define the class
                }
                c = defineClass(name, classData, 0, classData.length);
                // Cache the result;
                classCache.loadedClass = c;
                // Origin is set by the specific loader
                classCache.lastModified = classCache.origin.lastModified();
                cache.put(name, classCache);
                resolveClass(c);
                if (log.isDebugEnabled()) {
                    log.debug("Loaded " + name +
                        " adding to cache and returning");
                }
                return c;
            }
        }
        // If not found in any classpath
        throw new ClassNotFoundException(name);
}

 protected URL findResource(String name) 
{
        // The class object that will be returned.
        URL url = null;
        // Try to load it from each classpath
        Iterator it = classpath.iterator();
        while (it.hasNext()) {
            byte[] classData;
            File file = (File) it.next();
            if (file.isDirectory()) {
                url = findResourceInDirectory(file, name);
            } else {
                url = findResourceInZipfile(file, name);
            }
            if (url != null) {
                if (log.isDebugEnabled()) {
                    log.debug("Found resource " + url.toExternalForm());
                }
                return url;
            }
            if (log.isDebugEnabled()) {
                log.debug("Could not find resource " + name);
            }
        }
        return null;
}

 protected Enumeration findResources(String name) 
{
        HashSet resources = new HashSet();
        URL url = null;
        // Try to load it from each classpath
        Iterator it = classpath.iterator();
        while (it.hasNext()) {
            byte[] classData;
            File file = (File) it.next();
            if (file.isDirectory()) {
                url = findResourceInDirectory(file, name);
            } else {
                url = findResourceInZipfile(file, name);
            }
            if (url != null) {
                if (log.isDebugEnabled()) {
                    log.debug("Found resource " + url.toExternalForm());
                }
                resources.add(url);
            }
        }
        return new ResourceEnumeration(resources);
}

 public URL getResource(String name,
    File location) 
{
        if (isJarArchive(location)) {
            return findResourceInZipfile(location, name);
        } else {
            return findResourceInDirectory(location, name);
        }
}

 public boolean isJarArchive(File file) 
{
        boolean isArchive = true;
        ZipFile zipFile = null;
        try {
            zipFile = new ZipFile(file);
        } catch (ZipException zipCurrupted) {
            isArchive = false;
        } catch (IOException anyIOError) {
            isArchive = false;
        } finally {
            if (zipFile != null) {
                try {
                    zipFile.close();
                } catch (IOException ignored) {
                }
            }
        }
        return isArchive;
}

 public byte[] loadClassData(String name) throws ClassNotFoundException 
{
        // Try to load it from each classpath
        Iterator it = classpath.iterator();
        // Cache entry.
        ClassCacheEntry classCache = new ClassCacheEntry();
        while (it.hasNext()) {
            byte[] classData;
            File file = (File) it.next();
            try {
                if (file.isDirectory()) {
                    classData = loadClassFromDirectory(file, name, null);
                } else {
                    classData = loadClassFromZipfile(file, name, null);
                }
            } catch (IOException ioe) {
                // Error while reading in data, consider it as not found
                classData = null;
            }
            if (classData != null) {
                return classData;
            }
        }
        // If not found in any classpath
        throw new ClassNotFoundException(name);
}