diff --git a/src/main/java/fun/bb1/toml/Toml.java b/src/main/java/fun/bb1/toml/Toml.java index 008ef44..fe56736 100644 --- a/src/main/java/fun/bb1/toml/Toml.java +++ b/src/main/java/fun/bb1/toml/Toml.java @@ -12,6 +12,8 @@ import org.tomlj.TomlParseError; import org.tomlj.TomlParseResult; import org.tomlj.TomlTable; +import fun.bb1.toml.tomj.TomlJ; + public final class Toml { private Toml() { } @@ -62,7 +64,7 @@ public final class Toml { } private static final @Nullable Object recurse(@NotNull final ITomlElement toml) { - return new TomlJBuilder().recurse(toml); + return TomlJ.recurse(toml); } } diff --git a/src/main/java/fun/bb1/toml/TomlJBuilder.java b/src/main/java/fun/bb1/toml/TomlJBuilder.java deleted file mode 100644 index 9558627..0000000 --- a/src/main/java/fun/bb1/toml/TomlJBuilder.java +++ /dev/null @@ -1,165 +0,0 @@ -package fun.bb1.toml; - -import java.lang.reflect.Constructor; -import java.lang.reflect.Field; -import java.lang.reflect.InaccessibleObjectException; -import java.lang.reflect.InvocationTargetException; -import java.lang.reflect.Method; -import java.util.Map; - -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.tomlj.TomlArray; -import org.tomlj.TomlInvalidTypeException; -import org.tomlj.TomlPosition; -import org.tomlj.TomlTable; -import org.tomlj.TomlVersion; - -import fun.bb1.exceptions.handler.ExceptionHandler; - -final class TomlJBuilder { - - private static final @NotNull Class TOML_TABLE = ExceptionHandler.handle(()->Class.forName("org.tomlj.MutableTomlTable")); - private static final @NotNull Constructor TOML_TABLE_CONSTRUCTOR = ExceptionHandler.handle(()->TOML_TABLE.getConstructor(TomlVersion.class, TomlPosition.class)); - private static final @NotNull Field TOML_TABLE_PROPERTIES = ExceptionHandler.handle(()->TOML_TABLE.getField("properties")); - - private static final @NotNull Class TOML_TABLE_ELEMENT = ExceptionHandler.handle(()->Class.forName("org.tomlj.MutableTomlTable$Element")); - private static final @NotNull Constructor TOML_TABLE_ELEMENT_CONSTRUCTOR = ExceptionHandler.handle(()->TOML_TABLE_ELEMENT.getConstructor(Object.class, TomlPosition.class)); - - private static final @NotNull Class TOML_ARRAY = ExceptionHandler.handle(()->Class.forName("org.tomlj.MutableTomlArray")); - private static final @NotNull Method TOML_ARRAY_CREATE = ExceptionHandler.handle(()->TOML_ARRAY.getMethod("create", TomlVersion.class, boolean.class)); - private static final @NotNull Method TOML_ARRAY_APPEND = ExceptionHandler.handle(()->TOML_ARRAY.getMethod("append", Object.class, TomlPosition.class)); - - private int row = 1; - private int column = 1; - - TomlJBuilder() { - try { - TOML_TABLE_CONSTRUCTOR.setAccessible(true); - TOML_TABLE_PROPERTIES.setAccessible(true); - TOML_TABLE_ELEMENT_CONSTRUCTOR.setAccessible(true); - TOML_ARRAY_CREATE.setAccessible(true); - TOML_ARRAY_APPEND.setAccessible(true); - } catch (InaccessibleObjectException | SecurityException e) { - System.err.println("Failed to open up the required fields for toml, please report this as a bug!"); - e.printStackTrace(); - } - } - - public final @Nullable Object recurse(@NotNull final ITomlElement toml) { - if (toml instanceof TomlPrimitive primitive) return primitive.getInner(); - if (toml instanceof fun.bb1.toml.TomlArray tomlArray) { - @Nullable final TomlArray array = buildArray(); - if (array == null) return null; - for (int i = 0; i < tomlArray.getSize(); i++) { - int row = this.row; - this.row++; - @NotNull final ITomlElement preConversionObject = tomlArray.get(i); - if (preConversionObject.isTomlArray() || preConversionObject.isTomlObject()) { - this.column++; - } - @Nullable final Object convertedObject = recurse(preConversionObject); - if (preConversionObject.isTomlArray() || preConversionObject.isTomlObject()) { - this.column--; - } - if (convertedObject == null) { - this.row--; - continue; - } - if (!appendToArray(array, convertedObject, row)) { - this.row--; - } - } - return array; - } - @NotNull final TomlObject tomlObject = toml.getAsTomlObject(); - @Nullable final TomlTable table = buildTable(); - if (table == null) return null; - for (@NotNull final String key : tomlObject) { - @NotNull final ITomlElement preConversionObject = tomlObject.get(key); - int row = this.row; - this.row++; - if (preConversionObject.isTomlArray() || preConversionObject.isTomlObject()) { - this.column++; - } - @Nullable final Object convertedObject = recurse(preConversionObject); - if (preConversionObject.isTomlArray() || preConversionObject.isTomlObject()) { - this.column--; - } - if (convertedObject == null) { - this.row--; - continue; - } - if (!putOnTable(table, key, convertedObject, row)) { - this.row--; - } - } - return tomlObject; - } - - private final @NotNull TomlPosition getPosition() { - return TomlPosition.positionAt(this.row, this.column); - } - - private final @Nullable TomlArray buildArray() { - return (TomlArray) new ExceptionHandler<>(()->TOML_ARRAY_CREATE.invoke(null, TomlVersion.LATEST)).catcher((e) -> { - System.err.println("Failed to load TomlArray instance via reflection, please report this as a bug!"); - e.printStackTrace(); - return null; - }).get(); - } - - private final boolean appendToArray(@NotNull final TomlArray tomlArray, @NotNull Object convertedObject, int row) { - try { - if (convertedObject instanceof Double || convertedObject instanceof Float) { - convertedObject = ((Number)convertedObject).floatValue(); - } else if (convertedObject instanceof Number num) { - convertedObject = num.intValue(); - } - TOML_ARRAY_APPEND.invoke(tomlArray, convertedObject, TomlPosition.positionAt(row, this.column)); - return true; - } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) { - System.err.println("Failed to append to a TomlArray instance via reflection, please report this as a bug!"); - e.printStackTrace(); - } catch (TomlInvalidTypeException t) { - System.err.println("Failed to append to a TomlArray instance via reflection, this may be an issue with your Toml!"); - t.printStackTrace(); - } - return false; - } - - private final @Nullable TomlTable buildTable() { - return (TomlTable) new ExceptionHandler<>(()->TOML_TABLE_CONSTRUCTOR.newInstance(TomlVersion.LATEST, getPosition())).catcher((e) -> { - System.err.println("Failed to load TomlTable instance via reflection, please report this as a bug!"); - e.printStackTrace(); - return null; - }).get(); - } - - public final boolean putOnTable(@NotNull final TomlTable table, @NotNull final String key, @NotNull final Object convertedObject, int row) { - final @Nullable Map properties = getPropertiesOfTable(table); - if (properties == null) return false; - @Nullable final Object builtElement = buildTableElement(convertedObject); - if (builtElement == null) return false; - properties.put(key, builtElement); - return true; - } - - @SuppressWarnings("unchecked") - private final @Nullable Map getPropertiesOfTable(@NotNull final TomlTable tomlTable) { - return (Map) new ExceptionHandler<>(()->TOML_TABLE_PROPERTIES.get(tomlTable)).catcher((e) -> { - System.err.println("Failed to get TomlTable's properties via reflection, please report this as a bug!"); - e.printStackTrace(); - return null; - }).get(); - } - - private final @Nullable Object buildTableElement(@NotNull final Object toContain) { - return (TomlTable) new ExceptionHandler<>(()->TOML_TABLE_ELEMENT_CONSTRUCTOR.newInstance(toContain, getPosition())).catcher((e) -> { - System.err.println("Failed to load TomlTable$Element instance via reflection, please report this as a bug!"); - e.printStackTrace(); - return null; - }).get(); - } - -} diff --git a/src/main/java/fun/bb1/toml/tomj/TomlJ.java b/src/main/java/fun/bb1/toml/tomj/TomlJ.java new file mode 100644 index 0000000..f16bda4 --- /dev/null +++ b/src/main/java/fun/bb1/toml/tomj/TomlJ.java @@ -0,0 +1,33 @@ +package fun.bb1.toml.tomj; + +import org.jetbrains.annotations.ApiStatus.Internal; +import org.jetbrains.annotations.NotNull; + +import fun.bb1.toml.ITomlElement; +import fun.bb1.toml.TomlObject; +import fun.bb1.toml.TomlPrimitive; + +@Internal +public final class TomlJ { + + private TomlJ() { } + + @Internal + public static final @NotNull Object recurse(@NotNull final ITomlElement toml) { + if (toml instanceof TomlPrimitive primitive) return primitive.getInner(); + if (toml instanceof fun.bb1.toml.TomlArray tomlArray) { + @NotNull final TomlJArray array = new TomlJArray(); + for (int i = 0; i < tomlArray.getSize(); i++) { + array.add(recurse(tomlArray.get(i))); + } + return array; + } + @NotNull final TomlObject tomlObject = toml.getAsTomlObject(); + @NotNull final TomlJTable table = new TomlJTable(); + for (@NotNull final String key : tomlObject) { + table.put(key, recurse(tomlObject.get(key))); + } + return table; + } + +} diff --git a/src/main/java/fun/bb1/toml/tomj/TomlJArray.java b/src/main/java/fun/bb1/toml/tomj/TomlJArray.java new file mode 100644 index 0000000..c5ae8c8 --- /dev/null +++ b/src/main/java/fun/bb1/toml/tomj/TomlJArray.java @@ -0,0 +1,119 @@ +package fun.bb1.toml.tomj; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.jetbrains.annotations.NotNull; +import org.tomlj.TomlArray; +import org.tomlj.TomlPosition; + +final class TomlJArray extends ArrayList implements TomlArray { + + private static final long serialVersionUID = 934814329241781225L; + + TomlJArray() {} + + private final @NotNull Object check(@NotNull final Object e) { + if (e instanceof Number num) { + if (num instanceof Double || num instanceof Float) { + return num.doubleValue(); + } + return num.longValue(); + } + return e; + } + + @Override + public boolean add(Object e) { + return super.add(check(e)); + } + + @Override + public void add(int index, Object e) { + super.add(index, check(e)); + } + + @Override + public boolean addAll(Collection c) { + return super.addAll(c.stream().map(this::check).toList()); + } + + @Override + public boolean addAll(int index, Collection c) { + return super.addAll(index, c.stream().map(this::check).toList()); + } + + @Override + public boolean containsStrings() { + // Should never be called + throw new RuntimeException("Should not be here!"); + } + + @Override + public boolean containsLongs() { + // Should never be called + throw new RuntimeException("Should not be here!"); + } + + @Override + public boolean containsDoubles() { + // Should never be called + throw new RuntimeException("Should not be here!"); + } + + @Override + public boolean containsBooleans() { + // Should never be called + throw new RuntimeException("Should not be here!"); + } + + @Override + public boolean containsOffsetDateTimes() { + // Should never be called + throw new RuntimeException("Should not be here!"); + } + + @Override + public boolean containsLocalDateTimes() { + // Should never be called + throw new RuntimeException("Should not be here!"); + } + + @Override + public boolean containsLocalDates() { + // Should never be called + throw new RuntimeException("Should not be here!"); + } + + @Override + public boolean containsLocalTimes() { + // Should never be called + throw new RuntimeException("Should not be here!"); + } + + @Override + public boolean containsArrays() { + // Should never be called + throw new RuntimeException("Should not be here!"); + } + + @Override + public boolean containsTables() { + // Should never be called + throw new RuntimeException("Should not be here!"); + } + + @Override + public TomlPosition inputPositionOf(int index) { + // Should never be called + throw new RuntimeException("Should not be here!"); + } + + @Override + public List toList() { + return this; + } + + +} diff --git a/src/main/java/fun/bb1/toml/tomj/TomlJTable.java b/src/main/java/fun/bb1/toml/tomj/TomlJTable.java new file mode 100644 index 0000000..92352bd --- /dev/null +++ b/src/main/java/fun/bb1/toml/tomj/TomlJTable.java @@ -0,0 +1,68 @@ +package fun.bb1.toml.tomj; + +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.tomlj.TomlPosition; +import org.tomlj.TomlTable; + +final class TomlJTable extends HashMap implements TomlTable { + + private static final long serialVersionUID = 4693375646889181151L; + + TomlJTable() {} + + private final @NotNull Object check(@NotNull final Object e) { + if (e instanceof Number num) { + if (num instanceof Double || num instanceof Float) { + return num.doubleValue(); + } + return num.longValue(); + } + return e; + } + + @Override + public Object put(String key, Object value) { + return super.put(key, check(value)); + } + + @Override + public Object putIfAbsent(String key, Object value) { + return super.putIfAbsent(key, check(value)); + } + + @Override + public Set> keyPathSet(boolean includeTables) { + // Not called by serialiser so can be ignored + throw new RuntimeException("Should not be here!"); + } + + @Override + public Set, Object>> entryPathSet(boolean includeTables) { + // Not called by serialiser so can be ignored + throw new RuntimeException("Should not be here!"); + } + + @Override + public @Nullable Object get(List path) { + // Not called by serialiser so can be ignored + throw new RuntimeException("Should not be here!"); + } + + @Override + public @Nullable TomlPosition inputPositionOf(List path) { + // Not called by serialiser so can be ignored + throw new RuntimeException("Should not be here!"); + } + + @Override + public Map toMap() { + return this; + } + +}