This is an automated email from the ASF dual-hosted git repository.
davsclaus pushed a commit to branch tc-loader
in repository https://gitbox.apache.org/repos/asf/camel.git
The following commit(s) were added to refs/heads/tc-loader by this push:
new 2af2111 CAMEL-13313: Add support for generating type converter loader
source code to be able to load component type converters in a faster way
2af2111 is described below
commit 2af21110e9027f30ea6be0886c388e3af6eee188
Author: Claus Ibsen <[email protected]>
AuthorDate: Thu Mar 14 13:58:06 2019 +0100
CAMEL-13313: Add support for generating type converter loader source code
to be able to load component type converters in a faster way
---
.../apache/camel/component/bean/BeanConverter.java | 11 +++-
...cessor.java => CoreTypeConverterProcessor.java} | 17 +++--
.../tools/apt/TypeConverterLoaderProcessor.java | 73 +++++++++++++++-------
.../services/javax.annotation.processing.Processor | 2 +-
4 files changed, 73 insertions(+), 30 deletions(-)
diff --git
a/core/camel-core/src/main/java/org/apache/camel/component/bean/BeanConverter.java
b/core/camel-core/src/main/java/org/apache/camel/component/bean/BeanConverter.java
index fc85841..ed96fe9 100644
---
a/core/camel-core/src/main/java/org/apache/camel/component/bean/BeanConverter.java
+++
b/core/camel-core/src/main/java/org/apache/camel/component/bean/BeanConverter.java
@@ -27,13 +27,22 @@ import static org.apache.camel.TypeConverter.MISS_VALUE;
/**
* A set of converter methods for working with beans
*/
-@Converter
+@Converter(loader = true)
public final class BeanConverter {
private BeanConverter() {
// Helper Class
}
+ @Converter
+ public static int toDummy(String s) {
+ return 1;
+ }
+
+ public String hello(String w) {
+ return null;
+ }
+
@FallbackConverter
public static Object convertTo(Class<?> type, Exchange exchange, Object
value, TypeConverterRegistry registry) {
// use a fallback type converter so we can convert the embedded body
if the value is BeanInvocation
diff --git
a/tooling/apt/src/main/java/org/apache/camel/tools/apt/CoreConverterProcessor.java
b/tooling/apt/src/main/java/org/apache/camel/tools/apt/CoreTypeConverterProcessor.java
similarity index 94%
rename from
tooling/apt/src/main/java/org/apache/camel/tools/apt/CoreConverterProcessor.java
rename to
tooling/apt/src/main/java/org/apache/camel/tools/apt/CoreTypeConverterProcessor.java
index dfa0c29..6e8ebb4 100644
---
a/tooling/apt/src/main/java/org/apache/camel/tools/apt/CoreConverterProcessor.java
+++
b/tooling/apt/src/main/java/org/apache/camel/tools/apt/CoreTypeConverterProcessor.java
@@ -38,11 +38,16 @@ import javax.lang.model.type.TypeMirror;
import javax.tools.Diagnostic;
import javax.tools.JavaFileObject;
-@SupportedAnnotationTypes({"org.apache.camel.Converter"})
-public class CoreConverterProcessor extends AbstractCamelAnnotationProcessor {
+@SupportedAnnotationTypes({"org.apache.camel.Converter",
"org.apache.camel.FallbackConverter"})
+public class CoreTypeConverterProcessor extends
AbstractCamelAnnotationProcessor {
@Override
protected void doProcess(Set<? extends TypeElement> annotations,
RoundEnvironment roundEnv) throws Exception {
+
+ // TODO: fallback does not work
+ // TODO: generate so you dont need to pass in CamelContext but
register into a java set/thingy
+ // so you can init this via static initializer block { ... } and then
register on CamelContext later
+
if
(this.processingEnv.getElementUtils().getTypeElement("org.apache.camel.impl.converter.CoreStaticTypeConverterLoader")
!= null) {
return;
}
@@ -105,10 +110,10 @@ public class CoreConverterProcessor extends
AbstractCamelAnnotationProcessor {
writer.append("\n");
writer.append(" public static final
CoreStaticTypeConverterLoader INSTANCE = new
CoreStaticTypeConverterLoader();\n");
writer.append("\n");
- writer.append(" static abstract class SimpleTypeConverter
extends TypeConverterSupport {\n");
+ writer.append(" static abstract class BaseTypeConverter extends
TypeConverterSupport {\n");
writer.append(" private final boolean allowNull;\n");
writer.append("\n");
- writer.append(" public SimpleTypeConverter(boolean
allowNull) {\n");
+ writer.append(" public BaseTypeConverter(boolean allowNull)
{\n");
writer.append(" this.allowNull = allowNull;\n");
writer.append(" }\n");
writer.append("\n");
@@ -130,7 +135,7 @@ public class CoreConverterProcessor extends
AbstractCamelAnnotationProcessor {
writer.append(" protected abstract Object
doConvert(Exchange exchange, Object value) throws Exception;\n");
writer.append(" };\n");
writer.append("\n");
- writer.append(" private DoubleMap<Class<?>, Class<?>,
SimpleTypeConverter> converters = new DoubleMap<>(256);\n");
+ writer.append(" private final DoubleMap<Class<?>, Class<?>,
BaseTypeConverter> converters = new DoubleMap<>(256);\n");
writer.append("\n");
writer.append(" private ").append(c).append("() {\n");
@@ -151,7 +156,7 @@ public class CoreConverterProcessor extends
AbstractCamelAnnotationProcessor {
}
}
writer.append("
converters.put(").append(to.getKey()).append(".class").append(",
").append(toString(from.getKey()))
- .append(".class, new
SimpleTypeConverter(").append(Boolean.toString(allowNull)).append(") {\n");
+ .append(".class, new
BaseTypeConverter(").append(Boolean.toString(allowNull)).append(") {\n");
writer.append(" @Override\n");
writer.append(" public Object
doConvert(Exchange exchange, Object value) throws Exception {\n");
writer.append(" return
").append(toJava(from.getValue(), converterClasses)).append(";\n");
diff --git
a/tooling/apt/src/main/java/org/apache/camel/tools/apt/TypeConverterLoaderProcessor.java
b/tooling/apt/src/main/java/org/apache/camel/tools/apt/TypeConverterLoaderProcessor.java
index 1e2fbc3..54d1244 100644
---
a/tooling/apt/src/main/java/org/apache/camel/tools/apt/TypeConverterLoaderProcessor.java
+++
b/tooling/apt/src/main/java/org/apache/camel/tools/apt/TypeConverterLoaderProcessor.java
@@ -43,9 +43,15 @@ import javax.tools.JavaFileManager;
import javax.tools.JavaFileObject;
import javax.tools.StandardLocation;
-@SupportedAnnotationTypes({"org.apache.camel.Converter"})
+import static
org.apache.camel.tools.apt.AnnotationProcessorHelper.dumpExceptionToErrorFile;
+
+@SupportedAnnotationTypes({"org.apache.camel.Converter",
"org.apache.camel.FallbackConverter"})
public class TypeConverterLoaderProcessor extends
AbstractCamelAnnotationProcessor {
+ // TODO: fallback does not work
+ // TODO: generate so you dont need to pass in CamelContext but register
into a java set/thingy
+ // so you can init this via static initializer block { ... } and then
register on CamelContext later
+
private static final class ClassConverters {
private final Comparator<TypeMirror> comparator;
@@ -118,21 +124,24 @@ public class TypeConverterLoaderProcessor extends
AbstractCamelAnnotationProcess
ignoreOnLoadError = isIgnoreOnLoadError(element);
}
} else if (currentClass != null && element.getKind() ==
ElementKind.METHOD) {
+ // is the method annotated with @Converter
ExecutableElement ee = (ExecutableElement) element;
- TypeMirror to = ee.getReturnType();
- TypeMirror from = ee.getParameters().get(0).asType();
- String fromStr = toString(from);
- if (!fromStr.endsWith("[]")) {
- TypeElement e =
this.processingEnv.getElementUtils().getTypeElement(fromStr);
- if (e != null) {
- from = e.asType();
- } else {
-
processingEnv.getMessager().printMessage(Diagnostic.Kind.NOTE, "Could not
retrieve type element for " + fromStr);
+ if (isConverterMethod(ee)) {
+ TypeMirror to = ee.getReturnType();
+ TypeMirror from = ee.getParameters().get(0).asType();
+ String fromStr = toString(from);
+ if (!fromStr.endsWith("[]")) {
+ TypeElement e =
this.processingEnv.getElementUtils().getTypeElement(fromStr);
+ if (e != null) {
+ from = e.asType();
+ } else {
+
processingEnv.getMessager().printMessage(Diagnostic.Kind.NOTE, "Could not
retrieve type element for " + fromStr);
+ }
+ }
+ converters.computeIfAbsent(currentClass, c -> new
ClassConverters(comparator)).addTypeConverter(to, from, ee);
+ if (converters.containsKey(currentClass)) {
+
converters.get(currentClass).setIgnoreOnLoadError(ignoreOnLoadError);
}
- }
- converters.computeIfAbsent(currentClass, c -> new
ClassConverters(comparator)).addTypeConverter(to, from, ee);
- if (converters.containsKey(currentClass)) {
-
converters.get(currentClass).setIgnoreOnLoadError(ignoreOnLoadError);
}
}
}
@@ -140,7 +149,7 @@ public class TypeConverterLoaderProcessor extends
AbstractCamelAnnotationProcess
TypeElement fallbackAnnotationType =
this.processingEnv.getElementUtils().getTypeElement("org.apache.camel.FallbackConverter");
currentClass = null;
ignoreOnLoadError = false;
- for (Element element :
roundEnv.getElementsAnnotatedWith(fallbackAnnotationType)) {
+ for (Element element :
roundEnv.getElementsAnnotatedWith(converterAnnotationType)) {
if (element.getKind() == ElementKind.CLASS) {
TypeElement te = (TypeElement) element;
if (!te.getNestingKind().isNested() && isLoaderEnabled(te)) {
@@ -150,9 +159,11 @@ public class TypeConverterLoaderProcessor extends
AbstractCamelAnnotationProcess
}
} else if (currentClass != null && element.getKind() ==
ElementKind.METHOD) {
ExecutableElement ee = (ExecutableElement) element;
- converters.computeIfAbsent(currentClass, c -> new
ClassConverters(comparator)).addFallbackTypeConverter(ee);
- if (converters.containsKey(currentClass)) {
-
converters.get(currentClass).setIgnoreOnLoadError(ignoreOnLoadError);
+ if (isFallbackConverterMethod(ee)) {
+ converters.computeIfAbsent(currentClass, c -> new
ClassConverters(comparator)).addFallbackTypeConverter(ee);
+ if (converters.containsKey(currentClass)) {
+
converters.get(currentClass).setIgnoreOnLoadError(ignoreOnLoadError);
+ }
}
}
}
@@ -161,9 +172,7 @@ public class TypeConverterLoaderProcessor extends
AbstractCamelAnnotationProcess
for (Map.Entry<String, ClassConverters> entry : converters.entrySet())
{
String key = entry.getKey();
ClassConverters value = entry.getValue();
- if (!value.isEmpty()) {
- writeConverterLoader(key, value, converterAnnotationType,
fallbackAnnotationType);
- }
+ writeConverterLoader(key, value, converterAnnotationType,
fallbackAnnotationType);
}
writeConverterLoaderMetaInfo(converters);
}
@@ -190,6 +199,26 @@ public class TypeConverterLoaderProcessor extends
AbstractCamelAnnotationProcess
return false;
}
+ private static boolean isConverterMethod(ExecutableElement element) {
+ for (AnnotationMirror ann : element.getAnnotationMirrors()) {
+ String name =
ann.getAnnotationType().asElement().getSimpleName().toString();
+ if ("Converter".equals(name)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ private static boolean isFallbackConverterMethod(ExecutableElement
element) {
+ for (AnnotationMirror ann : element.getAnnotationMirrors()) {
+ String name =
ann.getAnnotationType().asElement().getSimpleName().toString();
+ if ("FallbackConverter".equals(name)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
private void writeConverterLoaderMetaInfo(Map<String, ClassConverters>
converters) throws Exception {
StringJoiner sj = new StringJoiner(",");
for (Map.Entry<String, ClassConverters> entry : converters.entrySet())
{
@@ -263,7 +292,7 @@ public class TypeConverterLoaderProcessor extends
AbstractCamelAnnotationProcess
writer.append(" protected abstract Object
doConvert(Exchange exchange, Object value) throws Exception;\n");
writer.append(" };\n");
writer.append("\n");
- writer.append(" private DoubleMap<Class<?>, Class<?>,
BaseTypeConverter> converters = new DoubleMap<>(" + converters.size() + ");\n");
+ writer.append(" private final DoubleMap<Class<?>, Class<?>,
BaseTypeConverter> converters = new DoubleMap<>(" + converters.size() + ");\n");
writer.append("\n");
writer.append(" private ").append(c).append("() {\n");
diff --git
a/tooling/apt/src/main/resources/META-INF/services/javax.annotation.processing.Processor
b/tooling/apt/src/main/resources/META-INF/services/javax.annotation.processing.Processor
index 065f185..ce52a1c 100644
---
a/tooling/apt/src/main/resources/META-INF/services/javax.annotation.processing.Processor
+++
b/tooling/apt/src/main/resources/META-INF/services/javax.annotation.processing.Processor
@@ -19,7 +19,7 @@
org.apache.camel.tools.apt.ModelAnnotationProcessor
org.apache.camel.tools.apt.EndpointAnnotationProcessor
org.apache.camel.tools.apt.SpiProcessor
+org.apache.camel.tools.apt.CoreTypeConverterProcessor
org.apache.camel.tools.apt.TypeConverterProcessor
-org.apache.camel.tools.apt.CoreConverterProcessor
org.apache.camel.tools.apt.TypeConverterLoaderProcessor
