Issue_66 Support for NaN, Inf and -Inf in JSON serialization

Author: georgweiss

.gitignore

@@ -15,3 +15,7 @@ nbactions.xml
 
 # For all you Mac OS users out there
 **/.DS_Store
+
+# For all you IntelliJ users out there
+**/*.iml
+**/.idea

epics-vtype/vtype-json/src/main/java/org/epics/vtype/json/JsonArrays.java

@@ -11,6 +11,7 @@
 import javax.json.JsonArray;
 import javax.json.JsonArrayBuilder;
 import javax.json.JsonNumber;
+import javax.json.JsonObject;
 import javax.json.JsonString;
 import javax.json.JsonValue;
 import org.epics.util.array.ArrayByte;
@@ -82,9 +83,11 @@ public static boolean isStringArray(JsonArray array) {
     public static ListDouble toListDouble(JsonArray array) {
         double[] values = new double[array.size()];
         for (int i = 0; i < values.length; i++) {
-            if (array.isNull(i)) {
-                values[i] = Double.NaN;
-            } else {
+            Double doubleValue = VTypeToJsonV1.getDoubleFromJsonString(array.get(i).toString());
+            if(doubleValue != null){
+                values[i] = doubleValue;
+            }
+            else {
                 values[i] = array.getJsonNumber(i).doubleValue();
             }
         }
@@ -313,9 +316,18 @@ public static JsonArrayBuilder fromListNumber(ListNumber list) {
         } else {
             for (int i = 0; i < list.size(); i++) {
                 double value = list.getDouble(i);
-                if (Double.isNaN(value) || Double.isInfinite(value)) {
-                    b.addNull();
-                } else {
+                if(Double.isFinite(value)){
+                    b.add(value);
+                }
+                else if (Double.isNaN(value)) {
+                    b.add(VTypeJsonMapper.NAN);
+                } else if(Double.valueOf(value).equals(Double.POSITIVE_INFINITY)){
+                    b.add(VTypeJsonMapper.POS_INF);
+                }
+                else if(Double.valueOf(value).equals(Double.NEGATIVE_INFINITY)){
+                    b.add(VTypeJsonMapper.NEG_INF);
+                }
+                else {
                     b.add(value);
                 }
             }

epics-vtype/vtype-json/src/main/java/org/epics/vtype/json/JsonVTypeBuilder.java

@@ -70,13 +70,26 @@ public JsonVTypeBuilder add(String string, long l) {
         return this;
     }
 
+    /**
+     * For the special cases of {@link Double#NaN}, {@link Double#POSITIVE_INFINITY} and
+     * {@link Double#NEGATIVE_INFINITY} this method adds a string representation of the value.
+     * @param string Name of property to set.
+     * @param d Value to set.
+     * @return The {@link JsonVTypeBuilder} instance.
+     */
     @Override
     public JsonVTypeBuilder add(String string, double d) {
-        if (Double.isNaN(d) || Double.isInfinite(d)) {
-            builder.addNull(string);
-        } else {
+        if(Double.isFinite(d)){
             builder.add(string, d);
         }
+        else if (Double.isNaN(d)) {
+            builder.add(string, VTypeJsonMapper.NAN);
+        } else if(Double.valueOf(d).equals(Double.POSITIVE_INFINITY)){
+            builder.add(string, VTypeJsonMapper.POS_INF);
+        }
+        else if(Double.valueOf(d).equals(Double.NEGATIVE_INFINITY)){
+            builder.add(string, VTypeJsonMapper.NEG_INF);
+        }
         return this;
     }
 

epics-vtype/vtype-json/src/main/java/org/epics/vtype/json/VTypeJsonMapper.java

@@ -41,6 +41,25 @@
  * @author carcassi
  */
 class VTypeJsonMapper implements JsonObject {
+
+    public static final String NAN = Double.toString(Double.NaN);
+    /**
+     * Quoted version of {@link Double#NaN}. Needed for comparison when de-serializing,
+     * as serialization of {@link Double#NaN} creates a quotes string.
+     */
+    public static final String NAN_QUOTED = "\"" + NAN + "\"";
+    public static final String POS_INF = Double.toString(Double.POSITIVE_INFINITY);
+    /**
+     * Quoted version of {@link Double#POSITIVE_INFINITY}. Needed for comparison when de-serializing,
+     * as serialization of {@link Double#POSITIVE_INFINITY} creates a quotes string.
+     */
+    public static final String POS_INF_QUOTED = "\"" + POS_INF + "\"";
+    public static final String NEG_INF = Double.toString(Double.NEGATIVE_INFINITY);
+    /**
+     * Quoted version of {@link Double#NEGATIVE_INFINITY}. Needed for comparison when de-serializing,
+     * as serialization of {@link Double#NEGATIVE_INFINITY} creates a quotes string.
+     */
+    public static final String NEG_INF_QUOTED = "\"" + NEG_INF + "\"";
 
     private final JsonObject json;
 

epics-vtype/vtype-json/src/main/java/org/epics/vtype/json/VTypeToJsonV1.java

@@ -12,6 +12,7 @@
 import org.epics.util.number.ULong;
 import org.epics.util.number.UShort;
 import org.epics.vtype.EnumDisplay;
+import org.epics.vtype.VDouble;
 import org.epics.vtype.VEnum;
 import org.epics.vtype.VNumber;
 import org.epics.vtype.VNumberArray;
@@ -78,11 +79,15 @@ static JsonObject toJson(VType vType) {
         throw new UnsupportedOperationException("Not implemented yet");
     }
 
-    static VNumber toVNumber(JsonObject json) {
+    static VType toVNumber(JsonObject json) {
         VTypeJsonMapper mapper = new VTypeJsonMapper(json);
         Number value;
         switch(mapper.getTypeName()) {
             case "VDouble":
+                Double doubleValue = getDoubleFromJsonString(json.get("value").toString());
+                if(doubleValue != null){
+                    return VDouble.of(doubleValue, mapper.getAlarm(), mapper.getTime(), mapper.getDisplay());
+                }
                 value = mapper.getJsonNumber("value").doubleValue();
                 break;
             case "VFloat":
@@ -207,4 +212,24 @@ static JsonObject toJson(VEnum vEnum) {
                 .addEnum(vEnum)
                 .build();
     }
+
+    /**
+     * Converts an input (JSON) string to a {@link Double} for the special cases
+     * {@link Double#NaN}, {@link Double#POSITIVE_INFINITY} and {@link Double#NEGATIVE_INFINITY}.
+     * @param valueAsString
+     * @return <code>null</code> if input is <code>null</code> or a valid double number, otherwise
+     * {@link Double#NaN}, {@link Double#POSITIVE_INFINITY} and {@link Double#NEGATIVE_INFINITY}.
+     */
+    public static Double getDoubleFromJsonString(String valueAsString){
+        if(VTypeJsonMapper.NAN_QUOTED.equals(valueAsString)){
+            return Double.NaN;
+        }
+        else if(VTypeJsonMapper.POS_INF_QUOTED.equals(valueAsString)){
+            return Double.POSITIVE_INFINITY;
+        }
+        else if(VTypeJsonMapper.NEG_INF_QUOTED.equals(valueAsString)){
+            return Double.NEGATIVE_INFINITY;
+        }
+        return null;
+    }
 }

epics-vtype/vtype-json/src/test/java/org/epics/vtype/json/VTypeToJsonTest.java

@@ -11,6 +11,7 @@
 import java.time.Instant;
 import java.util.Arrays;
 import java.util.Collections;
+import java.util.List;
 import javax.json.Json;
 import javax.json.JsonObject;
 import javax.json.JsonReader;
@@ -288,5 +289,45 @@ public void vByteArray1() {
         testDeserialization("VByteArray1", vByteArray1);
         testDeserialization("VByteArray1a", vByteArray1);
     }
-    
+
+    /**
+     * Tests serialization and de-serialization of a Double.NaN. See {@link JsonVTypeBuilder#add} and
+     * {@link VTypeToJsonV1#toVNumber}
+     */
+    @Test
+    public void testDoubleNaN(){
+        VDouble vDouble = VDouble.of(Double.NaN, Alarm.none(), Time.of(Instant.EPOCH), Display.none());
+        JsonObject jsonObject = VTypeToJson.toJson(vDouble);
+        assertEquals("NaN", jsonObject.getString("value"));
+        vDouble = (VDouble)VTypeToJson.toVType(jsonObject);
+        assertTrue(Double.isNaN(vDouble.getValue()));
+    }
+
+    @Test
+    public void testDoublePositiveInfinity(){
+        VDouble vDouble = VDouble.of(Double.POSITIVE_INFINITY, Alarm.none(), Time.of(Instant.EPOCH), Display.none());
+        JsonObject jsonObject = VTypeToJson.toJson(vDouble);
+        assertEquals(Double.toString(Double.POSITIVE_INFINITY), jsonObject.getString("value"));
+        vDouble = (VDouble)VTypeToJson.toVType(jsonObject);
+        assertTrue(vDouble.getValue().equals(Double.POSITIVE_INFINITY));
+    }
+
+    @Test
+    public void testDoubleNegativeInfinity(){
+        VDouble vDouble = VDouble.of(Double.NEGATIVE_INFINITY, Alarm.none(), Time.of(Instant.EPOCH), Display.none());
+        JsonObject jsonObject = VTypeToJson.toJson(vDouble);
+        assertEquals(VTypeJsonMapper.NEG_INF, jsonObject.getString("value"));
+        vDouble = (VDouble)VTypeToJson.toVType(jsonObject);
+        assertTrue(vDouble.getValue().equals(Double.NEGATIVE_INFINITY));
+    }
+
+    @Test
+    public void testDoubleNaNInArray(){
+        VDoubleArray vDoubleArray1 = VDoubleArray.of(ArrayDouble.of(0, Double.NaN, 2), Alarm.none(), Time.of(Instant.ofEpochSecond(0, 0)), Display.none());
+        JsonObject jsonObject = VTypeToJson.toJson(vDoubleArray1);
+        List valueObject = (List)jsonObject.get("value");
+        assertEquals(VTypeJsonMapper.NAN_QUOTED, valueObject.get(1).toString());
+        vDoubleArray1 = (VDoubleArray)VTypeToJson.toVType(jsonObject);
+        assertTrue(Double.isNaN(vDoubleArray1.getData().getDouble(1)));
+    }
 }