jdk-sandbox: comparison langtools/src/share/classes/com/sun/tools/javac/processing/JavacProcessingEnvironment.java

equal deleted inserted replaced

-:be9e8bdd7ead
+:f0077f165983
 */
 private class ServiceIterator implements Iterator<Processor> {
 // The to-be-wrapped iterator.
 private Iterator<?> iterator;
 private Log log;
+private Class<?> loaderClass;
+private boolean jusl;
+private Object loader;
 ServiceIterator(ClassLoader classLoader, Log log) {
-Class<?> loaderClass;
 String loadMethodName;
-boolean jusl;
 this.log = log;
 try {
 try {
 loaderClass = Class.forName("java.util.ServiceLoader");
 classLoader);
 // For java.util.ServiceLoader, we have to call another
 // method to get the iterator.
 if (jusl) {
+loader = result; // Store ServiceLoader to call reload later
 Method m = loaderClass.getMethod("iterator");
 result = m.invoke(result); // serviceLoader.iterator();
 }
 // The result should now be an iterator.
 }
 }
 public void remove() {
 throw new UnsupportedOperationException();
+}
+public void close() {
+if (jusl) {
+try {
+// Call java.util.ServiceLoader.reload
+Method reloadMethod = loaderClass.getMethod("reload");
+reloadMethod.invoke(loader);
+} catch(Exception e) {
+; // Ignore problems during a call to reload.
+}
+}
 }
 }
 private static class NameProcessIterator implements Iterator<Processor> {
 /**
 * This class holds information about the processors that have
 * been discoverd so far as well as the means to discover more, if
 * necessary.  A single iterator should be used per round of
 * annotation processing.  The iterator first visits already
-* discovered processors then fails over to the service provided
+* discovered processors then fails over to the service provider
 * mechanism if additional queries are made.
 */
 class DiscoveredProcessors implements Iterable<ProcessorState> {
 class ProcessorStateIterator implements Iterator<ProcessorState> {
 }
 DiscoveredProcessors(Iterator<? extends Processor> processorIterator) {
 this.processorIterator = processorIterator;
 this.procStateList = new ArrayList<ProcessorState>();
+}
+/**
+* Free jar files, etc. if using a service loader.
+*/
+public void close() {
+if (processorIterator != null &&
+processorIterator instanceof ServiceIterator) {
+((ServiceIterator) processorIterator).close();
+}
 }
 }
 private void discoverAndRunProcs(Context context,
 Set<TypeElement> annotationsPresent,
 * should exit with a nonzero exit code.  The current value of
 * errorStatus holds whether or not an error was raised on the
 * second to last round; errorRaised() gives the error status
 * of the last round.
 */
 errorStatus = errorStatus || messager.errorRaised();
 // Free resources
 this.close();
 /**
 * Free resources related to annotation processing.
 */
 public void close() throws IOException {
 filer.close();
+if (discoveredProcs != null) // Make calling close idempotent
+discoveredProcs.close();
 discoveredProcs = null;
 if (processorClassLoader != null && processorClassLoader instanceof Closeable)
 ((Closeable) processorClassLoader).close();
 }

changeset 3764	f0077f165983
parent 3656	d4e34b76b0c3
child 4871	655bba719625