EclipseHelper: Support incremental annotation indexing

dscho · dscho · commit 167bf6469945 · 2013-12-13T09:07:35.000-06:00
... which includes removing annotations that are now obsolete...

Signed-off-by: Johannes Schindelin &lt;johannes.schindelin@gmx.de&gt;
diff --git a/src/main/java/org/scijava/annotations/AbstractIndexWriter.java b/src/main/java/org/scijava/annotations/AbstractIndexWriter.java
@@ -81,6 +81,8 @@ public interface StreamFactory {
 		InputStream openInput(String annotationName) throws IOException;
 
 		OutputStream openOutput(String annotationName) throws IOException;
+
+		boolean isClassObsolete(String className);
 	}
 
 	protected synchronized void write(final StreamFactory factory)
@@ -99,6 +101,19 @@ protected synchronized void write(final StreamFactory factory)
 		map.clear();
 	}
 
+	/**
+	 * Merges an existing annotation index into the currently-generated one.
+	 * <p>
+	 * This method is used to read previously-indexed annotations and reconcile
+	 * them with the newly-generated ones just.
+	 * </p>
+	 * 
+	 * @param annotationName the name of the annotation for which the index
+	 *          contains the annotated classes
+	 * @param factory the factory to generate input and output streams given an
+	 *          annotation name
+	 * @throws IOException
+	 */
 	protected synchronized void merge(final String annotationName,
 		final StreamFactory factory) throws IOException
 	{
@@ -111,6 +126,12 @@ protected synchronized void merge(final String annotationName,
 			map = new LinkedHashMap<String, Object>();
 			this.map.put(annotationName, map);
 		}
+		/*
+		 * To determine whether the index needs to be written out,
+		 * we need to keep track of changed entries.
+		 */
+		int changedCount = map.size();
+		boolean hasObsoletes = false;
 
 		final IndexReader reader = new IndexReader(in);
 		try {
@@ -121,14 +142,26 @@ protected synchronized void merge(final String annotationName,
 					break;
 				}
 				final String className = (String) entry.get("class");
-				if (!map.containsKey(className)) {
+				if (factory.isClassObsolete(className)) {
+					hasObsoletes = true;
+				}
+				else if (map.containsKey(className)) {
+					if (!hasObsoletes && entry.equals(map.get(className))) {
+						changedCount--;
+					}
+				}
+				else {
 					map.put(className, entry);
 				}
 			}
 		}
 		finally {
 			reader.close();
 		}
+		// if this annotation index is unchanged, no need to write it out again
+		if (changedCount == 0 && !hasObsoletes) {
+			this.map.remove(annotationName);
+		}
 	}
 
 	protected Object adapt(final Object o) {
diff --git a/src/main/java/org/scijava/annotations/DirectoryIndexer.java b/src/main/java/org/scijava/annotations/DirectoryIndexer.java
@@ -115,7 +115,7 @@ private static <A extends Annotation> boolean isIndexable(final A annotation)
 	}
 
 	protected synchronized void write(final File directory) throws IOException {
-		write(new StreamFactory() {
+		final StreamFactory factory = new StreamFactory() {
 
 			public InputStream openInput(String annotationName) throws IOException {
 				final File file =
@@ -137,8 +137,34 @@ public OutputStream openOutput(String annotationName) throws IOException {
 				{
 					throw new IOException("Could not make directory " + directory);
 				}
-				return new FileOutputStream(file);
+				return new FileOutputStream(file) {
+
+					@Override
+					public void close() throws IOException {
+						super.close();
+						if (file.length() == 0) {
+							file.delete();
+						}
+					}
+				};
+			}
+
+			public boolean isClassObsolete(String className) {
+				final String classPath = className.replace('.', '/') + ".class";
+				return !new File(directory, classPath).exists();
 			}
-		});
+		};
+
+		final File[] possiblyObsoletes =
+			new File(directory, Index.INDEX_PREFIX).listFiles();
+		if (possiblyObsoletes != null) {
+			for (final File candidate : possiblyObsoletes) {
+				if (candidate.isFile()) {
+					final String annotationName = candidate.getName();
+					merge(annotationName, factory);
+				}
+			}
+		}
+		write(factory);
 	}
 }
diff --git a/src/test/java/org/scijava/annotations/EclipseHelperTest.java b/src/test/java/org/scijava/annotations/EclipseHelperTest.java
@@ -85,6 +85,25 @@ public Class<?> loadClass(final String className)
 			assertTrue(new File(jsonDir, clazz.getName()).exists());
 		}
 		assertEquals(2, jsonDir.list().length);
+
+		// delete the .class files and verify that the annotation indexes are
+		// deleted
+		jsonDir.setLastModified(123456789);
+		for (final Class<?> clazz : new Class<?>[] { AnnotatedA.class,
+			AnnotatedB.class, AnnotatedC.class })
+		{
+			assertTrue(new File(dir, DirectoryIndexerTest.getResourcePath(clazz))
+				.delete());
+		}
+		long now = System.currentTimeMillis();
+		EclipseHelper.updateAnnotationIndex(loader);
+		assertEquals(0, jsonDir.list().length);
+		/*
+		 * Most file systems provide the mtime at second granularity, not
+		 * milli-second granularity. Hence "now" might be as much as 999
+		 * milliseconds ahead of the stored mtime.
+		 */
+		assertTrue(jsonDir.lastModified() >= now - 999);
 	}
 
 	private void copyClasses(final File dir, final Class<?>... classes)
