Mojangson

src/main/java/org/lanternpowered/server/data/persistence/AbstractStringDataFormat.java

@@ -25,11 +25,66 @@
  */
 package org.lanternpowered.server.data.persistence;
 
+import org.spongepowered.api.data.DataContainer;
+import org.spongepowered.api.data.DataView;
 import org.spongepowered.api.data.persistence.StringDataFormat;
 
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Reader;
+import java.io.StringReader;
+import java.io.StringWriter;
+import java.io.Writer;
+import java.nio.charset.StandardCharsets;
+
 public abstract class AbstractStringDataFormat extends AbstractDataFormat implements StringDataFormat {
 
     public AbstractStringDataFormat(String identifier) {
         super(identifier);
     }
+
+    @Override
+    public DataContainer readFrom(InputStream input) throws IOException {
+        try (BufferedReader reader = new BufferedReader(new InputStreamReader(input, StandardCharsets.UTF_8))) {
+            return readFrom(reader);
+        }
+    }
+
+    @Override
+    public DataContainer read(String input) throws IOException {
+        return readFrom(new StringReader(input));
+    }
+
+    @Override
+    public void writeTo(OutputStream output, DataView data) throws IOException {
+        try (BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(output, StandardCharsets.UTF_8))) {
+            writeTo(writer, data);
+        }
+    }
+
+    @Override
+    public String write(DataView data) throws IOException {
+        final StringWriter writer = new StringWriter();
+        writeTo(writer, data);
+        return writer.toString();
+    }
+
+    protected static BufferedReader ensureBuffered(Reader reader) {
+        if (reader instanceof BufferedReader) {
+            return (BufferedReader) reader;
+        }
+        return new BufferedReader(reader);
+    }
+
+    protected static BufferedWriter ensureBuffered(Writer writer) {
+        if (writer instanceof BufferedWriter) {
+            return (BufferedWriter) writer;
+        }
+        return new BufferedWriter(writer);
+    }
 }

src/main/java/org/lanternpowered/server/data/persistence/HoconDataFormat.java

@@ -33,91 +33,33 @@
 import org.spongepowered.api.data.DataContainer;
 import org.spongepowered.api.data.DataView;
 import org.spongepowered.api.data.persistence.InvalidDataException;
-import org.spongepowered.api.data.persistence.InvalidDataFormatException;
 
-import java.io.BufferedReader;
-import java.io.BufferedWriter;
 import java.io.IOException;
-import java.io.InputStream;
-import java.io.InputStreamReader;
-import java.io.OutputStream;
-import java.io.OutputStreamWriter;
 import java.io.Reader;
-import java.io.StringReader;
-import java.io.StringWriter;
 import java.io.Writer;
-import java.util.concurrent.Callable;
 
 public final class HoconDataFormat extends AbstractStringDataFormat {
 
     public HoconDataFormat(String identifier) {
         super(identifier);
     }
 
-    @Override
-    public DataContainer read(String input) throws InvalidDataException, IOException {
-        return readFrom(() -> new BufferedReader(new StringReader(input)));
-    }
-
     @Override
     public DataContainer readFrom(Reader input) throws InvalidDataException, IOException {
-        return readFrom(() -> createBufferedReader(input));
-    }
-
-    @Override
-    public DataContainer readFrom(InputStream input) throws InvalidDataFormatException, IOException {
         final HoconConfigurationLoader loader = HoconConfigurationLoader.builder()
-                .setSource(() -> new BufferedReader(new InputStreamReader(input)))
+                .setSource(() -> ensureBuffered(input))
                 .build();
-        final ConfigurationNode node = loader.load();
+        final CommentedConfigurationNode node = loader.load();
         return ConfigurateTranslator.instance().translate(node);
     }
 
-    @Override
-    public String write(DataView data) throws IOException {
-        final StringWriter writer = new StringWriter();
-        writeTo(() -> new BufferedWriter(writer), data);
-        return writer.toString();
-    }
-
     @Override
     public void writeTo(Writer output, DataView data) throws IOException {
-        writeTo(() -> createBufferedWriter(output), data);
-    }
-
-    @Override
-    public void writeTo(OutputStream output, DataView data) throws IOException {
-        writeTo(() -> new BufferedWriter(new OutputStreamWriter(output)), data);
-    }
-
-    private static DataContainer readFrom(Callable<BufferedReader> source) throws IOException {
-        final HoconConfigurationLoader loader = HoconConfigurationLoader.builder()
-                .setSource(source)
-                .build();
-        final CommentedConfigurationNode node = loader.load();
-        return ConfigurateTranslator.instance().translate(node);
-    }
-
-    private static void writeTo(Callable<BufferedWriter> sink, DataView data) throws IOException {
         final HoconConfigurationLoader loader = HoconConfigurationLoader.builder()
                 .setHeaderMode(HeaderMode.NONE)
-                .setSink(sink)
+                .setSink(() -> ensureBuffered(output))
                 .build();
         final ConfigurationNode node = ConfigurateTranslator.instance().translate(data);
         loader.save(node);
     }
-
-    private static BufferedReader createBufferedReader(Reader reader) {
-        if (reader instanceof BufferedReader) {
-            return (BufferedReader) reader;
-        }
-        return new BufferedReader(reader);
-    }
-
-    private static BufferedWriter createBufferedWriter(Writer writer) {
-        if (writer instanceof BufferedWriter) {
-            return (BufferedWriter) writer;
-        }
-        return new BufferedWriter(writer);
-    }
 }

