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

Method Summary

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

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)