Simplify the definition of external domain classes (#1291)

Author: nakamura-to

doma-core/src/main/java/org/seasar/doma/ExternalDomain.java

@@ -38,6 +38,9 @@
  *     }
  *
  *     public Salary fromValueToDomain(BigDecimal value) {
+ *         if (value == null) {
+ *             return null;
+ *         }
  *         return new Salary(value);
  *     }
  * }
@@ -46,7 +49,6 @@
  * <p>The annotated instance is required to be thread safe.
  *
  * @see DomainConverter
- * @see DomainConverters
  */
 @Target(ElementType.TYPE)
 @Retention(RetentionPolicy.RUNTIME)

doma-core/src/main/java/org/seasar/doma/jdbc/domain/DomainConverter.java

@@ -15,14 +15,12 @@
  */
 package org.seasar.doma.jdbc.domain;
 
-import org.seasar.doma.DomainConverters;
 import org.seasar.doma.ExternalDomain;
 
 /**
- * A converter between domain objects and basic values.
+ * A converter interface for mapping between domain objects and their corresponding basic values.
  *
- * <p>The implementation class should be annotated with {@link ExternalDomain} and be registered to
- * {@link DomainConverters}.
+ * <p>The implementation class should be annotated with {@link ExternalDomain}.
  *
  * <pre>
  * &#064;ExternalDomain
@@ -33,31 +31,33 @@
  *     }
  *
  *     public Salary fromValueToDomain(BigDecimal value) {
+ *         if (value == null) {
+ *             return null;
+ *         }
  *         return new Salary(value);
  *     }
  * }
  * </pre>
  *
  * @see ExternalDomain
- * @see DomainConverters
- * @param <DOMAIN> the domain type
- * @param <BASIC> the basic type
+ * @param <DOMAIN> the type of the domain object
+ * @param <BASIC> the type of the basic value
  */
 public interface DomainConverter<DOMAIN, BASIC> {
 
   /**
-   * Converts from a domain object to a basic value.
+   * Converts a domain object into a basic value.
    *
-   * @param domain the domain object
-   * @return the basic value
+   * @param domain the domain object; must not be null
+   * @return the basic value; can be null
    */
   BASIC fromDomainToValue(DOMAIN domain);
 
   /**
-   * Converts from a basic value to a domain object.
+   * Converts a basic value into a domain object.
    *
-   * @param value the basic value
-   * @return the domain object
+   * @param value the basic value; can be null
+   * @return the domain object; can be null
    */
   DOMAIN fromValueToDomain(BASIC value);
 }

doma-core/src/main/java/org/seasar/doma/message/Message.java

@@ -479,9 +479,7 @@ public enum Message implements MessageResource {
   DOMA4093("The field annotated with @Version must be numeric."),
   DOMA4095("The field annotated with @GeneratedValue must be numeric."),
   DOMA4096(
-      "The class \"{0}\" is not supported as a persistent type. "
-          + "If you intend to map the class to the external domain class with @ExternalDomain, the configuration may be not enough. "
-          + "Check the class annotated with @DomainConverters and the annotation processing option \"doma.domain.converters\"."),
+      "The class \"{0}\" is not supported as a persistent type. By using @ExternalDomain, you can make that type persistent."),
   DOMA4097("The return type must be {0}."),
   DOMA4098("The type of the parameter annotated with @Out must be org.seasar.doma.jdbc.Reference."),
   DOMA4100("{0} is illegal as the type argument of Reference."),
@@ -852,10 +850,7 @@ public enum Message implements MessageResource {
   DOMA4297(
       "The embeddable class \"{0}\" cannot be used as a persistent property in the embeddable class."),
   DOMA4298(
-      "The class \"{0}\" is not supported as a persistent type. "
-          + "If you intend to map the class to the external domain class with @ExternalDomain, "
-          + "the configuration may be not enough. "
-          + "Check the class annotated with @DomainConverters and the annotation processing option \"doma.domain.converters\"."),
+      "The class \"{0}\" is not supported as a persistent type. By using @ExternalDomain, you can make that type persistent."),
   DOMA4299("The raw type of the class \"{0}\" cannot be used as a persistent property."),
   DOMA4301(
       "The type argument of the class \"{0}\" that is a wildcard or type variable cannot be used as a persistent property."),
