Java Code Examples for java.util.regex.Pattern#CASE_INSENSITIVE

The following examples show how to use java.util.regex.Pattern#CASE_INSENSITIVE . These examples are extracted from open source projects. You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example 1
Source Project: otroslogviewer   File: RegexFilter.java    License: Apache License 2.0 6 votes vote down vote up
protected void performPreFiltering() {
  condition = getFilteringText();
  while (condition.startsWith(DOT_ALL_SUFFIX)) {
    condition = condition.substring(2);
  }
  while (condition.endsWith(DOT_ALL_SUFFIX)) {
    condition = condition.substring(0, condition.length() - 2);
  }
  patternOk = false;
  int flags = 0;
  if (isIgnoreCase()) {
    flags = Pattern.CASE_INSENSITIVE;
  }
  try {
    pattern = Pattern.compile(condition, flags);
    patternOk = true;
  } catch (PatternSyntaxException e) {
    textField.setBackground(Color.RED);
  }

}
 
Example 2
public void init(InputStream in) throws ConfigurationException {
  propertiesConfiguration = new PropertiesConfiguration();
  propertiesConfiguration.setDelimiterParsingDisabled(true);
  propertiesConfiguration.load(in, "UTF-8");
  configuration = new DataConfiguration(propertiesConfiguration);
  configuration.setDelimiterParsingDisabled(true);
  String pa = configuration.getString(PROP_PATTERN);
  int flags = 0;
  flags = flags | (configuration.getBoolean(PROP_PATTERN_CANON_EQ, false) ? Pattern.CANON_EQ : 0);
  flags = flags | (configuration.getBoolean(PROP_PATTERN_CASE_INSENSITIVE, false) ? Pattern.CASE_INSENSITIVE : 0);
  flags = flags | (configuration.getBoolean(PROP_PATTERN_COMMENTS, false) ? Pattern.COMMENTS : 0);
  flags = flags | (configuration.getBoolean(PROP_PATTERN_DOTALL, false) ? Pattern.DOTALL : 0);
  flags = flags | (configuration.getBoolean(PROP_PATTERN_LITERAL, false) ? Pattern.LITERAL : 0);
  flags = flags | (configuration.getBoolean(PROP_PATTERN_MULTILINE, false) ? Pattern.MULTILINE : 0);
  flags = flags | (configuration.getBoolean(PROP_PATTERN_UNICODE_CASE, false) ? Pattern.UNICODE_CASE : 0);
  flags = flags | (configuration.getBoolean(PROP_PATTERN_UNIX_LINES, false) ? Pattern.UNIX_LINES : 0);

  pattern = Pattern.compile(pa, flags);
  groupCount = countGroups(pattern);
  name = configuration.getString(PROP_NAME, "NAME NOT SET!");
  description = configuration.getString(PROP_DESCRIPTION, "DESCRIPTION NOT SET!");
  testMessage = configuration.getString(PROP_TEST_MESSAGE, "");

}
 
Example 3
Source Project: GeoTriples   File: FilterParser.java    License: Apache License 2.0 6 votes vote down vote up
private IdentifierMatcher parseRegex() throws ParseException {
	StringBuilder builder = new StringBuilder();
	index++;	// skip initial '/'
	while (!atEnd() && inRegex()) {
		builder.append(current());
		index++;
	}
	if (atEnd() || current() != '/') throw new ParseException("Unterminated regex: /" + builder.toString());
	index++;	// skip final '/'
	int flags = 0;
	while (!atEnd() && inFlags()) {
		if (current() == 'i') {
			flags |= Pattern.CASE_INSENSITIVE;
		}
		index++;
	}
	return Filter.createPatternMatcher(Pattern.compile(builder.toString(), flags));
}
 
Example 4
/**
 * Construct a validator that matches any one of the set of regular
 * expressions with the specified case sensitivity.
 * 
 * @param regexs
 *            The set of regular expressions this validator will validate
 *            against
 * @param caseSensitive
 *            when <code>true</code> matching is <i>case sensitive</i>,
 *            otherwise matching is <i>case in-sensitive</i>
 */
