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

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