ValidationRule (painless-java-validator 2.0.0 API)

java.lang.Object
- com.github.danitutu.painlessjavavalidator.ValidationRule

public class ValidationRule
extends Object

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static <T> ViolationProvider`	`after(String field, Comparable<T> value, T other)` Checks if the compared value is strictly after the other.
`static <T> ViolationProvider`	`afterOrEqualsTo(String field, Comparable<T> value, T other)` Checks if the compared value is after or equals to the other.
`static <T> Optional<Violation>`	`afterOrEqualsToRule(String field, Comparable<T> value, T other)` See `afterOrEqualsTo(String, Comparable, Object)`
`static <T> Optional<Violation>`	`afterRule(String field, Comparable<T> value, T other)` See `after(String, Comparable, Object)`
`static <T> ViolationProvider`	`before(String field, Comparable<T> value, T other)` Checks if the compared value is strictly before the other.
`static <T> ViolationProvider`	`beforeOrEqualsTo(String field, Comparable<T> value, T other)` Checks if the compared value is before or equals to the other.
`static <T> Optional<Violation>`	`beforeOrEqualsToRule(String field, Comparable<T> value, T other)` See `beforeOrEqualsTo(String, Comparable, Object)`
`static <T> Optional<Violation>`	`beforeRule(String field, Comparable<T> value, T other)` See `before(String, Comparable, Object)`
`static ViolationProvider`	`blank(String field, CharSequence value)` Checks if the value is blank.
`static Optional<Violation>`	`blankRule(String field, CharSequence value)` See `blank(String, CharSequence)`
`static <T> ViolationProvider`	`compareComparable(Comparable<T> value, T other, BiPredicate<Comparable<T>,T> compareFunc, Supplier<Violation> violationFunc)`
`static <T> Optional<Violation>`	`compareComparableRule(Comparable<T> value, T other, BiPredicate<Comparable<T>,T> compareFunc, Supplier<Violation> violationFunc)` Returns violation in case compare function is true.
`static ViolationProvider`	`compareStrings(String value, String other, BiPredicate<String,String> compareFunc, Supplier<Violation> violationFunc)` Compares the two string against a provided rule.
`static Optional<Violation>`	`compareStringsRule(String value, String other, BiPredicate<String,String> compareFunc, Supplier<Violation> violationFunc)` Returns violation in case compare function is true.
`static ViolationProvider`	`empty(String field, CharSequence value)` Checks if the value is empty.
`static Optional<Violation>`	`emptyRule(String field, CharSequence value)` See `empty(String, CharSequence)`
`static <T> ViolationProvider`	`equalsTo(String field, Comparable<T> value, T other)` Checks if the compared value equals the other.
`static ViolationProvider`	`equalsTo(String field, String value, String other)` Checks if the compared value equals the other.
`static <T> Optional<Violation>`	`equalsToRule(String field, Comparable<T> value, T other)` See `equalsTo(String, Comparable, Object)`
`static Optional<Violation>`	`equalsToRule(String field, String value, String other)` See `equalsTo(String, String, String)`
`static ViolationProvider`	`inRange(String field, Integer value, int min, int max)` Checks if the value is between or equals to one of the two limits.
`static Optional<Violation>`	`inRangeRule(String field, Integer value, int min, int max)` See `inRange(String, Integer, int, int)`
`static ViolationProvider`	`isFalse(BooleanSupplier condition, Violation violation)` Checks if the condition is evaluated to false.
`static Optional<Violation>`	`isFalseRule(BooleanSupplier condition, Supplier<Violation> violation)` See `isFalse(BooleanSupplier, Violation)`
`static Optional<Violation>`	`isFalseRule(BooleanSupplier condition, Violation violation)` See `isFalse(BooleanSupplier, Violation)`
`static ViolationProvider`	`isNull(String field, Object value)` Checks if the value is null.
`static Optional<Violation>`	`isNullRule(String field, Object value)` See `isNull(String, Object)`
`static ViolationProvider`	`isTrue(BooleanSupplier condition, Violation violation)` Checks if the condition is evaluated to true.
`static Optional<Violation>`	`isTrueRule(BooleanSupplier condition, Supplier<Violation> violation)` See `isTrue(BooleanSupplier, Violation)`
`static Optional<Violation>`	`isTrueRule(BooleanSupplier condition, Violation violation)` See `isTrue(BooleanSupplier, Violation)`
`static ViolationProvider`	`lengthBetween(String field, CharSequence value, int min, int max)` Checks if the value has the length between or equals to one of two limits.
`static Optional<Violation>`	`lengthBetweenRule(String field, CharSequence value, int min, int max)` See `lengthBetween(String, CharSequence, int, int)`
`static ViolationProvider`	`matchRegex(String field, String value, String regex)` Checks if the value matches the provided regex.
`static Optional<Violation>`	`matchRegexRule(String field, String value, String regex)` See `matchRegex(String, String, String)`
`static ViolationProvider`	`max(String field, Integer value, int max)` Checks if the value is smaller than or equals to the provided superior limit.
`static Optional<Violation>`	`maxRule(String field, Integer value, int max)` See `max(String, Integer, int)`
`static ViolationProvider`	`min(String field, Integer value, int min)` Checks if the value is grater than or equals to the provided inferior limit.
`static Optional<Violation>`	`minRule(String field, Integer value, int min)` See `min(String, Integer, int)`
`static ViolationProvider`	`negative(String field, BigDecimal value)`
`static ViolationProvider`	`negative(String field, BigInteger value)`
`static ViolationProvider`	`negative(String field, Double value)`
`static ViolationProvider`	`negative(String field, Float value)`
`static ViolationProvider`	`negative(String field, Integer value)`
`static ViolationProvider`	`negative(String field, Long value)`
`static ViolationProvider`	`negativeOrZero(String field, BigDecimal value)`
`static ViolationProvider`	`negativeOrZero(String field, BigInteger value)`
`static ViolationProvider`	`negativeOrZero(String field, Double value)`
`static ViolationProvider`	`negativeOrZero(String field, Float value)`
`static ViolationProvider`	`negativeOrZero(String field, Integer value)`
`static ViolationProvider`	`negativeOrZero(String field, Long value)`
`static Optional<Violation>`	`negativeOrZeroRule(String field, BigDecimal value)`
`static Optional<Violation>`	`negativeOrZeroRule(String field, BigInteger value)`
`static Optional<Violation>`	`negativeOrZeroRule(String field, Double value)`
`static Optional<Violation>`	`negativeOrZeroRule(String field, Float value)`
`static Optional<Violation>`	`negativeOrZeroRule(String field, Integer value)`
`static Optional<Violation>`	`negativeOrZeroRule(String field, Long value)`
`static Optional<Violation>`	`negativeRule(String field, BigDecimal value)`
`static Optional<Violation>`	`negativeRule(String field, BigInteger value)`
`static Optional<Violation>`	`negativeRule(String field, Double value)`
`static Optional<Violation>`	`negativeRule(String field, Float value)`
`static Optional<Violation>`	`negativeRule(String field, Integer value)`
`static Optional<Violation>`	`negativeRule(String field, Long value)`
`static ViolationProvider`	`notBlank(String field, CharSequence value)` Checks if the value is not blank.
`static Optional<Violation>`	`notBlankRule(String field, CharSequence value)` See `notBlank(String, CharSequence)`
`static ViolationProvider`	`notEmpty(String field, CharSequence value)` Checks if the value is not empty.
`static Optional<Violation>`	`notEmptyRule(String field, CharSequence value)` See `notEmpty(String, CharSequence)`
`static ViolationProvider`	`notEqualsTo(String field, String value, String other)` Checks if the compared value is not equal to the other.
`static Optional<Violation>`	`notEqualsToRule(String field, String value, String other)` See `notEqualsTo(String, String, String)`
`static ViolationProvider`	`notNull(String field, Object value)` Checks if the value is not null.
`static Optional<Violation>`	`notNullRule(String field, Object value)` See `notNull(String, Object)`
`static ViolationProvider`	`positive(String field, BigDecimal value)`
`static ViolationProvider`	`positive(String field, BigInteger value)`
`static ViolationProvider`	`positive(String field, Double value)`
`static ViolationProvider`	`positive(String field, Float value)`
`static ViolationProvider`	`positive(String field, Integer value)`
`static ViolationProvider`	`positive(String field, Long value)`
`static ViolationProvider`	`positiveOrZero(String field, BigDecimal value)`
`static ViolationProvider`	`positiveOrZero(String field, BigInteger value)`
`static ViolationProvider`	`positiveOrZero(String field, Double value)`
`static ViolationProvider`	`positiveOrZero(String field, Float value)`
`static ViolationProvider`	`positiveOrZero(String field, Integer value)`
`static ViolationProvider`	`positiveOrZero(String field, Long value)`
`static Optional<Violation>`	`positiveOrZeroRule(String field, BigDecimal value)`
`static Optional<Violation>`	`positiveOrZeroRule(String field, BigInteger value)`
`static Optional<Violation>`	`positiveOrZeroRule(String field, Double value)`
`static Optional<Violation>`	`positiveOrZeroRule(String field, Float value)`
`static Optional<Violation>`	`positiveOrZeroRule(String field, Integer value)`
`static Optional<Violation>`	`positiveOrZeroRule(String field, Long value)`
`static Optional<Violation>`	`positiveRule(String field, BigDecimal value)`
`static Optional<Violation>`	`positiveRule(String field, BigInteger value)`
`static Optional<Violation>`	`positiveRule(String field, Double value)`
`static Optional<Violation>`	`positiveRule(String field, Float value)`
`static Optional<Violation>`	`positiveRule(String field, Integer value)`
`static Optional<Violation>`	`positiveRule(String field, Long value)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

