private static void append( final AppendingStringBuffer buffer, final CharSequence s, final int from, final int to) { if (s instanceof AppendingStringBuffer) { AppendingStringBuffer asb = (AppendingStringBuffer) s; buffer.append(asb.getValue(), from, to - from); } else { buffer.append(s.subSequence(from, to)); } }
/** * Replace all occurrences of one string replaceWith another string. * * @param s The string to process * @param searchFor The value to search for * @param replaceWith The value to searchFor replaceWith * @return The resulting string with searchFor replaced with replaceWith */ public static CharSequence replaceAll( final CharSequence s, final CharSequence searchFor, CharSequence replaceWith) { if (s == null) { return null; } // If searchFor is null or the empty string, then there is nothing to // replace, so returning s is the only option here. if ((searchFor == null) || "".equals(searchFor)) { return s; } // If replaceWith is null, then the searchFor should be replaced with // nothing, which can be seen as the empty string. if (replaceWith == null) { replaceWith = ""; } String searchString = searchFor.toString(); // Look for first occurrence of searchFor int matchIndex = search(s, searchString, 0); if (matchIndex == -1) { // No replace operation needs to happen return s; } else { // Allocate a AppendingStringBuffer that will hold one replacement // with a // little extra room. int size = s.length(); final int replaceWithLength = replaceWith.length(); final int searchForLength = searchFor.length(); if (replaceWithLength > searchForLength) { size += (replaceWithLength - searchForLength); } final AppendingStringBuffer buffer = new AppendingStringBuffer(size + 16); int pos = 0; do { // Append text up to the match append(buffer, s, pos, matchIndex); // Add replaceWith text buffer.append(replaceWith); // Find next occurrence, if any pos = matchIndex + searchForLength; matchIndex = search(s, searchString, pos); } while (matchIndex != -1); // Add tail of s buffer.append(s.subSequence(pos, s.length())); // Return processed buffer return buffer; } }
/** * Outputs the throwable and its stacktrace to the stringbuffer. If stopAtWicketSerlvet is true * then the output will stop when the org.apache.wicket servlet is reached. sun.reflect. packages * are filtered out. * * @param cause * @param sb * @param stopAtWicketServlet */ private static void outputThrowable( final Throwable cause, final AppendingStringBuffer sb, final boolean stopAtWicketServlet) { sb.append(cause); sb.append("\n"); StackTraceElement[] trace = cause.getStackTrace(); for (int i = 0; i < trace.length; i++) { String traceString = trace[i].toString(); if (!(traceString.startsWith("sun.reflect.") && (i > 1))) { sb.append(" at "); sb.append(traceString); sb.append("\n"); if (stopAtWicketServlet && (traceString.startsWith("org.apache.wicket.protocol.http.WicketServlet") || traceString.startsWith("org.apache.wicket.protocol.http.WicketFilter"))) { return; } } } }
/** * Converts a Throwable to a string. * * @param throwable The throwable * @return The string */ public static String toString(final Throwable throwable) { if (throwable != null) { List<Throwable> al = new ArrayList<Throwable>(); Throwable cause = throwable; al.add(cause); while ((cause.getCause() != null) && (cause != cause.getCause())) { cause = cause.getCause(); al.add(cause); } AppendingStringBuffer sb = new AppendingStringBuffer(256); // first print the last cause int length = al.size() - 1; cause = al.get(length); if (throwable instanceof RuntimeException) { sb.append("Message: "); sb.append(throwable.getMessage()); sb.append("\n\n"); } sb.append("Root cause:\n\n"); outputThrowable(cause, sb, false); if (length > 0) { sb.append("\n\nComplete stack:\n\n"); for (int i = 0; i < length; i++) { outputThrowable(al.get(i), sb, true); sb.append("\n"); } } return sb.toString(); } else { return "<Null Throwable>"; } }
/** * Converts a String to multiline HTML markup by replacing newlines with line break entities * (<br/>) and multiple occurrences of newline with paragraph break entities (<p>). * * @param s String to transform * @return String with all single occurrences of newline replaced with <br/> and all * multiple occurrences of newline replaced with <p>. */ public static CharSequence toMultilineMarkup(final CharSequence s) { if (s == null) { return null; } final AppendingStringBuffer buffer = new AppendingStringBuffer(); int newlineCount = 0; buffer.append("<p>"); for (int i = 0; i < s.length(); i++) { final char c = s.charAt(i); switch (c) { case '\n': newlineCount++; break; case '\r': break; default: if (newlineCount == 1) { buffer.append("<br/>"); } else if (newlineCount > 1) { buffer.append("</p><p>"); } buffer.append(c); newlineCount = 0; break; } } if (newlineCount == 1) { buffer.append("<br/>"); } else if (newlineCount > 1) { buffer.append("</p><p>"); } buffer.append("</p>"); return buffer; }
/** * Converts a Java String to an HTML markup String by replacing illegal characters with HTML * entities where appropriate. Spaces are converted to non-breaking spaces (<nbsp>) if * escapeSpaces is true, tabs are converted to four non-breaking spaces, less than signs are * converted to &lt; entities and greater than signs to &gt; entities. * * @param s The characters to escape * @param escapeSpaces True to replace ' ' with nonbreaking space * @param convertToHtmlUnicodeEscapes True to convert non-7 bit characters to unicode HTML (&#...) * @return The escaped string */ public static CharSequence escapeMarkup( final CharSequence s, final boolean escapeSpaces, final boolean convertToHtmlUnicodeEscapes) { if (s == null) { return null; } int len = s.length(); final AppendingStringBuffer buffer = new AppendingStringBuffer((int) (len * 1.1)); for (int i = 0; i < len; i++) { final char c = s.charAt(i); switch (c) { case '\t': if (escapeSpaces) { // Assumption is four space tabs (sorry, but that's // just how it is!) buffer.append(" "); } else { buffer.append(c); } break; case ' ': if (escapeSpaces) { buffer.append(" "); } else { buffer.append(c); } break; case '<': buffer.append("<"); break; case '>': buffer.append(">"); break; case '&': buffer.append("&"); break; case '"': buffer.append("""); break; case '\'': buffer.append("'"); break; default: int ci = 0xffff & c; if ( // if this is non-printable and not whitespace (TAB, LF, CR) ((ci < 32) && (ci != 9) && (ci != 10) && (ci != 13)) || // or non-ASCII (XXX: why 160+ ?!) and need to UNICODE escape it (convertToHtmlUnicodeEscapes && (ci > 159))) { buffer.append("&#"); buffer.append(Integer.toString(ci)); buffer.append(';'); } else { // ASCII or whitespace buffer.append(c); } break; } } return buffer; }