}        return null;    }    /**     * Returns an Enumeration of URLs representing all of the resources     * on the search path having the specified name.     *     * @param name the resource name     *     * @return an <code>Enumeration</code> of <code>URL</code>s. This is an     *      empty enumeration if no resources are found by this class loader     *      or if this class loader has already been destroyed.     */    public Enumeration findResources(String name) {        if (isDestroyed()) {            log.warn("Destroyed class loader cannot find resources");            return new Enumeration() {                public boolean hasMoreElements() {                    return false;                }                public Object nextElement() {                    throw new NoSuchElementException("No Entries");                }            };        }        log.debug("findResources: Try to find resources for {}", name);        List list = new LinkedList();        for (int i=0; i < repository.length; i++) {            final ClassPathEntry cp = repository[i];            log.debug("findResources: Trying {}", cp);            ClassLoaderResource res = cp.getResource(name);            if (res != null) {                log.debug("findResources: Adding resource from {}, created {}",                    res, new Date(res.getLastModificationTime()));                URL url = res.getURL();                if (url != null) {                    list.add(url);                }            }        }        // return the enumeration on the list        return Collections.enumeration(list);    }    /**     * Returns the search path of URLs for loading classes and resources.     * This includes the original list of URLs specified to the constructor,     * along with any URLs subsequently appended by the {@link #addURL(URL)}     * and {@link #addHandle(String)} methods.     *     * @return the search path of URLs for loading classes and resources. The     *      list is empty, if this class loader has already been destroyed.     */    public URL[] getURLs() {        if (isDestroyed()) {            log.warn("Destroyed class loader has no URLs any more");            return new URL[0];        }        List urls = new ArrayList();        for (int i=0; i < repository.length; i++) {            URL url = repository[i].toURL();            if (url != null) {                urls.add(url);            }        }        return (URL[]) urls.toArray(new URL[urls.size()]);    }    /**     * Appends the specified URL to the list of URLs to search for     * classes and resources. Only Repository URLs with the protocol set to     * <code>JCR</code> are considered for addition. The system will find out     * whether the URL points to a directory or a jar archive.     * <p>     * URLs added using this method will be preserved through reconfiguration     * and reinstantiation.     * <p>     * If this class loader has already been destroyed this method has no     * effect.     *     * @param url the <code>JCR</code> URL to be added to the search path of     *      URLs.     */    protected void addURL(URL url) {        if (isDestroyed()) {            log.warn("Cannot add URL to destroyed class loader");        } else if (checkURL(url)) {            // Repository URL            log.debug("addURL: Adding URL {}", url);            try {                JCRURLConnection conn = (JCRURLConnection) url.openConnection();                ClassPathEntry cp = ClassPathEntry.getInstance(                    conn.getSession(), conn.getPath());                addClassPathEntry(cp);            } catch (IOException ioe) {                log.warn("addURL: Cannot add URL " + url, ioe);            }        } else {            log.warn("addURL: {} is not a Repository URL, ignored", url);        }    }    /**     * Appends the specified path to the list of handles to search for classes     * and resources. The system will find out whether the path points to a     * directory or a JAR or ZIP archive. The path is added as is, provided it     * is valid to be used in the class path and therefore must not contain any     * globbing characters.     * <p>     * If this class loader has already been destroyed, this method has no     * effect.     *     * @param path The path to be added to the search path.     */    public void addHandle(String path) {        if (isDestroyed()) {            log.warn("Cannot add handle to destroyed class loader");            return;        }        log.debug("addURL: Adding Handle {}", path);        ClassPathEntry cp = ClassPathEntry.getInstance(session, path);        if (cp != null) {            addClassPathEntry(cp);        } else {            log.debug("addHandle: Cannot get a ClassPathEntry for {}", path);        }    }    //---------- Property access ----------------------------------------------    /**     * Sets the {@link PatternPath} list to be used as the initial search     * path of this class loader. This new list replaces the path pattern list     * set in the constructor or in a previous call to this method.     * <p>     * After setting the list, this class loader's class path has to be rebuilt     * by calling the {@link #buildRepository()} method.     *     * @param handles The {@link PatternPath} to set on this class loader.     */    /* package */ void setHandles(PatternPath handles) {        this.handles = handles;    }    /**     * Returns the current {@link PatternPath} from which the search path     * of this class loader is configured.     */    /* package */ PatternPath getHandles() {        return handles;    }    /**     * Returns the named {@link ClassLoaderResource} if it is contained in the     * cache. If the resource does not exist in the cache or has not been found     * in the class path at an earlier point in time, <code>null</code> is     * returned.     *     * @param name The name of the resource to retrieve from the cache.     *     * @return The named <code>ClassLoaderResource</code> or <code>null</code>     *      if not loaded.     *     * @throws NullPointerException If this class loader has already been     *      destroyed.     */    /* package */ ClassLoaderResource getCachedResource(String name) {        Object res = cache.get(name);        if (res == null || res == NOT_FOUND_RESOURCE) {            log.debug("Resource {} not cached", name);            return null;        }        return (ClassLoaderResource) res;    }    /**     * Returns an <code>Iterator</code> on all resources in the cache. This     * iterator may also contain {@link #NOT_FOUND_RESOURCE sentinel} entries     * for resources, which failed to load. Callers of this method should take     * care to filter out such resources before acting on it.     *     * @throws NullPointerException If this class loader has already been     *      destroyed.     */    /* package */ Iterator getCachedResources() {        return cache.values().iterator();    }    /**     * Removes all entries from the cache of loaded resources, which mark     * resources, which have not been found as of yet.     *     * @throws NullPointerException If this class loader has already been     *      destroyed.     */    protected void cleanCache() {        for (Iterator ci=cache.values().iterator(); ci.hasNext(); ) {            if (ci.next() == NOT_FOUND_RESOURCE) {                ci.remove();            }        }    }    /**     * Returns <code>true</code>, if the cache is not empty. If the     * {@link #cleanCache()} method is not called before calling this method, a     * false positive result may be returned.     *     * @throws NullPointerException If this class loader has already been     *      destroyed.     */    protected boolean hasLoadedResources() {        return cache.isEmpty();    }    /**     * Returns the session used by this class loader to access the repository.     * If this class loader has already been destroyed, this <code>null</code>     * is returned.     */    protected Session getSession() {        return session;    }    /**     * Sets the current active class path to the list of class path entries.     */    protected void setRepository(ClassPathEntry[] classPath) {        this.repository = classPath;    }    /**     * Returns the current active class path entries list or <code>null</code>     * if this class loader has already been destroyed.     */    protected ClassPathEntry[] getRepository() {        return repository;    }    /**     * Adds the class path entry to the current class path list. If the class     * loader has already been destroyed, this method creates a single entry     * class path list with the new class path entry.     */    protected void addClassPathEntry(ClassPathEntry cpe) {        log.debug("addHandle: Adding path {}", cpe.getPath());        // append the entry to the current class path        ClassPathEntry[] oldClassPath = getRepository();        ClassPathEntry[] newClassPath = addClassPathEntry(oldClassPath, cpe);        setRepository(newClassPath);    }    /**     * Helper method for class path handling to a new entry to an existing     * list and return the new list.     * <p>     * If <code>list</code> is <code>null</code> a new array is returned with     * a single element <code>newEntry</code>. Otherwise the array returned     * contains all elements of <code>list</code> and <code>newEntry</code>     * at the last position.     *     * @param list The array of class path entries, to which a new entry is     *      to be appended. This may be <code>null</code>.     * @param newEntry The new entry to append to the class path list.     *     * @return The extended class path list.     */    protected ClassPathEntry[] addClassPathEntry(ClassPathEntry[] list,            ClassPathEntry newEntry) {        // quickly define single entry array for the first entry        if (list == null) {            return new ClassPathEntry[]{ newEntry };        }