isNull

public static ViolationProvider isNull(String field,
                                       Object value)

Checks if the value is null.

Parameters:: field - path to field; value - value to be checked
Returns:: violation or success

isNullRule

public static Optional<Violation> isNullRule(String field,
                                             Object value)

See isNull(String, Object)

isTrueRule

public static Optional<Violation> isTrueRule(BooleanSupplier condition,
                                             Violation violation)

See isTrue(BooleanSupplier, Violation)

notNull

public static ViolationProvider notNull(String field,
                                        Object value)

Checks if the value is not null.

Parameters:: field - path to field; value - value to be checked
Returns:: violation or success

notNullRule

public static Optional<Violation> notNullRule(String field,
                                              Object value)

See notNull(String, Object)

empty

public static ViolationProvider empty(String field,
                                      CharSequence value)

Checks if the value is empty.

Parameters:: field - path to field; value - value to be checked
Returns:: violation or success

emptyRule

public static Optional<Violation> emptyRule(String field,
                                            CharSequence value)

See empty(String, CharSequence)

isTrue
```
public static ViolationProvider isTrue(BooleanSupplier condition,
                                       Violation violation)
```
Checks if the condition is evaluated to true. If not then the violation will be returned.

Parameters:

condition - condition

violation - violation

Returns:

violation or success

