Move jackson-datatype-jsr310 into jackson-databind

src/main/java/module-info.java

@@ -35,6 +35,11 @@
     exports tools.jackson.databind.deser.std;
     exports tools.jackson.databind.exc;
     exports tools.jackson.databind.ext;
+    exports tools.jackson.databind.ext.javatime;
+    exports tools.jackson.databind.ext.javatime.deser;
+    exports tools.jackson.databind.ext.javatime.deser.key;
+    exports tools.jackson.databind.ext.javatime.ser;
+    exports tools.jackson.databind.ext.javatime.ser.key;
     exports tools.jackson.databind.ext.jdk8;
     // Needed by Ion module for SqlDate deserializer:
     exports tools.jackson.databind.ext.sql;

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

@@ -5,8 +5,7 @@
 import java.util.function.UnaryOperator;
 
 import tools.jackson.core.*;
-import tools.jackson.databind.cfg.MapperBuilder;
-import tools.jackson.databind.cfg.MutableConfigOverride;
+import tools.jackson.databind.cfg.*;
 import tools.jackson.databind.deser.*;
 import tools.jackson.databind.jsontype.NamedType;
 import tools.jackson.databind.ser.Serializers;
@@ -146,6 +145,9 @@ public static interface SetupContext
         public boolean isEnabled(TokenStreamFactory.Feature f);
         public boolean isEnabled(StreamReadFeature f);
         public boolean isEnabled(StreamWriteFeature f);
+        public boolean isEnabled(DatatypeFeature f);
+
+        public DatatypeFeatures datatypeFeatures();
 
         /*
         /******************************************************************

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

@@ -210,6 +210,21 @@ public enum SerializationFeature implements ConfigFeature
      */
     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
