Add support for Guava primitives during deserialization

guava/src/main/java/com/fasterxml/jackson/datatype/guava/GuavaDeserializers.java

@@ -1,5 +1,6 @@
 package com.fasterxml.jackson.datatype.guava;
 
+import com.fasterxml.jackson.datatype.guava.util.PrimitiveTypes;
 import com.google.common.base.Optional;
 import com.google.common.collect.*;
 import com.google.common.hash.HashCode;
@@ -21,6 +22,8 @@
 
 import java.io.Serializable;
 
+import static com.fasterxml.jackson.datatype.guava.util.PrimitiveTypes.isAssignableFromPrimitive;
+
 /**
  * Custom deserializers module offers.
  */
@@ -127,7 +130,9 @@ public ValueDeserializer<?> findCollectionDeserializer(CollectionType type,
                     null, null);
         }
 
-        return null;
+        return isAssignableFromPrimitive(raw)
+                .transform(PrimitiveTypes.Primitives::newDeserializer)
+                .orNull();
     }
 
     private void requireCollectionOfComparableElements(CollectionType actualType, String targetType) {
@@ -310,8 +315,10 @@ public boolean hasDeserializerFor(DeserializationConfig config, Class<?> valueTy
                     || ImmutableCollection.class.isAssignableFrom(valueType)
                     || ImmutableMap.class.isAssignableFrom(valueType)
                     || BiMap.class.isAssignableFrom(valueType)
+                    || isAssignableFromPrimitive(valueType).isPresent()
                     ;
         }
         return false;
     }
+
 }

guava/src/main/java/com/fasterxml/jackson/datatype/guava/GuavaSerializers.java

@@ -1,5 +1,7 @@
 package com.fasterxml.jackson.datatype.guava;
 
+import com.fasterxml.jackson.databind.type.CollectionLikeType;
+import com.fasterxml.jackson.datatype.guava.util.PrimitiveTypes;
 import java.io.Serializable;
 import java.util.Set;
 
@@ -48,7 +50,7 @@ public Iterable<?> convert(Object value) {
     }
 
     @Override
