Java Code Examples for java.util.regex.PatternSyntaxException#getMessage()

private Attribute[] getAttributesArrayFromRegex(Attributes attributes, String regex) throws OperatorException {
	Pattern pattern = null;
	try {
		pattern = Pattern.compile(regex);
	} catch (PatternSyntaxException e) {
		throw new UserError(this, 206, regex, e.getMessage());
	}
	List<Attribute> attributeList = new LinkedList<>();
	Iterator<Attribute> i = attributes.allAttributes();
	while (i.hasNext()) {
		Attribute attribute = i.next();
		Matcher matcher = pattern.matcher(attribute.getName());
		if (matcher.matches()) {
			attributeList.add(attribute);
		}
	}

	Attribute[] attributesArray = new Attribute[attributeList.size()];
	attributesArray = attributeList.toArray(attributesArray);
	return attributesArray;
}
 

@Override
protected Object formNeedle(String word) {
    
    Object needle;
    
    if (config.getRegex()) {
        try {
            needle = Pattern.compile(word);
        } catch (PatternSyntaxException pse) {
            throw new IllegalArgumentException("Invalid regex syntax for "
                    + "pattern \"" + word + "\": " + pse.getMessage());
        }
    } else if (!config.getCaseSensitive()) {
        needle = word.toLowerCase();
    } else {
        needle = word;
    }
    
    return needle;
}
 

/**
 * Converts the given list of Strings to a list of Pattern objects
 *
 * @param regexps
 *            A list of regex pattern strings
 *
 * @exception IllegalArgumentException
 *            if one of the patterns has invalid regular expression
 *            syntax
 */
private List<Pattern> getRegExPatterns(List<String> regexps) {

    ArrayList<Pattern> patterns = new ArrayList<>();
    for (String regexp : regexps) {
        String regex = StringUtils.trimToNull(regexp);
        if (regex != null) {
            // if :empty: is in any of the then return an empty list
            if (StringUtils.equals(":empty:", regex)) return new ArrayList<>();

            try {
                patterns.add(Pattern.compile(regex, Pattern.CASE_INSENSITIVE));
            } catch (PatternSyntaxException e) {
                throw new IllegalArgumentException("Illegal Regular Expression Syntax: [" + regex + "] - " + e.getMessage());
            }
        }
    }
    return patterns;
}
 

@Override
public NamespaceOptBuilder withSeparatorExpression( String expression )
{
    if ( StringUtils.isEmpty( expression ) )
    {
        throw new IllegalArgumentException( "Separator expression may not be null or empty" );
    }
    this.item.separatorExpression = expression;
    try
    {
        setNamespacePath( this.item.namespace );
    }
    catch ( PatternSyntaxException e )
    {
        throw new IllegalArgumentException( "Bad pattern syntax separator expression " + expression + ": " + e.getMessage( ), e );
    }
    return this;
}
 

private static String fixUnicodeScriptPattern(String rawPattern) {
    for (int i = 0; i < UNICODE_SCRIPT_FIX_COUNTER; i++) {
        try {
            Pattern.compile(rawPattern);
            return rawPattern;
        } catch (final PatternSyntaxException ex) {
            LOG.debug("Invalid regex pattern syntax in: {}", rawPattern, ex);
            final String msg = ex.getMessage();
            if (msg.startsWith("Unknown character script name")
                    || msg.startsWith("Unknown character property name")) {
                rawPattern = fixUnknownScripts(msg, rawPattern);
            } else {
                return rawPattern;
            }
        }
    }

    LOG.warn("Regex pattern could not be fixed: {}", rawPattern);
    return rawPattern;
}
 

