in core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/SimpleFunctionExpression.java [78:345]
private Expression createSimpleExpression(CamelContext camelContext, String function, boolean strict) {
// return the function directly if we can create function without analyzing the prefix
Expression answer = createSimpleExpressionDirectly(camelContext, function);
if (answer != null) {
return answer;
}
// message first
answer = createSimpleExpressionMessage(camelContext, function, strict);
if (answer != null) {
return answer;
}
// body and headers first
answer = createSimpleExpressionBodyOrHeader(function, strict);
if (answer != null) {
return answer;
}
// variables
answer = createSimpleExpressionVariables(function, strict);
if (answer != null) {
return answer;
}
// custom languages
answer = createSimpleCustomLanguage(function, strict);
if (answer != null) {
return answer;
}
// camelContext OGNL
String remainder = ifStartsWithReturnRemainder("camelContext", function);
if (remainder != null) {
boolean invalid = OgnlHelper.isInvalidValidOgnlExpression(remainder);
if (invalid) {
throw new SimpleParserException("Valid syntax: ${camelContext.OGNL} was: " + function, token.getIndex());
}
return SimpleExpressionBuilder.camelContextOgnlExpression(remainder);
}
// Exception OGNL
remainder = ifStartsWithReturnRemainder("exception", function);
if (remainder != null) {
boolean invalid = OgnlHelper.isInvalidValidOgnlExpression(remainder);
if (invalid) {
throw new SimpleParserException("Valid syntax: ${exception.OGNL} was: " + function, token.getIndex());
}
return SimpleExpressionBuilder.exchangeExceptionOgnlExpression(remainder);
}
// exchange property
remainder = ifStartsWithReturnRemainder("exchangeProperty", function);
if (remainder != null) {
// remove leading character (dot, colon or ?)
if (remainder.startsWith(".") || remainder.startsWith(":") || remainder.startsWith("?")) {
remainder = remainder.substring(1);
}
// remove starting and ending brackets
if (remainder.startsWith("[") && remainder.endsWith("]")) {
remainder = remainder.substring(1, remainder.length() - 1);
}
// validate syntax
boolean invalid = OgnlHelper.isInvalidValidOgnlExpression(remainder);
if (invalid) {
throw new SimpleParserException("Valid syntax: ${exchangeProperty.OGNL} was: " + function, token.getIndex());
}
if (OgnlHelper.isValidOgnlExpression(remainder)) {
// ognl based property
return SimpleExpressionBuilder.propertyOgnlExpression(remainder);
} else {
// regular property
return ExpressionBuilder.exchangePropertyExpression(remainder);
}
}
// system property
remainder = ifStartsWithReturnRemainder("sys.", function);
if (remainder != null) {
return ExpressionBuilder.systemPropertyExpression(remainder);
}
remainder = ifStartsWithReturnRemainder("sysenv.", function);
if (remainder == null) {
remainder = ifStartsWithReturnRemainder("sysenv:", function);
}
if (remainder == null) {
remainder = ifStartsWithReturnRemainder("env.", function);
}
if (remainder == null) {
remainder = ifStartsWithReturnRemainder("env:", function);
}
if (remainder != null) {
return ExpressionBuilder.systemEnvironmentExpression(remainder);
}
// exchange OGNL
remainder = ifStartsWithReturnRemainder("exchange", function);
if (remainder != null) {
boolean invalid = OgnlHelper.isInvalidValidOgnlExpression(remainder);
if (invalid) {
throw new SimpleParserException("Valid syntax: ${exchange.OGNL} was: " + function, token.getIndex());
}
return SimpleExpressionBuilder.exchangeOgnlExpression(remainder);
}
// pretty
remainder = ifStartsWithReturnRemainder("pretty(", function);
if (remainder != null) {
String exp = StringHelper.beforeLast(remainder, ")");
if (exp == null) {
throw new SimpleParserException("Valid syntax: ${pretty(exp)} was: " + function, token.getIndex());
}
exp = StringHelper.removeLeadingAndEndingQuotes(exp);
Expression inlined = camelContext.resolveLanguage("simple").createExpression(exp);
return ExpressionBuilder.prettyExpression(inlined);
}
// file: prefix
remainder = ifStartsWithReturnRemainder("file:", function);
if (remainder != null) {
Expression fileExpression = createSimpleFileExpression(remainder, strict);
if (fileExpression != null) {
return fileExpression;
}
}
// date: prefix
remainder = ifStartsWithReturnRemainder("date:", function);
if (remainder != null) {
String[] parts = remainder.split(":", 2);
if (parts.length == 1) {
return SimpleExpressionBuilder.dateExpression(parts[0]);
} else if (parts.length == 2) {
return SimpleExpressionBuilder.dateExpression(parts[0], parts[1]);
}
}
// date-with-timezone: prefix
remainder = ifStartsWithReturnRemainder("date-with-timezone:", function);
if (remainder != null) {
String[] parts = remainder.split(":", 3);
if (parts.length < 3) {
throw new SimpleParserException(
"Valid syntax: ${date-with-timezone:command:timezone:pattern} was: " + function, token.getIndex());
}
return SimpleExpressionBuilder.dateExpression(parts[0], parts[1], parts[2]);
}
// bean: prefix
remainder = ifStartsWithReturnRemainder("bean:", function);
if (remainder != null) {
Language bean = camelContext.resolveLanguage("bean");
String ref = remainder;
Object method = null;
Object scope = null;
// we support different syntax for bean function
if (remainder.contains("?method=") || remainder.contains("?scope=")) {
ref = StringHelper.before(remainder, "?");
String query = StringHelper.after(remainder, "?");
try {
Map<String, Object> map = URISupport.parseQuery(query);
method = map.get("method");
scope = map.get("scope");
} catch (URISyntaxException e) {
throw RuntimeCamelException.wrapRuntimeException(e);
}
} else {
//first check case :: because of my.own.Bean::method
int doubleColonIndex = remainder.indexOf("::");
//need to check that not inside params
int beginOfParameterDeclaration = remainder.indexOf('(');
if (doubleColonIndex > 0 && (!remainder.contains("(") || doubleColonIndex < beginOfParameterDeclaration)) {
ref = remainder.substring(0, doubleColonIndex);
method = remainder.substring(doubleColonIndex + 2);
} else {
int idx = remainder.indexOf('.');
if (idx > 0) {
ref = remainder.substring(0, idx);
method = remainder.substring(idx + 1);
}
}
}
Class<?> type = null;
if (ref != null && ref.startsWith("type:")) {
try {
type = camelContext.getClassResolver().resolveMandatoryClass(ref.substring(5));
ref = null;
} catch (ClassNotFoundException e) {
throw RuntimeCamelException.wrapRuntimeException(e);
}
}
// there are parameters then map them into properties
Object[] properties = new Object[7];
properties[3] = type;
properties[4] = ref;
properties[2] = method;
properties[5] = scope;
return bean.createExpression(null, properties);
}
// properties-exist: prefix
remainder = ifStartsWithReturnRemainder("propertiesExist:", function);
if (remainder != null) {
String[] parts = remainder.split(":", 2);
if (parts.length > 2) {
throw new SimpleParserException("Valid syntax: ${propertiesExist:key} was: " + function, token.getIndex());
}
String key = parts[0];
boolean negate = key != null && key.startsWith("!");
if (negate) {
key = key.substring(1);
}
return ExpressionBuilder.propertiesComponentExist(key, negate);
}
// properties: prefix
remainder = ifStartsWithReturnRemainder("properties:", function);
if (remainder != null) {
String[] parts = remainder.split(":", 2);
if (parts.length > 2) {
throw new SimpleParserException("Valid syntax: ${properties:key[:default]} was: " + function, token.getIndex());
}
String defaultValue = null;
if (parts.length >= 2) {
defaultValue = parts[1];
}
String key = parts[0];
return ExpressionBuilder.propertiesComponentExpression(key, defaultValue);
}
// ref: prefix
remainder = ifStartsWithReturnRemainder("ref:", function);
if (remainder != null) {
return ExpressionBuilder.refExpression(remainder);
}
// type: prefix
remainder = ifStartsWithReturnRemainder("type:", function);
if (remainder != null) {
Expression exp = SimpleExpressionBuilder.typeExpression(remainder);
exp.init(camelContext);
// we want to cache this expression, so we won't re-evaluate it as the type/constant won't change
return SimpleExpressionBuilder.cacheExpression(exp);
}
// miscellaneous functions
Expression misc = createSimpleExpressionMisc(function);
if (misc != null) {
return misc;
}
// attachments
if ("attachments".equals(function) || ifStartsWithReturnRemainder("attachment", function) != null) {
Expression exp = createSimpleAttachments(camelContext, function);
if (exp != null) {
return exp;
}
}
if (strict) {
throw new SimpleParserException("Unknown function: " + function, token.getIndex());
} else {
return null;
}
}