public RegexValidator(String[] regexs, boolean caseSensitive) {
	if (regexs == null || regexs.length == 0) {
		throw new IllegalArgumentException(
				"Regular expressions are missing");
	}
	patterns = new Pattern[regexs.length];
	int flags = (caseSensitive ? 0 : Pattern.CASE_INSENSITIVE);
	for (int i = 0; i < regexs.length; i++) {
		if (regexs[i] == null || regexs[i].length() == 0) {
			throw new IllegalArgumentException("Regular expression[" + i
					+ "] is missing");
		}
		patterns[i] = Pattern.compile(regexs[i], flags);
	}
}
 
Example 5
Source Project: consulo   File: IndexPattern.java    License: Apache License 2.0 6 votes vote down vote up
private void compilePattern() {
  try {
    int flags = 0;
    if (!myCaseSensitive) {
      flags = Pattern.CASE_INSENSITIVE;
    }
    myPattern = Pattern.compile(myPatternString, flags);
    String optimizedPattern = myPatternString;
    optimizedPattern = StringUtil.trimStart(optimizedPattern, ".*");
    myOptimizedIndexingPattern = Pattern.compile(optimizedPattern, flags);
  }
  catch (PatternSyntaxException e) {
    myPattern = null;
    myOptimizedIndexingPattern = null;
  }
}
 
Example 6
Source Project: commons-vfs   File: RegexFileFilter.java    License: Apache License 2.0 5 votes vote down vote up
/**
 * Construct a new regular expression filter with the specified flags case
 * sensitivity.
 *
 * @param pattern         regular string expression to match - Cannot be null
 * @param caseSensitivity how to handle case sensitivity, null means
 *                        case-sensitive
 */
public RegexFileFilter(final String pattern, final IOCase caseSensitivity) {
    if (pattern == null) {
        throw new IllegalArgumentException(PATTERN_IS_MISSING);
    }
    int flags = 0;
    if (caseSensitivity != null && !caseSensitivity.isCaseSensitive()) {
        flags = Pattern.CASE_INSENSITIVE;
    }
    this.pattern = Pattern.compile(pattern, flags);
}
 
Example 7
@Test
public void testStringPatternNullArgConstruction() {
    try {
        new RegexFileFilter((String) null, Pattern.CASE_INSENSITIVE);
        fail();
    } catch (final IllegalArgumentException ex) {
        Assert.assertEquals(RegexFileFilter.PATTERN_IS_MISSING, ex.getMessage());
    }
}
 
Example 8
Source Project: Elasticsearch   File: Regex.java    License: Apache License 2.0 5 votes vote down vote up
public static String flagsToString(int flags) {
    StringBuilder sb = new StringBuilder();
    if ((flags & Pattern.CASE_INSENSITIVE) != 0) {
        sb.append("CASE_INSENSITIVE|");
    }
    if ((flags & Pattern.MULTILINE) != 0) {
        sb.append("MULTILINE|");
    }
    if ((flags & Pattern.DOTALL) != 0) {
        sb.append("DOTALL|");
    }
    if ((flags & Pattern.UNICODE_CASE) != 0) {
        sb.append("UNICODE_CASE|");
    }
    if ((flags & Pattern.CANON_EQ) != 0) {
        sb.append("CANON_EQ|");
    }
    if ((flags & Pattern.UNIX_LINES) != 0) {
        sb.append("UNIX_LINES|");
    }
    if ((flags & Pattern.LITERAL) != 0) {
        sb.append("LITERAL|");
    }
    if ((flags & Pattern.COMMENTS) != 0) {
        sb.append("COMMENTS|");
    }
    if ((flags & UNICODE_CHARACTER_CLASS) != 0) {
        sb.append("UNICODE_CHAR_CLASS|");
    }
    return sb.toString();
}
 
