Fix Java 11's new javadoc lint errors

Author: ctrueden

src/main/java/org/scijava/event/bushe/ThreadSafeEventService.java

@@ -110,21 +110,21 @@
  * Cleanup is pretty rare in general.  Not only are stale subscribers cleaned up with regular usage, stale 
  * subscribers on abandoned topics and classes do not take up a lot of memory, hence, they are allowed to build up to a certain degree.
  * Cleanup does not occur until the number of WeakReferences and SubscriptionsProxy's with WeakReference strength
- * subscribed to an EventService for all the EventService's subscriptions in total exceed the <tt>cleanupStartThreshhold</tt>, 
- * which is set to <tt>CLEANUP_START_THRESHOLD_DEFAULT</tt> (500) by default.  The default is overridable in the constructor 
+ * subscribed to an EventService for all the EventService's subscriptions in total exceed the <code>cleanupStartThreshhold</code>, 
+ * which is set to <code>CLEANUP_START_THRESHOLD_DEFAULT</code> (500) by default.  The default is overridable in the constructor 
  * or via #setCleanupStartThreshhold(Integer).  If set to null, cleanup will never start.  
  * </p>
  * <p>
- * Once the cleanup start threshold is exceeded, a <tt>java.util.Timer</tt> is started to clean up stale subscribers periodically 
- * in another thread.  The timer will fire every <tt>cleanupPeriodMS</tt> milliseconds, which is set to the 
- * <tt>CLEANUP_PERIOD_MS_DEFAULT</tt> (20 minutes) by default.  The default is overridable in the constructor or 
- * via #setCleanupPeriodMS(Integer).  If set to null, cleanup will not start.  This is implemented with a <tt>java.util.Timer</tt>,
+ * Once the cleanup start threshold is exceeded, a <code>java.util.Timer</code> is started to clean up stale subscribers periodically 
+ * in another thread.  The timer will fire every <code>cleanupPeriodMS</code> milliseconds, which is set to the 
+ * <code>CLEANUP_PERIOD_MS_DEFAULT</code> (20 minutes) by default.  The default is overridable in the constructor or 
+ * via #setCleanupPeriodMS(Integer).  If set to null, cleanup will not start.  This is implemented with a <code>java.util.Timer</code>,
  * so Timer's warnings apply - setting this too low will cause cleanups to bunch up and hog the cleanup thread.
  * </p>
  * <p>
- * After a cleanup cycle completes, if the number of stale subscribers falls at or below the <tt>cleanupStopThreshhold</tt> 
- * cleanup stops until the <tt>cleanupStartThreshhold</tt> is exceeded again. The <tt>cleanupStopThreshhold</tt> is set 
- * to <tt>CLEANUP_STOP_THRESHOLD_DEFAULT</tt> (100) by default.  The default is overridable in the constructor or via 
+ * After a cleanup cycle completes, if the number of stale subscribers falls at or below the <code>cleanupStopThreshhold</code> 
+ * cleanup stops until the <code>cleanupStartThreshhold</code> is exceeded again. The <code>cleanupStopThreshhold</code> is set 
+ * to <code>CLEANUP_STOP_THRESHOLD_DEFAULT</code> (100) by default.  The default is overridable in the constructor or via 
  * #setCleanupStopThreshhold(Integer).  If set to null or 0, cleanup will not stop if it is ever started.  
  * </p>
  * <p>

src/main/java/org/scijava/util/FileUtils.java

