You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@camel.apache.org by or...@apache.org on 2023/04/27 13:20:35 UTC
[camel] branch main updated (53fb7165b45 -> 559e970de79)
This is an automated email from the ASF dual-hosted git repository.
orpiske pushed a change to branch main
in repository https://gitbox.apache.org/repos/asf/camel.git
from 53fb7165b45 camel-jbang - Upgrade to Camel 3.20.4
new 775da6ca7ae (chores) camel-base: cleanup boolean conversions
new 559e970de79 (chores) camel-base: break a few large methods
The 2 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
.../impl/converter/CoreTypeConverterRegistry.java | 248 ++++++++++++---------
1 file changed, 138 insertions(+), 110 deletions(-)
[camel] 02/02: (chores) camel-base: break a few large methods
Posted by or...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
orpiske pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/camel.git
commit 559e970de7982bfca7503c445e5b35b98d437b72
Author: Otavio Rodolfo Piske <an...@gmail.com>
AuthorDate: Thu Apr 27 09:28:06 2023 +0200
(chores) camel-base: break a few large methods
This should help the profiler to provide useful information
---
.../impl/converter/CoreTypeConverterRegistry.java | 160 +++++++++++++--------
1 file changed, 98 insertions(+), 62 deletions(-)
diff --git a/core/camel-base/src/main/java/org/apache/camel/impl/converter/CoreTypeConverterRegistry.java b/core/camel-base/src/main/java/org/apache/camel/impl/converter/CoreTypeConverterRegistry.java
index f7f2ed1cc7c..a297b4594f3 100644
--- a/core/camel-base/src/main/java/org/apache/camel/impl/converter/CoreTypeConverterRegistry.java
+++ b/core/camel-base/src/main/java/org/apache/camel/impl/converter/CoreTypeConverterRegistry.java
@@ -381,6 +381,35 @@ public class CoreTypeConverterRegistry extends ServiceSupport implements TypeCon
}
}
+ private static Object primitiveTypes(final Class<?> type) {
+ if (boolean.class == type) {
+ return Boolean.FALSE;
+ }
+ if (int.class == type) {
+ return 0;
+ }
+ if (long.class == type) {
+ return 0L;
+ }
+ if (byte.class == type) {
+ return (byte) 0;
+ }
+ if (short.class == type) {
+ return (short) 0;
+ }
+ if (double.class == type) {
+ return 0.0;
+ }
+ if (float.class == type) {
+ return 0.0f;
+ }
+ if (char.class == type) {
+ return '\0';
+ }
+
+ return null;
+ }
+
protected Object doConvertTo(
final Class<?> type, final Exchange exchange, final Object value,
final boolean tryConvert)
@@ -394,30 +423,7 @@ public class CoreTypeConverterRegistry extends ServiceSupport implements TypeCon
}
// lets avoid NullPointerException when converting to primitives for null values
if (type.isPrimitive()) {
- if (boolean.class == type) {
- return Boolean.FALSE;
- }
- if (int.class == type) {
- return 0;
- }
- if (long.class == type) {
- return 0L;
- }
- if (byte.class == type) {
- return (byte) 0;
- }
- if (short.class == type) {
- return (short) 0;
- }
- if (double.class == type) {
- return 0.0;
- }
- if (float.class == type) {
- return 0.0f;
- }
- if (char.class == type) {
- return '\0';
- }
+ return primitiveTypes(type);
}
return null;
}
@@ -447,12 +453,7 @@ public class CoreTypeConverterRegistry extends ServiceSupport implements TypeCon
// try to find a suitable type converter
TypeConverter converter = getOrFindTypeConverter(type, value.getClass());
if (converter != null) {
- Object rc;
- if (tryConvert) {
- rc = converter.tryConvertTo(type, exchange, value);
- } else {
- rc = converter.convertTo(type, exchange, value);
- }
+ Object rc = doConvert(type, exchange, value, tryConvert, converter);
if (rc != null) {
return rc;
} else if (converter.allowNull()) {
@@ -469,12 +470,7 @@ public class CoreTypeConverterRegistry extends ServiceSupport implements TypeCon
if (tc != null) {
// add the type as a known type converter as we can convert from primitive to object converter
addTypeConverter(type, fromType, tc);
- Object rc;
- if (tryConvert) {
- rc = tc.tryConvertTo(primitiveType, exchange, value);
- } else {
- rc = tc.convertTo(primitiveType, exchange, value);
- }
+ Object rc = doConvert(exchange, value, tryConvert, primitiveType, tc);
if (rc == null && tc.allowNull()) {
return null;
} else if (rc != null) {
@@ -487,12 +483,7 @@ public class CoreTypeConverterRegistry extends ServiceSupport implements TypeCon
// fallback converters
for (FallbackTypeConverter fallback : fallbackConverters) {
TypeConverter tc = fallback.getFallbackTypeConverter();
- Object rc;
- if (tryConvert) {
- rc = tc.tryConvertTo(type, exchange, value);
- } else {
- rc = tc.convertTo(type, exchange, value);
- }
+ Object rc = doConvert(type, exchange, value, tryConvert, tc);
if (rc == null && tc.allowNull()) {
return null;
}
@@ -523,6 +514,24 @@ public class CoreTypeConverterRegistry extends ServiceSupport implements TypeCon
return TypeConverter.MISS_VALUE;
}
+ private static Object doConvert(
+ Exchange exchange, Object value, boolean tryConvert, Class<?> primitiveType, TypeConverter tc) {
+ if (tryConvert) {
+ return tc.tryConvertTo(primitiveType, exchange, value);
+ } else {
+ return tc.convertTo(primitiveType, exchange, value);
+ }
+ }
+
+ private static Object doConvert(
+ Class<?> type, Exchange exchange, Object value, boolean tryConvert, TypeConverter converter) {
+ if (tryConvert) {
+ return converter.tryConvertTo(type, exchange, value);
+ } else {
+ return converter.convertTo(type, exchange, value);
+ }
+ }
+
public TypeConverter getTypeConverter(Class<?> toType, Class<?> fromType) {
return typeMappings.get(toType, fromType);
}
@@ -618,35 +627,27 @@ public class CoreTypeConverterRegistry extends ServiceSupport implements TypeCon
if (fromType != null) {
// try with base converters first
- TypeConverter converter;
- for (BulkTypeConverters base : bulkTypeConverters) {
- converter = base.lookup(toType, fromType);
- if (converter != null) {
- return converter;
- }
+ final TypeConverter baseConverters = tryBaseConverters(toType, fromType);
+ if (baseConverters != null) {
+ return baseConverters;
}
// lets try if there is a direct match
- converter = getTypeConverter(toType, fromType);
- if (converter != null) {
- return converter;
+ final TypeConverter directMatchConverter = tryDirectMatchConverters(toType, fromType);
+ if (directMatchConverter != null) {
+ return directMatchConverter;
}
// try the interfaces
- for (Class<?> type : fromType.getInterfaces()) {
- converter = getTypeConverter(toType, type);
- if (converter != null) {
- return converter;
- }
+ final TypeConverter interfaceConverter = tryInterfaceConverters(toType, fromType);
+ if (interfaceConverter != null) {
+ return interfaceConverter;
}
// try super then
- Class<?> fromSuperClass = fromType.getSuperclass();
- if (fromSuperClass != null && !fromSuperClass.equals(Object.class)) {
- converter = doLookup(toType, fromSuperClass, true);
- if (converter != null) {
- return converter;
- }
+ final TypeConverter superConverter = trySuperConverters(toType, fromType);
+ if (superConverter != null) {
+ return superConverter;
}
}
@@ -675,6 +676,41 @@ public class CoreTypeConverterRegistry extends ServiceSupport implements TypeCon
return null;
}
+ private TypeConverter trySuperConverters(Class<?> toType, Class<?> fromType) {
+ Class<?> fromSuperClass = fromType.getSuperclass();
+ if (fromSuperClass != null && !fromSuperClass.equals(Object.class)) {
+ final TypeConverter converter = doLookup(toType, fromSuperClass, true);
+ if (converter != null) {
+ return converter;
+ }
+ }
+ return null;
+ }
+
+ private TypeConverter tryInterfaceConverters(Class<?> toType, Class<?> fromType) {
+ for (Class<?> type : fromType.getInterfaces()) {
+ TypeConverter converter = getTypeConverter(toType, type);
+ if (converter != null) {
+ return converter;
+ }
+ }
+ return null;
+ }
+
+ private TypeConverter tryDirectMatchConverters(Class<?> toType, Class<?> fromType) {
+ return getTypeConverter(toType, fromType);
+ }
+
+ private TypeConverter tryBaseConverters(Class<?> toType, Class<?> fromType) {
+ for (BulkTypeConverters base : bulkTypeConverters) {
+ TypeConverter converter = base.lookup(toType, fromType);
+ if (converter != null) {
+ return converter;
+ }
+ }
+ return null;
+ }
+
protected TypeConversionException createTypeConversionException(
Exchange exchange, Class<?> type, Object value, Throwable cause) {
if (cause instanceof TypeConversionException) {
[camel] 01/02: (chores) camel-base: cleanup boolean conversions
Posted by or...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
orpiske pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/camel.git
commit 775da6ca7ae0f2fe4980a39b908bd884a5fb8d95
Author: Otavio Rodolfo Piske <an...@gmail.com>
AuthorDate: Thu Apr 27 08:57:35 2023 +0200
(chores) camel-base: cleanup boolean conversions
---
.../impl/converter/CoreTypeConverterRegistry.java | 88 ++++++++++------------
1 file changed, 40 insertions(+), 48 deletions(-)
diff --git a/core/camel-base/src/main/java/org/apache/camel/impl/converter/CoreTypeConverterRegistry.java b/core/camel-base/src/main/java/org/apache/camel/impl/converter/CoreTypeConverterRegistry.java
index f7ed3be65aa..f7f2ed1cc7c 100644
--- a/core/camel-base/src/main/java/org/apache/camel/impl/converter/CoreTypeConverterRegistry.java
+++ b/core/camel-base/src/main/java/org/apache/camel/impl/converter/CoreTypeConverterRegistry.java
@@ -155,22 +155,9 @@ public class CoreTypeConverterRegistry extends ServiceSupport implements TypeCon
return (T) answer;
} else if (type == Boolean.class && value instanceof String) {
// String -> Boolean
- String str = (String) value;
- // must be 4 or 5 in length
- int len = str.length();
- // fast check the value as-is in lower case which is most common
- if (len == 4 && "true".equals(str)) {
- return (T) Boolean.TRUE;
- } else if (len == 5 && "false".equals(str)) {
- return (T) Boolean.FALSE;
- } else {
- // do check for ignore case
- str = str.toUpperCase();
- if (len == 4 && "TRUE".equals(str)) {
- return (T) Boolean.TRUE;
- } else if (len == 5 && "FALSE".equals(str)) {
- return (T) Boolean.FALSE;
- }
+ T parsedBoolean = customParseBoolean((String) value);
+ if (parsedBoolean != null) {
+ return parsedBoolean;
}
} else if (type.isPrimitive()) {
// okay its a wrapper -> primitive then return as-is for some common types
@@ -202,6 +189,37 @@ public class CoreTypeConverterRegistry extends ServiceSupport implements TypeCon
return (T) doConvertTo(type, exchange, value, false, false);
}
+ // must be 4 or 5 in length
+ private static <T> T customParseBoolean(String str) {
+ int len = str.length();
+ // fast check the value as-is in lower case which is most common
+ if (len == 4) {
+ if ("true".equals(str)) {
+ return (T) Boolean.TRUE;
+ }
+
+ if ("TRUE".equals(str.toUpperCase())) {
+ return (T) Boolean.TRUE;
+ }
+
+ return null;
+ }
+
+ if (len == 5) {
+ if ("false".equals(str)) {
+ return (T) Boolean.FALSE;
+ }
+
+ if ("FALSE".equals(str.toUpperCase())) {
+ return (T) Boolean.FALSE;
+ }
+
+ return null;
+ }
+
+ return null;
+ }
+
public <T> T mandatoryConvertTo(Class<T> type, Object value) throws NoTypeConversionAvailableException {
return mandatoryConvertTo(type, null, value);
}
@@ -225,22 +243,9 @@ public class CoreTypeConverterRegistry extends ServiceSupport implements TypeCon
return (T) answer;
} else if (type == Boolean.class && value instanceof String) {
// String -> Boolean
- String str = (String) value;
- // must be 4 or 5 in length
- int len = str.length();
- // fast check the value as-is in lower case which is most common
- if (len == 4 && "true".equals(str)) {
- return (T) Boolean.TRUE;
- } else if (len == 5 && "false".equals(str)) {
- return (T) Boolean.FALSE;
- } else {
- // do check for ignore case
- str = str.toUpperCase();
- if (len == 4 && "TRUE".equals(str)) {
- return (T) Boolean.TRUE;
- } else if (len == 5 && "FALSE".equals(str)) {
- return (T) Boolean.FALSE;
- }
+ T parsedBoolean = customParseBoolean((String) value);
+ if (parsedBoolean != null) {
+ return parsedBoolean;
}
} else if (type.isPrimitive()) {
// okay its a wrapper -> primitive then return as-is for some common types
@@ -299,22 +304,9 @@ public class CoreTypeConverterRegistry extends ServiceSupport implements TypeCon
return (T) answer;
} else if (type == Boolean.class && value instanceof String) {
// String -> Boolean
- String str = (String) value;
- // must be 4 or 5 in length
- int len = str.length();
- // fast check the value as-is in lower case which is most common
- if (len == 4 && "true".equals(str)) {
- return (T) Boolean.TRUE;
- } else if (len == 5 && "false".equals(str)) {
- return (T) Boolean.FALSE;
- } else {
- // do check for ignore case
- str = str.toUpperCase();
- if (len == 4 && "TRUE".equals(str)) {
- return (T) Boolean.TRUE;
- } else if (len == 5 && "FALSE".equals(str)) {
- return (T) Boolean.FALSE;
- }
+ T parsedBoolean = customParseBoolean((String) value);
+ if (parsedBoolean != null) {
+ return parsedBoolean;
}
} else if (type.isPrimitive()) {
// okay its a wrapper -> primitive then return as-is for some common types