Overall code improvements & fixes

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

@@ -14,12 +14,14 @@ import java.util.Optional;
 @Log4j2
 public class Collection extends Node {
 
+    private final String id;
     private final TranslationIdentifier[] customTooltipTranslation;
     @Getter
     private final String comment;
 
-    Collection(TranslationIdentifier translation, String[] customTooltipTranslationKeys, String comment) {
+    Collection(String id, TranslationIdentifier translation, String[] customTooltipTranslationKeys, String comment) {
         super(translation);
+        this.id = id;
         customTooltipTranslation = ArrayUtils.isNotEmpty(customTooltipTranslationKeys) ? Arrays.stream(customTooltipTranslationKeys).map(key -> translation.root().appendKey(key)).toArray(TranslationIdentifier[]::new) : null;
         this.comment = !StringUtils.isBlank(comment) ? comment : null;
     }
@@ -38,4 +40,9 @@ public class Collection extends Node {
         super.fetch(node);
     }
 
+    @Override
+    public String getID() {
+        return id;
+    }
+
 }

src/main/java/me/lortseam/completeconfig/data/CollectionMap.java → src/main/java/me/lortseam/completeconfig/data/CollectionSet.java

@@ -5,21 +5,21 @@ import me.lortseam.completeconfig.api.ConfigGroup;
 import me.lortseam.completeconfig.data.text.TranslationIdentifier;
 
 @Log4j2
-public class CollectionMap extends DataMap<Collection> {
+public class CollectionSet extends DataSet<Collection> {
 
-    protected CollectionMap(TranslationIdentifier translation) {
+    protected CollectionSet(TranslationIdentifier translation) {
         super(translation);
     }
 
     void resolve(ConfigGroup group) {
         String groupID = group.getID();
-        Collection collection = new Collection(translation.append(groupID), group.getTooltipTranslationKeys(), group.getComment());
+        Collection collection = new Collection(groupID, translation.append(groupID), group.getTooltipTranslationKeys(), group.getComment());
         collection.resolve(group);
         if (collection.isEmpty()) {
             logger.warn("[CompleteConfig] Group " + groupID + " is empty!");
             return;
         }
-        put(groupID, collection);
+        add(collection);
     }
 
 }

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

@@ -1,45 +0,0 @@
-package me.lortseam.completeconfig.data;
-
-import lombok.AccessLevel;
-import lombok.RequiredArgsConstructor;
-import me.lortseam.completeconfig.data.text.TranslationIdentifier;
-import me.lortseam.completeconfig.data.structure.DataPart;
-import me.lortseam.completeconfig.data.structure.ParentDataPart;
-import org.apache.commons.lang3.StringUtils;
-import org.spongepowered.configurate.CommentedConfigurationNode;
-
-import java.util.LinkedHashMap;
-import java.util.Map;
-
-@RequiredArgsConstructor(access = AccessLevel.PROTECTED)
-public abstract class DataMap<T extends DataPart> extends LinkedHashMap<String, T> implements ParentDataPart<Map.Entry<String, T>, T> {
-
-    protected final TranslationIdentifier translation;
-
-    @Override
-    public T put(String id, T value) {
-        if (StringUtils.isBlank(id)) {
-            throw new IllegalArgumentException("ID must not be null or blank");
-        }
-        if (containsKey(id)) {
-            throw new IllegalArgumentException("Duplicate ID: " + id);
-        }
-        return super.put(id, value);
-    }
-
-    @Override
-    public Iterable<Map.Entry<String, T>> getChildren() {
-        return entrySet();
-    }
-
-    @Override
-    public CommentedConfigurationNode navigateToChild(CommentedConfigurationNode node, Map.Entry<String, T> stringTEntry) {
-        return node.node(stringTEntry.getKey());
-    }
-
-    @Override
-    public T retrieveChildValue(Map.Entry<String, T> stringTEntry) {
-        return stringTEntry.getValue();
-    }
-
-}

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

@@ -0,0 +1,15 @@
+package me.lortseam.completeconfig.data;
+
+import lombok.AccessLevel;
+import lombok.RequiredArgsConstructor;
+import me.lortseam.completeconfig.data.structure.DataPart;
+import me.lortseam.completeconfig.data.text.TranslationIdentifier;
+
+import java.util.LinkedHashSet;
+
+@RequiredArgsConstructor(access = AccessLevel.PROTECTED)
+public abstract class DataSet<T extends DataPart> extends LinkedHashSet<T> {
+
+    protected final TranslationIdentifier translation;
+
+}

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

@@ -153,7 +153,8 @@ public class Entry<T> extends EntryBase<T> implements DataPart {
         listeners.add(new Listener<>(method, parentObject));
     }
 
-    String getID() {
+    @Override
+    public String getID() {
         return customID != null ? customID : field.getName();
     }
 

src/main/java/me/lortseam/completeconfig/data/EntryMap.java → src/main/java/me/lortseam/completeconfig/data/EntrySet.java

@@ -13,19 +13,17 @@ import me.lortseam.completeconfig.exception.IllegalReturnTypeException;
 import java.lang.reflect.Field;
 import java.lang.reflect.Modifier;
 import java.util.Arrays;
-import java.util.function.Function;
 import java.util.regex.Pattern;
-import java.util.stream.Collectors;
 
-public class EntryMap extends DataMap<Entry> {
+public class EntrySet extends DataSet<Entry> {
 
-    EntryMap(TranslationIdentifier translation) {
+    EntrySet(TranslationIdentifier translation) {
         super(translation);
     }
 
     void resolve(ConfigContainer container) {
         for (Class<? extends ConfigContainer> clazz : container.getConfigClasses()) {
-            putAll(Arrays.stream(clazz.getDeclaredFields()).filter(field -> {
+            Arrays.stream(clazz.getDeclaredFields()).filter(field -> {
                 if (clazz != container.getClass() && Modifier.isStatic(field.getModifiers())) {
                     return false;
                 }
@@ -40,7 +38,7 @@ public class EntryMap extends DataMap<Entry> {
                 Entry<?> entry = Entry.Draft.of(field, container.getClass()).build(Modifier.isStatic(field.getModifiers()) ? null : container, translation);
                 entry.resolve(field);
                 return entry;
-            }).collect(Collectors.toMap(Entry::getID, Function.identity())));
+            }).forEach(this::add);
             Arrays.stream(clazz.getDeclaredMethods()).filter(method -> {
                 if (clazz != container.getClass() && Modifier.isStatic(method.getModifiers())) {
                     return false;

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

@@ -1,28 +1,32 @@
 package me.lortseam.completeconfig.data;
 
+import com.google.common.collect.Iterables;
 import me.lortseam.completeconfig.api.ConfigContainer;
 import me.lortseam.completeconfig.api.ConfigGroup;
-import me.lortseam.completeconfig.data.structure.FlatDataPart;
+import me.lortseam.completeconfig.data.structure.DataPart;
+import me.lortseam.completeconfig.data.structure.ParentDataPart;
 import me.lortseam.completeconfig.data.text.TranslationIdentifier;
 import me.lortseam.completeconfig.exception.IllegalAnnotationTargetException;
 import net.minecraft.text.Text;
+import org.apache.commons.lang3.ArrayUtils;
 
 import java.lang.reflect.Constructor;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Modifier;
-import java.util.*;
+import java.util.Arrays;
+import java.util.Collections;
 import java.util.stream.Collectors;
 
-abstract class Node implements FlatDataPart<DataMap> {
+abstract class Node implements ParentDataPart<DataPart> {
 
     protected final TranslationIdentifier translation;
-    private final EntryMap entries;
-    private final CollectionMap collections;
+    private final EntrySet entries;
+    private final CollectionSet collections;
 
     Node(TranslationIdentifier translation) {
         this.translation = translation;
-        entries = new EntryMap(translation);
-        collections = new CollectionMap(translation);
+        entries = new EntrySet(translation);
+        collections = new CollectionSet(translation);
     }
 
     public Text getText() {
@@ -30,11 +34,11 @@ abstract class Node implements FlatDataPart<DataMap> {
     }
 
     public java.util.Collection<Entry> getEntries() {
-        return Collections.unmodifiableCollection(entries.values());
+        return Collections.unmodifiableCollection(entries);
     }
 
     public java.util.Collection<Collection> getCollections() {
-        return Collections.unmodifiableCollection(collections.values());
+        return Collections.unmodifiableCollection(collections);
     }
 
     void resolve(ConfigContainer container) {
@@ -58,7 +62,9 @@ abstract class Node implements FlatDataPart<DataMap> {
                     throw new RuntimeException(e);
                 }
             }).collect(Collectors.toList()));
-            resolve(Arrays.stream(clazz.getDeclaredClasses()).filter(nestedClass -> {
+            Class<?>[] nestedClasses = clazz.getDeclaredClasses();
+            ArrayUtils.reverse(nestedClasses);
+            resolve(Arrays.stream(nestedClasses).filter(nestedClass -> {
                 if (nestedClass.isAnnotationPresent(ConfigContainer.Transitive.class)) {
                     if (!ConfigContainer.class.isAssignableFrom(nestedClass)) {
                         throw new IllegalAnnotationTargetException("Transitive " + nestedClass + " must implement " + ConfigContainer.class.getSimpleName());
@@ -95,12 +101,12 @@ abstract class Node implements FlatDataPart<DataMap> {
     }
 
     @Override
-    public Iterable<DataMap> getChildren() {
-        return Arrays.asList(entries, collections);
+    public Iterable<DataPart> getChildren() {
+        return Iterables.concat(entries, collections);
     }
 
     boolean isEmpty() {
-        return entries.isEmpty() && collections.isEmpty();
+        return Iterables.size(getChildren()) == 0;
     }
 
 }

src/main/java/me/lortseam/completeconfig/data/structure/DataPart.java

@@ -4,6 +4,10 @@ import org.spongepowered.configurate.CommentedConfigurationNode;
 
 public interface DataPart {
 
+    default String getID() {
+        throw new UnsupportedOperationException();
+    }
+
     void apply(CommentedConfigurationNode node);
 
     void fetch(CommentedConfigurationNode node);

src/main/java/me/lortseam/completeconfig/data/structure/FlatDataPart.java

@@ -1,17 +0,0 @@
-package me.lortseam.completeconfig.data.structure;
-
-import org.spongepowered.configurate.CommentedConfigurationNode;
-
-public interface FlatDataPart<CV extends DataPart> extends ParentDataPart<CV, CV> {
-
-    @Override
-    default CommentedConfigurationNode navigateToChild(CommentedConfigurationNode node, CV childValue) {
-        return node;
-    }
-
-    @Override
-    default CV retrieveChildValue(CV childValue) {
-        return childValue;
-    }
-
-}

src/main/java/me/lortseam/completeconfig/data/structure/ParentDataPart.java

@@ -1,41 +1,33 @@
 package me.lortseam.completeconfig.data.structure;
 
+import com.google.common.base.Predicates;
 import org.spongepowered.configurate.CommentedConfigurationNode;
 
-import java.util.function.Consumer;
-import java.util.function.Function;
+import java.util.function.BiConsumer;
 import java.util.function.Predicate;
 
-public interface ParentDataPart<C, CV extends DataPart> extends DataPart {
+public interface ParentDataPart<C extends DataPart> extends DataPart {
 
     Iterable<C> getChildren();
 
-    CommentedConfigurationNode navigateToChild(CommentedConfigurationNode node, C c);
-
-    CV retrieveChildValue(C c);
-
     @Override
     default void apply(CommentedConfigurationNode node) {
-        propagateToChildren(childNode -> !childNode.virtual(), child -> child::apply, node);
+        propagateToChildren(childNode -> !childNode.virtual(), DataPart::apply, node);
     }
 
     @Override
     default void fetch(CommentedConfigurationNode node) {
-        propagateToChildren(child -> child::fetch, node);
+        propagateToChildren(Predicates.alwaysTrue(), DataPart::fetch, node);
     }
 
-    default void propagateToChildren(Predicate<CommentedConfigurationNode> childNodeCondition, Function<CV, Consumer<CommentedConfigurationNode>> functionSupplier, CommentedConfigurationNode node) {
+    default void propagateToChildren(Predicate<CommentedConfigurationNode> childNodeCondition, BiConsumer<C, CommentedConfigurationNode> function, CommentedConfigurationNode node) {
         for (C child : getChildren()) {
-            CommentedConfigurationNode childNode = navigateToChild(node, child);
+            CommentedConfigurationNode childNode = node.node(child.getID());
             if (!childNodeCondition.test(childNode)) {
                 continue;
             }
-            functionSupplier.apply(retrieveChildValue(child)).accept(childNode);
+            function.accept(child, childNode);
         }
     }
 
-    default void propagateToChildren(Function<CV, Consumer<CommentedConfigurationNode>> functionSupplier, CommentedConfigurationNode node) {
-        propagateToChildren((childNode) -> true, functionSupplier, node);
-    }
-
 }

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

@@ -1,5 +1,6 @@
 package me.lortseam.completeconfig.gui.cloth;
 
+import com.google.common.base.Predicates;
 import com.google.common.collect.Lists;
 import com.google.common.collect.MoreCollectors;
 import com.google.common.reflect.TypeToken;
@@ -58,7 +59,7 @@ public final class GuiRegistry {
         if (types.length == 0) {
             throw new IllegalArgumentException("Types must not be empty");
         }
-        registerProvider(provider, entry -> true, types);
+        registerProvider(provider, Predicates.alwaysTrue(), types);
     }
 
     public void registerBoundedProvider(GuiProvider<? extends BoundedEntry<?>> provider, boolean slider, Type... types) {