Example 9
protected void compile(String regex) throws PatternSyntaxException {
  int flags = Pattern.DOTALL;
  if (caseInsensitive) {
    flags |= Pattern.CASE_INSENSITIVE;
  }
  this.compiled = Pattern.compile(regex, flags);
}
 
Example 10
/**
 * Construct a new regular expression filter with the specified flags case sensitivity.
 *
 * @param pattern regular string expression to match
 * @param caseSensitivity  how to handle case sensitivity, null means case-sensitive
 * @throws IllegalArgumentException if the pattern is null
 */
public RegexFileFilter(final String pattern, final IOCase caseSensitivity) {
    if (pattern == null) {
        throw new IllegalArgumentException("Pattern is missing");
    }
    int flags = 0;
    if (caseSensitivity != null && !caseSensitivity.isCaseSensitive()) {
        flags = Pattern.CASE_INSENSITIVE;
    }
    this.pattern = Pattern.compile(pattern, flags);
}
 
Example 11
/**
 * Construct a new regular expression filter with the specified flags case sensitivity.
 *
 * @param pattern regular string expression to match
 * @param caseSensitivity  how to handle case sensitivity, null means case-sensitive
 * @throws IllegalArgumentException if the pattern is null
 */
public RegexFileFilter(String pattern, IOCase caseSensitivity) {
    if (pattern == null) {
        throw new IllegalArgumentException("Pattern is missing");
    }
    int flags = 0;
    if (caseSensitivity != null && !caseSensitivity.isCaseSensitive()) {
        flags = Pattern.CASE_INSENSITIVE;
    }
    this.pattern = Pattern.compile(pattern, flags);
}
 
Example 12
Source Project: Android-RTEditor   File: RegexValidator.java    License: Apache License 2.0 5 votes vote down vote up
/**
 * Construct a validator that matches any one of the set of regular
 * expressions with the specified case sensitivity.
 *
 * @param regexs The set of regular expressions this validator will
 * validate against
 * @param caseSensitive when <code>true</code> matching is <i>case
 * sensitive</i>, otherwise matching is <i>case in-sensitive</i>
 */
public RegexValidator(String[] regexs, boolean caseSensitive) {
    if (regexs == null || regexs.length == 0) {
        throw new IllegalArgumentException("Regular expressions are missing");
    }
    patterns = new Pattern[regexs.length];
    int flags =  (caseSensitive ? 0: Pattern.CASE_INSENSITIVE);
    for (int i = 0; i < regexs.length; i++) {
        if (regexs[i] == null || regexs[i].length() == 0) {
            throw new IllegalArgumentException("Regular expression[" + i + "] is missing");
        }
        patterns[i] =  Pattern.compile(regexs[i], flags);
    }
}
 
Example 13
/**
 * Construct a new <tt>MultipleRegexFilenameFilter</tt>.
 *
 * @param matchType <tt>MatchType.FILENAME</tt> to match just the
 *                  filename, <tt>MatchType.PATH</tt> to match the path
 */
public MultipleRegexFilenameFilter (MatchType matchType)
{
    this.matchType = matchType;
    regexOptions   = Pattern.CASE_INSENSITIVE;
    acceptPatterns = new ArrayList<Pattern>();
    rejectPatterns = new ArrayList<Pattern>();
}
 
Example 14
@Test
public void testRegexStringComparator() throws Exception {
  // test without specifying flags
  RegexStringComparator regexStringComparator = new RegexStringComparator(".+-2");
  assertTrue(regexStringComparator.areSerializedFieldsEqual(
    ProtobufUtil.toComparator(ProtobufUtil.toComparator(regexStringComparator))));

  // test with specifying flags
  try {
    new RegexStringComparator("regex", Pattern.CASE_INSENSITIVE | Pattern.DOTALL);
  } catch (Throwable t) {
    assertNull("Exception occurred while created the RegexStringComparator object", t);
  }
}
 
