deconstructed object is now backed by a map instead of a list

Author: Pesekjak

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

@@ -29,7 +29,6 @@ public class ClassModel {
 
     private final ModelAttribute[] attributes;
     private final ConstructionMethod constructionMethod;
-    private final Constructor<?> constructor;
 
     /**
      * Creates a class model for the specified type.
@@ -39,6 +38,10 @@ public class ClassModel {
      * @throws IllegalStateException if the class does not satisfy the requirements
      */
     public static ClassModel of(Class<?> type) {
+        if (type.isEnum() || type.isInterface() || type.isAnnotation() || Modifier.isAbstract(type.getModifiers()))
+            throw new UnsupportedOperationException("Can not automatically resolve class model for '"
+                    + type.getName() + "'");
+
         if (type.isRecord())
             return ofRecord(type);
 
@@ -58,7 +61,7 @@ public static ClassModel of(Class<?> type) {
         Constructor<?> noArgs = noArgsConstructor(type);
         Preconditions.checkState(noArgs != null, "Class '" + type.getName() + "' is missing "
                 + "no arguments constructor");
-        return new ClassModel(attributes, ConstructionMethod.NO_ARGS_CONSTRUCTOR, noArgs);
+        return new ClassModel(attributes, ConstructionMethod.NO_ARGS_CONSTRUCTOR);
     }
 
     private static ClassModel ofRecord(Class<?> type) {
@@ -67,21 +70,12 @@ private static ClassModel ofRecord(Class<?> type) {
                 .toArray(ModelAttribute[]::new);
         Constructor<?> constructor = allArgsConstructor(type, attributes);
         Preconditions.checkNotNull(constructor); // is always present on records
-        return new ClassModel(attributes, ConstructionMethod.ALL_ARGS_CONSTRUCTOR, constructor);
+        return new ClassModel(attributes, ConstructionMethod.ALL_ARGS_CONSTRUCTOR);
     }
 
-    protected ClassModel(ModelAttribute[] attributes, ConstructionMethod constructionMethod,
-                         Constructor<?> constructor) {
+    protected ClassModel(ModelAttribute[] attributes, ConstructionMethod constructionMethod) {
         this.attributes = attributes;
         this.constructionMethod = constructionMethod;
-        this.constructor = constructor;
-    }
-
-    /**
-     * @return the source class of this model
-     */
-    public Class<?> getSource() {
-        return constructor.getDeclaringClass();
     }
 
     /**
@@ -103,13 +97,6 @@ public ConstructionMethod getConstructionMethod() {
         return constructionMethod;
     }
 
-    /**
-     * @return constructor used by this model
-     */
-    public Constructor<?> getConstructor() {
-        return constructor;
-    }
-
     /**
      * Which construction method is used when creating new instance of the class.
      */

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

@@ -2,12 +2,10 @@
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Unmodifiable;
+import org.machinemc.foundry.DataHandler;
 
 import java.lang.reflect.AnnotatedType;
-import java.util.Collections;
-import java.util.Iterator;
-import java.util.List;
-import java.util.function.Function;
+import java.util.*;
 
 /**
  * Represents an object that has been deconstructed.
@@ -16,16 +14,16 @@
 public final class DeconstructedObject implements Iterable<DeconstructedObject.Field> {
 
     /**
-     * Creates a function that deconstructs an instance of the specified type into a
+     * Creates a data handler that deconstructs an instance of the specified type into a
      * {@link DeconstructedObject}.
      * <p>
-     * The returned function is thread-safe and optimized for repeated use.
+     * The returned data handler is thread-safe and optimized for repeated use.
      *
      * @param type type the object to deconstruct
      * @param <T> type of the object
-     * @return a function that converts an instance of {@link T} into a deconstructed object
+     * @return a data handler that converts an instance of {@link T} into a deconstructed object
      */
-    public static <T> Function<T, DeconstructedObject> createDeconstructor(Class<T> type) {
+    public static <T> DataHandler<T, DeconstructedObject> createDeconstructor(Class<T> type) {
         ClassModel classModel = ClassModel.of(type);
         ObjectFactory<T> objectFactory = ObjectFactory.create(type, classModel);
         FieldsExtractor fieldsExtractor = FieldsExtractor.of(classModel);
@@ -37,42 +35,62 @@ public static <T> Function<T, DeconstructedObject> createDeconstructor(Class<T>
     }
 
     /**
-     * Creates a function that reconstructs an instance of the specified type from a
+     * Creates a data handler that reconstructs an instance of the specified type from a
      * {@link DeconstructedObject}.
      * <p>
-     * The returned function expects the input {@link DeconstructedObject} to contain fields
+     * The returned data handler expects the input {@link DeconstructedObject} to contain fields
      * compatible with the target class schema.
      * <p>
-     * The returned function is thread-safe and optimized for repeated use.
+     * The returned data handler is thread-safe and optimized for repeated use.
      *
      * @param type type the object to reconstruct
      * @param <T> type of the object
-     * @return a function that converts deconstructed object into an instance of {@link T}
+     * @return a data handler that converts deconstructed object into an instance of {@link T}
      */
-    public static <T> Function<DeconstructedObject, T> createConstructor(Class<T> type) {
+    public static <T> DataHandler<DeconstructedObject, T> createConstructor(Class<T> type) {
         ClassModel classModel = ClassModel.of(type);
         ObjectFactory<T> objectFactory = ObjectFactory.create(type, classModel);
         FieldsInjector fieldsInjector = FieldsInjector.of(classModel);
         return deconstructed -> {
             ModelDataContainer container = objectFactory.newContainer();
-            fieldsInjector.write(deconstructed.fields, container);
+            fieldsInjector.write(deconstructed.asList(), container);
             return objectFactory.read(container);
         };
     }
 
-    private final List<Field> fields;
+    private final @Unmodifiable Map<String, Field> fields;
 
-    DeconstructedObject(List<Field> fields) {
-        this.fields = 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;
     }
 
     /**
      * Returns an unmodifiable list of the fields in this deconstructed object.
      *
-     * @return the list of fields
+     * @return list of fields
      */
     public @Unmodifiable List<Field> asList() {
-        return Collections.unmodifiableList(fields);
+        return List.copyOf(fields.values());
     }
 
     /**
@@ -84,7 +102,7 @@ public int size() {
 
     @Override
     public @NotNull Iterator<Field> iterator() {
-        return fields.iterator();
+        return fields.values().iterator();
     }
 
     /**
@@ -109,62 +127,89 @@ public sealed interface Field {
 
     }
 
+    /**
+     * Primitive boolean field.
+     */
     public record BoolField(String name, AnnotatedType annotatedType, boolean value) implements Field {
         @Override
         public Class<?> type() {
             return boolean.class;
         }
     }
 
+    /**
+     * Primitive char field.
+     */
     public record CharField(String name, AnnotatedType annotatedType, char value) implements Field {
         @Override
         public Class<?> type() {
             return char.class;
         }
     }
 
+    /**
+     * Primitive byte field.
+     */
     public record ByteField(String name, AnnotatedType annotatedType, byte value) implements Field {
         @Override
         public Class<?> type() {
             return byte.class;
         }
     }
 
+    /**
+     * Primitive short field.
+     */
     public record ShortField(String name, AnnotatedType annotatedType, short value) implements Field {
         @Override
         public Class<?> type() {
             return short.class;
         }
     }
 
+    /**
+     * Primitive int field.
+     */
     public record IntField(String name, AnnotatedType annotatedType, int value) implements Field {
         @Override
         public Class<?> type() {
             return int.class;
         }
     }
 
+    /**
+     * Primitive long field.
+     */
     public record LongField(String name, AnnotatedType annotatedType, long value) implements Field {
         @Override
         public Class<?> type() {
             return long.class;
         }
     }
 
+    /**
+     * Primitive float field.
+     */
     public record FloatField(String name, AnnotatedType annotatedType, float value) implements Field {
         @Override
         public Class<?> type() {
             return float.class;
         }
     }
 
+    /**
+     * Primitive double field.
+     */
     public record DoubleField(String name, AnnotatedType annotatedType, double value) implements Field {
         @Override
         public Class<?> type() {
             return double.class;
         }
     }
 
+    /**
+     * Primitive object field.
+     */
     public record ObjectField(String name, Class<?> type, AnnotatedType annotatedType, Object value) implements Field {
     }
 

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

@@ -1,10 +1,11 @@
 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.ArrayList;
-import java.util.List;
+import java.util.Map;
 import java.util.function.Function;
 
 /**
@@ -69,14 +70,16 @@ static FieldsExtractor of(ClassModel model) {
      * Reads fields from a container.
      *
      * @param dataContainer container to read
-     * @return list of fields
+     * @return map of fields
      */
-    List<DeconstructedObject.Field> read(ModelDataContainer dataContainer) {
-        List<DeconstructedObject.Field> fields = new ArrayList<>(fieldReaders.length);
-        for (var reader : fieldReaders) {
-            fields.add(reader.apply(dataContainer));
+    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);
         }
-        return fields;
+        return ImmutableMap.ofEntries(fields);
     }
 
 }

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

@@ -1,6 +1,5 @@
 package org.machinemc.foundry.model;
 
-import com.google.common.base.Preconditions;
 import org.jetbrains.annotations.ApiStatus;
 import org.objectweb.asm.ClassWriter;
 import org.objectweb.asm.MethodVisitor;
@@ -51,7 +50,6 @@ public static <T> ObjectFactory<T> create(Class<T> type) {
      * @param <T> object type
      */
     public static <T> ObjectFactory<T> create(Class<T> type, ClassModel classModel) {
-        Preconditions.checkState(type.equals(classModel.getSource()), "Unexpected class model");
         //noinspection unchecked
         return (ObjectFactory<T>) CACHE.computeIfAbsent(type, _ -> load(type, classModel));
     }