Better optional/defaulted behavior and fix transitive-annotated beans

Author: lukebemish

src/groovy/java/dev/lukebemish/codecextras/groovy/structured/reflective/implementation/GroovyReflectiveStructureCreator.java

@@ -21,6 +21,7 @@
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 import org.codehaus.groovy.reflection.CachedField;
@@ -105,15 +106,18 @@ public Function<CreationContext, List<Discoverer>> make() {
                     @Override
                     public void modifyProperties(Class<?> clazz, Map<String, java.lang.reflect.Type> known) {
                         var metaClass = DefaultGroovyMethods.getMetaClass(clazz);
-                        if (known.get("metaClass").equals(MetaClass.class)) {
+                        if (Objects.equals(known.get("metaClass"), MetaClass.class)) {
                             known.remove("metaClass");
                         }
                         metaClass.getProperties().forEach(metaProperty -> {
+                            if ((metaProperty.getModifiers() & Modifier.TRANSIENT) != 0) {
+                                return;
+                            }
                             var name = metaProperty.getName();
                             var type = metaProperty.getType();
                             var modifiers = metaProperty.getModifiers();
                             // We can only handle bean properties, due to needing to introspect them
-                            if ((modifiers & Modifier.PUBLIC) != 0 && metaProperty instanceof MetaBeanProperty) {
+                            if ((modifiers & Modifier.PUBLIC) != 0 && metaProperty instanceof MetaBeanProperty metaBeanProperty) {
                                 if (!known.containsKey(name)) {
                                     known.put(name, type);
                                 }
@@ -162,13 +166,14 @@ public int priority() {
                     @Override
                     public List<AnnotatedElement> context(Class<?> clazz, String property) {
                         var metaProperty = DefaultGroovyMethods.getMetaClass(clazz).getMetaProperty(property);
+                        var list = new ArrayList<AnnotatedElement>();
                         if (metaProperty instanceof MetaBeanProperty beanProperty) {
                             if (beanProperty.getField() instanceof CachedField field) {
-                                return List.of(field.getCachedField());
+                                list.add(field.getCachedField());
                             }
                         }
-                        // Unfortunately can't do too much with this
-                        return List.of();
+                        // And that's about all we can do...
+                        return list;
                     }
                 });
             }

src/main/java/dev/lukebemish/codecextras/structured/CodecInterpreter.java

@@ -88,7 +88,7 @@ public <A> DataResult<App<Holder.Mu, List<A>>> list(App<Holder.Mu, A> single) {
     }
 
     @Override
-    public <A> DataResult<App<Holder.Mu, A>> record(List<RecordStructure.Field<A, ?>> fields, Function<RecordStructure.Container, A> creator) {
+    public <A> DataResult<App<Holder.Mu, A>> record(List<RecordStructure.Field<A, ?>> fields, Function<RecordStructure.Container, DataResult<A>> creator) {
         return StructuredMapCodec.of(fields, creator, this, CodecInterpreter::unbox)
             .map(mapCodec -> new Holder<>(mapCodec.codec()));
     }

src/main/java/dev/lukebemish/codecextras/structured/IdentityInterpreter.java

@@ -60,13 +60,13 @@ public <A> DataResult<App<Identity.Mu, A>> keyed(Key<A> key) {
     }
 
     @Override
-    public <A> DataResult<App<Identity.Mu, A>> record(List<RecordStructure.Field<A, ?>> fields, Function<RecordStructure.Container, A> creator) {
+    public <A> DataResult<App<Identity.Mu, A>> record(List<RecordStructure.Field<A, ?>> fields, Function<RecordStructure.Container, DataResult<A>> creator) {
         var builder = RecordStructure.Container.builder();
         for (var field : fields) {
             DataResult<App<Identity.Mu, A>> result = forField(field, builder);
             if (result != null) return result;
         }
-        return DataResult.success(new Identity<>(creator.apply(builder.build())));
+        return creator.apply(builder.build()).map(Identity::new);
     }
 
     private <A, F> @Nullable DataResult<App<Identity.Mu, A>> forField(RecordStructure.Field<A, F> field, RecordStructure.Container.Builder builder) {

src/main/java/dev/lukebemish/codecextras/structured/Interpreter.java

@@ -37,7 +37,7 @@ public interface Interpreter<Mu extends K1> {
 
     <A> DataResult<App<Mu, A>> keyed(Key<A> key);
 
-    <A> DataResult<App<Mu, A>> record(List<RecordStructure.Field<A, ?>> fields, Function<RecordStructure.Container, A> creator);
+    <A> DataResult<App<Mu, A>> record(List<RecordStructure.Field<A, ?>> fields, Function<RecordStructure.Container, DataResult<A>> creator);
 
     <A, B> DataResult<App<Mu, B>> flatXmap(App<Mu, A> input, Function<A, DataResult<B>> to, Function<B, DataResult<A>> from);
 

src/main/java/dev/lukebemish/codecextras/structured/MapCodecInterpreter.java

@@ -55,7 +55,7 @@ public <A> DataResult<App<Holder.Mu, List<A>>> list(App<Holder.Mu, A> single) {
     }
 
     @Override
-    public <A> DataResult<App<Holder.Mu, A>> record(List<RecordStructure.Field<A, ?>> fields, Function<RecordStructure.Container, A> creator) {
+    public <A> DataResult<App<Holder.Mu, A>> record(List<RecordStructure.Field<A, ?>> fields, Function<RecordStructure.Container, DataResult<A>> creator) {
         return StructuredMapCodec.of(fields, creator, codecInterpreter(), CodecInterpreter::unbox)
             .map(Holder::new);
     }

src/main/java/dev/lukebemish/codecextras/structured/RecordStructure.java

@@ -279,7 +279,7 @@ private <T, F> void partialField(Function<A, T> getter, Field<T, F> field) {
      * @return a new structure
      * @param <A> the type of the data represented
      */
-    static <A> Structure<A> create(RecordStructure.Builder<A> builder) {
+    static <A> Structure<A> create(RecordStructure.FlatBuilder<A> builder) {
         RecordStructure<A> instance = new RecordStructure<>();
         var creator = builder.build(instance);
         return new Structure<>() {
@@ -305,5 +305,21 @@ public interface Builder<A> {
          * @return a function to assemble the final type from a {@link Container}
          */
         Function<Container, A> build(RecordStructure<A> builder);
+
+        default FlatBuilder<A> asFlatBuilder() {
+            return builder -> build(builder).andThen(DataResult::success);
+        }
+    }
+
+    @FunctionalInterface
+    public interface FlatBuilder<A> {
+        /**
+         * Assemble a record structure for the given type. Should collect {@link Key}s for every field needed and return
+         * a function that uses those keys to assemble the final type from a {@link Container}. Unlike a {@link Builder},
+         * allows for failures.
+         * @param builder a blank record structure to add fields to
+         * @return a function to assemble the final type from a {@link Container}
+         */
+        Function<Container, DataResult<A>> build(RecordStructure<A> builder);
     }
 }

src/main/java/dev/lukebemish/codecextras/structured/Structure.java

@@ -626,6 +626,17 @@ default Structure<A> validate(Function<A, DataResult<A>> verifier) {
      * @see RecordStructure
      */
     static <A> Structure<A> record(RecordStructure.Builder<A> builder) {
+        return RecordStructure.create(builder.asFlatBuilder());
+    }
+
+    /**
+     * {@return a structure representing a collection of key-value pairs with defined structures, which may be optionally present, and which can handle failures}
+     * @param builder the builder to use to create the record structure
+     * @param <A> the type of data the structure represents
+     * @see RecordStructure
+     * @see #record(RecordStructure.Builder)
+     */
+    static <A> Structure<A> flatRecord(RecordStructure.FlatBuilder<A> builder) {
         return RecordStructure.create(builder);
     }
 

src/main/java/dev/lukebemish/codecextras/structured/StructuredMapCodec.java

@@ -22,9 +22,9 @@ class StructuredMapCodec<A> extends MapCodec<A> {
     private record Field<A, T>(String name, MapCodec<T> codec, RecordStructure.Key<T> key, Function<A, T> getter) {}
 
     private final List<Field<A, ?>> fields;
-    private final Function<RecordStructure.Container, A> creator;
+    private final Function<RecordStructure.Container, DataResult<A>> creator;
 
-    private StructuredMapCodec(List<Field<A, ?>> fields, Function<RecordStructure.Container, A> creator) {
+    private StructuredMapCodec(List<Field<A, ?>> fields, Function<RecordStructure.Container, DataResult<A>> creator) {
         this.fields = fields;
         this.creator = creator;
     }
@@ -33,7 +33,7 @@ public interface Unboxer<Mu extends K1> {
         <A> Codec<A> unbox(App<Mu, A> box);
     }
 
-    public static <A, Mu extends K1> DataResult<MapCodec<A>> of(List<RecordStructure.Field<A, ?>> fields, Function<RecordStructure.Container, A> creator, Interpreter<Mu> interpreter, Unboxer<Mu> unboxer) {
+    public static <A, Mu extends K1> DataResult<MapCodec<A>> of(List<RecordStructure.Field<A, ?>> fields, Function<RecordStructure.Container, DataResult<A>> creator, Interpreter<Mu> interpreter, Unboxer<Mu> unboxer) {
         var mapCodecFields = new ArrayList<Field<A, ?>>();
         for (var field : fields) {
             DataResult<MapCodec<A>> result = recordSingleField(field, mapCodecFields, interpreter, unboxer);
@@ -93,12 +93,16 @@ public <T> DataResult<A> decode(DynamicOps<T> ops, MapLike<T> input) {
         }
         if (isError) {
             if (isPartial) {
-                return DataResult.error(errorMessage, creator.apply(builder.build()), errorLifecycle);
+                var result = creator.apply(builder.build());
+                if (result.isError()) {
+                    return DataResult.error(errorMessage, errorLifecycle);
+                }
+                return DataResult.error(errorMessage, result.result().orElseThrow(), errorLifecycle);
             } else {
                 return DataResult.error(errorMessage, errorLifecycle);
             }
         } else {
-            return DataResult.success(creator.apply(builder.build()));
+            return creator.apply(builder.build());
         }
     }
 

src/main/java/dev/lukebemish/codecextras/structured/reflective/annotations/Annotated.java

@@ -9,14 +9,5 @@
 @Retention(RetentionPolicy.RUNTIME)
 public @interface Annotated {
     Value key();
-    Value[] value() default {};
-    String[] stringValue() default {};
-    int[] intValue() default {};
-    long[] longValue() default {};
-    double[] doubleValue() default {};
-    float[] floatValue() default {};
-    boolean[] booleanValue() default {};
-    byte[] byteValue() default {};
-    short[] shortValue() default {};
-    char[] charValue() default {};
+    Value value();
 }

src/main/java/dev/lukebemish/codecextras/structured/reflective/annotations/Default.java

@@ -0,0 +1,12 @@
+package dev.lukebemish.codecextras.structured.reflective.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.METHOD, ElementType.RECORD_COMPONENT, ElementType.FIELD})
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Default {
+    Value value();
+}