@@ -957,7 +952,7 @@ public enum Message implements MessageResource {
       "If a method annotated with @MultiInsert targets immutable entities for insertion, the return type must be org.seasar.doma.jdbc.MultiResult."
           + "The type argument of org.seasar.doma.jdbc.MultiResult must be the immutable entity class."),
   DOMA4462("The property \"{0}\" is not found in the entity class \"{1}\"."),
-  DOMA4463("'{'\"execTimeMillis\": {0}, \"processor\": \"{1}\", \"element\": \"{2}\"'}'"),
+  DOMA4463("'{'\"execTimeMillis\": {0}, \"annotation\": \"{1}\", \"element\": \"{2}\"'}'"),
   DOMA4464("Fields annotated with AssociationLinker must be static."),
   DOMA4465("Fields annotated with AssociationLinker must be java.util.function.BiFunction."),
   DOMA4466("The {0} type parameter of BiFunction must be an entity class."),
@@ -1006,6 +1001,8 @@ public enum Message implements MessageResource {
   DOMA4488(
       "To specify propertyPath=\"{0}\", a separate definition of @AssociationLinker(propertyPath=\"{1}\") is required."),
   DOMA4489("The property path \"{0}\" is duplicated in another @AssociationLinker."),
+  DOMA4490(
+      "Multiple @ExternalDomain definitions were found for type \"{0}\". \"{1}\" conflicts with \"{2}\"."),
 
   // other
   DOMA5001(

doma-processor/src/main/java/module-info.java

@@ -18,12 +18,5 @@
   requires org.seasar.doma.core;
 
   provides javax.annotation.processing.Processor with
-      org.seasar.doma.internal.apt.processor.DomainProcessor,
-      org.seasar.doma.internal.apt.processor.DataTypeProcessor,
-      org.seasar.doma.internal.apt.processor.ExternalDomainProcessor,
-      org.seasar.doma.internal.apt.processor.DomainConvertersProcessor,
-      org.seasar.doma.internal.apt.processor.EmbeddableProcessor,
-      org.seasar.doma.internal.apt.processor.EntityProcessor,
-      org.seasar.doma.internal.apt.processor.DaoProcessor,
-      org.seasar.doma.internal.apt.processor.ScopeProcessor;
+      org.seasar.doma.internal.apt.DomaProcessor;
 }

doma-processor/src/main/java/org/seasar/doma/internal/apt/AnnotationTypes.java

@@ -0,0 +1,28 @@
+/*
+ * Copyright Doma Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.seasar.doma.internal.apt;
+
+public final class AnnotationTypes {
+  public static final String AGGREGATE_STRATEGY = "org.seasar.doma.AggregateStrategy";
+  public static final String DAO = "org.seasar.doma.Dao";
+  public static final String DATA_TYPE = "org.seasar.doma.DataType";
+  public static final String DOMAIN_CONVERTERS = "org.seasar.doma.DomainConverters";
+  public static final String DOMAIN = "org.seasar.doma.Domain";
+  public static final String EMBEDDABLE = "org.seasar.doma.Embeddable";
+  public static final String ENTITY = "org.seasar.doma.Entity";
+  public static final String EXTERNAL_DOMAIN = "org.seasar.doma.ExternalDomain";
+  public static final String SCOPE = "org.seasar.doma.Scope";
+}

doma-processor/src/main/java/org/seasar/doma/internal/apt/DomaProcessor.java

@@ -0,0 +1,185 @@
+/*
+ * Copyright Doma Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.seasar.doma.internal.apt;
+
+import static org.seasar.doma.internal.apt.AnnotationTypes.AGGREGATE_STRATEGY;
+import static org.seasar.doma.internal.apt.AnnotationTypes.DAO;
+import static org.seasar.doma.internal.apt.AnnotationTypes.DATA_TYPE;
+import static org.seasar.doma.internal.apt.AnnotationTypes.DOMAIN;
+import static org.seasar.doma.internal.apt.AnnotationTypes.DOMAIN_CONVERTERS;
+import static org.seasar.doma.internal.apt.AnnotationTypes.EMBEDDABLE;
+import static org.seasar.doma.internal.apt.AnnotationTypes.ENTITY;
+import static org.seasar.doma.internal.apt.AnnotationTypes.EXTERNAL_DOMAIN;
+import static org.seasar.doma.internal.apt.AnnotationTypes.SCOPE;
+
+import java.util.List;
+import java.util.Objects;
+import java.util.Set;
+import java.util.function.BiConsumer;
+import javax.annotation.processing.AbstractProcessor;
+import javax.annotation.processing.ProcessingEnvironment;
+import javax.annotation.processing.RoundEnvironment;
+import javax.annotation.processing.SupportedAnnotationTypes;
+import javax.annotation.processing.SupportedOptions;
+import javax.lang.model.SourceVersion;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.TypeElement;
+import org.seasar.doma.internal.apt.processor.AggregateStrategyProcessor;
+import org.seasar.doma.internal.apt.processor.DaoProcessor;
+import org.seasar.doma.internal.apt.processor.DataTypeProcessor;
+import org.seasar.doma.internal.apt.processor.DomainConvertersProcessor;
+import org.seasar.doma.internal.apt.processor.DomainProcessor;
+import org.seasar.doma.internal.apt.processor.EmbeddableProcessor;
+import org.seasar.doma.internal.apt.processor.EntityProcessor;
+import org.seasar.doma.internal.apt.processor.ExternalDomainProcessor;
+import org.seasar.doma.internal.apt.processor.ScopeProcessor;
+
+@SupportedAnnotationTypes({
+  AGGREGATE_STRATEGY,
+  DAO,
+  DATA_TYPE,
+  DOMAIN_CONVERTERS,
+  DOMAIN,
+  EMBEDDABLE,
+  ENTITY,
+  EXTERNAL_DOMAIN,
+  SCOPE,
+})
+@SupportedOptions({
+  Options.CONFIG_PATH,
+  Options.DAO_PACKAGE,
+  Options.DAO_SUBPACKAGE,
+  Options.DAO_SUFFIX,
+  Options.DEBUG,
+  Options.DOMAIN_CONVERTERS,
+  Options.ENTITY_FIELD_PREFIX,
+  Options.EXPR_FUNCTIONS,
+  Options.LOMBOK_ALL_ARGS_CONSTRUCTOR,
+  Options.LOMBOK_VALUE,
+  Options.METAMODEL_ENABLED,
+  Options.METAMODEL_PREFIX,
+  Options.METAMODEL_SUFFIX,
+  Options.RESOURCES_DIR,
+  Options.SQL_VALIDATION,
+  Options.TEST,
+  Options.TRACE,
+  Options.VERSION_VALIDATION,
+})
+public class DomaProcessor extends AbstractProcessor {
+
+  private final List<Operator> operators;
+  private ProcessingContext processingContext;
+
+  public DomaProcessor() {
+    operators =
+        List.of(
+            new Operator(EXTERNAL_DOMAIN, DomaProcessor::processExternalDomain),
+            new Operator(DATA_TYPE, DomaProcessor::processDataType),
+            new Operator(DOMAIN, DomaProcessor::processDomain),
+            new Operator(DOMAIN_CONVERTERS, DomaProcessor::processDomainConverters),
+            new Operator(EMBEDDABLE, DomaProcessor::processEmbeddable),
+            new Operator(ENTITY, DomaProcessor::processEntity),
+            new Operator(AGGREGATE_STRATEGY, DomaProcessor::processAggregateStrategy),
+            new Operator(DAO, DomaProcessor::processDao),
+            new Operator(SCOPE, DomaProcessor::processScope));
+  }
+
+  @Override
+  public synchronized void init(ProcessingEnvironment processingEnv) {
+    super.init(processingEnv);
+    processingContext = new ProcessingContext(processingEnv);
+    processingContext.init();
+  }
+
+  @Override
+  public SourceVersion getSupportedSourceVersion() {
+    return SourceVersion.latest();
+  }
+
+  @Override
+  public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
+    if (roundEnv.processingOver()) {
+      return true;
+    }
+
+    var roundContext = new RoundContext(processingContext, roundEnv, annotations);
+
+    for (var operator : operators) {
+      var elements = roundContext.getElementsAnnotatedWith(operator.name);
+      if (!elements.isEmpty()) {
+        operator.consumer.accept(roundContext, elements);
+      }
+    }
+
+    return true;
+  }
+
+  private static void processAggregateStrategy(
+      RoundContext roundContext, Set<? extends Element> elements) {
+    var processor = new AggregateStrategyProcessor(roundContext);
+    processor.process(elements);
+  }
+
+  private static void processDao(RoundContext roundContext, Set<? extends Element> elements) {
+    var processor = new DaoProcessor(roundContext);
+    processor.process(elements);
+  }
+
+  private static void processDataType(RoundContext roundContext, Set<? extends Element> elements) {
+    var processor = new DataTypeProcessor(roundContext);
+    processor.process(elements);
+  }
+
+  private static void processDomainConverters(
+      RoundContext roundContext, Set<? extends Element> elements) {
+    var processor = new DomainConvertersProcessor(roundContext);
+    processor.process(elements);
+  }
+
+  private static void processDomain(RoundContext roundContext, Set<? extends Element> elements) {
+    var processor = new DomainProcessor(roundContext);
+    processor.process(elements);
+  }
+
+  private static void processEmbeddable(
+      RoundContext roundContext, Set<? extends Element> elements) {
+    var processor = new EmbeddableProcessor(roundContext);
+    processor.process(elements);
+  }
+
+  private static void processEntity(RoundContext roundContext, Set<? extends Element> elements) {
+    var processor = new EntityProcessor(roundContext);
+    processor.process(elements);
+  }
+
+  private static void processExternalDomain(
+      RoundContext roundContext, Set<? extends Element> elements) {
+    var processor = new ExternalDomainProcessor(roundContext);
+    processor.process(elements);
+  }
+
+  private static void processScope(RoundContext roundContext, Set<? extends Element> elements) {
+    var processor = new ScopeProcessor(roundContext);
+    processor.process(elements);
+  }
+
+  private record Operator(String name, BiConsumer<RoundContext, Set<? extends Element>> consumer) {
+    Operator {
+      Objects.requireNonNull(name);
+      Objects.requireNonNull(consumer);
+    }
+  }
+}

doma-processor/src/main/java/org/seasar/doma/internal/apt/MoreElements.java

@@ -54,13 +54,13 @@
 
 public class MoreElements implements Elements {
 
-  private final Context ctx;
+  private final ProcessingContext ctx;
 
   private final Elements elementUtils;
 
   private final Map<String, TypeElement> typeElementCache = new HashMap<>(64);
 
-  public MoreElements(Context ctx, Elements elementUtils) {
+  public MoreElements(ProcessingContext ctx, Elements elementUtils) {
     assertNotNull(ctx, elementUtils);
     this.ctx = ctx;
     this.elementUtils = elementUtils;

doma-processor/src/main/java/org/seasar/doma/internal/apt/MoreTypes.java

@@ -43,11 +43,11 @@
 
 public class MoreTypes implements Types {
 
-  private final Context ctx;
+  private final ProcessingContext ctx;
 
   private final Types typeUtils;
 
-  public MoreTypes(Context ctx, Types typeUtils) {
+  public MoreTypes(ProcessingContext ctx, Types typeUtils) {
     assertNotNull(ctx, typeUtils);
     this.ctx = ctx;
     this.typeUtils = typeUtils;

doma-processor/src/main/java/org/seasar/doma/internal/apt/Names.java

@@ -25,9 +25,9 @@
 
 public class Names {
 
-  private final Context ctx;
+  private final RoundContext ctx;
 
-  Names(Context ctx) {
+  Names(RoundContext ctx) {
     assertNotNull(ctx);
     this.ctx = ctx;
   }