Merge branch '2.19'

pom.xml

@@ -227,8 +227,9 @@
         <artifactId>maven-javadoc-plugin</artifactId>
         <configuration>
           <links combine.children="append">
-            <link>https://fasterxml.github.io/jackson-annotations/javadoc/3.0.2021-01</link>
-            <link>https://fasterxml.github.io/jackson-core/javadoc/3.0.2021-01</link>
+	    <!-- 13-Feb-2025, tatu: Need to update on 3.0.0-rc1 release! -->
+            <link>https://javadoc.io/doc/com.fasterxml.jackson.core/jackson-annotations/latest</link>
+            <link>https://javadoc.io/doc/com.fasterxml.jackson.core/jackson-core/latest</link>
           </links>
         </configuration>
       </plugin>

src/main/java/tools/jackson/databind/JsonNode.java

@@ -838,7 +838,8 @@ public double asDouble(double defaultValue) {
      * this node is numeric ({@link #isNumber} returns true). For other
      * types returns <code>BigDecimal.ZERO</code>.
      *
-     * @return {@link BigDecimal} value this node contains, if numeric node; <code>BigDecimal.ZERO</code> for non-number nodes.
+     * @return {@link BigDecimal} value this node contains, if numeric node;
+     *   {@code BigDecimal.ZERO} for non-number nodes.
      */
     public BigDecimal decimalValue() { return BigDecimal.ZERO; }
 

src/main/java/tools/jackson/databind/ValueDeserializer.java

@@ -117,7 +117,7 @@ public ValueDeserializer<?> createContextual(DeserializationContext ctxt,
      *          ...
      *      }
      *  </pre>
-     *  Jackson consumes the two tokens (the <tt>@class</tt> field name
+     *  Jackson consumes the two tokens (the {@code @class} field name
      *  and its value) in order to learn the class and select the deserializer.
      *  Thus, the stream is pointing to the FIELD_NAME for the first field
      *  after the @class. Thus, if you want your method to work correctly

src/main/java/tools/jackson/databind/deser/DeserializerFactory.java

@@ -35,7 +35,6 @@
  *  </li>
  * <li>For all other types, {@link #createBeanDeserializer} is used.
  * </ul>
- *<p>
  */
 public abstract class DeserializerFactory
 {

src/main/java/tools/jackson/databind/jsontype/BasicPolymorphicTypeValidator.java

@@ -17,6 +17,7 @@
  *<br>
  * For example:
  *<pre>
+ *  [ADD EXAMPLE HERE]
  *</pre>
  */
 public class BasicPolymorphicTypeValidator

src/main/java/tools/jackson/databind/node/ContainerNode.java

@@ -195,7 +195,7 @@ public final NumericNode numberNode(long v) {
      * Short-cut for:
      *<pre>
      *     removeIf(JsonNode::isNull);
-     *<pre>
+     *</pre>
      *
      * @return Container node itself (to allow method call chaining)
      *

src/main/java/tools/jackson/databind/type/TypeFactory.java

@@ -980,11 +980,10 @@ public JavaType constructReferenceType(Class<?> rawType, JavaType referredType)
     /**
      * Factory method for constructing {@link JavaType} that
      * represents a parameterized type. For example, to represent
-     * type {@code List<Set<Integer>>}, you could
+     * type {@code Foo<Bar, Baz>}, you could
      * call
      *<pre>
-     *  JavaType inner = TypeFactory.constructParametricType(Set.class, Integer.class);
-     *  return TypeFactory.constructParametricType(List.class, inner);
+     *  return typeFactory.constructParametricType(Foo.class, Bar.class, Baz.class);
      *</pre>
      *
      * @param parametrized Type-erased type to parameterize
@@ -1004,8 +1003,8 @@ public JavaType constructParametricType(Class<?> parametrized, Class<?>... param
      * represents a parameterized type. For example, to represent
      * type {@code List<Set<Integer>>}, you could
      *<pre>
-     *  JavaType inner = TypeFactory.constructParametricType(Set.class, Integer.class);
-     *  return TypeFactory.constructParametricType(List.class, inner);
+     *  JavaType inner = typeFactory.constructParametricType(Set.class, Integer.class);
+     *  return typeFactory.constructParametricType(List.class, inner);
      *</pre>
      *
      * @param rawType Actual type-erased type
@@ -1025,7 +1024,7 @@ public JavaType constructParametricType(Class<?> rawType, JavaType... parameterT
      * is useful if you already have the type's parameters such
      * as those found on {@link JavaType}. For example, you could call
      * <pre>
-     *   return TypeFactory.constructParametricType(ArrayList.class, javaType.getBindings());
+     *   return typeFactory.constructParametricType(ArrayList.class, javaType.getBindings());
      * </pre>
      * This effectively applies the parameterized types from one
      * {@link JavaType} to another class.

src/main/java/tools/jackson/databind/util/internal/PrivateMaxEntriesMap.java

@@ -46,12 +46,12 @@
  * concurrency for updates, and a maximum capacity to bound the map by. This
  * implementation differs from {@link ConcurrentHashMap} in that it maintains a
  * page replacement algorithm that is used to evict an entry when the map has
- * exceeded its capacity. Unlike the <tt>Java Collections Framework</tt>, this
+ * exceeded its capacity. Unlike the {@code Java Collections Framework}, this
  * map does not have a publicly visible constructor and instances are created
  * through a {@link Builder}.
  * <p>
  * An entry is evicted from the map when the entry size exceeds
- * its <tt>maximum capacity</tt> threshold.
+ * its {@code maximum capacity} threshold.
  * <p>
  * An {@code EvictionListener} may be supplied for notification when an entry
  * is evicted from the map. This listener is invoked on a caller's thread and
@@ -62,7 +62,7 @@
  * operation asynchronously, such as by submitting a task to an
  * {@link java.util.concurrent.ExecutorService}.
  * <p>
- * The <tt>concurrency level</tt> determines the number of threads that can
+ * The {@code concurrency level} determines the number of threads that can
  * concurrently modify the table. Using a significantly higher or lower value
  * than needed can waste space or lead to thread contention, but an estimate
  * within an order of magnitude of the ideal value does not usually have a
@@ -74,7 +74,7 @@
  * interfaces.
  * <p>
  * Like {@link java.util.Hashtable} but unlike {@link HashMap}, this class
- * does <em>not</em> allow <tt>null</tt> to be used as a key or value. Unlike
+ * does <em>not</em> allow {@code null} to be used as a key or value. Unlike
  * {@link java.util.LinkedHashMap}, this class does <em>not</em> provide
  * predictable iteration order. A snapshot of the keys and entries may be
  * obtained in ascending and descending order of retention.
@@ -447,8 +447,8 @@ void drainWriteBuffer() {
     }
 
     /**
-     * Attempts to transition the node from the <tt>alive</tt> state to the
-     * <tt>retired</tt> state.
+     * Attempts to transition the node from the {@code alive} state to the
+     * {@code retired} state.
      *
      * @param node the entry in the page replacement policy
      * @param expect the expected weighted value
@@ -463,8 +463,8 @@ boolean tryToRetire(Node<K, V> node, WeightedValue<V> expect) {
     }
 
     /**
-     * Atomically transitions the node from the <tt>alive</tt> state to the
-     * <tt>retired</tt> state, if a valid transition.
+     * Atomically transitions the node from the {@code alive} state to the
+     * {@code retired} state, if a valid transition.
      *
      * @param node the entry in the page replacement policy
      */
@@ -482,8 +482,8 @@ void makeRetired(Node<K, V> node) {
     }
 
     /**
-     * Atomically transitions the node to the <tt>dead</tt> state and decrements
-     * the <tt>weightedSize</tt>.
+     * Atomically transitions the node to the {@code dead} state and decrements
+     * the {@code weightedSize}.
      *
      * @param node the entry in the page replacement policy
      */
@@ -895,7 +895,7 @@ public void setNext(Node<K, V> next) {
             this.next = next;
         }
 
-        /** Retrieves the value held by the current <tt>WeightedValue</tt>. */
+        /** Retrieves the value held by the current {@code WeightedValue}. */
         V getValue() {
             return get().value;
         }
@@ -1168,7 +1168,7 @@ public Builder() {
         }
 
         /**
-         * Specifies the initial capacity of the hash table (default <tt>16</tt>).
+         * Specifies the initial capacity of the hash table (default {@code 16}).
          * This is the number of key-value pairs that the hash table can hold
          * before a resize operation is required.
          *
@@ -1198,7 +1198,7 @@ public Builder<K, V> maximumCapacity(long capacity) {
         /**
          * Specifies the estimated number of concurrently updating threads. The
          * implementation performs internal sizing to try to accommodate this many
-         * threads (default <tt>16</tt>).
+         * threads (default {@code 16}).
          *
          * @param concurrencyLevel the estimated number of concurrently updating
          *     threads

src/main/java/tools/jackson/databind/util/internal/package-info.java

@@ -24,7 +24,7 @@
  * <p>
  * The {@link tools.jackson.databind.util.internal.PrivateMaxEntriesMap}
  * class supplies an efficient, scalable, thread-safe, bounded map. As with the
- * <tt>Java Collections Framework</tt> the "Concurrent" prefix is used to
+ * {@code Java Collections Framework} the "Concurrent" prefix is used to
  * indicate that the map is not governed by a single exclusion lock.
  *
  * @see <a href="http://code.google.com/p/concurrentlinkedhashmap/">