InExRules (Jodd API Documentation)

java.lang.Object
- jodd.util.InExRules<T,R>

All Implemented Interfaces:

InExRuleMatcher<T,R>
```
public class InExRules<T,R>
extends java.lang.Object
implements InExRuleMatcher<T,R>
```
One-class rule engine for includes/excludes logic. It can be used when set of objects has to filtered using includes and excludes rules. For example, when filtering files by file name etc.
Rule engine works in one of two modes:
- blacklist - when any input is allowed by default and when you specify explicit excludes.
- whitelist - when any input is disabled by default and when you specify explicit includes.
The logic of this rule engine depends on the current mode. In both cases, always the inverse rules are considered first. For example, for blacklist mode, engine first examine excludes, and then includes. This way you can set any filter combination.
All Jodd classes that filters something uses this class to unify the behavior across the Jodd library.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class InExRules.Rule<R>
Rule definition.

Nested Classes
Modifier and Type	Class and Description
`static class`	`InExRules.Rule<R>` Rule definition.

Field Summary

Fields
Modifier and Type	Field and Description
`protected boolean`	`blacklist`
`protected int`	`excludesCount`
`protected int`	`includesCount`
`protected InExRuleMatcher<T,R>`	`inExRuleMatcher`
`protected java.util.List<InExRules.Rule<R>>`	`rules`

Fields inherited from interface jodd.util.InExRuleMatcher
WILDCARD_PATH_RULE_MATCHER, WILDCARD_RULE_MATCHER

Constructor Summary

Constructors
Constructor and Description

InExRules()
Creates default instance.

InExRules(InExRuleMatcher<T,R> inExRuleMatcher)
Creates instance that uses provided matcher.

Constructors
Constructor and Description
`InExRules()` Creates default instance.
`InExRules(InExRuleMatcher<T,R> inExRuleMatcher)` Creates instance that uses provided matcher.

Method Summary

Methods
Modifier and Type	Method and Description
`boolean`	`accept(T value, R rule, boolean include)` Matches value against single rule.
`protected void`	`addRule(R rule, boolean include)` Adds a rule.
`boolean`	`apply(T value, boolean flag)` Applies rules on given flag using current black/white list mode.
`boolean`	`apply(T value, boolean blacklist, boolean flag)` Applies rules on given flag.
`void`	`blacklist()` Enables blacklist mode - everything is included by default, and user sets explicit excludes.
`void`	`exclude(R rule)` Adds exclude rule.
`R`	`getRule(int index)` Returns rule's value on given index.
`boolean`	`hasRules()` Returns `true` if rule engine has at least one rule set.
`void`	`include(R rule)` Adds include rule.
`boolean`	`isBlacklist()` Returns `true` if blacklist mode is set.
`boolean`	`isWhitelist()` Returns `true` if whitelist mode is set.
`boolean`	`match(T value)` Matches value against the set of rules using current white/black list mode.
`boolean`	`match(T value, boolean blacklist)` Matches value against the set of rules using provided white/black list mode.
`protected boolean`	`processExcludes(T value, boolean include)` Process excludes rules.
`protected boolean`	`processIncludes(T value, boolean include)` Process includes rules.
`void`	`reset()` Resets all the rules in this rule engine.
`void`	`smartMode()` Sets blacklist or whitelist mode depending on rules.
`int`	`totalExcludeRules()` Returns total number of exclude rules.
`int`	`totalIncludeRules()` Returns total number of include rules.
`int`	`totalRules()` Returns total number of all rules.
`void`	`whitelist()` Enables whitelist mode - everything is excluded by default, and user set explicit includes.

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

- Field Detail
  - rules
```
protected java.util.List<InExRules.Rule<R>> rules
```
  - inExRuleMatcher
```
protected final InExRuleMatcher<T,R> inExRuleMatcher
```
  - includesCount
```
protected int includesCount
```
  - excludesCount
```
protected int excludesCount
```
  - blacklist
```
protected boolean blacklist
```
- Constructor Detail
  - InExRules
```
public InExRules()
```
    Creates default instance.
  - InExRules
```
public InExRules(InExRuleMatcher<T,R> inExRuleMatcher)
```
    Creates instance that uses provided matcher.
- Method Detail
  - totalRules
```
public int totalRules()
```
    Returns total number of all rules.
  - totalIncludeRules
```
public int totalIncludeRules()
```
    Returns total number of include rules.
  - totalExcludeRules
```
public int totalExcludeRules()
```
    Returns total number of exclude rules.
  - hasRules
```
public boolean hasRules()
```
    Returns true if rule engine has at least one rule set.
  - getRule
```
public R getRule(int index)
```
    Returns rule's value on given index.
  - reset
```
public void reset()
```
    Resets all the rules in this rule engine.
  - blacklist
```
public void blacklist()
```
    Enables blacklist mode - everything is included by default, and user sets explicit excludes.
  - isBlacklist
```
public boolean isBlacklist()
```
    Returns true if blacklist mode is set.
  - whitelist
```
public void whitelist()
```
    Enables whitelist mode - everything is excluded by default, and user set explicit includes.
  - isWhitelist
```
public boolean isWhitelist()
```
    Returns true if whitelist mode is set.
  - smartMode
```
public void smartMode()
```
    Sets blacklist or whitelist mode depending on rules. Smart mode determines the following:
    - If there are only include rules, then the whitelist mode is set.
    - If there are only excluded rules, then the blacklist mode is set.
    - In any other case (both type of rules exist or no rules are set), then mode is not changed.
    Should be called after all the rules are set, before matching starts.
  - include
```
public void include(R rule)
```
    Adds include rule.
  - exclude
```
public void exclude(R rule)
```
    Adds exclude rule.
  - addRule
```
protected void addRule(R rule,
           boolean include)
```
    Adds a rule. Duplicates are not allowed and will be ignored.
  - match
```
public boolean match(T value)
```
    Matches value against the set of rules using current white/black list mode.
  - match
```
public boolean match(T value,
            boolean blacklist)
```
    Matches value against the set of rules using provided white/black list mode.
  - apply
```
public boolean apply(T value,
            boolean flag)
```
    Applies rules on given flag using current black/white list mode.
    
    See Also:
    apply(Object, boolean, boolean)
  - apply
```
public boolean apply(T value,
            boolean blacklist,
            boolean flag)
```
    Applies rules on given flag. Flag is only changed if at least one rule matched. Otherwise, the same value is returned. This way you can chain several rules and have the rule engine change the flag only when a rule is matched.
  - processIncludes
```
protected boolean processIncludes(T value,
                      boolean include)
```
    Process includes rules.
  - processExcludes
```
protected boolean processExcludes(T value,
                      boolean include)
```
    Process excludes rules.
  - accept
```
public boolean accept(T value,
             R rule,
             boolean include)
```
    Matches value against single rule. By default performs equals on value against the rule.
    
    Specified by:
    
    accept in interface InExRuleMatcher<T,R>

Class InExRules<T,R>

Nested Class Summary

Field Summary

Fields inherited from interface jodd.util.InExRuleMatcher

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

rules

inExRuleMatcher

includesCount

excludesCount

blacklist

Constructor Detail

InExRules

InExRules

Method Detail

totalRules

totalIncludeRules

totalExcludeRules

hasRules

getRule

reset

blacklist

isBlacklist

whitelist

isWhitelist

smartMode

include

exclude

addRule

match

match

apply

apply

processIncludes

processExcludes

accept