Throws:

IllegalArgumentException - in case condition or violation is null

isFalse
```
public static ViolationProvider isFalse(BooleanSupplier condition,
                                        Violation violation)
```
Checks if the condition is evaluated to false. If not then the violation will be returned.

Parameters:

condition - condition

violation - violation

Returns:

violation or success

Throws:

IllegalArgumentException - in case condition or violation is null

isFalseRule

public static Optional<Violation> isFalseRule(BooleanSupplier condition,
                                              Violation violation)

See isFalse(BooleanSupplier, Violation)

notEmpty

public static ViolationProvider notEmpty(String field,
                                         CharSequence value)

Checks if the value is not empty.

Parameters:: field - path to field; value - value to be checked
Returns:: violation or success

notEmptyRule

public static Optional<Violation> notEmptyRule(String field,
                                               CharSequence value)

See notEmpty(String, CharSequence)

blank
```
public static ViolationProvider blank(String field,
                                      CharSequence value)
```
Checks if the value is blank. Blank field means null, empty string or string with blanks.

Parameters:

field - path to field

value - value to be checked

Returns:

violation or success

blankRule

public static Optional<Violation> blankRule(String field,
                                            CharSequence value)

See blank(String, CharSequence)

notBlank
```
public static ViolationProvider notBlank(String field,
                                         CharSequence value)
```
Checks if the value is not blank. Blank field means null, empty string or string with blanks.

Parameters:

field - path to field

value - value to be checked

Returns:

violation or success

notBlankRule

public static Optional<Violation> notBlankRule(String field,
                                               CharSequence value)

See notBlank(String, CharSequence)

lengthBetween
```
public static ViolationProvider lengthBetween(String field,
                                              CharSequence value,
                                              int min,
                                              int max)
```
Checks if the value has the length between or equals to one of two limits. The limits can be equal. If the value is null then no violation is returned.

Parameters:

field - path to field

value - value to be checked

min - inferior limit

max - superior limit

Returns:

violation or success

Throws:

IllegalArgumentException - if min is greater than max.

