下面列出了java.util.regex.Matcher#appendReplacement ( ) 实例代码,或者点击链接到github查看源代码,也可以在右侧发表评论。
private static Octets str2Oct(String str)
{
String matchStr = "";
try
{
Matcher mat = s_patHex.matcher(str);
if (!mat.find())
return Octets.wrap(str.getBytes(s_cs88591));
StringBuilder sb = new StringBuilder(str.length());
do
{
matchStr = mat.group(1);
mat.appendReplacement(sb, Matcher.quoteReplacement(String.valueOf((char)(Integer.parseInt(matchStr, 16)))));
}
while (mat.find());
return Octets.wrap(mat.appendTail(sb).toString().getBytes(s_cs88591));
}
catch (RuntimeException e)
{
System.err.println("ERROR: parse failed: '" + matchStr + "' in '" + str + '\'');
throw e;
}
}
/**
* Retrieves a value from the current stash.
* The stash contains fields eventually extracted from previous responses that can be reused
* as arguments for following requests (e.g. scroll_id)
*/
public Object getValue(String key) throws IOException {
if (key.charAt(0) == '$' && key.charAt(1) != '{') {
return unstash(key.substring(1));
}
Matcher matcher = EXTENDED_KEY.matcher(key);
/*
* String*Buffer* because that is what the Matcher API takes. In modern versions of java the uncontended synchronization is very,
* very cheap so that should not be a problem.
*/
StringBuffer result = new StringBuffer(key.length());
if (false == matcher.find()) {
throw new IllegalArgumentException("Doesn't contain any stash keys [" + key + "]");
}
do {
matcher.appendReplacement(result, Matcher.quoteReplacement(unstash(matcher.group(1)).toString()));
} while (matcher.find());
matcher.appendTail(result);
return result.toString();
}
/**
* 执行interpolation(变量插入)。
*
* @param expression 含有变量的表达式字符串。表达式中的变量名也可以用<code>{}</code>括起来。
* @param params 变量集。变量名可以包含<code>.</code>、<code>_</code>字符。
* @return 完成interpolation后的字符串。 如:<code><pre>xxx${name}zzz -> xxxjerryzzz</pre></code>(其中变量name="jerry")
* @throws IllegalStateException 表达式字符串中使用到的变量 在变量集中没有
*/
// FIMXE 抛出IllegalStateException异常,是否合适?!
public static String interpolate(String expression, Map<String, String> params) {
if (expression == null || expression.length() == 0) {
throw new IllegalArgumentException("glob pattern is empty!");
}
if (expression.indexOf('$') < 0) {
return expression;
}
Matcher matcher = VARIABLE_PATTERN.matcher(expression);
StringBuffer sb = new StringBuffer();
while (matcher.find()) { // 逐个匹配
String key = matcher.group(1);
String value = params == null ? null: params.get(key);
if (value == null) {
value = "";
}
matcher.appendReplacement(sb, value);
}
matcher.appendTail(sb);
return sb.toString();
}
private String substitute(String input, Mapper mapper) {
StringBuffer buffer = new StringBuffer();
for (String find : correction.keySet()) {
Pattern pattern = Pattern.compile(find, CASE_INSENSITIVE
| UNICODE_CASE);
Matcher matcher = pattern.matcher(input);
String replace = correction.get(find);
mapper.prepare(input, find, replace);
while (!matcher.hitEnd() && matcher.find()) {
mapper.update(matcher.start() + 1);
matcher.appendReplacement(buffer, replace);
}
matcher.appendTail(buffer);
input = buffer.toString();
buffer.delete(0, buffer.length());
}
return input;
}
private String computeReplacementString(Pattern pattern, String originalText, String replacementText,
String lineDelimiter) throws PatternSyntaxException {
if (pattern != null) {
try {
replacementText = PatternConstructor.interpretReplaceEscapes(replacementText, originalText,
lineDelimiter);
Matcher matcher = pattern.matcher(originalText);
StringBuffer sb = new StringBuffer();
matcher.reset();
if (matcher.find()) {
matcher.appendReplacement(sb, replacementText);
} else {
return null;
}
matcher.appendTail(sb);
return sb.toString();
} catch (IndexOutOfBoundsException ex) {
throw new PatternSyntaxException(ex.getLocalizedMessage(), replacementText, -1);
}
}
return replacementText;
}
public static String urlDecode(String encoded, String encoding) {
try {
Matcher m = RE_URL_ENCODED_CHARS.matcher(encoded);
StringBuffer sb = new StringBuffer(encoded.length());
while (m.find()) {
String chars = m.group(0);
m.appendReplacement(sb, new String(parseBytes(chars), encoding));
}
m.appendTail(sb);
return sb.toString();
} catch (UnsupportedEncodingException e) {
throw new MisconfigurationException("core.UNSUPPORTED_ENCODING", encoding, e);
}
}
static String compile(String binaryRegex) {
Matcher matcher = HEX_VALUE.matcher(binaryRegex);
StringBuffer sb = new StringBuffer();
while (matcher.find()) {
String value = matcher.group();
if (!value.startsWith(ESCAPED_ESCAPE_CHAR)) {
value = convertByte(value.substring(2));
}
matcher.appendReplacement(sb, value);
}
matcher.appendTail(sb);
return sb.toString();
}
/**
* Substitute property values in BalloonStyle text template
*
* @param template text template
* @param placemark placemark to get property values from
* @return string with property values substituted
*/
public static String substituteProperties(String template, KmlPlacemark placemark) {
StringBuffer sb = new StringBuffer();
Pattern pattern = Pattern.compile("\\$\\[(.+?)]");
Matcher matcher = pattern.matcher(template);
while (matcher.find()) {
String property = matcher.group(1);
String value = placemark.getProperty(property);
if (value != null) {
matcher.appendReplacement(sb, value);
}
}
matcher.appendTail(sb);
return sb.toString();
}
/**
* Utility method to replace all occurrences given by the specific backreference with its uppercased form, and
* remove all other backreferences. <p> The Java {@link Pattern regular expression processing} does not use the
* preprocessing directives <code>\l</code>, <code>\u</code>, <code>\L</code>, and <code>\U</code>. If so, such
* directives could be used in the replacement string to uppercase or lowercase the backreferences. For example,
* <code>\L1</code> would lowercase the first backreference, and <code>\u3</code> would uppercase the 3rd
* backreference. </p>
*
* @return the input string with the appropriate characters converted to upper-case
*/
protected static String replaceAllWithUppercase( String input, String regex, int groupNumberToUppercase ) {
Pattern underscoreAndDotPattern = Pattern.compile( regex );
Matcher matcher = underscoreAndDotPattern.matcher( input );
StringBuffer sb = new StringBuffer();
while ( matcher.find() ) {
matcher.appendReplacement( sb, matcher.group( groupNumberToUppercase ).toUpperCase() );
}
matcher.appendTail( sb );
return sb.toString();
}
/**
* Xóa nội dung của String defStr theo Pattern pat
* @param defStr
* @param pat
* @return
*/
public static StringBuffer removePatternContents(String defStr, Pattern pat) {
Matcher mat = pat.matcher(defStr);
StringBuffer sb = new StringBuffer();
while (mat.find()) {
mat.appendReplacement(sb, " ");
}
mat.appendTail(sb);
return sb;
}
/**
* 驼峰转下划线,效率比上面高
* @param str
* @return
*/
public static String humpToLine2(String str) {
Matcher matcher = humpPattern.matcher(str);
StringBuffer sb = new StringBuffer();
while (matcher.find()) {
matcher.appendReplacement(sb, "_" + matcher.group(0).toLowerCase());
}
matcher.appendTail(sb);
return sb.toString();
}
/**
* Utility method that finds all occurrences of variable references and
* replaces them with their values.
* Values are taken from <code>varMap</code> and escaped. If they are
* not present there, system properties are queried. If not found there
* the variable reference is replaced with the same string with special
* characters escaped.
*
* @param value String value where the variables have to be replaced with values
* @param varMap mapping of variable names to their values
* @return String where the all the replacement was done
*/
public static String doSub(String value, Map<String, String> varMap) {
try {
Matcher matcher = pattern.matcher(value);
boolean result = matcher.find();
if (result) {
StringBuffer sb = new StringBuffer(value.length() * 2);
do {
String key = matcher.group(1);
String replacement = varMap.get(key);
if (replacement == null) {
replacement = System.getProperty(key);
if (replacement != null) {
replacement = escapePath(replacement);
} else {
replacement = "\\$\\{" + key + "\\}"; // NOI18N
}
} else {
replacement = escapePath(replacement);
}
matcher.appendReplacement(sb, replacement);
result = matcher.find();
} while (result);
matcher.appendTail(sb);
value = sb.toString();
}
} catch (Exception ex) {
Logger.getLogger("glassfish").log(Level.INFO, ex.getLocalizedMessage(), ex); // NOI18N
}
return value;
}
@Override
public String expandMacro(String queryString) {
count = 0;
Matcher matcher = macroPattern.matcher(queryString);
StringBuffer sb = new StringBuffer();
while (matcher.find()) {
matcher.appendReplacement(sb, doExpand(matcher.group(1)));
}
matcher.appendTail(sb);
return sb.toString();
}
private String resolveKey(String key) {
Matcher matcher = PATTERN.matcher(key);
StringBuffer sb = new StringBuffer();
while (matcher.find()) {
matcher.appendReplacement(sb, matcher.group(1).toUpperCase());
}
matcher.appendTail(sb);
return sb.toString();
}
/**
* Expand variables such as "{nms}" and "{obc}" to their corresponding packages.
*
* @param name - the full name of the class.
* @return The expanded string.
*/
private static String expandVariables(String name) {
StringBuffer output = new StringBuffer();
Matcher matcher = MATCH_VARIABLE.matcher(name);
while (matcher.find()) {
String variable = matcher.group(1);
String replacement;
// Expand all detected variables
if ("nms".equalsIgnoreCase(variable)) {
replacement = NMS_PREFIX;
} else if ("obc".equalsIgnoreCase(variable)) {
replacement = OBC_PREFIX;
} else if ("version".equalsIgnoreCase(variable)) {
replacement = VERSION;
} else {
throw new IllegalArgumentException("Unknown variable: " + variable);
}
// Assume the expanded variables are all packages, and append a dot
if (!replacement.isEmpty() && matcher.end() < name.length() && name.charAt(matcher.end()) != '.') {
replacement += ".";
}
matcher.appendReplacement(output, Matcher.quoteReplacement(replacement));
}
matcher.appendTail(output);
return output.toString();
}
public static String parse ( String input ) {
Pattern pattern = Pattern.compile( "\\{([^\\}]+)\\}", Pattern.CASE_INSENSITIVE );
Matcher matcher = pattern.matcher(input);
PathFormat.currentDate = new Date();
StringBuffer sb = new StringBuffer();
while ( matcher.find() ) {
matcher.appendReplacement(sb, PathFormat.getString( matcher.group( 1 ) ) );
}
matcher.appendTail(sb);
return sb.toString();
}
/** Normalizes all dates in a String
* Note: If you bugfix something in this version,
* please check for applying the same fix at the position change tracking function below */
public static String normalize(CharSequence s, Language language) {
Pattern monthPattern;
String[] months = null;
if (language.equals(Language.ENGLISH)) {
months = MONTHS_EN;
monthPattern = monthPatternEn;
} else if (language.equals(Language.GERMAN)) {
months = MONTHS_DE;
monthPattern = monthPatternDe;
} else if (language.equals(Language.SPANISH)) {
months = MONTHS_ES;
monthPattern = monthPatternEs;
} else if (language.equals(Language.FRENCH)) {
months = MONTHS_FR;
monthPattern = monthPatternFr;
} else if (language.equals(Language.ITALIAN)) {
months = MONTHS_IT;
monthPattern = monthPatternIt;
} else {
throw new IllegalArgumentException("Unsupported language: " + language);
}
// If it does not contain years or months, return it unchanged
if (!monthPattern.matcher(s).find() && !yearPattern.matcher(s).find()) return (s.toString());
StringBuffer in = new StringBuffer((int) (s.length() * 1.1));
// Replace all the months
Matcher m = monthPattern.matcher(s);
while (m.find()) {
int monthNum = D.indexOf(m.group().substring(0, 3), (Object[]) months);
if (monthNum == -1) monthNum = D.indexOf(m.group().substring(0, 4), (Object[]) months);
monthNum++; // convert from 0-based to 1-based
m.appendReplacement(in, "MONTH" + (monthNum / 10) + (monthNum % 10));
}
m.appendTail(in);
StringBuffer out = new StringBuffer((int) (in.length() * 1.1));
// Apply the patterns
for (FindReplace p : patterns) {
m = p.pattern.matcher(in);
if (m.find()) {
out.setLength(0);
do {
m.appendReplacement(out, p.replacement);
} while (m.find());
m.appendTail(out);
StringBuffer temp = out;
out = in;
in = temp;
}
}
m = Pattern.compile("&DEC(\\d++)").matcher(in);
if (m.find()) {
out.setLength(0);
do {
m.appendReplacement(out, "" + (Integer.parseInt(m.group(1)) - 1));
} while (m.find());
m.appendTail(out);
in = null;
return (out.toString());
}
out = null;
return (in.toString());
}
public void doFilter(final ServletRequest req, final ServletResponse resp, final FilterChain chain) throws IOException, ServletException
{
final String uri = ((HttpServletRequest) req).getRequestURI();
if (uri.matches(".*/ProjectForge.*.html") == false) {
chain.doFilter(req, resp);
return;
}
final PrintWriter out = resp.getWriter();
final CharResponseWrapper wrapper = new CharResponseWrapper((HttpServletResponse) resp);
chain.doFilter(req, wrapper);
final CharArrayWriter caw = new CharArrayWriter();
final String tutorialUrl = ((HttpServletResponse) resp).encodeURL(WicketUtils.getAbsoluteUrl("/wa/tutorial"));
final String regexp = "(\\{actionLink\\|)([a-zA-Z0-9]*)\\|([a-zA-Z0-9_\\-]*)(\\})([^\\{]*)(\\{/actionLink\\})";
final Pattern p = Pattern.compile(regexp, Pattern.MULTILINE | Pattern.DOTALL); // Compiles regular expression into Pattern.
final Matcher m = p.matcher(wrapper.toString());
final StringBuffer buf = new StringBuffer();
// final String html = m.replaceAll(tutorialUrl + "/Hurzel");
try {
while (m.find() == true) {
int i = 2;
if (m.groupCount() != 6) {
buf.append("{actionLink syntax error: " + m.groupCount() + ".}");
continue;
}
// {actionLink|createUser|linda}create{/actionLink}
m.appendReplacement(buf, "<a target=\"tutorial\" href=\"");
buf.append(tutorialUrl);
final String type = m.group(i++); // createUser
if (type == null) {
buf.append("\">create</a>");
continue;
}
buf.append("?type=").append(type).append("&ref=");
final String ref = m.group(i++);
if (ref == null) {
buf.append("\">create</a>");
continue;
}
buf.append(ref).append("\"><img src=\"images/actionlink_add.png\" style=\"vertical-align:middle;border:none;\" />");
i++; // }
final String label = m.group(i++);
if (label == null) {
buf.append("\">create</a>");
continue;
}
buf.append(label);
buf.append("</a>");
}
m.appendTail(buf);
} catch (final Exception ex) {
log.error(ex.getMessage(), ex);
}
// html = html.replace("{actionLink}", tutorialUrl);
// <link url="{actionLink}?type=createUser&ref=linda" target="tutorial">create</link>
caw.write(buf.toString());
// caw.write(wrapper.toString().substring(0, wrapper.toString().indexOf("</body>") - 1));
// caw.write("<p>\n<center>" + messages.getString("Visitor") + "<font color='red'>" + counter.getCounter() + "</font></center>");
// caw.write("\n</body></html>");
resp.setContentLength(caw.toString().length());
out.write(caw.toString());
out.close();
}
/**
* Resolves hyperlink placeholders to URLs in a Flash variable.
*
* @param text the text in which hyperlink placeholders are to be replaced
* @param element the print element where hyperlink parameters will be looked for
* @param linkProducer the hyperlink producer which transforms hyperlink
* objects to String URLs
* @return the text with hyperlink placeholders replaced by URLs
* @see #makeLinkPlaceholder(String)
*/
public static String resolveLinks(String text,
JRGenericPrintElement element,
JRHyperlinkProducer linkProducer,
boolean prepareForSerialization)
{
Matcher matcher = LINK_PATTERN.matcher(text);
StringBuffer xml = new StringBuffer();
List<HyperlinkData> hyperlinksData = new ArrayList<HyperlinkData>();
while (matcher.find())
{
String paramName = matcher.group(LINK_PARAM_NAME_GROUP);
JRPrintHyperlink hyperlink =
(JRPrintHyperlink) element.getParameterValue(paramName);
String replacement;
if (hyperlink == null)
{
if (log.isWarnEnabled())
{
log.warn("Hyperlink parameter " + paramName
+ " not found in element");
}
replacement = null;
}
else
{
replacement = linkProducer.getHyperlink(hyperlink);
if (prepareForSerialization) {
String id = String.valueOf(hyperlink.hashCode() & 0x7FFFFFFF);
HyperlinkData hyperlinkData = new HyperlinkData();
hyperlinkData.setId(id);
hyperlinkData.setHref(replacement);
hyperlinkData.setHyperlink(hyperlink);
hyperlinkData.setSelector("._jrHyperLink." + hyperlink.getLinkType());
replacement = "jrhl-" + id + ";" + hyperlink.getLinkType();
hyperlinksData.add(hyperlinkData);
}
}
if (replacement == null)
{
replacement = "";
}
else
{
try
{
if (!prepareForSerialization) {
replacement = URLEncoder.encode(replacement, "UTF-8");
}
}
catch (UnsupportedEncodingException e)
{
throw new JRRuntimeException(e);
}
}
matcher.appendReplacement(xml, replacement);
}
matcher.appendTail(xml);
if (hyperlinksData.size() > 0) {
element.setParameterValue("hyperlinksData", hyperlinksData);
}
return xml.toString();
}
/**
* Adds a comma-separated list of the short {@code Class} names of the
* method argument types to the output. For example, if a method has signature
* {@code put(java.lang.String, java.lang.Object)} then the value returned
* will be {@code String, Object}.
* @param methodInvocation the {@code MethodInvocation} being logged.
* Arguments will be retrieved from the corresponding {@code Method}.
* @param matcher the {@code Matcher} containing the state of the output
* @param output the {@code StringBuffer} containing the output
*/
private void appendArgumentTypes(MethodInvocation methodInvocation, Matcher matcher, StringBuffer output) {
Class<?>[] argumentTypes = methodInvocation.getMethod().getParameterTypes();
String[] argumentTypeShortNames = new String[argumentTypes.length];
for (int i = 0; i < argumentTypeShortNames.length; i++) {
argumentTypeShortNames[i] = ClassUtils.getShortName(argumentTypes[i]);
}
matcher.appendReplacement(output,
Matcher.quoteReplacement(StringUtils.arrayToCommaDelimitedString(argumentTypeShortNames)));
}