Fix many conversion-related issues

* Refactor DefaultConverter, fixing many bugs,
  and updating unit tests accordingly.

* Uncomment tests in DefaultConverterTest, which now pass.

* Undeprecate canConvert methods with Class src. There is no
  replacement when an object of the source type is not available.

* Make ConversionUtils better match ConvertService.
  It now uses the list of built-in converters that are part of SciJava
  Common, in the same order they are used as Converter plugins.

* Clean up conversion-related classes:
  * Add missing final keywords, fix warnings, and clean up style.
  * Update javadoc comments to be more accurate in more places.
  * Fix NullConverter to take precedence iff src and/or dest is null.

Author: ctrueden

src/main/java/org/scijava/convert/ArrayToStringConverter.java

@@ -37,12 +37,11 @@
 import org.scijava.plugin.Parameter;
 import org.scijava.plugin.Plugin;
 import org.scijava.util.ArrayUtils;
-import org.scijava.util.Types;
 
 /**
- * A {@link Converter} that specializes in converting
- * n-dimensional arrays into {@link String}s. This {@link Converter} can convert any array whose
- * component types can be converted into {@link String}s. By default, this
+ * A {@link Converter} that specializes in converting n-dimensional arrays into
+ * {@link String}s. This {@link Converter} can convert any array whose component
+ * types can be converted into {@link String}s. By default, this
  * {@link Converter} delimits the array elements with commas.
  * 
  * @author Gabriel Selzer
@@ -53,77 +52,77 @@ public class ArrayToStringConverter extends AbstractConverter<Object, String> {
 	@Parameter(required = false)
 	private ConvertService convertService;
 
-	@Override public boolean canConvert(final Class<?> src, final Class<?> dest) {
-		if (src == null) return false;
-		final Class<?> saneSrc = Types.box(src);
-		final Class<?> saneDest = Types.box(dest);
-		return saneSrc.isArray() && saneDest == String.class;
+	@Override
+	public boolean canConvert(final Class<?> src, final Class<?> dest) {
+		return src != null && src.isArray() && dest == String.class;
 	}
 
-	@Override public boolean canConvert(final Object src, final Class<?> dest) {
-		if (convertService == null) return false;
+	@Override
+	public boolean canConvert(final Object src, final Class<?> dest) {
+		if (convertService == null || src == null) return false;
 		if (!canConvert(src.getClass(), dest)) return false;
 		if (Array.getLength(src) == 0) return true;
 		return convertService.supports(Array.get(src, 0), dest);
 	}
 
 	@Override
-	public Object convert(Object src, Type dest) {
+	public Object convert(Object src, final Type dest) {
 		// Preprocess the "string-likes"
-		if (src.getClass().equals(String[].class) || //
-			src.getClass().equals(Character[].class) || //
-			src.getClass().equals(char[].class)) //
+		final Class<?> srcClass = src.getClass();
+		if (srcClass == String[].class || //
+			srcClass == Character[].class || //
+			srcClass == char[].class) //
 		{
 			src = preprocessCharacters(src);
 		}
 		// Convert each element to Strings
-		String elementString = ArrayUtils.toCollection(src).stream() //
+		final String elementString = ArrayUtils.toCollection(src).stream() //
 			.map(object -> convertService.convert(object, String.class)) //
 			.collect(Collectors.joining(", "));
 		return "{" + elementString + "}";
 	}
 
 	private String[] preprocessStrings(final Object src) {
-		int numElements = Array.getLength(src);
-		String[] processed = new String[numElements];
+		final int numElements = Array.getLength(src);
+		final String[] processed = new String[numElements];
 		for (int i = 0; i < numElements; i++) {
 			processed[i] = preprocessString(Array.get(src, i));
 		}
 		return processed;
 	}
 
 	private String preprocessString(final Object o) {
-		String s;
-		if (o == null) {
-			return null;
-		} else {
-			s = o.toString();
-			s = s.replace("\\", "\\\\");
-			s = s.replace("\"", "\\\"");
-		}
+		if (o == null) return null;
+		String s = o.toString();
+		s = s.replace("\\", "\\\\");
+		s = s.replace("\"", "\\\"");
 		return "\"" + s + "\"";
 	}
 
 	private String[] preprocessCharacters(Object src) {
-		String[] processed = new String[Array.getLength(src)];
+		final String[] processed = new String[Array.getLength(src)];
 		for (int i = 0; i < processed.length; i++) {
-			Object value = Array.get(src, i);
+			final Object value = Array.get(src, i);
 			processed[i] = value == null ? null : value.toString();
 		}
 		return preprocessStrings(processed);
 	}
 
-	@SuppressWarnings("unchecked") @Override
-	public <T> T convert(Object src, Class<T> dest) {
-		return (T) convert(src, (Type) dest);
+	@Override
+	public <T> T convert(final Object src, final Class<T> dest) {
+		final Type destType = dest;
+		@SuppressWarnings("unchecked")
+		final T converted = (T) convert(src, destType);
+		return converted;
 	}
 
-	@Override public Class<String> getOutputType() {
+	@Override
+	public Class<String> getOutputType() {
 		return String.class;
 	}
 
-	@Override public Class<Object> getInputType() {
+	@Override
+	public Class<Object> getInputType() {
 		return Object.class;
 	}
-
 }

src/main/java/org/scijava/convert/CastingConverter.java

@@ -28,6 +28,8 @@
  */
 package org.scijava.convert;
 
