Move date/time-related SerializationFeatures into DateTimeFeature (#5085)

Author: cowtowncoder

release-notes/VERSION

@@ -8,6 +8,7 @@ Versions: 3.x (for earlier see VERSION-2.x)
 3.0.0-rc3 (not yet released)
 
 #5065: Change default for `DateTimeFeature.ONE_BASED_MONTHS` to `true` in 3.0
+#5066: Move date/time `SerializationFeature`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

@@ -458,7 +458,7 @@ public enum DeserializationFeature implements ConfigFeature
      * 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 SerializationFeature#WRITE_DATE_TIMESTAMPS_AS_NANOSECONDS}.
+     * 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.
      */

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

@@ -547,6 +547,15 @@ public boolean isEnabled(SerializationFeature f) {
         return _serializationConfig.isEnabled(f);
     }
 
+    /**
+     * Method for checking whether given datatype-specific
+     * feature is enabled.
+     */
+    public boolean isEnabled(DatatypeFeature f) {
+        // could call either config object:
+        return _serializationConfig.isEnabled(f);
+    }
+
     /*
     /**********************************************************************
     /* Configuration, accessing module information

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

@@ -236,9 +236,9 @@ public SerializationConfig with(DateFormat df) {
         SerializationConfig cfg = super.with(df);
         // Also need to toggle this feature based on existence of date format:
         if (df == null) {
-            return cfg.with(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
+            return cfg.with(DateTimeFeature.WRITE_DATES_AS_TIMESTAMPS);
         }
-        return cfg.without(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
+        return cfg.without(DateTimeFeature.WRITE_DATES_AS_TIMESTAMPS);
     }
 
     /*

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

@@ -17,6 +17,7 @@
 import tools.jackson.databind.cfg.ContextAttributes;
 import tools.jackson.databind.cfg.DatatypeFeature;
 import tools.jackson.databind.cfg.DatatypeFeatures;
+import tools.jackson.databind.cfg.DateTimeFeature;
 import tools.jackson.databind.cfg.GeneratorSettings;
 import tools.jackson.databind.exc.InvalidDefinitionException;
 import tools.jackson.databind.exc.InvalidTypeIdException;
@@ -1180,7 +1181,7 @@ public final void defaultSerializeProperty(String propertyName, Object value, Js
     public final void defaultSerializeDateValue(long timestamp, JsonGenerator g)
         throws JacksonException
     {
-        if (isEnabled(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS)) {
+        if (isEnabled(DateTimeFeature.WRITE_DATES_AS_TIMESTAMPS)) {
             g.writeNumber(timestamp);
         } else {
             g.writeString(_dateFormat().format(new Date(timestamp)));
@@ -1197,7 +1198,7 @@ public final void defaultSerializeDateValue(long timestamp, JsonGenerator g)
     public final void defaultSerializeDateValue(Date date, JsonGenerator g)
         throws JacksonException
     {
-        if (isEnabled(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS)) {
+        if (isEnabled(DateTimeFeature.WRITE_DATES_AS_TIMESTAMPS)) {
             g.writeNumber(date.getTime());
         } else {
             g.writeString(_dateFormat().format(date));
@@ -1206,13 +1207,13 @@ public final void defaultSerializeDateValue(Date date, JsonGenerator g)
 
     /**
      * Method that will handle serialization of Dates used as {@link java.util.Map} keys,
-     * based on {@link SerializationFeature#WRITE_DATE_KEYS_AS_TIMESTAMPS}
+     * based on {@link DateTimeFeature#WRITE_DATE_KEYS_AS_TIMESTAMPS}
      * value (and if using textual representation, configured date format)
      */
     public void defaultSerializeDateKey(long timestamp, JsonGenerator g)
         throws JacksonException
     {
-        if (isEnabled(SerializationFeature.WRITE_DATE_KEYS_AS_TIMESTAMPS)) {
+        if (isEnabled(DateTimeFeature.WRITE_DATE_KEYS_AS_TIMESTAMPS)) {
             g.writeName(String.valueOf(timestamp));
         } else {
             g.writeName(_dateFormat().format(new Date(timestamp)));
@@ -1221,12 +1222,12 @@ public void defaultSerializeDateKey(long timestamp, JsonGenerator g)
 
     /**
      * Method that will handle serialization of Dates used as {@link java.util.Map} keys,
-     * based on {@link SerializationFeature#WRITE_DATE_KEYS_AS_TIMESTAMPS}
+     * based on {@link DateTimeFeature#WRITE_DATE_KEYS_AS_TIMESTAMPS}
      * value (and if using textual representation, configured date format)
      */
     public void defaultSerializeDateKey(Date date, JsonGenerator g) throws JacksonException
     {
-        if (isEnabled(SerializationFeature.WRITE_DATE_KEYS_AS_TIMESTAMPS)) {
+        if (isEnabled(DateTimeFeature.WRITE_DATE_KEYS_AS_TIMESTAMPS)) {
             g.writeName(String.valueOf(date.getTime()));
         } else {
             g.writeName(_dateFormat().format(date));

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

@@ -172,110 +172,6 @@ public enum SerializationFeature implements ConfigFeature
     /**********************************************************************
      */
 
-    /**
-     * Feature that determines whether Date (and date/time) values
-     * (and Date-based things like {@link java.util.Calendar}s) are to be
-     * serialized as numeric time stamps (true; the default),
-     * or as something else (usually textual representation).
-     * If textual representation is used, the actual format depends on configuration
-     * settings including possible per-property use of {@code @JsonFormat} annotation,
-     * globally configured {@link java.text.DateFormat}.
-     *<p>
-     * For "classic" JDK date types ({@link java.util.Date}, {@link java.util.Calendar})
-     * the default formatting is provided by {@link tools.jackson.databind.util.StdDateFormat},
-     * and corresponds to format String of "yyyy-MM-dd'T'HH:mm:ss.SSSX"
-     * (see {@link java.text.DateFormat} for details of format Strings).
-     * Whether this feature affects handling of other date-related
-     * types depend on handlers of those types, although ideally they
-     * should use this feature
-     *<p>
-     * Note: whether {@link java.util.Map} keys are serialized as Strings
-     * or not is controlled using {@link #WRITE_DATE_KEYS_AS_TIMESTAMPS} instead of
-     * this feature.
-     *<p>
-     * Feature is disabled by default as of Jackson 3.0 (in 2.x it was enabled),
-     * so that date/time are by default serialized as textual values NOT timestamps.
-     */
-    WRITE_DATES_AS_TIMESTAMPS(false),
-
-    /**
-     * Feature that determines whether {@link java.util.Date}s
-     * (and sub-types) used as {@link java.util.Map} keys are serialized
-     * as time stamps or not (if not, will be serialized as textual values).
-     *<p>
-     * Default value is 'false', meaning that Date-valued Map keys are serialized
-     * as textual (ISO-8601) values.
-     *<p>
-     * Feature is disabled by default.
-     */
-    WRITE_DATE_KEYS_AS_TIMESTAMPS(false),
-
-    /**
-     * Feature that controls whether numeric timestamp values are
-     * 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 DeserializationFeature#READ_DATE_TIMESTAMPS_AS_NANOSECONDS}.
-     *<p>
-     * Feature is enabled by default, to support most accurate time values possible.
-     */
-    WRITE_DATE_TIMESTAMPS_AS_NANOSECONDS(true),
-
-    /**
-     * Feature that determines whether date/date-time values should be serialized
-     * so that they include timezone id, in cases where type itself contains
-     * timezone information. Including this information may lead to compatibility
-     * issues because ISO-8601 specification does not define formats that include
-     * such information.
-     *<p>
-     * If enabled, Timezone id should be included using format specified
-     * with Java 8 <code>DateTimeFormatter#ISO_ZONED_DATE_TIME</code> definition
-     * (for example, '2011-12-03T10:15:30+01:00[Europe/Paris]').
-     *<p>
-     * Note: setting has no relevance if date/time values are serialized as timestamps.
-     *<p>
-     * Feature is disabled by default, so that zone id is NOT included; rather, timezone
-     * offset is used for ISO-8601 compatibility (if any timezone information is
-     * included in value).
-     */
-    WRITE_DATES_WITH_ZONE_ID(false),
-
-    /**
-     * Feature that determines whether timezone/offset included in zoned date/time
-     * values (note: does NOT {@link java.util.Date} will be overridden if there
-     * is an explicitly set context time zone.
-     * If disabled, timezone/offset value is used-is; if enabled, context time zone
-     * is used instead.
-     *<p>
-     * Note that this setting only affects "Zoned" date/time values of
-     * {@code Java 8 date/time} types -- it will have no effect on old
-     * {@link java.util} value handling (of which {@link java.util.Date} has no timezone
-     * information and must use contextual timezone, implicit or explicit; and
-     * {@link java.util.Calendar} which will always use timezone Calendar value has).
-     * Setting is also ignored by Joda date/time values.
-     *<p>
-     * Feature is enabled by default for backwards-compatibility purposes
-     * (from Jackson 2.x)
-     */
-    WRITE_DATES_WITH_CONTEXT_TIME_ZONE(true),
-
-    /**
-     * Feature that determines whether time values that represents time periods
-     * (durations, periods, ranges) are to be serialized by default using
-     * a numeric (true) or textual (false) representations. Note that numeric
-     * representation may mean either simple number, or an array of numbers,
-     * depending on type.
-     *<p>
-     * Feature is disabled by default as of Jackson 3.0 (in 2.x it was enabled),
-     * so that period/duration are by default serialized as textual values,
-     * NOT timestamps.
-     */
-    WRITE_DURATIONS_AS_TIMESTAMPS(false),
-
     /**
      * Feature that determines how type <code>char[]</code> is serialized:
      * when enabled, will be serialized as an explict JSON array (with

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

@@ -1,5 +1,7 @@
 package tools.jackson.databind.cfg;
 
+import tools.jackson.databind.DeserializationFeature;
+
 /**
  * Configurable on/off features to configure Date/Time handling.
  * Mostly used to configure
@@ -58,8 +60,128 @@ public enum DateTimeFeature implements DatatypeFeature
      * Default setting is disabled, for backwards-compatibility with
      * Jackson 2.18.
      */
-    USE_TIME_ZONE_FOR_LENIENT_DATE_PARSING(false)
+    USE_TIME_ZONE_FOR_LENIENT_DATE_PARSING(false),
+
+    /**
+     * Feature that determines whether Date (and date/time) values
+     * (and Date-based things like {@link java.util.Calendar}s) are to be
+     * serialized as numeric time stamps (true; the default),
+     * or as something else (usually textual representation).
+     * If textual representation is used, the actual format depends on configuration
+     * settings including possible per-property use of {@code @JsonFormat} annotation,
+     * globally configured {@link java.text.DateFormat}.
+     *<p>
+     * For "classic" JDK date types ({@link java.util.Date}, {@link java.util.Calendar})
+     * the default formatting is provided by {@link tools.jackson.databind.util.StdDateFormat},
+     * and corresponds to format String of "yyyy-MM-dd'T'HH:mm:ss.SSSX"
+     * (see {@link java.text.DateFormat} for details of format Strings).
+     * Whether this feature affects handling of other date-related
+     * types depend on handlers of those types, although ideally they
+     * should use this feature
+     *<p>
+     * Note: whether {@link java.util.Map} keys are serialized as Strings
+     * or not is controlled using {@link #WRITE_DATE_KEYS_AS_TIMESTAMPS} instead of
+     * this feature.
+     *<p>
+     * Feature used to be one of {@link tools.jackson.databind.SerializationFeature}s
+     * in Jackson 2.x but was moved here in 3.0.
+     *<p>
+     * Feature is disabled by default as of Jackson 3.0 (in 2.x it was enabled),
+     * so that date/time are by default serialized as textual values NOT timestamps.
+     */
+    WRITE_DATES_AS_TIMESTAMPS(false),
 
+    /**
+     * Feature that determines whether {@link java.util.Date}s
+     * (and sub-types) used as {@link java.util.Map} keys are serialized
+     * as time stamps or not (if not, will be serialized as textual values).
+     *<p>
+     * Feature used to be one of {@link tools.jackson.databind.SerializationFeature}s
+     * in Jackson 2.x but was moved here in 3.0.
+     *<p>
+     * Feature is disabled by default, meaning that Date-valued Map keys are serialized
+     * as textual (ISO-8601) values.
+     */
+    WRITE_DATE_KEYS_AS_TIMESTAMPS(false),
+
+    /**
+     * Feature that controls whether numeric timestamp values are
+     * 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 DeserializationFeature#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.
+     *<p>
+     * Feature is enabled by default, to support most accurate time values possible.
+     */
+    WRITE_DATE_TIMESTAMPS_AS_NANOSECONDS(true),
+
+    /**
+     * Feature that determines whether timezone/offset included in zoned date/time
+     * values (note: does NOT {@link java.util.Date} will be overridden if there
+     * is an explicitly set context time zone.
+     * If disabled, timezone/offset value is used-is; if enabled, context time zone
+     * is used instead.
+     *<p>
+     * Note that this setting only affects "Zoned" date/time values of
+     * {@code Java 8 date/time} types -- it will have no effect on old
+     * {@link java.util} value handling (of which {@link java.util.Date} has no timezone
+     * information and must use contextual timezone, implicit or explicit; and
+     * {@link java.util.Calendar} which will always use timezone Calendar value has).
+     * Setting is also ignored by Joda date/time values.
+     *<p>
+     * Feature used to be one of {@link tools.jackson.databind.SerializationFeature}s
+     * in Jackson 2.x but was moved here in 3.0.
+     *<p>
+     * Feature is enabled by default for backwards-compatibility purposes
+     * (from Jackson 2.x)
+     */
+    WRITE_DATES_WITH_CONTEXT_TIME_ZONE(true),
+
+    /**
+     * Feature that determines whether date/date-time values should be serialized
+     * so that they include timezone id, in cases where type itself contains
+     * timezone information. Including this information may lead to compatibility
+     * issues because ISO-8601 specification does not define formats that include
+     * such information.
+     *<p>
+     * If enabled, Timezone id should be included using format specified
+     * with Java 8 <code>DateTimeFormatter#ISO_ZONED_DATE_TIME</code> definition
+     * (for example, '2011-12-03T10:15:30+01:00[Europe/Paris]').
+     *<p>
+     * Note: setting has no relevance if date/time values are serialized as timestamps.
+     *<p>
+     * Feature used to be one of {@link tools.jackson.databind.SerializationFeature}s
+     * in Jackson 2.x but was moved here in 3.0.
+     *<p>
+     * Feature is disabled by default, so that zone id is NOT included; rather, timezone
+     * offset is used for ISO-8601 compatibility (if any timezone information is
+     * included in value).
+     */
+    WRITE_DATES_WITH_ZONE_ID(false),
+
+    /**
+     * Feature that determines whether time values that represents time periods
+     * (durations, periods, ranges) are to be serialized by default using
+     * a numeric (true) or textual (false) representations. Note that numeric
+     * representation may mean either simple number, or an array of numbers,
+     * depending on type.
+     *<p>
+     * Feature used to be one of {@link tools.jackson.databind.SerializationFeature}s
+     * in Jackson 2.x but was moved here in 3.0.
+     *<p>
+     * Feature is disabled by default as of Jackson 3.0 (in 2.x it was enabled),
+     * so that period/duration are by default serialized as textual values,
+     * NOT timestamps.
+     */
+    WRITE_DURATIONS_AS_TIMESTAMPS(false),
+    
     ;
 
     private final static int FEATURE_INDEX = DatatypeFeatures.FEATURE_INDEX_DATETIME;

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

@@ -811,13 +811,13 @@ public B configureForJackson2() {
         return enable(MapperFeature.ALLOW_FINAL_FIELDS_AS_MUTATORS)
                 .disable(MapperFeature.SORT_PROPERTIES_ALPHABETICALLY)
                 .enable(MapperFeature.USE_GETTERS_AS_SETTERS)
-                .disable(DeserializationFeature.FAIL_ON_NULL_FOR_PRIMITIVES)
-                .disable(DeserializationFeature.FAIL_ON_TRAILING_TOKENS)
+                .disable(DeserializationFeature.FAIL_ON_NULL_FOR_PRIMITIVES,
+                        DeserializationFeature.FAIL_ON_TRAILING_TOKENS)
                 .enable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)
                 .disable(DeserializationFeature.READ_ENUMS_USING_TO_STRING)
                 .enable(SerializationFeature.FAIL_ON_EMPTY_BEANS)
-                .enable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS)
-                .enable(SerializationFeature.WRITE_DURATIONS_AS_TIMESTAMPS)
+                .enable(DateTimeFeature.WRITE_DATES_AS_TIMESTAMPS,
+                        DateTimeFeature.WRITE_DURATIONS_AS_TIMESTAMPS)
                 .disable(SerializationFeature.WRITE_ENUMS_USING_TO_STRING)
                 .disable(DateTimeFeature.ONE_BASED_MONTHS)
                 ;
@@ -1416,7 +1416,7 @@ public B addAbstractTypeResolver(AbstractTypeResolver resolver) {
      */
     public B defaultDateFormat(DateFormat f) {
         _baseSettings = _baseSettings.with(f);
-        configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, (f == null));
+        configure(DateTimeFeature.WRITE_DATES_AS_TIMESTAMPS, (f == null));
         return _this();
     }