ObjectIndex: only resolve relevant pending objects

If a pending object will not be of a type compatible with the
requested type, then skip resolution of that pending object.

This improves performance of the get(Class) and getAll() methods in
cases where there are a large number of pending objects in the index.

It also helps to eliminate difficulties like those in issue #90.

Author: ctrueden

src/main/java/org/scijava/object/ObjectIndex.java

@@ -31,6 +31,8 @@
 
 package org.scijava.object;
 
+import java.lang.reflect.Method;
+import java.lang.reflect.Type;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
@@ -45,6 +47,7 @@
 import java.util.concurrent.ConcurrentHashMap;
 
 import org.scijava.util.ClassUtils;
+import org.scijava.util.GenericUtils;
 
 /**
  * Data structure for managing lists of registered objects.
@@ -129,7 +132,7 @@ public List<E> getAll() {
 	 */
 	public List<E> get(final Class<?> type) {
 		// lazily register any pending objects
-		if (!pending.isEmpty()) resolvePending();
+		if (!pending.isEmpty()) resolvePending(type);
 
 		List<E> list = retrieveList(type);
 		// NB: Return a copy of the data, to facilitate thread safety.
@@ -380,15 +383,53 @@ protected List<E> retrieveList(final Class<?> type) {
 		return list;
 	}
 
-	private void resolvePending() {
+	private void resolvePending(final Class<?> type) {
 		synchronized (pending) {
-			while (!pending.isEmpty()) {
-				final LazyObjects<? extends E> c = pending.remove(0);
+			for (int p = pending.size() - 1; p >= 0; p--) {
+				final LazyObjects<? extends E> c = pending.get(p);
+
+				// NB: If this pending callback returns objects of a different
+				// type than the one we are interested in, it can be skipped.
+				if (!isCompatibleType(c, type)) continue;
+
+				// trigger the callback and add the results
+				pending.remove(p);
 				addAll(c.get());
 			}
 		}
 	}
 
+	// -- Helper methods --
+
+	private boolean isCompatibleType(final LazyObjects<? extends E> c,
+		final Class<?> type)
+	{
+		if (type == All.class) return true;
+
+		// extract the generic type from the LazyObjects#get return type
+		final Method getMethod;
+		try {
+			getMethod = c.getClass().getMethod("get");
+		}
+		catch (final NoSuchMethodException exc) {
+			throw new IllegalStateException(exc);
+		}
+		final Type returnType =
+			GenericUtils.getMethodReturnType(getMethod, c.getClass());
+		final Type paramType =
+			GenericUtils.getTypeParameter(returnType, Collection.class, 0);
+
+		// NB: paramType will be null if the LazyObjects subtype uses raw types.
+		if (paramType != null) {
+			final Class<?> paramClass = GenericUtils.getClass(paramType);
+			if (paramClass != null && !paramClass.isAssignableFrom(type)) {
+				return false;
+			}
+		}
+
+		return true;
+	}
+
 	// -- Helper classes --
 
 	private static class All {