-    public ValueSerializer<?> findReferenceSerializer(SerializationConfig config, 
+    public ValueSerializer<?> findReferenceSerializer(SerializationConfig config,
             ReferenceType refType, BeanDescription beanDesc, JsonFormat.Value formatOverrides,
             TypeSerializer contentTypeSerializer, ValueSerializer<Object> contentValueSerializer)
     {
@@ -114,8 +116,21 @@ public ValueSerializer<?> findMapLikeSerializer(SerializationConfig config,
         return null;
     }
 
+    @Override
+    public ValueSerializer<?> findCollectionLikeSerializer(SerializationConfig config, CollectionLikeType type,
+            BeanDescription beanDesc, JsonFormat.Value formatOverrides, TypeSerializer elementTypeSerializer,
+           ValueSerializer<Object> elementValueSerializer)
+    {
+        Class<?> raw = type.getRawClass();
+        Optional<ValueSerializer<?>> primitiveSerializer = PrimitiveTypes.isAssignableFromPrimitive(raw)
+                .transform((ignore) -> ToStringSerializer.instance);
+
+        return primitiveSerializer
+                .or(() -> super.findCollectionLikeSerializer(config, type, beanDesc, formatOverrides, elementTypeSerializer, elementValueSerializer));
+    }
+
     private JavaType _findDeclared(JavaType subtype, Class<?> target) {
-        JavaType decl = subtype.findSuperType(target);
+            JavaType decl = subtype.findSuperType(target);
         if (decl == null) { // should never happen but
             throw new IllegalArgumentException("Strange "+target.getName()+" sub-type, "+subtype+", can not find type parameters");
         }

guava/src/main/java/com/fasterxml/jackson/datatype/guava/deser/BasePrimitiveCollectionDeserializer.java

@@ -0,0 +1,75 @@
+package com.fasterxml.jackson.datatype.guava.deser;
+
+import com.fasterxml.jackson.core.JacksonException;
+import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.core.JsonToken;
+import com.fasterxml.jackson.databind.DeserializationContext;
+import com.fasterxml.jackson.databind.DeserializationFeature;
+import com.fasterxml.jackson.databind.JavaType;
+import com.fasterxml.jackson.databind.deser.std.StdDeserializer;
+import com.fasterxml.jackson.databind.jsontype.TypeDeserializer;
+
+import java.util.Collection;
+import java.util.List;
+
+public abstract class BasePrimitiveCollectionDeserializer<ObjectType, PrimitiveList extends List<ObjectType>, IntermediateCollection extends Collection<ObjectType>>
+        extends StdDeserializer<PrimitiveList> {
+
+    protected BasePrimitiveCollectionDeserializer(Class<? extends PrimitiveList> cls, Class<? super ObjectType> itemType) {
+        super(cls);
+    }
+
+    protected BasePrimitiveCollectionDeserializer(JavaType type) {
+        super(type);
+    }
+
+    protected abstract IntermediateCollection createIntermediateCollection();
+
+    protected IntermediateCollection createIntermediateCollection(int expectedSize) {
+        return createIntermediateCollection();
+    }
+
+    protected abstract void add(IntermediateCollection intermediateCollection, JsonParser parser,
+                                DeserializationContext context) throws JacksonException;
+
+    protected abstract PrimitiveList finish(IntermediateCollection intermediateCollection);
+
+    @Override
+    public Object deserializeWithType(JsonParser parser, DeserializationContext context,
+                                      TypeDeserializer typeDeserializer) throws JacksonException {
+        return typeDeserializer.deserializeTypedFromArray(parser, context);
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public PrimitiveList deserialize(JsonParser parser, DeserializationContext context)
+            throws JacksonException {
+        // Should usually point to START_ARRAY
+        if (parser.isExpectedStartArrayToken()) {
+            return _deserializeContents(parser, context);
+        }
+        // But may support implicit arrays from single values?
+        if (context.isEnabled(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY)) {
+            return _deserializeFromSingleValue(parser, context);
+        }
+        return (PrimitiveList) context.handleUnexpectedToken(getValueType(context), parser);
+    }
+
+    protected PrimitiveList _deserializeContents(JsonParser parser, DeserializationContext context)
+            throws JacksonException {
+        IntermediateCollection collection = createIntermediateCollection();
+
+        while (parser.nextToken() != JsonToken.END_ARRAY) {
+            add(collection, parser, context);
+        }
+        return finish(collection);
+    }
+
+    protected PrimitiveList _deserializeFromSingleValue(JsonParser parser, DeserializationContext ctxt)
+            throws JacksonException {
+        IntermediateCollection intermediateCollection = createIntermediateCollection();
+        add(intermediateCollection, parser, ctxt);
+        return finish(intermediateCollection);
+    }
+
+}

guava/src/main/java/com/fasterxml/jackson/datatype/guava/deser/primitives/BaseGuavaPrimitivesCollectionDeserializer.java

@@ -0,0 +1,30 @@
+package com.fasterxml.jackson.datatype.guava.deser.primitives;
+
+import com.fasterxml.jackson.core.JacksonException;
+import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.databind.DeserializationContext;
+import com.fasterxml.jackson.datatype.guava.deser.BasePrimitiveCollectionDeserializer;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+public abstract class BaseGuavaPrimitivesCollectionDeserializer<ObjectType, PrimitiveList extends List<ObjectType>, IntermediateCollection extends Collection<ObjectType>>
+        extends BasePrimitiveCollectionDeserializer<ObjectType, PrimitiveList, IntermediateCollection> {
+
+    protected BaseGuavaPrimitivesCollectionDeserializer(Class<? extends PrimitiveList> cls, Class<? super ObjectType> itemType) {
+        super(cls, itemType);
+    }
+
+    @Override
+    protected IntermediateCollection createIntermediateCollection() {
+        return (IntermediateCollection) new ArrayList<ObjectType>();
+    }
+
+    @Override
+    protected void add(IntermediateCollection intermediateCollection, JsonParser parser, DeserializationContext context) throws JacksonException {
+        intermediateCollection.add(asPrimitive(parser));
+    }
+
+    protected abstract ObjectType asPrimitive(JsonParser parser) throws JacksonException;
+}

guava/src/main/java/com/fasterxml/jackson/datatype/guava/deser/primitives/BooleansPrimitiveCollectionDeserializer.java

@@ -0,0 +1,27 @@
+package com.fasterxml.jackson.datatype.guava.deser.primitives;
+
+import com.fasterxml.jackson.core.JacksonException;
+import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.datatype.guava.util.PrimitiveTypes;
+import com.google.common.primitives.Booleans;
+
+import java.util.Collection;
+import java.util.List;
+
+public class BooleansPrimitiveCollectionDeserializer
+        extends BaseGuavaPrimitivesCollectionDeserializer<Boolean, List<Boolean>, Collection<Boolean>> {
+
+    public BooleansPrimitiveCollectionDeserializer() {
+        super(PrimitiveTypes.BooleansType, Boolean.class);
+    }
+
+    @Override
+    protected Boolean asPrimitive(JsonParser parser) throws JacksonException {
+        return parser.getBooleanValue();
+    }
+
+    @Override
+    protected List<Boolean> finish(Collection<Boolean> booleans) {
+        return Booleans.asList(Booleans.toArray(booleans));
+    }
+}

guava/src/main/java/com/fasterxml/jackson/datatype/guava/deser/primitives/BytesPrimitiveCollectionDeserializer.java

@@ -0,0 +1,26 @@
+package com.fasterxml.jackson.datatype.guava.deser.primitives;
+
+import com.fasterxml.jackson.core.JacksonException;
+import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.datatype.guava.util.PrimitiveTypes;
+import com.google.common.primitives.Bytes;
+
+import java.util.Collection;
+import java.util.List;
+
+public class BytesPrimitiveCollectionDeserializer
+        extends BaseGuavaPrimitivesCollectionDeserializer<Byte, List<Byte>, Collection<Byte>> {
+    public BytesPrimitiveCollectionDeserializer() {
+        super(PrimitiveTypes.BytesType, Byte.class);
+    }
+
+    @Override
+    protected Byte asPrimitive(JsonParser parser) throws JacksonException {
+        return parser.getByteValue();
+    }
+
+    @Override
+    protected List<Byte> finish(Collection<Byte> bytes) {
+        return Bytes.asList(Bytes.toArray(bytes));
+    }
+}

guava/src/main/java/com/fasterxml/jackson/datatype/guava/deser/primitives/CharsPrimitiveCollectionDeserializer.java

@@ -0,0 +1,26 @@
+package com.fasterxml.jackson.datatype.guava.deser.primitives;
+
+import com.fasterxml.jackson.core.JacksonException;
+import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.datatype.guava.util.PrimitiveTypes;
+import com.google.common.primitives.Chars;
+
+import java.util.Collection;
+import java.util.List;
+
+public class CharsPrimitiveCollectionDeserializer
+        extends BaseGuavaPrimitivesCollectionDeserializer<Character, List<Character>, Collection<Character>> {
+    public CharsPrimitiveCollectionDeserializer() {
+        super(PrimitiveTypes.CharsType, Character.class);
+    }
+
+    @Override
+    protected Character asPrimitive(JsonParser parser) throws JacksonException {
+        return (char) parser.getValueAsString().toCharArray()[0];
+    }
+
+    @Override
+    protected List<Character> finish(Collection<Character> characters) {
+        return Chars.asList(Chars.toArray(characters));
+    }
+}

guava/src/main/java/com/fasterxml/jackson/datatype/guava/deser/primitives/DoublesPrimitiveCollectionDeserializer.java

@@ -0,0 +1,26 @@
+package com.fasterxml.jackson.datatype.guava.deser.primitives;
+
+import com.fasterxml.jackson.core.JacksonException;
+import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.datatype.guava.util.PrimitiveTypes;
+import com.google.common.primitives.Doubles;
+
+import java.util.Collection;
+import java.util.List;
+
+public class DoublesPrimitiveCollectionDeserializer
+        extends BaseGuavaPrimitivesCollectionDeserializer<Double, List<Double>, Collection<Double>> {
+    public DoublesPrimitiveCollectionDeserializer() {
+        super(PrimitiveTypes.DoublesType, Double.class);
+    }
+
+    @Override
+    protected Double asPrimitive(JsonParser parser) throws JacksonException {
+        return parser.getDoubleValue();
+    }
+
+    @Override
+    protected List<Double> finish(Collection<Double> doubles) {
+        return Doubles.asList(Doubles.toArray(doubles));
+    }
+}

guava/src/main/java/com/fasterxml/jackson/datatype/guava/deser/primitives/FloatsPrimitiveCollectionDeserializer.java

@@ -0,0 +1,26 @@
+package com.fasterxml.jackson.datatype.guava.deser.primitives;
+
+import com.fasterxml.jackson.core.JacksonException;
+import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.datatype.guava.util.PrimitiveTypes;
+import com.google.common.primitives.Floats;
+
+import java.util.Collection;
+import java.util.List;
+
+public class FloatsPrimitiveCollectionDeserializer
+        extends BaseGuavaPrimitivesCollectionDeserializer<Float, List<Float>, Collection<Float>> {
+    public FloatsPrimitiveCollectionDeserializer() {
+        super(PrimitiveTypes.FloatsType, Float.class);
+    }
+
+    @Override
+    protected Float asPrimitive(JsonParser parser) throws JacksonException {
+        return parser.getFloatValue();
+    }
+
+    @Override
+    protected List<Float> finish(Collection<Float> floats) {
+        return Floats.asList(Floats.toArray(floats));
+    }
+}

guava/src/main/java/com/fasterxml/jackson/datatype/guava/deser/primitives/IntsPrimitiveCollectionDeserializer.java

@@ -0,0 +1,26 @@
+package com.fasterxml.jackson.datatype.guava.deser.primitives;
+
+import com.fasterxml.jackson.core.JacksonException;
+import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.datatype.guava.util.PrimitiveTypes;
+import com.google.common.primitives.Ints;
+
+import java.util.Collection;
+import java.util.List;
+
+public class IntsPrimitiveCollectionDeserializer
+        extends BaseGuavaPrimitivesCollectionDeserializer<Integer, List<Integer>, Collection<Integer>> {
+    public IntsPrimitiveCollectionDeserializer() {
+        super(PrimitiveTypes.IntsType, Integer.class);
+    }
+
+    @Override
+    protected Integer asPrimitive(JsonParser parser) throws JacksonException {
+        return parser.getIntValue();
+    }
+
+    @Override
+    protected List<Integer> finish(Collection<Integer> integers) {
+        return Ints.asList(Ints.toArray(integers));
+    }
+}

guava/src/main/java/com/fasterxml/jackson/datatype/guava/deser/primitives/LongsPrimitiveCollectionDeserializer.java

@@ -0,0 +1,26 @@
+package com.fasterxml.jackson.datatype.guava.deser.primitives;
+
+import com.fasterxml.jackson.core.JacksonException;
+import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.datatype.guava.util.PrimitiveTypes;
+import com.google.common.primitives.Longs;
+
+import java.util.Collection;
+import java.util.List;
+
+public class LongsPrimitiveCollectionDeserializer
+        extends BaseGuavaPrimitivesCollectionDeserializer<Long, List<Long>, Collection<Long>> {
+    public LongsPrimitiveCollectionDeserializer() {
+        super(PrimitiveTypes.LongsType, Long.class);
+    }
+
+    @Override
+    protected Long asPrimitive(JsonParser parser) throws JacksonException {
+        return parser.getLongValue();
+    }
+
+    @Override
+    protected List<Long> finish(Collection<Long> longs) {
+        return Longs.asList(Longs.toArray(longs));
+    }
+}