Java PatternSyntaxException.printStackTrace方法代码示例

import java.util.regex.PatternSyntaxException; //导入方法依赖的package包/类
Pattern[] toPatterns(String[] regexStrings) {
    if (regexStrings == null)
        return new Pattern[0];
    List<Pattern> patterns = new ArrayList<Pattern>();
    for (String pattern : regexStrings) {
        try {
            patterns.add(Pattern.compile(pattern));
        } catch (PatternSyntaxException pse) {
            ByteArrayOutputStream bs = new ByteArrayOutputStream();
            PrintStream ps = new PrintStream(bs);
            try {
                pse.printStackTrace(ps);
                logger.logDebug(String.format("%s: %s", this.getClass()
                        .getName(), bs.toString()));
            } finally {
                ps.close();
            }
        }
    }
    return patterns.toArray(new Pattern[patterns.size()]);
}
 

import java.util.regex.PatternSyntaxException; //导入方法依赖的package包/类
@Override
public List<String> getParameters(String template) {

    List<String> parameters = new ArrayList<>();
    try {
        Pattern regex = Pattern.compile(REGEX);
        Matcher matcher = regex.matcher(template);
        while (matcher.find())
        {
            parameters.add(matcher.group(1));
        }
    }catch (PatternSyntaxException e)
    {
        e.printStackTrace();
    }
    return parameters;
}
 

import java.util.regex.PatternSyntaxException; //导入方法依赖的package包/类
private void cmdSplit(String cmd){
	
	try {
		cmds = cmd.split("\\n+");
	} catch (PatternSyntaxException e) {
		e.printStackTrace();
	}
	
}
 

import java.util.regex.PatternSyntaxException; //导入方法依赖的package包/类
private void shouldThrow(String... globs) {
  for (String glob : globs) {
    try {
      GlobPattern.compile(glob);
    }
    catch (PatternSyntaxException e) {
      e.printStackTrace();
      continue;
    }
    assertTrue("glob "+ glob +" should throw", false);
  }
}
 

import java.util.regex.PatternSyntaxException; //导入方法依赖的package包/类
/**
 * Creates a regular expression pattern that matches a "wildcard" pattern.
 *
 * @param wildcard The wildcard pattern.
 * @param matchCase Whether the pattern should be case sensitive.
 * @param escapeStartChar Whether to escape a starting <code>'^'</code>
 *        character.
 * @return The pattern.
 */
public static Pattern wildcardToPattern(String wildcard, boolean matchCase,
		boolean escapeStartChar) {

	int flags = RSyntaxUtilities.getPatternFlags(matchCase, 0);

	StringBuilder sb = new StringBuilder();
	for (int i=0; i<wildcard.length(); i++) {
		char ch = wildcard.charAt(i);
		switch (ch) {
			case '*':
				sb.append(".*");
				break;
			case '?':
				sb.append('.');
				break;
			case '^':
				if (i>0 || escapeStartChar) {
					sb.append('\\');
				}
				sb.append('^');
				break;
			case '\\':
			case '.': case '|':
			case '+': case '-':
			case '$':
			case '[': case ']':
			case '{': case '}':
			case '(': case ')':
				sb.append('\\').append(ch);
				break;
			default:
				sb.append(ch);
				break;
		}
	}

	Pattern p = null;
	try {
		p = Pattern.compile(sb.toString(), flags);
	} catch (PatternSyntaxException pse) {
		pse.printStackTrace();
		p = Pattern.compile(".+");
	}

	return p;

}
 

import java.util.regex.PatternSyntaxException; //导入方法依赖的package包/类
/** This method will list the customizations added to a code generated file.
 * @param file the code generated file.
 * @param writer the customizations will be written to this writer.
 * @param customizationFilter the customizations will be filtered based on this paramter. If no value is passed, then all the customizations will be listed.
 * @throws IOException if any IO error occurs.
 * @throws SourceDecomposerException if the file is malformed or if it cannot be decomposed.
 */
public static void listCustomizations(File file, BufferedWriter writer, String customizationFilter)
throws IOException, SourceDecomposerException {
    System.out.println("Processing file... " + file);
    SourceDecomposer sd = new SourceDecomposer(new BufferedReader(new FileReader(file)));
    Collection elements = sd.getCollection();
    boolean headerWritten = false;
    if (elements != null) {
        for (Iterator itr = elements.iterator(); itr.hasNext();) {
            Object obj = itr.next();
            if (obj instanceof SourceDecomposer.GuardedBorder) {
                SourceDecomposer.GuardedBorder gb = (SourceDecomposer.GuardedBorder) obj;
                
                // Check the name of the customization block against the filter
                if (customizationFilter != null && customizationFilter.length() > 0) {
                    try {
                        // Ignore this customization, if it does not match the filter
                        if (!Pattern.matches(customizationFilter, gb.getKey()))
                            continue;
                    } catch (PatternSyntaxException e) {
                        e.printStackTrace();
                        throw new IllegalArgumentException("Invalid customizationFilter passed: " + customizationFilter);
                    }
                }
                
                // Strip the borders from the contents
                StringHelper.Line line = null;
                StringBuffer buf = new StringBuffer();
                PushbackReader reader = new PushbackReader(new StringReader(gb.getContents()));
                while ((line = StringHelper.readLine(reader)) != null) {
                    if (line.getContents().indexOf(SourceDecomposer.FIRST) < 0 && line.getContents().indexOf(SourceDecomposer.LAST) < 0)
                        buf.append(line);
                }
                String contents = buf.toString().trim();
                
                // Only write if the contents are not empty
                if (contents.length() > 0) {
                    if (!headerWritten) {
                        writer.write("===============================================================================\n");
                        writer.write(file.getPath());
                        writer.write("\n===============================================================================\n");
                        headerWritten = true;
                    }
                    writer.write("* " + gb.getKey() + '\n');
                    writer.write(contents);
                    writer.write("\n\n");
                    writer.flush();
                }
            }
        }
    }
}