You can construct predicates by testing expressions for equality. For example, the
predicate, simple("${header.timeOfDay} == '14:30'")
, tests
whether the timeOfDay
header in the incoming message is equal to
14:30
.
You can also test various parts of an exchange (headers, message body, and so on) using simple predicates. Simple predicates have the following general syntax:
${LHSVariable
}Op
RHSValue
Where the variable on the left hand side, LHSVariable
, is one
of the variables shown in Table 10, “Simple language variable” and the value on the right
hand side, RHSValue
, is one of the following:
Another variable,
${
RHSVariable
}
.
A string literal, enclosed in single quotes, ' '
.
A string literal, not enclosed in quotes (no spaces allowed).
A numeric constant.
The null object, null
.
The simple language always attempts to convert the RHS value to the type of the LHS value.
The complete set of operators for simple language predicates is shown in Table 11, “Simple language operators”.
Table 11. Simple language operators
Operator | Description |
---|---|
== | Equals. |
> | Greater than. |
>= | Greater than or equals. |
< | Less than. |
<= | Less than or equals. |
!= | Not equal to. |
contains | Test if LHS string contains RHS string. |
not contains | Test if LHS string does not contain RHS string. |
regex | Test if LHS string matches RHS regular expression. |
not regex | Test if LHS string does not match RHS regular expression. |
in | Test if LHS string appears in the RHS comma-separated list. |
not in | Test if LHS string does not appear in the RHS comma-separated list. |
is | Test if LHS is an instance of RHS Java type (using Java instanceof
operator). |
not is | Test if LHS is not an instance of RHS Java type (using
Java instanceof operator). |
range | Test if LHS number lies in the RHS range (where range has the format,
min ... max ). |
not range | Test if LHS number does not lie in the RHS
range (where range has the format,
min ... max ). |
For example, you can perform simple string comparisons and numerical comparisons as follows:
<language language="simple">${in.header.user} == 'john'</language> <!-- Quotes are optional here --> <language language="simple">${in.header.user} == john</language> <language language="simple">${in.header.number} > 100</language> <!-- String literal can be converted to integer --> <language language="simple">${in.header.number} > '100'</language>
You can test whether the left hand side is a member of a comma-separated list, as follows:
<language language="simple">${in.header.type} not in 'gold,silver'</language>
You can test whether the left hand side matches a regular expression, as follows:
<language language="simple">${in.header.number} regex '\d{4}'</language>
You can test the type of the left hand side using the is
operator, as
follows:
<language language="simple">${in.header.type} is 'java.lang.String'</language> <!-- You can abbreviate java.lang. types --> <language language="simple">${in.header.type} is String</langauge>
You can test whether the left hand side lies in a specified numerical range, as follows:
<language language="simple">${in.header.number} range 100..199</language>
You can also combine predicates using the logical conjunctions, and
and or
. But these conjunctions are currently subject to the restriction
that a logical conjunction can appear only once in a simple
expression.
For example, here is an expression using the and
conjunction:
<language language="simple"> ${in.header.title} contains 'Camel' and ${in.header.type} == 'gold' </language>
And here is an expression using the or
conjunction:
<language language="simple"> ${in.header.title} contains 'Camel' or ${in.header.type} == 'gold' </langauge>