Improvements to handling of polymorphic type information for AtomicReference, ref types.

Author: cowtowncoder

src/main/java/com/fasterxml/jackson/databind/ObjectMapper.java

@@ -228,6 +228,10 @@ public boolean useForType(JavaType t)
                 }
                 // fall through
             case OBJECT_AND_NON_CONCRETE:
+                // 19-Apr-2016, tatu: ReferenceType like Optional also requires similar handling:
+                while (t.isReferenceType()) {
+                    t = t.getReferencedType();
+                }
                 return t.isJavaLangObject()
                         || (!t.isConcrete()
                                 // [databind#88] Should not apply to JSON tree models:
@@ -237,7 +241,11 @@ public boolean useForType(JavaType t)
                 while (t.isArrayType()) {
                     t = t.getContentType();
                 }
-                // [Issue#88] Should not apply to JSON tree models:
+                // 19-Apr-2016, tatu: ReferenceType like Optional also requires similar handling:
+                while (t.isReferenceType()) {
+                    t = t.getReferencedType();
+                }
+                // [databind#88] Should not apply to JSON tree models:
                 return !t.isFinal() && !TreeNode.class.isAssignableFrom(t.getRawClass());
             default:
             //case JAVA_LANG_OBJECT:
@@ -1333,7 +1341,7 @@ public ObjectMapper setDefaultPrettyPrinter(PrettyPrinter pp) {
 
     /*
     /**********************************************************
-    /* Type information configuration (1.5+)
+    /* Type information configuration
     /**********************************************************
      */
 

src/main/java/com/fasterxml/jackson/databind/jsontype/impl/ClassNameIdResolver.java

@@ -77,31 +77,29 @@ protected JavaType _typeFromId(String id, TypeFactory typeFactory)
 
     protected final String _idFrom(Object value, Class<?> cls)
     {
-        // [JACKSON-380] Need to ensure that "enum subtypes" work too
+        // Need to ensure that "enum subtypes" work too
         if (Enum.class.isAssignableFrom(cls)) {
             if (!cls.isEnum()) { // means that it's sub-class of base enum, so:
                 cls = cls.getSuperclass();
             }
         }
         String str = cls.getName();
         if (str.startsWith("java.util")) {
-            /* 25-Jan-2009, tatu: There are some internal classes that
-             *   we can not access as is. We need better mechanism; for
-             *   now this has to do...
-             */
-            /* Enum sets and maps are problematic since we MUST know
-             * type of contained enums, to be able to deserialize.
-             * In addition, EnumSet is not a concrete type either
-             */
+            // 25-Jan-2009, tatu: There are some internal classes that we can not access as is.
+            //     We need better mechanism; for now this has to do...
+
+            // Enum sets and maps are problematic since we MUST know type of
+            // contained enums, to be able to deserialize.
+            // In addition, EnumSet is not a concrete type either
             if (value instanceof EnumSet<?>) { // Regular- and JumboEnumSet...
                 Class<?> enumClass = ClassUtil.findEnumType((EnumSet<?>) value);
                 // not optimal: but EnumSet is not a customizable type so this is sort of ok
-                str = TypeFactory.defaultInstance().constructCollectionType(EnumSet.class, enumClass).toCanonical();
+               str = _typeFactory.constructCollectionType(EnumSet.class, enumClass).toCanonical();
             } else if (value instanceof EnumMap<?,?>) {
                 Class<?> enumClass = ClassUtil.findEnumType((EnumMap<?,?>) value);
                 Class<?> valueClass = Object.class;
                 // not optimal: but EnumMap is not a customizable type so this is sort of ok
-                str = TypeFactory.defaultInstance().constructMapType(EnumMap.class, enumClass, valueClass).toCanonical();
+                str = _typeFactory.constructMapType(EnumMap.class, enumClass, valueClass).toCanonical();
             } else {
                 String end = str.substring(9);
                 if ((end.startsWith(".Arrays$") || end.startsWith(".Collections$"))

src/main/java/com/fasterxml/jackson/databind/ser/std/AtomicReferenceSerializer.java

@@ -279,10 +279,22 @@ public void serializeWithType(AtomicReference<?> ref,
             return;
         }
 
+        // 19-Apr-2016, tatu: In order to basically "skip" the whole wrapper level
+        //    (which is what non-polymorphic serialization does too), we will need
+        //    to simply delegate call, I think, and NOT try to use it here.
+        
         // Otherwise apply type-prefix/suffix, then std serialize:
+        /*
         typeSer.writeTypePrefixForScalar(ref, g);
         serialize(ref, g, provider);
         typeSer.writeTypeSuffixForScalar(ref, g);
+        */
+
+        JsonSerializer<Object> ser = _valueSerializer;
+        if (ser == null) {
+            ser = _findCachedSerializer(provider, value.getClass());
+        }
+        ser.serializeWithType(value, g, provider, typeSer);
     }
 
     /*