lengthBetweenRule

public static Optional<Violation> lengthBetweenRule(String field,
                                                    CharSequence value,
                                                    int min,
                                                    int max)

See lengthBetween(String, CharSequence, int, int)

isTrueRule

public static Optional<Violation> isTrueRule(BooleanSupplier condition,
                                             Supplier<Violation> violation)

See isTrue(BooleanSupplier, Violation)

Parameters:: violation - violation provider

matchRegex

public static ViolationProvider matchRegex(String field,
                                           String value,
                                           String regex)

Checks if the value matches the provided regex. If the value is null then no violation is returned.

Parameters:: field - path to field; value - value to be checked; regex - a valid regex pattern
Returns:: violation or success

matchRegexRule

public static Optional<Violation> matchRegexRule(String field,
                                                 String value,
                                                 String regex)

See matchRegex(String, String, String)

inRange
```
public static ViolationProvider inRange(String field,
                                        Integer value,
                                        int min,
                                        int max)
```
Checks if the value is between or equals to one of the two limits. The limits can be equal. If the value is null then no violation is returned.

Parameters:

field - path to field

value - value to be checked

min - inferior limit

max - superior limit

Returns:

violation or success

Throws:

IllegalArgumentException - if min is greater than max.

inRangeRule

public static Optional<Violation> inRangeRule(String field,
                                              Integer value,
                                              int min,
                                              int max)

See inRange(String, Integer, int, int)

min
```
public static ViolationProvider min(String field,
                                    Integer value,
                                    int min)
```
Checks if the value is grater than or equals to the provided inferior limit. If the value is null then no violation is returned.

Parameters:

field - path to field

value - value to be checked

min - inferior limit

Returns:

violation or success

minRule

public static Optional<Violation> minRule(String field,
                                          Integer value,
                                          int min)

See min(String, Integer, int)

positiveOrZero

public static ViolationProvider positiveOrZero(String field,
                                               BigDecimal value)

positiveOrZeroRule

public static Optional<Violation> positiveOrZeroRule(String field,
                                                     BigDecimal value)

positiveOrZero

public static ViolationProvider positiveOrZero(String field,
                                               BigInteger value)

positiveOrZeroRule

public static Optional<Violation> positiveOrZeroRule(String field,
                                                     BigInteger value)

positiveOrZero

public static ViolationProvider positiveOrZero(String field,
                                               Double value)

positiveOrZeroRule

public static Optional<Violation> positiveOrZeroRule(String field,
                                                     Double value)

positiveOrZero

public static ViolationProvider positiveOrZero(String field,
                                               Float value)

positiveOrZeroRule

public static Optional<Violation> positiveOrZeroRule(String field,
                                                     Float value)

positiveOrZero

public static ViolationProvider positiveOrZero(String field,
                                               Long value)

positiveOrZeroRule

public static Optional<Violation> positiveOrZeroRule(String field,
                                                     Long value)

positiveOrZero

public static ViolationProvider positiveOrZero(String field,
                                               Integer value)

positiveOrZeroRule

public static Optional<Violation> positiveOrZeroRule(String field,
                                                     Integer value)

positive

public static ViolationProvider positive(String field,
                                         BigDecimal value)

positiveRule

public static Optional<Violation> positiveRule(String field,
                                               BigDecimal value)

positive

public static ViolationProvider positive(String field,
                                         BigInteger value)

positiveRule

public static Optional<Violation> positiveRule(String field,
                                               BigInteger value)

positive

public static ViolationProvider positive(String field,
                                         Double value)

positiveRule

public static Optional<Violation> positiveRule(String field,
                                               Double value)

positive

public static ViolationProvider positive(String field,
                                         Float value)

positiveRule

public static Optional<Violation> positiveRule(String field,
                                               Float value)

positive

public static ViolationProvider positive(String field,
                                         Long value)

positiveRule

public static Optional<Violation> positiveRule(String field,
                                               Long value)

positive

public static ViolationProvider positive(String field,
                                         Integer value)

positiveRule

public static Optional<Violation> positiveRule(String field,
                                               Integer value)

negativeOrZero

public static ViolationProvider negativeOrZero(String field,
                                               BigDecimal value)

negativeOrZeroRule

public static Optional<Violation> negativeOrZeroRule(String field,
                                                     BigDecimal value)

negativeOrZero

public static ViolationProvider negativeOrZero(String field,
                                               BigInteger value)

negativeOrZeroRule

