Remove entry extras

src/main/java/me/lortseam/completeconfig/api/ConfigEntry.java

@@ -2,7 +2,7 @@ package me.lortseam.completeconfig.api;
 
 import lombok.AccessLevel;
 import lombok.NoArgsConstructor;
-import me.lortseam.completeconfig.data.EnumOptions.DisplayType;
+import me.lortseam.completeconfig.data.EnumEntry;
 
 import java.lang.annotation.ElementType;
 import java.lang.annotation.Retention;
@@ -189,9 +189,9 @@ public @interface ConfigEntry {
         /**
          * Specifies how the entry should be rendered.
          *
-         * @return the desired {@link DisplayType}
+         * @return the desired {@link EnumEntry.DisplayType}
          */
-        DisplayType displayType() default DisplayType.BUTTON;
+        EnumEntry.DisplayType displayType() default EnumEntry.DisplayType.BUTTON;
 
     }
 

src/main/java/me/lortseam/completeconfig/data/BoundedEntry.java

@@ -0,0 +1,41 @@
+package me.lortseam.completeconfig.data;
+
+import lombok.Getter;
+import me.lortseam.completeconfig.api.ConfigEntryContainer;
+import me.lortseam.completeconfig.data.gui.TranslationIdentifier;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.lang.reflect.Field;
+import java.math.BigDecimal;
+
+public class BoundedEntry<T extends Number> extends Entry<T> {
+
+    private static final Logger LOGGER = LogManager.getLogger();
+
+    @Getter
+    private final T min, max;
+    @Getter
+    private final boolean slider;
+
+    BoundedEntry(Field field, ConfigEntryContainer parentObject, TranslationIdentifier parentTranslation, T min, T max, boolean slider) {
+        super(field, parentObject, parentTranslation, value -> {
+            if (new BigDecimal(value.toString()).compareTo(new BigDecimal(min.toString())) < 0) {
+                LOGGER.warn("[CompleteConfig] Tried to set value of field " + field + " to a value less than minimum bound, setting to minimum now!");
+                return min;
+            } else if (new BigDecimal(value.toString()).compareTo(new BigDecimal(max.toString())) > 0) {
+                LOGGER.warn("[CompleteConfig] Tried to set value of field " + field + " to a value greater than maximum bound, setting to maximum now!");
+                return max;
+            }
+            return value;
+        });
+        this.min = min;
+        this.max = max;
+        this.slider = slider;
+    }
+
+    BoundedEntry(Field field, ConfigEntryContainer parentObject, TranslationIdentifier parentTranslation, T min, T max) {
+        this(field, parentObject, parentTranslation, min, max, false);
+    }
+
+}

src/main/java/me/lortseam/completeconfig/data/Bounds.java

@@ -1,17 +0,0 @@
-package me.lortseam.completeconfig.data;
-
-import lombok.AccessLevel;
-import lombok.Getter;
-import lombok.RequiredArgsConstructor;
-
-@RequiredArgsConstructor(access = AccessLevel.PACKAGE)
-public class Bounds<T> {
-
-    @Getter
-    private final T min;
-    @Getter
-    private final T max;
-    @Getter
-    private final boolean slider;
-
-}

src/main/java/me/lortseam/completeconfig/data/Entry.java

@@ -16,9 +16,9 @@ import org.spongepowered.configurate.serialize.SerializationException;
 
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
-import java.math.BigDecimal;
 import java.util.*;
 import java.util.function.Consumer;
