Added 'isEmpty()' implementation for GuavaOptionalSerializer; minor test cleanup

Author: cowtowncoder

src/main/java/com/fasterxml/jackson/datatype/guava/ser/GuavaBeanSerializerModifier.java

@@ -12,16 +12,15 @@ public class GuavaBeanSerializerModifier extends BeanSerializerModifier {
 
     @Override
     public List<BeanPropertyWriter> changeProperties(SerializationConfig config,
-                                                     BeanDescription beanDesc,
-                                                     List<BeanPropertyWriter> beanProperties) {
-
+            BeanDescription beanDesc,
+            List<BeanPropertyWriter> beanProperties)
+    {
         for (int i = 0; i < beanProperties.size(); ++i) {
             final BeanPropertyWriter writer = beanProperties.get(i);
-            if (Optional.class.isAssignableFrom(writer.getPropertyType()))
+            if (Optional.class.isAssignableFrom(writer.getPropertyType())) {
                 beanProperties.set(i, new GuavaOptionalBeanPropertyWriter(writer));
+            }
         }
-
         return beanProperties;
     }
-
 }

src/main/java/com/fasterxml/jackson/datatype/guava/ser/GuavaOptionalBeanPropertyWriter.java

@@ -12,9 +12,13 @@ protected GuavaOptionalBeanPropertyWriter(BeanPropertyWriter base) {
     }
 
     @Override
