Fixes #5067; move date/time DeserializationFeatures into DateTimeFeature

Author: cowtowncoder

release-notes/VERSION

@@ -9,6 +9,7 @@ Versions: 3.x (for earlier see VERSION-2.x)
 
 #5065: Change default for `DateTimeFeature.ONE_BASED_MONTHS` to `true` in 3.0
 #5066: Move date/time `SerializationFeature`s into `DateTimeFeature` (3.0)
+#5067: Move date/time `DeserializationFeature`s into `DateTimeFeature` (3.0)
 - Branch rename "master" -> "3.x" [JSTEP-12]
 
 3.0.0-rc3 (not yet released)

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

@@ -449,43 +449,6 @@ public enum DeserializationFeature implements ConfigFeature
      */
     READ_UNKNOWN_ENUM_VALUES_USING_DEFAULT_VALUE(false),
 
-    /**
-     * Feature that controls whether numeric timestamp values are expected
-     * to be written using nanosecond timestamps (enabled) or not (disabled),
-     * <b>if and only if</b> datatype supports such resolution.
-     * Only newer datatypes (such as Java8 Date/Time) support such resolution --
-     * older types (pre-Java8 <b>java.util.Date</b> etc) and Joda do not --
-     * and this setting <b>has no effect</b> on such types.
-     *<p>
-     * If disabled, standard millisecond timestamps are assumed.
-     * This is the counterpart to {@link DateTimeFeature#WRITE_DATE_TIMESTAMPS_AS_NANOSECONDS}.
-     *<p>
-     * Feature is enabled by default, to support most accurate time values possible.
-     */
-    READ_DATE_TIMESTAMPS_AS_NANOSECONDS(true),
-
-    /**
-     * Feature that specifies whether context provided {@link java.util.TimeZone}
-     * ({@link DeserializationContext#getTimeZone()} should be used to adjust Date/Time
-     * values on deserialization, even if value itself contains timezone information.
-     * If enabled, contextual <code>TimeZone</code> will essentially override any other
-     * TimeZone information; if disabled, it will only be used if value itself does not
-     * contain any TimeZone information.
-     *<p>
-     * Note that exact behavior depends on date/time types in question; and specifically
-     * JDK type of {@link java.util.Date} does NOT have in-built timezone information
-     * so this setting has no effect.
-     * Further, while {@link java.util.Calendar} does have this information basic
-     * JDK {@link java.text.SimpleDateFormat} is unable to retain parsed zone information,
-     * and as a result, {@link java.util.Calendar} will always get context timezone
-     * adjustment regardless of this setting.
-     *<p>
-     *<p>
-     * Taking above into account, this feature is supported only by extension modules for
-     * Joda and Java 8 date/time datatypes.
-     */
-    ADJUST_DATES_TO_CONTEXT_TIME_ZONE(true),
-
     /*
     /**********************************************************************
     /* Other

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

@@ -28,13 +28,13 @@ public enum MapperFeature
 
     /**
      * Feature that determines whether otherwise regular "getter"
-     * methods (but only ones that handle Collections and Maps,
-     * not getters of other type)
-     * can be used for purpose of getting a reference to a Collection
-     * and Map to modify the property, without requiring a setter
-     * method.
-     * This is similar to how JAXB framework sets Collections and
-     * Maps: no setter is involved, just getter.
+     * methods (but only ones that handle {@link java.util.Collection}s
+     * and {@link java.util.Map}s, not getters of other types)
+     * can be used for purpose of getting a reference to
+     * {@code Collection} / {@code Map} valued properties,
+     * without requiring a setter method.
+     * This is similar to how JAXB framework sets {@code Collection}s
+     * and {@code Map}s: no setter is involved, just getter.
      *<p>
      * Note that such getters-as-setters methods have lower
      * precedence than setters, so they are only used if no

src/main/java/tools/jackson/databind/cfg/DateTimeFeature.java

@@ -1,6 +1,6 @@
 package tools.jackson.databind.cfg;
 
-import tools.jackson.databind.DeserializationFeature;
+import tools.jackson.databind.DeserializationContext;
 
 /**
  * Configurable on/off features to configure Date/Time handling.
@@ -12,6 +12,30 @@
  */
 public enum DateTimeFeature implements DatatypeFeature
 {
+    /**
+     * Feature that specifies whether context provided {@link java.util.TimeZone}
+     * ({@link DeserializationContext#getTimeZone()} should be used to adjust Date/Time
+     * values on deserialization, even if value itself contains timezone information.
+     * If enabled, contextual <code>TimeZone</code> will essentially override any other
+     * TimeZone information; if disabled, it will only be used if value itself does not
+     * contain any TimeZone information.
+     *<p>
+     * Note that exact behavior depends on date/time types in question; and specifically
+     * JDK type of {@link java.util.Date} does NOT have in-built timezone information
+     * so this setting has no effect.
+     * Further, while {@link java.util.Calendar} does have this information basic
+     * JDK {@link java.text.SimpleDateFormat} is unable to retain parsed zone information,
+     * and as a result, {@link java.util.Calendar} will always get context timezone
+     * adjustment regardless of this setting.
+     *<p>
+     * Taking above into account, this feature is supported only by extension modules for
+     * Joda and Java 8 date/time datatypes.
+     *<p>
+     * Feature used to be one of {@link tools.jackson.databind.DeserializationFeature}s
+     * in Jackson 2.x but was moved here in 3.0.
+     */
+    ADJUST_DATES_TO_CONTEXT_TIME_ZONE(true),
+
     /**
      * Feature that controls whether stringified numbers (Strings that without
      * quotes would be legal JSON Numbers) may be interpreted as
@@ -51,6 +75,25 @@ public enum DateTimeFeature implements DatatypeFeature
      */
     ONE_BASED_MONTHS(true),
 
+    /**
+     * Feature that controls whether numeric timestamp values are expected
+     * to be written using nanosecond timestamps (enabled) or not (disabled),
+     * <b>if and only if</b> datatype supports such resolution.
+     * Only newer datatypes (such as Java8 Date/Time) support such resolution --
+     * older types (pre-Java8 <b>java.util.Date</b> etc) and Joda do not --
+     * and this setting <b>has no effect</b> on such types.
+     *<p>
+     * If disabled, standard millisecond timestamps are assumed.
+     * This is the counterpart to {@link DateTimeFeature#WRITE_DATE_TIMESTAMPS_AS_NANOSECONDS}.
+     *<p>
+     * Feature used to be one of {@link tools.jackson.databind.DeserializationFeature}s
+     * in Jackson 2.x but was moved here in 3.0.
+     *<p>
+     * Feature is enabled by default, to support most accurate time values possible (where
+     * available).
+     */
+    READ_DATE_TIMESTAMPS_AS_NANOSECONDS(true),
+
     /**
      * Feature that determines whether the {@link java.util.TimeZone} of the
      * {@link tools.jackson.databind.DeserializationContext} is used
@@ -113,7 +156,7 @@ public enum DateTimeFeature implements DatatypeFeature
      * and this setting <b>has no effect</b> on such types.
      *<p>
      * If disabled, standard millisecond timestamps are assumed.
-     * This is the counterpart to {@link DeserializationFeature#READ_DATE_TIMESTAMPS_AS_NANOSECONDS}.
+     * This is the counterpart to {@link DateTimeFeature#READ_DATE_TIMESTAMPS_AS_NANOSECONDS}.
      *<p>
      * Feature used to be one of {@link tools.jackson.databind.SerializationFeature}s
      * in Jackson 2.x but was moved here in 3.0.

src/main/java/tools/jackson/databind/ext/javatime/JavaTimeInitializer.java

@@ -53,7 +53,7 @@
  * <p>
  * Granularity of timestamps is controlled through the companion features
  * {@link DateTimeFeature#WRITE_DATE_TIMESTAMPS_AS_NANOSECONDS} and
- * {@link DeserializationFeature#READ_DATE_TIMESTAMPS_AS_NANOSECONDS}. For serialization, timestamps are
+ * {@link DateTimeFeature#READ_DATE_TIMESTAMPS_AS_NANOSECONDS}. For serialization, timestamps are
  * written as fractional numbers (decimals), where the number is seconds and the decimal is fractional seconds, if
  * {@code WRITE_DATE_TIMESTAMPS_AS_NANOSECONDS} is enabled (it is by default), with resolution as fine as nanoseconds depending on the
  * underlying JDK implementation. If {@code WRITE_DATE_TIMESTAMPS_AS_NANOSECONDS} is disabled, timestamps are written as a whole number of

src/main/java/tools/jackson/databind/ext/javatime/deser/DurationDeserializer.java

@@ -29,6 +29,7 @@
 import tools.jackson.core.StreamReadCapability;
 import tools.jackson.core.io.NumberInput;
 import tools.jackson.databind.*;
+import tools.jackson.databind.cfg.DateTimeFeature;
 import tools.jackson.databind.ext.javatime.util.DecimalUtils;
 import tools.jackson.databind.ext.javatime.util.DurationUnitConverter;
 
@@ -43,7 +44,7 @@ public class DurationDeserializer extends JSR310DeserializerBase<Duration>
      * When defined (not {@code null}) integer values will be converted into duration
      * unit configured for the converter.
      * Using this converter will typically override the value specified in
-     * {@link DeserializationFeature#READ_DATE_TIMESTAMPS_AS_NANOSECONDS} as it is
+     * {@link DateTimeFeature#READ_DATE_TIMESTAMPS_AS_NANOSECONDS} as it is
      * considered that the unit set in {@link JsonFormat#pattern()} has precedence
      * since it is more specific.
      *<p>
@@ -209,6 +210,6 @@ protected Duration _fromTimestamp(DeserializationContext ctxt, long ts)
 
     protected boolean shouldReadTimestampsAsNanoseconds(DeserializationContext context) {
         return (_readTimestampsAsNanosOverride != null) ? _readTimestampsAsNanosOverride :
-            context.isEnabled(DeserializationFeature.READ_DATE_TIMESTAMPS_AS_NANOSECONDS);
+            context.isEnabled(DateTimeFeature.READ_DATE_TIMESTAMPS_AS_NANOSECONDS);
     }
 }

src/main/java/tools/jackson/databind/ext/javatime/deser/InstantDeserializer.java

@@ -287,12 +287,12 @@ public T deserialize(JsonParser parser, DeserializationContext context)
 
     protected boolean shouldAdjustToContextTimezone(DeserializationContext context) {
         return (_adjustToContextTZOverride != null) ? _adjustToContextTZOverride :
-                context.isEnabled(DeserializationFeature.ADJUST_DATES_TO_CONTEXT_TIME_ZONE);
+                context.isEnabled(DateTimeFeature.ADJUST_DATES_TO_CONTEXT_TIME_ZONE);
     }
 
     protected boolean shouldReadTimestampsAsNanoseconds(DeserializationContext context) {
         return (_readTimestampsAsNanosOverride != null) ? _readTimestampsAsNanosOverride :
-            context.isEnabled(DeserializationFeature.READ_DATE_TIMESTAMPS_AS_NANOSECONDS);
+            context.isEnabled(DateTimeFeature.READ_DATE_TIMESTAMPS_AS_NANOSECONDS);
     }
 
     // Helper method to find Strings of form "all digits" and "digits-comma-digits"

src/main/java/tools/jackson/databind/ext/javatime/deser/LocalDateTimeDeserializer.java

@@ -163,7 +163,7 @@ public LocalDateTime deserialize(JsonParser parser, DeserializationContext conte
 
     protected boolean shouldReadTimestampsAsNanoseconds(DeserializationContext context) {
         return (_readTimestampsAsNanosOverride != null) ? _readTimestampsAsNanosOverride :
-            context.isEnabled(DeserializationFeature.READ_DATE_TIMESTAMPS_AS_NANOSECONDS);
+            context.isEnabled(DateTimeFeature.READ_DATE_TIMESTAMPS_AS_NANOSECONDS);
     }
 
     protected LocalDateTime _fromString(JsonParser p, DeserializationContext ctxt,

src/main/java/tools/jackson/databind/ext/javatime/deser/LocalTimeDeserializer.java

@@ -29,6 +29,7 @@
 import tools.jackson.databind.BeanProperty;
 import tools.jackson.databind.DeserializationContext;
 import tools.jackson.databind.DeserializationFeature;
+import tools.jackson.databind.cfg.DateTimeFeature;
 
 /**
  * Deserializer for Java 8 temporal {@link LocalTime}s.
@@ -167,7 +168,7 @@ public LocalTime deserialize(JsonParser parser, DeserializationContext context)
 
     protected boolean shouldReadTimestampsAsNanoseconds(DeserializationContext context) {
         return (_readTimestampsAsNanosOverride != null) ? _readTimestampsAsNanosOverride :
-            context.isEnabled(DeserializationFeature.READ_DATE_TIMESTAMPS_AS_NANOSECONDS);
+            context.isEnabled(DateTimeFeature.READ_DATE_TIMESTAMPS_AS_NANOSECONDS);
     }
 
     protected LocalTime _fromString(JsonParser p, DeserializationContext ctxt,

src/main/java/tools/jackson/databind/ext/javatime/deser/OffsetTimeDeserializer.java

@@ -25,6 +25,7 @@
 import com.fasterxml.jackson.annotation.JsonFormat;
 import tools.jackson.core.*;
 import tools.jackson.databind.*;
+import tools.jackson.databind.cfg.DateTimeFeature;
 
 /**
  * Deserializer for Java 8 temporal {@link OffsetTime}s.
@@ -172,7 +173,7 @@ public OffsetTime deserialize(JsonParser parser, DeserializationContext context)
 
     protected boolean shouldReadTimestampsAsNanoseconds(DeserializationContext context) {
         return (_readTimestampsAsNanosOverride != null) ? _readTimestampsAsNanosOverride :
-            context.isEnabled(DeserializationFeature.READ_DATE_TIMESTAMPS_AS_NANOSECONDS);
+            context.isEnabled(DateTimeFeature.READ_DATE_TIMESTAMPS_AS_NANOSECONDS);
     }
 
     protected OffsetTime _fromString(JsonParser p, DeserializationContext ctxt,

src/test/java/tools/jackson/databind/deser/jdk/DateDeserializationTest.java

@@ -12,6 +12,7 @@
 import com.fasterxml.jackson.annotation.OptBoolean;
 
 import tools.jackson.databind.*;
+import tools.jackson.databind.cfg.DateTimeFeature;
 import tools.jackson.databind.exc.InvalidFormatException;
 import tools.jackson.databind.exc.MismatchedInputException;
 
@@ -642,7 +643,7 @@ public void testContextTimezone() throws Exception
         final String tzId = "PST";
 
         // this is enabled by default:
-        assertTrue(MAPPER.isEnabled(DeserializationFeature.ADJUST_DATES_TO_CONTEXT_TIME_ZONE));
+        assertTrue(MAPPER.isEnabled(DateTimeFeature.ADJUST_DATES_TO_CONTEXT_TIME_ZONE));
         final ObjectReader r = MAPPER
                 .readerFor(Calendar.class)
                 .with(TimeZone.getTimeZone(tzId));
@@ -662,7 +663,7 @@ public void testContextTimezone() throws Exception
         assertEquals(11, cal.get(Calendar.HOUR_OF_DAY));
 
         // but if disabled, should use what's been sent in:
-        cal = r.without(DeserializationFeature.ADJUST_DATES_TO_CONTEXT_TIME_ZONE)
+        cal = r.without(DateTimeFeature.ADJUST_DATES_TO_CONTEXT_TIME_ZONE)
                 .readValue(q(inputStr));
 
         // 23-Jun-2017, tatu: Actually turns out to be hard if not impossible to do ...

src/test/java/tools/jackson/databind/ext/javatime/TestFeatures.java

@@ -18,7 +18,6 @@
 
 import org.junit.jupiter.api.Test;
 
-import tools.jackson.databind.DeserializationFeature;
 import tools.jackson.databind.cfg.DateTimeFeature;
 
 import static org.junit.jupiter.api.Assertions.*;
@@ -35,14 +34,14 @@ public void testWriteDateTimestampsAsNanosecondsSettingEnabledByDefault()
     @Test
     public void testReadDateTimestampsAsNanosecondsSettingEnabledByDefault()
     {
-        assertTrue(DeserializationFeature.READ_DATE_TIMESTAMPS_AS_NANOSECONDS.enabledByDefault(),
+        assertTrue(DateTimeFeature.READ_DATE_TIMESTAMPS_AS_NANOSECONDS.enabledByDefault(),
                 "Read date timestamps as nanoseconds setting should be enabled by default.");
     }
 
     @Test
     public void testAdjustDatesToContextTimeZoneSettingEnabledByDefault()
     {
-        assertTrue(DeserializationFeature.ADJUST_DATES_TO_CONTEXT_TIME_ZONE.enabledByDefault(),
+        assertTrue(DateTimeFeature.ADJUST_DATES_TO_CONTEXT_TIME_ZONE.enabledByDefault(),
                 "Adjust dates to context time zone setting should be enabled by default.");
     }
 }