From bb5ddf3142f6014fdc3b7244dfb4c11cb39859dd Mon Sep 17 00:00:00 2001 From: Speiger Date: Wed, 29 Sep 2021 14:12:14 +0200 Subject: [PATCH] Upgraded engine and moved PrettyJsonWriter into the engine --- build.gradle | 2 +- .../rendering/models/GLDataType.java | 10 + .../utils/collections/CollectionUtils.java | 5 +- .../coreengine/utils/helpers/JsonUtil.java | 116 +++++++++++- .../coreengine/utils/io/PrettyGsonWriter.java | 176 ++++++++++++++++++ 5 files changed, 305 insertions(+), 4 deletions(-) create mode 100644 src/main/java/speiger/src/coreengine/utils/io/PrettyGsonWriter.java diff --git a/build.gradle b/build.gradle index a126c13..600e8f3 100644 --- a/build.gradle +++ b/build.gradle @@ -64,5 +64,5 @@ dependencies { compile 'com.google.code.gson:gson:2.8.6' //Primitive Collections - compile 'de.speiger:Primitive-Collections:0.4.0' + compile 'de.speiger:Primitive-Collections:0.4.1' } \ No newline at end of file diff --git a/src/main/java/speiger/src/coreengine/rendering/models/GLDataType.java b/src/main/java/speiger/src/coreengine/rendering/models/GLDataType.java index 56be93c..5aff763 100644 --- a/src/main/java/speiger/src/coreengine/rendering/models/GLDataType.java +++ b/src/main/java/speiger/src/coreengine/rendering/models/GLDataType.java @@ -82,4 +82,14 @@ public class GLDataType { return ignoreAttributeSize ? dataType.getByteSize() : attributeSize * dataType.getByteSize(); } + + public static GLDataType byName(String name) + { + return NAME_TO_TYPE.get(name); + } + + public static GLDataType byID(int id) + { + return ID_TO_TYPE.get(id); + } } diff --git a/src/main/java/speiger/src/coreengine/utils/collections/CollectionUtils.java b/src/main/java/speiger/src/coreengine/utils/collections/CollectionUtils.java index d9d4ca7..9476b9a 100644 --- a/src/main/java/speiger/src/coreengine/utils/collections/CollectionUtils.java +++ b/src/main/java/speiger/src/coreengine/utils/collections/CollectionUtils.java @@ -8,6 +8,7 @@ import speiger.src.collections.ints.maps.impl.hash.Int2ObjectLinkedOpenHashMap; import speiger.src.collections.ints.maps.impl.hash.Int2ObjectOpenHashMap; import speiger.src.collections.ints.maps.interfaces.Int2ObjectMap; import speiger.src.collections.objects.lists.ObjectArrayList; +import speiger.src.collections.objects.lists.ObjectList; import speiger.src.collections.objects.sets.ObjectLinkedOpenHashSet; import speiger.src.collections.objects.sets.ObjectOpenHashSet; @@ -32,9 +33,9 @@ public class CollectionUtils return sets; } - public static List[] createList(int size) + public static ObjectList[] createList(int size) { - List[] list = new List[size]; + ObjectList[] list = new ObjectList[size]; for(int i = 0;i(); diff --git a/src/main/java/speiger/src/coreengine/utils/helpers/JsonUtil.java b/src/main/java/speiger/src/coreengine/utils/helpers/JsonUtil.java index b8410ef..5156720 100644 --- a/src/main/java/speiger/src/coreengine/utils/helpers/JsonUtil.java +++ b/src/main/java/speiger/src/coreengine/utils/helpers/JsonUtil.java @@ -8,6 +8,7 @@ import java.io.InputStreamReader; import java.io.Reader; import java.nio.file.Files; import java.nio.file.Path; +import java.util.List; import java.util.function.BiConsumer; import java.util.function.Consumer; @@ -15,6 +16,7 @@ import com.google.gson.JsonArray; import com.google.gson.JsonElement; import com.google.gson.JsonObject; import com.google.gson.JsonParser; +import com.google.gson.JsonPrimitive; public class JsonUtil { @@ -83,6 +85,19 @@ public class JsonUtil } } + public static void iterateValues(JsonElement element, Consumer result) + { + if(element.isJsonPrimitive()) result.accept(element.getAsJsonPrimitive()); + else if(element.isJsonArray()) + { + JsonArray array = element.getAsJsonArray(); + for(int i = 0,m=array.size();i values) + { + JsonArray array = new JsonArray(); + for(int i = 0,m=values.size();i singleLineObjects = new HashSet<>(); + + + public PrettyGsonWriter(Writer out) + { + this(new Overrider(out)); + } + + public PrettyGsonWriter(Writer out, String indent) + { + this(new Overrider(out)); + setTabs(indent); + } + + private PrettyGsonWriter(Overrider rider) + { + super(rider); + rider.owner = this; + } + + public PrettyGsonWriter addSinlgeLines(String... names) + { + singleLineObjects.addAll(Arrays.asList(names)); + return this; + } + + public void setTabs(String key) + { + setIndent(key); + if(key.length() == 0) indent = null; + else indent = key; + } + + private void push(boolean value, boolean object) + { + if(indent == null) return; + if(value) + { + if(++arrayPointer >= usedArrays.length) usedArrays = Arrays.copyOf(usedArrays, usedArrays.length * 2); + if(!object && ++namePointer >= singleNames.length) singleNames = Arrays.copyOf(singleNames, singleNames.length * 2); + } + else if((blocked.top() & 1) != 0) usedArrays[arrayPointer]++; + blocked.push((byte)((value ? 1 : 0) | (value && !object ? 2 : 0))); + } + + private void pop() + { + if(indent == null) return; + byte value = blocked.pop(); + if((value & 1) != 0) usedArrays[arrayPointer--] = 0; + if((value & 2) != 0) singleNames[namePointer--] = null; + } + + @Override + public JsonWriter name(String name) throws IOException + { + if(singleLineObjects.contains(name)) nextArray = name; + return super.name(name); + } + + @Override + public JsonWriter beginArray() throws IOException + { + super.beginArray(); + push(true, false); + singleNames[namePointer] = nextArray; + nextArray = null; + return this; + } + + @Override + public JsonWriter beginObject() throws IOException + { + boolean shouldRework = shouldBlockObject(); + push(false, true); + super.beginObject(); + if(shouldRework) push(shouldRework, true); + return this; + } + + @Override + public JsonWriter endArray() throws IOException + { + boolean ignore = usedArrays[arrayPointer] > 0; + if(ignore) pop(); + super.endArray(); + if(!ignore) pop(); + return this; + } + + @Override + public JsonWriter endObject() throws IOException + { + super.endObject(); + if(shouldBlockObject()) pop(); + pop(); + return this; + } + + public boolean shouldBlockObject() + { + return singleNames[namePointer] != null; + } + + public boolean isBlocked() + { + return (blocked.top() & 1) != 0; + } + + public static class Overrider extends BufferedWriter + { + PrettyGsonWriter owner; + public Overrider(Writer out) + { + super(out); + } + + @Override + public void write(int c) throws IOException + { + if(owner.indent != null && owner.isBlocked()) + { + if(c == '\n') return; + else if(c == ',' && owner.shouldBlockObject()) + { + super.write(", "); + return; + } + } + super.write(c); + } + + @Override + public Writer append(char c) throws IOException + { + if(owner.indent != null && c == ',' && owner.isBlocked() && (owner.usedArrays[owner.arrayPointer] <= 0)) + { + super.write(", "); + return this; + } + return super.append(c); + } + + @Override + public void write(String str) throws IOException + { + if(owner.indent != null && owner.isBlocked() && str.equals(owner.indent)) return; + super.write(str); + } + } +}