+import java.lang.reflect.Type;
+
 import org.scijava.Priority;
 import org.scijava.plugin.Plugin;
 import org.scijava.util.Types;
@@ -37,7 +39,7 @@
  *
  * @author Mark Hiner
  */
-@Plugin(type = Converter.class, priority = Priority.EXTREMELY_HIGH)
+@Plugin(type = Converter.class, priority = Priority.EXTREMELY_HIGH - 1)
 public class CastingConverter extends AbstractConverter<Object, Object> {
 
 	@Override
@@ -46,25 +48,23 @@ public boolean canConvert(final Object src, final Class<?> dest) {
 	}
 
 	@Override
-	public boolean canConvert(final Class<?> src, final Class<?> dest) {
+	public boolean canConvert(final Class<?> src, final Type dest) {
 		// OK if the existing object can be casted
 		return dest != null && Types.isAssignable(src, dest);
 	}
 
-	@SuppressWarnings("unchecked")
+	@Override
+	public boolean canConvert(final Class<?> src, final Class<?> dest) {
+		// NB: Invert functional flow from Converter interface:
+		// Converter: canConvert(Class, Type) -> canConvert(Class, Class)
+		// becomes: canConvert(Class, Class) -> canConvert(Class, Type)
+		final Type destType = dest;
+		return canConvert(src, destType);
+	}
+
 	@Override
 	public <T> T convert(final Object src, final Class<T> dest) {
-		// NB: Regardless of whether the destination type is an array or
-		// collection, we still want to cast directly if doing so is possible.
-		// But note that in general, this check does not detect cases of
-		// incompatible generic parameter types. If this limitation becomes a
-		// problem in the future we can extend the logic here to provide
-		// additional signatures of canCast which operate on Types in general
-		// rather than only Classes. However, the logic could become complex
-		// very quickly in various subclassing cases, generic parameters
-		// resolved vs. propagated, etc.
-		final Class<?> c = Types.raw(dest);
-		return (T) Types.cast(src, c);
+		return Types.cast(src, dest);
 	}
 
 	@Override

src/main/java/org/scijava/convert/DefaultConvertService.java

@@ -40,5 +40,5 @@
 @Plugin(type = Service.class)
 public class DefaultConvertService extends AbstractConvertService
 {
-	// Trivial implementation
+	// NB: No implementation needed.
 }