src/main/java/org/lanternpowered/server/data/persistence/json/JsonDataFormat.java

@@ -36,54 +36,20 @@
 import org.spongepowered.api.data.DataView;
 import org.spongepowered.api.data.persistence.InvalidDataException;
 
-import java.io.BufferedReader;
-import java.io.BufferedWriter;
 import java.io.IOException;
-import java.io.InputStream;
-import java.io.InputStreamReader;
-import java.io.OutputStream;
-import java.io.OutputStreamWriter;
 import java.io.Reader;
 import java.io.StringReader;
 import java.io.StringWriter;
 import java.io.Writer;
-import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
-import java.util.regex.Pattern;
 
 import javax.annotation.Nullable;
 
 public class JsonDataFormat extends AbstractStringDataFormat {
 
-    private static final String DOUBLE_SUFFIX = "d";
-    private static final String DOUBLE_SUFFIX_UNTYPED = ".0";
-    private static final String FLOAT_SUFFIX = "f";
-    private static final String LONG_SUFFIX = "l";
-    private static final String BYTE_SUFFIX = "b";
-    private static final String SHORT_SUFFIX = "s";
-
-    private static String upperOrLower(String value) {
-        return value + value.toUpperCase();
-    }
-
-    private static final Pattern DOUBLE =
-            Pattern.compile("^[-+]?[0-9]*\\.?[0-9]+[" + upperOrLower(DOUBLE_SUFFIX) + "]$");
-    private static final Pattern DOUBLE_UNTYPED =
-            Pattern.compile("^[-+]?[0-9]*\\.?[0-9]+$");
-    private static final Pattern FLOAT =
-            Pattern.compile("^[-+]?[0-9]*\\.?[0-9]+[" + upperOrLower(FLOAT_SUFFIX) + "]$");
-    private static final Pattern LONG =
-            Pattern.compile("^[-+]?[0-9]+[" + upperOrLower(LONG_SUFFIX) + "]$");
-    private static final Pattern BYTE =
-            Pattern.compile("^[-+]?[0-9]+[" + upperOrLower(BYTE_SUFFIX) + "]$");
-    private static final Pattern SHORT =
-            Pattern.compile("^[-+]?[0-9]+[" + upperOrLower(SHORT_SUFFIX) + "]$");
-    private static final Pattern INTEGER =
-            Pattern.compile("^[-+]?[0-9]+$");
-
     public JsonDataFormat(String identifier) {
         super(identifier);
     }
@@ -95,20 +61,6 @@ public DataContainer readFrom(Reader input) throws InvalidDataException, IOExcep
         }
     }
 
