Javadoc cleanup to remove obsolete references to Jackson 1.x versions

cowtowncoder · cowtowncoder · commit 19c9dc7a0056 · 2015-09-23T16:53:36.000-07:00
diff --git a/src/main/java/com/fasterxml/jackson/databind/AnnotationIntrospector.java b/src/main/java/com/fasterxml/jackson/databind/AnnotationIntrospector.java
@@ -111,7 +111,7 @@ public static AnnotationIntrospector pair(AnnotationIntrospector a1, AnnotationI
 
     /*
     /**********************************************************
-    /* Access to possibly chained introspectors (1.7)
+    /* Access to possibly chained introspectors
     /**********************************************************
      */
 
diff --git a/src/main/java/com/fasterxml/jackson/databind/annotation/JsonSerialize.java b/src/main/java/com/fasterxml/jackson/databind/annotation/JsonSerialize.java
@@ -222,8 +222,7 @@ public enum Inclusion
          * <li>For Java arrays, empty arrays are ones with length of 0
          *   </li>
          * <li>For Java {@link java.lang.String}s, <code>length()</code> is called,
-         *   and return value of 0 indicates empty String (note that <code>String.isEmpty()</code>
-         *   was added in Java 1.6 and as such can not be used by Jackson
+         *   and return value of 0 indicates empty String
          *   </li>
          * </ul>
          *  For other types, non-null values are to be included.
diff --git a/src/main/java/com/fasterxml/jackson/databind/deser/BasicDeserializerFactory.java b/src/main/java/com/fasterxml/jackson/databind/deser/BasicDeserializerFactory.java
@@ -80,15 +80,15 @@ public abstract class BasicDeserializerFactory
         _collectionFallbacks.put(SortedSet.class.getName(), TreeSet.class);
         _collectionFallbacks.put(Queue.class.getName(), LinkedList.class);
 
-        // then 1.6 types:
-        /* 17-May-2013, tatu: [Issue#216] Should be fine to use straight Class references EXCEPT
-         *   that some godforsaken platforms (... looking at you, Android) do not
+        // then JDK 1.6 types:
+        /* 17-May-2013, tatu: [databind#216] Should be fine to use straight Class references EXCEPT
+         *   that some god-forsaken platforms (... looking at you, Android) do not
          *   include these. So, use "soft" references...
          */
         _collectionFallbacks.put("java.util.Deque", LinkedList.class);
         _collectionFallbacks.put("java.util.NavigableSet", TreeSet.class);
     }
-    
+
     /*
     /**********************************************************
     /* Config
@@ -100,7 +100,7 @@ public abstract class BasicDeserializerFactory
      * factory), new version created via copy-constructor (fluent-style)
      */
     protected final DeserializerFactoryConfig _factoryConfig;
-    
+
     /*
     /**********************************************************
     /* Life cycle
diff --git a/src/main/java/com/fasterxml/jackson/databind/deser/BeanDeserializerFactory.java b/src/main/java/com/fasterxml/jackson/databind/deser/BeanDeserializerFactory.java
@@ -116,7 +116,7 @@ public JsonDeserializer<Object> createBeanDeserializer(DeserializationContext ct
          * (defaulting, materialization)
          */
         if (type.isAbstract()) {
-            // [JACKSON-41] (v1.6): Let's make it possible to materialize abstract types.
+            // Let's make it possible to materialize abstract types.
             JavaType concreteType = materializeAbstractType(ctxt, type, beanDesc);
             if (concreteType != null) {
                 /* important: introspect actual implementation (abstract class or
diff --git a/src/main/java/com/fasterxml/jackson/databind/deser/std/NumberDeserializers.java b/src/main/java/com/fasterxml/jackson/databind/deser/std/NumberDeserializers.java
@@ -178,7 +178,7 @@ public Boolean deserialize(JsonParser j, DeserializationContext ctxt) throws IOE
             return _parseBoolean(j, ctxt);
         }
 
-        // 1.6: since we can never have type info ("natural type"; String, Boolean, Integer, Double):
+        // Since we can never have type info ("natural type"; String, Boolean, Integer, Double):
         // (is it an error to even call this version?)
         @Override
         public Boolean deserializeWithType(JsonParser p, DeserializationContext ctxt,
@@ -309,7 +309,7 @@ public Integer deserialize(JsonParser p, DeserializationContext ctxt) throws IOE
             return _parseInteger(p, ctxt);
         }
 
-        // 1.6: since we can never have type info ("natural type"; String, Boolean, Integer, Double):
+        // Since we can never have type info ("natural type"; String, Boolean, Integer, Double):
         // (is it an error to even call this version?)
         @Override
         public Integer deserializeWithType(JsonParser p, DeserializationContext ctxt,
@@ -386,7 +386,7 @@ public Double deserialize(JsonParser jp, DeserializationContext ctxt) throws IOE
             return _parseDouble(jp, ctxt);
         }
 
-        // 1.6: since we can never have type info ("natural type"; String, Boolean, Integer, Double):
+        // Since we can never have type info ("natural type"; String, Boolean, Integer, Double):
         // (is it an error to even call this version?)
         @Override
         public Double deserializeWithType(JsonParser jp, DeserializationContext ctxt,
@@ -400,7 +400,7 @@ public Double deserializeWithType(JsonParser jp, DeserializationContext ctxt,
      * For type <code>Number.class</code>, we can just rely on type
      * mappings that plain {@link JsonParser#getNumberValue} returns.
      *<p>
-     * Since 1.5, there is one additional complication: some numeric
+     * There is one additional complication: some numeric
      * types (specifically, int/Integer and double/Double) are "non-typed";
      * meaning that they will NEVER be output with type information.
      * But other numeric types may need such type information.
diff --git a/src/main/java/com/fasterxml/jackson/databind/deser/std/StdDeserializer.java b/src/main/java/com/fasterxml/jackson/databind/deser/std/StdDeserializer.java
@@ -808,10 +808,9 @@ protected java.util.Date _parseDate(JsonParser jp, DeserializationContext ctxt)
      */
     protected final static double parseDouble(String numStr) throws NumberFormatException
     {
-        // [JACKSON-486]: avoid some nasty float representations... but should it be MIN_NORMAL or MIN_VALUE?
-        // for now, MIN_VALUE, since MIN_NORMAL is JDK 1.6
+        // avoid some nasty float representations... but should it be MIN_NORMAL or MIN_VALUE?
         if (NumberInput.NASTY_SMALL_DOUBLE.equals(numStr)) {
-            return Double.MIN_VALUE;
+            return Double.MIN_NORMAL; // since 2.7; was MIN_VALUE prior
         }
         return Double.parseDouble(numStr);
     }
@@ -937,7 +936,7 @@ protected Object _coerceIntegral(JsonParser p, DeserializationContext ctxt) thro
      * 
      * @param type Type of property to deserialize
      * @param property Actual property object (field, method, constuctor parameter) used
-     *     for passing deserialized values; provided so deserializer can be contextualized if necessary (since 1.7)
+     *     for passing deserialized values; provided so deserializer can be contextualized if necessary
      */
     protected JsonDeserializer<Object> findDeserializer(DeserializationContext ctxt,
             JavaType type, BeanProperty property)
diff --git a/src/main/java/com/fasterxml/jackson/databind/deser/std/StringDeserializer.java b/src/main/java/com/fasterxml/jackson/databind/deser/std/StringDeserializer.java
@@ -62,7 +62,7 @@ public String deserialize(JsonParser jp, DeserializationContext ctxt) throws IOE
         throw ctxt.mappingException(_valueClass, curr);
     }
 
-    // 1.6: since we can never have type info ("natural type"; String, Boolean, Integer, Double):
+    // Since we can never have type info ("natural type"; String, Boolean, Integer, Double):
     // (is it an error to even call this version?)
     @Override
     public String deserializeWithType(JsonParser jp, DeserializationContext ctxt, TypeDeserializer typeDeserializer) throws IOException {
diff --git a/src/main/java/com/fasterxml/jackson/databind/ext/OptionalHandlerFactory.java b/src/main/java/com/fasterxml/jackson/databind/ext/OptionalHandlerFactory.java
@@ -18,7 +18,7 @@ public class OptionalHandlerFactory implements java.io.Serializable
 {
     private static final long serialVersionUID = 1;
 
-    /* 1.6.1+ To make 2 main "optional" handler groups (javax.xml.stream)
+    /* To make 2 main "optional" handler groups (javax.xml.stream)
      * more dynamic, we better only figure out handlers completely dynamically, if and
      * when they are needed. To do this we need to assume package prefixes.
      */
diff --git a/src/main/java/com/fasterxml/jackson/databind/introspect/AnnotatedClass.java b/src/main/java/com/fasterxml/jackson/databind/introspect/AnnotatedClass.java
@@ -1068,8 +1068,8 @@ protected Method[] _findClassMethods(Class<?> cls)
             try {
                 contextClass = loader.loadClass(cls.getName());
             } catch (ClassNotFoundException e) {
-                // !!! TODO: 08-May-2015, tatu: Chain appropriately once we have JDK7 as baseline
-                //ex.addSuppressed(e); Not until 1.7
+                // !!! TODO: 08-May-2015, tatu: Chain appropriately once we have JDK 1.7/Java7 as baseline
+                //ex.addSuppressed(e); Not until Jackson 2.7
                throw ex;
             }
             return contextClass.getDeclaredMethods(); // Cross fingers
diff --git a/src/main/java/com/fasterxml/jackson/databind/ser/BeanPropertyWriter.java b/src/main/java/com/fasterxml/jackson/databind/ser/BeanPropertyWriter.java
@@ -326,7 +326,7 @@ protected BeanPropertyWriter(BeanPropertyWriter base, PropertyName name)
 
         _serializer = base._serializer;
         _nullSerializer = base._nullSerializer;
-        // one more thing: copy internal settings, if any (since 1.7)
+        // one more thing: copy internal settings, if any
         if (base._internalSettings != null) {
             _internalSettings = new HashMap<Object,Object>(base._internalSettings);
         }
diff --git a/src/main/java/com/fasterxml/jackson/databind/ser/std/TokenBufferSerializer.java b/src/main/java/com/fasterxml/jackson/databind/ser/std/TokenBufferSerializer.java
@@ -28,7 +28,7 @@ public class TokenBufferSerializer
 
     @Override
     public void serialize(TokenBuffer value, JsonGenerator jgen, SerializerProvider provider)
-        throws IOException, JsonGenerationException
+            throws IOException
     {
         value.serialize(jgen);
     }
@@ -39,16 +39,13 @@ public void serialize(TokenBuffer value, JsonGenerator jgen, SerializerProvider
      * we do know when serializing, but not necessarily when deserializing!)
      * One possibility would be to check the current token, and use that to
      * determine if we would output JSON Array, Object or scalar value.
-     * Jackson 1.5 did NOT include any type information; but this seems wrong,
-     * and so 1.6 WILL include type information.
      *<p>
      * Note that we just claim it is scalar; this should work ok and is simpler
      * than doing introspection on both serialization and deserialization.
      */
     @Override
     public final void serializeWithType(TokenBuffer value, JsonGenerator jgen, SerializerProvider provider,
-            TypeSerializer typeSer)
-        throws IOException, JsonGenerationException
+            TypeSerializer typeSer) throws IOException
     {
         typeSer.writeTypePrefixForScalar(value, jgen);
         serialize(value, jgen, provider);
@@ -58,21 +55,17 @@ public final void serializeWithType(TokenBuffer value, JsonGenerator jgen, Seria
     @Override
     public JsonNode getSchema(SerializerProvider provider, Type typeHint)
     {
-        /* 01-Jan-2010, tatu: Not 100% sure what we should say here:
-         *   type is basically not known. This seems closest
-         *   approximation
-         */
+        // Not 100% sure what we should say here: type is basically not known.
+        // This seems like closest approximation
         return createSchemaNode("any", true);
     }
     
     @Override
     public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
         throws JsonMappingException
     {
-        /* 01-Jan-2010, tatu: Not 100% sure what we should say here:
-         *   type is basically not known. This seems closest
-         *   approximation
-         */
+        // Not 100% sure what we should say here: type is basically not known.
+        // This seems like closest approximation
         visitor.expectAnyFormat(typeHint);
     }
 }    
diff --git a/src/main/java/com/fasterxml/jackson/databind/type/CollectionType.java b/src/main/java/com/fasterxml/jackson/databind/type/CollectionType.java
@@ -55,13 +55,11 @@ public static CollectionType construct(Class<?> rawType, JavaType elemT)
         return new CollectionType(rawType, elemT, null, null, false);
     }
 
-    // Since 1.7:
     @Override
     public CollectionType withTypeHandler(Object h) {
         return new CollectionType(_class, _elementType, _valueHandler, h, _asStatic);
     }
 
-    // Since 1.7:
     @Override
     public CollectionType withContentTypeHandler(Object h)
     {
diff --git a/src/main/java/com/fasterxml/jackson/databind/util/EmptyIterator.java b/src/main/java/com/fasterxml/jackson/databind/util/EmptyIterator.java
@@ -5,7 +5,7 @@
 
 /**
  * Implementation of {@link Iterator} for Empty collections.
- * While JDK has an implementation starting with 1.7, we need this
+ * While JDK has an implementation starting with JDK 1.7 / Java 7, we need this
  * class until then.
  * 
  * @since 2.2 (before, we had embedded instances)

Original file line number	Diff line number	Diff line change
`@@ -808,10 +808,9 @@ protected java.util.Date _parseDate(JsonParser jp, DeserializationContext ctxt)`
`808`	`808`	`*/`
`809`	`809`	`protected final static double parseDouble(String numStr) throws NumberFormatException`
`810`	`810`	`{`
`811`		`- // [JACKSON-486]: avoid some nasty float representations... but should it be MIN_NORMAL or MIN_VALUE?`
`812`		`- // for now, MIN_VALUE, since MIN_NORMAL is JDK 1.6`
	`811`	`+ // avoid some nasty float representations... but should it be MIN_NORMAL or MIN_VALUE?`
`813`	`812`	`if (NumberInput.NASTY_SMALL_DOUBLE.equals(numStr)) {`
`814`		`- return Double.MIN_VALUE;`
	`813`	`+ return Double.MIN_NORMAL; // since 2.7; was MIN_VALUE prior`
`815`	`814`	`}`
`816`	`815`	`return Double.parseDouble(numStr);`
`817`	`816`	`}`
`@@ -937,7 +936,7 @@ protected Object _coerceIntegral(JsonParser p, DeserializationContext ctxt) thro`
`937`	`936`	`*`
`938`	`937`	`* @param type Type of property to deserialize`
`939`	`938`	`* @param property Actual property object (field, method, constuctor parameter) used`
`940`		`- * for passing deserialized values; provided so deserializer can be contextualized if necessary (since 1.7)`
	`939`	`+ * for passing deserialized values; provided so deserializer can be contextualized if necessary`
`941`	`940`	`*/`
`942`	`941`	`protected JsonDeserializer<Object> findDeserializer(DeserializationContext ctxt,`
`943`	`942`	`JavaType type, BeanProperty property)`
Original file line number	Diff line number	Diff line change
`@@ -62,7 +62,7 @@ public String deserialize(JsonParser jp, DeserializationContext ctxt) throws IOE`
`62`	`62`	`throw ctxt.mappingException(_valueClass, curr);`
`63`	`63`	`}`
`64`	`64`
`65`		`- // 1.6: since we can never have type info ("natural type"; String, Boolean, Integer, Double):`
	`65`	`+ // Since we can never have type info ("natural type"; String, Boolean, Integer, Double):`
`66`	`66`	`// (is it an error to even call this version?)`
`67`	`67`	`@Override`
`68`	`68`	`public String deserializeWithType(JsonParser jp, DeserializationContext ctxt, TypeDeserializer typeDeserializer) throws IOException {`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ public class OptionalHandlerFactory implements java.io.Serializable`
`18`	`18`	`{`
`19`	`19`	`private static final long serialVersionUID = 1;`
`20`	`20`
`21`		`- /* 1.6.1+ To make 2 main "optional" handler groups (javax.xml.stream)`
	`21`	`+ /* To make 2 main "optional" handler groups (javax.xml.stream)`
`22`	`22`	`* more dynamic, we better only figure out handlers completely dynamically, if and`
`23`	`23`	`* when they are needed. To do this we need to assume package prefixes.`
`24`	`24`	`*/`
Original file line number	Diff line number	Diff line change
`@@ -326,7 +326,7 @@ protected BeanPropertyWriter(BeanPropertyWriter base, PropertyName name)`
`326`	`326`
`327`	`327`	`_serializer = base._serializer;`
`328`	`328`	`_nullSerializer = base._nullSerializer;`
`329`		`- // one more thing: copy internal settings, if any (since 1.7)`
	`329`	`+ // one more thing: copy internal settings, if any`
`330`	`330`	`if (base._internalSettings != null) {`
`331`	`331`	`_internalSettings = new HashMap<Object,Object>(base._internalSettings);`
`332`	`332`	`}`