You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@camel.apache.org by da...@apache.org on 2019/03/14 06:53:28 UTC
[camel] 06/06: CAMEL-13313: Add support for generating type
converter loader source code to be able to load component type converters
in a faster way.
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
commit 379d1ec2378199a638ca18e3c2fba06b8234ba82
Author: Claus Ibsen <cl...@gmail.com>
AuthorDate: Thu Mar 14 07:25:30 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.
---
.../tools/apt/TypeConverterLoaderProcessor.java | 40 +++++++++++++++++++++-
1 file changed, 39 insertions(+), 1 deletion(-)
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 321d904..1e2fbc3 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
@@ -52,11 +52,20 @@ public class TypeConverterLoaderProcessor extends AbstractCamelAnnotationProcess
private final Map<String, Map<TypeMirror, ExecutableElement>> converters = new TreeMap<>();
private final List<ExecutableElement> fallbackConverters = new ArrayList<>();
private int size;
+ private boolean ignoreOnLoadError;
ClassConverters(Comparator<TypeMirror> comparator) {
this.comparator = comparator;
}
+ boolean isIgnoreOnLoadError() {
+ return ignoreOnLoadError;
+ }
+
+ void setIgnoreOnLoadError(boolean ignoreOnLoadError) {
+ this.ignoreOnLoadError = ignoreOnLoadError;
+ }
+
void addTypeConverter(TypeMirror to, TypeMirror from, ExecutableElement ee) {
converters.computeIfAbsent(toString(to), c -> new TreeMap<>(comparator)).put(from, ee);
size++;
@@ -98,6 +107,7 @@ public class TypeConverterLoaderProcessor extends AbstractCamelAnnotationProcess
TypeElement converterAnnotationType = this.processingEnv.getElementUtils().getTypeElement("org.apache.camel.Converter");
// the current class with type converters
String currentClass = null;
+ boolean ignoreOnLoadError = false;
for (Element element : roundEnv.getElementsAnnotatedWith(converterAnnotationType)) {
// we need a top level class first
if (element.getKind() == ElementKind.CLASS) {
@@ -105,6 +115,7 @@ public class TypeConverterLoaderProcessor extends AbstractCamelAnnotationProcess
if (!te.getNestingKind().isNested() && isLoaderEnabled(te)) {
// we only accept top-level classes and if loader is enabled
currentClass = te.getQualifiedName().toString();
+ ignoreOnLoadError = isIgnoreOnLoadError(element);
}
} else if (currentClass != null && element.getKind() == ElementKind.METHOD) {
ExecutableElement ee = (ExecutableElement) element;
@@ -120,21 +131,29 @@ public class TypeConverterLoaderProcessor extends AbstractCamelAnnotationProcess
}
}
converters.computeIfAbsent(currentClass, c -> new ClassConverters(comparator)).addTypeConverter(to, from, ee);
+ if (converters.containsKey(currentClass)) {
+ converters.get(currentClass).setIgnoreOnLoadError(ignoreOnLoadError);
+ }
}
}
TypeElement fallbackAnnotationType = this.processingEnv.getElementUtils().getTypeElement("org.apache.camel.FallbackConverter");
currentClass = null;
+ ignoreOnLoadError = false;
for (Element element : roundEnv.getElementsAnnotatedWith(fallbackAnnotationType)) {
if (element.getKind() == ElementKind.CLASS) {
TypeElement te = (TypeElement) element;
if (!te.getNestingKind().isNested() && isLoaderEnabled(te)) {
// we only accept top-level classes and if loader is enabled
currentClass = te.getQualifiedName().toString();
+ ignoreOnLoadError = isIgnoreOnLoadError(element);
}
} 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);
+ }
}
}
@@ -160,6 +179,17 @@ public class TypeConverterLoaderProcessor extends AbstractCamelAnnotationProcess
return false;
}
+ private static boolean isIgnoreOnLoadError(Element element) {
+ for (AnnotationMirror ann : element.getAnnotationMirrors()) {
+ for (Map.Entry<? extends ExecutableElement, ? extends AnnotationValue> entry : ann.getElementValues().entrySet()) {
+ if ("ignoreOnLoadError".equals(entry.getKey().getSimpleName().toString())) {
+ return (Boolean) entry.getValue().getValue();
+ }
+ }
+ }
+ return false;
+ }
+
private void writeConverterLoaderMetaInfo(Map<String, ClassConverters> converters) throws Exception {
StringJoiner sj = new StringJoiner(",");
for (Map.Entry<String, ClassConverters> entry : converters.entrySet()) {
@@ -266,7 +296,15 @@ public class TypeConverterLoaderProcessor extends AbstractCamelAnnotationProcess
writer.append("\n");
writer.append(" @Override\n");
writer.append(" public void load(TypeConverterRegistry registry) throws TypeConverterLoaderException {\n");
- writer.append(" converters.forEach((k, v, c) -> registry.addTypeConverter(k, v, c));\n");
+ if (converters.isIgnoreOnLoadError()) {
+ writer.append(" try {\n");
+ writer.append(" converters.forEach((k, v, c) -> registry.addTypeConverter(k, v, c));\n");
+ writer.append(" } catch (Throwable e) {\n");
+ writer.append(" // ignore on load error\n");
+ writer.append(" }\n");
+ } else {
+ writer.append(" converters.forEach((k, v, c) -> registry.addTypeConverter(k, v, c));\n");
+ }
for (ExecutableElement ee : converters.getFallbackConverters()) {
boolean allowNull = false;
boolean canPromote = false;