Gson interface (#109)

* Add gson-interface

* Add gson-interface

* Update license things

12 files changed, 1130 insertions, 10 deletions

diff --git a/api/OneConfig.api b/api/OneConfig.api
index c6b2936..60c800f 100644
--- a/api/OneConfig.api
+++ b/api/OneConfig.api
@@ -332,23 +332,73 @@ public class cc/polyfrost/oneconfig/config/elements/OptionSubcategory {
 	public fun reset (Lcc/polyfrost/oneconfig/config/Config;)V
 }
 
-public class cc/polyfrost/oneconfig/config/gson/ExclusionUtils {
+public class cc/polyfrost/oneconfig/config/gson/exclusion/ExclusionUtils {
 	public fun <init> ()V
 	protected static fun isSuperClassOf (Ljava/lang/Class;Ljava/lang/Class;)Z
 }
 
-public class cc/polyfrost/oneconfig/config/gson/NonProfileSpecificExclusionStrategy : cc/polyfrost/oneconfig/config/gson/ExclusionUtils, com/google/gson/ExclusionStrategy {
+public class cc/polyfrost/oneconfig/config/gson/exclusion/NonProfileSpecificExclusionStrategy : cc/polyfrost/oneconfig/config/gson/exclusion/ExclusionUtils, com/google/gson/ExclusionStrategy {
 	public fun <init> ()V
 	public fun shouldSkipClass (Ljava/lang/Class;)Z
 	public fun shouldSkipField (Lcom/google/gson/FieldAttributes;)Z
 }
 
-public class cc/polyfrost/oneconfig/config/gson/ProfileExclusionStrategy : cc/polyfrost/oneconfig/config/gson/ExclusionUtils, com/google/gson/ExclusionStrategy {
+public class cc/polyfrost/oneconfig/config/gson/exclusion/ProfileExclusionStrategy : cc/polyfrost/oneconfig/config/gson/exclusion/ExclusionUtils, com/google/gson/ExclusionStrategy {
 	public fun <init> ()V
 	public fun shouldSkipClass (Ljava/lang/Class;)Z
 	public fun shouldSkipField (Lcom/google/gson/FieldAttributes;)Z
 }
 
+public class cc/polyfrost/oneconfig/config/gson/gsoninterface/GsonContext {
+	public fun <init> (Lcom/google/gson/Gson;Lcc/polyfrost/oneconfig/config/gson/gsoninterface/InterfaceAdapterFactory$InterfaceTypeAdapter;)V
+	public fun fromJsonTree (Lcom/google/gson/JsonElement;Ljava/lang/Class;)Ljava/lang/Object;
+	public fun fromJsonTree (Lcom/google/gson/JsonElement;Ljava/lang/reflect/Type;)Ljava/lang/Object;
+	public fun thisFromJsonTree (Lcom/google/gson/JsonElement;)Ljava/lang/Object;
+	public fun thisFromJsonTree (Lcom/google/gson/JsonElement;Ljava/lang/reflect/Type;)Ljava/lang/Object;
+	public fun thisToJsonTree (Ljava/lang/Object;)Lcom/google/gson/JsonElement;
+	public fun toJsonTree (Ljava/lang/Object;)Lcom/google/gson/JsonElement;
+}
+
+public class cc/polyfrost/oneconfig/config/gson/gsoninterface/InterfaceAdapterFactory : com/google/gson/TypeAdapterFactory {
+	public fun <init> ()V
+	public fun create (Lcom/google/gson/Gson;Lcom/google/gson/reflect/TypeToken;)Lcom/google/gson/TypeAdapter;
+}
+
+public class cc/polyfrost/oneconfig/config/gson/gsoninterface/InterfaceAdapterFactory$InterfaceTypeAdapter : com/google/gson/TypeAdapter {
+	public fun read (Lcom/google/gson/stream/JsonReader;)Ljava/lang/Object;
+	public fun write (Lcom/google/gson/stream/JsonWriter;Ljava/lang/Object;)V
+}
+
+public abstract interface class cc/polyfrost/oneconfig/config/gson/gsoninterface/JsonDeserialization {
+}
+
+public abstract interface class cc/polyfrost/oneconfig/config/gson/gsoninterface/JsonDeserializes {
+	public abstract fun fromJsonTree (Lcom/google/gson/JsonElement;Ljava/lang/reflect/Type;Lcc/polyfrost/oneconfig/config/gson/gsoninterface/GsonContext;)Ljava/lang/Object;
+}
+
+public abstract interface class cc/polyfrost/oneconfig/config/gson/gsoninterface/JsonSerialization {
+	public abstract fun toJsonTree (Lcc/polyfrost/oneconfig/config/gson/gsoninterface/GsonContext;)Lcom/google/gson/JsonElement;
+}
+
+public class cc/polyfrost/oneconfig/config/gson/gsoninterface/Reflection {
+	public fun <init> ()V
+	public static fun classOfType (Ljava/lang/reflect/Type;)Ljava/lang/Class;
+	public static fun constructAnyway (Ljava/lang/reflect/Constructor;[Ljava/lang/Object;)Ljava/lang/Object;
+	public static fun getAccessibleField (Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/reflect/Field;
+	public static fun getConstructor (Ljava/lang/Class;[Ljava/lang/Class;)Ljava/lang/reflect/Constructor;
+	public static fun getFieldValue (Ljava/lang/reflect/Field;Ljava/lang/Object;)Ljava/lang/Object;
+	public static fun getParameterBounds (Ljava/lang/Class;)[Ljava/lang/Class;
+	public static fun getTypeParameters (Ljava/lang/Class;Ljava/lang/Class;)[Ljava/lang/Class;
+	public static fun isAbstract (Ljava/lang/Class;)Z
+	public static fun newInstance (Ljava/lang/Class;)Ljava/lang/Object;
+}
+
+public class cc/polyfrost/oneconfig/config/gson/gsoninterface/Reflection$Stack : java/util/ArrayList {
+	public fun <init> ()V
+	public fun pop ()Ljava/lang/Object;
+	public fun push (Ljava/lang/Object;)Lcc/polyfrost/oneconfig/config/gson/gsoninterface/Reflection$Stack;
+}
+
 public class cc/polyfrost/oneconfig/config/migration/CfgMigrator : cc/polyfrost/oneconfig/config/migration/Migrator {
 	public fun <init> (Ljava/lang/String;)V
 	protected fun generateValues ()V
diff --git a/src/main/java/cc/polyfrost/oneconfig/config/Config.java b/src/main/java/cc/polyfrost/oneconfig/config/Config.java
index eb74d2a..87ade90 100644
--- a/src/main/java/cc/polyfrost/oneconfig/config/Config.java
+++ b/src/main/java/cc/polyfrost/oneconfig/config/Config.java
@@ -34,8 +34,9 @@ import cc.polyfrost.oneconfig.config.data.PageLocation;
 import cc.polyfrost.oneconfig.config.elements.BasicOption;
 import cc.polyfrost.oneconfig.config.elements.OptionPage;
 import cc.polyfrost.oneconfig.config.elements.OptionSubcategory;
-import cc.polyfrost.oneconfig.config.gson.NonProfileSpecificExclusionStrategy;
-import cc.polyfrost.oneconfig.config.gson.ProfileExclusionStrategy;
+import cc.polyfrost.oneconfig.config.gson.exclusion.NonProfileSpecificExclusionStrategy;
+import cc.polyfrost.oneconfig.config.gson.exclusion.ProfileExclusionStrategy;
+import cc.polyfrost.oneconfig.config.gson.gsoninterface.InterfaceAdapterFactory;
 import cc.polyfrost.oneconfig.gui.elements.config.ConfigKeyBind;
 import cc.polyfrost.oneconfig.gui.OneConfigGui;
 import cc.polyfrost.oneconfig.gui.elements.config.ConfigPageButton;
@@ -63,8 +64,18 @@ import java.util.function.Supplier;
 public class Config {
     public final transient HashMap<String, BasicOption> optionNames = new HashMap<>();
     transient protected final String configFile;
-    transient protected final Gson gson = new GsonBuilder().setExclusionStrategies(new ProfileExclusionStrategy()).excludeFieldsWithModifiers(Modifier.TRANSIENT).setPrettyPrinting().create();
-    transient protected final Gson nonProfileSpecificGson = new GsonBuilder().setExclusionStrategies(new NonProfileSpecificExclusionStrategy()).excludeFieldsWithModifiers(Modifier.TRANSIENT).setPrettyPrinting().create();
+    transient protected final Gson gson = new GsonBuilder()
+            .setExclusionStrategies(new ProfileExclusionStrategy())
+            .registerTypeAdapterFactory(new InterfaceAdapterFactory())
+            .excludeFieldsWithModifiers(Modifier.TRANSIENT)
+            .setPrettyPrinting()
+            .create();
+    transient protected final Gson nonProfileSpecificGson = new GsonBuilder()
+            .setExclusionStrategies(new NonProfileSpecificExclusionStrategy())
+            .registerTypeAdapterFactory(new InterfaceAdapterFactory())
+            .excludeFieldsWithModifiers(Modifier.TRANSIENT)
+            .setPrettyPrinting()
+            .create();
     transient protected final HashMap<Field, Object> defaults = new HashMap<>();
     transient public Mod mod;
     public boolean enabled;
diff --git a/src/main/java/cc/polyfrost/oneconfig/config/gson/ExclusionUtils.java b/src/main/java/cc/polyfrost/oneconfig/config/gson/exclusion/ExclusionUtils.java
index 031efa6..efad110 100644
--- a/src/main/java/cc/polyfrost/oneconfig/config/gson/ExclusionUtils.java
+++ b/src/main/java/cc/polyfrost/oneconfig/config/gson/exclusion/ExclusionUtils.java
@@ -24,7 +24,7 @@
  * <https://polyfrost.cc/legal/oneconfig/additional-terms>
  */
 
-package cc.polyfrost.oneconfig.config.gson;
+package cc.polyfrost.oneconfig.config.gson.exclusion;
 
 public class ExclusionUtils {
     protected static boolean isSuperClassOf(Class<?> clazz, Class<?> parentClass) {
diff --git a/src/main/java/cc/polyfrost/oneconfig/config/gson/NonProfileSpecificExclusionStrategy.java b/src/main/java/cc/polyfrost/oneconfig/config/gson/exclusion/NonProfileSpecificExclusionStrategy.java
index 82dd1c5..ae4e7ac 100644
--- a/src/main/java/cc/polyfrost/oneconfig/config/gson/NonProfileSpecificExclusionStrategy.java
+++ b/src/main/java/cc/polyfrost/oneconfig/config/gson/exclusion/NonProfileSpecificExclusionStrategy.java
@@ -24,7 +24,7 @@
  * <https://polyfrost.cc/legal/oneconfig/additional-terms>
  */
 
-package cc.polyfrost.oneconfig.config.gson;
+package cc.polyfrost.oneconfig.config.gson.exclusion;
 
 import cc.polyfrost.oneconfig.config.Config;
 import cc.polyfrost.oneconfig.config.annotations.Exclude;
diff --git a/src/main/java/cc/polyfrost/oneconfig/config/gson/ProfileExclusionStrategy.java b/src/main/java/cc/polyfrost/oneconfig/config/gson/exclusion/ProfileExclusionStrategy.java
index 3f0a97b..e15a6ec 100644
--- a/src/main/java/cc/polyfrost/oneconfig/config/gson/ProfileExclusionStrategy.java
+++ b/src/main/java/cc/polyfrost/oneconfig/config/gson/exclusion/ProfileExclusionStrategy.java
@@ -24,7 +24,7 @@
  * <https://polyfrost.cc/legal/oneconfig/additional-terms>
  */
 
-package cc.polyfrost.oneconfig.config.gson;
+package cc.polyfrost.oneconfig.config.gson.exclusion;
 
 import cc.polyfrost.oneconfig.config.Config;
 import cc.polyfrost.oneconfig.config.annotations.Exclude;
diff --git a/src/main/java/cc/polyfrost/oneconfig/config/gson/gsoninterface/GsonContext.java b/src/main/java/cc/polyfrost/oneconfig/config/gson/gsoninterface/GsonContext.java
new file mode 100644
index 0000000..e27a362
--- /dev/null
+++ b/src/main/java/cc/polyfrost/oneconfig/config/gson/gsoninterface/GsonContext.java
@@ -0,0 +1,123 @@
+package cc.polyfrost.oneconfig.config.gson.gsoninterface;
+
+/*
+ * This file is part of OneConfig.
+ * OneConfig - Next Generation Config Library for Minecraft: Java Edition
+ * Copyright (C) 2021, 2022 Polyfrost.
+ *
+ *   <https://polyfrost.cc> <https://github.com/Polyfrost/>
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ *   OneConfig is licensed under the terms of version 3 of the GNU Lesser
+ * General Public License as published by the Free Software Foundation, AND
+ * under the Additional Terms Applicable to OneConfig, as published by Polyfrost,
+ * either version 1.0 of the Additional Terms, or (at your option) any later
+ * version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Lesser General Public
+ * License.  If not, see <https://www.gnu.org/licenses/>. You should
+ * have also received a copy of the Additional Terms Applicable
+ * to OneConfig, as published by Polyfrost. If not, see
+ * <https://polyfrost.cc/legal/oneconfig/additional-terms>
+
+ * This file contains an adaptation of code from gson-interface
+ * Project found at <https://github.com/mintern/gson-interface>
+ * For the avoidance of doubt, this file is still licensed under the terms
+ * of OneConfig's Licensing.
+ *
+ *                 LICENSE NOTICE FOR ADAPTED CODE
+ *
+ * Copyright (C) 2012, Brandon Mintern, EasyESI, Berkeley, CA
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither gson-interface nor the names of its contributors may be used
+ *     to endorse or promote products derived from this software without
+ *     specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+ * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL BRANDON MINTERN OR EASYESI BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+import com.google.gson.Gson;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonIOException;
+import com.google.gson.TypeAdapter;
+import com.google.gson.internal.bind.JsonTreeReader;
+import com.google.gson.internal.bind.JsonTreeWriter;
+
+import java.io.IOException;
+import java.lang.reflect.Type;
+
+/**
+ * @author mintern
+ */
+public class GsonContext<T> {
+    private final Gson gson;
+    private final InterfaceAdapterFactory.InterfaceTypeAdapter<T> constructingAdapter;
+
+    public GsonContext(Gson g, InterfaceAdapterFactory.InterfaceTypeAdapter<T> ita) {
+        gson = g;
+        constructingAdapter = ita;
+    }
+
+    public JsonElement toJsonTree(Object obj) {
+        return gson.toJsonTree(obj);
+    }
+
+    public JsonElement thisToJsonTree(T obj) throws JsonIOException {
+        JsonTreeWriter writer = new JsonTreeWriter();
+        try {
+            constructingAdapter.getDelegate().write(writer, obj);
+        } catch (IOException e) {
+            throw new JsonIOException(e);
+        }
+        return writer.get();
+    }
+
+    public <C> C fromJsonTree(JsonElement json, Class<C> type) {
+        return gson.fromJson(json, type);
+    }
+
+    public <C> C fromJsonTree(JsonElement json, Type typeOfC) {
+        return (C) gson.fromJson(json, typeOfC);
+    }
+
+    public T thisFromJsonTree(JsonElement json) throws JsonIOException {
+        try {
+            return constructingAdapter.getDelegate().read(new JsonTreeReader(json));
+        } catch (IOException e) {
+            throw new JsonIOException(e);
+        }
+    }
+
+    public <C extends T> C thisFromJsonTree(JsonElement json, Type typeOfC) {
+        TypeAdapter<C> adapter = constructingAdapter.getNextAdapter(typeOfC);
+        try {
+            return adapter.read(new JsonTreeReader(json));
+        } catch (IOException e) {
+            throw new JsonIOException(e);
+        }
+    }
+}
diff --git a/src/main/java/cc/polyfrost/oneconfig/config/gson/gsoninterface/InterfaceAdapterFactory.java b/src/main/java/cc/polyfrost/oneconfig/config/gson/gsoninterface/InterfaceAdapterFactory.java
new file mode 100644
index 0000000..8f7d9d6
--- /dev/null
+++ b/src/main/java/cc/polyfrost/oneconfig/config/gson/gsoninterface/InterfaceAdapterFactory.java
@@ -0,0 +1,192 @@
+package cc.polyfrost.oneconfig.config.gson.gsoninterface;
+
+/*
+ * This file is part of OneConfig.
+ * OneConfig - Next Generation Config Library for Minecraft: Java Edition
+ * Copyright (C) 2021, 2022 Polyfrost.
+ *
+ *   <https://polyfrost.cc> <https://github.com/Polyfrost/>
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ *   OneConfig is licensed under the terms of version 3 of the GNU Lesser
+ * General Public License as published by the Free Software Foundation, AND
+ * under the Additional Terms Applicable to OneConfig, as published by Polyfrost,
+ * either version 1.0 of the Additional Terms, or (at your option) any later
+ * version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Lesser General Public
+ * License.  If not, see <https://www.gnu.org/licenses/>. You should
+ * have also received a copy of the Additional Terms Applicable
+ * to OneConfig, as published by Polyfrost. If not, see
+ * <https://polyfrost.cc/legal/oneconfig/additional-terms>
+
+ * This file contains an adaptation of code from gson-interface
+ * Project found at <https://github.com/mintern/gson-interface>
+ * For the avoidance of doubt, this file is still licensed under the terms
+ * of OneConfig's Licensing.
+ *
+ *                 LICENSE NOTICE FOR ADAPTED CODE
+ *
+ * Copyright (C) 2012, Brandon Mintern, EasyESI, Berkeley, CA
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither gson-interface nor the names of its contributors may be used
+ *     to endorse or promote products derived from this software without
+ *     specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+ * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL BRANDON MINTERN OR EASYESI BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+import com.google.gson.*;
+import com.google.gson.internal.Streams;
+import com.google.gson.reflect.TypeToken;
+import com.google.gson.stream.JsonReader;
+import com.google.gson.stream.JsonWriter;
+
+import java.io.IOException;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Type;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * @author mintern
+ */
+public class InterfaceAdapterFactory implements TypeAdapterFactory {
+    @Override
+    public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> tt) {
+        Class<T> rawType = Reflection.classOfType(tt.getRawType());
+        boolean serializes = JsonSerialization.class.isAssignableFrom(rawType);
+        Constructor<JsonDeserializes<T>> deserializerConstructor = null;
+        Class<JsonDeserializes<T>>[] typeParameters = Reflection.getTypeParameters(rawType, JsonDeserialization.class);
+        if (typeParameters != null) {
+            deserializerConstructor = Reflection.getConstructor(typeParameters[0]);
+        }
+        if (serializes || deserializerConstructor != null) {
+            return new InterfaceTypeAdapter(serializes, deserializerConstructor, gson, tt, this);
+        }
+        return null;
+    }
+
+    public static class InterfaceTypeAdapter<T> extends TypeAdapter<T> {
+        // This map ensures that only one deserializer of each type exists.
+        private static final Map<Class, JsonDeserializes<?>> deserializerInstances = new HashMap();
+
+        // Fields set in the constructor
+        private final boolean selfSerializing;
+        private final Constructor<JsonDeserializes<T>> deserializerConstructor;
+        private final Gson gson;
+        private final TypeToken<T> typeToken;
+        private final TypeAdapterFactory thisFactory;
+
+        // Adapters that follow this one in the chain for the indicated type
+        private final Map<Type, TypeAdapter> nextAdapters = new HashMap();
+
+        // Lazily-initialized fields. Call their corresponding getters in
+        // order to access them.
+        private TypeAdapter<T> delegate;
+        private GsonContext gsonContext;
+
+        private InterfaceTypeAdapter(
+                boolean serializes,
+                Constructor<JsonDeserializes<T>> dsc,
+                Gson g,
+                TypeToken<T> tt,
+                TypeAdapterFactory factory) {
+            selfSerializing = serializes;
+            if (dsc != null) {
+                dsc.setAccessible(true);
+            }
+            deserializerConstructor = dsc;
+            gson = g;
+            typeToken = tt;
+            thisFactory = factory;
+        }
+
+        @Override
+        public void write(JsonWriter writer, T value) throws IOException {
+            if (!selfSerializing) {
+                getDelegate().write(writer, value);
+            } else if (value == null) {
+                writer.nullValue();
+            } else {
+                JsonElement tree = ((JsonSerialization) value).toJsonTree(gsonContext());
+                Streams.write(tree, writer);
+            }
+        }
+
+        @Override
+        public T read(JsonReader reader) throws IOException {
+            if (deserializerConstructor == null) {
+                return getDelegate().read(reader);
+            }
+            JsonElement json = Streams.parse(reader);
+            if (json.isJsonNull()) {
+                return null;
+            }
+            return (T) deserializer().fromJsonTree(json, typeToken.getType(), gsonContext());
+        }
+
+        synchronized TypeAdapter<T> getDelegate() {
+            if (delegate == null) {
+                delegate = gson.getDelegateAdapter(thisFactory, typeToken);
+            }
+            return delegate;
+        }
+
+        private synchronized GsonContext gsonContext() {
+            if (gsonContext == null) {
+                gsonContext = new GsonContext(gson, this);
+            }
+            return gsonContext;
+        }
+
+        synchronized <C extends T> TypeAdapter<C> getNextAdapter(Type typeOfC) {
+            TypeAdapter<C> nextAdapter = nextAdapters.get(typeOfC);
+            if (nextAdapter == null) {
+                nextAdapter = gson.getDelegateAdapter(thisFactory, (TypeToken<C>) TypeToken.get(typeOfC));
+                nextAdapters.put(typeOfC, nextAdapter);
+            }
+            return nextAdapter;
+        }
+
+        private JsonDeserializes<T> deserializer() {
+            synchronized (deserializerInstances) {
+                Class<JsonDeserializes<T>> c = deserializerConstructor.getDeclaringClass();
+                JsonDeserializes<T> deserializer = (JsonDeserializes<T>) deserializerInstances.get(c);
+                if (deserializer == null) {
+                    try {
+                        deserializer = deserializerConstructor.newInstance();
+                    } catch (Exception e) {
+                        throw new JsonParseException(e);
+                    }
+                    deserializerInstances.put(c, deserializer);
+                }
+                return deserializer;
+            }
+        }
+    }
+}
diff --git a/src/main/java/cc/polyfrost/oneconfig/config/gson/gsoninterface/JsonDeserialization.java b/src/main/java/cc/polyfrost/oneconfig/config/gson/gsoninterface/JsonDeserialization.java
new file mode 100644
index 0000000..436d897
--- /dev/null
+++ b/src/main/java/cc/polyfrost/oneconfig/config/gson/gsoninterface/JsonDeserialization.java
@@ -0,0 +1,63 @@
+package cc.polyfrost.oneconfig.config.gson.gsoninterface;
+
+/*
+ * This file is part of OneConfig.
+ * OneConfig - Next Generation Config Library for Minecraft: Java Edition
+ * Copyright (C) 2021, 2022 Polyfrost.
+ *
+ *   <https://polyfrost.cc> <https://github.com/Polyfrost/>
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ *   OneConfig is licensed under the terms of version 3 of the GNU Lesser
+ * General Public License as published by the Free Software Foundation, AND
+ * under the Additional Terms Applicable to OneConfig, as published by Polyfrost,
+ * either version 1.0 of the Additional Terms, or (at your option) any later
+ * version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Lesser General Public
+ * License.  If not, see <https://www.gnu.org/licenses/>. You should
+ * have also received a copy of the Additional Terms Applicable
+ * to OneConfig, as published by Polyfrost. If not, see
+ * <https://polyfrost.cc/legal/oneconfig/additional-terms>
+
+ * This file contains an adaptation of code from gson-interface
+ * Project found at <https://github.com/mintern/gson-interface>
+ * For the avoidance of doubt, this file is still licensed under the terms
+ * of OneConfig's Licensing.
+ *
+ *                 LICENSE NOTICE FOR ADAPTED CODE
+ *
+ * Copyright (C) 2012, Brandon Mintern, EasyESI, Berkeley, CA
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither gson-interface nor the names of its contributors may be used
+ *     to endorse or promote products derived from this software without
+ *     specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+ * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL BRANDON MINTERN OR EASYESI BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+public interface JsonDeserialization<D extends JsonDeserializes<? extends JsonDeserialization<D>>> {
+}
diff --git a/src/main/java/cc/polyfrost/oneconfig/config/gson/gsoninterface/JsonDeserializes.java b/src/main/java/cc/polyfrost/oneconfig/config/gson/gsoninterface/JsonDeserializes.java
new file mode 100644
index 0000000..ecdf8e5
--- /dev/null
+++ b/src/main/java/cc/polyfrost/oneconfig/config/gson/gsoninterface/JsonDeserializes.java
@@ -0,0 +1,72 @@
+package cc.polyfrost.oneconfig.config.gson.gsoninterface;
+
+/*
+ * This file is part of OneConfig.
+ * OneConfig - Next Generation Config Library for Minecraft: Java Edition
+ * Copyright (C) 2021, 2022 Polyfrost.
+ *
+ *   <https://polyfrost.cc> <https://github.com/Polyfrost/>
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ *   OneConfig is licensed under the terms of version 3 of the GNU Lesser
+ * General Public License as published by the Free Software Foundation, AND
+ * under the Additional Terms Applicable to OneConfig, as published by Polyfrost,
+ * either version 1.0 of the Additional Terms, or (at your option) any later
+ * version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Lesser General Public
+ * License.  If not, see <https://www.gnu.org/licenses/>. You should
+ * have also received a copy of the Additional Terms Applicable
+ * to OneConfig, as published by Polyfrost. If not, see
+ * <https://polyfrost.cc/legal/oneconfig/additional-terms>
+
+ * This file contains an adaptation of code from gson-interface
+ * Project found at <https://github.com/mintern/gson-interface>
+ * For the avoidance of doubt, this file is still licensed under the terms
+ * of OneConfig's Licensing.
+ *
+ *                 LICENSE NOTICE FOR ADAPTED CODE
+ *
+ * Copyright (C) 2012, Brandon Mintern, EasyESI, Berkeley, CA
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither gson-interface nor the names of its contributors may be used
+ *     to endorse or promote products derived from this software without
+ *     specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+ * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL BRANDON MINTERN OR EASYESI BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+import com.google.gson.JsonElement;
+
+import java.lang.reflect.Type;
+
+/**
+ * @author mintern
+ */
+public interface JsonDeserializes<T> {
+    T fromJsonTree(JsonElement json, Type type, GsonContext<T> context);
+}
diff --git a/src/main/java/cc/polyfrost/oneconfig/config/gson/gsoninterface/JsonSerialization.java b/src/main/java/cc/polyfrost/oneconfig/config/gson/gsoninterface/JsonSerialization.java
new file mode 100644
index 0000000..3cae64d
--- /dev/null
+++ b/src/main/java/cc/polyfrost/oneconfig/config/gson/gsoninterface/JsonSerialization.java
@@ -0,0 +1,70 @@
+package cc.polyfrost.oneconfig.config.gson.gsoninterface;
+
+/*
+ * This file is part of OneConfig.
+ * OneConfig - Next Generation Config Library for Minecraft: Java Edition
+ * Copyright (C) 2021, 2022 Polyfrost.
+ *
+ *   <https://polyfrost.cc> <https://github.com/Polyfrost/>
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ *   OneConfig is licensed under the terms of version 3 of the GNU Lesser
+ * General Public License as published by the Free Software Foundation, AND
+ * under the Additional Terms Applicable to OneConfig, as published by Polyfrost,
+ * either version 1.0 of the Additional Terms, or (at your option) any later
+ * version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Lesser General Public
+ * License.  If not, see <https://www.gnu.org/licenses/>. You should
+ * have also received a copy of the Additional Terms Applicable
+ * to OneConfig, as published by Polyfrost. If not, see
+ * <https://polyfrost.cc/legal/oneconfig/additional-terms>
+
+ * This file contains an adaptation of code from gson-interface
+ * Project found at <https://github.com/mintern/gson-interface>
+ * For the avoidance of doubt, this file is still licensed under the terms
+ * of OneConfig's Licensing.
+ *
+ *                 LICENSE NOTICE FOR ADAPTED CODE
+ *
+ * Copyright (C) 2012, Brandon Mintern, EasyESI, Berkeley, CA
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither gson-interface nor the names of its contributors may be used
+ *     to endorse or promote products derived from this software without
+ *     specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+ * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL BRANDON MINTERN OR EASYESI BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+import com.google.gson.JsonElement;
+
+/**
+ * @author mintern
+ */
+public interface JsonSerialization<T extends JsonSerialization<T>> {
+    public JsonElement toJsonTree(GsonContext<T> context);
+}
diff --git a/src/main/java/cc/polyfrost/oneconfig/config/gson/gsoninterface/Reflection.java b/src/main/java/cc/polyfrost/oneconfig/config/gson/gsoninterface/Reflection.java
new file mode 100644
index 0000000..ee50b64
--- /dev/null
+++ b/src/main/java/cc/polyfrost/oneconfig/config/gson/gsoninterface/Reflection.java
@@ -0,0 +1,513 @@
+package cc.polyfrost.oneconfig.config.gson.gsoninterface;
+
+/*
+ * This file is part of OneConfig.
+ * OneConfig - Next Generation Config Library for Minecraft: Java Edition
+ * Copyright (C) 2021, 2022 Polyfrost.
+ *
+ *   <https://polyfrost.cc> <https://github.com/Polyfrost/>
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ *   OneConfig is licensed under the terms of version 3 of the GNU Lesser
+ * General Public License as published by the Free Software Foundation, AND
+ * under the Additional Terms Applicable to OneConfig, as published by Polyfrost,
+ * either version 1.0 of the Additional Terms, or (at your option) any later
+ * version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Lesser General Public
+ * License.  If not, see <https://www.gnu.org/licenses/>. You should
+ * have also received a copy of the Additional Terms Applicable
+ * to OneConfig, as published by Polyfrost. If not, see
+ * <https://polyfrost.cc/legal/oneconfig/additional-terms>
+
+ * This file contains an adaptation of code from gson-interface
+ * Project found at <https://github.com/mintern/gson-interface>
+ * For the avoidance of doubt, this file is still licensed under the terms
+ * of OneConfig's Licensing.
+ *
+ *                 LICENSE NOTICE FOR ADAPTED CODE
+ *
+ * Copyright (C) 2012, Brandon Mintern, EasyESI, Berkeley, CA
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither gson-interface nor the names of its contributors may be used
+ *     to endorse or promote products derived from this software without
+ *     specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+ * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL BRANDON MINTERN OR EASYESI BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+import java.lang.reflect.*;
+import java.util.ArrayList;
+import java.util.EmptyStackException;
+
+/**
+ * Provides various static helper methods that add a high-level interface to
+ * introspection and reflection.
+ *
+ * @author mintern
+ */
+public class Reflection {
+    /**
+     * A wrapper for Class.newInstance() that throws an unchecked Exception.
+     * It also ensures that even private constructors can be called.
+     *
+     * @param c the class on which to call newInstance()
+     * @return the object returned from c.newInstance()
+     * @throws IllegalArgumentException if there was an exception
+     *                                  constructing the instance
+     */
+    public static <T> T newInstance(Class<T> c) {
+        try {
+            return constructAnyway(c.getDeclaredConstructor());
+        } catch (Exception e) {
+            throw new IllegalArgumentException(e);
+        }
+    }
+
+    /**
+     * Gets the aClass constructor with the given paramaters, throwing an
+     * unchecked exception in the case of errors.
+     *
+     * @param aClass the class whose constructor should be fetched.
+     * @param params the parameters to the desired constructor
+     * @return the constructor for aClass that accepts params, or null if
+     * there is no such constructor
+     */
+    public static <T> Constructor<T> getConstructor(Class<T> aClass, Class... params) {
+        try {
+            return aClass.getDeclaredConstructor(params);
+        } catch (Exception e) {
+            return null;
+        }
+    }
+
+    /**
+     * Invokes the given constructor with the given args even if it's not
+     * accessible.
+     *
+     * @param <T>         the type of value to be constructed
+     * @param constructor the constructor to invoke (see getConstructor)
+     * @param args        the args to send to the constructor
+     * @return a new instance of type T
+     * @throws IllegalArgumentException if there was an exception while
+     *                                  setting the constructor to be accessible or invoking it
+     */
+    public static <T> T constructAnyway(Constructor<T> constructor, Object... args)
+            throws IllegalArgumentException {
+        try {
+            boolean wasAccessible = constructor.isAccessible();
+            constructor.setAccessible(true);
+            try {
+                T instance = constructor.newInstance(args);
+                return instance;
+            } finally {
+                constructor.setAccessible(wasAccessible);
+            }
+        } catch (Exception e) {
+            throw new IllegalArgumentException(e);
+        }
+    }
+
+    /**
+     * Checks whether a class is abstract.
+     *
+     * @param c the class to check
+     * @return true iff c is an interface or abstract class
+     */
+    public static boolean isAbstract(Class c) {
+        return c.isInterface() || Modifier.isAbstract(c.getModifiers());
+    }
+
+    /**
+     * Obtain the value of a field even if it is not public.
+     *
+     * @param field    the field value to obtain
+     * @param fieldObj an instantiated object which defines field
+     * @return the value of field in fieldObj
+     * @throws IllegalArgumentException on any error
+     */
+    public static Object getFieldValue(Field field, Object fieldObj)
+            throws IllegalArgumentException {
+        try {
+            boolean wasAccessible = field.isAccessible();
+            field.setAccessible(true);
+            try {
+                return field.get(fieldObj);
+            } finally {
+                field.setAccessible(wasAccessible);
+            }
+        } catch (IllegalAccessException e) {
+            throw new IllegalArgumentException(e);
+        }
+    }
+
+    /**
+     * Returns a field on which field.get(...) can be called, even if the field
+     * is private.
+     *
+     * @param aClass    the class defining the desired field
+     * @param fieldName the name of the desired field
+     * @return a field that is accessible regardless of its modifiers
+     * @throws IllegalArgumentException on any error
+     */
+    public static Field getAccessibleField(Class aClass, String fieldName)
+            throws IllegalArgumentException {
+        try {
+            Field field = aClass.getDeclaredField(fieldName);
+            field.setAccessible(true);
+            return field;
+        } catch (Exception e) {
+            // NoSuchFieldException, SecurityException
+            throw new IllegalArgumentException(e);
+        }
+    }
+
+    /**
+     * For a class implClass that instantiates a generic class or interface
+     * genClass, return the types that genClass is instantiated with. This
+     * method has a runtime linear in the size of the type hierarchy, so if
+     * the results are used at runtime, it is recommended to cache them.
+     * <p>
+     * An example of its usage:
+     * <p>
+     * import java.util.*;
+     * public class IdToNameMap extends HashMap<Integer, String> {
+     * public static void main (String[] args) {
+     * for (Class c: getTypeParameters(IdToNameMap.class, Map.class) {
+     * System.out.println(c);
+     * }
+     * }
+     * }
+     * <p>
+     * Calling main() would print out:
+     * <p>
+     * Integer.class
+     * String.class
+     * <p>
+     * Note that this method ascends and descends the class hierarchy to
+     * determine the best bounds possible on all type parameters. For
+     * example, even if the class hierarchy is:
+     * <p>
+     * public class IdMap<V> extends HashMap<Integer, V> {}
+     * public class IdToNameMap extends IdMap<String> {}
+     * <p>
+     * the main() call would print the same thing. For type parameters that
+     * remain unbounded, the tightest bound available is printed. So:
+     * <p>
+     * getTypeParameters(EnumSet.class, Set.class)
+     * <p>
+     * would return Enum.class. Sometimes the tightest bound available is
+     * Object.class.
+     * <p>
+     * This method should NOT be called with implClass or genClass as a
+     * primitive class. This is not sensible, anyway.
+     *
+     * @param implClass a class instantiating a generic class or interface
+     * @param genClass  the generic class or interface which has type
+     *                  parameters you want to know
+     * @return the array of instantiated parameters. If implClass does not
+     * extend or implement genClass, null is returned. For any genClass
+     * type parameters not instantiated by implClass, we return the
+     * parameters' upper bounds.
+     */
+    public static Class[] getTypeParameters(Class implClass, Class genClass) {
+        return getTypeParameters(implClass, genClass, new Stack());
+    }
+
+    /**
+     * @param genClass typically a Class with generic type parameters
+     * @return the array of Class bounds on those parameters, or an empty
+     * Class array if genClass is not generic.
+     */
+    public static Class[] getParameterBounds(Class genClass) {
+        Type[] parameters = genClass.getTypeParameters();
+        Class[] paramClasses = new Class[parameters.length];
+        for (int i = 0; i < parameters.length; i++) {
+            paramClasses[i] = classOfType(parameters[i]);
+        }
+        return paramClasses;
+    }
+
+    /**
+     * @param type any Type object
+     * @return the most specific class of type that we can determine
+     */
+    public static Class classOfType(Type type) {
+        if (type instanceof Class) {
+            return (Class) type;
+        } else if (type instanceof ParameterizedType) {
+            return classOfType(((ParameterizedType) type).getRawType());
+        } else if (type instanceof TypeVariable) {
+            return classOfType(((TypeVariable) type).getBounds()[0]);
+        } else if (type instanceof WildcardType) {
+            return classOfType(((WildcardType) type).getUpperBounds()[0]);
+        } else {
+            // this should never happen in principle, but just in case...
+            return Object.class;
+        }
+    }
+
+    // Internal helper methods used above.
+
+    /**
+     * See public ... getTypeParameters. This method and the others below
+     * that implement it work by ascending and descending the type hierarchy
+     * in order to gather the desired information. As we ascend the type
+     * hierarchy looking for genClass, we push the classes that have led us
+     * there onto classStack. Later, if we find genClass but the associated
+     * implClass is generic, we descend the classStack to figure out how
+     * implClass is instantiated. Eventually, each type parameter is either
+     * fully instantiated, in which case we use the instantiation class, or
+     * the type parameter is not instantiated, in which case we return its
+     * upper bound, which in some cases will be Object.class.  @param
+     * implClass  the class extending/implementing genClass @param genClass
+     * a class with generic type parameters
+     *
+     * @param classStack the stack of subclasses we've visited before
+     *                   reaching this implClass
+     * @return the tightest bounds implClass places on those type
+     * parameters
+     */
+    private static Class[] getTypeParameters(Class implClass, Class genClass, Stack<Class> classStack) {
+        if (genClass.isInterface()) {
+            return getInterfaceParameters(implClass, genClass, classStack);
+        }
+        return getSuperParameters(implClass, genClass, classStack);
+    }
+
+    /**
+     * This method implements getTypeParameters when genClass is an
+     * interface.  Since a class can implement multiple interfaces and since
+     * they must be retrieved differently than with a superclass, we keep
+     * the functions separate.
+     * <p>
+     * At each level, we check each interface against genClass. If none of
+     * them match, we look at any interface's implemented interfaces, and so
+     * on all the way up until we reach an interface with no implemented
+     * interfaces.
+     * <p>
+     * If we still haven't found genClass at this point, we ascend into
+     * implClass's superclass and perform the same work.
+     * <p>
+     * As mentioned in private ... getTypeParameters, any time we ascend the
+     * type hierarchy, we push the implClass onto the classStack so that we
+     * can later descend the class hierarchy to resolve type parameters
+     * which are set further down the tree.
+     */
+    private static Class[] getInterfaceParameters(Class implClass, Class genClass, Stack<Class> classStack) {
+        Type[] interfaces = implClass.getGenericInterfaces();
+        // Check each of the interfaces implemented by implClass to see if
+        // one matches genClass.
+        for (Type iface : interfaces) {
+            Class[] result = getParametersIfMatches(iface, implClass, genClass, classStack);
+            if (result != null) {
+                // We found it.
+                return result;
+            }
+        }
+        // None of the implemented interfaces matched genClass. Ascend each
+        // interface's type hierarchy looking for genClass.
+        for (Type iface : interfaces) {
+            Class interfaceClass = classOfType(iface);
+            classStack.push(implClass);
+            Class[] result = getInterfaceParameters(interfaceClass, genClass, classStack);
+            classStack.pop();
+            if (result != null) {
+                return result;
+            }
+        }
+        // We visited the entire interface hierarchy of implClass. Ascend to
+        // implClass's superclass and look for the interface there.
+        Class superclass = implClass.getSuperclass();
+        if (superclass == null) {
+            // implClass is an interface or Object, so it has no superclass.
+            // We didn't find genClass along this path.
+            return null;
+        }
+        // The ascent.
+        classStack.push(implClass);
+        Class[] result = getInterfaceParameters(superclass, genClass, classStack);
+        classStack.pop();
+        // The result may still be null at this point, but we've visited the
+        // entire type hierarchy and haven't found genClass. In these cases, we
+        // want to return null, anyway.
+        return result;
+    }
+
+    /**
+     * This method implements getTypeParameters when genClass is not an
+     * interface, and therefore should be found as a superclass of
+     * implClass.  Since a class can only have one superclass, we simply
+     * check that superclass and then ascend the type hierarchy if it is not
+     * a match.
+     */
+    private static Class[] getSuperParameters(Class implClass, Class genClass, Stack<Class> classStack) {
+        Type supertype = implClass.getGenericSuperclass();
+        if (supertype == null) {
+            // Base case; implClass is Object; we didn't find genClass.
+            return null;
+        }
+        Class[] result = getParametersIfMatches(supertype, implClass, genClass, classStack);
+        if (result != null) {
+            // We found it.
+            return result;
+        }
+        // The superclass of implClass didn't match genClass. Ascend class
+        // hierarchy.
+        classStack.push(implClass);
+        result = getSuperParameters(classOfType(supertype), genClass, classStack);
+        classStack.pop();
+        // We either have our result or null. Return.
+        return result;
+    }
+
+    /**
+     * If the Class represented by type matches genClass, return the
+     * genClass type parameters. If it is not a match, returns null.
+     *
+     * @param type       the type being considered, with all information present
+     *                   in implClass
+     * @param implClass  the current class, for which type was a superclass
+     *                   or an implemented interface
+     * @param genClass   the class we are looking for (to be compared against
+     *                   type)
+     * @param classStack
+     * @return null if type is not of Class genClass, genClass
+     * instantiated type parameters otherwise. Class[0] if genClasses has
+     * no type parameters
+     */
+    private static Class[] getParametersIfMatches(Type type, Class implClass, Class genClass, Stack<Class> classStack) {
+        if (type == genClass) {
+            // type matches genClass and it's a Class Type; if genClass has
+            // type parameters, they have not been instantiated by
+            // implClass.  Simply return the bounds on genClass's
+            // parameters, if it has any parameters. If it doesn't have
+            // parameters, we'll return Class[0]
+            return getParameterBounds(genClass);
+        }
+        if (type instanceof ParameterizedType && classOfType(type) == genClass) {
+            // We've found our parameterized genClass. For each type,
+            // convert it to its corresponding class. If it's a TypeVariable
+            // and it matches a type argument in implClass, descend down the
+            // classStack to determine THAT parameter type.  Otherwise, or
+            // if the TypeVariable can't be resolved, simply perform a dumb
+            // conversion on the type.
+            Type[] types = ((ParameterizedType) type).getActualTypeArguments();
+            Class[] classes = new Class[types.length];
+            // The following two types declared here to avoid repeated work
+            Type[] implParams = null;
+            Class[] implInstantiatedParams = null;
+            // This loop is probably the most complex bit in the code. An
+            // instructive example is where we have a class hierarchy like:
+            //     IdNameMap extends IdMap<String>
+            //     IdMap<E> extends HashMap<Integer, E>
+            //     getTypeParameters(IdNameMap.class, HashMap.class)
+            // When we reach this point:
+            //     types = [Integer, E]
+            //     implClass = IdMap
+            //     classes = []
+            //     classStack = [IdNameMap]
+            // The outer loop iterates over types. After its first iteration
+            // (for which the if-test fails), classes=[Integer]. In the
+            // second iteration, E is a TypeVariable and the classStack is
+            // not empty.  We fetch IdMap's TypeParameters:
+            //     implParams = [E]
+            // The inner loop iterates over implParams, finding that when j
+            // = 0, implParams[j] matches types[i] (both are E). We then
+            // call getTypeParameters(IdNameMap, IdMap, []) to determine the
+            // type of E, which turns out to be String:
+            //     implInstantiatedParams = [String]
+            // We update classes:
+            //     classes = [Integer, String]
+            // and we continue to the next iteration of the outer loop,
+            // where it turns out to terminate. Finally, we return classes.
+            types:
+            for (int i = 0; i < types.length; i++) {
+                if (types[i] instanceof TypeVariable && !classStack.isEmpty()) {
+                    if (implParams == null) {
+                        implParams = implClass.getTypeParameters();
+                    }
+                    for (int j = 0; j < implParams.length; j++) {
+                        if (((TypeVariable) types[i]).equals(implParams[j])) {
+                            if (implInstantiatedParams == null) {
+                                Class subClass = classStack.pop();
+                                // the descent
+                                implInstantiatedParams = getTypeParameters(subClass, implClass, classStack);
+                                classStack.push(subClass);
+                            }
+                            classes[i] = implInstantiatedParams[j];
+                            continue types;
+                        }
+                    }
+                    // If we reach this point (we were unable to resolve the
+                    // parameter), type[i] will be resolved to its bound in the
+                    // line below.
+                }
+                classes[i] = classOfType(types[i]);
+            }
+            return classes;
+        }
+        // type did not match genClass
+        return null;
+    }
+
+    /**
+     * A non-threadsafe alternative to java.util.Stack.
+     * Since the Reflection code is single threaded, using this should be
+     * faster.
+     *
+     * @param E the type of elements in the stack
+     */
+    public static class Stack<E> extends ArrayList<E> {
+        /**
+         * Push an item onto the stack. The next call to pop() will return
+         * the most-recently push()ed item.
+         *
+         * @param elt the element to add to the stack
+         * @return this; convenient for chaining: stack.push(...).push(...)
+         */
+        public Stack<E> push(E elt) {
+            add(elt);
+            return this;
+        }
+
+        /**
+         * Pop from this and return the item that was most recently pushed
+         * onto this. This should never be called on an empty stack.
+         *
+         * @return the item that was pop()ed
+         * @throws EmptyStackException if this is empty
+         */
+        public E pop() {
+            try {
+                return remove(size() - 1);
+            } catch (IndexOutOfBoundsException e) {
+                throw new EmptyStackException();
+            }
+        }
+    }
+}
diff --git a/src/main/resources/licenses/gson-interface-License.txt b/src/main/resources/licenses/gson-interface-License.txt
new file mode 100644
index 0000000..23b34e1
--- /dev/null
+++ b/src/main/resources/licenses/gson-interface-License.txt
@@ -0,0 +1,26 @@
+Copyright (c) 2012, Brandon Mintern, EasyESI, Berkeley, CA
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+  * Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+  * Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the
+    documentation and/or other materials provided with the distribution.
+  * Neither Java-Reflection nor the names of its contributors may be used
+    to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL BRANDON MINTERN OR EASYESI BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+THE POSSIBILITY OF SUCH DAMAGE.
\ No newline at end of file