Package org.apache.catalina.valves.rewrite

# Class RewriteCond

java.lang.Object
org.apache.catalina.valves.rewrite.RewriteCond

public class RewriteCond extends Object

## Nested Class Summary

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

## Field Summary

Fields
Modifier and Type
Field
Description
`protected RewriteCond.Condition`
`condition`
`protected String`
`condPattern`
`protected String`
`flagsString`
`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
Description
`RewriteCond()`

## Method Summary

Modifier and Type
Method
Description
`boolean`
`evaluate(Matcher rule, Matcher cond, Resolver resolver)`
Evaluate the condition based on the context
`String`
`getCondPattern()`
`final String`
`getFlagsString()`
`Matcher`
`getMatcher()`
`String`
`getTestString()`
`boolean`
`isNocase()`
`boolean`
`isOrnext()`
`boolean`
`isPositive()`
`void`
`parse(Map<String,RewriteMap> maps)`
`void`
`setCondPattern(String condPattern)`
`final void`
`setFlagsString(String flagsString)`
`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 Details

### testString

protected String testString

### condPattern

protected String condPattern

### flagsString

protected String flagsString

### positive

protected boolean positive

### test

protected Substitution test

### condition

protected 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 Details

### RewriteCond

public RewriteCond()

## Method Details

### getCondPattern

public String getCondPattern()

### setCondPattern

public void setCondPattern(String condPattern)

### getTestString

public String getTestString()

### setTestString

public void setTestString(String testString)

### getFlagsString

public final String getFlagsString()

### setFlagsString

public final void setFlagsString(String flagsString)

### 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
  `resolver` - Property resolver
Returns:
  `true` if the condition matches

### 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)