## Predicates

### Overview

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`.

### Syntax

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.

### Operators

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`).

### Examples

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>

### Conjunctions

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>