RewriteCond (Apache Tomcat 8.5.57 API Documentation)

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 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 and Description
    `RewriteCond()`

  - ### Method Summary

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

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

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

Copyright © 2000-2020 Apache Software Foundation. All Rights Reserved.