add something like mixin

Author: SentryMan

jsonb-generator/src/main/java/io/avaje/jsonb/generator/BeanReader.java

@@ -42,7 +42,27 @@ class BeanReader {
     this.constructor = typeReader.constructor();
   }
 
-  @Override
+  public BeanReader(
+      TypeElement beanType,
+      Map<String,  Element> mixInFields,
+      ProcessingContext context) {
+
+	    this.beanType = beanType;
+	    this.type = beanType.getQualifiedName().toString();
+	    this.shortName = shortName(beanType);
+	    final NamingConventionReader ncReader = new NamingConventionReader(beanType);
+	    this.namingConvention = ncReader.get();
+	    this.typeProperty = ncReader.typeProperty();
+	    this.typeReader = new TypeReader(beanType, mixInFields, context, namingConvention);
+	    typeReader.process();
+	    this.nonAccessibleField = typeReader.nonAccessibleField();
+	    this.hasSubTypes = typeReader.hasSubTypes();
+	    this.allFields = typeReader.allFields();
+	    this.constructor = typeReader.constructor();
+
+  }
+
+@Override
   public String toString() {
     return beanType.toString();
   }

jsonb-generator/src/main/java/io/avaje/jsonb/generator/ImportReader.java

@@ -11,6 +11,7 @@
 class ImportReader {
 
   private static final String JSON_IMPORT = "io.avaje.jsonb.Json.Import";
+  private static final String JSON_MIXIN = "io.avaje.jsonb.Json.MixIn";
 
   /**
    * Read the Json.Import annotation using annotation mirrors.
@@ -31,4 +32,15 @@ List<String> read(Element element) {
     return fullNames;
   }
 
+  String readMixin(Element element) {
+    for (final AnnotationMirror mirror : element.getAnnotationMirrors()) {
+      if (JSON_MIXIN.equals(mirror.getAnnotationType().toString())) {
+        for (final Map.Entry<? extends ExecutableElement, ? extends AnnotationValue> entry :
+            mirror.getElementValues().entrySet()) {
+          return Util.trimClassSuffix(entry.getValue().toString());
+        }
+      }
+    }
+    return null;
+  }
 }

jsonb-generator/src/main/java/io/avaje/jsonb/generator/Processor.java

@@ -43,6 +43,7 @@ public Set<String> getSupportedAnnotationTypes() {
     Set<String> annotations = new LinkedHashSet<>();
     annotations.add(Json.class.getCanonicalName());
     annotations.add(Json.Import.class.getCanonicalName());
+    annotations.add(Json.MixIn.class.getCanonicalName());
     return annotations;
   }
 
@@ -111,12 +112,24 @@ private boolean ignoreType(String type) {
   /**
    * Elements that have a {@code @Json.Import} annotation.
    */
-  private void writeAdaptersForImported(Set<? extends Element> importedElements) {
-    for (Element importedElement : importedElements) {
-      for (String importType : importReader.read(importedElement)) {
-        TypeElement element = context.element(importType);
+  private void writeAdaptersForImported(
+      Set<? extends Element> importedElements, Set<? extends Element> mixed) {
+    final Map<String, TypeElement> mixinMap = new HashMap<>();
+    for (final Element mixin : mixed) {
+      final String importType = importReader.readMixin(mixin);
+      if (importType != null) {
+        mixinMap.put(importType, context.element(mixin.asType().toString()));
+      }
+    }
+
+    for (final Element importedElement : importedElements) {
+      for (final String importType : importReader.read(importedElement)) {
+        final TypeElement element = context.element(importType);
+
         if (element == null) {
           context.logError("Unable to find imported element " + importType);
+        } else if (mixinMap.containsKey(importType)) {
+          writeAdapterForMixInType(element, mixinMap.get(importType));
         } else {
           writeAdapterForType(element);
         }
@@ -158,7 +171,20 @@ private void writeAdapters(Set<? extends Element> beans) {
   }
 
   private void writeAdapterForType(TypeElement typeElement) {
-    BeanReader beanReader = new BeanReader(typeElement, context);
+    final BeanReader beanReader = new BeanReader(typeElement, context);
+    writeAdapter(typeElement, beanReader);
+  }
+
+  private void writeAdapterForMixInType(TypeElement typeElement, TypeElement mixin) {
+    final Map<String, Element> mixInFields =
+        mixin.getEnclosedElements().stream()
+            .filter(e -> e.getKind() == ElementKind.FIELD)
+            .collect(Collectors.toMap(e -> e.getSimpleName().toString(), e -> e));
+    final BeanReader beanReader = new BeanReader(typeElement, mixInFields, context);
+    writeAdapter(typeElement, beanReader);
+  }
+
+  private void writeAdapter(TypeElement typeElement, BeanReader beanReader) {
     beanReader.read();
     if (beanReader.nonAccessibleField()) {
       if (beanReader.hasJsonAnnotation()) {
@@ -176,5 +202,4 @@ private void writeAdapterForType(TypeElement typeElement) {
       context.logError("Error writing JsonAdapter for %s %s", beanReader, e);
     }
   }
-
 }

jsonb-generator/src/main/java/io/avaje/jsonb/generator/TypeReader.java

@@ -32,9 +32,26 @@ class TypeReader {
   private TypeSubTypeMeta currentSubType;
   private boolean nonAccessibleField;
 
+private final Map<String, Element> mixInFields;
+
   TypeReader(TypeElement baseType, ProcessingContext context, NamingConvention namingConvention) {
     this.baseType = baseType;
     this.context = context;
+    this.mixInFields = new HashMap<>();
+    this.namingConvention = namingConvention;
+    this.hasJsonAnnotation = baseType.getAnnotation(Json.class) != null;
+    this.subTypes = new TypeSubTypeReader(baseType, context);
+  }
+
+  public TypeReader(
+      TypeElement baseType,
+      Map<String, Element> mixInFields,
+      ProcessingContext context,
+      NamingConvention namingConvention) {
+
+    this.baseType = baseType;
+    this.mixInFields = mixInFields;
+    this.context = context;
     this.namingConvention = namingConvention;
     this.hasJsonAnnotation = baseType.getAnnotation(Json.class) != null;
     this.subTypes = new TypeSubTypeReader(baseType, context);
@@ -74,7 +91,10 @@ void read(TypeElement type) {
   }
 
   private void readField(Element element, List<FieldReader> localFields) {
-    if (includeField(element)) {
+    if (mixInFields.containsKey(element.getSimpleName().toString())) {
+      element = mixInFields.get(element.getSimpleName().toString());
+    }
+	 if (includeField(element)) {
       localFields.add(new FieldReader(element, namingConvention, currentSubType));
     }
   }

jsonb-generator/src/test/java/io/avaje/jsonb/generator/models/valid/MixinClass.java

@@ -0,0 +1,13 @@
+package io.avaje.jsonb.generator.models.valid;
+
+import io.avaje.jsonb.Json;
+
+@Json.Import(MixinTarget.class)
+@Json.MixIn(MixinTarget.class)
+public abstract class MixinClass {
+
+  @Json.Property("among us")
+  private String st;
+
+  @Json.Ignore private String av;
+}

jsonb-generator/src/test/java/io/avaje/jsonb/generator/models/valid/MixinTarget.java

@@ -0,0 +1,23 @@
+package io.avaje.jsonb.generator.models.valid;
+
+public class MixinTarget {
+
+  private String st;
+  private String av;
+
+  public String getSt() {
+    return st;
+  }
+
+  public void setSt(String st) {
+    this.st = st;
+  }
+
+  public String getAv() {
+    return av;
+  }
+
+  public void setAv(String av) {
+    this.av = av;
+  }
+}

jsonb/src/main/java/io/avaje/jsonb/Json.java

@@ -1,13 +1,13 @@
 package io.avaje.jsonb;
 
+import static java.lang.annotation.RetentionPolicy.CLASS;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
 import java.lang.annotation.ElementType;
 import java.lang.annotation.Repeatable;
 import java.lang.annotation.Retention;
 import java.lang.annotation.Target;
 
-import static java.lang.annotation.RetentionPolicy.CLASS;
-import static java.lang.annotation.RetentionPolicy.RUNTIME;
-
 /**
  * Marks a type for JSON support.
  *
@@ -225,6 +225,14 @@
 
   }
 
+  /** Marks a Class as a MixIn class. */
+  @Retention(CLASS)
+  @Target({ElementType.TYPE})
+  @interface MixIn {
+    /** The concrete type to mix. */
+    Class<?> value();
+  }
+
   /**
    * The naming convention that we can use for a given type.
    */