private Attribute[] getMatchingAttributes(Attributes attributes, String regex) throws OperatorException {
	Pattern pattern = null;
	try {
		pattern = Pattern.compile(regex);
	} catch (PatternSyntaxException e) {
		throw new UserError(this, 206, regex, e.getMessage());
	}
	List<Attribute> attributeList = new LinkedList<>();
	Iterator<Attribute> iterator = attributes.allAttributes();
	while (iterator.hasNext()) {
		Attribute attribute = iterator.next();
		if (pattern.matcher(attribute.getName()).matches()) {
			attributeList.add(attribute);
		}
	}

	// building array of attributes for faster access.
	Attribute[] attributesArray = new Attribute[attributeList.size()];
	attributesArray = attributeList.toArray(attributesArray);
	return attributesArray;
}
 

@Override
public VersionOptBuilder withSeparatorExpression( String expression )
{
    if ( StringUtils.isEmpty( expression ) )
    {
        throw new IllegalArgumentException( "Separator expression may not be null or empty" );
    }
    this.item.separatorExpression = expression;
    try
    {
        updateVersionSegments( );
    }
    catch ( PatternSyntaxException e )
    {
        throw new IllegalArgumentException( "Bad separator expression " + expression + ": " + e.getMessage( ), e );
    }
    return this;
}
 

void init(String filePattern, PathFilter filter) throws IOException {
  try {
    userFilter = filter;
    pattern = new GlobPattern(filePattern);
  }
  catch (PatternSyntaxException e) {
    // Existing code expects IOException startWith("Illegal file pattern")
    throw new IOException("Illegal file pattern: "+ e.getMessage(), e);
  }
}
 

public void setSkipRegexChecksum(String skipRegexChecksum) {
  try {
    if (skipRegexChecksum != null && skipRegexChecksum.length() > 0) {
      this.skipRegexChecksum = Pattern.compile(skipRegexChecksum);
    }
  } catch (PatternSyntaxException e) {
    throw new BuildException("Unable to compile skipRegexChecksum pattern.  Reason: "
        + e.getMessage() + " " + skipRegexChecksum, e);
  }
}
 

@Override
public ComparisonResult evaluate(String testText, String... param) {
    if (param.length > 0 && param[0] != null && !param[0].equals("")) {
        try {
            final Pattern pattern = Pattern.compile(param[0].trim());
            if (testText != null && evaluate(testText.trim(), pattern)) {
                return EQUAL;
            }
        } catch(PatternSyntaxException e) {
            throw new XMLUnitException(e.getMessage(), e);
        }
    }
    return DIFFERENT;
}
 

public Object stringToValue(String string) throws ParseException {
    try {
        return Pattern.compile(string);
    } catch (final PatternSyntaxException e) {
        throw new ParseException(e.getMessage(), e.getIndex());
    }
}
 

@Override
public RegexPatternOption convert(String input) throws OptionsParsingException {
  try {
    return RegexPatternOption.create(Pattern.compile(input));
  } catch (PatternSyntaxException e) {
    throw new OptionsParsingException("Not a valid regular expression: " + e.getMessage());
  }
}
 

@Override
public ExampleSet apply(ExampleSet exampleSet) throws OperatorException {
	String splittingRegex = getParameterAsString(PARAMETER_SPLIT_PATTERN);
	Pattern splittingPattern = null;
	try {
		splittingPattern = Pattern.compile(splittingRegex);
	} catch (PatternSyntaxException e) {
		throw new UserError(this, 206, splittingRegex, e.getMessage());
	}

	int type = getParameterAsInt(PARAMETER_SPLIT_MODE);
	// Until version 6.0.3 there was thrown no UserError when attributes were missing.
	// Compatibility check to avoid older processes to fail.
	boolean errorOnMissing = getCompatibilityLevel().isAtMost(OPERATOR_VERSION_6_0_3) ? false : true;

	for (Attribute attribute : attributeSubsetSelector.getAttributeSubset(exampleSet, false, errorOnMissing)) {
		if (attribute.isNominal()) {
			switch (type) {
				case SPLIT_MODE_ORDERED:
					orderedSplit(exampleSet, attribute, splittingPattern);
					break;
				case SPLIT_MODE_UNORDERED:
				default:
					unorderedSplit(exampleSet, attribute, splittingPattern);
					break;
			}
		}
	}

	return exampleSet;
}
 

