replaced backing map in deconstructed object with list

Author: Pesekjak

foundry-core/src/main/java/org/machinemc/foundry/model/DeconstructedObject.java

@@ -25,6 +25,7 @@ public final class DeconstructedObject implements Iterable<DeconstructedObject.F
      * @param <T> type of the object
      * @return a codec that converts an instance of {@link T} into a deconstructed object and back
      */
+    // TODO overload method that takes class model
     public static <T> Codec<T, DeconstructedObject> codec(Class<T> type) {
         ClassModel classModel = ClassModel.of(type);
         ObjectFactory<T> objectFactory = ObjectFactory.create(type, classModel);
@@ -44,6 +45,7 @@ public static <T> Codec<T, DeconstructedObject> codec(Class<T> type) {
      * @param <T> type of the object
      * @return a data handler that converts an instance of {@link T} into a deconstructed object
      */
+    // TODO overload method that takes class model
     public static <T> DataHandler<T, DeconstructedObject> createDeconstructor(Class<T> type) {
         ClassModel classModel = ClassModel.of(type);
         return createDeconstructor(classModel, ObjectFactory.create(type, classModel));
@@ -62,36 +64,16 @@ public static <T> DataHandler<T, DeconstructedObject> createDeconstructor(Class<
      * @param <T> type of the object
      * @return a data handler that converts deconstructed object into an instance of {@link T}
      */
+    // TODO overload method that takes class model
     public static <T> DataHandler<DeconstructedObject, T> createConstructor(Class<T> type) {
         ClassModel classModel = ClassModel.of(type);
         return createConstructor(classModel, ObjectFactory.create(type, classModel));
     }
 
-    // TODO this must also take source class as field names can overlap
-    private final @Unmodifiable Map<String, Field> fields;
+    private final @Unmodifiable List<Field> fields;
 
-    DeconstructedObject(Map<String, Field> fields) {
-        this.fields = Collections.unmodifiableMap(fields);
-    }
-
-    /**
-     * Returns field with given name of empty if none exists.
-     *
-     * @param name name of the field
-     * @return field with given name
-     */
-    public Optional<Field> getField(String name) {
-        return Optional.ofNullable(fields.get(name));
-    }
-
-    /**
-     * Returns an unmodifiable map of the fields in this deconstructed object, mapped
-     * by their names.
-     *
-     * @return map of fields
-     */
-    public @Unmodifiable Map<String, Field> asMap() {
-        return fields;
+    DeconstructedObject(List<Field> fields) {
+        this.fields = Collections.unmodifiableList(fields);
     }
 
     /**
@@ -100,7 +82,7 @@ public Optional<Field> getField(String name) {
      * @return list of fields
      */
     public @Unmodifiable List<Field> asList() {
-        return List.copyOf(fields.values());
+        return fields;
     }
 
     /**
@@ -111,8 +93,8 @@ public int size() {
     }
 
     @Override
-    public @NotNull Iterator<Field> iterator() {
-        return fields.values().iterator();
+    public @NotNull ListIterator<Field> iterator() {
+        return fields.listIterator();
     }
 
     @Override
@@ -147,6 +129,13 @@ public sealed interface Field {
          */
         AnnotatedType annotatedType();
 
+        /**
+         * @return whether this field is primitive
+         */
+        default boolean primitive() {
+            return type().isPrimitive();
+        }
+
     }
 
     /**
@@ -235,6 +224,7 @@ public Class<?> type() {
     public record ObjectField(String name, Class<?> type, AnnotatedType annotatedType, Object value) implements Field {
     }
 
+    // TODO this should possibly be in a different class
     private static <T> DataHandler<T, DeconstructedObject> createDeconstructor(ClassModel classModel,
                                                                                ObjectFactory<T> objectFactory) {
         FieldsExtractor fieldsExtractor = FieldsExtractor.of(classModel);
@@ -245,6 +235,7 @@ private static <T> DataHandler<T, DeconstructedObject> createDeconstructor(Class
         };
     }
 
+    // TODO this should possibly be in a different class
     private static <T> DataHandler<DeconstructedObject, T> createConstructor(ClassModel classModel,
                                                                              ObjectFactory<T> objectFactory) {
         FieldsInjector fieldsInjector = FieldsInjector.of(classModel);

foundry-core/src/main/java/org/machinemc/foundry/model/FieldsExtractor.java

@@ -1,11 +1,10 @@
 package org.machinemc.foundry.model;
 
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.Maps;
 import org.jetbrains.annotations.ApiStatus;
 
 import java.lang.reflect.AnnotatedType;
-import java.util.Map;
+import java.util.ArrayList;
+import java.util.List;
 import java.util.function.Function;
 
 /**
@@ -70,16 +69,14 @@ static FieldsExtractor of(ClassModel model) {
      * Reads fields from a container.
      *
      * @param dataContainer container to read
-     * @return map of fields
+     * @return list of fields
      */
-    Map<String, DeconstructedObject.Field> read(ModelDataContainer dataContainer) {
-        //noinspection unchecked
-        Map.Entry<String, DeconstructedObject.Field>[] fields = new Map.Entry[fieldReaders.length];
-        for (int i = 0; i < fieldReaders.length; i++) {
-            var field = fieldReaders[i].apply(dataContainer);
-            fields[i] = Maps.immutableEntry(field.name(), field);
+    List<DeconstructedObject.Field> read(ModelDataContainer dataContainer) {
+        List<DeconstructedObject.Field> fields = new ArrayList<>(fieldReaders.length);
+        for (var reader : fieldReaders) {
+            fields.add(reader.apply(dataContainer));
         }
-        return ImmutableMap.ofEntries(fields);
+        return fields;
     }
 
 }

foundry-core/src/test/java/org/machinemc/foundry/model/DeconstructedObjectTest.java

@@ -45,17 +45,17 @@ void testDirectFields() throws Exception {
         assertEquals(3, deconstructed.size());
 
         DeconstructedObject.ObjectField textField = (DeconstructedObject.ObjectField)
-                deconstructed.getField("text").orElseThrow();
+                getField(deconstructed, "text").orElseThrow();
         assertNotNull(textField);
         assertEquals("Direct Access", textField.value());
 
         DeconstructedObject.IntField numField = (DeconstructedObject.IntField)
-                deconstructed.getField("number").orElseThrow();
+                getField(deconstructed, "number").orElseThrow();
         assertNotNull(numField);
         assertEquals(42, numField.value());
 
         DeconstructedObject.DoubleField decField = (DeconstructedObject.DoubleField)
-                deconstructed.getField("decimal").orElseThrow();
+                getField(deconstructed, "decimal").orElseThrow();
         assertNotNull(decField);
         assertEquals(3.14, decField.value());
 
@@ -119,7 +119,7 @@ void testAccessors() throws Exception {
         assertEquals(2, original.getCalls, "Should have called getters during deconstruction");
 
         DeconstructedObject.BoolField activeField = (DeconstructedObject.BoolField)
-                deconstructed.getField("active").orElseThrow();
+                getField(deconstructed, "active").orElseThrow();
         assertNotNull(activeField);
         assertTrue(activeField.value());
 
@@ -143,9 +143,9 @@ void testRecord() throws Exception {
 
         DeconstructedObject deconstructed = deconstructor.transform(original);
 
-        assertInstanceOf(DeconstructedObject.IntField.class, deconstructed.getField("value").orElseThrow());
-        assertInstanceOf(DeconstructedObject.FloatField.class, deconstructed.getField("factor").orElseThrow());
-        assertInstanceOf(DeconstructedObject.ObjectField.class, deconstructed.getField("key").orElseThrow());
+        assertInstanceOf(DeconstructedObject.IntField.class, getField(deconstructed, "value").orElseThrow());
+        assertInstanceOf(DeconstructedObject.FloatField.class, getField(deconstructed, "factor").orElseThrow());
+        assertInstanceOf(DeconstructedObject.ObjectField.class, getField(deconstructed, "key").orElseThrow());
 
         SimpleRecord copy = constructor.transform(deconstructed);
 
@@ -181,7 +181,7 @@ void testFieldAccessAnnotation() throws Exception {
         DeconstructedObject deconstructed = deconstructor.transform(original);
 
         DeconstructedObject.IntField fooField = (DeconstructedObject.IntField)
-                deconstructed.getField("foo").orElseThrow();
+                getField(deconstructed, "foo").orElseThrow();
         assertNotNull(fooField);
         assertEquals(99, fooField.value());
         assertTrue(original.calledGet, "Custom getter should be called");
@@ -200,11 +200,14 @@ void testManualModification() throws Exception {
         SimpleRecord original = new SimpleRecord("Original", 1, 1.0f);
         DeconstructedObject deconstructed = deconstructor.transform(original);
 
-        Map<String, DeconstructedObject.Field> map = new LinkedHashMap<>(deconstructed.asMap());
-        DeconstructedObject.Field toReplace = map.get("value");
-        map.replace("value", new DeconstructedObject.IntField("value", toReplace.annotatedType(), 999));
+        var modifiedFields = deconstructed.asList().stream().map(f -> {
+            if (f.name().equals("value"))
+                return new DeconstructedObject.IntField("value", f.annotatedType(), 999);
+            else
+                return f;
+        }).toList();
 
-        DeconstructedObject modified = new DeconstructedObject(map);
+        DeconstructedObject modified = new DeconstructedObject(modifiedFields);
 
         SimpleRecord copy = constructor.transform(modified);
 
@@ -227,4 +230,12 @@ void testMultipleConstructions() throws Exception {
         }
     }
 
+    Optional<DeconstructedObject.Field> getField(DeconstructedObject obj, String name) {
+        for (var field : obj) {
+            if (field.name().equals(name))
+                return Optional.of(field);
+        }
+        return Optional.empty();
+    }
+
 }