Example 15
Source Project: database   File: RegexBOp.java    License: GNU General Public License v2.0 4 votes vote down vote up
private static Pattern getPattern(final Value parg, final Value farg)
            throws IllegalArgumentException {
        
        if (debug) {
            log.debug("regex pattern: " + parg);
            log.debug("regex flags: " + farg);
        }
        
        //BLZG-1200 Literals with language types are not included in REGEX
        if (QueryEvaluationUtil.isPlainLiteral(parg)
                && (farg == null || QueryEvaluationUtil.isPlainLiteral(farg))) {

            final String ptn = ((Literal) parg).getLabel();
            String flags = "";
            if (farg != null) {
                flags = ((Literal)farg).getLabel();
            }
            int f = 0;
            for (char c : flags.toCharArray()) {
                // See https://www.w3.org/TR/xpath-functions/#flags
                switch (c) {
                    case 's':
                        f |= Pattern.DOTALL;
                        break;
                    case 'm':
                        f |= Pattern.MULTILINE;
                        break;
                    case 'i': {
                    /*
                     * The SPARQL REGEX operator is based on the XQuery REGEX
                     * operator. That operator should be Unicode clean by
                     * default. Therefore, when case-folding is specified, we
                     * also need to include the UNICODE_CASE option.
                     * 
                     * @see <a
                     * href="https://sourceforge.net/apps/trac/bigdata/ticket/655"
                     * > SPARQL REGEX operator does not perform case-folding
                     * correctly for Unicode data </a>
                     */
                        f |= Pattern.CASE_INSENSITIVE;
                        f |= Pattern.UNICODE_CASE;
                        break;
                    }
                    case 'x':
                        f |= Pattern.COMMENTS;
                        break;
                    case 'd':
                        f |= Pattern.UNIX_LINES;
                        break;
                    case 'u': // Implicit with 'i' flag.
//                      f |= Pattern.UNICODE_CASE;
                        break;
                    case 'q':
                        f |= Pattern.LITERAL;
                        break;
                    default:
                        throw new IllegalArgumentException();
                }
            }
            final Pattern pattern = Pattern.compile(ptn, f);
            return pattern;
        }
        
        throw new IllegalArgumentException();
        
    }
 
Example 16
/**
 * Determines whether the two operands match according to the <code>regex</code> operator.
 *
 * @return <tt>true</tt> if the operands match according to the <tt>regex</tt> operator, <tt>false</tt> otherwise.
 */
public Value evaluate(Regex node, BindingSet bindings)
		throws QueryEvaluationException {
	Value arg = evaluate(node.getArg(), bindings);
	Value parg = evaluate(node.getPatternArg(), bindings);
	Value farg = null;
	ValueExpr flagsArg = node.getFlagsArg();
	if (flagsArg != null) {
		farg = evaluate(flagsArg, bindings);
	}

	if (QueryEvaluationUtil.isStringLiteral(arg) && QueryEvaluationUtil.isSimpleLiteral(parg)
			&& (farg == null || QueryEvaluationUtil.isSimpleLiteral(farg))) {
		String text = ((Literal) arg).getLabel();
		String ptn = ((Literal) parg).getLabel();
		String flags = "";
		if (farg != null) {
			flags = ((Literal) farg).getLabel();
		}
		// TODO should this Pattern be cached?
		int f = 0;
		for (char c : flags.toCharArray()) {
			switch (c) {
			case 's':
				f |= Pattern.DOTALL;
				break;
			case 'm':
				f |= Pattern.MULTILINE;
				break;
			case 'i':
				f |= Pattern.CASE_INSENSITIVE;
				f |= Pattern.UNICODE_CASE;
				break;
			case 'x':
				f |= Pattern.COMMENTS;
				break;
			case 'd':
				f |= Pattern.UNIX_LINES;
				break;
			case 'u':
				f |= Pattern.UNICODE_CASE;
				break;
			case 'q':
				f |= Pattern.LITERAL;
				break;
			default:
				throw new ValueExprEvaluationException(flags);
			}
		}
		Pattern pattern = Pattern.compile(ptn, f);
		boolean result = pattern.matcher(text).find();
		return BooleanLiteral.valueOf(result);
	}

	throw new ValueExprEvaluationException();
}
 
