Simplified and improved Cloth GUI building process

lib/src/main/java/me/lortseam/completeconfig/extensions/clothbasicmath/ClothBasicMathClientExtension.java

@@ -2,22 +2,21 @@ package me.lortseam.completeconfig.extensions.clothbasicmath;
 
 import me.lortseam.completeconfig.data.ColorEntry;
 import me.lortseam.completeconfig.extensions.ConfigExtensionPattern;
-import me.lortseam.completeconfig.gui.cloth.GuiProviderRegistration;
+import me.lortseam.completeconfig.gui.cloth.Provider;
 import me.lortseam.completeconfig.gui.cloth.GuiRegistry;
+import me.shedaniel.clothconfig2.api.ConfigEntryBuilder;
 import me.shedaniel.math.Color;
 
 public final class ClothBasicMathClientExtension implements ConfigExtensionPattern {
 
     ClothBasicMathClientExtension() {
-        dependOn("cloth-config2", () -> GuiRegistry.addGlobal(new GuiProviderRegistration<>((ColorEntry<Color> entry) -> GuiRegistry.build(
-                builder -> builder
+        dependOn("cloth-config2", () -> GuiRegistry.addGlobal(Provider.create(ColorEntry.class, (ColorEntry<Color> entry) -> ConfigEntryBuilder.create()
                         .startColorField(entry.getText(), entry.getValue())
                         .setAlphaMode(entry.isAlphaMode())
                         .setDefaultValue(entry.getDefaultValue().getColor())
                         .setTooltip(entry.getTooltip())
                         .setSaveConsumer2(entry::setValue),
-                entry.requiresRestart()
-        ), ColorEntry.class, Color.class)));
+                ColorEntry.class, Color.class)));
     }
 
 }

lib/src/main/java/me/lortseam/completeconfig/gui/cloth/ClothConfigScreenBuilder.java