public static Optional<Violation> negativeOrZeroRule(String field,
                                                     BigInteger value)

negativeOrZero

public static ViolationProvider negativeOrZero(String field,
                                               Double value)

negativeOrZeroRule

public static Optional<Violation> negativeOrZeroRule(String field,
                                                     Double value)

negativeOrZero

public static ViolationProvider negativeOrZero(String field,
                                               Float value)

negativeOrZeroRule

public static Optional<Violation> negativeOrZeroRule(String field,
                                                     Float value)

negativeOrZero

public static ViolationProvider negativeOrZero(String field,
                                               Long value)

negativeOrZeroRule

public static Optional<Violation> negativeOrZeroRule(String field,
                                                     Long value)

negativeOrZero

public static ViolationProvider negativeOrZero(String field,
                                               Integer value)

negativeOrZeroRule

public static Optional<Violation> negativeOrZeroRule(String field,
                                                     Integer value)

negative

public static ViolationProvider negative(String field,
                                         BigDecimal value)

negativeRule

public static Optional<Violation> negativeRule(String field,
                                               BigDecimal value)

negative

public static ViolationProvider negative(String field,
                                         BigInteger value)

negativeRule

public static Optional<Violation> negativeRule(String field,
                                               BigInteger value)

negative

public static ViolationProvider negative(String field,
                                         Double value)

negativeRule

public static Optional<Violation> negativeRule(String field,
                                               Double value)

negative

public static ViolationProvider negative(String field,
                                         Float value)

negativeRule

public static Optional<Violation> negativeRule(String field,
                                               Float value)

negative

public static ViolationProvider negative(String field,
                                         Long value)

negativeRule

public static Optional<Violation> negativeRule(String field,
                                               Long value)

negative

public static ViolationProvider negative(String field,
                                         Integer value)

negativeRule

public static Optional<Violation> negativeRule(String field,
                                               Integer value)

max
```
public static ViolationProvider max(String field,
                                    Integer value,
                                    int max)
```
Checks if the value is smaller than or equals to the provided superior limit. If the value is null then no violation is returned.

Parameters:

field - path to field

value - value to be checked

max - superior limit

Returns:

violation or success

maxRule

public static Optional<Violation> maxRule(String field,
                                          Integer value,
                                          int max)

See max(String, Integer, int)

after
```
public static <T> ViolationProvider after(String field,
                                          Comparable<T> value,
                                          T other)
```
Checks if the compared value is strictly after the other. If the value is null then no violation is returned.

Type Parameters:

T - compared object type

Parameters:

field - path to field

value - value to be checked

other - other value

Returns:

violation or success

afterRule

public static <T> Optional<Violation> afterRule(String field,
                                                Comparable<T> value,
                                                T other)

See after(String, Comparable, Object)

compareComparableRule

public static <T> Optional<Violation> compareComparableRule(Comparable<T> value,
                                                            T other,
                                                            BiPredicate<Comparable<T>,T> compareFunc,
                                                            Supplier<Violation> violationFunc)

Returns violation in case compare function is true. If the value is null then no violation is returned.

Parameters:: value - first value; other - second value; compareFunc - function that compares the two values; violationFunc - the Violation that will be returned
Returns:: violation or success

afterOrEqualsTo
```
public static <T> ViolationProvider afterOrEqualsTo(String field,
                                                    Comparable<T> value,
                                                    T other)
```
Checks if the compared value is after or equals to the other. If the value is null then no violation is returned.

Type Parameters:

T - compared object type

Parameters:

field - path to field

value - value to be checked

other - other value

Returns:

violation or success

afterOrEqualsToRule

public static <T> Optional<Violation> afterOrEqualsToRule(String field,
                                                          Comparable<T> value,
                                                          T other)

See afterOrEqualsTo(String, Comparable, Object)

before
```
public static <T> ViolationProvider before(String field,
                                           Comparable<T> value,
                                           T other)
```
Checks if the compared value is strictly before the other. If the value is null then no violation is returned.

Type Parameters:

T - compared object type

Parameters:

field - path to field

value - value to be checked

other - other value

Returns:

violation or success

beforeRule

public static <T> Optional<Violation> beforeRule(String field,
                                                 Comparable<T> value,
                                                 T other)

See before(String, Comparable, Object)

beforeOrEqualsTo
```
public static <T> ViolationProvider beforeOrEqualsTo(String field,
                                                     Comparable<T> value,
                                                     T other)
```
Checks if the compared value is before or equals to the other. If the value is null then no violation is returned.

