in nifi-commons/nifi-expression-language/src/main/java/org/apache/nifi/attribute/expression/language/compile/ExpressionCompiler.java [596:1115]
private Evaluator<?> buildFunctionEvaluator(final Tree tree, final Evaluator<?> subjectEvaluator, final List<Evaluator<?>> argEvaluators) {
switch (tree.getType()) {
case TRIM: {
verifyArgCount(argEvaluators, 0, "trim");
return addToken(new TrimEvaluator(toStringEvaluator(subjectEvaluator)), "trim");
}
case TO_STRING: {
verifyArgCount(argEvaluators, 0, "toString");
return addToken(new ToStringEvaluator(subjectEvaluator), "toString");
}
case TO_LOWER: {
verifyArgCount(argEvaluators, 0, "toLower");
return addToken(new ToLowerEvaluator(toStringEvaluator(subjectEvaluator)), "toLower");
}
case TO_UPPER: {
verifyArgCount(argEvaluators, 0, "toUpper");
return addToken(new ToUpperEvaluator(toStringEvaluator(subjectEvaluator)), "toUpper");
}
case EVALUATE_EL_STRING: {
verifyArgCount(argEvaluators, 0, "evaluateELString");
return addToken(new EvaluateELStringEvaluator(toStringEvaluator(subjectEvaluator)), "evaluateELString");
}
case URL_ENCODE: {
verifyArgCount(argEvaluators, 0, "urlEncode");
return addToken(new UrlEncodeEvaluator(toStringEvaluator(subjectEvaluator)), "urlEncode");
}
case URL_DECODE: {
verifyArgCount(argEvaluators, 0, "urlDecode");
return addToken(new UrlDecodeEvaluator(toStringEvaluator(subjectEvaluator)), "urlDecode");
}
case BASE64_ENCODE: {
verifyArgCount(argEvaluators, 0, "base64Encode");
return addToken(new Base64EncodeEvaluator(toStringEvaluator(subjectEvaluator)), "base64Encode");
}
case BASE64_DECODE: {
verifyArgCount(argEvaluators, 0, "base64Decode");
return addToken(new Base64DecodeEvaluator(toStringEvaluator(subjectEvaluator)), "base64Decode");
}
case ESCAPE_CSV: {
verifyArgCount(argEvaluators, 0, "escapeCsv");
return addToken(CharSequenceTranslatorEvaluator.csvEscapeEvaluator(toStringEvaluator(subjectEvaluator)), "escapeCsv");
}
case ESCAPE_HTML3: {
verifyArgCount(argEvaluators, 0, "escapeHtml3");
return addToken(CharSequenceTranslatorEvaluator.html3EscapeEvaluator(toStringEvaluator(subjectEvaluator)), "escapeHtml3");
}
case ESCAPE_HTML4: {
verifyArgCount(argEvaluators, 0, "escapeHtml4");
return addToken(CharSequenceTranslatorEvaluator.html4EscapeEvaluator(toStringEvaluator(subjectEvaluator)), "escapeHtml4");
}
case ESCAPE_JSON: {
verifyArgCount(argEvaluators, 0, "escapeJson");
return addToken(CharSequenceTranslatorEvaluator.jsonEscapeEvaluator(toStringEvaluator(subjectEvaluator)), "escapeJson");
}
case ESCAPE_XML: {
verifyArgCount(argEvaluators, 0, "escapeXml");
return addToken(CharSequenceTranslatorEvaluator.xmlEscapeEvaluator(toStringEvaluator(subjectEvaluator)), "escapeXml");
}
case UNESCAPE_CSV: {
verifyArgCount(argEvaluators, 0, "unescapeCsv");
return addToken(CharSequenceTranslatorEvaluator.csvUnescapeEvaluator(toStringEvaluator(subjectEvaluator)), "unescapeCsv");
}
case UNESCAPE_HTML3: {
verifyArgCount(argEvaluators, 0, "unescapeHtml3");
return addToken(CharSequenceTranslatorEvaluator.html3UnescapeEvaluator(toStringEvaluator(subjectEvaluator)), "unescapeHtml3");
}
case UNESCAPE_HTML4: {
verifyArgCount(argEvaluators, 0, "unescapeHtml4");
return addToken(CharSequenceTranslatorEvaluator.html4UnescapeEvaluator(toStringEvaluator(subjectEvaluator)), "unescapeHtml4");
}
case UNESCAPE_JSON: {
verifyArgCount(argEvaluators, 0, "unescapeJson");
return addToken(CharSequenceTranslatorEvaluator.jsonUnescapeEvaluator(toStringEvaluator(subjectEvaluator)), "unescapeJson");
}
case UNESCAPE_XML: {
verifyArgCount(argEvaluators, 0, "unescapeXml");
return addToken(CharSequenceTranslatorEvaluator.xmlUnescapeEvaluator(toStringEvaluator(subjectEvaluator)), "unescapeXml");
}
case SUBSTRING_BEFORE: {
verifyArgCount(argEvaluators, 1, "substringBefore");
return addToken(new SubstringBeforeEvaluator(toStringEvaluator(subjectEvaluator),
toStringEvaluator(argEvaluators.get(0), "first argument to substringBefore")), "substringBefore");
}
case SUBSTRING_BEFORE_LAST: {
verifyArgCount(argEvaluators, 1, "substringBeforeLast");
return addToken(new SubstringBeforeLastEvaluator(toStringEvaluator(subjectEvaluator),
toStringEvaluator(argEvaluators.get(0), "first argument to substringBeforeLast")), "substringBeforeLast");
}
case SUBSTRING_AFTER: {
verifyArgCount(argEvaluators, 1, "substringAfter");
return addToken(new SubstringAfterEvaluator(toStringEvaluator(subjectEvaluator),
toStringEvaluator(argEvaluators.get(0), "first argument to substringAfter")), "substringAfter");
}
case SUBSTRING_AFTER_LAST: {
verifyArgCount(argEvaluators, 1, "substringAfterLast");
return addToken(new SubstringAfterLastEvaluator(toStringEvaluator(subjectEvaluator),
toStringEvaluator(argEvaluators.get(0), "first argument to substringAfterLast")), "substringAfterLast");
}
case REPLACE_NULL: {
verifyArgCount(argEvaluators, 1, "replaceNull");
return addToken(new ReplaceNullEvaluator(toStringEvaluator(subjectEvaluator),
toStringEvaluator(argEvaluators.get(0), "first argument to replaceNull")), "replaceNull");
}
case REPLACE_EMPTY: {
verifyArgCount(argEvaluators, 1, "replaceEmtpy");
return addToken(new ReplaceEmptyEvaluator(toStringEvaluator(subjectEvaluator), toStringEvaluator(argEvaluators.get(0), "first argument to replaceEmpty")), "replaceEmpty");
}
case REPLACE: {
verifyArgCount(argEvaluators, 2, "replace");
return addToken(new ReplaceEvaluator(toStringEvaluator(subjectEvaluator),
toStringEvaluator(argEvaluators.get(0), "first argument to replace"),
toStringEvaluator(argEvaluators.get(1), "second argument to replace")), "replace");
}
case REPLACE_FIRST: {
verifyArgCount(argEvaluators, 2, "replaceFirst");
return addToken(new ReplaceFirstEvaluator(toStringEvaluator(subjectEvaluator),
toStringEvaluator(argEvaluators.get(0), "first argument to replaceFirst"),
toStringEvaluator(argEvaluators.get(1), "second argument to replaceFirst")), "replaceFirst");
}
case REPLACE_ALL: {
verifyArgCount(argEvaluators, 2, "replaceAll");
return addToken(new ReplaceAllEvaluator(toStringEvaluator(subjectEvaluator),
toStringEvaluator(argEvaluators.get(0), "first argument to replaceAll"),
toStringEvaluator(argEvaluators.get(1), "second argument to replaceAll")), "replaceAll");
}
case HASH: {
verifyArgCount(argEvaluators, 1, "hash");
return addToken(new HashEvaluator(toStringEvaluator(subjectEvaluator),
toStringEvaluator(argEvaluators.get(0), "first argument to hash")), "hash");
}
case PAD_LEFT: {
if (argEvaluators.size() == 1) {
return addToken(new PadLeftEvaluator(toStringEvaluator(subjectEvaluator),
toWholeNumberEvaluator(argEvaluators.get(0), "desired string length")),
"padLeft");
} else {
return addToken(new PadLeftEvaluator(toStringEvaluator(subjectEvaluator),
toWholeNumberEvaluator(argEvaluators.get(0), "desired string length"),
toStringEvaluator(argEvaluators.get(1), "padding string")), "padLeft");
}
}
case PAD_RIGHT: {
if (argEvaluators.size() == 1) {
return addToken(new PadRightEvaluator(toStringEvaluator(subjectEvaluator),
toWholeNumberEvaluator(argEvaluators.get(0), "desired string length")),
"padRight");
} else {
return addToken(new PadRightEvaluator(toStringEvaluator(subjectEvaluator),
toWholeNumberEvaluator(argEvaluators.get(0), "desired string length"),
toStringEvaluator(argEvaluators.get(1), "padding string")), "padRight");
}
}
case REPLACE_BY_PATTERN: {
verifyArgCount(argEvaluators, 1, "replaceByPattern");
return addToken(new ReplaceByPatternEvaluator(toStringEvaluator(subjectEvaluator),
toStringEvaluator(argEvaluators.get(0), "first argument to replace")), "replaceByPattern");
}
case APPEND: {
verifyArgCount(argEvaluators, 1, "append");
return addToken(new AppendEvaluator(toStringEvaluator(subjectEvaluator),
toStringEvaluator(argEvaluators.get(0), "first argument to append")), "append");
}
case PREPEND: {
verifyArgCount(argEvaluators, 1, "prepend");
return addToken(new PrependEvaluator(toStringEvaluator(subjectEvaluator),
toStringEvaluator(argEvaluators.get(0), "first argument to prepend")), "prepend");
}
case SUBSTRING: {
final int numArgs = argEvaluators.size();
if (numArgs == 1) {
return addToken(new SubstringEvaluator(toStringEvaluator(subjectEvaluator),
toWholeNumberEvaluator(argEvaluators.get(0), "first argument to substring")), "substring");
} else if (numArgs == 2) {
return addToken(new SubstringEvaluator(toStringEvaluator(subjectEvaluator),
toWholeNumberEvaluator(argEvaluators.get(0), "first argument to substring"),
toWholeNumberEvaluator(argEvaluators.get(1), "second argument to substring")), "substring");
} else {
throw new AttributeExpressionLanguageParsingException("substring() function can take either 1 or 2 arguments but cannot take " + numArgs + " arguments");
}
}
case REPEAT: {
final int numArgs = argEvaluators.size();
if (numArgs == 1) {
return addToken(new RepeatEvaluator(toStringEvaluator(subjectEvaluator),
toWholeNumberEvaluator(argEvaluators.get(0), "first argument to repeat")), "repeat");
} else if (numArgs == 2) {
return addToken(new RepeatEvaluator(toStringEvaluator(subjectEvaluator),
toWholeNumberEvaluator(argEvaluators.get(0), "first argument to repeat"),
toWholeNumberEvaluator(argEvaluators.get(1), "second argument to repeat")), "repeat");
} else {
throw new AttributeExpressionLanguageParsingException("repeat() function can take either 1 or 2 arguments but cannot take " + numArgs + " arguments");
}
}
case JOIN: {
verifyArgCount(argEvaluators, 1, "join");
return addToken(new JoinEvaluator(toStringEvaluator(subjectEvaluator), toStringEvaluator(argEvaluators.get(0))), "join");
}
case COUNT: {
verifyArgCount(argEvaluators, 0, "count");
return addToken(new CountEvaluator(subjectEvaluator), "count");
}
case IS_NULL: {
verifyArgCount(argEvaluators, 0, "isNull");
return addToken(new IsNullEvaluator(toStringEvaluator(subjectEvaluator)), "isNull");
}
case IS_EMPTY: {
verifyArgCount(argEvaluators, 0, "isEmpty");
return addToken(new IsEmptyEvaluator(toStringEvaluator(subjectEvaluator)), "isEmpty");
}
case NOT_NULL: {
verifyArgCount(argEvaluators, 0, "notNull");
return addToken(new NotNullEvaluator(toStringEvaluator(subjectEvaluator)), "notNull");
}
case STARTS_WITH: {
verifyArgCount(argEvaluators, 1, "startsWith");
return addToken(new StartsWithEvaluator(toStringEvaluator(subjectEvaluator),
toStringEvaluator(argEvaluators.get(0), "first argument to startsWith")), "startsWith");
}
case ENDS_WITH: {
verifyArgCount(argEvaluators, 1, "endsWith");
return addToken(new EndsWithEvaluator(toStringEvaluator(subjectEvaluator),
toStringEvaluator(argEvaluators.get(0), "first argument to endsWith")), "endsWith");
}
case CONTAINS: {
verifyArgCount(argEvaluators, 1, "contains");
return addToken(new ContainsEvaluator(toStringEvaluator(subjectEvaluator),
toStringEvaluator(argEvaluators.get(0), "first argument to contains")), "contains");
}
case IN: {
List<Evaluator<String>> list = new ArrayList<>();
for (int i = 0; i < argEvaluators.size(); i++) {
list.add(toStringEvaluator(argEvaluators.get(i), i + "th argument to in"));
}
return addToken(new InEvaluator(toStringEvaluator(subjectEvaluator), list), "in");
}
case IS_JSON:
verifyArgCount(argEvaluators, 0, "isJson");
return addToken(new IsJsonEvaluator(toStringEvaluator(subjectEvaluator)), "isJson");
case FIND: {
verifyArgCount(argEvaluators, 1, "find");
return addToken(new FindEvaluator(toStringEvaluator(subjectEvaluator),
toStringEvaluator(argEvaluators.get(0), "first argument to find")), "find");
}
case MATCHES: {
verifyArgCount(argEvaluators, 1, "matches");
return addToken(new MatchesEvaluator(toStringEvaluator(subjectEvaluator),
toStringEvaluator(argEvaluators.get(0), "first argument to matches")), "matches");
}
case EQUALS: {
verifyArgCount(argEvaluators, 1, "equals");
return addToken(new EqualsEvaluator(subjectEvaluator, argEvaluators.get(0)), "equals");
}
case EQUALS_IGNORE_CASE: {
verifyArgCount(argEvaluators, 1, "equalsIgnoreCase");
return addToken(new EqualsIgnoreCaseEvaluator(toStringEvaluator(subjectEvaluator),
toStringEvaluator(argEvaluators.get(0), "first argument to equalsIgnoreCase")), "equalsIgnoreCase");
}
case GREATER_THAN: {
verifyArgCount(argEvaluators, 1, "gt");
return addToken(new GreaterThanEvaluator(toNumberEvaluator(subjectEvaluator),
toNumberEvaluator(argEvaluators.get(0), "first argument to gt")), "gt");
}
case GREATER_THAN_OR_EQUAL: {
verifyArgCount(argEvaluators, 1, "ge");
return addToken(new GreaterThanOrEqualEvaluator(toNumberEvaluator(subjectEvaluator),
toNumberEvaluator(argEvaluators.get(0), "first argument to ge")), "ge");
}
case LESS_THAN: {
verifyArgCount(argEvaluators, 1, "lt");
return addToken(new LessThanEvaluator(toNumberEvaluator(subjectEvaluator),
toNumberEvaluator(argEvaluators.get(0), "first argument to lt")), "lt");
}
case LESS_THAN_OR_EQUAL: {
verifyArgCount(argEvaluators, 1, "le");
return addToken(new LessThanOrEqualEvaluator(toNumberEvaluator(subjectEvaluator),
toNumberEvaluator(argEvaluators.get(0), "first argument to le")), "le");
}
case LENGTH: {
verifyArgCount(argEvaluators, 0, "length");
return addToken(new LengthEvaluator(toStringEvaluator(subjectEvaluator)), "length");
}
case TO_DATE: {
if (argEvaluators.isEmpty()) {
return addToken(new NumberToDateEvaluator(toWholeNumberEvaluator(subjectEvaluator)), "toDate");
} else if (subjectEvaluator.getResultType() == ResultType.STRING && argEvaluators.size() == 1) {
return addToken(new StringToDateEvaluator(toStringEvaluator(subjectEvaluator), toStringEvaluator(argEvaluators.get(0)), null), "toDate");
} else if (subjectEvaluator.getResultType() == ResultType.STRING && argEvaluators.size() == 2) {
return addToken(new StringToDateEvaluator(toStringEvaluator(subjectEvaluator), toStringEvaluator(argEvaluators.get(0)), toStringEvaluator(argEvaluators.get(1))), "toDate");
} else {
return addToken(new NumberToDateEvaluator(toWholeNumberEvaluator(subjectEvaluator)), "toDate");
}
}
case TO_INSTANT: {
if (argEvaluators.isEmpty()) {
return addToken(new NumberToInstantEvaluator(toWholeNumberEvaluator(subjectEvaluator)), "toInstant");
} else if (subjectEvaluator.getResultType() == ResultType.STRING && argEvaluators.size() == 2) {
return addToken(new StringToInstantEvaluator(toStringEvaluator(subjectEvaluator), toStringEvaluator(argEvaluators.get(0)), toStringEvaluator(argEvaluators.get(1))), "toInstant");
} else {
return addToken(new NumberToInstantEvaluator(toWholeNumberEvaluator(subjectEvaluator)), "toInstant");
}
}
case TO_NUMBER: {
verifyArgCount(argEvaluators, 0, "toNumber");
switch (subjectEvaluator.getResultType()) {
case STRING:
case WHOLE_NUMBER:
case DECIMAL:
case NUMBER:
case DATE:
case INSTANT:
return addToken(toWholeNumberEvaluator(subjectEvaluator), "toNumber");
default:
throw new AttributeExpressionLanguageParsingException(subjectEvaluator + " returns type " + subjectEvaluator.getResultType() + " but expected to get " + ResultType.STRING +
", " + ResultType.DECIMAL + ", or " + ResultType.DATE);
}
}
case TO_DECIMAL: {
verifyArgCount(argEvaluators, 0, "toDecimal");
switch (subjectEvaluator.getResultType()) {
case WHOLE_NUMBER:
case DECIMAL:
case STRING:
case NUMBER:
case DATE:
case INSTANT:
return addToken(toDecimalEvaluator(subjectEvaluator), "toDecimal");
default:
throw new AttributeExpressionLanguageParsingException(subjectEvaluator + " returns type " + subjectEvaluator.getResultType() + " but expected to get " + ResultType.STRING +
", " + ResultType.WHOLE_NUMBER + ", or " + ResultType.DATE);
}
}
case TO_MICROS: {
verifyArgCount(argEvaluators, 0, "toMicros");
if (subjectEvaluator.getResultType() == ResultType.INSTANT) {
return addToken(new EpochTimeEvaluator(ChronoUnit.MICROS, subjectEvaluator), "toMicros");
} else {
throw new AttributeExpressionLanguageParsingException(subjectEvaluator + " returns type " + subjectEvaluator.getResultType() + " but expected to get " + ResultType.INSTANT);
}
}
case TO_NANOS: {
verifyArgCount(argEvaluators, 0, "toNanos");
if (subjectEvaluator.getResultType() == ResultType.INSTANT) {
return addToken(new EpochTimeEvaluator(ChronoUnit.NANOS, subjectEvaluator), "toNanos");
} else {
throw new AttributeExpressionLanguageParsingException(subjectEvaluator + " returns type " + subjectEvaluator.getResultType() + " but expected to get " + ResultType.INSTANT);
}
}
case TO_RADIX: {
if (argEvaluators.size() == 1) {
return addToken(new ToRadixEvaluator(toWholeNumberEvaluator(subjectEvaluator),
toWholeNumberEvaluator(argEvaluators.get(0))), "toRadix");
} else {
return addToken(new ToRadixEvaluator(toWholeNumberEvaluator(subjectEvaluator),
toWholeNumberEvaluator(argEvaluators.get(0)), toWholeNumberEvaluator(argEvaluators.get(1))), "toRadix");
}
}
case FROM_RADIX: {
return addToken(new FromRadixEvaluator(toStringEvaluator(subjectEvaluator),
toWholeNumberEvaluator(argEvaluators.get(0))), "fromRadix");
}
case MOD: {
return addToken(new ModEvaluator(toNumberEvaluator(subjectEvaluator), toNumberEvaluator(argEvaluators.get(0))), "mod");
}
case PLUS: {
return addToken(new PlusEvaluator(toNumberEvaluator(subjectEvaluator), toNumberEvaluator(argEvaluators.get(0))), "plus");
}
case MINUS: {
return addToken(new MinusEvaluator(toNumberEvaluator(subjectEvaluator), toNumberEvaluator(argEvaluators.get(0))), "minus");
}
case MULTIPLY: {
return addToken(new MultiplyEvaluator(toNumberEvaluator(subjectEvaluator), toNumberEvaluator(argEvaluators.get(0))), "multiply");
}
case DIVIDE: {
return addToken(new DivideEvaluator(toNumberEvaluator(subjectEvaluator), toNumberEvaluator(argEvaluators.get(0))), "divide");
}
case MATH: {
if (argEvaluators.size() == 1) {
return addToken(new MathEvaluator(toNumberEvaluator(subjectEvaluator), toStringEvaluator(argEvaluators.get(0)), null), "math");
} else if (argEvaluators.size() == 2) {
return addToken(new MathEvaluator(toNumberEvaluator(subjectEvaluator), toStringEvaluator(argEvaluators.get(0)), toNumberEvaluator(argEvaluators.get(1))), "math");
} else {
throw new AttributeExpressionLanguageParsingException("math() function takes 1 or 2 arguments");
}
}
case RANDOM: {
return addToken(new RandomNumberGeneratorEvaluator(), "random");
}
case INDEX_OF: {
verifyArgCount(argEvaluators, 1, "indexOf");
return addToken(new IndexOfEvaluator(toStringEvaluator(subjectEvaluator),
toStringEvaluator(argEvaluators.get(0), "first argument to indexOf")), "indexOf");
}
case LAST_INDEX_OF: {
verifyArgCount(argEvaluators, 1, "lastIndexOf");
return addToken(new LastIndexOfEvaluator(toStringEvaluator(subjectEvaluator),
toStringEvaluator(argEvaluators.get(0), "first argument to lastIndexOf")), "lastIndexOf");
}
case FORMAT: {
if (argEvaluators.size() == 1) {
return addToken(new FormatEvaluator(toDateEvaluator(subjectEvaluator), toStringEvaluator(argEvaluators.get(0), "first argument of format"), null), "format");
} else if (argEvaluators.size() == 2) {
return addToken(new FormatEvaluator(toDateEvaluator(subjectEvaluator), toStringEvaluator(argEvaluators.get(0)), toStringEvaluator(argEvaluators.get(1))), "format");
} else {
throw new AttributeExpressionLanguageParsingException("format() function takes 1 or 2 arguments");
}
}
case FORMAT_INSTANT: {
if (argEvaluators.size() == 2) {
return addToken(new InstantFormatEvaluator(toInstantEvaluator(subjectEvaluator), toStringEvaluator(argEvaluators.get(0)), toStringEvaluator(argEvaluators.get(1))), "format");
} else {
throw new AttributeExpressionLanguageParsingException("format() function takes 2 arguments");
}
}
case OR: {
return addToken(new OrEvaluator(toBooleanEvaluator(subjectEvaluator), toBooleanEvaluator(argEvaluators.get(0))), "or");
}
case AND: {
return addToken(new AndEvaluator(toBooleanEvaluator(subjectEvaluator), toBooleanEvaluator(argEvaluators.get(0))), "and");
}
case NOT: {
return addToken(new NotEvaluator(toBooleanEvaluator(subjectEvaluator)), "not");
}
case GET_DELIMITED_FIELD: {
if (argEvaluators.size() == 1) {
// Only a single argument - the index to return.
return addToken(new GetDelimitedFieldEvaluator(toStringEvaluator(subjectEvaluator),
toWholeNumberEvaluator(argEvaluators.get(0), "first argument of getDelimitedField")), "getDelimitedField");
} else if (argEvaluators.size() == 2) {
// two arguments - index and delimiter.
return addToken(new GetDelimitedFieldEvaluator(toStringEvaluator(subjectEvaluator),
toWholeNumberEvaluator(argEvaluators.get(0), "first argument of getDelimitedField"),
toStringEvaluator(argEvaluators.get(1), "second argument of getDelimitedField")),
"getDelimitedField");
} else if (argEvaluators.size() == 3) {
// 3 arguments - index, delimiter, quote char.
return addToken(new GetDelimitedFieldEvaluator(toStringEvaluator(subjectEvaluator),
toWholeNumberEvaluator(argEvaluators.get(0), "first argument of getDelimitedField"),
toStringEvaluator(argEvaluators.get(1), "second argument of getDelimitedField"),
toStringEvaluator(argEvaluators.get(2), "third argument of getDelimitedField")),
"getDelimitedField");
} else if (argEvaluators.size() == 4) {
// 4 arguments - index, delimiter, quote char, escape char
return addToken(new GetDelimitedFieldEvaluator(toStringEvaluator(subjectEvaluator),
toWholeNumberEvaluator(argEvaluators.get(0), "first argument of getDelimitedField"),
toStringEvaluator(argEvaluators.get(1), "second argument of getDelimitedField"),
toStringEvaluator(argEvaluators.get(2), "third argument of getDelimitedField"),
toStringEvaluator(argEvaluators.get(3), "fourth argument of getDelimitedField")),
"getDelimitedField");
} else {
// 5 arguments - index, delimiter, quote char, escape char, strip escape/quote chars flag
return addToken(new GetDelimitedFieldEvaluator(toStringEvaluator(subjectEvaluator),
toWholeNumberEvaluator(argEvaluators.get(0), "first argument of getDelimitedField"),
toStringEvaluator(argEvaluators.get(1), "second argument of getDelimitedField"),
toStringEvaluator(argEvaluators.get(2), "third argument of getDelimitedField"),
toStringEvaluator(argEvaluators.get(3), "fourth argument of getDelimitedField"),
toBooleanEvaluator(argEvaluators.get(4), "fifth argument of getDelimitedField")),
"getDelimitedField");
}
}
case JSON_PATH: {
verifyArgCount(argEvaluators, 1, "jsonPath");
return addToken(new JsonPathEvaluator(toStringEvaluator(subjectEvaluator),
toStringEvaluator(argEvaluators.get(0), "first argument to jsonPath")), "jsonPath");
}
case JSON_PATH_DELETE: {
verifyArgCount(argEvaluators, 1, "jsonPathDelete");
return addToken(new JsonPathDeleteEvaluator(toStringEvaluator(subjectEvaluator),
toStringEvaluator(argEvaluators.get(0), "first argument to jsonPathDelete")), "jsonPathDelete");
}
case JSON_PATH_SET: {
verifyArgCount(argEvaluators, 2, "jsonPathSet");
Evaluator<?> argValueEvaluator = argEvaluators.get(1);
String location = "second argument to jsonPathSet";
Evaluator<?> valueEvaluator = getJsonPathUpdateEvaluator(argValueEvaluator, location);
return addToken(new JsonPathSetEvaluator(toStringEvaluator(subjectEvaluator),
toStringEvaluator(argEvaluators.get(0), "first argument to jsonPathSet"),
valueEvaluator), "jsonPathSet");
}
case JSON_PATH_ADD: {
verifyArgCount(argEvaluators, 2, "jsonPathAdd");
Evaluator<?> argValueEvaluator = argEvaluators.get(1);
String location = "second argument to jsonPathAdd";
Evaluator<?> valueEvaluator = getJsonPathUpdateEvaluator(argValueEvaluator, location);
return addToken(new JsonPathAddEvaluator(toStringEvaluator(subjectEvaluator),
toStringEvaluator(argEvaluators.get(0), "first argument to jsonPathAdd"),
valueEvaluator), "jsonPathAdd");
}
case JSON_PATH_PUT: {
verifyArgCount(argEvaluators, 3, "jsonPathPut");
Evaluator<?> argValueEvaluator = argEvaluators.get(1);
String valueLocation = "second argument to jsonPathPut";
Evaluator<?> valueEvaluator = getJsonPathUpdateEvaluator(argValueEvaluator, valueLocation);
Evaluator<?> argKeyEvaluator = argEvaluators.get(2);
String keyLocation = "third argument to jsonPathPut";
Evaluator<?> keyEvaluator = getJsonPathUpdateEvaluator(argKeyEvaluator, keyLocation);
return addToken(new JsonPathPutEvaluator(toStringEvaluator(subjectEvaluator),
toStringEvaluator(argEvaluators.get(0), "first argument to jsonPathPut"),
toStringEvaluator(keyEvaluator, keyLocation),
valueEvaluator), "jsonPathPut");
}
case UUID3: {
verifyArgCount(argEvaluators, 1, "UUID3");
return addToken(new Uuid3Evaluator(toStringEvaluator(subjectEvaluator),
toStringEvaluator(argEvaluators.get(0), "first argument to UUID3")), "UUID3");
}
case UUID5: {
verifyArgCount(argEvaluators, 1, "UUID5");
return addToken(new Uuid5Evaluator(toStringEvaluator(subjectEvaluator),
toStringEvaluator(argEvaluators.get(0), "first argument to UUID5")), "UUID5");
}
case IF_ELSE: {
verifyArgCount(argEvaluators, 2, "ifElse");
return addToken(new IfElseEvaluator(toBooleanEvaluator(subjectEvaluator),
toStringEvaluator(argEvaluators.get(0), "argument to return if true"),
toStringEvaluator(argEvaluators.get(1), "argument to return if false")), "ifElse");
}
default:
throw new AttributeExpressionLanguageParsingException("Expected a Function-type expression but got " + tree.toString());
}
}