RewriteCond (Undertow 2.1.0.Final API)

java.lang.Object
- io.undertow.servlet.compat.rewrite.RewriteCond

```
public class RewriteCond
extends Object
```
Author:

Remy Maucherat

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`RewriteCond.Condition`
`static class`	`RewriteCond.LexicalCondition`
`static class`	`RewriteCond.PatternCondition`
`static class`	`RewriteCond.ResourceCondition`

Field Summary

Fields
Modifier and Type	Field and Description
`protected ThreadLocal<RewriteCond.Condition>`	`condition`
`protected String`	`condPattern`
`boolean`	`nocase` This makes the test case-insensitive, i.e., there is no difference between 'A-Z' and 'a-z' both in the expanded TestString and the CondPattern.
`boolean`	`ornext` Use this to combine rule conditions with a local OR instead of the implicit AND.
`protected boolean`	`positive`
`protected Substitution`	`test`
`protected String`	`testString`

Constructor Summary

Constructors
Constructor and Description

RewriteCond()

Constructors
Constructor and Description
`RewriteCond()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`evaluate(Matcher rule, Matcher cond, Resolver resolver)` Evaluate the condition based on the context
`String`	`getCondPattern()`
`Matcher`	`getMatcher()`
`String`	`getTestString()`
`boolean`	`isNocase()`
`boolean`	`isOrnext()`
`boolean`	`isPositive()`
`void`	`parse(Map<String,RewriteMap> maps)`
`void`	`setCondPattern(String condPattern)`
`void`	`setNocase(boolean nocase)`
`void`	`setOrnext(boolean ornext)`
`void`	`setPositive(boolean positive)`
`void`	`setTestString(String testString)`
`String`	`toString()` String representation.

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

Field Detail
- testString
```
protected String testString
```
- condPattern
```
protected String condPattern
```
- positive
```
protected boolean positive
```
- test
```
protected Substitution test
```
- condition
```
protected ThreadLocal<RewriteCond.Condition> condition
```
- nocase
```
public boolean nocase
```
  This makes the test case-insensitive, i.e., there is no difference between 'A-Z' and 'a-z' both in the expanded TestString and the CondPattern. This flag is effective only for comparisons between TestString and CondPattern. It has no effect on filesystem and subrequest checks.
- ornext
```
public boolean ornext
```
  Use this to combine rule conditions with a local OR instead of the implicit AND.

Constructor Detail
- RewriteCond
```
public RewriteCond()
```

Method Detail

getCondPattern
```
public String getCondPattern()
```

setCondPattern

public void setCondPattern(String condPattern)

getTestString
```
public String getTestString()
```

setTestString

public void setTestString(String testString)

parse

public void parse(Map<String,RewriteMap> maps)

getMatcher
```
public Matcher getMatcher()
```

toString
```
public String toString()
```
String representation.

Overrides:

toString in class Object

evaluate

public boolean evaluate(Matcher rule,
                        Matcher cond,
                        Resolver resolver)

Evaluate the condition based on the context

Parameters:: rule - corresponding matched rule; cond - last matched condition
Returns:

isNocase
```
public boolean isNocase()
```

setNocase

public void setNocase(boolean nocase)

isOrnext
```
public boolean isOrnext()
```

setOrnext

public void setOrnext(boolean ornext)

isPositive
```
public boolean isPositive()
```

setPositive

public void setPositive(boolean positive)

Class RewriteCond

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

testString

condPattern

positive

test

condition

nocase

ornext

Constructor Detail

RewriteCond

Method Detail

getCondPattern

setCondPattern

getTestString

setTestString

parse

getMatcher

toString

evaluate

isNocase

setNocase

isOrnext

setOrnext

isPositive

setPositive