@@ -65,7 +65,7 @@ public final class ClothConfigScreenBuilder extends ConfigScreenBuilder {
     }
 
     private AbstractConfigListEntry<?> buildEntry(Entry<?> entry) {
-        return registry.getProvider(entry).orElseThrow(() -> {
+        return registry.findBuilder(entry).orElseThrow(() -> {
             return new UnsupportedOperationException("Could not generate GUI for field " + entry.getField());
         }).build(entry);
     }

lib/src/main/java/me/lortseam/completeconfig/gui/cloth/EntryBuilder.java

@@ -0,0 +1,21 @@
+package me.lortseam.completeconfig.gui.cloth;
+
+import me.lortseam.completeconfig.data.Entry;
+import me.shedaniel.clothconfig2.api.AbstractConfigListEntry;
+import me.shedaniel.clothconfig2.impl.builders.FieldBuilder;
+import net.fabricmc.api.EnvType;
+import net.fabricmc.api.Environment;
+
+@Environment(EnvType.CLIENT)
+@FunctionalInterface
+public interface EntryBuilder<E extends Entry<?>> {
+
+    FieldBuilder<?, ?> apply(E entry);
+
+    default AbstractConfigListEntry<?> build(E entry) {
+        FieldBuilder<?, ?> builder = apply(entry);
+        builder.requireRestart(entry.requiresRestart());
+        return builder.build();
+    }
+
+}

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

@@ -1,14 +0,0 @@
-package me.lortseam.completeconfig.gui.cloth;
-
-import me.lortseam.completeconfig.data.Entry;
-import me.shedaniel.clothconfig2.api.AbstractConfigListEntry;
-import net.fabricmc.api.EnvType;
-import net.fabricmc.api.Environment;
-
-@Environment(EnvType.CLIENT)
-@FunctionalInterface
-public interface GuiProvider<E extends Entry<?>> {
-
-    AbstractConfigListEntry<?> build(E entry);
-
-}

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

@@ -1,45 +0,0 @@
-package me.lortseam.completeconfig.gui.cloth;
-
-import lombok.AccessLevel;
-import lombok.Getter;
-import me.lortseam.completeconfig.data.Entry;
-import me.lortseam.completeconfig.util.Arrays;
-import net.fabricmc.api.EnvType;
-import net.fabricmc.api.Environment;
-import org.apache.commons.lang3.ArrayUtils;
-
-import java.lang.reflect.Type;
-import java.util.function.Predicate;
-
-@Environment(EnvType.CLIENT)
-public final class GuiProviderRegistration<E extends Entry<?>> {
-
-    private final Predicate<Entry<?>> predicate;
-    @Getter(AccessLevel.PACKAGE)
-    private final GuiProvider<? extends E> provider;
-
-    public GuiProviderRegistration(GuiProvider<? extends E> provider, Predicate<Entry<?>> predicate, Type... types) {
-        this.predicate = entry -> {
-            if (types.length > 0 && !ArrayUtils.contains(types, entry.getType())) return false;
-            return predicate.test(entry);
-        };
-        this.provider = provider;
-    }
-
-    public GuiProviderRegistration(GuiProvider<? extends E> provider, Type... types) {
-        this(provider, entry -> true, Arrays.requireNonEmpty(types, "types"));
-    }
-
-    public GuiProviderRegistration(Class<E> entryType, GuiProvider<? extends E> provider, Predicate<E> predicate, Type... types) {
-        this(provider, entry -> entry.getClass() == entryType && predicate.test((E) entry), types);
-    }
-
-    public GuiProviderRegistration(Class<E> entryType, GuiProvider<? extends E> provider, Type... types) {
-        this(entryType, provider, entry -> true, types);
-    }
-
-    boolean test(Entry<?> entry) {
-        return predicate.test(entry);
-    }
-
-}

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

@@ -4,230 +4,179 @@ import com.google.common.collect.Lists;
 import com.google.common.collect.MoreCollectors;
 import com.google.common.reflect.TypeToken;
 import me.lortseam.completeconfig.data.*;
-import me.shedaniel.clothconfig2.api.AbstractConfigListEntry;
 import me.shedaniel.clothconfig2.api.ConfigEntryBuilder;
 import me.shedaniel.clothconfig2.impl.builders.DropdownMenuBuilder;
-import me.shedaniel.clothconfig2.impl.builders.FieldBuilder;
 import net.fabricmc.api.EnvType;
 import net.fabricmc.api.Environment;
 import net.minecraft.text.TextColor;
 
 import java.util.*;
-import java.util.function.Function;
+import java.util.stream.Stream;
 
 @Environment(EnvType.CLIENT)
 public final class GuiRegistry {
 
-    private static final List<GuiProviderRegistration> globalRegistrations = Lists.newArrayList(
-            new GuiProviderRegistration<>(BooleanEntry.class, entry -> build(
-                    builder -> builder
+    private static final List<Provider> globalProviders = Lists.newArrayList(
+            Provider.create(BooleanEntry.class, entry -> ConfigEntryBuilder.create()
                             .startBooleanToggle(entry.getText(), entry.getValue())
                             .setDefaultValue(entry.getDefaultValue())
                             .setYesNoTextSupplier(entry.getValueTextSupplier())
                             .setTooltip(entry.getTooltip())
                             .setSaveConsumer(entry::setValue),
-                    entry.requiresRestart()
-            ), boolean.class, Boolean.class),
-            new GuiProviderRegistration<>((Entry<Integer> entry) -> build(
-                    builder -> builder
+                    boolean.class, Boolean.class),
+            Provider.create((Entry<Integer> entry) -> ConfigEntryBuilder.create()
                             .startIntField(entry.getText(), entry.getValue())
                             .setDefaultValue(entry.getDefaultValue())
                             .setTooltip(entry.getTooltip())
                             .setSaveConsumer(entry::setValue),
-                    entry.requiresRestart()
-            ), int.class, Integer.class),
-            new GuiProviderRegistration<>(BoundedEntry.class, (BoundedEntry<Integer> entry) -> build(
-                    builder -> builder
+                    int.class, Integer.class),
+            Provider.create(BoundedEntry.class, (BoundedEntry<Integer> entry) -> ConfigEntryBuilder.create()
                             .startIntField(entry.getText(), entry.getValue())
                             .setDefaultValue(entry.getDefaultValue())
                             .setMin(entry.getMin())
                             .setMax(entry.getMax())
                             .setTooltip(entry.getTooltip())
                             .setSaveConsumer(entry::setValue),
-                    entry.requiresRestart()
-            ), int.class, Integer.class),
-            new GuiProviderRegistration<>(SliderEntry.class, (SliderEntry<Integer> entry) -> build(
-                    builder -> builder
+                    int.class, Integer.class),
+            Provider.create(SliderEntry.class, (SliderEntry<Integer> entry) -> ConfigEntryBuilder.create()
                             .startIntSlider(entry.getText(), entry.getValue(), entry.getMin(), entry.getMax())
                             .setDefaultValue(entry.getDefaultValue())
                             .setTextGetter(entry.getValueTextSupplier())
                             .setTooltip(entry.getTooltip())
                             .setSaveConsumer(entry::setValue),
-                    entry.requiresRestart()
-            ), int.class, Integer.class),
-            new GuiProviderRegistration<>(ColorEntry.class, (ColorEntry<Integer> entry) -> build(
-                    builder -> builder
+                    int.class, Integer.class),
+            Provider.create(ColorEntry.class, (ColorEntry<Integer> entry) -> ConfigEntryBuilder.create()
                             .startColorField(entry.getText(), entry.getValue())
                             .setDefaultValue(entry.getDefaultValue())
                             .setAlphaMode(entry.isAlphaMode())
                             .setTooltip(entry.getTooltip())
                             .setSaveConsumer(entry::setValue),
-                    entry.requiresRestart()
-            ), int.class, Integer.class),
-            new GuiProviderRegistration<>((Entry<Long> entry) -> build(
-                    builder -> builder
+                    int.class, Integer.class),
+            Provider.create((Entry<Long> entry) -> ConfigEntryBuilder.create()
                             .startLongField(entry.getText(), entry.getValue())
                             .setDefaultValue(entry.getDefaultValue())
                             .setTooltip(entry.getTooltip())
                             .setSaveConsumer(entry::setValue),
-                    entry.requiresRestart()
-            ), long.class, Long.class),
-            new GuiProviderRegistration<>(BoundedEntry.class, (BoundedEntry<Long> entry) -> build(
-                    builder -> builder
+                    long.class, Long.class),
+            Provider.create(BoundedEntry.class, (BoundedEntry<Long> entry) -> ConfigEntryBuilder.create()
                             .startLongField(entry.getText(), entry.getValue())
                             .setDefaultValue(entry.getDefaultValue())
                             .setMin(entry.getMin())
                             .setMax(entry.getMax())
                             .setTooltip(entry.getTooltip())
                             .setSaveConsumer(entry::setValue),
-                    entry.requiresRestart()
-            ), long.class, Long.class),
-            new GuiProviderRegistration<>(SliderEntry.class, (SliderEntry<Long> entry) -> build(
-                    builder -> builder
+                    long.class, Long.class),
+            Provider.create(SliderEntry.class, (SliderEntry<Long> entry) -> ConfigEntryBuilder.create()
                             .startLongSlider(entry.getText(), entry.getValue(), entry.getMin(), entry.getMax())
                             .setDefaultValue(entry.getDefaultValue())
                             .setTextGetter(entry.getValueTextSupplier())
                             .setTooltip(entry.getTooltip())
                             .setSaveConsumer(entry::setValue),
-                    entry.requiresRestart()
-            ), long.class, Long.class),
-            new GuiProviderRegistration<>((Entry<Float> entry) -> build(
-                    builder -> builder
+                    long.class, Long.class),
+            Provider.create((Entry<Float> entry) -> ConfigEntryBuilder.create()
                             .startFloatField(entry.getText(), entry.getValue())
                             .setDefaultValue(entry.getDefaultValue())
                             .setTooltip(entry.getTooltip())
                             .setSaveConsumer(entry::setValue),
-                    entry.requiresRestart()
-            ), float.class, Float.class),
-            new GuiProviderRegistration<>(BoundedEntry.class, (BoundedEntry<Float> entry) -> build(
-                    builder -> builder
+                    float.class, Float.class),
+            Provider.create(BoundedEntry.class, (BoundedEntry<Float> entry) -> ConfigEntryBuilder.create()
                             .startFloatField(entry.getText(), entry.getValue())
                             .setDefaultValue(entry.getDefaultValue())
                             .setMin(entry.getMin())
                             .setMax(entry.getMax())
                             .setTooltip(entry.getTooltip())
                             .setSaveConsumer(entry::setValue),
-                    entry.requiresRestart()
-            ), float.class, Float.class),
-            new GuiProviderRegistration<>((Entry<Double> entry) -> build(
-                    builder -> builder
+                    float.class, Float.class),
+            Provider.create((Entry<Double> entry) -> ConfigEntryBuilder.create()
                             .startDoubleField(entry.getText(), entry.getValue())
                             .setDefaultValue(entry.getDefaultValue())
                             .setTooltip(entry.getTooltip())
                             .setSaveConsumer(entry::setValue),
-                    entry.requiresRestart()
-            ), double.class, Double.class),
-            new GuiProviderRegistration<>(BoundedEntry.class, (BoundedEntry<Double> entry) -> build(
-                    builder -> builder
+                    double.class, Double.class),
+            Provider.create(BoundedEntry.class, (BoundedEntry<Double> entry) -> ConfigEntryBuilder.create()
                             .startDoubleField(entry.getText(), entry.getValue())
                             .setDefaultValue(entry.getDefaultValue())
                             .setMin(entry.getMin())
                             .setMax(entry.getMax())
                             .setTooltip(entry.getTooltip())
                             .setSaveConsumer(entry::setValue),
-                    entry.requiresRestart()
-            ), double.class, Double.class),
-            new GuiProviderRegistration<>((Entry<String> entry) -> build(
-                    builder -> builder
+                    double.class, Double.class),
+            Provider.create((Entry<String> entry) -> ConfigEntryBuilder.create()
                             .startStrField(entry.getText(), entry.getValue())
                             .setDefaultValue(entry.getDefaultValue())
                             .setTooltip(entry.getTooltip())
                             .setSaveConsumer(entry::setValue),
-                    entry.requiresRestart()
-            ), String.class),
-            new GuiProviderRegistration<>(EnumEntry.class, (EnumEntry<Enum<?>> entry) -> build(
-                    builder -> builder
+                    String.class),
+            Provider.create(EnumEntry.class, (EnumEntry<Enum<?>> entry) -> ConfigEntryBuilder.create()
                             .startEnumSelector(entry.getText(), entry.getTypeClass(), entry.getValue())
                             .setDefaultValue(entry.getDefaultValue())
                             .setTooltip(entry.getTooltip())
                             .setEnumNameProvider(entry.getEnumNameProvider())
                             .setSaveConsumer(entry::setValue),
-                    entry.requiresRestart()
-            ), entry -> entry.getDisplayType() == EnumEntry.DisplayType.BUTTON),
-            new GuiProviderRegistration<>(EnumEntry.class, (EnumEntry<Enum<?>> entry) -> {
+                    entry -> entry.getDisplayType() == EnumEntry.DisplayType.BUTTON),
+            Provider.create(EnumEntry.class, (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.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()
-                );
+                return ConfigEntryBuilder.create()
+                        .startDropdownMenu(entry.getText(), DropdownMenuBuilder.TopCellElementBuilder.of(
+                                entry.getValue(),
+                                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 -> entry.getDisplayType() == EnumEntry.DisplayType.DROPDOWN),
-            new GuiProviderRegistration<>((Entry<List<Integer>> entry) -> build(
-                    builder -> builder
+            Provider.create((Entry<List<Integer>> entry) -> ConfigEntryBuilder.create()
                             .startIntList(entry.getText(), entry.getValue())
                             .setDefaultValue(entry.getDefaultValue())
                             .setTooltip(entry.getTooltip())
                             .setSaveConsumer(entry::setValue),
-                    entry.requiresRestart()
-            ), new TypeToken<List<Integer>>() {}.getType()),
-            new GuiProviderRegistration<>((Entry<List<Long>> entry) -> build(
-                    builder -> builder
+                    new TypeToken<List<Integer>>() {}.getType()),
+            Provider.create((Entry<List<Long>> entry) -> ConfigEntryBuilder.create()
                             .startLongList(entry.getText(), entry.getValue())
                             .setDefaultValue(entry.getDefaultValue())
                             .setTooltip(entry.getTooltip())
                             .setSaveConsumer(entry::setValue),
-                    entry.requiresRestart()
-            ), new TypeToken<List<Long>>() {}.getType()),
-            new GuiProviderRegistration<>((Entry<List<Float>> entry) -> build(
-                    builder -> builder
+                    new TypeToken<List<Long>>() {}.getType()),
+            Provider.create((Entry<List<Float>> entry) -> ConfigEntryBuilder.create()
                             .startFloatList(entry.getText(), entry.getValue())
                             .setDefaultValue(entry.getDefaultValue())
                             .setTooltip(entry.getTooltip())
                             .setSaveConsumer(entry::setValue),
-                    entry.requiresRestart()
-            ), new TypeToken<List<Float>>() {}.getType()),
-            new GuiProviderRegistration<>((Entry<List<Double>> entry) -> build(
-                    builder -> builder
+                    new TypeToken<List<Float>>() {}.getType()),
+            Provider.create((Entry<List<Double>> entry) -> ConfigEntryBuilder.create()
                             .startDoubleList(entry.getText(), entry.getValue())
                             .setDefaultValue(entry.getDefaultValue())
                             .setTooltip(entry.getTooltip())
                             .setSaveConsumer(entry::setValue),
-                    entry.requiresRestart()
-            ), new TypeToken<List<Double>>() {}.getType()),
-            new GuiProviderRegistration<>((Entry<List<String>> entry) -> build(
-                    builder -> builder
+                    new TypeToken<List<Double>>() {}.getType()),
+            Provider.create((Entry<List<String>> entry) -> ConfigEntryBuilder.create()
                             .startStrList(entry.getText(), entry.getValue())
                             .setDefaultValue(entry.getDefaultValue())
                             .setTooltip(entry.getTooltip())
                             .setSaveConsumer(entry::setValue),
-                    entry.requiresRestart()
-            ), new TypeToken<List<String>>() {}.getType()),
-            new GuiProviderRegistration<>(ColorEntry.class, (ColorEntry<TextColor> entry) -> build(
-                    builder -> builder
+                    new TypeToken<List<String>>() {}.getType()),
+            Provider.create(ColorEntry.class, (ColorEntry<TextColor> entry) -> ConfigEntryBuilder.create()
                         .startColorField(entry.getText(), entry.getValue())
                         .setDefaultValue(entry.getDefaultValue())
                         .setTooltip(entry.getTooltip())
                         .setSaveConsumer3(entry::setValue),
-                    entry.requiresRestart()
-            ), entry -> !entry.isAlphaMode(), TextColor.class)
+                    entry -> !entry.isAlphaMode(), TextColor.class)
     );
 
-    public static void addGlobal(GuiProviderRegistration... registrations) {
-        Collections.addAll(globalRegistrations, registrations);
-    }
-
-    public static AbstractConfigListEntry<?> build(Function<ConfigEntryBuilder, FieldBuilder<?, ?>> builder, boolean requiresRestart) {
-        FieldBuilder<?, ?> fieldBuilder = builder.apply(ConfigEntryBuilder.create());
-        fieldBuilder.requireRestart(requiresRestart);
-        return fieldBuilder.build();
+    public static void addGlobal(Provider... providers) {
+        Collections.addAll(globalProviders, providers);
     }
 
-    private final List<GuiProviderRegistration> registrations = new ArrayList<>(globalRegistrations);
+    private final List<Provider> providers = new ArrayList<>();
 
-    public void add(GuiProviderRegistration... registrations) {
-        Collections.addAll(this.registrations, registrations);
+    public void add(Provider... providers) {
+        Collections.addAll(this.providers, providers);
     }
 
-    Optional<GuiProvider<Entry<?>>> getProvider(Entry<?> entry) {
-        return registrations.stream().filter(registration -> registration.test(entry)).findFirst().map(registration -> {
-            return (GuiProvider<Entry<?>>) registration.getProvider();
+    Optional<EntryBuilder<Entry<?>>> findBuilder(Entry<?> entry) {
+        return Stream.of(providers, globalProviders).flatMap(List::stream).filter(provider -> provider.test(entry)).findFirst().map(provider -> {
+            return (EntryBuilder<Entry<?>>) provider.getBuilder();
         });
     }
 

lib/src/main/java/me/lortseam/completeconfig/gui/cloth/Provider.java

@@ -0,0 +1,49 @@
+package me.lortseam.completeconfig.gui.cloth;
+
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import me.lortseam.completeconfig.data.Entry;
+import net.fabricmc.api.EnvType;
+import net.fabricmc.api.Environment;
+import org.apache.commons.lang3.ArrayUtils;
+
+import java.lang.reflect.Type;
+import java.util.function.Predicate;
+
+@Environment(EnvType.CLIENT)
+@RequiredArgsConstructor(access = AccessLevel.PRIVATE)
+public final class Provider {
+
+    public static <E extends Entry<?>> Provider create(Class<E> entryType, EntryBuilder<? extends E> builder, Predicate<E> predicate, Type... types) {
+        return new Provider(entry -> {
+            if (entry.getClass() != (entryType != null ? entryType : Entry.class)) return false;
+            if (types.length > 0 && !ArrayUtils.contains(types, entry.getType())) return false;
+            return predicate.test((E) entry);
+        }, builder);
+    }
+
+    public static <E extends Entry<?>> Provider create(Class<E> entryType, EntryBuilder<? extends E> builder, Type... types) {
+        return create(entryType, builder, entry -> true, types);
+    }
+
+    public static Provider create(EntryBuilder<?> builder, Predicate<Entry<?>> predicate, Type... types) {
+        return create(null, builder, predicate, types);
+    }
+
+    public static Provider create(EntryBuilder<?> builder, Type... types) {
+        if (types.length == 0) {
+            throw new IllegalArgumentException("Types must not be empty");
+        }
+        return create(builder, entry -> true, types);
+    }
+
+    private final Predicate<Entry<?>> predicate;
+    @Getter
+    private final EntryBuilder<?> builder;
+
+    boolean test(Entry<?> entry) {
+        return predicate.test(entry);
+    }
+
+}

lib/src/main/java/me/lortseam/completeconfig/util/Arrays.java

@@ -1,15 +0,0 @@
-package me.lortseam.completeconfig.util;
-
-import lombok.experimental.UtilityClass;
-
-@UtilityClass
-public final class Arrays {
-
-    public static <T> T[] requireNonEmpty(T[] array, String name) {
-        if (array.length == 0) {
-            throw new IllegalArgumentException(name + " must not be empty");
-        }
-        return array;
-    }
-
-}