-    public void serializeAsField(Object bean, JsonGenerator jgen, SerializerProvider prov) throws Exception {
-        if ((get(bean) == null || Optional.absent().equals(get(bean))) && _nullSerializer == null) {
-            return;
+    public void serializeAsField(Object bean, JsonGenerator jgen, SerializerProvider prov) throws Exception
+    {
+        if (_nullSerializer == null) {
+            Object value = get(bean);
+            if (value == null || Optional.absent().equals(value)) {
+                return;
+            }
         }
         super.serializeAsField(bean, jgen, prov);
     }

src/main/java/com/fasterxml/jackson/datatype/guava/ser/GuavaOptionalSerializer.java

@@ -11,11 +11,18 @@
 import com.fasterxml.jackson.databind.ser.std.StdSerializer;
 import com.google.common.base.Optional;
 
-public final class GuavaOptionalSerializer extends StdSerializer<Optional<?>> {
+public final class GuavaOptionalSerializer extends StdSerializer<Optional<?>>
+{
     public GuavaOptionalSerializer(JavaType type) {
         super(type);
     }
 
+    // implemented since 2.3
+    @Override
+    public boolean isEmpty(Optional<?> value) {
+        return (value == null) || !value.isPresent();
+    }
+
     @Override
     public void serialize(Optional<?> value, JsonGenerator jgen, SerializerProvider provider)
             throws IOException, JsonGenerationException {

src/test/java/com/fasterxml/jackson/datatype/guava/TestOptional.java

@@ -1,75 +1,87 @@
 package com.fasterxml.jackson.datatype.guava;
 
-
 import com.fasterxml.jackson.annotation.JsonAutoDetect;
 import com.fasterxml.jackson.annotation.JsonAutoDetect.Visibility;
 import com.fasterxml.jackson.annotation.JsonInclude;
 import com.fasterxml.jackson.core.type.TypeReference;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.google.common.base.Optional;
 
-public class TestOptional extends BaseTest {
+public class TestOptional extends BaseTest
+{
+    private final ObjectMapper MAPPER = mapperWithModule();
+
+    @JsonAutoDetect(fieldVisibility=Visibility.ANY)
+    public static final class OptionalData{
+        private Optional<String> myString;
+    }
+    
+    @JsonAutoDetect(fieldVisibility=Visibility.ANY)
+    public static final class OptionalGenericData<T>{
+        private Optional<T> myData;
+    }
+
     public void testDeserAbsent() throws Exception {
-        Optional<?> value = mapperWithModule().readValue("null", new TypeReference<Optional<String>>() {});
+        Optional<?> value = MAPPER.readValue("null", new TypeReference<Optional<String>>() {});
         assertFalse(value.isPresent());
     }
 
     public void testDeserSimpleString() throws Exception{
-        Optional<?> value = mapperWithModule().readValue("\"simpleString\"", new TypeReference<Optional<String>>() {});
+        Optional<?> value = MAPPER.readValue("\"simpleString\"", new TypeReference<Optional<String>>() {});
         assertTrue(value.isPresent());
         assertEquals("simpleString", value.get());
     }
 
     public void testDeserInsideObject() throws Exception {
-        OptionalData data = mapperWithModule().readValue("{\"myString\":\"simpleString\"}", OptionalData.class);
+        OptionalData data = MAPPER.readValue("{\"myString\":\"simpleString\"}", OptionalData.class);
         assertTrue(data.myString.isPresent());
         assertEquals("simpleString", data.myString.get());
     }
 
     public void testDeserComplexObject() throws Exception {
         TypeReference<Optional<OptionalData>> type = new TypeReference<Optional<OptionalData>>() {};
-        Optional<OptionalData> data = mapperWithModule().readValue("{\"myString\":\"simpleString\"}", type);
+        Optional<OptionalData> data = MAPPER.readValue("{\"myString\":\"simpleString\"}", type);
         assertTrue(data.isPresent());
         assertTrue(data.get().myString.isPresent());
         assertEquals("simpleString", data.get().myString.get());
     }
 
     public void testDeserGeneric() throws Exception {
         TypeReference<Optional<OptionalGenericData<String>>> type = new TypeReference<Optional<OptionalGenericData<String>>>() {};
-        Optional<OptionalGenericData<String>> data = mapperWithModule().readValue("{\"myData\":\"simpleString\"}", type);
+        Optional<OptionalGenericData<String>> data = MAPPER.readValue("{\"myData\":\"simpleString\"}", type);
         assertTrue(data.isPresent());
         assertTrue(data.get().myData.isPresent());
         assertEquals("simpleString", data.get().myData.get());
     }
 
     public void testSerAbsent() throws Exception {
-        String value = mapperWithModule().writeValueAsString(Optional.absent());
+        String value = MAPPER.writeValueAsString(Optional.absent());
         assertEquals("null", value);
     }
 
     public void testSerSimpleString() throws Exception {
-        String value = mapperWithModule().writeValueAsString(Optional.of("simpleString"));
+        String value = MAPPER.writeValueAsString(Optional.of("simpleString"));
         assertEquals("\"simpleString\"", value);
     }
 
     public void testSerInsideObject() throws Exception {
         OptionalData data = new OptionalData();
         data.myString = Optional.of("simpleString");
-        String value = mapperWithModule().writeValueAsString(data);
+        String value = MAPPER.writeValueAsString(data);
         assertEquals("{\"myString\":\"simpleString\"}", value);
     }
 
     public void testSerComplexObject() throws Exception {
         OptionalData data = new OptionalData();
         data.myString = Optional.of("simpleString");
-        String value = mapperWithModule().writeValueAsString(Optional.of(data));
+        String value = MAPPER.writeValueAsString(Optional.of(data));
         assertEquals("{\"myString\":\"simpleString\"}", value);
     }
 
     public void testSerGeneric() throws Exception {
         OptionalGenericData<String> data = new OptionalGenericData<String>();
         data.myData = Optional.of("simpleString");
-        String value = mapperWithModule().writeValueAsString(Optional.of(data));
+        String value = MAPPER.writeValueAsString(Optional.of(data));
         assertEquals("{\"myData\":\"simpleString\"}", value);
     }
 
@@ -99,15 +111,5 @@ public void testWithTypingEnabled() throws Exception {
 
 		final OptionalData deserializedMyData = objectMapper.readValue(json, OptionalData.class);
 		assertEquals(myData.myString, deserializedMyData.myString);
-	}
-    
-    @JsonAutoDetect(fieldVisibility=Visibility.ANY)
-    public static final class OptionalData{
-        private Optional<String> myString;
-    }
-    
-    @JsonAutoDetect(fieldVisibility=Visibility.ANY)
-    public static final class OptionalGenericData<T>{
-        private Optional<T> myData;
     }
 }