Add processed category interface

lineargraph · lineargraph · commit 5887489c02cc · 2024-11-12T14:03:41.000+01:00
diff --git a/common/src/main/java/io/github/notenoughupdates/moulconfig/Config.java b/common/src/main/java/io/github/notenoughupdates/moulconfig/Config.java
@@ -38,11 +38,11 @@ public HorizontalAlign alignCategory(ProcessedCategory category, boolean isSelec
 
     public String formatCategoryName(ProcessedCategory category, boolean isSelected) {
         if (isSelected) {
-            return "§b§n" + category.name;
-        } else if (category.parent == null) {
-            return "§7" + category.name;
+            return "§b§n" + category.getDisplayName();
+        } else if (category.getParentCategoryId() == null) {
+            return "§7" + category.getDisplayName();
         } else {
-            return "§8" + category.name;
+            return "§8" + category.getDisplayName();
         }
     }
 
diff --git a/common/src/main/java/io/github/notenoughupdates/moulconfig/gui/MoulConfigEditor.java b/common/src/main/java/io/github/notenoughupdates/moulconfig/gui/MoulConfigEditor.java
@@ -67,7 +67,7 @@ public class MoulConfigEditor<T extends Config> extends GuiElement {
     @Setter
     private SearchFunction searchFunction = GuiOptionEditor::fulfillsSearch;
 
-    private LinkedHashMap<String, ProcessedCategory> currentlyVisibleCategories;
+    private LinkedHashMap<String, ? extends ProcessedCategory> currentlyVisibleCategories;
     private Set<ProcessedOption> currentlyVisibleOptions;
     private Map<String, Set<String>> childCategoryLookup = new HashMap<>();
     private List<ProcessedOption> allOptions = new ArrayList<>();
@@ -76,10 +76,10 @@ public MoulConfigEditor(MoulConfigProcessor<T> processedConfig) {
         processedConfig.requireFinalized();
         this.openedMillis = System.currentTimeMillis();
         this.processedConfig = processedConfig;
-        for (Map.Entry<String, ProcessedCategory> category : processedConfig.getAllCategories().entrySet()) {
-            allOptions.addAll(category.getValue().options);
-            if (category.getValue().parent != null) {
-                childCategoryLookup.computeIfAbsent(category.getValue().parent, ignored -> new HashSet<>())
+        for (Map.Entry<String, ? extends ProcessedCategory> category : processedConfig.getAllCategories().entrySet()) {
+            allOptions.addAll(category.getValue().getOptions());
+            if (category.getValue().getParentCategoryId() != null) {
+                childCategoryLookup.computeIfAbsent(category.getValue().getParentCategoryId(), ignored -> new HashSet<>())
                     .add(category.getKey());
             }
         }
@@ -91,7 +91,7 @@ public MoulConfigEditor(MoulConfigProcessor<T> processedConfig) {
     }
 
     private List<ProcessedOption> getOptionsInCategory(ProcessedCategory cat) {
-        List<ProcessedOption> options = new ArrayList<>(cat.options);
+        List<ProcessedOption> options = new ArrayList<>(cat.getOptions());
         options.removeIf(it -> !currentlyVisibleOptions.contains(it));
         return options;
     }
@@ -107,7 +107,7 @@ public boolean scrollOptionIntoView(ProcessedOption searchedOption, int timeToRe
         // Recursively expand accordions this option is in
         var accordionP = searchedOption;
         while (accordionP.getAccordionId() >= 0) {
-            accordionP = processedCategory.accordionAnchors.get(accordionP.getAccordionId());
+            accordionP = processedCategory.getAccordionAnchors().get(accordionP.getAccordionId());
             ((GuiOptionEditorAccordion) accordionP.getEditor()).setToggled(true);
         }
 
@@ -169,7 +169,7 @@ private void propagateSearchinessForAccordions(Set<ProcessedOption> options, Set
 
         for (ProcessedOption option : lastRound) {
             if (option.getAccordionId() >= 0 && upwards) {
-                for (ProcessedOption accordion : option.getCategory().options) {
+                for (ProcessedOption accordion : option.getCategory().getOptions()) {
                     if (accordion == option) continue;
                     if (!(accordion.getEditor() instanceof GuiOptionEditorAccordion)) continue;
                     if (((GuiOptionEditorAccordion) accordion.getEditor()).getAccordionId() == option.getAccordionId()) {
@@ -179,7 +179,7 @@ private void propagateSearchinessForAccordions(Set<ProcessedOption> options, Set
             }
             if (option.getEditor() instanceof GuiOptionEditorAccordion && !upwards) {
                 int parentId = ((GuiOptionEditorAccordion) option.getEditor()).getAccordionId();
-                for (ProcessedOption potentialChild : option.getCategory().options) {
+                for (ProcessedOption potentialChild : option.getCategory().getOptions()) {
                     if (potentialChild.getAccordionId() == parentId) {
                         nextRound.add(potentialChild);
                     }
@@ -201,7 +201,7 @@ public void updateSearchResults(boolean recalculateOptionUniverse) {
         if (recalculateOptionUniverse) {
             allOptions.clear();
             for (ProcessedCategory category : processedConfig.getAllCategories().values()) {
-                allOptions.addAll(category.options);
+                allOptions.addAll(category.getOptions());
             }
         }
         String toSearch = searchFieldContent.get().trim().toLowerCase(Locale.ROOT);
@@ -214,14 +214,15 @@ public void updateSearchResults(boolean recalculateOptionUniverse) {
             HashSet<ProcessedCategory> directlyMatchedCategories = new HashSet<>(processedConfig.getAllCategories().values());
             if (!processedConfig.getConfigObject().shouldSearchCategoryNames()) directlyMatchedCategories.clear();
             for (String word : toSearch.split(" +")) {
-                directlyMatchedCategories.removeIf(it -> ContextAware.wrapErrorWithContext(it.reflectField,
-                    () -> !(it.name.toLowerCase(Locale.ROOT).contains(word) || it.desc.toLowerCase(Locale.ROOT).contains(word))));
+                directlyMatchedCategories.removeIf(it -> ContextAware.wrapErrorWithContext(it,
+                    () -> !(it.getDisplayName().toLowerCase(Locale.ROOT).contains(word)
+                        || it.getDescription().toLowerCase(Locale.ROOT).contains(word))));
             }
 
             Set<ProcessedOption> matchingOptionsAndDependencies = new HashSet<>();
 
             var childCategoriesOfDirectlyMatched = directlyMatchedCategories.stream()
-                .flatMap(it -> childCategoryLookup.getOrDefault(it.name, Collections.emptySet()).stream())
+                .flatMap(it -> childCategoryLookup.getOrDefault(it.getIdentifier(), Collections.emptySet()).stream())
                 .map(processedConfig.getAllCategories()::get)
                 .filter(Objects::nonNull)
                 .collect(Collectors.toList());
@@ -230,18 +231,21 @@ public void updateSearchResults(boolean recalculateOptionUniverse) {
             // No search propagation needed if category is matched.
             // Add them directly to the final visible option set.
             for (ProcessedCategory directCategory : directlyMatchedCategories) {
-                matchingOptionsAndDependencies.addAll(directCategory.options);
-                directCategory.options.forEach(matchingOptions::remove);
+                matchingOptionsAndDependencies.addAll(directCategory.getOptions());
+                directCategory.getOptions().forEach(matchingOptions::remove);
             }
 
             propagateSearchinessForAccordions(matchingOptionsAndDependencies, matchingOptions, true);
             propagateSearchinessForAccordions(matchingOptionsAndDependencies, matchingOptions, false);
 
             currentlyVisibleOptions = matchingOptionsAndDependencies;
 
-            Set<ProcessedCategory> visibleCategories = matchingOptionsAndDependencies.stream().map(it -> it.getCategory()).collect(Collectors.toSet());
+            Set<ProcessedCategory> visibleCategories = matchingOptionsAndDependencies
+                .stream()
+                .map(ProcessedOption::getCategory).collect(Collectors.toSet());
             Set<ProcessedCategory> parentCategories = visibleCategories.stream()
-                .filter(it -> it.parent != null).map(it -> processedConfig.getAllCategories().get(it.parent))
+                .filter(it -> it.getParentCategoryId() != null)
+                .map(it -> processedConfig.getAllCategories().get(it.getParentCategoryId()))
                 .filter(Objects::nonNull).collect(Collectors.toSet());
             visibleCategories.addAll(parentCategories);
             LinkedHashMap<String, ProcessedCategory> matchingCategories = new LinkedHashMap<>(processedConfig.getAllCategories());
@@ -254,21 +258,21 @@ public void updateSearchResults(boolean recalculateOptionUniverse) {
     }
 
     public LinkedHashMap<String, ProcessedCategory> getCurrentlyVisibleCategories() {
-        var newHashes = new LinkedHashMap<>(currentlyVisibleCategories);
+        var newHashes = new LinkedHashMap<String, ProcessedCategory>(currentlyVisibleCategories);
         newHashes.entrySet().removeIf(it -> {
-            if (it.getValue().parent == null) return false;
+            if (it.getValue().getParentCategoryId() == null) return false;
             if (!showSubcategories) return true;
-            if (it.getValue().parent.equals(getSelectedCategory())) return false;
+            if (it.getValue().getParentCategoryId().equals(getSelectedCategory())) return false;
             var processedCategory = currentlyVisibleCategories.get(getSelectedCategory());
             if (processedCategory == null) return true;
             //noinspection RedundantIfStatement
-            if (it.getValue().parent.equals(processedCategory.parent)) return false;
+            if (it.getValue().getParentCategoryId().equals(processedCategory.getParentCategoryId())) return false;
             return true;
         });
         return newHashes;
     }
 
-    public LinkedHashMap<String, ProcessedCategory> getCurrentlySearchedCategories() {
+    public LinkedHashMap<String, ? extends ProcessedCategory> getCurrentlySearchedCategories() {
         return currentlyVisibleCategories;
     }
 
@@ -378,7 +382,7 @@ public void render() {
             var catName = processedConfig.getConfigObject().formatCategoryName(entry.getValue(), isSelected);
             var align = processedConfig.getConfigObject().alignCategory(entry.getValue(), isSelected);
             var textLength = ifr.getStringWidth(catName);
-            var isIndented = childCategories != null || entry.getValue().parent != null;
+            var isIndented = childCategories != null || entry.getValue().getParentCategoryId() != null;
             if (textLength > ((isIndented) ? 90 : 100)) {
                 context.drawStringCenteredScaledMaxWidth(catName,
                     ifr, x + 75 + (isIndented ? 5 : 0), y + 70 + catY, false, (isIndented ? 90 : 100), -1
@@ -477,7 +481,7 @@ public void render() {
             ProcessedCategory cat = currentConfigEditing.get(getSelectedCategory());
 
             context.drawStringScaledMaxWidth(
-                cat.desc,
+                cat.getDescription(),
                 ifr, innerLeft + 1, y + 40, true, innerRight - innerLeft - rightStuffLen - 10, 0xb0b0b0
             );
         }
@@ -865,7 +869,7 @@ public boolean mouseInput(int mouseX, int mouseY, MouseEvent mouseEvent) {
                     if (mouseX >= x + 5 && mouseX <= x + 145 &&
                         mouseY >= y + 70 + catY - 7 && mouseY <= y + 70 + catY + 7) {
                         if (entry.getKey().equals(getSelectedCategory())) {
-                            if (entry.getValue().parent == null)
+                            if (entry.getValue().getParentCategoryId() == null)
                                 showSubcategories = !showSubcategories;
                         } else {
                             showSubcategories = true;
diff --git a/common/src/main/java/io/github/notenoughupdates/moulconfig/internal/ContextAware.java b/common/src/main/java/io/github/notenoughupdates/moulconfig/internal/ContextAware.java
@@ -1,6 +1,7 @@
 package io.github.notenoughupdates.moulconfig.internal;
 
 import io.github.notenoughupdates.moulconfig.gui.GuiOptionEditor;
+import io.github.notenoughupdates.moulconfig.processor.HasDebugLocation;
 
 import java.lang.reflect.Field;
 
@@ -18,10 +19,14 @@ public static <T> T wrapErrorWithContext(GuiOptionEditor editor, ContextAwareRun
     }
 
     public static <T> T wrapErrorWithContext(Field field, ContextAwareRunnable<T> runnable) {
+        return wrapErrorWithContext(field::toString, runnable);
+    }
+
+    public static <T> T wrapErrorWithContext(HasDebugLocation field, ContextAwareRunnable<T> runnable) {
         try {
             return runnable.run();
         } catch (Exception e) {
-            throw new ContextualException(e, field.toString());
+            throw new ContextualException(e, field.getDebugDeclarationLocation());
         }
     }
 
diff --git a/common/src/main/java/io/github/notenoughupdates/moulconfig/processor/HasDebugLocation.java b/common/src/main/java/io/github/notenoughupdates/moulconfig/processor/HasDebugLocation.java
@@ -0,0 +1,6 @@
+package io.github.notenoughupdates.moulconfig.processor;
+
+@FunctionalInterface
+public interface HasDebugLocation {
+    String getDebugDeclarationLocation();
+}
diff --git a/common/src/main/java/io/github/notenoughupdates/moulconfig/processor/MoulConfigProcessor.java b/common/src/main/java/io/github/notenoughupdates/moulconfig/processor/MoulConfigProcessor.java
@@ -39,8 +39,8 @@
 public class MoulConfigProcessor<T extends Config> implements ConfigStructureReader {
 
     private final T configBaseObject;
-    private final LinkedHashMap<String, ProcessedCategory> categories = new LinkedHashMap<>();
-    private ProcessedCategory currentCategory;
+    private final LinkedHashMap<String, ProcessedCategoryImpl> categories = new LinkedHashMap<>();
+    private ProcessedCategoryImpl currentCategory;
     private Stack<Integer> accordion = new Stack<>();
     private Stack<String> categoryPath = new Stack<>();
     @Getter
@@ -71,7 +71,7 @@ public void requireFinalized() {
 
     @Override
     public void beginCategory(Object baseObject, Field field, String name, String description) {
-        currentCategory = new ProcessedCategory(field, name, description);
+        currentCategory = new ProcessedCategoryImpl(field, name, description);
         categories.put(currentCategory.getIdentifier(), currentCategory);
     }
 
@@ -175,7 +175,7 @@ protected GuiOptionEditor createOptionGui(ProcessedOption processedOption, Field
         return null;
     }
 
-    public LinkedHashMap<String, ProcessedCategory> getAllCategories() {
+    public LinkedHashMap<String, ? extends ProcessedCategory> getAllCategories() {
         requireFinalized();
         return this.categories;
     }
diff --git a/common/src/main/java/io/github/notenoughupdates/moulconfig/processor/ProcessedCategory.java b/common/src/main/java/io/github/notenoughupdates/moulconfig/processor/ProcessedCategory.java
@@ -21,34 +21,23 @@
 package io.github.notenoughupdates.moulconfig.processor;
 
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.annotations.Unmodifiable;
 
-import java.lang.reflect.Field;
-import java.util.ArrayList;
-import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
-public class ProcessedCategory { // TODO: replace with interface
-    public final String name;
-    public final String desc;
-    public final Field reflectField;
-    public final List<ProcessedOption> options = new ArrayList<>();
-    public final Map<Integer, ProcessedOption> accordionAnchors = new HashMap<>();
-
-    public @Nullable String parent;
-
-    public String getIdentifier() {
-        return reflectField.toString();
-    }
-
-    public ProcessedCategory(Field field, String name, String desc) {
-        this(field, name, desc, null);
-    }
-
-    public ProcessedCategory(Field field, String name, String desc, @Nullable String parent) {
-        this.reflectField = field;
-        this.name = name;
-        this.parent = parent;
-        this.desc = desc;
-    }
+public interface ProcessedCategory extends HasDebugLocation {
+    String getDisplayName();
+
+    String getDescription();
+
+    String getIdentifier();
+
+    @Nullable String getParentCategoryId();
+
+    @Unmodifiable
+    List<ProcessedOption> getOptions();
+
+    @Unmodifiable
+    Map<Integer, ProcessedOption> getAccordionAnchors();
 }
diff --git a/common/src/main/java/io/github/notenoughupdates/moulconfig/processor/ProcessedCategoryImpl.java b/common/src/main/java/io/github/notenoughupdates/moulconfig/processor/ProcessedCategoryImpl.java
@@ -0,0 +1,66 @@
+package io.github.notenoughupdates.moulconfig.processor;
+
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.annotations.Unmodifiable;
+
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class ProcessedCategoryImpl implements ProcessedCategory {
+    public final String name;
+    public final String desc;
+    public final Field reflectField;
+    public final List<ProcessedOption> options = new ArrayList<>();
+    public final Map<Integer, ProcessedOption> accordionAnchors = new HashMap<>();
+
+    public @Nullable String parent;
+
+    @Override
+    public String getDisplayName() {
+        return name;
+    }
+
+    @Override
+    public String getDescription() {
+        return desc;
+    }
+
+    @Override
+    public String getDebugDeclarationLocation() {
+        return reflectField.toString();
+    }
+
+    @Override
+    public String getIdentifier() {
+        return reflectField.toString();
+    }
+
+    @Override
+    public @Nullable String getParentCategoryId() {
+        return parent;
+    }
+
+    @Override
+    public @Unmodifiable List<ProcessedOption> getOptions() {
+        return options;
+    }
+
+    @Override
+    public @Unmodifiable Map<Integer, ProcessedOption> getAccordionAnchors() {
+        return accordionAnchors;
+    }
+
+    public ProcessedCategoryImpl(Field field, String name, String desc) {
+        this(field, name, desc, null);
+    }
+
+    public ProcessedCategoryImpl(Field field, String name, String desc, @Nullable String parent) {
+        this.reflectField = field;
+        this.name = name;
+        this.parent = parent;
+        this.desc = desc;
+    }
+}
diff --git a/common/src/main/java/io/github/notenoughupdates/moulconfig/processor/ProcessedOption.java b/common/src/main/java/io/github/notenoughupdates/moulconfig/processor/ProcessedOption.java
@@ -71,7 +71,7 @@ public SearchTag[] getSearchTags() {
     public GuiOptionEditorAccordion getOwningAccordion() {
         if (owningAccordion == null && getAccordionId() >= 0) {
             owningAccordion = getCategory()
-                .options
+                .getOptions()
                 .stream()
                 .map(ProcessedOption::getEditor)
                 .filter(it -> it instanceof GuiOptionEditorAccordion)

Original file line number	Diff line number	Diff line change
`@@ -38,11 +38,11 @@ public HorizontalAlign alignCategory(ProcessedCategory category, boolean isSelec`
`38`	`38`
`39`	`39`	`public String formatCategoryName(ProcessedCategory category, boolean isSelected) {`
`40`	`40`	`if (isSelected) {`
`41`		`- return "§b§n" + category.name;`
`42`		`- } else if (category.parent == null) {`
`43`		`- return "§7" + category.name;`
	`41`	`+ return "§b§n" + category.getDisplayName();`
	`42`	`+ } else if (category.getParentCategoryId() == null) {`
	`43`	`+ return "§7" + category.getDisplayName();`
`44`	`44`	`} else {`
`45`		`- return "§8" + category.name;`
	`45`	`+ return "§8" + category.getDisplayName();`
`46`	`46`	`}`
`47`	`47`	`}`
`48`	`48`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,7 @@`
`1`	`1`	`package io.github.notenoughupdates.moulconfig.internal;`
`2`	`2`
`3`	`3`	`import io.github.notenoughupdates.moulconfig.gui.GuiOptionEditor;`
	`4`	`+import io.github.notenoughupdates.moulconfig.processor.HasDebugLocation;`
`4`	`5`
`5`	`6`	`import java.lang.reflect.Field;`
`6`	`7`
`@@ -18,10 +19,14 @@ public static <T> T wrapErrorWithContext(GuiOptionEditor editor, ContextAwareRun`
`18`	`19`	`}`
`19`	`20`
`20`	`21`	`public static <T> T wrapErrorWithContext(Field field, ContextAwareRunnable<T> runnable) {`
	`22`	`+ return wrapErrorWithContext(field::toString, runnable);`
	`23`	`+ }`
	`24`	`+`
	`25`	`+ public static <T> T wrapErrorWithContext(HasDebugLocation field, ContextAwareRunnable<T> runnable) {`
`21`	`26`	`try {`
`22`	`27`	`return runnable.run();`
`23`	`28`	`} catch (Exception e) {`
`24`		`- throw new ContextualException(e, field.toString());`
	`29`	`+ throw new ContextualException(e, field.getDebugDeclarationLocation());`
`25`	`30`	`}`
`26`	`31`	`}`
`27`	`32`