@Override
protected Validator<String> createValidator(String model, Converter<String> converter) throws ModelSyntaxException {
    String regexpString = parseAndGetOneGroup(model, REGEXP_REGEXP);
    try {
        return new RegexpValidator(regexpString);
    } catch (PatternSyntaxException e) {
        throw new ModelSyntaxException(e.getMessage(), e);
    }
}
 

protected static List<String> parseAndGetRegexGroups(String valueToParse, String regexp)
        throws ModelSyntaxException {
    try {
        Pattern pattern = Pattern.compile(regexp);
        Matcher matcher = pattern.matcher(valueToParse);
        if (matcher.find()) {
            return getMatchedGroups(matcher, matcher.groupCount());
        } else {
            throw new ModelSyntaxException("Expression '" + valueToParse + "' does not match " + regexp);
        }
    } catch (PatternSyntaxException e) {
        throw new ModelSyntaxException("Internal error, regular expression '" + regexp + "' is invalid: " +
                                       e.getMessage(), e);
    }
}
 

/**
 * This method is called during the parser initialization. It parses the parser
 * configuration and configures the parser accordingly. It then initializes
 * instance variables.
 *
 * @param parserConfig ParserConfig(Map<String, Object>) supplied to the sensor.
 * @see org.apache.metron.parsers.interfaces.Configurable#configure(java.util.Map)<br>
 *      <br>
 */
// @formatter:on
@Override
public void configure(Map<String, Object> parserConfig) {
    setReadCharset(parserConfig);
    setParserConfig(parserConfig);
    setFields((List<Map<String, Object>>) getParserConfig()
        .get(ParserConfigConstants.FIELDS.getName()));
    String recordTypeRegex =
        (String) getParserConfig().get(ParserConfigConstants.RECORD_TYPE_REGEX.getName());

    if (StringUtils.isBlank(recordTypeRegex)) {
        LOG.error("Invalid config :recordTypeRegex is missing in parserConfig");
        throw new IllegalStateException(
            "Invalid config :recordTypeRegex is missing in parserConfig");
    }

    setRecordTypePattern(recordTypeRegex);
    recordTypePatternNamedGroups.addAll(getNamedGroups(recordTypeRegex));
    List<Map<String, Object>> fields =
        (List<Map<String, Object>>) getParserConfig().get(ParserConfigConstants.FIELDS.getName());

    try {
        configureRecordTypePatterns(fields);
        configureMessageHeaderPattern();
    } catch (PatternSyntaxException e) {
        LOG.error("Invalid config : {} ", e.getMessage());
        throw new IllegalStateException("Invalid config : " + e.getMessage());
    }

    validateConfig();
}
 

public RegExSearchData(String inputString) {
	super(inputString, new byte[0], null);		
	try {
		pattern = Pattern.compile(inputString, Pattern.DOTALL);
	} catch (PatternSyntaxException pse) {
		errorMessage = pse.getMessage();
	}
}
 

/**
 * @param obj1
 * @param obj2
 * @return true x matches SQL pattern y
 * @throws BirtException
 * @throws DataException
 */