@@ -465,7 +465,7 @@ public static File createTemporaryDirectory(final String prefix,
 	 *          see {@link File#createTempFile(String, String, File)}
 	 * @param directory The directory in which the file is to be created, or null
 	 *          if the default temporary-file directory is to be used
-	 * @return: An abstract pathname denoting a newly-created empty directory
+	 * @return An abstract pathname denoting a newly-created empty directory
 	 * @throws IOException
 	 */
 	public static File createTemporaryDirectory(final String prefix,

src/main/java/org/scijava/util/MersenneTwisterFast.java

@@ -521,8 +521,8 @@ public final boolean nextBoolean()
 
 
 
-    /** This generates a coin flip with a probability <tt>probability</tt>
-        of returning true, else returning false.  <tt>probability</tt> must
+    /** This generates a coin flip with a probability <code>probability</code>
+        of returning true, else returning false.  <code>probability</code> must
         be between 0.0 and 1.0, inclusive.   Not as precise a random real
         event as nextBoolean(double), but twice as fast. To explicitly
         use this, remember you may need to cast to float first. */
@@ -567,8 +567,8 @@ public final boolean nextBoolean(final float probability)
         }
 
 
-    /** This generates a coin flip with a probability <tt>probability</tt>
-        of returning true, else returning false.  <tt>probability</tt> must
+    /** This generates a coin flip with a probability <code>probability</code>
+        of returning true, else returning false.  <code>probability</code> must
         be between 0.0 and 1.0, inclusive. */
 
     public final boolean nextBoolean(final double probability)
@@ -928,7 +928,7 @@ public final double nextDouble()
 
     /** Returns a double in the range from 0.0 to 1.0, possibly inclusive of 0.0 and 1.0 themselves.  Thus:
 
-        <table border=0 summary="Table">
+        <table><caption>Table</caption>
         <tr><th>Expression</th><th>Interval</th></tr>
         <tr><td>nextDouble(false, false)</td><td>(0.0, 1.0)</td></tr>
         <tr><td>nextDouble(true, false)</td><td>[0.0, 1.0)</td></tr>
@@ -1141,7 +1141,7 @@ public final float nextFloat()
 
     /** Returns a float in the range from 0.0f to 1.0f, possibly inclusive of 0.0f and 1.0f themselves.  Thus:
 
-        <table border=0 summary="Table">
+        <table><caption>Table</caption>
         <tr><th>Expression</th><th>Interval</th></tr>
         <tr><td>nextFloat(false, false)</td><td>(0.0f, 1.0f)</td></tr>
         <tr><td>nextFloat(true, false)</td><td>[0.0f, 1.0f)</td></tr>

src/main/java/org/scijava/util/Types.java

@@ -3257,8 +3257,8 @@ else if (type instanceof ParameterizedType) {
 		/**
 		 * Returns a type representing the class, with all type parameters the
 		 * unbound wildcard ("?"). For example,
-		 * <tt>addWildcardParameters(Map.class)</tt> returns a type representing
-		 * <tt>Map&lt;?,?&gt;</tt>.
+		 * <code>addWildcardParameters(Map.class)</code> returns a type representing
+		 * <code>Map&lt;?,?&gt;</code>.
 		 * 
 		 * @return
 		 *         <ul>
@@ -3288,27 +3288,27 @@ else if (isMissingTypeParameters(clazz)) {
 		}
 
 		/**
-		 * Finds the most specific supertype of <tt>type</tt> whose erasure is
-		 * <tt>searchClass</tt>. In other words, returns a type representing the
-		 * class <tt>searchClass</tt> plus its exact type parameters in
-		 * <tt>type</tt>.
+		 * Finds the most specific supertype of <code>type</code> whose erasure is
+		 * <code>searchClass</code>. In other words, returns a type representing the
+		 * class <code>searchClass</code> plus its exact type parameters in
+		 * <code>type</code>.
 		 * <ul>
 		 * <li>Returns an instance of {@link ParameterizedType} if
-		 * <tt>searchClass</tt> is a real class or interface and <tt>type</tt> has
+		 * <code>searchClass</code> is a real class or interface and <code>type</code> has
 		 * parameters for it</li>
 		 * <li>Returns an instance of {@link GenericArrayType} if
-		 * <tt>searchClass</tt> is an array type, and <tt>type</tt> has type
+		 * <code>searchClass</code> is an array type, and <code>type</code> has type
 		 * parameters for it</li>
-		 * <li>Returns an instance of {@link Class} if <tt>type</tt> is a raw type,
-		 * or has no type parameters for <tt>searchClass</tt></li>
-		 * <li>Returns null if <tt>searchClass</tt> is not a superclass of type.
+		 * <li>Returns an instance of {@link Class} if <code>type</code> is a raw type,
+		 * or has no type parameters for <code>searchClass</code></li>
+		 * <li>Returns null if <code>searchClass</code> is not a superclass of type.
 		 * </li>
 		 * </ul>
 		 * <p>
 		 * For example, with
-		 * <tt>class StringList implements List&lt;String&gt;</tt>,
-		 * <tt>getExactSuperType(StringList.class, Collection.class)</tt> returns a
-		 * {@link ParameterizedType} representing <tt>Collection&lt;String&gt;</tt>.
+		 * <code>class StringList implements List&lt;String&gt;</code>,
+		 * <code>getExactSuperType(StringList.class, Collection.class)</code> returns a
+		 * {@link ParameterizedType} representing <code>Collection&lt;String&gt;</code>.
 		 * </p>
 		 */
 		public static Type getExactSuperType(final Type type,
@@ -3337,9 +3337,9 @@ public static Type getExactSuperType(final Type type,
 		/**
 		 * Gets the type parameter for a given type that is the value for a given
 		 * type variable. For example, with
-		 * <tt>class StringList implements List&lt;String&gt;</tt>,
-		 * <tt>getTypeParameter(StringList.class, Collection.class.getTypeParameters()[0])</tt>
-		 * returns <tt>String</tt>.
+		 * <code>class StringList implements List&lt;String&gt;</code>,
+		 * <code>getTypeParameter(StringList.class, Collection.class.getTypeParameters()[0])</code>
+		 * returns <code>String</code>.
 		 * 
 		 * @param type The type to inspect.
 		 * @param variable The type variable to find the value for.
@@ -3569,9 +3569,9 @@ private static Type[] getArrayExactDirectSuperTypes(final Type arrayType) {
 
 		/**
 		 * Returns the exact return type of the given method in the given type. This
-		 * may be different from <tt>m.getGenericReturnType()</tt> when the method
-		 * was declared in a superclass, or <tt>type</tt> has a type parameter that
-		 * is used in the return type, or <tt>type</tt> is a raw type.
+		 * may be different from <code>m.getGenericReturnType()</code> when the method
+		 * was declared in a superclass, or <code>type</code> has a type parameter that
+		 * is used in the return type, or <code>type</code> is a raw type.
 		 */
 		public static Type getExactReturnType(final Method m, final Type type) {
 			final Type returnType = m.getGenericReturnType();
@@ -3587,9 +3587,9 @@ public static Type getExactReturnType(final Method m, final Type type) {
 
 		/**
 		 * Returns the exact type of the given field in the given type. This may be
-		 * different from <tt>f.getGenericType()</tt> when the field was declared in
-		 * a superclass, or <tt>type</tt> has a type parameter that is used in the
-		 * type of the field, or <tt>type</tt> is a raw type.
+		 * different from <code>f.getGenericType()</code> when the field was declared in
+		 * a superclass, or <code>type</code> has a type parameter that is used in the
+		 * type of the field, or <code>type</code> is a raw type.
 		 */
 		public static Type getExactFieldType(final Field f, final Type type) {
 			final Type returnType = f.getGenericType();
@@ -3605,9 +3605,9 @@ public static Type getExactFieldType(final Field f, final Type type) {
 
 		/**
 		 * Returns the exact parameter types of the given method in the given type.
-		 * This may be different from <tt>m.getGenericParameterTypes()</tt> when the
-		 * method was declared in a superclass, or <tt>type</tt> has a type
-		 * parameter that is used in one of the parameters, or <tt>type</tt> is a
+		 * This may be different from <code>m.getGenericParameterTypes()</code> when the
+		 * method was declared in a superclass, or <code>type</code> has a type
+		 * parameter that is used in one of the parameters, or <code>type</code> is a
 		 * raw type.
 		 */
 		public static Type[] getExactParameterTypes(final Method m,
@@ -3666,14 +3666,14 @@ public static Type capture(final Type type) {
 		/**
 		 * Returns list of classes and interfaces that are supertypes of the given
 		 * type. For example given this class:
-		 * <tt>class Foo&lt;A extends Number & Iterable&lt;A&gt;, B extends A&gt;</tt>
+		 * <code>class Foo&lt;A extends Number & Iterable&lt;A&gt;, B extends A&gt;</code>
 		 * <br>
-		 * calling this method on type parameters <tt>B</tt>
-		 * (<tt>Foo.class.getTypeParameters()[1]</tt>) returns a list containing
-		 * <tt>Number</tt> and <tt>Iterable</tt>.
+		 * calling this method on type parameters <code>B</code>
+		 * (<code>Foo.class.getTypeParameters()[1]</code>) returns a list containing
+		 * <code>Number</code> and <code>Iterable</code>.
 		 * <p>
 		 * This is mostly useful if you get a type from one of the other methods in
-		 * <tt>GenericTypeReflector</tt>, but you don't want to deal with all the
+		 * <code>GenericTypeReflector</code>, but you don't want to deal with all the
 		 * different sorts of types, and you are only really interested in concrete
 		 * classes and interfaces.
 		 * </p>
@@ -3719,17 +3719,17 @@ private static void buildUpperBoundClassAndInterfaces(final Type type,
 	private interface CaptureType extends Type {
 
 		/**
-		 * Returns an array of <tt>Type</tt> objects representing the upper bound(s)
+		 * Returns an array of <code>Type</code> objects representing the upper bound(s)
 		 * of this capture. This includes both the upper bound of a
-		 * <tt>? extends</tt> wildcard, and the bounds declared with the type
+		 * <code>? extends</code> wildcard, and the bounds declared with the type
 		 * variable. References to other (or the same) type variables in bounds
 		 * coming from the type variable are replaced by their matching capture.
 		 */
 		Type[] getUpperBounds();
 
 		/**
-		 * Returns an array of <tt>Type</tt> objects representing the lower bound(s)
-		 * of this type variable. This is the bound of a <tt>? super</tt> wildcard.
+		 * Returns an array of <code>Type</code> objects representing the lower bound(s)
+		 * of this type variable. This is the bound of a <code>? super</code> wildcard.
 		 * This normally contains only one or no types; it is an array for
 		 * consistency with {@link WildcardType#getLowerBounds()}.
 		 */