private void _setSpriteImages(ServletContext servletContext, Theme theme, String resourcePath) throws Exception { if (!resourcePath.startsWith(StringPool.SLASH)) { resourcePath = StringPool.SLASH.concat(resourcePath); } Set<String> resourcePaths = servletContext.getResourcePaths(resourcePath); if (resourcePaths == null) { return; } List<URL> imageURLs = new ArrayList<URL>(resourcePaths.size()); for (String curResourcePath : resourcePaths) { if (curResourcePath.endsWith(StringPool.SLASH)) { _setSpriteImages(servletContext, theme, curResourcePath); } else if (curResourcePath.endsWith(".png")) { URL imageURL = servletContext.getResource(curResourcePath); if (imageURL != null) { imageURLs.add(imageURL); } else { if (ServerDetector.isTomcat()) { if (_log.isInfoEnabled()) { _log.info(ServletContextUtil.LOG_INFO_SPRITES); } } else { _log.error("Real path for " + curResourcePath + " is null"); } } } } String spriteFileName = resourcePath.concat(PropsValues.SPRITE_FILE_NAME); String spritePropertiesFileName = resourcePath.concat(PropsValues.SPRITE_PROPERTIES_FILE_NAME); URL spritePropertiesRootURL = servletContext.getResource(StringPool.SLASH); Properties spriteProperties = SpriteProcessorUtil.generate( servletContext, imageURLs, spriteFileName, spritePropertiesFileName, spritePropertiesRootURL, 16, 16, 10240); if (spriteProperties == null) { return; } String contextPath = ContextPathUtil.getContextPath(servletContext); spriteFileName = contextPath.concat(SpriteProcessor.PATH).concat(spriteFileName); theme.setSpriteImages(spriteFileName, spriteProperties); }
private List<URL> listResourcesFromWebDir(String base, String namespace, String suffix) { Preconditions.checkNotNull(base, "No base defined"); // Make sure we end in a slash StringBuilder path = new StringBuilder(base); if (!base.endsWith("/")) { path.append('/'); } path.append(namespace.replace(".", "/")).append('/'); Set<String> files = (Set<String>) servletContext.getResourcePaths(path.toString()); List<URL> resourceList = new ArrayList<URL>(); if (files != null) { for (String file : files) { if (file.endsWith(suffix)) { try { resourceList.add(servletContext.getResource(file)); } catch (MalformedURLException e) { throw new RuntimeException("Unable to resolve resource at: " + file, e); } } } } return resourceList; }
/* * Scans the web application's sub-directory identified by startPath, * along with its sub-directories, for TLDs and adds an implicit map entry * to the taglib map for any TLD that has a <uri> element. * * Initially, rootPath equals /WEB-INF/. The /WEB-INF/classes and * /WEB-INF/lib sub-directories are excluded from the search, as per the * JSP 2.0 spec. * * Keep code in sync with o.a.c.startup.TldConfig */ private void tldScanResourcePaths(String startPath) throws Exception { Set<String> dirList = ctxt.getResourcePaths(startPath); if (dirList != null) { Iterator<String> it = dirList.iterator(); while (it.hasNext()) { String path = it.next(); if (!path.endsWith(TLD_EXT) && (path.startsWith(WEB_INF_LIB) || path.startsWith("/WEB-INF/classes/"))) { continue; } if (path.endsWith(TLD_EXT)) { if (path.startsWith("/WEB-INF/tags/") && !path.endsWith("implicit.tld")) { continue; } InputStream stream = ctxt.getResourceAsStream(path); try { tldScanStream(path, null, stream); } finally { if (stream != null) { try { stream.close(); } catch (Throwable t) { ExceptionUtils.handleThrowable(t); } } } } else { tldScanResourcePaths(path); } } } }
/** Initiate all plugins available */ @Override public void init() { Set<String> libJars = servletContext.getResourcePaths("/WEB-INF/lib"); Set<URL> pluginJars = libJars .stream() .filter( jar -> jar.toLowerCase().contains("plugin") || jar.toLowerCase().contains("common")) .map( jar -> { try { return servletContext.getResource(jar); } catch (MalformedURLException e) { log.error("error getting resource", e); return null; } }) .filter(url -> url != null) .collect(Collectors.toSet()); AnnotationDB db = new AnnotationDB(); try { ClassLoader cl = Thread.currentThread().getContextClassLoader(); URL[] urls = pluginJars.toArray(new URL[] {}); db.scanArchives(urls); sourceRepoPluginMap = buildPluginMap(db, cl, RepoPlugin.class); transServerPluginMap = buildPluginMap(db, cl, TranslationServerPlugin.class); } catch (IOException | ClassNotFoundException e) { throw Throwables.propagate(e); } }
@SuppressWarnings("unchecked") public List<String> getResourcePaths(String path) { List<String> result = CollectionFactory.newList(); Stack<String> queue = CollectionFactory.newStack(); queue.push(path); while (!queue.isEmpty()) { String current = queue.pop(); Set<String> matches = servletContext.getResourcePaths(current); // Tomcat 5.5.20 inside JBoss 4.0.2 has been observed to do this! // Perhaps other servers do as well. if (matches == null) continue; for (String match : matches) { // Folders are queued up for further expansion. if (match.endsWith("/")) queue.push(match); else result.add(match); } } Collections.sort(result); return result; }
private void _setSpriteImages(ServletContext servletContext, Theme theme, String resourcePath) throws Exception { if (!resourcePath.startsWith(StringPool.SLASH)) { resourcePath = StringPool.SLASH.concat(resourcePath); } Set<String> resourcePaths = servletContext.getResourcePaths(resourcePath); if ((resourcePaths == null) || resourcePaths.isEmpty()) { return; } List<URL> imageURLs = new ArrayList<URL>(resourcePaths.size()); for (String curResourcePath : resourcePaths) { if (curResourcePath.endsWith(StringPool.SLASH)) { _setSpriteImages(servletContext, theme, curResourcePath); } else if (curResourcePath.endsWith(".png")) { URL imageURL = servletContext.getResource(curResourcePath); if (imageURL != null) { imageURLs.add(imageURL); } else { _log.error("Resource URL for " + curResourcePath + " is null"); } } } String spriteRootDirName = PropsValues.SPRITE_ROOT_DIR; String spriteFileName = resourcePath.concat(PropsValues.SPRITE_FILE_NAME); String spritePropertiesFileName = resourcePath.concat(PropsValues.SPRITE_PROPERTIES_FILE_NAME); String rootPath = ServletContextUtil.getRootPath(servletContext); Properties spriteProperties = SpriteProcessorUtil.generate( servletContext, imageURLs, spriteRootDirName, spriteFileName, spritePropertiesFileName, rootPath, 16, 16, 10240); if (spriteProperties == null) { return; } String contextPath = ContextPathUtil.getContextPath(servletContext); spriteFileName = contextPath.concat(SpriteProcessor.PATH).concat(spriteFileName); theme.setSpriteImages(spriteFileName, spriteProperties); }
private void _setSpriteImages(ServletContext servletContext, Theme theme, String resourcePath) throws Exception { Set<String> resourcePaths = servletContext.getResourcePaths(resourcePath); if (resourcePaths == null) { return; } List<File> images = new ArrayList<File>(resourcePaths.size()); for (String curResourcePath : resourcePaths) { if (curResourcePath.endsWith(StringPool.SLASH)) { _setSpriteImages(servletContext, theme, curResourcePath); } else if (curResourcePath.endsWith(".png")) { String realPath = ServletContextUtil.getRealPath(servletContext, curResourcePath); if (realPath != null) { images.add(new File(realPath)); } else { if (ServerDetector.isTomcat()) { if (_log.isInfoEnabled()) { _log.info(ServletContextUtil.LOG_INFO_SPRITES); } } else { _log.error("Real path for " + curResourcePath + " is null"); } } } } String spriteFileName = ".sprite.png"; String spritePropertiesFileName = ".sprite.properties"; String spritePropertiesRootPath = ServletContextUtil.getRealPath(servletContext, theme.getImagesPath()); Properties spriteProperties = SpriteProcessorUtil.generate( images, spriteFileName, spritePropertiesFileName, spritePropertiesRootPath, 16, 16, 10240); if (spriteProperties == null) { return; } spriteFileName = resourcePath.substring(theme.getImagesPath().length(), resourcePath.length()) + spriteFileName; theme.setSpriteImages(spriteFileName, spriteProperties); }
@Override public Set<String> getResourcePaths(String s) { final String pluginPath = "/plugins/" + pluginManager.getName(plugin) + "/"; final Set<String> proxyResults = proxy.getResourcePaths(pluginPath + s); final Set<String> results = new HashSet<>(); for (final String proxyResult : proxyResults) { results.add(proxyResult.replaceFirst(pluginPath, "")); } return results; }
/* (non-Javadoc) * @see net.jawr.web.resource.handler.ResourceInfoProvider#getResourceNames(java.lang.String) */ @SuppressWarnings("unchecked") public Set<String> getResourceNames(String path) { Set<String> paths = context.getResourcePaths(path); Set<String> names = new HashSet<String>(); int length = path.length(); if (null != paths) { for (Iterator<String> it = paths.iterator(); it.hasNext(); ) { String resourcePath = (String) it.next(); names.add(resourcePath.substring(length, resourcePath.length())); } } return names; }
public Repository[] getRepositories() throws IOException { Set paths = context.getResourcePaths(path); List<Repository> list = new ArrayList<Repository>(); if (paths != null) { for (Object obj : paths) { String path = (String) obj; if (path.endsWith("/")) { int n = path.lastIndexOf('/', path.length() - 2); String name = path.substring(n + 1, path.length() - 1); list.add(lookupRepository(name)); } } } return list.toArray(new Repository[list.size()]); }
public static void readOntologyFilesInPathSet(String path, ServletContext ctx, Model model) { log.debug("Reading ontology files from '" + path + "'"); Set<String> paths = ctx.getResourcePaths(path); if (paths != null) { for (String p : paths) { String format = getRdfFormat(p); log.info("Loading ontology file at " + p + " as format " + format); InputStream ontologyInputStream = ctx.getResourceAsStream(p); try { model.read(ontologyInputStream, null, format); log.debug("...successful"); } catch (Throwable t) { log.error("Failed to load ontology file at '" + p + "' as format " + format, t); } } } }
protected void getResources(List<Resource> list, boolean recursive) throws IOException { Set paths = context.getResourcePaths(path); if (paths != null) { for (Object obj : paths) { String path = (String) obj; if (!path.endsWith("/")) { int n = path.lastIndexOf('/', path.length() - 1); String name = path.substring(n + 1); list.add(lookupResource(name)); } else if (recursive) { int n = path.lastIndexOf('/', path.length() - 2); String name = path.substring(n + 1, path.length() - 1); AbstractRepository repo = lookupRepository(name); repo.getResources(list, true); } } } }
private void processWebInfGroovy(ServletContext sc, Set<String> paths, Set<String> classList) { if (paths != null && !paths.isEmpty()) { for (String pathElement : paths) { if (pathElement.endsWith("/")) { processWebInfGroovy(sc, sc.getResourcePaths(pathElement), classList); } else { if (pathElement.endsWith(SUFFIX)) { String cname = convertToClassName(SCRIPT_PATH, pathElement); if (containsAnnotation(sc, pathElement)) { if (LOGGER.isLoggable(Level.FINE)) { LOGGER.log(Level.FINE, "[WEB-INF/groovy] Found annotated Class: {0}", cname); } classList.add(cname); } } } } } }
/* * Searches the filesystem under /WEB-INF for any TLD files, and adds * an implicit map entry to the taglib map for any TLD that has a <uri> * element. */ protected void processTldsInFileSystem(String startPath, Map tmpMappings) // SYNC throws Exception { Set dirList = ctx.getResourcePaths(startPath); if (dirList != null) { Iterator it = dirList.iterator(); while (it.hasNext()) { String path = (String) it.next(); if (path.endsWith("/")) { processTldsInFileSystem(path, tmpMappings); // SYNC } if (path.endsWith(".jar")) { URL resURL = ctx.getResource(path); URLConnection conn = resURL.openConnection(); conn.setUseCaches(false); this.scanJar(conn, resURL.toString(), false, tmpMappings); // SYNC } else if (path.endsWith(".tld") == true) { InputStream stream = ctx.getResourceAsStream(path); String uri = null; try { uri = getUriFromTld(path, stream); } finally { if (stream != null) { try { stream.close(); } catch (Throwable t) { // do nothing } } } // Add implicit map entry only if its uri is not already // present in the map if (uri != null && tmpMappings.get(uri) == null) // SYNC { tmpMappings.put(uri, new String[] {path, null}); // SYNC } } } } }
public FolderOAICatalog(Properties properties, ServletContext context) throws IOException { this.context = context; String temp; dateFormatter.applyPattern("yyyy-MM-dd'T'HH:mm:ss'Z'"); temp = properties.getProperty("NewFileSystemOAICatalog.maxListSize"); if (temp == null) throw new IllegalArgumentException( "NewFileSystemOAICatalog." + "maxListSize is missing from the properties file"); maxListSize = Integer.parseInt(temp); if (debug) System.out.println("in NewFileSystemOAICatalog(): maxListSize=" + maxListSize); homeDir = properties.getProperty("NewFileSystemOAICatalog.homeDir"); if (homeDir != null) { if (debug) System.out.println("in NewFileSystemOAICatalog(): homeDir=" + homeDir); File homeFile = new File(homeDir); int homeDirLen = homeFile.getPath().length() + 1; loadFileMap(homeDirLen, homeFile); } else { /* Try looking in a known location */ Set resourcePaths = context.getResourcePaths("/WEB-INF/DATA/"); if (resourcePaths == null || resourcePaths.size() == 0) { throw new IllegalArgumentException( "NewFileSystemOAICatalog." + "homeDir is missing from the properties file"); } String earliestDatestamp = loadFileMap(context, resourcePaths); properties.setProperty("Identify.earliestDatestamp", earliestDatestamp); } // Iterator iterator = datestampMap.entrySet().iterator(); // while (iterator.hasNext()) { // Map.Entry entry = (Map.Entry)iterator.next(); // System.out.println(entry.getKey() + ":" + entry.getValue()); // } sets = getSets(properties); }
/** * Creates any result types from the resources available in the web application. This scans the * web application resources using the servlet context. * * @param actionClass The action class the results are being built for. * @param results The results map to put the result configs created into. * @param resultPath The calculated path to the resources. * @param resultPrefix The prefix for the result. This is usually <code>/resultPath/actionName * </code>. * @param actionName The action name which is used only for logging in this implementation. * @param packageConfig The package configuration which is passed along in order to determine * @param resultsByExtension The map of extensions to result type configuration instances. */ protected void createFromResources( Class<?> actionClass, Map<String, ResultConfig> results, final String resultPath, final String resultPrefix, final String actionName, PackageConfig packageConfig, Map<String, ResultTypeConfig> resultsByExtension) { if (LOG.isTraceEnabled()) { LOG.trace( "Searching for results in the Servlet container at [#0]" + " with result prefix of [#1]", resultPath, resultPrefix); } // Build from web application using the ServletContext @SuppressWarnings("unchecked") Set<String> paths = servletContext.getResourcePaths(flatResultLayout ? resultPath : resultPrefix); if (paths != null) { for (String path : paths) { if (LOG.isTraceEnabled()) { LOG.trace("Processing resource path [#0]", path); } String fileName = StringUtils.substringAfterLast(path, "/"); if (StringUtils.isBlank(fileName) || StringUtils.startsWith(fileName, ".")) { if (LOG.isTraceEnabled()) LOG.trace("Ignoring file without name [#0]", path); continue; } else if (fileName.lastIndexOf(".") > 0) { String suffix = fileName.substring(fileName.lastIndexOf(".") + 1); if (conventionsService.getResultTypesByExtension(packageConfig).get(suffix) == null) { if (LOG.isDebugEnabled()) LOG.debug( "No result type defined for file suffix : [#0]. Ignoring file #1", suffix, fileName); continue; } } makeResults(actionClass, path, resultPrefix, results, packageConfig, resultsByExtension); } } // Building from the classpath String classPathLocation = resultPath.startsWith("/") ? resultPath.substring(1, resultPath.length()) : resultPath; if (LOG.isTraceEnabled()) { LOG.trace( "Searching for results in the class path at [#0]" + " with a result prefix of [#1] and action name [#2]", classPathLocation, resultPrefix, actionName); } ResourceFinder finder = new ResourceFinder(classPathLocation, getClassLoaderInterface()); try { Map<String, URL> matches = finder.getResourcesMap(""); if (matches != null) { Test<URL> resourceTest = getResourceTest(resultPath, actionName); for (Map.Entry<String, URL> entry : matches.entrySet()) { if (resourceTest.test(entry.getValue())) { if (LOG.isTraceEnabled()) { LOG.trace("Processing URL [#0]", entry.getKey()); } String urlStr = entry.getValue().toString(); int index = urlStr.lastIndexOf(resultPrefix); String path = urlStr.substring(index); makeResults( actionClass, path, resultPrefix, results, packageConfig, resultsByExtension); } } } } catch (IOException ex) { if (LOG.isErrorEnabled()) LOG.error("Unable to scan directory [#0] for results", ex, classPathLocation); } }
/* (non-Javadoc) * @see net.jawr.web.resource.handler.ResourceInfoProvider#isDirectory(java.lang.String) */ @SuppressWarnings("unchecked") public boolean isDirectory(String path) { Set<String> paths = context.getResourcePaths(path); return (null != paths && paths.size() > 0); }
public Set getResourcePaths(String name) { return delegate.getResourcePaths(name); }
/** @see javax.faces.context.ExternalContext#getResourcePaths(String) */ public Set<String> getResourcePaths(String path) { return TypedCollections.dynamicallyCastSet(servletContext.getResourcePaths(path), String.class); }
/** * Scan the provided ServletContext and classloader for JAR files. Each JAR file found will be * passed to the callback handler to be processed. * * @param context The ServletContext - used to locate and access WEB-INF/lib * @param classloader The classloader - used to access JARs not in WEB-INF/lib * @param callback The handler to process any JARs found * @param jarsToSkip List of JARs to ignore. If this list is null, a default list will be read * from the system property defined by {@link Constants#SKIP_JARS_PROPERTY} */ @Override public void scan( ServletContext context, ClassLoader classloader, JarScannerCallback callback, Set<String> jarsToSkip) { if (log.isTraceEnabled()) { log.trace(sm.getString("jarScan.webinflibStart")); } Set<String> ignoredJars; if (jarsToSkip == null) { ignoredJars = defaultJarsToSkip; } else { ignoredJars = jarsToSkip; } Set<String[]> ignoredJarsTokens = new HashSet<String[]>(); for (String pattern : ignoredJars) { ignoredJarsTokens.add(Matcher.tokenizePathAsArray(pattern)); } // Scan WEB-INF/lib Set<String> dirList = context.getResourcePaths(Constants.WEB_INF_LIB); if (dirList != null) { Iterator<String> it = dirList.iterator(); while (it.hasNext()) { String path = it.next(); if (path.endsWith(Constants.JAR_EXT) && !Matcher.matchPath(ignoredJarsTokens, path.substring(path.lastIndexOf('/') + 1))) { // Need to scan this JAR if (log.isDebugEnabled()) { log.debug(sm.getString("jarScan.webinflibJarScan", path)); } URL url = null; try { url = context.getResource(path); process(callback, url); } catch (IOException e) { log.warn(sm.getString("jarScan.webinflibFail", url), e); } } else { if (log.isTraceEnabled()) { log.trace(sm.getString("jarScan.webinflibJarNoScan", path)); } } } } // Scan the classpath if (scanClassPath) { if (log.isTraceEnabled()) { log.trace(sm.getString("jarScan.classloaderStart")); } ClassLoader loader = Thread.currentThread().getContextClassLoader(); while (loader != null) { if (loader instanceof URLClassLoader) { URL[] urls = ((URLClassLoader) loader).getURLs(); for (int i = 0; i < urls.length; i++) { // Extract the jarName if there is one to be found String jarName = getJarName(urls[i]); // Skip JARs known not to be interesting and JARs // in WEB-INF/lib we have already scanned if (jarName != null && !(Matcher.matchPath(ignoredJarsTokens, jarName) || urls[i].toString().contains(Constants.WEB_INF_LIB + jarName))) { if (log.isDebugEnabled()) { log.debug(sm.getString("jarScan.classloaderJarScan", urls[i])); } try { process(callback, urls[i]); } catch (IOException ioe) { log.warn(sm.getString("jarScan.classloaderFail", urls[i]), ioe); } } else { if (log.isTraceEnabled()) { log.trace(sm.getString("jarScan.classloaderJarNoScan", urls[i])); } } } } loader = loader.getParent(); } } }
public Set<String> getScripts() { Set<String> scripts = new HashSet<>(); processWebInfGroovy(servletContext, servletContext.getResourcePaths(SCRIPT_PATH), scripts); return scripts; }
public Set<String> getResourcePaths(String path) { return context.getResourcePaths(canonicalURI(path)); }
@Override public Set<String> getResourcePaths(String path) { return sc.getResourcePaths(path); }
/** * Scan the provided ServletContext and classloader for JAR files. Each JAR file found will be * passed to the callback handler to be processed. * * @param context The ServletContext - used to locate and access WEB-INF/lib * @param classloader The classloader - used to access JARs not in WEB-INF/lib * @param callback The handler to process any JARs found * @param jarsToSkip List of JARs to ignore. If this list is null, a default list will be read * from the system property defined by {@link Constants#SKIP_JARS_PROPERTY} */ @Override public void scan( ServletContext context, ClassLoader classloader, JarScannerCallback callback, Set<String> jarsToSkip) { if (log.isTraceEnabled()) { log.trace(sm.getString("jarScan.webinflibStart")); } final Set<String> ignoredJars; if (jarsToSkip == null) { ignoredJars = defaultJarsToSkip; } else { ignoredJars = jarsToSkip; } // Scan WEB-INF/lib Set<String> dirList = context.getResourcePaths(Constants.WEB_INF_LIB); if (dirList != null) { Iterator<String> it = dirList.iterator(); while (it.hasNext()) { String path = it.next(); if (path.endsWith(Constants.JAR_EXT) && !Matcher.matchName(ignoredJars, path.substring(path.lastIndexOf('/') + 1))) { // Need to scan this JAR if (log.isDebugEnabled()) { log.debug(sm.getString("jarScan.webinflibJarScan", path)); } URL url = null; try { // File URLs are always faster to work with so use them // if available. String realPath = context.getRealPath(path); if (realPath == null) { url = context.getResource(path); } else { url = (new File(realPath)).toURI().toURL(); } process(callback, url); } catch (IOException e) { log.warn(sm.getString("jarScan.webinflibFail", url), e); } } else { if (log.isTraceEnabled()) { log.trace(sm.getString("jarScan.webinflibJarNoScan", path)); } } } } // Scan the classpath if (scanClassPath && classloader != null) { if (log.isTraceEnabled()) { log.trace(sm.getString("jarScan.classloaderStart")); } ClassLoader loader = classloader; ClassLoader stopLoader = null; if (!scanBootstrapClassPath) { // Stop when we reach the bootstrap class loader stopLoader = ClassLoader.getSystemClassLoader().getParent(); } while (loader != null && loader != stopLoader) { if (loader instanceof URLClassLoader) { URL[] urls = ((URLClassLoader) loader).getURLs(); for (int i = 0; i < urls.length; i++) { // Extract the jarName if there is one to be found String jarName = getJarName(urls[i]); // Skip JARs known not to be interesting and JARs // in WEB-INF/lib we have already scanned if (jarName != null && !(Matcher.matchName(ignoredJars, jarName) || urls[i].toString().contains(Constants.WEB_INF_LIB + jarName))) { if (log.isDebugEnabled()) { log.debug(sm.getString("jarScan.classloaderJarScan", urls[i])); } try { process(callback, urls[i]); } catch (IOException ioe) { log.warn(sm.getString("jarScan.classloaderFail", urls[i]), ioe); } } else { if (log.isTraceEnabled()) { log.trace(sm.getString("jarScan.classloaderJarNoScan", urls[i])); } } } } loader = loader.getParent(); } } }
private void processPaths(String... paths) { for (final String path : paths) { final Set<String> resourcePaths = sc.getResourcePaths(path); if (resourcePaths == null) { break; } resourceFinderStack.push( new ResourceFinder() { private Deque<String> resourcePathsStack = new LinkedList<String>() { private static final long serialVersionUID = 3109256773218160485L; { for (String resourcePath : resourcePaths) { push(resourcePath); } } }; private String current; private String next; @Override public boolean hasNext() { while (next == null && !resourcePathsStack.isEmpty()) { next = resourcePathsStack.pop(); if (next.endsWith("/")) { processPaths(next); next = null; } else if (next.endsWith(".jar")) { try { resourceFinderStack.push( new JarFileScanner(sc.getResourceAsStream(next), "", true)); } catch (IOException ioe) { throw new ResourceFinderException(ioe); } next = null; } } return next != null; } @Override public String next() { if (next != null || hasNext()) { current = next; next = null; return current; } throw new NoSuchElementException(); } @Override public void remove() { throw new UnsupportedOperationException(); } @Override public InputStream open() { return sc.getResourceAsStream(current); } @Override public void reset() { throw new UnsupportedOperationException(); } }); } }