Type Parameters:

T - compared object type

Parameters:

field - path to field

value - value to be checked

other - other value

Returns:

violation or success

beforeOrEqualsToRule

public static <T> Optional<Violation> beforeOrEqualsToRule(String field,
                                                           Comparable<T> value,
                                                           T other)

See beforeOrEqualsTo(String, Comparable, Object)

equalsTo
```
public static <T> ViolationProvider equalsTo(String field,
                                             Comparable<T> value,
                                             T other)
```
Checks if the compared value equals the other. If the value is null then no violation is returned.

Type Parameters:

T - compared object type

Parameters:

field - path to field

value - value to be checked

other - other value

Returns:

violation or success

equalsToRule

public static <T> Optional<Violation> equalsToRule(String field,
                                                   Comparable<T> value,
                                                   T other)

See equalsTo(String, Comparable, Object)

equalsTo

public static ViolationProvider equalsTo(String field,
                                         String value,
                                         String other)

Checks if the compared value equals the other. If the value is null then no violation is returned.

Parameters:: field - path to field; value - value to be checked; other - other value
Returns:: violation or success

equalsToRule

public static Optional<Violation> equalsToRule(String field,
                                               String value,
                                               String other)

See equalsTo(String, String, String)

compareStringsRule

public static Optional<Violation> compareStringsRule(String value,
                                                     String other,
                                                     BiPredicate<String,String> compareFunc,
                                                     Supplier<Violation> violationFunc)

Returns violation in case compare function is true. If the value is null then no violation is returned.

Parameters:: value - first value; other - second value; compareFunc - function that compares the two values; violationFunc - the Violation that will be returned
Returns:: violation or success

isFalseRule

public static Optional<Violation> isFalseRule(BooleanSupplier condition,
                                              Supplier<Violation> violation)

See isFalse(BooleanSupplier, Violation)

Parameters:: violation - violation provider

compareStrings

public static ViolationProvider compareStrings(String value,
                                               String other,
                                               BiPredicate<String,String> compareFunc,
                                               Supplier<Violation> violationFunc)

Compares the two string against a provided rule. If the validation rule is evaluated to true then the provided violation will be returned.

Parameters:: value - value to be checked; other - other value; compareFunc - comparison function; violationFunc - violation to be retrieved when compareFunc evaluates to true
Returns:: violation or success

notEqualsTo

public static ViolationProvider notEqualsTo(String field,
                                            String value,
                                            String other)

Checks if the compared value is not equal to the other. If the value is null then no violation is returned.

Parameters:: field - path to field; value - value to be checked; other - other value
Returns:: violation or success

notEqualsToRule

public static Optional<Violation> notEqualsToRule(String field,
                                                  String value,
                                                  String other)

See notEqualsTo(String, String, String)

compareComparable

public static <T> ViolationProvider compareComparable(Comparable<T> value,
                                                      T other,
                                                      BiPredicate<Comparable<T>,T> compareFunc,
                                                      Supplier<Violation> violationFunc)

Class ValidationRule

Method Summary

Methods inherited from class java.lang.Object

Method Detail

isNull

isNullRule

isTrueRule

notNull

notNullRule

empty

emptyRule

isTrue

isFalse

isFalseRule

notEmpty

notEmptyRule

blank

blankRule

notBlank

notBlankRule

lengthBetween

lengthBetweenRule

isTrueRule

matchRegex

matchRegexRule

inRange

inRangeRule

min

minRule

positiveOrZero

positiveOrZeroRule

positiveOrZero

positiveOrZeroRule

positiveOrZero

positiveOrZeroRule

positiveOrZero

positiveOrZeroRule

positiveOrZero

positiveOrZeroRule

positiveOrZero

positiveOrZeroRule

positive

positiveRule

positive

positiveRule

positive

positiveRule

positive

positiveRule

positive

positiveRule

positive

positiveRule

negativeOrZero

negativeOrZeroRule

negativeOrZero

negativeOrZeroRule

negativeOrZero

negativeOrZeroRule

negativeOrZero

negativeOrZeroRule

negativeOrZero

negativeOrZeroRule

negativeOrZero

negativeOrZeroRule

negative

negativeRule

negative

negativeRule

negative

negativeRule

negative

negativeRule

negative

negativeRule

negative

negativeRule

max

maxRule

after