-    @Override
-    public DataContainer readFrom(InputStream input) throws IOException {
-        try (JsonReader reader = new JsonReader(new BufferedReader(new InputStreamReader(input, StandardCharsets.UTF_8)))) {
-            return readContainer(reader);
-        }
-    }
-
-    @Override
-    public DataContainer read(String input) throws IOException {
-        try (JsonReader reader = new JsonReader(new StringReader(input))) {
-            return readContainer(reader);
-        }
-    }
-
     public static DataContainer serialize(Gson gson, Object o) throws IOException {
         final DataViewJsonWriter writer = new DataViewJsonWriter();
         gson.toJson(o, o.getClass(), writer);
@@ -196,40 +148,14 @@ private static Object read0(JsonReader reader) throws IOException {
                 reader.nextNull();
                 return null;
             case STRING:
-                return readString(reader);
+                return reader.nextString();
             case NUMBER:
                 return readNumber(reader);
             default:
                 throw new IOException("Unexpected token: " + token);
         }
     }
 
-    private static Object readString(JsonReader reader) throws IOException {
-        final String value = reader.nextString();
-        if (DOUBLE.matcher(value).matches()) {
-            return Double.parseDouble(value.substring(0, value.length() - 1));
-        } else if (FLOAT.matcher(value).matches()) {
-            return Float.parseFloat(value.substring(0, value.length() - 1));
-        } else if (LONG.matcher(value).matches()) {
-            return Long.parseLong(value.substring(0, value.length() - 1));
-        } else if (SHORT.matcher(value).matches()) {
-            return Short.parseShort(value.substring(0, value.length() - 1));
-        } else if (BYTE.matcher(value).matches()) {
-            return Byte.parseByte(value.substring(0, value.length() - 1));
-        } else if (INTEGER.matcher(value).matches()) {
-            return Integer.parseInt(value);
-        } else if (DOUBLE_UNTYPED.matcher(value).matches()) {
-            return Double.parseDouble(value);
-        } else {
-            if ("true".equalsIgnoreCase(value)) {
-                return true;
-            } else if ("false".equalsIgnoreCase(value)) {
-                return false;
-            }
-            return value;
-        }
-    }
-
     private static Number readNumber(JsonReader reader) throws IOException {
         // Similar to https://github.com/zml2008/configurate/blob/master/configurate-gson/src/main/java/ninja/leaping/configurate/gson/GsonConfigurationLoader.java#L113
         // Not sure what's the best way to detect the type of number
@@ -257,29 +183,13 @@ private static List<?> readArray(JsonReader reader) throws IOException {
         return result;
     }
 
-    @Override
-    public void writeTo(OutputStream output, DataView data) throws IOException {
-        try (JsonWriter writer = new JsonWriter(new BufferedWriter(new OutputStreamWriter(output, StandardCharsets.UTF_8)))) {
-            writeView(writer, data);
-        }
-    }
-
     @Override
     public void writeTo(Writer output, DataView data) throws IOException {
         try (JsonWriter writer = new JsonWriter(output)) {
             writeView(writer, data);
         }
     }
 
-    @Override
-    public String write(DataView data) throws IOException {
-        final StringWriter writer = new StringWriter();
-        try (JsonWriter jsonWriter = new JsonWriter(writer)) {
-            writeView(jsonWriter, data);
-        }
-        return writer.toString();
-    }
-
     private static void writeView(JsonWriter writer, DataView view) throws IOException {
         writer.beginObject();
         for (Map.Entry<DataQuery, Object> entry : view.getValues(false).entrySet()) {
@@ -308,24 +218,7 @@ public static void write(JsonWriter writer, @Nullable Object value) throws IOExc
         } else if (value instanceof Boolean) {
             writer.value((Boolean) value);
         } else if (value instanceof Number) {
-            if (value instanceof Double) {
-                String dbl = Double.toString((Double) value);
-                if (dbl.indexOf('.') == -1) {
-                    dbl += DOUBLE_SUFFIX_UNTYPED;
-                }
-                // Writes a raw json value, without quotes
-                writer.jsonValue(dbl);
-            } else if (value instanceof Float) {
-                writer.value(value + FLOAT_SUFFIX);
-            } else if (value instanceof Long) {
-                writer.value(value + LONG_SUFFIX);
-            } else if (value instanceof Byte) {
-                writer.value(value + BYTE_SUFFIX);
-            } else if (value instanceof Short) {
-                writer.value(value + SHORT_SUFFIX);
-            } else {
-                writer.value((Number) value);
-            }
+            writer.value((Number) value);
         } else if (value instanceof String) {
             writer.value((String) value);
         } else if (value instanceof Iterable) {