@@ -360,21 +375,6 @@ public enum SerializationFeature implements ConfigFeature
      */
     WRITE_SINGLE_ELEM_ARRAYS_UNWRAPPED(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 {@link java.util.Map} entries are first
      * sorted by key before serialization or not: if enabled, additional sorting

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

@@ -14,31 +14,38 @@ public class DatatypeFeatures
 
     protected final static int FEATURE_INDEX_ENUM = 0;
     protected final static int FEATURE_INDEX_JSON_NODE = 1;
+    protected final static int FEATURE_INDEX_DATETIME = 2;
 
-    private final int _enabledFor1, _enabledFor2;
+    private final int _enabledFor1, _enabledFor2, _enabledFor3;
 
-    private final int _explicitFor1, _explicitFor2;
+    private final int _explicitFor1, _explicitFor2, _explicitFor3;
 
     protected DatatypeFeatures(int enabledFor1, int explicitFor1,
-            int enabledFor2, int explicitFor2)  {
+            int enabledFor2, int explicitFor2,
+            int enabledFor3, int explicitFor3)  {
         _enabledFor1 = enabledFor1;
         _explicitFor1 = explicitFor1;
         _enabledFor2 = enabledFor2;
         _explicitFor2 = explicitFor2;
+        _enabledFor3 = enabledFor3;
+        _explicitFor3 = explicitFor3;
     }
 
     public static DatatypeFeatures defaultFeatures() {
         return DefaultHolder.getDefault();
     }
 
     private DatatypeFeatures _with(int enabledFor1, int explicitFor1,
-            int enabledFor2, int explicitFor2) {
+            int enabledFor2, int explicitFor2,
+            int enabledFor3, int explicitFor3) {
         if ((_enabledFor1 == enabledFor1) && (_explicitFor1 == explicitFor1)
-                && (_enabledFor2 == enabledFor2) && (_explicitFor2 == explicitFor2)) {
+                && (_enabledFor2 == enabledFor2) && (_explicitFor2 == explicitFor2)
+                && (_enabledFor3 == enabledFor3) && (_explicitFor3 == explicitFor3)) {
             return this;
         }
         return new DatatypeFeatures(enabledFor1, explicitFor1,
-                enabledFor2, explicitFor2);
+                enabledFor2, explicitFor2,
+                enabledFor3, explicitFor3);
     }
 
     /*
@@ -61,10 +68,16 @@ public DatatypeFeatures with(DatatypeFeature f) {
         switch (f.featureIndex()) {
         case 0:
             return _with(_enabledFor1 | mask, _explicitFor1 | mask,
-                    _enabledFor2, _explicitFor2);
+                    _enabledFor2, _explicitFor2,
+                    _enabledFor3, _explicitFor3);
         case 1:
             return _with(_enabledFor1, _explicitFor1,
-                    _enabledFor2 | mask, _explicitFor2 | mask);
+                    _enabledFor2 | mask, _explicitFor2 | mask,
+                    _enabledFor3, _explicitFor3);
+        case 2:
+            return _with(_enabledFor1, _explicitFor1,
+                    _enabledFor2, _explicitFor2,
+                    _enabledFor3 | mask, _explicitFor3 | mask);
         default:
             VersionUtil.throwInternal();
             return this;
@@ -88,10 +101,16 @@ public DatatypeFeatures withFeatures(DatatypeFeature... features) {
         switch (features[0].featureIndex()) {
         case 0:
             return _with(_enabledFor1 | mask, _explicitFor1 | mask,
-                    _enabledFor2, _explicitFor2);
+                    _enabledFor2, _explicitFor2,
+                    _enabledFor3, _explicitFor3);
         case 1:
             return _with(_enabledFor1, _explicitFor1,
-                    _enabledFor2 | mask, _explicitFor2 | mask);
+                    _enabledFor2 | mask, _explicitFor2 | mask,
+                    _enabledFor3, _explicitFor3);
+        case 2:
+            return _with(_enabledFor1, _explicitFor1,
+                    _enabledFor2, _explicitFor2,
+                    _enabledFor3 | mask, _explicitFor3 | mask);
         default:
             VersionUtil.throwInternal();
             return this;
@@ -112,10 +131,16 @@ public DatatypeFeatures without(DatatypeFeature f) {
         switch (f.featureIndex()) {
         case 0:
             return _with(_enabledFor1 & ~mask, _explicitFor1 | mask,
-                    _enabledFor2, _explicitFor2);
+                    _enabledFor2, _explicitFor2,
+                    _enabledFor3, _explicitFor3);
         case 1:
             return _with(_enabledFor1, _explicitFor1,
-                    _enabledFor2 & ~mask, _explicitFor2 | mask);
+                    _enabledFor2 & ~mask, _explicitFor2 | mask,
+                    _enabledFor3, _explicitFor3);
+        case 2:
+            return _with(_enabledFor1, _explicitFor1,
+                    _enabledFor2, _explicitFor2,
+                    _enabledFor3 & ~mask, _explicitFor3 | mask);
         default:
             VersionUtil.throwInternal();
             return this;
@@ -139,10 +164,16 @@ public DatatypeFeatures withoutFeatures(DatatypeFeature... features) {
         switch (features[0].featureIndex()) {
         case 0:
             return _with(_enabledFor1 & ~mask, _explicitFor1 | mask,
-                    _enabledFor2, _explicitFor2);
+                    _enabledFor2, _explicitFor2,
+                    _enabledFor3, _explicitFor3);
         case 1:
             return _with(_enabledFor1, _explicitFor1,
-                    _enabledFor2 & ~mask, _explicitFor2 | mask);
+                    _enabledFor2 & ~mask, _explicitFor2 | mask,
+                    _enabledFor3, _explicitFor3);
+        case 2:
+            return _with(_enabledFor1, _explicitFor1,
+                    _enabledFor2, _explicitFor2,
+                    _enabledFor3 & ~mask, _explicitFor3 | mask);
         default:
             VersionUtil.throwInternal();
             return this;
@@ -179,6 +210,8 @@ public boolean isEnabled(DatatypeFeature f) {
             return f.enabledIn(_enabledFor1);
         case 1:
             return f.enabledIn(_enabledFor2);
+        case 2:
+            return f.enabledIn(_enabledFor3);
         default:
             VersionUtil.throwInternal();
             return false;
@@ -200,6 +233,8 @@ public boolean isExplicitlySet(DatatypeFeature f) {
             return f.enabledIn(_explicitFor1);
         case 1:
             return f.enabledIn(_explicitFor2);
+        case 2:
+            return f.enabledIn(_explicitFor3);
         default:
             VersionUtil.throwInternal();
             return false;
@@ -215,15 +250,15 @@ public boolean isExplicitlySet(DatatypeFeature f) {
      * @param f Feature to check
      *
      * @return Whether given feature has been explicitly enabled
-     *
-     * @since 2.15
      */
     public boolean isExplicitlyEnabled(DatatypeFeature f) {
         switch (f.featureIndex()) {
         case 0:
             return f.enabledIn(_explicitFor1 & _enabledFor1);
         case 1:
             return f.enabledIn(_explicitFor2 & _enabledFor2);
+        case 2:
+            return f.enabledIn(_explicitFor3 & _enabledFor3);
         default:
             VersionUtil.throwInternal();
             return false;
@@ -239,15 +274,15 @@ public boolean isExplicitlyEnabled(DatatypeFeature f) {
      * @param f Feature to check
      *
      * @return Whether given feature has been explicitly disabled
-     *
-     * @since 2.15
      */
     public boolean isExplicitlyDisabled(DatatypeFeature f) {
         switch (f.featureIndex()) {
         case 0:
             return f.enabledIn(_explicitFor1 & ~_enabledFor1);
         case 1:
             return f.enabledIn(_explicitFor2 & ~_enabledFor2);
+        case 2:
+            return f.enabledIn(_explicitFor3 & ~_enabledFor3);
         default:
             VersionUtil.throwInternal();
             return false;
@@ -276,6 +311,11 @@ public Boolean getExplicitState(DatatypeFeature f) {
                 return f.enabledIn(_enabledFor2);
             }
             return null;
+        case 2:
+            if (f.enabledIn(_explicitFor3)) {
+                return f.enabledIn(_enabledFor3);
+            }
+            return null;
         default:
             VersionUtil.throwInternal();
             return null;
@@ -298,7 +338,8 @@ private static class DefaultHolder
         static {
             DEFAULT_FEATURES = new DatatypeFeatures(
                     collectDefaults(EnumFeature.values()), 0,
-                    collectDefaults(JsonNodeFeature.values()), 0
+                    collectDefaults(JsonNodeFeature.values()), 0,
+                    collectDefaults(DateTimeFeature.values()), 0
                     );
         }
 

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

@@ -0,0 +1,84 @@
+package tools.jackson.databind.cfg;
+
+/**
+ * Configurable on/off features to configure Date/Time handling.
+ * Mostly used to configure
+ * Java 8 Time ({@code java.time}) type handling (see
+ * {@link tools.jackson.databind.ext.javatime.JavaTimeInitializer})
+ * but also to "legacy" ({@link java.util.Date}, {@link java.util.Calendar})
+ * and Joda Date/Time.
+ */
+public enum DateTimeFeature implements DatatypeFeature
+{
+    /**
+     * Feature that determines whether {@link java.time.ZoneId} is normalized
+     * (via call to {@code java.time.ZoneId#normalized()}) when deserializing
+     * types like {@link java.time.ZonedDateTime}.
+     *<p>
+     * Default setting is enabled, for backwards-compatibility with
+     * Jackson 2.15.
+     */
+    NORMALIZE_DESERIALIZED_ZONE_ID(true),
+
+    /**
+     * Feature that determines whether the {@link java.util.TimeZone} of the
+     * {@link tools.jackson.databind.DeserializationContext} is used
+     * when leniently deserializing {@link java.time.LocalDate} or
+     * {@link java.time.LocalDateTime} from the UTC/ISO instant format.
+     * <p>
+     * Default setting is disabled, for backwards-compatibility with
+     * Jackson 2.18.
+     *
+     * @since 2.19
+     */
+    USE_TIME_ZONE_FOR_LENIENT_DATE_PARSING(false),
+
+    /**
+     * Feature that controls whether stringified numbers (Strings that without
+     * quotes would be legal JSON Numbers) may be interpreted as
+     * timestamps (enabled) or not (disabled), in case where there is an
+     * explicitly defined pattern ({@code DateTimeFormatter}, usually by
+     * using {@code @JsonFormat} annotation) for value.
+     * <p>
+     * Note that when the default pattern is used (no custom pattern defined),
+     * stringified numbers are always accepted as timestamps regardless of
+     * this feature.
+     */
+    ALWAYS_ALLOW_STRINGIFIED_DATE_TIMESTAMPS(false),
+
+    /**
+     * Feature that determines whether {@link java.time.Month} is serialized
+     * and deserialized as using a zero-based index (FALSE) or a one-based index (TRUE).
+     * For example, "1" would be serialized/deserialized as Month.JANUARY if TRUE and Month.FEBRUARY if FALSE.
+     *<p>
+     * Default setting is false, meaning that Month is serialized/deserialized as a zero-based index.
+     */
+    ONE_BASED_MONTHS(false)
+    ;
+
+    private final static int FEATURE_INDEX = DatatypeFeatures.FEATURE_INDEX_DATETIME;
+
+    /**
+     * Whether feature is enabled or disabled by default.
+     */
+    private final boolean _enabledByDefault;
+
+    private final int _mask;
+
+    private DateTimeFeature(boolean enabledByDefault) {
+        _enabledByDefault = enabledByDefault;
+        _mask = (1 << ordinal());
+    }
+
+    @Override
+    public boolean enabledByDefault() { return _enabledByDefault; }
+    @Override
+    public boolean enabledIn(int flags) { return (flags & _mask) != 0; }
+    @Override
+    public int getMask() { return _mask; }
+
+    @Override
+    public int featureIndex() {
+        return FEATURE_INDEX;
+    }
+}

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

@@ -16,6 +16,7 @@
 import tools.jackson.core.util.Snapshottable;
 import tools.jackson.databind.*;
 import tools.jackson.databind.deser.*;
+import tools.jackson.databind.ext.javatime.JavaTimeInitializer;
 import tools.jackson.databind.introspect.*;
 import tools.jackson.databind.jsontype.*;
 import tools.jackson.databind.jsontype.impl.DefaultTypeResolverBuilder;
@@ -419,8 +420,9 @@ public MapperBuilderState saveStateApplyModules()
     {
         if (_savedState == null) {
             _savedState = _saveState();
+            ModuleContextBase ctxt = _constructModuleContext();
+            JavaTimeInitializer.getInstance().setupModule(ctxt);
             if (_modules != null) {
-                ModuleContextBase ctxt = _constructModuleContext();
                 _modules.values().forEach(m -> m.setupModule(ctxt));
                 // and since context may buffer some changes, ensure those are flushed:
                 ctxt.applyChanges(this);
@@ -485,7 +487,6 @@ public boolean isEnabled(SerializationFeature f) {
     public boolean isEnabled(DatatypeFeature f) {
         return _datatypeFeatures.isEnabled(f);
     }
-
     public boolean isEnabled(StreamReadFeature f) {
         return f.enabledIn(_streamReadFeatures);
     }