Example 17
Source Project: sawmill   File: MatchRegexCondition.java    License: Apache License 2.0 4 votes vote down vote up
public MatchRegexCondition(String field, String regex, boolean caseInsensitive, boolean matchPartOfValue) {
    int patternFlags = caseInsensitive ? Pattern.CASE_INSENSITIVE : 0;
    this.field = requireNonNull(field);
    this.pattern = Pattern.compile(requireNonNull(regex), patternFlags);
    this.matchingFunction = matchPartOfValue ? this::matchPartOfValue : this::matchEntireOfValue;
}
 
Example 18
Source Project: quarkus-http   File: RewriteRule.java    License: Apache License 2.0 4 votes vote down vote up
/**
 * Evaluate the rule based on the context
 *
 * @return null if no rewrite took place
 */
public CharSequence evaluate(CharSequence url, Resolver resolver) {
    Pattern pattern = this.pattern.get();
    if (pattern == null) {
        // Parse the pattern
        int flags = 0;
        if (isNocase()) {
            flags |= Pattern.CASE_INSENSITIVE;
        }
        pattern = Pattern.compile(patternString, flags);
        this.pattern.set(pattern);
    }
    Matcher matcher = pattern.matcher(url);
    if (!matcher.matches()) {
        // Evaluation done
        return null;
    }
    // Evaluate conditions
    boolean done = false;
    boolean rewrite = true;
    Matcher lastMatcher = null;
    int pos = 0;
    while (!done) {
        if (pos < conditions.length) {
            rewrite = conditions[pos].evaluate(matcher, lastMatcher, resolver);
            if (rewrite) {
                Matcher lastMatcher2 = conditions[pos].getMatcher();
                if (lastMatcher2 != null) {
                    lastMatcher = lastMatcher2;
                }
                while (pos < conditions.length && conditions[pos].isOrnext()) {
                    pos++;
                }
            } else if (!conditions[pos].isOrnext()) {
                done = true;
            }
            pos++;
        } else {
            done = true;
        }
    }
    // Use the substitution to rewrite the url
    if (rewrite) {
        if (isEnv()) {
            for (int i = 0; i < envSubstitution.size(); i++) {
                envResult.get(i).set(envSubstitution.get(i).evaluate(matcher, lastMatcher, resolver));
            }
        }
        if (isCookie()) {
            cookieResult.set(cookieSubstitution.evaluate(matcher, lastMatcher, resolver));
        }
        if (substitution != null) {
            return substitution.evaluate(matcher, lastMatcher, resolver);
        } else {
            return url;
        }
    } else {
        return null;
    }
}
 
Example 19
Source Project: xipki   File: DomainValidator.java    License: Apache License 2.0 3 votes vote down vote up
/**
 * Construct a validator that matches any one of the set of regular
 * expressions with the specified case sensitivity.
 *
 * @param regex The regular expressions this validator will validate against
 * @param caseSensitive when <code>true</code> matching is <i>case
 * sensitive</i>, otherwise matching is <i>case in-sensitive</i>
 */
public RegexValidator(String regex, boolean caseSensitive) {
  if (regex == null || regex.length() == 0) {
    throw new IllegalArgumentException("Regular expression is missing");
  }
  int flags =  (caseSensitive ? 0 : Pattern.CASE_INSENSITIVE);
  pattern = Pattern.compile(regex, flags);
}
 
Example 20
/**
 * Create filter instance.
 *
 * @param caseSensitive Case sensitive flag.
 * @param regex Regex search flag.
 * @param ptrn String to search in string presentation of key or value.
 */
public VisorQueryScanRegexFilter(boolean caseSensitive, boolean regex, String ptrn) {
    int flags = caseSensitive ? 0 : Pattern.CASE_INSENSITIVE;

    this.ptrn = Pattern.compile(regex ? ptrn : ".*?" + Pattern.quote(ptrn) + ".*?", flags);
}