Skip to main content
summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat (limited to 'common/plugins/org.eclipse.jpt.common.utility/src/org/eclipse/jpt/common/utility/internal/StringTools.java')
-rw-r--r--common/plugins/org.eclipse.jpt.common.utility/src/org/eclipse/jpt/common/utility/internal/StringTools.java5095
1 files changed, 0 insertions, 5095 deletions
diff --git a/common/plugins/org.eclipse.jpt.common.utility/src/org/eclipse/jpt/common/utility/internal/StringTools.java b/common/plugins/org.eclipse.jpt.common.utility/src/org/eclipse/jpt/common/utility/internal/StringTools.java
deleted file mode 100644
index ec458be12b..0000000000
--- a/common/plugins/org.eclipse.jpt.common.utility/src/org/eclipse/jpt/common/utility/internal/StringTools.java
+++ /dev/null
@@ -1,5095 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005, 2011 Oracle. All rights reserved.
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0, which accompanies this distribution
- * and is available at http://www.eclipse.org/legal/epl-v10.html.
- *
- * Contributors:
- * Oracle - initial API and implementation
- ******************************************************************************/
-package org.eclipse.jpt.common.utility.internal;
-
-import java.io.IOException;
-import java.io.Writer;
-import java.util.Arrays;
-import java.util.Iterator;
-import org.eclipse.jpt.common.utility.internal.iterables.TransformationIterable;
-import org.eclipse.jpt.common.utility.internal.iterators.ArrayListIterator;
-import org.eclipse.jpt.common.utility.internal.iterators.TransformationIterator;
-
-/**
- * Convenience methods related to the java.lang.String class.
- *
- * As of jdk 1.5, it's tempting to convert all of these methods to use
- * java.lang.Appendable (instead of StringBuffer, StringBuilder, and Writer);
- * but all the Appendable methods throw java.io.IOException (yech) and we
- * [might?] get a bit better performance invoking methods on classes than
- * we get on interfaces. :-)
- */
-public final class StringTools {
-
- /** carriage return */
- public static final String CR = System.getProperty("line.separator"); //$NON-NLS-1$
-
- /** double quote */
- public static final char QUOTE = '"';
-
- /** parenthesis */
- public static final char OPEN_PARENTHESIS = '(';
- public static final char CLOSE_PARENTHESIS = ')';
-
- /** brackets */
- public static final char OPEN_BRACKET = '[';
- public static final char CLOSE_BRACKET = ']';
-
- /** brackets */
- public static final char OPEN_BRACE = '{';
- public static final char CLOSE_BRACE = '}';
-
- /** brackets */
- public static final char OPEN_CHEVRON = '<';
- public static final char CLOSE_CHEVRON = '>';
-
- /** empty string */
- public static final String EMPTY_STRING = ""; //$NON-NLS-1$
-
- /** empty char array */
- public static final char[] EMPTY_CHAR_ARRAY = new char[0];
-
- /** empty string array */
- public static final String[] EMPTY_STRING_ARRAY = new String[0];
-
-
-
- // ********** padding/truncating **********
-
- /**
- * Pad the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, an IllegalArgumentException is thrown.
- * If it is shorter than the specified length, it is padded with spaces at the end.
- * <p>
- * <code>
- * String.pad(int)
- * </code>
- */
- public static String pad(String string, int length) {
- return pad(string, length, ' ');
- }
-
- /**
- * Pad the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, an IllegalArgumentException is thrown.
- * If it is shorter than the specified length, it is padded with spaces at the end.
- * <p>
- * <code>
- * String.padOn(int, Writer)
- * </code>
- */
- public static void padOn(String string, int length, Writer writer) {
- padOn(string, length, ' ', writer);
- }
-
- /**
- * Pad the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, an IllegalArgumentException is thrown.
- * If it is shorter than the specified length, it is padded with spaces at the end.
- * <p>
- * <code>
- * String.padOn(int, StringBuffer)
- * </code>
- */
- public static void padOn(String string, int length, StringBuffer sb) {
- padOn(string, length, ' ', sb);
- }
-
- /**
- * Pad the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, an IllegalArgumentException is thrown.
- * If it is shorter than the specified length, it is padded with spaces at the end.
- * <p>
- * <code>
- * String.padOn(int, StringBuilder)
- * </code>
- */
- public static void padOn(String string, int length, StringBuilder sb) {
- padOn(string, length, ' ', sb);
- }
-
- /**
- * Pad the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, an IllegalArgumentException is thrown.
- * If it is shorter than the specified length, it is padded with the
- * specified character at the end.
- * <p>
- * <code>
- * String.pad(int, char)
- * </code>
- */
- public static String pad(String string, int length, char c) {
- int stringLength = string.length();
- if (stringLength > length) {
- throw new IllegalArgumentException("String is too long: " + stringLength + " > " + length); //$NON-NLS-1$ //$NON-NLS-2$
- }
- if (stringLength == length) {
- return string;
- }
- return pad_(string, length, c);
- }
-
- /**
- * Pad the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, an IllegalArgumentException is thrown.
- * If it is shorter than the specified length, it is padded with the
- * specified character at the end.
- * <p>
- * <code>
- * String.padOn(int, char, Writer)
- * </code>
- */
- public static void padOn(String string, int length, char c, Writer writer) {
- int stringLength = string.length();
- if (stringLength > length) {
- throw new IllegalArgumentException("String is too long: " + stringLength + " > " + length); //$NON-NLS-1$ //$NON-NLS-2$
- }
- if (stringLength == length) {
- writeStringOn(string, writer);
- } else {
- padOn_(string, length, c, writer);
- }
- }
-
- /**
- * Pad the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, an IllegalArgumentException is thrown.
- * If it is shorter than the specified length, it is padded with the
- * specified character at the end.
- * <p>
- * <code>
- * String.padOn(int, char, StringBuffer)
- * </code>
- */
- public static void padOn(String string, int length, char c, StringBuffer sb) {
- int stringLength = string.length();
- if (stringLength > length) {
- throw new IllegalArgumentException("String is too long: " + stringLength + " > " + length); //$NON-NLS-1$ //$NON-NLS-2$
- }
- if (stringLength == length) {
- sb.append(string);
- } else {
- padOn_(string, length, c, sb);
- }
- }
-
- /**
- * Pad the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, an IllegalArgumentException is thrown.
- * If it is shorter than the specified length, it is padded with the
- * specified character at the end.
- * <p>
- * <code>
- * String.padOn(int, char, StringBuilder)
- * </code>
- */
- public static void padOn(String string, int length, char c, StringBuilder sb) {
- int stringLength = string.length();
- if (stringLength > length) {
- throw new IllegalArgumentException("String is too long: " + stringLength + " > " + length); //$NON-NLS-1$ //$NON-NLS-2$
- }
- if (stringLength == length) {
- sb.append(string);
- } else {
- padOn_(string, length, c, sb);
- }
- }
-
- /**
- * Pad the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, an IllegalArgumentException is thrown.
- * If it is shorter than the specified length, it is padded with spaces at the end.
- * <p>
- * <code>
- * String.pad(int)
- * </code>
- */
- public static char[] pad(char[] string, int length) {
- return pad(string, length, ' ');
- }
-
- /**
- * Pad the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, an IllegalArgumentException is thrown.
- * If it is shorter than the specified length, it is padded with spaces at the end.
- * <p>
- * <code>
- * String.padOn(int, writer)
- * </code>
- */
- public static void padOn(char[] string, int length, Writer writer) {
- padOn(string, length, ' ', writer);
- }
-
- /**
- * Pad the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, an IllegalArgumentException is thrown.
- * If it is shorter than the specified length, it is padded with spaces at the end.
- * <p>
- * <code>
- * String.padOn(int, StringBuffer)
- * </code>
- */
- public static void padOn(char[] string, int length, StringBuffer sb) {
- padOn(string, length, ' ', sb);
- }
-
- /**
- * Pad the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, an IllegalArgumentException is thrown.
- * If it is shorter than the specified length, it is padded with spaces at the end.
- * <p>
- * <code>
- * String.padOn(int, StringBuilder)
- * </code>
- */
- public static void padOn(char[] string, int length, StringBuilder sb) {
- padOn(string, length, ' ', sb);
- }
-
- /**
- * Pad the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, an IllegalArgumentException is thrown.
- * If it is shorter than the specified length, it is padded with the
- * specified character at the end.
- * <p>
- * <code>
- * String.pad(int, char)
- * </code>
- */
- public static char[] pad(char[] string, int length, char c) {
- int stringLength = string.length;
- if (stringLength > length) {
- throw new IllegalArgumentException("String is too long: " + stringLength + " > " + length); //$NON-NLS-1$ //$NON-NLS-2$
- }
- if (stringLength == length) {
- return string;
- }
- return pad_(string, length, c);
- }
-
- /**
- * Pad the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, an IllegalArgumentException is thrown.
- * If it is shorter than the specified length, it is padded with the
- * specified character at the end.
- * <p>
- * <code>
- * String.padOn(int, char, Writer)
- * </code>
- */
- public static void padOn(char[] string, int length, char c, Writer writer) {
- int stringLength = string.length;
- if (stringLength > length) {
- throw new IllegalArgumentException("String is too long: " + stringLength + " > " + length); //$NON-NLS-1$ //$NON-NLS-2$
- }
- if (stringLength == length) {
- writeStringOn(string, writer);
- } else {
- padOn_(string, length, c, writer);
- }
- }
-
- /**
- * Pad the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, an IllegalArgumentException is thrown.
- * If it is shorter than the specified length, it is padded with the
- * specified character at the end.
- * <p>
- * <code>
- * String.padOn(int, char, StringBuffer)
- * </code>
- */
- public static void padOn(char[] string, int length, char c, StringBuffer sb) {
- int stringLength = string.length;
- if (stringLength > length) {
- throw new IllegalArgumentException("String is too long: " + stringLength + " > " + length); //$NON-NLS-1$ //$NON-NLS-2$
- }
- if (stringLength == length) {
- sb.append(string);
- } else {
- padOn_(string, length, c, sb);
- }
- }
-
- /**
- * Pad the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, an IllegalArgumentException is thrown.
- * If it is shorter than the specified length, it is padded with the
- * specified character at the end.
- * <p>
- * <code>
- * String.padOn(int, char, StringBuilder)
- * </code>
- */
- public static void padOn(char[] string, int length, char c, StringBuilder sb) {
- int stringLength = string.length;
- if (stringLength > length) {
- throw new IllegalArgumentException("String is too long: " + stringLength + " > " + length); //$NON-NLS-1$ //$NON-NLS-2$
- }
- if (stringLength == length) {
- sb.append(string);
- } else {
- padOn_(string, length, c, sb);
- }
- }
-
- /**
- * Pad or truncate the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, it is truncated.
- * If it is shorter than the specified length, it is padded with spaces at the end.
- * <p>
- * <code>
- * String.padOrTruncate(int)
- * </code>
- */
- public static String padOrTruncate(String string, int length) {
- return padOrTruncate(string, length, ' ');
- }
-
- /**
- * Pad or truncate the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, it is truncated.
- * If it is shorter than the specified length, it is padded with spaces at the end.
- * <p>
- * <code>
- * String.padOrTruncateOn(int, Writer)
- * </code>
- */
- public static void padOrTruncateOn(String string, int length, Writer writer) {
- padOrTruncateOn(string, length, ' ', writer);
- }
-
- /**
- * Pad or truncate the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, it is truncated.
- * If it is shorter than the specified length, it is padded with spaces at the end.
- * <p>
- * <code>
- * String.padOrTruncateOn(int, StringBuffer)
- * </code>
- */
- public static void padOrTruncateOn(String string, int length, StringBuffer sb) {
- padOrTruncateOn(string, length, ' ', sb);
- }
-
- /**
- * Pad or truncate the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, it is truncated.
- * If it is shorter than the specified length, it is padded with spaces at the end.
- * <p>
- * <code>
- * String.padOrTruncateOn(int, StringBuilder)
- * </code>
- */
- public static void padOrTruncateOn(String string, int length, StringBuilder sb) {
- padOrTruncateOn(string, length, ' ', sb);
- }
-
- /**
- * Pad or truncate the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, it is truncated.
- * If it is shorter than the specified length, it is padded with the
- * specified character at the end.
- * <p>
- * <code>
- * String.padOrTruncate(int, char)
- * </code>
- */
- public static String padOrTruncate(String string, int length, char c) {
- int stringLength = string.length();
- if (stringLength == length) {
- return string;
- }
- if (stringLength > length) {
- return string.substring(0, length);
- }
- return pad_(string, length, c);
- }
-
- /**
- * Pad or truncate the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, it is truncated.
- * If it is shorter than the specified length, it is padded with the
- * specified character at the end.
- * <p>
- * <code>
- * String.padOrTruncateOn(int, char, Writer)
- * </code>
- */
- public static void padOrTruncateOn(String string, int length, char c, Writer writer) {
- int stringLength = string.length();
- if (stringLength == length) {
- writeStringOn(string, writer);
- } else if (stringLength > length) {
- writeStringOn(string.substring(0, length), writer);
- } else {
- padOn_(string, length, c, writer);
- }
- }
-
- /**
- * Pad or truncate the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, it is truncated.
- * If it is shorter than the specified length, it is padded with the
- * specified character at the end.
- * <p>
- * <code>
- * String.padOrTruncateOn(int, char, StringBuffer)
- * </code>
- */
- public static void padOrTruncateOn(String string, int length, char c, StringBuffer sb) {
- int stringLength = string.length();
- if (stringLength == length) {
- sb.append(string);
- } else if (stringLength > length) {
- sb.append(string.substring(0, length));
- } else {
- padOn_(string, length, c, sb);
- }
- }
-
- /**
- * Pad or truncate the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, it is truncated.
- * If it is shorter than the specified length, it is padded with the
- * specified character at the end.
- * <p>
- * <code>
- * String.padOrTruncateOn(int, char, StringBuilder)
- * </code>
- */
- public static void padOrTruncateOn(String string, int length, char c, StringBuilder sb) {
- int stringLength = string.length();
- if (stringLength == length) {
- sb.append(string);
- } else if (stringLength > length) {
- sb.append(string.substring(0, length));
- } else {
- padOn_(string, length, c, sb);
- }
- }
-
- /**
- * Pad or truncate the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, it is truncated.
- * If it is shorter than the specified length, it is padded with spaces at the end.
- * <p>
- * <code>
- * String.padOrTruncate(int)
- * </code>
- */
- public static char[] padOrTruncate(char[] string, int length) {
- return padOrTruncate(string, length, ' ');
- }
-
- /**
- * Pad or truncate the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, it is truncated.
- * If it is shorter than the specified length, it is padded with spaces at the end.
- * <p>
- * <code>
- * String.padOrTruncateOn(int, Writer)
- * </code>
- */
- public static void padOrTruncateOn(char[] string, int length, Writer writer) {
- padOrTruncateOn(string, length, ' ', writer);
- }
-
- /**
- * Pad or truncate the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, it is truncated.
- * If it is shorter than the specified length, it is padded with spaces at the end.
- * <p>
- * <code>
- * String.padOrTruncateOn(int, StringBuffer)
- * </code>
- */
- public static void padOrTruncate(char[] string, int length, StringBuffer sb) {
- padOrTruncateOn(string, length, ' ', sb);
- }
-
- /**
- * Pad or truncate the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, it is truncated.
- * If it is shorter than the specified length, it is padded with spaces at the end.
- * <p>
- * <code>
- * String.padOrTruncateOn(int, StringBuilder)
- * </code>
- */
- public static void padOrTruncate(char[] string, int length, StringBuilder sb) {
- padOrTruncateOn(string, length, ' ', sb);
- }
-
- /**
- * Pad or truncate the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, it is truncated.
- * If it is shorter than the specified length, it is padded with the
- * specified character at the end.
- * <p>
- * <code>
- * String.padOrTruncate(int, char)
- * </code>
- */
- public static char[] padOrTruncate(char[] string, int length, char c) {
- int stringLength = string.length;
- if (stringLength == length) {
- return string;
- }
- if (stringLength > length) {
- char[] result = new char[length];
- System.arraycopy(string, 0, result, 0, length);
- return result;
- }
- return pad_(string, length, c);
- }
-
- /**
- * Pad or truncate the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, it is truncated.
- * If it is shorter than the specified length, it is padded with the
- * specified character at the end.
- * <p>
- * <code>
- * String.padOrTruncateOn(int, char, Writer)
- * </code>
- */
- public static void padOrTruncateOn(char[] string, int length, char c, Writer writer) {
- int stringLength = string.length;
- if (stringLength == length) {
- writeStringOn(string, writer);
- } else if (stringLength > length) {
- writeStringOn(string, 0, length, writer);
- } else {
- padOn_(string, length, c, writer);
- }
- }
-
- /**
- * Pad or truncate the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, it is truncated.
- * If it is shorter than the specified length, it is padded with the
- * specified character at the end.
- * <p>
- * <code>
- * String.padOrTruncateOn(int, char, StringBuffer)
- * </code>
- */
- public static void padOrTruncateOn(char[] string, int length, char c, StringBuffer sb) {
- int stringLength = string.length;
- if (stringLength == length) {
- sb.append(string);
- } else if (stringLength > length) {
- sb.append(string, 0, length);
- } else {
- padOn_(string, length, c, sb);
- }
- }
-
- /**
- * Pad or truncate the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, it is truncated.
- * If it is shorter than the specified length, it is padded with the
- * specified character at the end.
- * <p>
- * <code>
- * String.padOrTruncateOn(int, char, StringBuilder)
- * </code>
- */
- public static void padOrTruncateOn(char[] string, int length, char c, StringBuilder sb) {
- int stringLength = string.length;
- if (stringLength == length) {
- sb.append(string);
- } else if (stringLength > length) {
- sb.append(string, 0, length);
- } else {
- padOn_(string, length, c, sb);
- }
- }
-
- /*
- * Pad the specified string without validating the parms.
- */
- private static String pad_(String string, int length, char c) {
- return new String(pad_(string.toCharArray(), length, c));
- }
-
- /*
- * Pad the specified string without validating the parms.
- */
- private static void padOn_(String string, int length, char c, Writer writer) {
- writeStringOn(string, writer);
- fill_(string, length, c, writer);
- }
-
- /*
- * Add enough characters to the specified writer to compensate for
- * the difference between the specified string and specified length.
- */
- private static void fill_(String string, int length, char c, Writer writer) {
- fill_(string.length(), length, c, writer);
- }
-
- /*
- * Add enough characters to the specified writer to compensate for
- * the difference between the specified string and specified length.
- */
- private static void fill_(char[] string, int length, char c, Writer writer) {
- fill_(string.length, length, c, writer);
- }
-
- /*
- * Add enough characters to the specified writer to compensate for
- * the difference between the specified string and specified length.
- */
- private static void fill_(int stringLength, int length, char c, Writer writer) {
- writeStringOn(ArrayTools.fill(new char[length - stringLength], c), writer);
- }
-
- /*
- * Pad the specified string without validating the parms.
- */
- private static void padOn_(String string, int length, char c, StringBuffer sb) {
- sb.append(string);
- fill_(string, length, c, sb);
- }
-
- /*
- * Add enough characters to the specified string buffer to compensate for
- * the difference between the specified string and specified length.
- */
- private static void fill_(String string, int length, char c, StringBuffer sb) {
- fill_(string.length(), length, c, sb);
- }
-
- /*
- * Add enough characters to the specified string buffer to compensate for
- * the difference between the specified string and specified length.
- */
- private static void fill_(char[] string, int length, char c, StringBuffer sb) {
- fill_(string.length, length, c, sb);
- }
-
- /*
- * Add enough characters to the specified string buffer to compensate for
- * the difference between the specified string and specified length.
- */
- private static void fill_(int stringLength, int length, char c, StringBuffer sb) {
- sb.append(ArrayTools.fill(new char[length - stringLength], c));
- }
-
- /*
- * Pad the specified string without validating the parms.
- */
- private static void padOn_(String string, int length, char c, StringBuilder sb) {
- sb.append(string);
- fill_(string, length, c, sb);
- }
-
- /*
- * Add enough characters to the specified string builder to compensate for
- * the difference between the specified string and specified length.
- */
- private static void fill_(String string, int length, char c, StringBuilder sb) {
- fill_(string.length(), length, c, sb);
- }
-
- /*
- * Add enough characters to the specified string builder to compensate for
- * the difference between the specified string and specified length.
- */
- private static void fill_(char[] string, int length, char c, StringBuilder sb) {
- fill_(string.length, length, c, sb);
- }
-
- /*
- * Add enough characters to the specified string builder to compensate for
- * the difference between the specified string and specified length.
- */
- private static void fill_(int stringLength, int length, char c, StringBuilder sb) {
- sb.append(ArrayTools.fill(new char[length - stringLength], c));
- }
-
- /*
- * Pad the specified string without validating the parms.
- */
- private static char[] pad_(char[] string, int length, char c) {
- char[] result = new char[length];
- int stringLength = string.length;
- System.arraycopy(string, 0, result, 0, stringLength);
- Arrays.fill(result, stringLength, length, c);
- return result;
- }
-
- /*
- * Pad the specified string without validating the parms.
- */
- private static void padOn_(char[] string, int length, char c, Writer writer) {
- writeStringOn(string, writer);
- fill_(string, length, c, writer);
- }
-
- /*
- * Pad the specified string without validating the parms.
- */
- private static void padOn_(char[] string, int length, char c, StringBuffer sb) {
- sb.append(string);
- fill_(string, length, c, sb);
- }
-
- /*
- * Pad the specified string without validating the parms.
- */
- private static void padOn_(char[] string, int length, char c, StringBuilder sb) {
- sb.append(string);
- fill_(string, length, c, sb);
- }
-
- /**
- * Pad the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, an IllegalArgumentException is thrown.
- * If it is shorter than the specified length, it is padded with zeros at the front.
- * <p>
- * <code>
- * String.zeroPad(int)
- * </code>
- */
- public static String zeroPad(String string, int length) {
- return frontPad(string, length, '0');
- }
-
- /**
- * Pad the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, an IllegalArgumentException is thrown.
- * If it is shorter than the specified length, it is padded with zeros at the front.
- * <p>
- * <code>
- * String.zeroPadOn(int, Writer)
- * </code>
- */
- public static void zeroPadOn(String string, int length, Writer writer) {
- frontPadOn(string, length, '0', writer);
- }
-
- /**
- * Pad the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, an IllegalArgumentException is thrown.
- * If it is shorter than the specified length, it is padded with zeros at the front.
- * <p>
- * <code>
- * String.zeroPadOn(int, StringBuffer)
- * </code>
- */
- public static void zeroPadOn(String string, int length, StringBuffer sb) {
- frontPadOn(string, length, '0', sb);
- }
-
- /**
- * Pad the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, an IllegalArgumentException is thrown.
- * If it is shorter than the specified length, it is padded with zeros at the front.
- * <p>
- * <code>
- * String.zeroPadOn(int, StringBuilder)
- * </code>
- */
- public static void zeroPadOn(String string, int length, StringBuilder sb) {
- frontPadOn(string, length, '0', sb);
- }
-
- /**
- * Pad the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, an IllegalArgumentException is thrown.
- * If it is shorter than the specified length, it is padded with the
- * specified character at the front.
- * <p>
- * <code>
- * String.frontPad(int, char)
- * </code>
- */
- public static String frontPad(String string, int length, char c) {
- int stringLength = string.length();
- if (stringLength > length) {
- throw new IllegalArgumentException("String is too long: " + stringLength + " > " + length); //$NON-NLS-1$ //$NON-NLS-2$
- }
- if (stringLength == length) {
- return string;
- }
- return frontPad_(string, length, c);
- }
-
- /**
- * Pad the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, an IllegalArgumentException is thrown.
- * If it is shorter than the specified length, it is padded with the
- * specified character at the front.
- * <p>
- * <code>
- * String.frontPadOn(int, char, Writer)
- * </code>
- */
- public static void frontPadOn(String string, int length, char c, Writer writer) {
- int stringLength = string.length();
- if (stringLength > length) {
- throw new IllegalArgumentException("String is too long: " + stringLength + " > " + length); //$NON-NLS-1$ //$NON-NLS-2$
- }
- if (stringLength == length) {
- writeStringOn(string, writer);
- } else {
- frontPadOn_(string, length, c, writer);
- }
- }
-
- /**
- * Pad the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, an IllegalArgumentException is thrown.
- * If it is shorter than the specified length, it is padded with the
- * specified character at the front.
- * <p>
- * <code>
- * String.frontPadOn(int, char, StringBuffer)
- * </code>
- */
- public static void frontPadOn(String string, int length, char c, StringBuffer sb) {
- int stringLength = string.length();
- if (stringLength > length) {
- throw new IllegalArgumentException("String is too long: " + stringLength + " > " + length); //$NON-NLS-1$ //$NON-NLS-2$
- }
- if (stringLength == length) {
- sb.append(string);
- } else {
- frontPadOn_(string, length, c, sb);
- }
- }
-
- /**
- * Pad the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, an IllegalArgumentException is thrown.
- * If it is shorter than the specified length, it is padded with the
- * specified character at the front.
- * <p>
- * <code>
- * String.frontPadOn(int, char, StringBuilder)
- * </code>
- */
- public static void frontPadOn(String string, int length, char c, StringBuilder sb) {
- int stringLength = string.length();
- if (stringLength > length) {
- throw new IllegalArgumentException("String is too long: " + stringLength + " > " + length); //$NON-NLS-1$ //$NON-NLS-2$
- }
- if (stringLength == length) {
- sb.append(string);
- } else {
- frontPadOn_(string, length, c, sb);
- }
- }
-
- /**
- * Pad the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, an IllegalArgumentException is thrown.
- * If it is shorter than the specified length, it is padded with zeros at the front.
- * <p>
- * <code>
- * String.zeroPad(int)
- * </code>
- */
- public static char[] zeroPad(char[] string, int length) {
- return frontPad(string, length, '0');
- }
-
- /**
- * Pad the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, an IllegalArgumentException is thrown.
- * If it is shorter than the specified length, it is padded with zeros at the front.
- * <p>
- * <code>
- * String.zeroPadOn(int, Writer)
- * </code>
- */
- public static void zeroPadOn(char[] string, int length, Writer writer) {
- frontPadOn(string, length, '0', writer);
- }
-
- /**
- * Pad the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, an IllegalArgumentException is thrown.
- * If it is shorter than the specified length, it is padded with zeros at the front.
- * <p>
- * <code>
- * String.zeroPadOn(int, StringBuffer)
- * </code>
- */
- public static void zeroPadOn(char[] string, int length, StringBuffer sb) {
- frontPadOn(string, length, '0', sb);
- }
-
- /**
- * Pad the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, an IllegalArgumentException is thrown.
- * If it is shorter than the specified length, it is padded with zeros at the front.
- * <p>
- * <code>
- * String.zeroPadOn(int, StringBuilder)
- * </code>
- */
- public static void zeroPadOn(char[] string, int length, StringBuilder sb) {
- frontPadOn(string, length, '0', sb);
- }
-
- /**
- * Pad the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, an IllegalArgumentException is thrown.
- * If it is shorter than the specified length, it is padded with the
- * specified character at the front.
- * <p>
- * <code>
- * String.frontPad(int, char)
- * </code>
- */
- public static char[] frontPad(char[] string, int length, char c) {
- int stringLength = string.length;
- if (stringLength > length) {
- throw new IllegalArgumentException("String is too long: " + stringLength + " > " + length); //$NON-NLS-1$ //$NON-NLS-2$
- }
- if (stringLength == length) {
- return string;
- }
- return frontPad_(string, length, c);
- }
-
- /**
- * Pad the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, an IllegalArgumentException is thrown.
- * If it is shorter than the specified length, it is padded with the
- * specified character at the front.
- * <p>
- * <code>
- * String.frontPadOn(int, char, Writer)
- * </code>
- */
- public static void frontPadOn(char[] string, int length, char c, Writer writer) {
- int stringLength = string.length;
- if (stringLength > length) {
- throw new IllegalArgumentException("String is too long: " + stringLength + " > " + length); //$NON-NLS-1$ //$NON-NLS-2$
- }
- if (stringLength == length) {
- writeStringOn(string, writer);
- } else {
- frontPadOn_(string, length, c, writer);
- }
- }
-
- /**
- * Pad the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, an IllegalArgumentException is thrown.
- * If it is shorter than the specified length, it is padded with the
- * specified character at the front.
- * <p>
- * <code>
- * String.frontPadOn(int, char, StringBuffer)
- * </code>
- */
- public static void frontPadOn(char[] string, int length, char c, StringBuffer sb) {
- int stringLength = string.length;
- if (stringLength > length) {
- throw new IllegalArgumentException("String is too long: " + stringLength + " > " + length); //$NON-NLS-1$ //$NON-NLS-2$
- }
- if (stringLength == length) {
- sb.append(string);
- } else {
- frontPadOn_(string, length, c, sb);
- }
- }
-
- /**
- * Pad the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, an IllegalArgumentException is thrown.
- * If it is shorter than the specified length, it is padded with the
- * specified character at the front.
- * <p>
- * <code>
- * String.frontPadOn(int, char, StringBuilder)
- * </code>
- */
- public static void frontPadOn(char[] string, int length, char c, StringBuilder sb) {
- int stringLength = string.length;
- if (stringLength > length) {
- throw new IllegalArgumentException("String is too long: " + stringLength + " > " + length); //$NON-NLS-1$ //$NON-NLS-2$
- }
- if (stringLength == length) {
- sb.append(string);
- } else {
- frontPadOn_(string, length, c, sb);
- }
- }
-
- /**
- * Pad or truncate the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, only the last part of the string is returned.
- * If it is shorter than the specified length, it is padded with zeros at the front.
- * <p>
- * <code>
- * String.zeroPadOrTruncate(int)
- * </code>
- */
- public static String zeroPadOrTruncate(String string, int length) {
- return frontPadOrTruncate(string, length, '0');
- }
-
- /**
- * Pad or truncate the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, only the last part of the string is returned.
- * If it is shorter than the specified length, it is padded with zeros at the front.
- * <p>
- * <code>
- * String.zeroPadOrTruncateOn(int, Writer)
- * </code>
- */
- public static void zeroPadOrTruncateOn(String string, int length, Writer writer) {
- frontPadOrTruncateOn(string, length, '0', writer);
- }
-
- /**
- * Pad or truncate the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, only the last part of the string is returned.
- * If it is shorter than the specified length, it is padded with zeros at the front.
- * <p>
- * <code>
- * String.zeroPadOrTruncateOn(int, StringBuffer)
- * </code>
- */
- public static void zeroPadOrTruncateOn(String string, int length, StringBuffer sb) {
- frontPadOrTruncateOn(string, length, '0', sb);
- }
-
- /**
- * Pad or truncate the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, only the last part of the string is returned.
- * If it is shorter than the specified length, it is padded with zeros at the front.
- * <p>
- * <code>
- * String.zeroPadOrTruncateOn(int, StringBuilder)
- * </code>
- */
- public static void zeroPadOrTruncateOn(String string, int length, StringBuilder sb) {
- frontPadOrTruncateOn(string, length, '0', sb);
- }
-
- /**
- * Pad or truncate the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, only the last part of the string is returned.
- * If it is shorter than the specified length, it is padded with the
- * specified character at the front.
- * <p>
- * <code>
- * String.frontPadOrTruncate(int, char)
- * </code>
- */
- public static String frontPadOrTruncate(String string, int length, char c) {
- int stringLength = string.length();
- if (stringLength == length) {
- return string;
- }
- if (stringLength > length) {
- return string.substring(stringLength - length);
- }
- return frontPad_(string, length, c);
- }
-
- /**
- * Pad or truncate the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, only the last part of the string is returned.
- * If it is shorter than the specified length, it is padded with the
- * specified character at the front.
- * <p>
- * <code>
- * String.frontPadOrTruncateOn(int, char, Writer)
- * </code>
- */
- public static void frontPadOrTruncateOn(String string, int length, char c, Writer writer) {
- int stringLength = string.length();
- if (stringLength == length) {
- writeStringOn(string, writer);
- } else if (stringLength > length) {
- writeStringOn(string.substring(stringLength - length), writer);
- } else {
- frontPadOn_(string, length, c, writer);
- }
- }
-
- /**
- * Pad or truncate the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, only the last part of the string is returned.
- * If it is shorter than the specified length, it is padded with the
- * specified character at the front.
- * <p>
- * <code>
- * String.frontPadOrTruncateOn(int, char, StringBuffer)
- * </code>
- */
- public static void frontPadOrTruncateOn(String string, int length, char c, StringBuffer sb) {
- int stringLength = string.length();
- if (stringLength == length) {
- sb.append(string);
- } else if (stringLength > length) {
- sb.append(string.substring(stringLength - length));
- } else {
- frontPadOn_(string, length, c, sb);
- }
- }
-
- /**
- * Pad or truncate the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, only the last part of the string is returned.
- * If it is shorter than the specified length, it is padded with the
- * specified character at the front.
- * <p>
- * <code>
- * String.frontPadOrTruncateOn(int, char, StringBuilder)
- * </code>
- */
- public static void frontPadOrTruncateOn(String string, int length, char c, StringBuilder sb) {
- int stringLength = string.length();
- if (stringLength == length) {
- sb.append(string);
- } else if (stringLength > length) {
- sb.append(string.substring(stringLength - length));
- } else {
- frontPadOn_(string, length, c, sb);
- }
- }
-
- /**
- * Pad or truncate the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, only the last part of the string is returned.
- * If it is shorter than the specified length, it is padded with zeros at the front.
- * <p>
- * <code>
- * String.zeroPadOrTruncate(int)
- * </code>
- */
- public static char[] zeroPadOrTruncate(char[] string, int length) {
- return frontPadOrTruncate(string, length, '0');
- }
-
- /**
- * Pad or truncate the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, only the last part of the string is returned.
- * If it is shorter than the specified length, it is padded with zeros at the front.
- * <p>
- * <code>
- * String.zeroPadOrTruncateOn(int, Writer)
- * </code>
- */
- public static void zeroPadOrTruncateOn(char[] string, int length, Writer writer) {
- frontPadOrTruncateOn(string, length, '0', writer);
- }
-
- /**
- * Pad or truncate the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, only the last part of the string is returned.
- * If it is shorter than the specified length, it is padded with zeros at the front.
- * <p>
- * <code>
- * String.zeroPadOrTruncateOn(int, StringBuffer)
- * </code>
- */
- public static void zeroPadOrTruncateOn(char[] string, int length, StringBuffer sb) {
- frontPadOrTruncateOn(string, length, '0', sb);
- }
-
- /**
- * Pad or truncate the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, only the last part of the string is returned.
- * If it is shorter than the specified length, it is padded with zeros at the front.
- * <p>
- * <code>
- * String.zeroPadOrTruncateOn(int, StringBuilder)
- * </code>
- */
- public static void zeroPadOrTruncateOn(char[] string, int length, StringBuilder sb) {
- frontPadOrTruncateOn(string, length, '0', sb);
- }
-
- /**
- * Pad or truncate the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, only the last part of the string is returned.
- * If it is shorter than the specified length, it is padded with the
- * specified character at the front.
- * <p>
- * <code>
- * String.frontPadOrTruncate(int, char)
- * </code>
- */
- public static char[] frontPadOrTruncate(char[] string, int length, char c) {
- int stringLength = string.length;
- if (stringLength == length) {
- return string;
- }
- if (stringLength > length) {
- char[] result = new char[length];
- System.arraycopy(string, stringLength - length, result, 0, length);
- return result;
- }
- return frontPad_(string, length, c);
- }
-
- /**
- * Pad or truncate the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, only the last part of the string is returned.
- * If it is shorter than the specified length, it is padded with the
- * specified character at the front.
- * <p>
- * <code>
- * String.frontPadOrTruncateOn(int, char, Writer)
- * </code>
- */
- public static void frontPadOrTruncateOn(char[] string, int length, char c, Writer writer) {
- int stringLength = string.length;
- if (stringLength == length) {
- writeStringOn(string, writer);
- } else if (stringLength > length) {
- writeStringOn(string, stringLength - length, length, writer);
- } else {
- frontPadOn_(string, length, c, writer);
- }
- }
-
- /**
- * Pad or truncate the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, only the last part of the string is returned.
- * If it is shorter than the specified length, it is padded with the
- * specified character at the front.
- * <p>
- * <code>
- * String.frontPadOrTruncateOn(int, char, StringBuffer)
- * </code>
- */
- public static void frontPadOrTruncateOn(char[] string, int length, char c, StringBuffer sb) {
- int stringLength = string.length;
- if (stringLength == length) {
- sb.append(string);
- } else if (stringLength > length) {
- sb.append(string, stringLength - length, length);
- } else {
- frontPadOn_(string, length, c, sb);
- }
- }
-
- /**
- * Pad or truncate the specified string to the specified length.
- * If the string is already the specified length, it is returned unchanged.
- * If it is longer than the specified length, only the last part of the string is returned.
- * If it is shorter than the specified length, it is padded with the
- * specified character at the front.
- * <p>
- * <code>
- * String.frontPadOrTruncateOn(int, char, StringBuilder)
- * </code>
- */
- public static void frontPadOrTruncateOn(char[] string, int length, char c, StringBuilder sb) {
- int stringLength = string.length;
- if (stringLength == length) {
- sb.append(string);
- } else if (stringLength > length) {
- sb.append(string, stringLength - length, length);
- } else {
- frontPadOn_(string, length, c, sb);
- }
- }
-
- /*
- * Front-pad the specified string without validating the parms.
- */
- private static String frontPad_(String string, int length, char c) {
- return new String(frontPad_(string.toCharArray(), length, c));
- }
-
- /*
- * Zero-pad the specified string without validating the parms.
- */
- private static char[] frontPad_(char[] string, int length, char c) {
- char[] result = new char[length];
- int stringLength = string.length;
- int padLength = length - stringLength;
- System.arraycopy(string, 0, result, padLength, stringLength);
- Arrays.fill(result, 0, padLength, c);
- return result;
- }
-
- /*
- * Pad the specified string without validating the parms.
- */
- private static void frontPadOn_(String string, int length, char c, Writer writer) {
- fill_(string, length, c, writer);
- writeStringOn(string, writer);
- }
-
- /*
- * Pad the specified string without validating the parms.
- */
- private static void frontPadOn_(char[] string, int length, char c, Writer writer) {
- fill_(string, length, c, writer);
- writeStringOn(string, writer);
- }
-
- /*
- * Pad the specified string without validating the parms.
- */
- private static void frontPadOn_(String string, int length, char c, StringBuffer sb) {
- fill_(string, length, c, sb);
- sb.append(string);
- }
-
- /*
- * Pad the specified string without validating the parms.
- */
- private static void frontPadOn_(char[] string, int length, char c, StringBuffer sb) {
- fill_(string, length, c, sb);
- sb.append(string);
- }
-
- /*
- * Pad the specified string without validating the parms.
- */
- private static void frontPadOn_(String string, int length, char c, StringBuilder sb) {
- fill_(string, length, c, sb);
- sb.append(string);
- }
-
- /*
- * Pad the specified string without validating the parms.
- */
- private static void frontPadOn_(char[] string, int length, char c, StringBuilder sb) {
- fill_(string, length, c, sb);
- sb.append(string);
- }
-
-
- // ********** separating **********
-
- /**
- * Separate the segments of the specified string with the specified
- * separator:<pre>
- * separate("012345", '-', 2) => "01-23-45"
- * </pre>
- */
- public static String separate(String string, char separator, int segmentSize) {
- if (segmentSize <= 0) {
- throw new IllegalArgumentException("segment size must be positive: " + segmentSize); //$NON-NLS-1$
- }
- int len = string.length();
- return (len <= segmentSize) ? string : new String(separate(string.toCharArray(), separator, segmentSize, len));
- }
-
- /**
- * Separate the segments of the specified string with the specified
- * separator:<pre>
- * separate("012345", '-', 2) => "01-23-45"
- * </pre>
- */
- public static void separateOn(String string, char separator, int segmentSize, Writer writer) {
- if (segmentSize <= 0) {
- throw new IllegalArgumentException("segment size must be positive: " + segmentSize); //$NON-NLS-1$
- }
- if (string.length() <= segmentSize) {
- writeStringOn(string, writer);
- } else {
- separateOn_(string.toCharArray(), separator, segmentSize, writer);
- }
- }
-
- /**
- * Separate the segments of the specified string with the specified
- * separator:<pre>
- * separate("012345", '-', 2) => "01-23-45"
- * </pre>
- */
- public static void separateOn(String string, char separator, int segmentSize, StringBuffer sb) {
- if (segmentSize <= 0) {
- throw new IllegalArgumentException("segment size must be positive: " + segmentSize); //$NON-NLS-1$
- }
- if (string.length() <= segmentSize) {
- sb.append(string);
- } else {
- separateOn_(string.toCharArray(), separator, segmentSize, sb);
- }
- }
-
- /**
- * Separate the segments of the specified string with the specified
- * separator:<pre>
- * separate("012345", '-', 2) => "01-23-45"
- * </pre>
- */
- public static void separateOn(String string, char separator, int segmentSize, StringBuilder sb) {
- if (segmentSize <= 0) {
- throw new IllegalArgumentException("segment size must be positive: " + segmentSize); //$NON-NLS-1$
- }
- if (string.length() <= segmentSize) {
- sb.append(string);
- } else {
- separateOn_(string.toCharArray(), separator, segmentSize, sb);
- }
- }
-
- /**
- * Separate the segments of the specified string with the specified
- * separator:<pre>
- * separate("012345", '-', 2) => "01-23-45"
- * </pre>
- */
- public static char[] separate(char[] string, char separator, int segmentSize) {
- if (segmentSize <= 0) {
- throw new IllegalArgumentException("segment size must be positive: " + segmentSize); //$NON-NLS-1$
- }
- int len = string.length;
- return (len <= segmentSize) ? string : separate(string, separator, segmentSize, len);
- }
-
- /**
- * pre-conditions: string is longer than segment size; segment size is positive
- */
- private static char[] separate(char[] string, char separator, int segmentSize, int len) {
- int resultLen = len + (len / segmentSize);
- if ((len % segmentSize) == 0) {
- resultLen--; // no separator after the final segment if nothing following it
- }
- char[] result = new char[resultLen];
- int j = 0;
- int segCount = 0;
- for (char c : string) {
- if (segCount == segmentSize) {
- result[j++] = separator;
- segCount = 0;
- }
- segCount++;
- result[j++] = c;
- }
- return result;
- }
-
- /**
- * Separate the segments of the specified string with the specified
- * separator:<pre>
- * separate("012345", '-', 2) => "01-23-45"
- * </pre>
- */
- public static void separateOn(char[] string, char separator, int segmentSize, Writer writer) {
- if (segmentSize <= 0) {
- throw new IllegalArgumentException("segment size must be positive: " + segmentSize); //$NON-NLS-1$
- }
- if (string.length <= segmentSize) {
- writeStringOn(string, writer);
- } else {
- separateOn_(string, separator, segmentSize, writer);
- }
- }
-
- /**
- * pre-conditions: string is longer than segment size; segment size is positive
- */
- private static void separateOn_(char[] string, char separator, int segmentSize, Writer writer) {
- int segCount = 0;
- for (char c : string) {
- if (segCount == segmentSize) {
- writeCharOn(separator, writer);
- segCount = 0;
- }
- segCount++;
- writeCharOn(c, writer);
- }
- }
-
- /**
- * Separate the segments of the specified string with the specified
- * separator:<pre>
- * separate("012345", '-', 2) => "01-23-45"
- * </pre>
- */
- public static void separateOn(char[] string, char separator, int segmentSize, StringBuffer sb) {
- if (segmentSize <= 0) {
- throw new IllegalArgumentException("segment size must be positive: " + segmentSize); //$NON-NLS-1$
- }
- if (string.length <= segmentSize) {
- sb.append(string);
- } else {
- separateOn_(string, separator, segmentSize, sb);
- }
- }
-
- /**
- * pre-conditions: string is longer than segment size; segment size is positive
- */
- private static void separateOn_(char[] string, char separator, int segmentSize, StringBuffer sb) {
- int segCount = 0;
- for (char c : string) {
- if (segCount == segmentSize) {
- sb.append(separator);
- segCount = 0;
- }
- segCount++;
- sb.append(c);
- }
- }
-
- /**
- * Separate the segments of the specified string with the specified
- * separator:<pre>
- * separate("012345", '-', 2) => "01-23-45"
- * </pre>
- */
- public static void separateOn(char[] string, char separator, int segmentSize, StringBuilder sb) {
- if (segmentSize <= 0) {
- throw new IllegalArgumentException("segment size must be positive: " + segmentSize); //$NON-NLS-1$
- }
- if (string.length <= segmentSize) {
- sb.append(string);
- } else {
- separateOn_(string, separator, segmentSize, sb);
- }
- }
-
- /**
- * pre-conditions: string is longer than segment size; segment size is positive
- */
- private static void separateOn_(char[] string, char separator, int segmentSize, StringBuilder sb) {
- int segCount = 0;
- for (char c : string) {
- if (segCount == segmentSize) {
- sb.append(separator);
- segCount = 0;
- }
- segCount++;
- sb.append(c);
- }
- }
-
-
- // ********** delimiting/quoting **********
-
- /**
- * Delimit the specified string with double quotes.
- * Escape any occurrences of a double quote in the string with another
- * double quote.
- */
- public static String quote(String string) {
- return delimit(string, QUOTE);
- }
-
- /**
- * Delimit the specified string with double quotes.
- * Escape any occurrences of a double quote in the string with another
- * double quote.
- */
- public static void quoteOn(String string, Writer writer) {
- delimitOn(string, QUOTE, writer);
- }
-
- /**
- * Delimit the specified string with double quotes.
- * Escape any occurrences of a double quote in the string with another
- * double quote.
- */
- public static void quoteOn(String string, StringBuffer sb) {
- delimitOn(string, QUOTE, sb);
- }
-
- /**
- * Delimit the specified string with double quotes.
- * Escape any occurrences of a double quote in the string with another
- * double quote.
- */
- public static void quoteOn(String string, StringBuilder sb) {
- delimitOn(string, QUOTE, sb);
- }
-
- /**
- * Delimit each of the specified strings with double quotes.
- * Escape any occurrences of a double quote in a string with another
- * double quote.
- */
- public static Iterator<String> quote(Iterator<String> strings) {
- return delimit(strings, QUOTE);
- }
-
- /**
- * Delimit the specified string with the specified delimiter; i.e. put a copy of
- * the delimiter at the front and back of the resulting string.
- * Escape any occurrences of the delimiter in the string with another delimiter.
- */
- public static String delimit(String string, char delimiter) {
- return new String(delimit(string.toCharArray(), delimiter));
- }
-
- /**
- * Delimit the specified string with the specified delimiter; i.e. put a copy of
- * the delimiter at the front and back of the resulting string.
- * Escape any occurrences of the delimiter in the string with another delimiter.
- */
- public static void delimitOn(String string, char delimiter, Writer writer) {
- delimitOn(string.toCharArray(), delimiter, writer);
- }
-
- /**
- * Delimit the specified string with the specified delimiter; i.e. put a copy of
- * the delimiter at the front and back of the resulting string.
- * Escape any occurrences of the delimiter in the string with another delimiter.
- */
- public static void delimitOn(String string, char delimiter, StringBuffer sb) {
- delimitOn(string.toCharArray(), delimiter, sb);
- }
-
- /**
- * Delimit the specified string with the specified delimiter; i.e. put a copy of
- * the delimiter at the front and back of the resulting string.
- * Escape any occurrences of the delimiter in the string with another delimiter.
- */
- public static void delimitOn(String string, char delimiter, StringBuilder sb) {
- delimitOn(string.toCharArray(), delimiter, sb);
- }
-
- /**
- * Delimit each of the specified strings with the specified delimiter; i.e. put a
- * copy of the delimiter at the front and back of the resulting string.
- * Escape any occurrences of the delimiter in a string with another delimiter.
- */
- public static Iterable<String> delimit(Iterable<String> strings, char delimiter) {
- return new TransformationIterable<String, String>(strings, new CharStringDelimiter(delimiter));
- }
-
- /**
- * Delimit each of the specified strings with the specified delimiter; i.e. put a
- * copy of the delimiter at the front and back of the resulting string.
- * Escape any occurrences of the delimiter in a string with another delimiter.
- */
- public static Iterator<String> delimit(Iterator<String> strings, char delimiter) {
- return new TransformationIterator<String, String>(strings, new CharStringDelimiter(delimiter));
- }
-
- private static class CharStringDelimiter implements Transformer<String, String> {
- private char delimiter;
- CharStringDelimiter(char delimiter) {
- super();
- this.delimiter = delimiter;
- }
- public String transform(String string) {
- return StringTools.delimit(string, this.delimiter);
- }
- }
-
- /**
- * Delimit the specified string with the specified delimiter; i.e. put a copy of
- * the delimiter at the front and back of the resulting string.
- * Escape any occurrences of a single-character delimiter in the string with
- * another delimiter.
- */
- public static String delimit(String string, String delimiter) {
- if (delimiter.length() == 1) {
- return delimit(string, delimiter.charAt(0));
- }
- return new String(delimit(string.toCharArray(), delimiter.toCharArray()));
- }
-
- /**
- * Delimit the specified string with the specified delimiter; i.e. put a copy of
- * the delimiter at the front and back of the resulting string.
- * Escape any occurrences of a single-character delimiter in the string with
- * another delimiter.
- */
- public static void delimitOn(String string, String delimiter, Writer writer) {
- if (delimiter.length() == 1) {
- delimitOn(string, delimiter.charAt(0), writer);
- } else {
- delimitOn(string.toCharArray(), delimiter.toCharArray(), writer);
- }
- }
-
- /**
- * Delimit the specified string with the specified delimiter; i.e. put a copy of
- * the delimiter at the front and back of the resulting string.
- * Escape any occurrences of a single-character delimiter in the string with
- * another delimiter.
- */
- public static void delimitOn(String string, String delimiter, StringBuffer sb) {
- if (delimiter.length() == 1) {
- delimitOn(string, delimiter.charAt(0), sb);
- } else {
- delimitOn(string.toCharArray(), delimiter.toCharArray(), sb);
- }
- }
-
- /**
- * Delimit the specified string with the specified delimiter; i.e. put a copy of
- * the delimiter at the front and back of the resulting string.
- * Escape any occurrences of a single-character delimiter in the string with
- * another delimiter.
- */
- public static void delimitOn(String string, String delimiter, StringBuilder sb) {
- if (delimiter.length() == 1) {
- delimitOn(string, delimiter.charAt(0), sb);
- } else {
- delimitOn(string.toCharArray(), delimiter.toCharArray(), sb);
- }
- }
-
- /**
- * Delimit each of the specified strings with the specified delimiter; i.e. put a
- * copy of the delimiter at the front and back of the resulting string.
- * Escape any occurrences of a single-character delimiter in a string with
- * another delimiter.
- */
- public static Iterable<String> delimit(Iterable<String> strings, String delimiter) {
- return (delimiter.length() == 1) ?
- delimit(strings, delimiter.charAt(0)) :
- new TransformationIterable<String, String>(strings, new StringStringDelimiter(delimiter));
- }
-
- /**
- * Delimit each of the specified strings with the specified delimiter; i.e. put a
- * copy of the delimiter at the front and back of the resulting string.
- * Escape any occurrences of a single-character delimiter in a string with
- * another delimiter.
- */
- public static Iterator<String> delimit(Iterator<String> strings, String delimiter) {
- return (delimiter.length() == 1) ?
- delimit(strings, delimiter.charAt(0)) :
- new TransformationIterator<String, String>(strings, new StringStringDelimiter(delimiter));
- }
-
- private static class StringStringDelimiter implements Transformer<String, String> {
- private String delimiter;
- StringStringDelimiter(String delimiter) {
- super();
- this.delimiter = delimiter;
- }
- public String transform(String string) {
- return StringTools.delimit(string, this.delimiter);
- }
- }
-
- /**
- * Delimit the specified string with double quotes.
- * Escape any occurrences of a double quote in the string with another
- * double quote.
- */
- public static char[] quote(char[] string) {
- return delimit(string, QUOTE);
- }
-
- /**
- * Delimit the specified string with double quotes.
- * Escape any occurrences of a double quote in the string with another
- * double quote.
- */
- public static void quoteOn(char[] string, Writer writer) {
- delimitOn(string, QUOTE, writer);
- }
-
- /**
- * Delimit the specified string with double quotes.
- * Escape any occurrences of a double quote in the string with another
- * double quote.
- */
- public static void quoteOn(char[] string, StringBuffer sb) {
- delimitOn(string, QUOTE, sb);
- }
-
- /**
- * Delimit the specified string with double quotes.
- * Escape any occurrences of a double quote in the string with another
- * double quote.
- */
- public static void quoteOn(char[] string, StringBuilder sb) {
- delimitOn(string, QUOTE, sb);
- }
-
- /**
- * Delimit each of the specified strings with double quotes.
- * Escape any occurrences of a double quote in a string with another
- * double quote.
- */
- // cannot name method simply 'quote' because of type-erasure...
- public static Iterator<char[]> quoteCharArrays(Iterator<char[]> strings) {
- return delimitCharArrays(strings, QUOTE);
- }
-
- /**
- * Delimit the specified string with the specified delimiter; i.e. put a copy of
- * the delimiter at the front and back of the resulting string.
- * Escape any occurrences of the delimiter in the string with another delimiter.
- */
- public static char[] delimit(char[] string, char delimiter) {
- StringBuilder sb = new StringBuilder(string.length + 2);
- delimitOn(string, delimiter, sb);
- return convertToCharArray(sb);
- }
-
- /**
- * Delimit the specified string with the specified delimiter; i.e. put a copy of
- * the delimiter at the front and back of the resulting string.
- * Escape any occurrences of the delimiter in the string with another delimiter.
- */
- public static void delimitOn(char[] string, char delimiter, Writer writer) {
- writeCharOn(delimiter, writer);
- writeStringOn(string, delimiter, writer);
- writeCharOn(delimiter, writer);
- }
-
- /**
- * Delimit the specified string with the specified delimiter; i.e. put a copy of
- * the delimiter at the front and back of the resulting string.
- * Escape any occurrences of the delimiter in the string with another delimiter.
- */
- public static void delimitOn(char[] string, char delimiter, StringBuffer sb) {
- sb.append(delimiter);
- for (char c : string) {
- if (c == delimiter) {
- sb.append(c);
- }
- sb.append(c);
- }
- sb.append(delimiter);
- }
-
- /**
- * Delimit the specified string with the specified delimiter; i.e. put a copy of
- * the delimiter at the front and back of the resulting string.
- * Escape any occurrences of the delimiter in the string with another delimiter.
- */
- public static void delimitOn(char[] string, char delimiter, StringBuilder sb) {
- sb.append(delimiter);
- for (char c : string) {
- if (c == delimiter) {
- sb.append(c);
- }
- sb.append(c);
- }
- sb.append(delimiter);
- }
-
- /**
- * Delimit each of the specified strings with the specified delimiter; i.e. put a
- * copy of the delimiter at the front and back of the resulting string.
- * Escape any occurrences of the delimiter in a string with another delimiter.
- */
- // cannot name method simply 'delimit' because of type-erasure...
- public static Iterable<char[]> delimitCharArrays(Iterable<char[]> strings, char delimiter) {
- return new TransformationIterable<char[], char[]>(strings, new CharCharArrayDelimiter(delimiter));
- }
-
- /**
- * Delimit each of the specified strings with the specified delimiter; i.e. put a
- * copy of the delimiter at the front and back of the resulting string.
- * Escape any occurrences of the delimiter in a string with another delimiter.
- */
- // cannot name method simply 'delimit' because of type-erasure...
- public static Iterator<char[]> delimitCharArrays(Iterator<char[]> strings, char delimiter) {
- return new TransformationIterator<char[], char[]>(strings, new CharCharArrayDelimiter(delimiter));
- }
-
- private static class CharCharArrayDelimiter implements Transformer<char[], char[]> {
- private char delimiter;
- CharCharArrayDelimiter(char delimiter) {
- super();
- this.delimiter = delimiter;
- }
- public char[] transform(char[] string) {
- return StringTools.delimit(string, this.delimiter);
- }
- }
-
- /**
- * Delimit the specified string with the specified delimiter; i.e. put a copy of
- * the delimiter at the front and back of the resulting string.
- * Escape any occurrences of a single-character delimiter in the string with
- * another delimiter.
- */
- public static char[] delimit(char[] string, char[] delimiter) {
- int delimiterLength = delimiter.length;
- if (delimiterLength == 1) {
- return delimit(string, delimiter[0]);
- }
- int stringLength = string.length;
- char[] result = new char[stringLength+(2*delimiterLength)];
- System.arraycopy(delimiter, 0, result, 0, delimiterLength);
- System.arraycopy(string, 0, result, delimiterLength, stringLength);
- System.arraycopy(delimiter, 0, result, stringLength+delimiterLength, delimiterLength);
- return result;
- }
-
- /**
- * Delimit the specified string with the specified delimiter; i.e. put a copy of
- * the delimiter at the front and back of the resulting string.
- * Escape any occurrences of a single-character delimiter in the string with
- * another delimiter.
- */
- public static void delimitOn(char[] string, char[] delimiter, Writer writer) {
- if (delimiter.length == 1) {
- delimitOn(string, delimiter[0], writer);
- } else {
- writeStringOn(delimiter, writer);
- writeStringOn(string, writer);
- writeStringOn(delimiter, writer);
- }
- }
-
- /**
- * Delimit the specified string with the specified delimiter; i.e. put a copy of
- * the delimiter at the front and back of the resulting string.
- * Escape any occurrences of a single-character delimiter in the string with
- * another delimiter.
- */
- public static void delimitOn(char[] string, char[] delimiter, StringBuffer sb) {
- if (delimiter.length == 1) {
- delimitOn(string, delimiter[0], sb);
- } else {
- sb.append(delimiter);
- sb.append(string);
- sb.append(delimiter);
- }
- }
-
- /**
- * Delimit the specified string with the specified delimiter; i.e. put a copy of
- * the delimiter at the front and back of the resulting string.
- * Escape any occurrences of a single-character delimiter in the string with
- * another delimiter.
- */
- public static void delimitOn(char[] string, char[] delimiter, StringBuilder sb) {
- if (delimiter.length == 1) {
- delimitOn(string, delimiter[0], sb);
- } else {
- sb.append(delimiter);
- sb.append(string);
- sb.append(delimiter);
- }
- }
-
- /**
- * Delimit each of the specified strings with the specified delimiter; i.e. put a
- * copy of the delimiter at the front and back of the resulting string.
- * Escape any occurrences of a single-character delimiter in a string with
- * another delimiter.
- */
- // cannot name method simply 'delimit' because of type-erasure...
- public static Iterable<char[]> delimitCharArrays(Iterable<char[]> strings, char[] delimiter) {
- return new TransformationIterable<char[], char[]>(strings, new CharArrayCharArrayDelimiter(delimiter));
- }
-
- /**
- * Delimit each of the specified strings with the specified delimiter; i.e. put a
- * copy of the delimiter at the front and back of the resulting string.
- * Escape any occurrences of a single-character delimiter in a string with
- * another delimiter.
- */
- // cannot name method simply 'delimit' because of type-erasure...
- public static Iterator<char[]> delimitCharArrays(Iterator<char[]> strings, char[] delimiter) {
- return new TransformationIterator<char[], char[]>(strings, new CharArrayCharArrayDelimiter(delimiter));
- }
-
- private static class CharArrayCharArrayDelimiter implements Transformer<char[], char[]> {
- private char[] delimiter;
- CharArrayCharArrayDelimiter(char[] delimiter) {
- super();
- this.delimiter = delimiter;
- }
- public char[] transform(char[] string) {
- return StringTools.delimit(string, this.delimiter);
- }
- }
-
-
- // ********** delimiting queries **********
-
- /**
- * Return whether the specified string is quoted: "\"foo\"".
- */
- public static boolean stringIsQuoted(String string) {
- return stringIsDelimited(string, QUOTE);
- }
-
- /**
- * Return whether the specified string is parenthetical: "(foo)".
- */
- public static boolean stringIsParenthetical(String string) {
- return stringIsDelimited(string, OPEN_PARENTHESIS, CLOSE_PARENTHESIS);
- }
-
- /**
- * Return whether the specified string is bracketed: "[foo]".
- */
- public static boolean stringIsBracketed(String string) {
- return stringIsDelimited(string, OPEN_BRACKET, CLOSE_BRACKET);
- }
-
- /**
- * Return whether the specified string is braced: "{foo}".
- */
- public static boolean stringIsBraced(String string) {
- return stringIsDelimited(string, OPEN_BRACE, CLOSE_BRACE);
- }
-
- /**
- * Return whether the specified string is chevroned: "<foo>".
- */
- public static boolean stringIsChevroned(String string) {
- return stringIsDelimited(string, OPEN_CHEVRON, CLOSE_CHEVRON);
- }
-
- /**
- * Return whether the specified string is delimited by the specified
- * character.
- */
- public static boolean stringIsDelimited(String string, char c) {
- return stringIsDelimited(string, c, c);
- }
-
- /**
- * Return whether the specified string is delimited by the specified
- * characters.
- */
- public static boolean stringIsDelimited(String string, char start, char end) {
- int len = string.length();
- if (len < 2) {
- return false;
- }
- return stringIsDelimited(string.toCharArray(), start, end, len);
- }
-
- /**
- * Return whether the specified string is quoted: "\"foo\"".
- */
- public static boolean stringIsQuoted(char[] string) {
- return stringIsDelimited(string, QUOTE);
- }
-
- /**
- * Return whether the specified string is parenthetical: "(foo)".
- */
- public static boolean stringIsParenthetical(char[] string) {
- return stringIsDelimited(string, OPEN_PARENTHESIS, CLOSE_PARENTHESIS);
- }
-
- /**
- * Return whether the specified string is bracketed: "[foo]".
- */
- public static boolean stringIsBracketed(char[] string) {
- return stringIsDelimited(string, OPEN_BRACKET, CLOSE_BRACKET);
- }
-
- /**
- * Return whether the specified string is braced: "{foo}".
- */
- public static boolean stringIsBraced(char[] string) {
- return stringIsDelimited(string, OPEN_BRACE, CLOSE_BRACE);
- }
-
- /**
- * Return whether the specified string is chevroned: "<foo>".
- */
- public static boolean stringIsChevroned(char[] string) {
- return stringIsDelimited(string, OPEN_CHEVRON, CLOSE_CHEVRON);
- }
-
- /**
- * Return whether the specified string is delimited by the specified
- * character.
- */
- public static boolean stringIsDelimited(char[] string, char c) {
- return stringIsDelimited(string, c, c);
- }
-
- /**
- * Return whether the specified string is delimited by the specified
- * characters.
- */
- public static boolean stringIsDelimited(char[] string, char start, char end) {
- int len = string.length;
- if (len < 2) {
- return false;
- }
- return stringIsDelimited(string, start, end, len);
- }
-
- private static boolean stringIsDelimited(char[] s, char start, char end, int len) {
- return (s[0] == start) && (s[len - 1] == end);
- }
-
-
- // ********** undelimiting **********
-
- /**
- * Remove the delimiters from the specified string, removing any escape
- * characters. Throw an IllegalArgumentException if the string is too short
- * to undelimit (i.e. length < 2).
- */
- public static String undelimit(String string) {
- int len = string.length() - 2;
- if (len < 0) {
- throw new IllegalArgumentException("invalid string: \"" + string + '"'); //$NON-NLS-1$
- }
- if (len == 0) {
- return EMPTY_STRING;
- }
- return new String(undelimit_(string.toCharArray(), len));
- }
-
- /**
- * Remove the first and last count characters from the specified string.
- * If the string is too short to be undelimited, throw an
- * IllegalArgumentException.
- * Use this method to undelimit strings that do not escape embedded
- * delimiters.
- */
- public static String undelimit(String string, int count) {
- int len = string.length() - (2 * count);
- if (len < 0) {
- throw new IllegalArgumentException("invalid string: \"" + string + '"'); //$NON-NLS-1$
- }
- if (len == 0) {
- return EMPTY_STRING;
- }
- return new String(undelimit(string.toCharArray(), len, count));
- }
-
- /**
- * Remove the delimiters from the specified string, removing any escape
- * characters. Throw an IllegalArgumentException if the string is too short
- * to undelimit (i.e. length < 2).
- */
- public static char[] undelimit(char[] string) {
- int len = string.length - 2;
- if (len < 0) {
- throw new IllegalArgumentException("invalid string: \"" + new String(string) + '"'); //$NON-NLS-1$
- }
- if (len == 0) {
- return EMPTY_CHAR_ARRAY;
- }
- return undelimit_(string, len);
- }
-
- private static char[] undelimit_(char[] string, int length) {
- StringBuilder sb = new StringBuilder(length);
- undelimitOn_(string, sb);
- return convertToCharArray(sb);
- }
-
- /**
- * Remove the first and last count characters from the specified string.
- * If the string is too short to be undelimited, throw an
- * IllegalArgumentException.
- * Use this method to undelimit strings that do not escape embedded
- * delimiters.
- */
- public static char[] undelimit(char[] string, int count) {
- int len = string.length - (2 * count);
- if (len < 0) {
- throw new IllegalArgumentException("invalid string: \"" + new String(string) + '"'); //$NON-NLS-1$
- }
- if (len == 0) {
- return EMPTY_CHAR_ARRAY;
- }
- return undelimit(string, len, count);
- }
-
- private static char[] undelimit(char[] string, int len, int count) {
- char[] result = new char[len];
- System.arraycopy(string, count, result, 0, len);
- return result;
- }
-
- /**
- * Remove the delimiters from the specified string, removing any escape
- * characters. Throw an IllegalArgumentException if the string is too short
- * to undelimit (i.e. length < 2).
- */
- public static void undelimitOn(String string, Writer writer) {
- undelimitOn(string.toCharArray(), writer);
- }
-
- /**
- * Remove the first and last count characters from the specified string.
- * If the string is too short to be undelimited, throw an
- * IllegalArgumentException.
- * Use this method to undelimit strings that do not escape embedded
- * delimiters.
- */
- public static void undelimitOn(String string, int count, Writer writer) {
- int len = string.length() - (2 * count);
- if (len < 0) {
- throw new IllegalArgumentException("invalid string: \"" + string + '"'); //$NON-NLS-1$
- }
- if (len == 0) {
- return;
- }
- writeStringOn(string, count, len, writer);
- }
-
- /**
- * Remove the delimiters from the specified string, removing any escape
- * characters. Throw an IllegalArgumentException if the string is too short
- * to undelimit (i.e. length < 2).
- */
- public static void undelimitOn(String string, StringBuffer sb) {
- undelimitOn(string.toCharArray(), sb);
- }
-
- /**
- * Remove the first and last count characters from the specified string.
- * If the string is too short to be undelimited, throw an
- * IllegalArgumentException.
- * Use this method to undelimit strings that do not escape embedded
- * delimiters.
- */
- public static void undelimitOn(String string, int count, StringBuffer sb) {
- int len = string.length() - (2 * count);
- if (len < 0) {
- throw new IllegalArgumentException("invalid string: \"" + string + '"'); //$NON-NLS-1$
- }
- if (len == 0) {
- return;
- }
- sb.append(string, count, count + len);
- }
-
- /**
- * Remove the delimiters from the specified string, removing any escape
- * characters. Throw an IllegalArgumentException if the string is too short
- * to undelimit (i.e. length < 2).
- */
- public static void undelimitOn(String string, StringBuilder sb) {
- undelimitOn(string.toCharArray(), sb);
- }
-
- /**
- * Remove the first and last count characters from the specified string.
- * If the string is too short to be undelimited, throw an
- * IllegalArgumentException.
- * Use this method to undelimit strings that do not escape embedded
- * delimiters.
- */
- public static void undelimitOn(String string, int count, StringBuilder sb) {
- int len = string.length() - (2 * count);
- if (len < 0) {
- throw new IllegalArgumentException("invalid string: \"" + string + '"'); //$NON-NLS-1$
- }
- if (len == 0) {
- return;
- }
- sb.append(string, count, count + len);
- }
-
- /**
- * Remove the delimiters from the specified string, removing any escape
- * characters. Throw an IllegalArgumentException if the string is too short
- * to undelimit (i.e. length < 2).
- */
- public static void undelimitOn(char[] string, Writer writer) {
- int len = string.length - 2;
- if (len < 0) {
- throw new IllegalArgumentException("invalid string: \"" + new String(string) + '"'); //$NON-NLS-1$
- }
- if (len == 0) {
- return;
- }
- undelimitOn_(string, writer);
- }
-
- /**
- * pre-condition: string is at least 3 characters long
- */
- private static void undelimitOn_(char[] string, Writer writer) {
- char delimiter = string[0]; // the first char is the delimiter
- char c = string[0];
- char next = string[1];
- int i = 1;
- int last = string.length - 1;
- do {
- c = next;
- writeCharOn(c, writer);
- i++;
- next = string[i];
- if (c == delimiter) {
- if ((next != delimiter) || (i == last)) {
- // an embedded delimiter must be followed by another delimiter
- return;
- }
- i++;
- next = string[i];
- }
- } while (i != last);
- }
-
- /**
- * Remove the first and last count characters from the specified string.
- * If the string is too short to be undelimited, throw an
- * IllegalArgumentException.
- * Use this method to undelimit strings that do not escape embedded
- * delimiters.
- */
- public static void undelimitOn(char[] string, int count, Writer writer) {
- int len = string.length - (2 * count);
- if (len < 0) {
- throw new IllegalArgumentException("invalid string: \"" + new String(string) + '"'); //$NON-NLS-1$
- }
- if (len == 0) {
- return;
- }
- writeStringOn(string, count, len, writer);
- }
-
- /**
- * Remove the delimiters from the specified string, removing any escape
- * characters. Throw an IllegalArgumentException if the string is too short
- * to undelimit (i.e. length < 2).
- */
- public static void undelimitOn(char[] string, StringBuffer sb) {
- int len = string.length - 2;
- if (len < 0) {
- throw new IllegalArgumentException("invalid string: \"" + new String(string) + '"'); //$NON-NLS-1$
- }
- if (len == 0) {
- return;
- }
- undelimitOn_(string, sb);
- }
-
- /**
- * pre-condition: string is at least 3 characters long
- */
- private static void undelimitOn_(char[] string, StringBuffer sb) {
- char delimiter = string[0]; // the first char is the delimiter
- char c = string[0];
- char next = string[1];
- int i = 1;
- int last = string.length - 1;
- do {
- c = next;
- sb.append(c);
- i++;
- next = string[i];
- if (c == delimiter) {
- if ((next != delimiter) || (i == last)) {
- // an embedded delimiter must be followed by another delimiter
- return;
- }
- i++;
- next = string[i];
- }
- } while (i != last);
- }
-
- /**
- * Remove the first and last count characters from the specified string.
- * If the string is too short to be undelimited, throw an
- * IllegalArgumentException.
- * Use this method to undelimit strings that do not escape embedded
- * delimiters.
- */
- public static void undelimitOn(char[] string, int count, StringBuffer sb) {
- int len = string.length - (2 * count);
- if (len < 0) {
- throw new IllegalArgumentException("invalid string: \"" + new String(string) + '"'); //$NON-NLS-1$
- }
- if (len == 0) {
- return;
- }
- sb.append(string, count, len);
- }
-
- /**
- * Remove the delimiters from the specified string, removing any escape
- * characters. Throw an IllegalArgumentException if the string is too short
- * to undelimit (i.e. length < 2).
- */
- public static void undelimitOn(char[] string, StringBuilder sb) {
- int len = string.length - 2;
- if (len < 0) {
- throw new IllegalArgumentException("invalid string: \"" + new String(string) + '"'); //$NON-NLS-1$
- }
- if (len == 0) {
- return;
- }
- undelimitOn_(string, sb);
- }
-
- /**
- * pre-condition: string is at least 3 characters long
- */
- private static void undelimitOn_(char[] string, StringBuilder sb) {
- char delimiter = string[0]; // the first char is the delimiter
- char c = string[0];
- char next = string[1];
- int i = 1;
- int last = string.length - 1;
- do {
- c = next;
- sb.append(c);
- i++;
- next = string[i];
- if (c == delimiter) {
- if ((next != delimiter) || (i == last)) {
- // an embedded delimiter must be followed by another delimiter
- return;
- }
- i++;
- next = string[i];
- }
- } while (i != last);
- }
-
- /**
- * Remove the first and last count characters from the specified string.
- * If the string is too short to be undelimited, throw an
- * IllegalArgumentException.
- * Use this method to undelimit strings that do not escape embedded
- * delimiters.
- */
- public static void undelimitOn(char[] string, int count, StringBuilder sb) {
- int len = string.length - (2 * count);
- if (len < 0) {
- throw new IllegalArgumentException("invalid string: \"" + new String(string) + '"'); //$NON-NLS-1$
- }
- if (len == 0) {
- return;
- }
- sb.append(string, count, len);
- }
-
-
- // ********** removing characters **********
-
- /**
- * Remove the first occurrence of the specified character
- * from the specified string and return the result.
- * <p>
- * <code>
- * String.removeFirstOccurrence(char)
- * </code>
- */
- public static String removeFirstOccurrence(String string, char c) {
- int index = string.indexOf(c);
- if (index == -1) {
- // character not found
- return string;
- }
- if (index == 0) {
- // character found at the front of string
- return string.substring(1);
- }
- int last = string.length() - 1;
- if (index == last) {
- // character found at the end of string
- return string.substring(0, last);
- }
- // character found somewhere in the middle of the string
- return string.substring(0, index).concat(string.substring(index + 1));
- }
-
- /**
- * Remove the first occurrence of the specified character
- * from the specified string and print the result on the specified stream.
- * <p>
- * <code>
- * String.removeFirstOccurrenceOn(char, Writer)
- * </code>
- */
- public static void removeFirstOccurrenceOn(String string, char c, Writer writer) {
- int index = string.indexOf(c);
- if (index == -1) {
- writeStringOn(string, writer);
- } else {
- removeCharAtIndexOn(string.toCharArray(), index, writer);
- }
- }
-
- /**
- * Remove the first occurrence of the specified character
- * from the specified string and print the result on the specified stream.
- * <p>
- * <code>
- * String.removeFirstOccurrenceOn(char, StringBuffer)
- * </code>
- */
- public static void removeFirstOccurrenceOn(String string, char c, StringBuffer sb) {
- int index = string.indexOf(c);
- if (index == -1) {
- sb.append(string);
- } else {
- removeCharAtIndexOn(string.toCharArray(), index, sb);
- }
- }
-
- /**
- * Remove the first occurrence of the specified character
- * from the specified string and print the result on the specified stream.
- * <p>
- * <code>
- * String.removeFirstOccurrenceOn(char, StringBuilder)
- * </code>
- */
- public static void removeFirstOccurrenceOn(String string, char c, StringBuilder sb) {
- int index = string.indexOf(c);
- if (index == -1) {
- sb.append(string);
- } else {
- removeCharAtIndexOn(string.toCharArray(), index, sb);
- }
- }
-
- /**
- * Remove the first occurrence of the specified character
- * from the specified string and return the result.
- * <p>
- * <code>
- * String.removeFirstOccurrence(char)
- * </code>
- */
- public static char[] removeFirstOccurrence(char[] string, char c) {
- int index = ArrayTools.indexOf(string, c);
- if (index == -1) {
- // character not found
- return string;
- }
- int last = string.length - 1;
- char[] result = new char[last];
- if (index == 0) {
- // character found at the front of string
- System.arraycopy(string, 1, result, 0, last);
- } else if (index == last) {
- // character found at the end of string
- System.arraycopy(string, 0, result, 0, last);
- } else {
- // character found somewhere in the middle of the string
- System.arraycopy(string, 0, result, 0, index);
- System.arraycopy(string, index + 1, result, index, last - index);
- }
- return result;
- }
-
- /**
- * Remove the first occurrence of the specified character
- * from the specified string and print the result on the specified stream.
- * <p>
- * <code>
- * String.removeFirstOccurrenceOn(char, Writer)
- * </code>
- */
- public static void removeFirstOccurrenceOn(char[] string, char c, Writer writer) {
- int index = ArrayTools.indexOf(string, c);
- if (index == -1) {
- writeStringOn(string, writer);
- } else {
- removeCharAtIndexOn(string, index, writer);
- }
- }
-
- private static void removeCharAtIndexOn(char[] string, int index, Writer writer) {
- int last = string.length - 1;
- if (index == 0) {
- // character found at the front of string
- writeStringOn(string, 1, last, writer);
- } else if (index == last) {
- // character found at the end of string
- writeStringOn(string, 0, last, writer);
- } else {
- // character found somewhere in the middle of the string
- writeStringOn(string, 0, index, writer);
- writeStringOn(string, index + 1, last - index, writer);
- }
- }
-
- /**
- * Remove the first occurrence of the specified character
- * from the specified string and print the result on the specified stream.
- * <p>
- * <code>
- * String.removeFirstOccurrenceOn(char, StringBuffer)
- * </code>
- */
- public static void removeFirstOccurrenceOn(char[] string, char c, StringBuffer sb) {
- int index = ArrayTools.indexOf(string, c);
- if (index == -1) {
- sb.append(string);
- } else {
- removeCharAtIndexOn(string, index, sb);
- }
- }
-
- private static void removeCharAtIndexOn(char[] string, int index, StringBuffer sb) {
- int last = string.length - 1;
- if (index == 0) {
- // character found at the front of string
- sb.append(string, 1, last);
- } else if (index == last) {
- // character found at the end of string
- sb.append(string, 0, last);
- } else {
- // character found somewhere in the middle of the string
- sb.append(string, 0, index);
- sb.append(string, index + 1, last - index);
- }
- }
-
- /**
- * Remove the first occurrence of the specified character
- * from the specified string and print the result on the specified stream.
- * <p>
- * <code>
- * String.removeFirstOccurrenceOn(char, StringBuilder)
- * </code>
- */
- public static void removeFirstOccurrenceOn(char[] string, char c, StringBuilder sb) {
- int index = ArrayTools.indexOf(string, c);
- if (index == -1) {
- sb.append(string);
- } else {
- removeCharAtIndexOn(string, index, sb);
- }
- }
-
- private static void removeCharAtIndexOn(char[] string, int index, StringBuilder sb) {
- int last = string.length - 1;
- if (index == 0) {
- // character found at the front of string
- sb.append(string, 1, last);
- } else if (index == last) {
- // character found at the end of string
- sb.append(string, 0, last);
- } else {
- // character found somewhere in the middle of the string
- sb.append(string, 0, index);
- sb.append(string, index + 1, last - index);
- }
- }
-
- /**
- * Remove all occurrences of the specified character
- * from the specified string and return the result.
- * <p>
- * <code>
- * String.removeAllOccurrences(char)
- * </code>
- */
- public static String removeAllOccurrences(String string, char c) {
- int first = string.indexOf(c);
- return (first == -1) ? string : new String(removeAllOccurrences_(string.toCharArray(), c, first));
- }
-
- /**
- * Remove all occurrences of the specified character
- * from the specified string and write the result to the specified stream.
- * <p>
- * <code>
- * String.removeAllOccurrencesOn(char, Writer)
- * </code>
- */
- public static void removeAllOccurrencesOn(String string, char c, Writer writer) {
- int first = string.indexOf(c);
- if (first == -1) {
- writeStringOn(string, writer);
- } else {
- removeAllOccurrencesOn_(string.toCharArray(), c, first, writer);
- }
- }
-
- /**
- * Remove all occurrences of the specified character
- * from the specified string and write the result to the specified stream.
- * <p>
- * <code>
- * String.removeAllOccurrencesOn(char, StringBuffer)
- * </code>
- */
- public static void removeAllOccurrencesOn(String string, char c, StringBuffer sb) {
- int first = string.indexOf(c);
- if (first == -1) {
- sb.append(string);
- } else {
- removeAllOccurrencesOn_(string.toCharArray(), c, first, sb);
- }
- }
-
- /**
- * Remove all occurrences of the specified character
- * from the specified string and write the result to the specified stream.
- * <p>
- * <code>
- * String.removeAllOccurrencesOn(char, StringBuilder)
- * </code>
- */
- public static void removeAllOccurrencesOn(String string, char c, StringBuilder sb) {
- int first = string.indexOf(c);
- if (first == -1) {
- sb.append(string);
- } else {
- removeAllOccurrencesOn_(string.toCharArray(), c, first, sb);
- }
- }
-
- /**
- * Remove all occurrences of the specified character
- * from the specified string and return the result.
- * <p>
- * <code>
- * String.removeAllOccurrences(char)
- * </code>
- */
- public static char[] removeAllOccurrences(char[] string, char c) {
- int first = ArrayTools.indexOf(string, c);
- return (first == -1) ? string : removeAllOccurrences_(string, c, first);
- }
-
- /*
- * The index of the first matching character is passed in.
- */
- private static char[] removeAllOccurrences_(char[] string, char c, int first) {
- StringBuilder sb = new StringBuilder(string.length);
- removeAllOccurrencesOn_(string, c, first, sb);
- return convertToCharArray(sb);
- }
-
- /**
- * Remove all occurrences of the specified character
- * from the specified string and write the result to the
- * specified writer.
- * <p>
- * <code>
- * String.removeAllOccurrencesOn(char, Writer)
- * </code>
- */
- public static void removeAllOccurrencesOn(char[] string, char c, Writer writer) {
- int first = ArrayTools.indexOf(string, c);
- if (first == -1) {
- writeStringOn(string, writer);
- } else {
- removeAllOccurrencesOn_(string, c, first, writer);
- }
- }
-
- /*
- * The index of the first matching character is passed in.
- */
- private static void removeAllOccurrencesOn_(char[] string, char c, int first, Writer writer) {
- writeStringOn(string, 0, first, writer);
- int len = string.length;
- for (int i = first; i < len; i++) {
- char d = string[i];
- if (d != c) {
- writeCharOn(d, writer);
- }
- }
- }
-
- /**
- * Remove all occurrences of the specified character
- * from the specified string and append the result to the
- * specified string buffer.
- * <p>
- * <code>
- * String.removeAllOccurrencesOn(char, StringBuffer)
- * </code>
- */
- public static void removeAllOccurrencesOn(char[] string, char c, StringBuffer sb) {
- int first = ArrayTools.indexOf(string, c);
- if (first == -1) {
- sb.append(string);
- } else {
- removeAllOccurrencesOn_(string, c, first, sb);
- }
- }
-
- /*
- * The index of the first matching character is passed in.
- */
- private static void removeAllOccurrencesOn_(char[] string, char c, int first, StringBuffer sb) {
- sb.append(string, 0, first);
- int len = string.length;
- for (int i = first; i < len; i++) {
- char d = string[i];
- if (d != c) {
- sb.append(d);
- }
- }
- }
-
- /**
- * Remove all occurrences of the specified character
- * from the specified string and append the result to the
- * specified string builder.
- * <p>
- * <code>
- * String.removeAllOccurrencesOn(char, StringBuilder)
- * </code>
- */
- public static void removeAllOccurrencesOn(char[] string, char c, StringBuilder sb) {
- int first = ArrayTools.indexOf(string, c);
- if (first == -1) {
- sb.append(string);
- } else {
- removeAllOccurrencesOn_(string, c, first, sb);
- }
- }
-
- /*
- * The index of the first matching character is passed in.
- */
- private static void removeAllOccurrencesOn_(char[] string, char c, int first, StringBuilder sb) {
- sb.append(string, 0, first);
- int len = string.length;
- for (int i = first; i < len; i++) {
- char d = string[i];
- if (d != c) {
- sb.append(d);
- }
- }
- }
-
- /**
- * Remove all the spaces from the specified string and return the result.
- * <p>
- * <code>
- * String.removeAllSpaces()
- * </code>
- */
- public static String removeAllSpaces(String string) {
- return removeAllOccurrences(string, ' ');
- }
-
- /**
- * Remove all the spaces
- * from the specified string and write the result to the specified writer.
- * <p>
- * <code>
- * String.removeAllSpacesOn(Writer)
- * </code>
- */
- public static void removeAllSpacesOn(String string, Writer writer) {
- removeAllOccurrencesOn(string, ' ', writer);
- }
-
- /**
- * Remove all the spaces
- * from the specified string and write the result to the specified
- * string buffer.
- * <p>
- * <code>
- * String.removeAllSpacesOn(StringBuffer)
- * </code>
- */
- public static void removeAllSpacesOn(String string, StringBuffer sb) {
- removeAllOccurrencesOn(string, ' ', sb);
- }
-
- /**
- * Remove all the spaces
- * from the specified string and write the result to the specified
- * string builder.
- * <p>
- * <code>
- * String.removeAllSpacesOn(StringBuilder)
- * </code>
- */
- public static void removeAllSpacesOn(String string, StringBuilder sb) {
- removeAllOccurrencesOn(string, ' ', sb);
- }
-
- /**
- * Remove all the spaces from the specified string and return the result.
- * <p>
- * <code>
- * String.removeAllSpaces()
- * </code>
- */
- public static char[] removeAllSpaces(char[] string) {
- return removeAllOccurrences(string, ' ');
- }
-
- /**
- * Remove all the spaces
- * from the specified string and write the result to the
- * specified writer.
- * <p>
- * <code>
- * String.removeAllSpacesOn(Writer)
- * </code>
- */
- public static void removeAllSpacesOn(char[] string, Writer writer) {
- removeAllOccurrencesOn(string, ' ', writer);
- }
-
- /**
- * Remove all the spaces
- * from the specified string and append the result to the
- * specified string buffer.
- * <p>
- * <code>
- * String.removeAllSpacesOn(StringBuffer)
- * </code>
- */
- public static void removeAllSpacesOn(char[] string, StringBuffer sb) {
- removeAllOccurrencesOn(string, ' ', sb);
- }
-
- /**
- * Remove all the spaces
- * from the specified string and append the result to the
- * specified string builder.
- * <p>
- * <code>
- * String.removeAllSpacesOn(StringBuilder)
- * </code>
- */
- public static void removeAllSpacesOn(char[] string, StringBuilder sb) {
- removeAllOccurrencesOn(string, ' ', sb);
- }
-
- /**
- * Remove all the whitespace from the specified string and return the result.
- * <p>
- * <code>
- * String.removeAllWhitespace()
- * </code>
- */
- public static String removeAllWhitespace(String string) {
- char[] string2 = string.toCharArray();
- int first = indexOfWhitespace_(string2);
- return (first == -1) ? string : new String(removeAllWhitespace_(string2, first));
- }
-
- /**
- * Remove all the whitespace
- * from the specified string and append the result to the
- * specified writer.
- * <p>
- * <code>
- * String.removeAllWhitespaceOn(Writer)
- * </code>
- */
- public static void removeAllWhitespaceOn(String string, Writer writer) {
- char[] string2 = string.toCharArray();
- int first = indexOfWhitespace_(string2);
- if (first == -1) {
- writeStringOn(string, writer);
- } else {
- removeAllWhitespaceOn_(string2, first, writer);
- }
- }
-
- /**
- * Remove all the whitespace
- * from the specified string and append the result to the
- * specified string buffer.
- * <p>
- * <code>
- * String.removeAllWhitespaceOn(StringBuffer)
- * </code>
- */
- public static void removeAllWhitespaceOn(String string, StringBuffer sb) {
- char[] string2 = string.toCharArray();
- int first = indexOfWhitespace_(string2);
- if (first == -1) {
- sb.append(string);
- } else {
- removeAllWhitespaceOn_(string2, first, sb);
- }
- }
-
- /**
- * Remove all the whitespace
- * from the specified string and append the result to the
- * specified string builder.
- * <p>
- * <code>
- * String.removeAllWhitespaceOn(StringBuilder)
- * </code>
- */
- public static void removeAllWhitespaceOn(String string, StringBuilder sb) {
- char[] string2 = string.toCharArray();
- int first = indexOfWhitespace_(string2);
- if (first == -1) {
- sb.append(string);
- } else {
- removeAllWhitespaceOn_(string2, first, sb);
- }
- }
-
- /**
- * Remove all the whitespace from the specified string and return the result.
- * <p>
- * <code>
- * String.removeAllWhitespace()
- * </code>
- */
- public static char[] removeAllWhitespace(char[] string) {
- int first = indexOfWhitespace_(string);
- return (first == -1) ? string : removeAllWhitespace_(string, first);
- }
-
- private static int indexOfWhitespace_(char[] string) {
- int len = string.length;
- for (int i = 0; i < len; i++) {
- if (Character.isWhitespace(string[i])) {
- return i;
- }
- }
- return -1;
- }
-
- /*
- * The index of the first non-whitespace character is passed in.
- */
- private static char[] removeAllWhitespace_(char[] string, int first) {
- StringBuilder sb = new StringBuilder(string.length);
- removeAllWhitespaceOn_(string, first, sb);
- return convertToCharArray(sb);
- }
-
- /**
- * Remove all the whitespace
- * from the specified string and append the result to the
- * specified writer.
- * <p>
- * <code>
- * String.removeAllWhitespaceOn(Writer)
- * </code>
- */
- public static void removeAllWhitespaceOn(char[] string, Writer writer) {
- int first = indexOfWhitespace_(string);
- if (first == -1) {
- writeStringOn(string, writer);
- } else {
- removeAllWhitespaceOn_(string, first, writer);
- }
- }
-
- /*
- * The index of the first whitespace character is passed in.
- */
- private static void removeAllWhitespaceOn_(char[] string, int first, Writer writer) {
- writeStringOn(string, 0, first, writer);
- int len = string.length;
- for (int i = first; i < len; i++) {
- char c = string[i];
- if ( ! Character.isWhitespace(c)) {
- writeCharOn(c, writer);
- }
- }
- }
-
- /**
- * Remove all the whitespace
- * from the specified string and append the result to the
- * specified string buffer.
- * <p>
- * <code>
- * String.removeAllWhitespaceOn(StringBuffer)
- * </code>
- */
- public static void removeAllWhitespaceOn(char[] string, StringBuffer sb) {
- int first = indexOfWhitespace_(string);
- if (first == -1) {
- sb.append(string);
- } else {
- removeAllWhitespaceOn_(string, first, sb);
- }
- }
-
- /*
- * The index of the first whitespace character is passed in.
- */
- private static void removeAllWhitespaceOn_(char[] string, int first, StringBuffer sb) {
- sb.append(string, 0, first);
- int len = string.length;
- for (int i = first; i < len; i++) {
- char c = string[i];
- if ( ! Character.isWhitespace(c)) {
- sb.append(c);
- }
- }
- }
-
- /**
- * Remove all the whitespace
- * from the specified string and append the result to the
- * specified string builder.
- * <p>
- * <code>
- * String.removeAllWhitespaceOn(StringBuilder)
- * </code>
- */
- public static void removeAllWhitespaceOn(char[] string, StringBuilder sb) {
- int first = indexOfWhitespace_(string);
- if (first == -1) {
- sb.append(string);
- } else {
- removeAllWhitespaceOn_(string, first, sb);
- }
- }
-
- /*
- * The index of the first whitespace character is passed in.
- */
- private static void removeAllWhitespaceOn_(char[] string, int first, StringBuilder sb) {
- sb.append(string, 0, first);
- int len = string.length;
- for (int i = first; i < len; i++) {
- char c = string[i];
- if ( ! Character.isWhitespace(c)) {
- sb.append(c);
- }
- }
- }
-//===============================
- /**
- * Compress the whitespace in the specified string and return the result.
- * The whitespace is compressed by replacing any occurrence of one or more
- * whitespace characters with a single space.
- * <p>
- * <code>
- * String.compressWhitespace()
- * </code>
- */
- public static String compressWhitespace(String string) {
- char[] string2 = string.toCharArray();
- int first = indexOfWhitespace_(string2);
- return (first == -1) ? string : new String(compressWhitespace_(string2, first));
- }
-
- /**
- * Compress the whitespace
- * in the specified string and append the result to the
- * specified writer.
- * The whitespace is compressed by replacing any occurrence of one or more
- * whitespace characters with a single space.
- * <p>
- * <code>
- * String.compressWhitespaceOn(Writer)
- * </code>
- */
- public static void compressWhitespaceOn(String string, Writer writer) {
- char[] string2 = string.toCharArray();
- int first = indexOfWhitespace_(string2);
- if (first == -1) {
- writeStringOn(string, writer);
- } else {
- compressWhitespaceOn_(string2, first, writer);
- }
- }
-
- /**
- * Compress the whitespace
- * in the specified string and append the result to the
- * specified string buffer.
- * The whitespace is compressed by replacing any occurrence of one or more
- * whitespace characters with a single space.
- * <p>
- * <code>
- * String.compressWhitespaceOn(StringBuffer)
- * </code>
- */
- public static void compressWhitespaceOn(String string, StringBuffer sb) {
- char[] string2 = string.toCharArray();
- int first = indexOfWhitespace_(string2);
- if (first == -1) {
- sb.append(string);
- } else {
- compressWhitespaceOn_(string2, first, sb);
- }
- }
-
- /**
- * Compress the whitespace
- * in the specified string and append the result to the
- * specified string builder.
- * The whitespace is compressed by replacing any occurrence of one or more
- * whitespace characters with a single space.
- * <p>
- * <code>
- * String.compressWhitespaceOn(StringBuilder)
- * </code>
- */
- public static void compressWhitespaceOn(String string, StringBuilder sb) {
- char[] string2 = string.toCharArray();
- int first = indexOfWhitespace_(string2);
- if (first == -1) {
- sb.append(string);
- } else {
- compressWhitespaceOn_(string2, first, sb);
- }
- }
-
- /**
- * Compress the whitespace in the specified string and return the result.
- * The whitespace is compressed by replacing any occurrence of one or more
- * whitespace characters with a single space.
- * <p>
- * <code>
- * String.compressWhitespace()
- * </code>
- */
- public static char[] compressWhitespace(char[] string) {
- int first = indexOfWhitespace_(string);
- return (first == -1) ? string : compressWhitespace_(string, first);
- }
-
- /*
- * The index of the first whitespace character is passed in.
- */
- private static char[] compressWhitespace_(char[] string, int first) {
- StringBuilder sb = new StringBuilder(string.length);
- compressWhitespaceOn_(string, first, sb);
- return convertToCharArray(sb);
- }
-
- /**
- * Compress the whitespace
- * in the specified string and append the result to the
- * specified writer.
- * The whitespace is compressed by replacing any occurrence of one or more
- * whitespace characters with a single space.
- * <p>
- * <code>
- * String.compressWhitespaceOn(Writer)
- * </code>
- */
- public static void compressWhitespaceOn(char[] string, Writer writer) {
- int first = indexOfWhitespace_(string);
- if (first == -1) {
- writeStringOn(string, writer);
- } else {
- compressWhitespaceOn_(string, first, writer);
- }
- }
-
- /*
- * The index of the first whitespace character is passed in.
- */
- private static void compressWhitespaceOn_(char[] string, int first, Writer writer) {
- writeStringOn(string, 0, first, writer);
- boolean spaceWritten = false;
- int len = string.length;
- for (int i = first; i < len; i++) {
- char c = string[i];
- if (Character.isWhitespace(c)) {
- if (spaceWritten) {
- // skip subsequent whitespace characters
- } else {
- // replace first whitespace character with a space
- spaceWritten = true;
- writeCharOn(' ', writer);
- }
- } else {
- spaceWritten = false;
- writeCharOn(c, writer);
- }
- }
- }
-
- /**
- * Compress the whitespace
- * in the specified string and append the result to the
- * specified string buffer.
- * The whitespace is compressed by replacing any occurrence of one or more
- * whitespace characters with a single space.
- * <p>
- * <code>
- * String.compressWhitespaceOn(StringBuffer)
- * </code>
- */
- public static void compressWhitespaceOn(char[] string, StringBuffer sb) {
- int first = indexOfWhitespace_(string);
- if (first == -1) {
- sb.append(string);
- } else {
- compressWhitespaceOn_(string, first, sb);
- }
- }
-
- /*
- * The index of the first whitespace character is passed in.
- */
- private static void compressWhitespaceOn_(char[] string, int first, StringBuffer sb) {
- sb.append(string, 0, first);
- boolean spaceWritten = false;
- int len = string.length;
- for (int i = first; i < len; i++) {
- char c = string[i];
- if (Character.isWhitespace(c)) {
- if (spaceWritten) {
- // skip subsequent whitespace characters
- } else {
- // replace first whitespace character with a space
- spaceWritten = true;
- sb.append(' ');
- }
- } else {
- spaceWritten = false;
- sb.append(c);
- }
- }
- }
-
- /**
- * Compress the whitespace
- * in the specified string and append the result to the
- * specified string builder.
- * The whitespace is compressed by replacing any occurrence of one or more
- * whitespace characters with a single space.
- * <p>
- * <code>
- * String.compressWhitespaceOn(StringBuilder)
- * </code>
- */
- public static void compressWhitespaceOn(char[] string, StringBuilder sb) {
- int first = indexOfWhitespace_(string);
- if (first == -1) {
- sb.append(string);
- } else {
- compressWhitespaceOn_(string, first, sb);
- }
- }
-
- /*
- * The index of the first whitespace character is passed in.
- */
- private static void compressWhitespaceOn_(char[] string, int first, StringBuilder sb) {
- sb.append(string, 0, first);
- boolean spaceWritten = false;
- int len = string.length;
- for (int i = first; i < len; i++) {
- char c = string[i];
- if (Character.isWhitespace(c)) {
- if (spaceWritten) {
- // skip subsequent whitespace characters
- } else {
- // replace first whitespace character with a space
- spaceWritten = true;
- sb.append(' ');
- }
- } else {
- spaceWritten = false;
- sb.append(c);
- }
- }
- }
-
-
- // ********** common prefix **********
-
- /**
- * Return the length of the common prefix shared by the specified strings.
- * <p>
- * <code>
- * String.commonPrefixLength(String)
- * </code>
- */
- public static int commonPrefixLength(String s1, String s2) {
- return commonPrefixLength(s1.toCharArray(), s2.toCharArray());
- }
-
- /**
- * Return the length of the common prefix shared by the specified strings.
- */
- public static int commonPrefixLength(char[] s1, char[] s2) {
- return commonPrefixLength_(s1, s2, Math.min(s1.length, s2.length));
- }
-
- /**
- * Return the length of the common prefix shared by the specified strings;
- * but limit the length to the specified maximum.
- * <p>
- * <code>
- * String.commonPrefixLength(String, int)
- * </code>
- */
- public static int commonPrefixLength(String s1, String s2, int max) {
- return commonPrefixLength(s1.toCharArray(), s2.toCharArray(), max);
- }
-
- /**
- * Return the length of the common prefix shared by the specified strings;
- * but limit the length to the specified maximum.
- */
- public static int commonPrefixLength(char[] s1, char[] s2, int max) {
- return commonPrefixLength_(s1, s2, Math.min(max, Math.min(s1.length, s2.length)));
- }
-
- /*
- * Return the length of the common prefix shared by the specified strings;
- * but limit the length to the specified maximum. Assume the specified
- * maximum is less than the lengths of the specified strings.
- */
- private static int commonPrefixLength_(char[] s1, char[] s2, int max) {
- for (int i = 0; i < max; i++) {
- if (s1[i] != s2[i]) {
- return i;
- }
- }
- return max; // all the characters up to 'max' are the same
- }
-
-
- // ********** capitalization **********
-
- /*
- * no zero-length check or lower case check
- */
- private static char[] capitalize_(char[] string) {
- string[0] = Character.toUpperCase(string[0]);
- return string;
- }
-
- /**
- * Modify and return the specified string with
- * its first letter capitalized.
- */
- public static char[] capitalize(char[] string) {
- if ((string.length == 0) || Character.isUpperCase(string[0])) {
- return string;
- }
- return capitalize_(string);
- }
-
- /**
- * Return the specified string with its first letter capitalized.
- * <p>
- * <code>
- * String.capitalize()
- * </code>
- */
- public static String capitalize(String string) {
- if ((string.length() == 0) || Character.isUpperCase(string.charAt(0))) {
- return string;
- }
- return new String(capitalize_(string.toCharArray()));
- }
-
- /**
- * Modify each of the specified strings, capitalizing the first letter of
- * each.
- */
- public static Iterable<String> capitalize(Iterable<String> strings) {
- return new TransformationIterable<String, String>(strings, STRING_CAPITALIZER);
- }
-
- /**
- * Modify each of the specified strings, capitalizing the first letter of
- * each.
- */
- public static Iterator<String> capitalize(Iterator<String> strings) {
- return new TransformationIterator<String, String>(strings, STRING_CAPITALIZER);
- }
-
- private static final Transformer<String, String> STRING_CAPITALIZER = new Transformer<String, String>() {
- public String transform(String string) {
- return StringTools.capitalize(string);
- }
- };
-
- /**
- * Modify each of the specified strings, capitalizing the first letter of
- * each.
- */
- // cannot name method simply 'capitalize' because of type-erasure...
- public static Iterable<char[]> capitalizeCharArrays(Iterable<char[]> strings) {
- return new TransformationIterable<char[], char[]>(strings, CHAR_ARRAY_CAPITALIZER);
- }
-
- /**
- * Modify each of the specified strings, capitalizing the first letter of
- * each.
- */
- // cannot name method simply 'capitalize' because of type-erasure...
- public static Iterator<char[]> capitalizeCharArrays(Iterator<char[]> strings) {
- return new TransformationIterator<char[], char[]>(strings, CHAR_ARRAY_CAPITALIZER);
- }
-
- private static final Transformer<char[], char[]> CHAR_ARRAY_CAPITALIZER = new Transformer<char[], char[]>() {
- public char[] transform(char[] string) {
- return StringTools.capitalize(string);
- }
- };
-
- /*
- * no zero-length check or upper case check
- */
- private static void capitalizeOn_(char[] string, StringBuffer sb) {
- sb.append(Character.toUpperCase(string[0]));
- sb.append(string, 1, string.length - 1);
- }
-
- /**
- * Append the specified string to the specified string buffer
- * with its first letter capitalized.
- */
- public static void capitalizeOn(char[] string, StringBuffer sb) {
- if (string.length == 0) {
- return;
- }
- if (Character.isUpperCase(string[0])) {
- sb.append(string);
- } else {
- capitalizeOn_(string, sb);
- }
- }
-
- /**
- * Append the specified string to the specified string buffer
- * with its first letter capitalized.
- * <p>
- * <code>
- * String.capitalizeOn(StringBuffer)
- * </code>
- */
- public static void capitalizeOn(String string, StringBuffer sb) {
- if (string.length() == 0) {
- return;
- }
- if (Character.isUpperCase(string.charAt(0))) {
- sb.append(string);
- } else {
- capitalizeOn_(string.toCharArray(), sb);
- }
- }
-
- /*
- * no zero-length check or upper case check
- */
- private static void capitalizeOn_(char[] string, StringBuilder sb) {
- sb.append(Character.toUpperCase(string[0]));
- sb.append(string, 1, string.length - 1);
- }
-
- /**
- * Append the specified string to the specified string builder
- * with its first letter capitalized.
- */
- public static void capitalizeOn(char[] string, StringBuilder sb) {
- if (string.length == 0) {
- return;
- }
- if (Character.isUpperCase(string[0])) {
- sb.append(string);
- } else {
- capitalizeOn_(string, sb);
- }
- }
-
- /**
- * Append the specified string to the specified string builder
- * with its first letter capitalized.
- * <p>
- * <code>
- * String.capitalizeOn(StringBuffer)
- * </code>
- */
- public static void capitalizeOn(String string, StringBuilder sb) {
- if (string.length() == 0) {
- return;
- }
- if (Character.isUpperCase(string.charAt(0))) {
- sb.append(string);
- } else {
- capitalizeOn_(string.toCharArray(), sb);
- }
- }
-
- /*
- * no zero-length check or upper case check
- */
- private static void capitalizeOn_(char[] string, Writer writer) {
- writeCharOn(Character.toUpperCase(string[0]), writer);
- writeStringOn(string, 1, string.length - 1, writer);
- }
-
- /**
- * Append the specified string to the specified string buffer
- * with its first letter capitalized.
- */
- public static void capitalizeOn(char[] string, Writer writer) {
- if (string.length == 0) {
- return;
- }
- if (Character.isUpperCase(string[0])) {
- writeStringOn(string, writer);
- } else {
- capitalizeOn_(string, writer);
- }
- }
-
- /**
- * Append the specified string to the specified string buffer
- * with its first letter capitalized.
- * <p>
- * <code>
- * String.capitalizeOn(Writer)
- * </code>
- */
- public static void capitalizeOn(String string, Writer writer) {
- if (string.length() == 0) {
- return;
- }
- if (Character.isUpperCase(string.charAt(0))) {
- writeStringOn(string, writer);
- } else {
- capitalizeOn_(string.toCharArray(), writer);
- }
- }
-
- /*
- * no zero-length check or lower case check
- */
- private static char[] uncapitalize_(char[] string) {
- string[0] = Character.toLowerCase(string[0]);
- return string;
- }
-
- private static boolean stringNeedNotBeUncapitalized_(char[] string) {
- if (string.length == 0) {
- return true;
- }
- if (Character.isLowerCase(string[0])) {
- return true;
- }
- // if both the first and second characters are capitalized,
- // return the string unchanged
- if ((string.length > 1)
- && Character.isUpperCase(string[1])
- && Character.isUpperCase(string[0])){
- return true;
- }
- return false;
- }
-
- /**
- * Modify and return the specified string with its
- * first letter converted to lower case.
- * (Unless both the first and second letters are upper case,
- * in which case the string is returned unchanged.)
- */
- public static char[] uncapitalize(char[] string) {
- if (stringNeedNotBeUncapitalized_(string)) {
- return string;
- }
- return uncapitalize_(string);
- }
-
- private static boolean stringNeedNotBeUncapitalized_(String string) {
- if (string.length() == 0) {
- return true;
- }
- if (Character.isLowerCase(string.charAt(0))) {
- return true;
- }
- // if both the first and second characters are capitalized,
- // return the string unchanged
- if ((string.length() > 1)
- && Character.isUpperCase(string.charAt(1))
- && Character.isUpperCase(string.charAt(0))){
- return true;
- }
- return false;
- }
-
- /**
- * Return the specified string with its first letter converted to lower case.
- * (Unless both the first and second letters are upper case,
- * in which case the string is returned unchanged.)
- * <p>
- * <code>
- * String.uncapitalize()
- * </code>
- */
- public static String uncapitalize(String string) {
- if (stringNeedNotBeUncapitalized_(string)) {
- return string;
- }
- return new String(uncapitalize_(string.toCharArray()));
- }
-
- /*
- * no zero-length check or lower case check
- */
- private static void uncapitalizeOn_(char[] string, StringBuffer sb) {
- sb.append(Character.toLowerCase(string[0]));
- sb.append(string, 1, string.length - 1);
- }
-
- /**
- * Append the specified string to the specified string buffer
- * with its first letter converted to lower case.
- * (Unless both the first and second letters are upper case,
- * in which case the string is returned unchanged.)
- */
- public static void uncapitalizeOn(char[] string, StringBuffer sb) {
- if (stringNeedNotBeUncapitalized_(string)) {
- sb.append(string);
- } else {
- uncapitalizeOn_(string, sb);
- }
- }
-
- /**
- * Append the specified string to the specified string buffer
- * with its first letter converted to lower case.
- * (Unless both the first and second letters are upper case,
- * in which case the string is returned unchanged.)
- * <p>
- * <code>
- * String.uncapitalizeOn(StringBuffer)
- * </code>
- */
- public static void uncapitalizeOn(String string, StringBuffer sb) {
- if (stringNeedNotBeUncapitalized_(string)) {
- sb.append(string);
- } else {
- uncapitalizeOn_(string.toCharArray(), sb);
- }
- }
-
- /*
- * no zero-length check or lower case check
- */
- private static void uncapitalizeOn_(char[] string, StringBuilder sb) {
- sb.append(Character.toLowerCase(string[0]));
- sb.append(string, 1, string.length - 1);
- }
-
- /**
- * Append the specified string to the specified string builder
- * with its first letter converted to lower case.
- * (Unless both the first and second letters are upper case,
- * in which case the string is returned unchanged.)
- */
- public static void uncapitalizeOn(char[] string, StringBuilder sb) {
- if (stringNeedNotBeUncapitalized_(string)) {
- sb.append(string);
- } else {
- uncapitalizeOn_(string, sb);
- }
- }
-
- /**
- * Append the specified string to the specified string builder
- * with its first letter converted to lower case.
- * (Unless both the first and second letters are upper case,
- * in which case the string is returned unchanged.)
- * <p>
- * <code>
- * String.uncapitalizeOn(StringBuffer)
- * </code>
- */
- public static void uncapitalizeOn(String string, StringBuilder sb) {
- if (stringNeedNotBeUncapitalized_(string)) {
- sb.append(string);
- } else {
- uncapitalizeOn_(string.toCharArray(), sb);
- }
- }
-
- /*
- * no zero-length check or upper case check
- */
- private static void uncapitalizeOn_(char[] string, Writer writer) {
- writeCharOn(Character.toLowerCase(string[0]), writer);
- writeStringOn(string, 1, string.length - 1, writer);
- }
-
- /**
- * Append the specified string to the specified string buffer
- * with its first letter converted to lower case.
- * (Unless both the first and second letters are upper case,
- * in which case the string is returned unchanged.)
- */
- public static void uncapitalizeOn(char[] string, Writer writer) {
- if (stringNeedNotBeUncapitalized_(string)) {
- writeStringOn(string, writer);
- } else {
- uncapitalizeOn_(string, writer);
- }
- }
-
- /**
- * Append the specified string to the specified string buffer
- * with its first letter converted to lower case.
- * (Unless both the first and second letters are upper case,
- * in which case the string is returned unchanged.)
- * <p>
- * <code>
- * String.uncapitalizeOn(Writer)
- * </code>
- */
- public static void uncapitalizeOn(String string, Writer writer) {
- if (stringNeedNotBeUncapitalized_(string)) {
- writeStringOn(string, writer);
- } else {
- uncapitalizeOn_(string.toCharArray(), writer);
- }
- }
-
-
- // ********** toString() helper methods **********
-
- /**
- * Build a "Dali standard" {@link Object#toString() toString()} result for
- * the specified object and additional information:<pre>
- * ClassName[00-F3-EE-42](add'l info)
- * </pre>
- */
- public static String buildToStringFor(Object o, Object additionalInfo) {
- StringBuilder sb = new StringBuilder();
- appendSimpleToString(sb, o);
- sb.append('(');
- sb.append(additionalInfo);
- sb.append(')');
- return sb.toString();
- }
-
- /**
- * Build a "Dali standard" {@link Object#toString() toString()} result for
- * the specified object:<pre>
- * ClassName[00-F3-EE-42]
- * </pre>
- */
- public static String buildToStringFor(Object o) {
- StringBuilder sb = new StringBuilder();
- appendSimpleToString(sb, o);
- return sb.toString();
- }
-
- /**
- * Append a "Dali standard" {@link Object#toString() toString()} result for
- * the specified object to the specified string builder:<pre>
- * ClassName[00-F3-EE-42]
- */
- public static void appendSimpleToString(StringBuilder sb, Object o) {
- appendToStringClassName(sb, o.getClass());
- sb.append('[');
- separateOn(buildHashCode(o), '-', 2, sb);
- sb.append(']');
- }
-
- private static String buildHashCode(Object o) {
- // use System.identityHashCode(Object), since Object.hashCode() may be overridden
- return zeroPad(Integer.toHexString(System.identityHashCode(o)).toUpperCase(), 8);
- }
-
- /**
- * Return a name suitable for a "Dali standard"
- * {@link Object#toString() toString()} implementation.
- * {@link Class#getSimpleName()} isn't quite useful enough:<ul>
- * <li>An <em>anonymous</em> class's simple name is an empty string.
- * Return the "Dali standard" name of the anonymous class's super class
- * instead, which is a bit more helpful.
- * <li>A <em>member</em> or <em>local</em> class's simple name does not
- * include its context. Prefix the class's simple name with its
- * enclosing class's "Dali standard" name.
- * </ul>
- */
- public static String buildToStringClassName(Class<?> javaClass) {
- StringBuilder sb = new StringBuilder();
- appendToStringClassName(sb, javaClass);
- return sb.toString();
- }
-
- /**
- * Return a string suitable for a <em>singleton</em>; which is the simple
- * name of the object's class, since there should only be one.
- */
- public static String buildSingletonToString(Object o) {
- return buildToStringClassName(o.getClass());
- }
-
- /**
- * Append a name suitable for a "Dali standard"
- * {@link Object#toString() toString()} implementation to the specified
- * string builder.
- * @see #buildToStringClassName(Class)
- */
- public static void appendToStringClassName(StringBuilder sb, Class<?> javaClass) {
- if (javaClass.isAnonymousClass()) {
- appendToStringClassName(sb, javaClass.getSuperclass()); // recurse
- } else {
- Class<?> enclosingClass = javaClass.getEnclosingClass();
- if (enclosingClass == null) {
- appendToStringClassName_(sb, javaClass); // top-level class
- } else {
- appendToStringClassName(sb, enclosingClass); // recurse
- sb.append('.');
- sb.append(javaClass.getSimpleName());
- }
- }
- }
-
- /**
- * pre-condition: the specified class is a top-level class
- */
- private static void appendToStringClassName_(StringBuilder sb, Class<?> javaClass) {
- String fullName = javaClass.getName();
- int dot = fullName.lastIndexOf('.');
- if (dot == -1) {
- sb.append(fullName); // "default" package
- } else {
- sb.append(fullName, dot + 1, fullName.length());
- }
- }
-
- /**
- * Append the string representations of the objects in the specified array
- * to the specified string builder:<pre>
- * ["foo", "bar", "baz"]
- * </pre>
- * <p>
- * <code>
- * StringBuilder.append(Object[])
- * </code>
- */
- public static <T> String append(StringBuilder sb, T[] array) {
- return append(sb, new ArrayListIterator<T>(array));
- }
-
- /**
- * Append the string representations of the objects in the specified iterable
- * to the specified string builder:<pre>
- * ["foo", "bar", "baz"]
- * </pre>
- * <p>
- * <code>
- * StringBuilder.append(Iterable)
- * </code>
- */
- public static <T> String append(StringBuilder sb, Iterable<T> iterable) {
- return append(sb, iterable.iterator());
- }
-
- /**
- * Append the string representations of the objects in the specified iterator
- * to the specified string builder:<pre>
- * ["foo", "bar", "baz"]
- * </pre>
- * <p>
- * <code>
- * StringBuilder.append(Iterator)
- * </code>
- */
- public static <T> String append(StringBuilder sb, Iterator<T> iterator) {
- sb.append('[');
- while (iterator.hasNext()) {
- sb.append(iterator.next());
- if (iterator.hasNext()) {
- sb.append(", "); //$NON-NLS-1$
- }
- }
- sb.append(']');
- return sb.toString();
- }
-
-
- // ********** queries **********
-
- /**
- * Return whether the specified string is <code>null</code>, empty, or
- * contains only whitespace characters.
- */
- public static boolean stringIsEmpty(String string) {
- if (string == null) {
- return true;
- }
- int len = string.length();
- if (len == 0) {
- return true;
- }
- return stringIsEmpty_(string.toCharArray(), len);
- }
-
- /**
- * Return whether the specified string is <code>null</code>, empty, or
- * contains only whitespace characters.
- */
- public static boolean stringIsEmpty(char[] string) {
- if (string == null) {
- return true;
- }
- int len = string.length;
- if (len == 0) {
- return true;
- }
- return stringIsEmpty_(string, len);
- }
-
- private static boolean stringIsEmpty_(char[] s, int len) {
- for (int i = len; i-- > 0; ) {
- if ( ! Character.isWhitespace(s[i])) {
- return false;
- }
- }
- return true;
- }
-
- /**
- * Return whether the specified string is non-<code>null</code>, non-empty,
- * and does not contain only whitespace characters.
- */
- public static boolean stringIsNotEmpty(String string) {
- return ! stringIsEmpty(string);
- }
-
- /**
- * Return whether the specified string is non-<code>null</code>, non-empty,
- * and does not contain only whitespace characters.
- */
- public static boolean stringIsNotEmpty(char[] string) {
- return ! stringIsEmpty(string);
- }
-
- /**
- * Return whether the specified strings are equal.
- * Check for <code>null</code>s.
- */
- public static boolean stringsAreEqual(String s1, String s2) {
- return Tools.valuesAreEqual(s1, s2);
- }
-
- /**
- * Return whether the specified strings are equal.
- * Check for <code>null</code>s.
- */
- public static boolean stringsAreEqual(char[] s1, char[] s2) {
- return (s1 == null) ?
- (s2 == null) :
- ((s2 != null) && stringsAreEqual_(s1, s2));
- }
-
- /**
- * no <code>null</code> checks
- */
- private static boolean stringsAreEqual_(char[] s1, char[] s2) {
- int len = s1.length;
- if (len != s2.length) {
- return false;
- }
- for (int i = len; i-- > 0; ) {
- if (s1[i] != s2[i]) {
- return false;
- }
- }
- return true;
- }
-
- /**
- * Return whether the specified strings are equal, ignoring case.
- * Check for <code>null</code>s.
- */
- public static boolean stringsAreEqualIgnoreCase(String s1, String s2) {
- return (s1 == null) ?
- (s2 == null) :
- ((s2 != null) && s1.equalsIgnoreCase(s2));
- }
-
- /**
- * Return whether the specified strings are equal, ignoring case.
- * Check for <code>null</code>s.
- */
- public static boolean stringsAreEqualIgnoreCase(char[] s1, char[] s2) {
- return (s1 == null) ?
- (s2 == null) :
- ((s2 != null) && stringsAreEqualIgnoreCase_(s1, s2));
- }
-
- /**
- * no <code>null</code> checks
- */
- private static boolean stringsAreEqualIgnoreCase_(char[] s1, char[] s2) {
- int len = s1.length;
- if (len != s2.length) {
- return false;
- }
- for (int i = len; i-- > 0; ) {
- if ( ! charactersAreEqualIgnoreCase(s1[i], s2[i])) {
- return false;
- }
- }
- return true;
- }
-
- /**
- * Return whether the specified string starts with the specified prefix,
- * ignoring case.
- */
- public static boolean stringStartsWithIgnoreCase(char[] string, char[] prefix) {
- int prefixLength = prefix.length;
- if (string.length < prefixLength) {
- return false;
- }
- for (int i = prefixLength; i-- > 0; ) {
- if ( ! charactersAreEqualIgnoreCase(string[i], prefix[i])) {
- return false;
- }
- }
- return true;
- }
-
- /**
- * Return whether the specified string starts with the specified prefix,
- * ignoring case.
- */
- public static boolean stringStartsWithIgnoreCase(String string, String prefix) {
- return string.regionMatches(true, 0, prefix, 0, prefix.length());
- }
-
- /**
- * Return whether the specified characters are are equal, ignoring case.
- * @see String#regionMatches(boolean, int, String, int, int)
- */
- public static boolean charactersAreEqualIgnoreCase(char c1, char c2) {
- // something about the Georgian alphabet requires us to check lower case also
- return (c1 == c2)
- || (Character.toUpperCase(c1) == Character.toUpperCase(c2))
- || (Character.toLowerCase(c1) == Character.toLowerCase(c2));
- }
-
- /**
- * Return whether the specified string is uppercase.
- */
- public static boolean stringIsUppercase(String string) {
- return (string.length() == 0) ? false : stringIsUppercase_(string);
- }
-
- /**
- * Return whether the specified string is uppercase.
- */
- public static boolean stringIsUppercase(char[] string) {
- return (string.length == 0) ? false : stringIsUppercase_(new String(string));
- }
-
- private static boolean stringIsUppercase_(String string) {
- return string.equals(string.toUpperCase());
- }
-
- /**
- * Return whether the specified string is lowercase.
- */
- public static boolean stringIsLowercase(String string) {
- return (string.length() == 0) ? false : stringIsLowercase_(string);
- }
-
- /**
- * Return whether the specified string is lowercase.
- */
- public static boolean stringIsLowercase(char[] string) {
- return (string.length == 0) ? false : stringIsLowercase_(new String(string));
- }
-
- private static boolean stringIsLowercase_(String string) {
- return string.equals(string.toLowerCase());
- }
-
-
- // ********** convert camel case to all caps **********
-
- /**
- * Convert the specified "camel case" string to an "all caps" string:
- * "largeProject" -> "LARGE_PROJECT"
- */
- public static String convertCamelCaseToAllCaps(String camelCaseString) {
- int len = camelCaseString.length();
- if (len == 0) {
- return camelCaseString;
- }
- return new String(convertCamelCaseToAllCaps_(camelCaseString.toCharArray(), len));
- }
-
- /**
- * Convert the specified "camel case" string to an "all caps" string:
- * "largeProject" -> "LARGE_PROJECT"
- */
- public static char[] convertCamelCaseToAllCaps(char[] camelCaseString) {
- int len = camelCaseString.length;
- if (len == 0) {
- return camelCaseString;
- }
- return convertCamelCaseToAllCaps_(camelCaseString, len);
- }
-
- private static char[] convertCamelCaseToAllCaps_(char[] camelCaseString, int len) {
- StringBuilder sb = new StringBuilder(len * 2);
- convertCamelCaseToAllCapsOn_(camelCaseString, len, sb);
- return convertToCharArray(sb);
- }
-
- /**
- * Convert the specified "camel case" string to an "all caps" string:
- * "largeProject" -> "LARGE_PROJECT"
- */
- public static void convertCamelCaseToAllCapsOn(String camelCaseString, StringBuffer sb) {
- int len = camelCaseString.length();
- if (len != 0) {
- convertCamelCaseToAllCapsOn_(camelCaseString.toCharArray(), len, sb);
- }
- }
-
- /**
- * Convert the specified "camel case" string to an "all caps" string:
- * "largeProject" -> "LARGE_PROJECT"
- */
- public static void convertCamelCaseToAllCapsOn(char[] camelCaseString, StringBuffer sb) {
- int len = camelCaseString.length;
- if (len != 0) {
- convertCamelCaseToAllCapsOn_(camelCaseString, len, sb);
- }
- }
-
- private static void convertCamelCaseToAllCapsOn_(char[] camelCaseString, int len, StringBuffer sb) {
- char prev = 0; // assume 0 is not a valid char
- char c = 0;
- char next = camelCaseString[0];
- for (int i = 1; i <= len; i++) { // NB: start at 1 and end at len!
- c = next;
- next = ((i == len) ? 0 : camelCaseString[i]);
- if (camelCaseWordBreak_(prev, c, next)) {
- sb.append('_');
- }
- sb.append(Character.toUpperCase(c));
- prev = c;
- }
- }
-
- /**
- * Convert the specified "camel case" string to an "all caps" string:
- * "largeProject" -> "LARGE_PROJECT"
- */
- public static void convertCamelCaseToAllCapsOn(String camelCaseString, StringBuilder sb) {
- int len = camelCaseString.length();
- if (len != 0) {
- convertCamelCaseToAllCapsOn_(camelCaseString.toCharArray(), len, sb);
- }
- }
-
- /**
- * Convert the specified "camel case" string to an "all caps" string:
- * "largeProject" -> "LARGE_PROJECT"
- */
- public static void convertCamelCaseToAllCapsOn(char[] camelCaseString, StringBuilder sb) {
- int len = camelCaseString.length;
- if (len != 0) {
- convertCamelCaseToAllCapsOn_(camelCaseString, len, sb);
- }
- }
-
- private static void convertCamelCaseToAllCapsOn_(char[] camelCaseString, int len, StringBuilder sb) {
- char prev = 0; // assume 0 is not a valid char
- char c = 0;
- char next = camelCaseString[0];
- for (int i = 1; i <= len; i++) { // NB: start at 1 and end at len!
- c = next;
- next = ((i == len) ? 0 : camelCaseString[i]);
- if (camelCaseWordBreak_(prev, c, next)) {
- sb.append('_');
- }
- sb.append(Character.toUpperCase(c));
- prev = c;
- }
- }
-
- /**
- * Convert the specified "camel case" string to an "all caps" string:
- * "largeProject" -> "LARGE_PROJECT"
- */
- public static void convertCamelCaseToAllCapsOn(String camelCaseString, Writer writer) {
- int len = camelCaseString.length();
- if (len != 0) {
- convertCamelCaseToAllCapsOn_(camelCaseString.toCharArray(), len, writer);
- }
- }
-
- /**
- * Convert the specified "camel case" string to an "all caps" string:
- * "largeProject" -> "LARGE_PROJECT"
- */
- public static void convertCamelCaseToAllCapsOn(char[] camelCaseString, Writer writer) {
- int len = camelCaseString.length;
- if (len != 0) {
- convertCamelCaseToAllCapsOn_(camelCaseString, len, writer);
- }
- }
-
- private static void convertCamelCaseToAllCapsOn_(char[] camelCaseString, int len, Writer writer) {
- char prev = 0; // assume 0 is not a valid char
- char c = 0;
- char next = camelCaseString[0];
- for (int i = 1; i <= len; i++) { // NB: start at 1 and end at len!
- c = next;
- next = ((i == len) ? 0 : camelCaseString[i]);
- if (camelCaseWordBreak_(prev, c, next)) {
- writeCharOn('_', writer);
- }
- writeCharOn(Character.toUpperCase(c), writer);
- prev = c;
- }
- }
-
- /**
- * Convert the specified "camel case" string to an "all caps" string:
- * "largeProject" -> "LARGE_PROJECT"
- * Limit the resulting string to the specified maximum length.
- */
- public static String convertCamelCaseToAllCaps(String camelCaseString, int maxLength) {
- int len = camelCaseString.length();
- if ((len == 0) || (maxLength == 0)) {
- return camelCaseString;
- }
- return new String(convertCamelCaseToAllCaps_(camelCaseString.toCharArray(), maxLength, len));
- }
-
- /**
- * Convert the specified "camel case" string to an "all caps" string:
- * "largeProject" -> "LARGE_PROJECT"
- * Limit the resulting string to the specified maximum length.
- */
- public static char[] convertCamelCaseToAllCaps(char[] camelCaseString, int maxLength) {
- int len = camelCaseString.length;
- if ((len == 0) || (maxLength == 0)) {
- return camelCaseString;
- }
- return convertCamelCaseToAllCaps_(camelCaseString, maxLength, len);
- }
-
- private static char[] convertCamelCaseToAllCaps_(char[] camelCaseString, int maxLength, int len) {
- StringBuilder sb = new StringBuilder(maxLength);
- convertCamelCaseToAllCapsOn_(camelCaseString, maxLength, len, sb);
- return convertToCharArray(sb);
- }
-
- /**
- * Convert the specified "camel case" string to an "all caps" string:
- * "largeProject" -> "LARGE_PROJECT"
- * Limit the resulting string to the specified maximum length.
- */
- public static void convertCamelCaseToAllCapsOn(String camelCaseString, int maxLength, StringBuffer sb) {
- int len = camelCaseString.length();
- if ((len != 0) && (maxLength != 0)) {
- convertCamelCaseToAllCapsOn_(camelCaseString.toCharArray(), maxLength, len, sb);
- }
- }
-
- /**
- * Convert the specified "camel case" string to an "all caps" string:
- * "largeProject" -> "LARGE_PROJECT"
- * Limit the resulting string to the specified maximum length.
- */
- public static void convertCamelCaseToAllCapsOn(char[] camelCaseString, int maxLength, StringBuffer sb) {
- int len = camelCaseString.length;
- if ((len != 0) && (maxLength != 0)) {
- convertCamelCaseToAllCapsOn_(camelCaseString, maxLength, len, sb);
- }
- }
-
- private static void convertCamelCaseToAllCapsOn_(char[] camelCaseString, int maxLength, int len, StringBuffer sb) {
- char prev = 0; // assume 0 is not a valid char
- char c = 0;
- char next = camelCaseString[0];
- for (int i = 1; i <= len; i++) { // NB: start at 1 and end at len!
- c = next;
- next = ((i == len) ? 0 : camelCaseString[i]);
- if (camelCaseWordBreak_(prev, c, next)) {
- sb.append('_');
- if (sb.length() == maxLength) {
- return;
- }
- }
- sb.append(Character.toUpperCase(c));
- if (sb.length() == maxLength) {
- return;
- }
- prev = c;
- }
- }
-
- /**
- * Convert the specified "camel case" string to an "all caps" string:
- * "largeProject" -> "LARGE_PROJECT"
- * Limit the resulting string to the specified maximum length.
- */
- public static void convertCamelCaseToAllCapsOn(String camelCaseString, int maxLength, StringBuilder sb) {
- int len = camelCaseString.length();
- if ((len != 0) && (maxLength != 0)) {
- convertCamelCaseToAllCapsOn_(camelCaseString.toCharArray(), maxLength, len, sb);
- }
- }
-
- /**
- * Convert the specified "camel case" string to an "all caps" string:
- * "largeProject" -> "LARGE_PROJECT"
- * Limit the resulting string to the specified maximum length.
- */
- public static void convertCamelCaseToAllCapsOn(char[] camelCaseString, int maxLength, StringBuilder sb) {
- int len = camelCaseString.length;
- if ((len != 0) && (maxLength != 0)) {
- convertCamelCaseToAllCapsOn_(camelCaseString, maxLength, len, sb);
- }
- }
-
- private static void convertCamelCaseToAllCapsOn_(char[] camelCaseString, int maxLength, int len, StringBuilder sb) {
- char prev = 0; // assume 0 is not a valid char
- char c = 0;
- char next = camelCaseString[0];
- for (int i = 1; i <= len; i++) { // NB: start at 1 and end at len!
- c = next;
- next = ((i == len) ? 0 : camelCaseString[i]);
- if (camelCaseWordBreak_(prev, c, next)) {
- sb.append('_');
- if (sb.length() == maxLength) {
- return;
- }
- }
- sb.append(Character.toUpperCase(c));
- if (sb.length() == maxLength) {
- return;
- }
- prev = c;
- }
- }
-
- /**
- * Convert the specified "camel case" string to an "all caps" string:
- * "largeProject" -> "LARGE_PROJECT"
- * Limit the resulting string to the specified maximum length.
- */
- public static void convertCamelCaseToAllCapsOn(String camelCaseString, int maxLength, Writer writer) {
- int len = camelCaseString.length();
- if ((len != 0) && (maxLength != 0)) {
- convertCamelCaseToAllCapsOn_(camelCaseString.toCharArray(), maxLength, len, writer);
- }
- }
-
- /**
- * Convert the specified "camel case" string to an "all caps" string:
- * "largeProject" -> "LARGE_PROJECT"
- * Limit the resulting string to the specified maximum length.
- */
- public static void convertCamelCaseToAllCapsOn(char[] camelCaseString, int maxLength, Writer writer) {
- int len = camelCaseString.length;
- if ((len != 0) && (maxLength != 0)) {
- convertCamelCaseToAllCapsOn_(camelCaseString, maxLength, len, writer);
- }
- }
-
- private static void convertCamelCaseToAllCapsOn_(char[] camelCaseString, int maxLength, int len, Writer writer) {
- char prev = 0; // assume 0 is not a valid char
- char c = 0;
- char next = camelCaseString[0];
- int writerLength = 0;
- for (int i = 1; i <= len; i++) { // NB: start at 1 and end at len!
- c = next;
- next = ((i == len) ? 0 : camelCaseString[i]);
- if (camelCaseWordBreak_(prev, c, next)) {
- writeCharOn('_', writer);
- if (++writerLength == maxLength) {
- return;
- }
- }
- writeCharOn(Character.toUpperCase(c), writer);
- if (++writerLength == maxLength) {
- return;
- }
- prev = c;
- }
- }
-
- /*
- * Return whether the specified series of characters occur at
- * a "camel case" work break:
- * "*aa" -> false
- * "*AA" -> false
- * "*Aa" -> false
- * "AaA" -> false
- * "AAA" -> false
- * "aa*" -> false
- * "AaA" -> false
- * "aAa" -> true
- * "AA*" -> false
- * "AAa" -> true
- * where '*' == any char
- */
- private static boolean camelCaseWordBreak_(char prev, char c, char next) {
- if (prev == 0) { // start of string
- return false;
- }
- if (Character.isLowerCase(c)) {
- return false;
- }
- if (Character.isLowerCase(prev)) {
- return true;
- }
- if (next == 0) { // end of string
- return false;
- }
- return Character.isLowerCase(next);
- }
-
-
- // ********** convert underscores to camel case **********
-
- /**
- * Convert the specified "underscore" string to a "camel case" string:
- * "LARGE_PROJECT" -> "LargeProject"
- * Capitalize the first letter.
- */
- public static String convertUnderscoresToCamelCase(String underscoreString) {
- return convertUnderscoresToCamelCase(underscoreString, true);
- }
-
- /**
- * Convert the specified "underscore" string to a "camel case" string:
- * "LARGE_PROJECT" -> "LargeProject"
- * Capitalize the first letter.
- */
- public static char[] convertUnderscoresToCamelCase(char[] underscoreString) {
- return convertUnderscoresToCamelCase(underscoreString, true);
- }
-
- /**
- * Convert the specified "underscore" string to a "camel case" string:
- * "LARGE_PROJECT" -> "largeProject"
- * Optionally capitalize the first letter.
- */
- public static String convertUnderscoresToCamelCase(String underscoreString, boolean capitalizeFirstLetter) {
- int len = underscoreString.length();
- if (len == 0) {
- return underscoreString;
- }
- return new String(convertUnderscoresToCamelCase_(underscoreString.toCharArray(), capitalizeFirstLetter, len));
- }
-
- /**
- * Convert the specified "underscore" string to a "camel case" string:
- * "LARGE_PROJECT" -> "largeProject"
- * Optionally capitalize the first letter.
- */
- public static char[] convertUnderscoresToCamelCase(char[] underscoreString, boolean capitalizeFirstLetter) {
- int len = underscoreString.length;
- if (len == 0) {
- return underscoreString;
- }
- return convertUnderscoresToCamelCase_(underscoreString, capitalizeFirstLetter, len);
- }
-
- private static char[] convertUnderscoresToCamelCase_(char[] underscoreString, boolean capitalizeFirstLetter, int len) {
- StringBuilder sb = new StringBuilder(len);
- convertUnderscoresToCamelCaseOn_(underscoreString, capitalizeFirstLetter, len, sb);
- return convertToCharArray(sb);
- }
-
- /**
- * Convert the specified "underscore" string to a "camel case" string:
- * "LARGE_PROJECT" -> "largeProject"
- * Optionally capitalize the first letter.
- */
- public static void convertUnderscoresToCamelCaseOn(String underscoreString, boolean capitalizeFirstLetter, StringBuffer sb) {
- int len = underscoreString.length();
- if (len != 0) {
- convertUnderscoresToCamelCaseOn_(underscoreString.toCharArray(), capitalizeFirstLetter, len, sb);
- }
- }
-
- /**
- * Convert the specified "underscore" string to a "camel case" string:
- * "LARGE_PROJECT" -> "largeProject"
- * Optionally capitalize the first letter.
- */
- public static void convertUnderscoresToCamelCaseOn(char[] underscoreString, boolean capitalizeFirstLetter, StringBuffer sb) {
- int len = underscoreString.length;
- if (len != 0) {
- convertUnderscoresToCamelCaseOn_(underscoreString, capitalizeFirstLetter, len, sb);
- }
- }
-
- private static void convertUnderscoresToCamelCaseOn_(char[] underscoreString, boolean capitalizeFirstLetter, int len, StringBuffer sb) {
- char prev = 0;
- char c = 0;
- boolean first = true;
- for (int i = 0; i < len; i++) {
- prev = c;
- c = underscoreString[i];
- if (c == '_') {
- continue;
- }
- if (first) {
- first = false;
- sb.append(capitalizeFirstLetter ? Character.toUpperCase(c) : Character.toLowerCase(c));
- } else {
- sb.append((prev == '_') ? Character.toUpperCase(c) : Character.toLowerCase(c));
- }
- }
- }
-
- /**
- * Convert the specified "underscore" string to a "camel case" string:
- * "LARGE_PROJECT" -> "largeProject"
- * Optionally capitalize the first letter.
- */
- public static void convertUnderscoresToCamelCaseOn(String underscoreString, boolean capitalizeFirstLetter, StringBuilder sb) {
- int len = underscoreString.length();
- if (len != 0) {
- convertUnderscoresToCamelCaseOn_(underscoreString.toCharArray(), capitalizeFirstLetter, len, sb);
- }
- }
-
- /**
- * Convert the specified "underscore" string to a "camel case" string:
- * "LARGE_PROJECT" -> "largeProject"
- * Optionally capitalize the first letter.
- */
- public static void convertUnderscoresToCamelCaseOn(char[] underscoreString, boolean capitalizeFirstLetter, StringBuilder sb) {
- int len = underscoreString.length;
- if (len != 0) {
- convertUnderscoresToCamelCaseOn_(underscoreString, capitalizeFirstLetter, len, sb);
- }
- }
-
- private static void convertUnderscoresToCamelCaseOn_(char[] underscoreString, boolean capitalizeFirstLetter, int len, StringBuilder sb) {
- char prev = 0;
- char c = 0;
- boolean first = true;
- for (int i = 0; i < len; i++) {
- prev = c;
- c = underscoreString[i];
- if (c == '_') {
- continue;
- }
- if (first) {
- first = false;
- sb.append(capitalizeFirstLetter ? Character.toUpperCase(c) : Character.toLowerCase(c));
- } else {
- sb.append((prev == '_') ? Character.toUpperCase(c) : Character.toLowerCase(c));
- }
- }
- }
-
- /**
- * Convert the specified "underscore" string to a "camel case" string:
- * "LARGE_PROJECT" -> "largeProject"
- * Optionally capitalize the first letter.
- */
- public static void convertUnderscoresToCamelCaseOn(String underscoreString, boolean capitalizeFirstLetter, Writer writer) {
- int len = underscoreString.length();
- if (len != 0) {
- convertUnderscoresToCamelCaseOn_(underscoreString.toCharArray(), capitalizeFirstLetter, len, writer);
- }
- }
-
- /**
- * Convert the specified "underscore" string to a "camel case" string:
- * "LARGE_PROJECT" -> "largeProject"
- * Optionally capitalize the first letter.
- */
- public static void convertUnderscoresToCamelCaseOn(char[] underscoreString, boolean capitalizeFirstLetter, Writer writer) {
- int len = underscoreString.length;
- if (len != 0) {
- convertUnderscoresToCamelCaseOn_(underscoreString, capitalizeFirstLetter, len, writer);
- }
- }
-
- private static void convertUnderscoresToCamelCaseOn_(char[] underscoreString, boolean capitalizeFirstLetter, int len, Writer writer) {
- char prev = 0;
- char c = 0;
- boolean first = true;
- for (int i = 0; i < len; i++) {
- prev = c;
- c = underscoreString[i];
- if (c == '_') {
- continue;
- }
- if (first) {
- first = false;
- writeCharOn(capitalizeFirstLetter ? Character.toUpperCase(c) : Character.toLowerCase(c), writer);
- } else {
- writeCharOn((prev == '_') ? Character.toUpperCase(c) : Character.toLowerCase(c), writer);
- }
- }
- }
-
-
- // ********** convert to Java string literal **********
-
- public static final String EMPTY_JAVA_STRING_LITERAL = "\"\""; //$NON-NLS-1$
- public static final char[] EMPTY_JAVA_STRING_LITERAL_CHAR_ARRAY = EMPTY_JAVA_STRING_LITERAL.toCharArray();
-
- public static String convertToJavaStringLiteral(String string) {
- int len = string.length();
- if (len == 0) {
- return EMPTY_JAVA_STRING_LITERAL;
- }
- StringBuilder sb = new StringBuilder(len + 5);
- convertToJavaStringLiteralOn_(string.toCharArray(), sb, len);
- return sb.toString();
- }
-
- public static char[] convertToJavaStringLiteral(char[] string) {
- int len = string.length;
- if (len == 0) {
- return EMPTY_JAVA_STRING_LITERAL_CHAR_ARRAY;
- }
- StringBuilder sb = new StringBuilder(len + 5);
- convertToJavaStringLiteralOn_(string, sb, len);
- len = sb.length();
- char[] result = new char[len];
- sb.getChars(0, len, result, 0);
- return result;
- }
-
- public static Iterable<String> convertToJavaStringLiterals(Iterable<String> strings) {
- return new TransformationIterable<String, String>(strings, STRING_TO_JAVA_STRING_LITERAL_TRANSFORMER);
- }
-
- public static Iterator<String> convertToJavaStringLiterals(Iterator<String> strings) {
- return new TransformationIterator<String, String>(strings, STRING_TO_JAVA_STRING_LITERAL_TRANSFORMER);
- }
-
- private static final Transformer<String, String> STRING_TO_JAVA_STRING_LITERAL_TRANSFORMER = new Transformer<String, String>() {
- public String transform(String string) {
- return StringTools.convertToJavaStringLiteral(string);
- }
- };
-
- // cannot name method simply 'convertToJavaStringLiterals' because of type-erasure...
- public static Iterable<char[]> convertToJavaCharArrayLiterals(Iterable<char[]> strings) {
- return new TransformationIterable<char[], char[]>(strings, CHAR_ARRAY_TO_JAVA_STRING_LITERAL_TRANSFORMER);
- }
-
- // cannot name method simply 'convertToJavaStringLiterals' because of type-erasure...
- public static Iterator<char[]> convertToJavaCharArrayLiterals(Iterator<char[]> strings) {
- return new TransformationIterator<char[], char[]>(strings, CHAR_ARRAY_TO_JAVA_STRING_LITERAL_TRANSFORMER);
- }
-
- private static final Transformer<char[], char[]> CHAR_ARRAY_TO_JAVA_STRING_LITERAL_TRANSFORMER = new Transformer<char[], char[]>() {
- public char[] transform(char[] string) {
- return StringTools.convertToJavaStringLiteral(string);
- }
- };
-
- public static void convertToJavaStringLiteralOn(String string, StringBuffer sb) {
- int len = string.length();
- if (len == 0) {
- sb.append(EMPTY_JAVA_STRING_LITERAL);
- } else {
- convertToJavaStringLiteralOn_(string.toCharArray(), sb, len);
- }
- }
-
- public static void convertToJavaStringLiteralOn(char[] string, StringBuffer sb) {
- int len = string.length;
- if (len == 0) {
- sb.append(EMPTY_JAVA_STRING_LITERAL);
- } else {
- convertToJavaStringLiteralOn_(string, sb, len);
- }
- }
-
- /*
- * no length checks
- */
- private static void convertToJavaStringLiteralOn_(char[] string, StringBuffer sb, int len) {
- sb.ensureCapacity(sb.length() + len + 5);
- sb.append(QUOTE);
- for (char c : string) {
- switch (c) {
- case '\b': // backspace
- sb.append("\\b"); //$NON-NLS-1$
- break;
- case '\t': // horizontal tab
- sb.append("\\t"); //$NON-NLS-1$
- break;
- case '\n': // line-feed LF
- sb.append("\\n"); //$NON-NLS-1$
- break;
- case '\f': // form-feed FF
- sb.append("\\f"); //$NON-NLS-1$
- break;
- case '\r': // carriage-return CR
- sb.append("\\r"); //$NON-NLS-1$
- break;
- case '"': // double-quote
- sb.append("\\\""); //$NON-NLS-1$
- break;
-// case '\'': // single-quote
-// sb.append("\\'"); //$NON-NLS-1$
-// break;
- case '\\': // backslash
- sb.append("\\\\"); //$NON-NLS-1$
- break;
- default:
- sb.append(c);
- break;
- }
- }
- sb.append(QUOTE);
- }
-
- public static void convertToJavaStringLiteralOn(String string, StringBuilder sb) {
- int len = string.length();
- if (len == 0) {
- sb.append(EMPTY_JAVA_STRING_LITERAL);
- } else {
- convertToJavaStringLiteralOn_(string.toCharArray(), sb, len);
- }
- }
-
- public static void convertToJavaStringLiteralOn(char[] string, StringBuilder sb) {
- int len = string.length;
- if (len == 0) {
- sb.append(EMPTY_JAVA_STRING_LITERAL);
- } else {
- convertToJavaStringLiteralOn_(string, sb, len);
- }
- }
-
- /*
- * no length checks
- */
- private static void convertToJavaStringLiteralOn_(char[] string, StringBuilder sb, int len) {
- sb.ensureCapacity(sb.length() + len + 5);
- sb.append(QUOTE);
- for (char c : string) {
- switch (c) {
- case '\b': // backspace
- sb.append("\\b"); //$NON-NLS-1$
- break;
- case '\t': // horizontal tab
- sb.append("\\t"); //$NON-NLS-1$
- break;
- case '\n': // line-feed LF
- sb.append("\\n"); //$NON-NLS-1$
- break;
- case '\f': // form-feed FF
- sb.append("\\f"); //$NON-NLS-1$
- break;
- case '\r': // carriage-return CR
- sb.append("\\r"); //$NON-NLS-1$
- break;
- case '"': // double-quote
- sb.append("\\\""); //$NON-NLS-1$
- break;
-// case '\'': // single-quote
-// sb.append("\\'"); //$NON-NLS-1$
-// break;
- case '\\': // backslash
- sb.append("\\\\"); //$NON-NLS-1$
- break;
- default:
- sb.append(c);
- break;
- }
- }
- sb.append(QUOTE);
- }
-
- public static void convertToJavaStringLiteralOn(String string, Writer writer) {
- if (string.length() == 0) {
- writeStringOn(EMPTY_JAVA_STRING_LITERAL, writer);
- } else {
- convertToJavaStringLiteralOn_(string.toCharArray(), writer);
- }
- }
-
- public static void convertToJavaStringLiteralOn(char[] string, Writer writer) {
- if (string.length == 0) {
- writeStringOn(EMPTY_JAVA_STRING_LITERAL, writer);
- } else {
- convertToJavaStringLiteralOn_(string, writer);
- }
- }
-
- /*
- * no length checks
- */
- private static void convertToJavaStringLiteralOn_(char[] string, Writer writer) {
- writeCharOn(QUOTE, writer);
- for (char c : string) {
- switch (c) {
- case '\b': // backspace
- writeStringOn("\\b", writer); //$NON-NLS-1$
- break;
- case '\t': // horizontal tab
- writeStringOn("\\t", writer); //$NON-NLS-1$
- break;
- case '\n': // line-feed LF
- writeStringOn("\\n", writer); //$NON-NLS-1$
- break;
- case '\f': // form-feed FF
- writeStringOn("\\f", writer); //$NON-NLS-1$
- break;
- case '\r': // carriage-return CR
- writeStringOn("\\r", writer); //$NON-NLS-1$
- break;
- case '"': // double-quote
- writeStringOn("\\\"", writer); //$NON-NLS-1$
- break;
-// case '\'': // single-quote
-// writeStringOn("\\'", writer); //$NON-NLS-1$
-// break;
- case '\\': // backslash
- writeStringOn("\\\\", writer); //$NON-NLS-1$
- break;
- default:
- writeCharOn(c, writer);
- break;
- }
- }
- writeCharOn(QUOTE, writer);
- }
-
-
- // ********** convenience **********
-
- public static char[] convertToCharArray(StringBuffer sb) {
- int len = sb.length();
- char[] result = new char[len];
- sb.getChars(0, len, result, 0);
- return result;
- }
-
- public static char[] convertToCharArray(StringBuilder sb) {
- int len = sb.length();
- char[] result = new char[len];
- sb.getChars(0, len, result, 0);
- return result;
- }
-
- private static void writeStringOn(char[] string, Writer writer) {
- try {
- writer.write(string);
- } catch (IOException ex) {
- throw new RuntimeException(ex);
- }
- }
-
- private static void writeStringOn(char[] string, char escape, Writer writer) {
- try {
- for (char c : string) {
- if (c == escape) {
- writer.write(c);
- }
- writer.write(c);
- }
- } catch (IOException ex) {
- throw new RuntimeException(ex);
- }
- }
-
- private static void writeStringOn(char[] string, int off, int len, Writer writer) {
- try {
- writer.write(string, off, len);
- } catch (IOException ex) {
- throw new RuntimeException(ex);
- }
- }
-
- private static void writeStringOn(String string, int off, int len, Writer writer) {
- try {
- writer.write(string, off, len);
- } catch (IOException ex) {
- throw new RuntimeException(ex);
- }
- }
-
- private static void writeStringOn(String string, Writer writer) {
- try {
- writer.write(string);
- } catch (IOException ex) {
- throw new RuntimeException(ex);
- }
- }
-
- private static void writeCharOn(char c, Writer writer) {
- try {
- writer.write(c);
- } catch (IOException ex) {
- throw new RuntimeException(ex);
- }
- }
-
-
- // ********** constructor **********
-
- /*
- * Suppress default constructor, ensuring non-instantiability.
- */
- private StringTools() {
- super();
- throw new UnsupportedOperationException();
- }
-}

Back to the top