private static boolean like( Object source, Object pattern, boolean ignorecase ) throws BirtException
{
	String sourceStr = null;
	sourceStr = (source == null)? "": DataTypeUtil.toLocaleNeutralString( source );
	String patternStr;
	patternStr = ( pattern == null )? "" : DataTypeUtil.toLocaleNeutralString( pattern );
	
	// As per Bugzilla 115940, LIKE operator's pattern syntax is SQL-like: it
	// recognizes '_' and '%'. Backslash '\' escapes the next character.
	
	// Construct a Java RegExp pattern based on input. We need to translate 
	// unescaped '%' to '.*', and '_' to '.'
	// Also need to escape any RegExp metacharacter in the source pattern.
	
	final String reservedChars = "([{^$|)?*+.";
	int patternLen = patternStr.length();
	StringBuffer buffer = new StringBuffer( patternLen * 2 );
	
	for ( int i = 0; i < patternLen; i++)
	{
		char c = patternStr.charAt(i);
		if ( c == '\\' )
		{
			// Escape char; copy next character to new pattern if 
			// it is '\', '%' or '_'
			++i;
			if ( i < patternLen )
			{
				c = patternStr.charAt( i );
				if ( c == '%' || c == '_' )
					buffer.append( c );
				else if ( c == '\\' )
					buffer.append( "\\\\");		// Need to escape \
			}
			else
			{
				buffer.append( "\\\\" );  	// Leave last \ and escape it
			}
		}
		else if ( c == '%')
		{
			buffer.append(".*");
		}
		else if ( c == '_')
		{
			buffer.append(".");
		}
		else
		{
			// Copy this char to target, escape if it is a metacharacter
			if ( reservedChars.indexOf(c) >= 0 )
			{
				buffer.append('\\');
			}
			buffer.append(c);
		}
	}
	
	try
	{
		String newPatternStr = buffer.toString( );
		Pattern p = null;
		// Support search in multiple lines
		if ( !ignorecase )
		{
			p = Pattern.compile( newPatternStr, Pattern.DOTALL );
		}
		else
		{
			p = Pattern.compile( newPatternStr,
					Pattern.DOTALL | Pattern.CASE_INSENSITIVE );
		}
		Matcher m = p.matcher( sourceStr.toString( ) );
		return m.matches( );
	}
	catch ( PatternSyntaxException e )
	{
		throw new BirtException( e.getMessage( ) );
	}
}
 

private Matcher createMatcher(
    Map<String, String> parameters,
    String paramName,
    PrintStream debugErr
)
    throws PatternSyntaxException
{
    Matcher regexMatch = null;
    try
    {
        String regex = parameters.get(paramName);
        if (regex != null)
        {
            Pattern ptrn = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
            regexMatch = ptrn.matcher("");
        }
    }
    catch (PatternSyntaxException patternExc)
    {
        String errorCause;
        String excMessage = patternExc.getMessage();
        if (excMessage == null)
        {
            errorCause = "The regular expression library did not return an error cause description.";
        }
        else
        {
            errorCause = "The error description returned by the regular expression library is:\n" +
                         excMessage;
        }
        printError(
            debugErr,
            "The regular expression argument for the filter parameter '" + paramName + "' is invalid.",
            errorCause,
            "Reenter the command with the corrected filter parameter.",
            null
        );
        throw patternExc;
    }
    return regexMatch;
}
 

@Nullable
@Override
protected ValidationInfo doValidate() {
    if (regexCheckBox.isSelected()) {
        String regex = regexTextField.getText();
        PatternSyntaxException exception = tryCompileRegex(regex);
        if (regex.isEmpty() || exception != null) {
            String message = "Please specify a valid regex.";
            if (exception != null) {
                message += " ( " + exception.getMessage() + ")";
            }
            return new ValidationInfo(message);
        }
    }

    if (parentsCheckBox.isSelected()) {
        if (parentsTextField.getText().isEmpty()) {
            return new ValidationInfo("Please specify at least one parent.", parentsTextField);
        }
    }

    if (namesCheckBox.isSelected()) {
        if (namesTextField.getText().isEmpty()) {
            return new ValidationInfo("Please specify at least one name.", namesTextField);
        }
    }

    if (extensionsCheckBox.isSelected()) {
        if (extensionsTextField.getText().isEmpty()) {
            return new ValidationInfo("Please specify at least one extension.", extensionsTextField);
        }
    }

    if (mayEndWithRadioButton.isSelected() && mayEndWithRadioButton.isEnabled()) {
        if (!namesCheckBox.isSelected()) {
            return new ValidationInfo("If you select \"May end in\", you need to select the names checkbox.", namesCheckBox);
        }
    }

    if (!getModelConditionFromInput().isValid()) {
        return new ValidationInfo("Please select at least one checkbox.");
    }

    return null;
}