+import java.util.function.UnaryOperator;
 
 public class Entry<T> extends EntryBase<T> implements DataPart {
 
@@ -37,6 +37,45 @@ public class Entry<T> extends EntryBase<T> implements DataPart {
         return entries.computeIfAbsent(field, absentField -> new Draft<>(field));
     }
 
+    private static Entry<?> create(Field field, ConfigEntryContainer parentObject, TranslationIdentifier parentTranslation) {
+        if (field.isAnnotationPresent(ConfigEntry.Bounded.Integer.class)) {
+            if (field.getType() != int.class && field.getType() != Integer.class) {
+                throw new IllegalAnnotationTargetException("Cannot apply Integer bound to non Integer field " + field);
+            }
+            ConfigEntry.Bounded.Integer bounds = field.getDeclaredAnnotation(ConfigEntry.Bounded.Integer.class);
+            return new BoundedEntry<>(field, parentObject, parentTranslation, bounds.min(), bounds.max(), bounds.slider());
+        }
+        if (field.isAnnotationPresent(ConfigEntry.Bounded.Long.class)) {
+            if (field.getType() != long.class && field.getType() != Long.class) {
+                throw new IllegalAnnotationTargetException("Cannot apply Long bound to non Long field " + field);
+            }
+            ConfigEntry.Bounded.Long bounds = field.getDeclaredAnnotation(ConfigEntry.Bounded.Long.class);
+            return new BoundedEntry<>(field, parentObject, parentTranslation, bounds.min(), bounds.max(), bounds.slider());
+        }
+        if (field.isAnnotationPresent(ConfigEntry.Bounded.Float.class)) {
+            if (field.getType() != float.class && field.getType() != Float.class) {
+                throw new IllegalAnnotationTargetException("Cannot apply Float bound to non Float field " + field);
+            }
+            ConfigEntry.Bounded.Float bounds = field.getDeclaredAnnotation(ConfigEntry.Bounded.Float.class);
+            return new BoundedEntry<>(field, parentObject, parentTranslation, bounds.min(), bounds.max());
+        }
+        if (field.isAnnotationPresent(ConfigEntry.Bounded.Double.class)) {
+            if (field.getType() != double.class && field.getType() != Double.class) {
+                throw new IllegalAnnotationTargetException("Cannot apply Double bound to non Double field " + field);
+            }
+            ConfigEntry.Bounded.Double bounds = field.getDeclaredAnnotation(ConfigEntry.Bounded.Double.class);
+            return new BoundedEntry<>(field, parentObject, parentTranslation, bounds.min(), bounds.max());
+        }
+        if (Enum.class.isAssignableFrom(field.getType())) {
+            if (field.isAnnotationPresent(ConfigEntry.EnumOptions.class)) {
+                return new EnumEntry<>(field, parentObject, parentTranslation, field.getDeclaredAnnotation(ConfigEntry.EnumOptions.class).displayType());
+            } else {
+                return new EnumEntry<>(field, parentObject, parentTranslation);
+            }
+        }
+        return new Entry<>(field, parentObject, parentTranslation);
+    }
+
     private final ConfigEntryContainer parentObject;
     private String customID;
     @Getter
@@ -46,16 +85,20 @@ public class Entry<T> extends EntryBase<T> implements DataPart {
     private TranslationIdentifier[] customTooltipTranslations;
     private boolean forceUpdate;
     private boolean requiresRestart;
-    @Getter
-    private final Extras<T> extras = new Extras<>(this);
     private String comment;
+    private final UnaryOperator<T> modifier;
     private final List<Listener<T>> listeners = new ArrayList<>();
 
-    private Entry(Field field, ConfigEntryContainer parentObject, TranslationIdentifier parentTranslation) {
+    protected Entry(Field field, ConfigEntryContainer parentObject, TranslationIdentifier parentTranslation, UnaryOperator<T> modifier) {
         super(field);
         this.parentObject = parentObject;
-        defaultValue = getValue();
         this.parentTranslation = parentTranslation;
+        this.modifier = modifier;
+        defaultValue = getValue();
+    }
+
+    protected Entry(Field field, ConfigEntryContainer parentObject, TranslationIdentifier parentTranslation) {
+        this(field, parentObject, parentTranslation, null);
     }
 
     public T getValue() {
@@ -82,14 +125,8 @@ public class Entry<T> extends EntryBase<T> implements DataPart {
     }
 
     private boolean update(T value) {
-        if (extras.getBounds() != null) {
-            if (new BigDecimal(value.toString()).compareTo(new BigDecimal(extras.getBounds().getMin().toString())) < 0) {
-                LOGGER.warn("[CompleteConfig] Tried to set value of field " + field + " to a value less than minimum bound, setting to minimum now!");
-                value = extras.getBounds().getMin();
-            } else if (new BigDecimal(value.toString()).compareTo(new BigDecimal(extras.getBounds().getMax().toString())) > 0) {
-                LOGGER.warn("[CompleteConfig] Tried to set value of field " + field + " to a value greater than maximum bound, setting to maximum now!");
-                value = extras.getBounds().getMax();
-            }
+        if (modifier != null) {
+            value = modifier.apply(value);
         }
         if (value.equals(getFieldValue())) {
             return false;
@@ -182,43 +219,6 @@ public class Entry<T> extends EntryBase<T> implements DataPart {
                 this.comment = comment;
             }
         }
-        if (field.isAnnotationPresent(ConfigEntry.Bounded.Integer.class)) {
-            if (field.getType() != int.class && field.getType() != Integer.class) {
-                throw new IllegalAnnotationTargetException("Cannot apply Integer bound to non Integer field " + field);
-            }
-            ConfigEntry.Bounded.Integer bounds = field.getDeclaredAnnotation(ConfigEntry.Bounded.Integer.class);
-            extras.setBounds(bounds.min(), bounds.max(), bounds.slider());
-        }
-        if (field.isAnnotationPresent(ConfigEntry.Bounded.Long.class)) {
-            if (field.getType() != long.class && field.getType() != Long.class) {
-                throw new IllegalAnnotationTargetException("Cannot apply Long bound to non Long field " + field);
-            }
-            ConfigEntry.Bounded.Long bounds = field.getDeclaredAnnotation(ConfigEntry.Bounded.Long.class);
-            extras.setBounds(bounds.min(), bounds.max(), bounds.slider());
-        }
-        if (field.isAnnotationPresent(ConfigEntry.Bounded.Float.class)) {
-            if (field.getType() != float.class && field.getType() != Float.class) {
-                throw new IllegalAnnotationTargetException("Cannot apply Float bound to non Float field " + field);
-            }
-            ConfigEntry.Bounded.Float bounds = field.getDeclaredAnnotation(ConfigEntry.Bounded.Float.class);
-            extras.setBounds(bounds.min(), bounds.max(), false);
-        }
-        if (field.isAnnotationPresent(ConfigEntry.Bounded.Double.class)) {
-            if (field.getType() != double.class && field.getType() != Double.class) {
-                throw new IllegalAnnotationTargetException("Cannot apply Double bound to non Double field " + field);
-            }
-            ConfigEntry.Bounded.Double bounds = field.getDeclaredAnnotation(ConfigEntry.Bounded.Double.class);
-            extras.setBounds(bounds.min(), bounds.max(), false);
-        }
-        if (Enum.class.isAssignableFrom(field.getType())) {
-            if (field.isAnnotationPresent(ConfigEntry.EnumOptions.class)) {
-                extras.setEnumOptions(field.getDeclaredAnnotation(ConfigEntry.EnumOptions.class).displayType());
-            } else {
-                extras.setEnumOptions(EnumOptions.DisplayType.DEFAULT);
-            }
-        } else if (field.isAnnotationPresent(ConfigEntry.EnumOptions.class)) {
-            throw new IllegalAnnotationTargetException("Cannot apply enum options to non enum field " + field);
-        }
     }
 
     @Override
@@ -269,7 +269,7 @@ public class Entry<T> extends EntryBase<T> implements DataPart {
         }
 
         Entry<T> build(ConfigEntryContainer parentObject, TranslationIdentifier parentTranslation) {
-            Entry<T> entry = new Entry<>(field, parentObject, parentTranslation);
+            Entry<T> entry = (Entry<T>) create(field, parentObject, parentTranslation);
             for (Consumer<Entry<T>> interaction : interactions) {
                 interaction.accept(entry);
             }

src/main/java/me/lortseam/completeconfig/data/EnumEntry.java

@@ -0,0 +1,47 @@
+package me.lortseam.completeconfig.data;
+
+import com.google.common.base.CaseFormat;
+import lombok.Getter;
+import me.lortseam.completeconfig.api.ConfigEntry;
+import me.lortseam.completeconfig.api.ConfigEntryContainer;
+import me.lortseam.completeconfig.data.gui.TranslationIdentifier;
+import net.minecraft.text.Text;
+
+import java.lang.reflect.Field;
+import java.util.function.Function;
+
+public class EnumEntry<T extends Enum<?>> extends Entry<T> {
+
+    @Getter
+    private final DisplayType displayType;
+
+    EnumEntry(Field field, ConfigEntryContainer parentObject, TranslationIdentifier parentTranslation, DisplayType displayType) {
+        super(field, parentObject, parentTranslation);
+        this.displayType = displayType;
+    }
+
+    EnumEntry(Field field, ConfigEntryContainer parentObject, TranslationIdentifier parentTranslation) {
+        this(field, parentObject, parentTranslation, DisplayType.DEFAULT);
+    }
+
+    public Function<Enum, Text> getEnumNameProvider() {
+        return enumValue -> getTranslation().append(CaseFormat.UPPER_UNDERSCORE.to(CaseFormat.LOWER_CAMEL, enumValue.name())).translate();
+    }
+
+    public enum DisplayType {
+
+        BUTTON, DROPDOWN;
+
+        private static final DisplayType DEFAULT;
+
+        static {
+            try {
+                DEFAULT = (DisplayType) ConfigEntry.EnumOptions.class.getDeclaredMethod("displayType").getDefaultValue();
+            } catch (NoSuchMethodException e) {
+                throw new RuntimeException(e);
+            }
+        }
+
+    }
+
+}

src/main/java/me/lortseam/completeconfig/data/EnumOptions.java

@@ -1,39 +0,0 @@
-package me.lortseam.completeconfig.data;
-
-import com.google.common.base.CaseFormat;
-import lombok.AccessLevel;
-import lombok.Getter;
-import lombok.RequiredArgsConstructor;
-import me.lortseam.completeconfig.api.ConfigEntry;
-import net.minecraft.text.Text;
-
-import java.util.function.Function;
-
-@RequiredArgsConstructor(access = AccessLevel.PACKAGE)
-public class EnumOptions {
-
-    private final Entry<?> parent;
-    @Getter
-    private final DisplayType displayType;
-
-    public Function<Enum, Text> getNameProvider() {
-        return enumValue -> parent.getTranslation().append(CaseFormat.UPPER_UNDERSCORE.to(CaseFormat.LOWER_CAMEL, enumValue.name())).translate();
-    }
-
-    public enum DisplayType {
-
-        BUTTON, DROPDOWN;
-
-        static final DisplayType DEFAULT;
-
-        static {
-            try {
-                DEFAULT = (DisplayType) ConfigEntry.EnumOptions.class.getDeclaredMethod("displayType").getDefaultValue();
-            } catch (NoSuchMethodException e) {
-                throw new RuntimeException(e);
-            }
-        }
-
-    }
-
-}

src/main/java/me/lortseam/completeconfig/data/Extras.java

@@ -1,28 +0,0 @@
-package me.lortseam.completeconfig.data;
-
-import lombok.AccessLevel;
-import lombok.Getter;
-import lombok.RequiredArgsConstructor;
-import org.apache.commons.lang3.reflect.TypeUtils;
-
-@RequiredArgsConstructor(access = AccessLevel.PACKAGE)
-public class Extras<T> {
-
-    private final Entry<T> entry;
-    @Getter
-    private Bounds<T> bounds;
-    @Getter
-    private EnumOptions enumOptions;
-
-    <N extends Number> void setBounds(N min, N max, boolean slider) {
-        if (!TypeUtils.isAssignable(entry.getType(), min.getClass()) || !TypeUtils.isAssignable(entry.getType(), max.getClass())) {
-            throw new IllegalArgumentException();
-        }
-        bounds = new Bounds<>((T) min, (T) max, slider);
-    }
-
-    void setEnumOptions(EnumOptions.DisplayType displayType) {
-        enumOptions = new EnumOptions(entry, displayType);
-    }
-
-}

src/main/java/me/lortseam/completeconfig/gui/cloth/ClothGuiBuilder.java

@@ -1,8 +1,8 @@
 package me.lortseam.completeconfig.gui.cloth;
 
 import lombok.Getter;
-import me.lortseam.completeconfig.data.Config;
 import me.lortseam.completeconfig.data.Collection;
+import me.lortseam.completeconfig.data.Config;
 import me.lortseam.completeconfig.data.Entry;
 import me.lortseam.completeconfig.gui.GuiBuilder;
 import me.shedaniel.clothconfig2.api.AbstractConfigListEntry;
@@ -16,7 +16,6 @@ import net.minecraft.client.gui.screen.Screen;
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Optional;
 import java.util.function.Supplier;
 
 @Environment(EnvType.CLIENT)
@@ -52,7 +51,7 @@ public class ClothGuiBuilder implements GuiBuilder {
     private List<AbstractConfigListEntry> buildCollection(Collection collection) {
         List<AbstractConfigListEntry> collectionGui = new ArrayList<>();
         for (Entry entry : collection.getEntries().values()) {
-            collectionGui.add(((Optional<GuiProvider>) registry.getProvider(entry)).orElseThrow(() -> {
+            collectionGui.add((registry.getProvider(entry)).orElseThrow(() -> {
                 return new UnsupportedOperationException("Could not find gui provider for field " + entry.getField());
             }).build(entry));
         }

src/main/java/me/lortseam/completeconfig/gui/cloth/GuiProvider.java

@@ -7,8 +7,8 @@ import net.fabricmc.api.Environment;
 
 @Environment(EnvType.CLIENT)
 @FunctionalInterface
-public interface GuiProvider<T> {
+public interface GuiProvider<E extends Entry<?>> {
 
-    AbstractConfigListEntry<T> build(Entry<T> entry);
+    AbstractConfigListEntry<?> build(E entry);
 
 }

src/main/java/me/lortseam/completeconfig/gui/cloth/GuiProviderPredicate.java

@@ -1,21 +0,0 @@
-package me.lortseam.completeconfig.gui.cloth;
-
-import me.lortseam.completeconfig.data.Extras;
-import net.fabricmc.api.EnvType;
-import net.fabricmc.api.Environment;
-
-import java.lang.reflect.Field;
-import java.util.Objects;
-
-@Environment(EnvType.CLIENT)
-@FunctionalInterface
-public interface GuiProviderPredicate<T> {
-
-    boolean test(Field field, Extras<?> extras);
-
-    default GuiProviderPredicate<T> and(GuiProviderPredicate<T> other) {
-        Objects.requireNonNull(other);
-        return (field, extras) -> test(field, extras) && other.test(field, extras);
-    }
-
-}

src/main/java/me/lortseam/completeconfig/gui/cloth/GuiProviderRegistration.java

@@ -7,16 +7,18 @@ import me.lortseam.completeconfig.data.Entry;
 import net.fabricmc.api.EnvType;
 import net.fabricmc.api.Environment;
 
+import java.util.function.Predicate;
+
 @Environment(EnvType.CLIENT)
 @RequiredArgsConstructor(access = AccessLevel.PACKAGE)
-class GuiProviderRegistration<T> {
+class GuiProviderRegistration {
 
-    private final GuiProviderPredicate<T> predicate;
+    private final Predicate<Entry<?>> predicate;
     @Getter(AccessLevel.PACKAGE)
-    private final GuiProvider<T> provider;
+    private final GuiProvider<?> provider;
 
-    public boolean test(Entry<?> entry) {
-        return predicate.test(entry.getField(), entry.getExtras());
+    boolean test(Entry<?> entry) {
+        return predicate.test(entry);
     }
 
 }

src/main/java/me/lortseam/completeconfig/gui/cloth/GuiRegistry.java

@@ -3,9 +3,9 @@ package me.lortseam.completeconfig.gui.cloth;
 import com.google.common.collect.Lists;
 import com.google.common.collect.MoreCollectors;
 import com.google.common.reflect.TypeToken;
+import me.lortseam.completeconfig.data.BoundedEntry;
 import me.lortseam.completeconfig.data.Entry;
-import me.lortseam.completeconfig.data.EnumOptions;
-import me.lortseam.completeconfig.util.TypeUtils;
+import me.lortseam.completeconfig.data.EnumEntry;
 import me.shedaniel.clothconfig2.api.AbstractConfigListEntry;
 import me.shedaniel.clothconfig2.api.ConfigEntryBuilder;
 import me.shedaniel.clothconfig2.impl.builders.DropdownMenuBuilder;
@@ -20,6 +20,7 @@ import java.util.Arrays;
 import java.util.List;
 import java.util.Optional;
 import java.util.function.Function;
+import java.util.function.Predicate;
 
 @Environment(EnvType.CLIENT)
 public class GuiRegistry {
@@ -36,12 +37,12 @@ public class GuiRegistry {
         registerDefaultProviders();
     }
 
-    public <T> void registerProvider(GuiProvider<T> provider, GuiProviderPredicate<T> predicate, Type... types) {
-        registrations.add(new GuiProviderRegistration<>(predicate.and((field, extras) -> {
+    public void registerProvider(GuiProvider<?> provider, Predicate<Entry<?>> predicate, Type... types) {
+        registrations.add(new GuiProviderRegistration(predicate.and(entry -> {
             if (types.length == 0) {
                 return true;
             }
-            return ArrayUtils.contains(types, TypeUtils.getFieldType(field));
+            return ArrayUtils.contains(types, entry.getType());
         }), provider));
     }
 
@@ -49,19 +50,19 @@ public class GuiRegistry {
         if (types.length == 0) {
             throw new IllegalArgumentException("Types must not be empty");
         }
-        registerProvider(provider, (field, extras) -> true, types);
+        registerProvider(provider, entry -> true, types);
     }
 
-    private void registerBoundedProvider(GuiProvider<?> provider, boolean slider, Type... types) {
-        registerProvider(provider, (field, extras) -> extras.getBounds() != null && extras.getBounds().isSlider() == slider, types);
+    private void registerBoundedProvider(GuiProvider<? extends BoundedEntry<?>> provider, boolean slider, Type... types) {
+        registerProvider(provider, entry -> entry instanceof BoundedEntry && ((BoundedEntry<?>) entry).isSlider() == slider, types);
     }
 
-    private void registerEnumProvider(GuiProvider<? extends Enum> provider, EnumOptions.DisplayType enumDisplayType) {
-        registerProvider(provider, (field, extras) -> Enum.class.isAssignableFrom(field.getType()) && extras.getEnumOptions().getDisplayType() == enumDisplayType);
+    private void registerEnumProvider(GuiProvider<? extends EnumEntry<?>> provider, EnumEntry.DisplayType enumDisplayType) {
+        registerProvider(provider, entry -> entry instanceof EnumEntry && ((EnumEntry<?>) entry).getDisplayType() == enumDisplayType);
     }
 
     private void registerDefaultProviders() {
-       registerProvider((GuiProvider<Boolean>) entry -> build(
+       registerProvider((Entry<Boolean> entry) -> build(
                builder -> builder
                        .startBooleanToggle(entry.getText(), entry.getValue())
                        .setDefaultValue(entry.getDefaultValue())
@@ -69,7 +70,7 @@ public class GuiRegistry {
                        .setSaveConsumer(entry::setValue),
                entry.requiresRestart()
        ), boolean.class, Boolean.class);
-       registerProvider((GuiProvider<Integer>) entry -> build(
+       registerProvider((Entry<Integer> entry) -> build(
                builder -> builder
                        .startIntField(entry.getText(), entry.getValue())
                        .setDefaultValue(entry.getDefaultValue())
@@ -77,25 +78,25 @@ public class GuiRegistry {
                        .setSaveConsumer(entry::setValue),
                entry.requiresRestart()
        ), int.class, Integer.class);
-       registerBoundedProvider((GuiProvider<Integer>) entry -> build(
+       registerBoundedProvider((BoundedEntry<Integer> entry) -> build(
                builder -> builder
                        .startIntField(entry.getText(), entry.getValue())
                        .setDefaultValue(entry.getDefaultValue())
-                       .setMin(entry.getExtras().getBounds().getMin())
-                       .setMax(entry.getExtras().getBounds().getMax())
+                       .setMin(entry.getMin())
+                       .setMax(entry.getMax())
                        .setTooltip(entry.getTooltip())
                        .setSaveConsumer(entry::setValue),
                entry.requiresRestart()
        ), false, int.class, Integer.class);
-       registerBoundedProvider((GuiProvider<Integer>) entry -> build(
+       registerBoundedProvider((BoundedEntry<Integer> entry) -> build(
                builder -> builder
-                       .startIntSlider(entry.getText(), entry.getValue(), entry.getExtras().getBounds().getMin(), entry.getExtras().getBounds().getMax())
+                       .startIntSlider(entry.getText(), entry.getValue(), entry.getMin(), entry.getMax())
                        .setDefaultValue(entry.getDefaultValue())
                        .setTooltip(entry.getTooltip())
                        .setSaveConsumer(entry::setValue),
                entry.requiresRestart()
        ), true, int.class, Integer.class);
-       registerProvider((GuiProvider<Long>) entry -> build(
+       registerProvider((Entry<Long> entry) -> build(
                builder -> builder
                        .startLongField(entry.getText(), entry.getValue())
                        .setDefaultValue(entry.getDefaultValue())
@@ -103,25 +104,25 @@ public class GuiRegistry {
                        .setSaveConsumer(entry::setValue),
                entry.requiresRestart()
        ), long.class, Long.class);
-       registerBoundedProvider((GuiProvider<Long>) entry -> build(
+       registerBoundedProvider((BoundedEntry<Long> entry) -> build(
                builder -> builder
                        .startLongField(entry.getText(), entry.getValue())
                        .setDefaultValue(entry.getDefaultValue())
-                       .setMin(entry.getExtras().getBounds().getMin())
-                       .setMax(entry.getExtras().getBounds().getMax())
+                       .setMin(entry.getMin())
+                       .setMax(entry.getMax())
                        .setTooltip(entry.getTooltip())
                        .setSaveConsumer(entry::setValue),
                entry.requiresRestart()
        ), false, long.class, Long.class);
-       registerBoundedProvider((GuiProvider<Long>) entry -> build(
+       registerBoundedProvider((BoundedEntry<Long> entry) -> build(
                builder -> builder
-                       .startLongSlider(entry.getText(), entry.getValue(), entry.getExtras().getBounds().getMin(), entry.getExtras().getBounds().getMax())
+                       .startLongSlider(entry.getText(), entry.getValue(), entry.getMin(), entry.getMax())
                        .setDefaultValue(entry.getDefaultValue())
                        .setTooltip(entry.getTooltip())
                        .setSaveConsumer(entry::setValue),
                entry.requiresRestart()
        ), true, long.class, Long.class);
-       registerProvider((GuiProvider<Float>) entry -> build(
+       registerProvider((Entry<Float> entry) -> build(
                builder -> builder
                        .startFloatField(entry.getText(), entry.getValue())
                        .setDefaultValue(entry.getDefaultValue())
@@ -129,17 +130,17 @@ public class GuiRegistry {
                        .setSaveConsumer(entry::setValue),
                entry.requiresRestart()
        ), float.class, Float.class);
-       registerBoundedProvider((GuiProvider<Float>) entry -> build(
+       registerBoundedProvider((BoundedEntry<Float> entry) -> build(
                builder -> builder
                        .startFloatField(entry.getText(), entry.getValue())
                        .setDefaultValue(entry.getDefaultValue())
-                       .setMin(entry.getExtras().getBounds().getMin())
-                       .setMax(entry.getExtras().getBounds().getMax())
+                       .setMin(entry.getMin())
+                       .setMax(entry.getMax())
                        .setTooltip(entry.getTooltip())
                        .setSaveConsumer(entry::setValue),
                entry.requiresRestart()
        ), false, float.class, Float.class);
-       registerProvider((GuiProvider<Double>) entry -> build(
+       registerProvider((Entry<Double> entry) -> build(
                builder -> builder
                        .startDoubleField(entry.getText(), entry.getValue())
                        .setDefaultValue(entry.getDefaultValue())
@@ -147,17 +148,17 @@ public class GuiRegistry {
                        .setSaveConsumer(entry::setValue),
                entry.requiresRestart()
        ), double.class, Double.class);
-       registerBoundedProvider((GuiProvider<Double>) entry -> build(
+       registerBoundedProvider((BoundedEntry<Double> entry) -> build(
                builder -> builder
                        .startDoubleField(entry.getText(), entry.getValue())
                        .setDefaultValue(entry.getDefaultValue())
-                       .setMin(entry.getExtras().getBounds().getMin())
-                       .setMax(entry.getExtras().getBounds().getMax())
+                       .setMin(entry.getMin())
+                       .setMax(entry.getMax())
                        .setTooltip(entry.getTooltip())
                        .setSaveConsumer(entry::setValue),
                entry.requiresRestart()
        ), false, double.class, Double.class);
-       registerProvider((GuiProvider<String>) entry -> build(
+       registerProvider((Entry<String> entry) -> build(
                builder -> builder
                        .startStrField(entry.getText(), entry.getValue())
                        .setDefaultValue(entry.getDefaultValue())
@@ -165,31 +166,31 @@ public class GuiRegistry {
                        .setSaveConsumer(entry::setValue),
                entry.requiresRestart()
        ), String.class);
-       registerEnumProvider((GuiProvider<? extends Enum<?>>) entry -> build(
+       registerEnumProvider((EnumEntry<Enum<?>> entry) -> build(
                builder -> builder
                        .startEnumSelector(entry.getText(), entry.getTypeClass(), entry.getValue())
                        .setDefaultValue(entry.getDefaultValue())
                        .setTooltip(entry.getTooltip())
-                       .setEnumNameProvider(entry.getExtras().getEnumOptions().getNameProvider())
+                       .setEnumNameProvider(entry.getEnumNameProvider())
                        .setSaveConsumer(entry::setValue),
                entry.requiresRestart()
-       ), EnumOptions.DisplayType.BUTTON);
-       registerEnumProvider((GuiProvider<? extends Enum>) entry -> {
-           List<Enum> enumValues = Arrays.asList(((Class<? extends Enum>) entry.getTypeClass()).getEnumConstants());
+       ), EnumEntry.DisplayType.BUTTON);
+       registerEnumProvider((EnumEntry<Enum<?>> entry) -> {
+           List<Enum> enumValues = Arrays.asList(((Class<? extends Enum<?>>) entry.getTypeClass()).getEnumConstants());
            return build(
                    builder -> builder
                            .startDropdownMenu(entry.getText(), DropdownMenuBuilder.TopCellElementBuilder.of(
                                    entry.getValue(),
-                                   enumTranslation -> enumValues.stream().filter(enumValue -> entry.getExtras().getEnumOptions().getNameProvider().apply(enumValue).getString().equals(enumTranslation)).collect(MoreCollectors.toOptional()).orElse(null),
-                                   entry.getExtras().getEnumOptions().getNameProvider()
-                           ), DropdownMenuBuilder.CellCreatorBuilder.of(entry.getExtras().getEnumOptions().getNameProvider()))
+                                   enumTranslation -> enumValues.stream().filter(enumValue -> entry.getEnumNameProvider().apply(enumValue).getString().equals(enumTranslation)).collect(MoreCollectors.toOptional()).orElse(null),
+                                   entry.getEnumNameProvider()
+                           ), DropdownMenuBuilder.CellCreatorBuilder.of(entry.getEnumNameProvider()))
                            .setSelections(enumValues)
                            .setDefaultValue(entry.getDefaultValue())
                            .setSaveConsumer(entry::setValue),
                    entry.requiresRestart()
            );
-       }, EnumOptions.DisplayType.DROPDOWN);
-       registerProvider((GuiProvider<List<Integer>>) entry -> build(
+       }, EnumEntry.DisplayType.DROPDOWN);
+       registerProvider((Entry<List<Integer>> entry) -> build(
                builder -> builder
                        .startIntList(entry.getText(), entry.getValue())
                        .setDefaultValue(entry.getDefaultValue())
@@ -197,7 +198,7 @@ public class GuiRegistry {
                        .setSaveConsumer(entry::setValue),
                entry.requiresRestart()
        ), new TypeToken<List<Integer>>() {}.getType());
-       registerProvider((GuiProvider<List<Long>>) entry -> build(
+       registerProvider((Entry<List<Long>> entry) -> build(
                builder -> builder
                        .startLongList(entry.getText(), entry.getValue())
                        .setDefaultValue(entry.getDefaultValue())
@@ -205,7 +206,7 @@ public class GuiRegistry {
                        .setSaveConsumer(entry::setValue),
                entry.requiresRestart()
        ), new TypeToken<List<Long>>() {}.getType());
-       registerProvider((GuiProvider<List<Float>>) entry -> build(
+       registerProvider((Entry<List<Float>> entry) -> build(
                builder -> builder
                        .startFloatList(entry.getText(), entry.getValue())
                        .setDefaultValue(entry.getDefaultValue())
@@ -213,7 +214,7 @@ public class GuiRegistry {
                        .setSaveConsumer(entry::setValue),
                entry.requiresRestart()
        ), new TypeToken<List<Float>>() {}.getType());
-       registerProvider((GuiProvider<List<Double>>) entry -> build(
+       registerProvider((Entry<List<Double>> entry) -> build(
                builder -> builder
                        .startDoubleList(entry.getText(), entry.getValue())
                        .setDefaultValue(entry.getDefaultValue())
@@ -221,7 +222,7 @@ public class GuiRegistry {
                        .setSaveConsumer(entry::setValue),
                entry.requiresRestart()
        ), new TypeToken<List<Double>>() {}.getType());
-       registerProvider((GuiProvider<List<String>>) entry -> build(
+       registerProvider((Entry<List<String>> entry) -> build(
                builder -> builder
                        .startStrList(entry.getText(), entry.getValue())
                        .setDefaultValue(entry.getDefaultValue())
@@ -231,10 +232,10 @@ public class GuiRegistry {
        ), new TypeToken<List<String>>() {}.getType());
     }
 
-    <T> Optional<GuiProvider<T>> getProvider(Entry<T> entry) {
-        for (GuiProviderRegistration<?> registration : Lists.reverse(registrations)) {
+    <E extends Entry<?>> Optional<GuiProvider<E>> getProvider(E entry) {
+        for (GuiProviderRegistration registration : Lists.reverse(registrations)) {
             if (registration.test(entry)) {
-                return Optional.of((GuiProvider<T>) registration.getProvider());
+                return Optional.of((GuiProvider<E>) registration.getProvider());
             }
         }
         return Optional.empty();