Author: ggregory
Date: Wed Feb 6 12:21:57 2008
New Revision: 619143
URL: http://svn.apache.org/viewvc?rev=619143&view=rev
Log:
Format @since 2.4 methods to match the rest of the file. For example,
expressions use no spaces around parens.
Modified:
commons/proper/lang/trunk/src/java/org/apache/commons/lang/StringUtils.java
Modified:
commons/proper/lang/trunk/src/java/org/apache/commons/lang/StringUtils.java
URL:
http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/java/org/apache/commons/lang/StringUtils.java?rev=619143&r1=619142&r2=619143&view=diff
==============================================================================
--- commons/proper/lang/trunk/src/java/org/apache/commons/lang/StringUtils.java
(original)
+++ commons/proper/lang/trunk/src/java/org/apache/commons/lang/StringUtils.java
Wed Feb 6 12:21:57 2008
@@ -1163,8 +1163,7 @@
* @since 2.4
*/
public static boolean containsAny(String str, char[] searchChars) {
- if (str == null || str.length() == 0 ||
- searchChars == null || searchChars.length == 0) {
+ if (str == null || str.length() == 0 || searchChars == null ||
searchChars.length == 0) {
return false;
}
for (int i = 0; i < str.length(); i++) {
@@ -1179,12 +1178,15 @@
}
/**
- * <p>Checks if the String contains any character in the given
- * set of characters.</p>
- *
- * <p>A <code>null</code> String will return <code>false</code>.
- * A <code>null</code> search string will return <code>false</code>.</p>
- *
+ * <p>
+ * Checks if the String contains any character in the given set of
characters.
+ * </p>
+ *
+ * <p>
+ * A <code>null</code> String will return <code>false</code>. A
<code>null</code> search string will return
+ * <code>false</code>.
+ * </p>
+ *
* <pre>
* StringUtils.containsAny(null, *) = false
* StringUtils.containsAny("", *) = false
@@ -1194,11 +1196,12 @@
* StringUtils.containsAny("zzabyycdxx", "by") = true
* StringUtils.containsAny("aba","z") = false
* </pre>
- *
- * @param str the String to check, may be null
- * @param searchChars the chars to search for, may be null
- * @return the <code>true</code> if any of the chars are found,
- * <code>false</code> if no match or null input
+ *
+ * @param str
+ * the String to check, may be null
+ * @param searchChars
+ * the chars to search for, may be null
+ * @return the <code>true</code> if any of the chars are found,
<code>false</code> if no match or null input
* @since 2.4
*/
public static boolean containsAny(String str, String searchChars) {
@@ -2283,7 +2286,7 @@
* @since 2.4
*/
public static String[] splitByWholeSeparatorPreserveAllTokens(String str,
String separator) {
- return splitByWholeSeparatorWorker( str, separator, -1, true ) ;
+ return splitByWholeSeparatorWorker(str, separator, -1, true);
}
/**
@@ -2315,7 +2318,7 @@
* @return an array of parsed Strings, <code>null</code> if null String
was input
* @since 2.4
*/
- public static String[] splitByWholeSeparatorPreserveAllTokens( String str,
String separator, int max ) {
+ public static String[] splitByWholeSeparatorPreserveAllTokens(String str,
String separator, int max) {
return splitByWholeSeparatorWorker(str, separator, max, true);
}
@@ -2333,76 +2336,72 @@
* @return an array of parsed Strings, <code>null</code> if null String
input
* @since 2.4
*/
- private static String[] splitByWholeSeparatorWorker( String str, String
separator,
- int max, boolean
preserveAllTokens )
- {
+ private static String[] splitByWholeSeparatorWorker(String str, String
separator, int max, boolean preserveAllTokens) {
if (str == null) {
return null;
}
- int len = str.length() ;
+ int len = str.length();
if (len == 0) {
return ArrayUtils.EMPTY_STRING_ARRAY;
}
- if ( ( separator == null ) || ( EMPTY.equals( separator ) ) ) {
+ if ((separator == null) || (EMPTY.equals(separator))) {
// Split on whitespace.
- return splitWorker( str, null, max, preserveAllTokens ) ;
+ return splitWorker(str, null, max, preserveAllTokens);
}
+ int separatorLength = separator.length();
- int separatorLength = separator.length() ;
-
- ArrayList substrings = new ArrayList() ;
- int numberOfSubstrings = 0 ;
- int beg = 0 ;
- int end = 0 ;
- while ( end < len ) {
- end = str.indexOf( separator, beg ) ;
+ ArrayList substrings = new ArrayList();
+ int numberOfSubstrings = 0;
+ int beg = 0;
+ int end = 0;
+ while (end < len) {
+ end = str.indexOf(separator, beg);
- if ( end > -1 ) {
- if ( end > beg ) {
- numberOfSubstrings += 1 ;
+ if (end > -1) {
+ if (end > beg) {
+ numberOfSubstrings += 1;
- if ( numberOfSubstrings == max ) {
- end = len ;
- substrings.add( str.substring( beg ) ) ;
+ if (numberOfSubstrings == max) {
+ end = len;
+ substrings.add(str.substring(beg));
} else {
// The following is OK, because String.substring( beg,
end ) excludes
// the character at the position 'end'.
- substrings.add( str.substring( beg, end ) ) ;
+ substrings.add(str.substring(beg, end));
// Set the starting point for the next search.
// The following is equivalent to beg = end +
(separatorLength - 1) + 1,
// which is the right calculation:
- beg = end + separatorLength ;
+ beg = end + separatorLength;
}
} else {
// We found a consecutive occurrence of the separator, so
skip it.
- if( preserveAllTokens ) {
- numberOfSubstrings += 1 ;
- if ( numberOfSubstrings == max ) {
- end = len ;
- substrings.add( str.substring( beg ) ) ;
+ if (preserveAllTokens) {
+ numberOfSubstrings += 1;
+ if (numberOfSubstrings == max) {
+ end = len;
+ substrings.add(str.substring(beg));
} else {
- substrings.add( EMPTY );
+ substrings.add(EMPTY);
}
}
- beg = end + separatorLength ;
+ beg = end + separatorLength;
}
} else {
// String.substring( beg ) goes from 'beg' to the end of the
String.
- substrings.add( str.substring( beg ) ) ;
- end = len ;
+ substrings.add(str.substring(beg));
+ end = len;
}
}
- return (String[]) substrings.toArray( new String[substrings.size()] ) ;
+ return (String[]) substrings.toArray(new String[substrings.size()]);
}
-
- //-----------------------------------------------------------------------
+ // -----------------------------------------------------------------------
/**
* <p>Splits the provided text into an array, using whitespace as the
* separator, preserving all tokens, including empty tokens created by
@@ -2770,8 +2769,7 @@
if (type == currentType) {
continue;
}
- if (camelCase && type == Character.LOWERCASE_LETTER
- && currentType == Character.UPPERCASE_LETTER) {
+ if (camelCase && type == Character.LOWERCASE_LETTER && currentType
== Character.UPPERCASE_LETTER) {
int newTokenStart = pos - 1;
if (newTokenStart != tokenStart) {
list.add(new String(c, tokenStart, newTokenStart -
tokenStart));
@@ -3267,7 +3265,7 @@
if (isEmpty(str) || isEmpty(remove)) {
return str;
}
- if (startsWithIgnoreCase(str, remove)){
+ if (startsWithIgnoreCase(str, remove)) {
return str.substring(remove.length());
}
return str;
@@ -3603,7 +3601,6 @@
* @since 2.4
*/
public static String replaceEachRepeatedly(String text, String[] repl,
String[] with) {
-
// timeToLive should be 0 if not used or nothing to replace, else it's
// the length of the replace array
int timeToLive = repl == null ? 0 : repl.length;
@@ -3656,16 +3653,12 @@
* and/or size 0)
* @since 2.4
*/
- private static String replaceEach(String text, String[] repl, String[]
with,
- boolean repeat, int timeToLive) {
+ private static String replaceEach(String text, String[] repl, String[]
with, boolean repeat, int timeToLive) {
- // mchyzer Performance note: This creates very few new objects (one
major goal)
+ // mchyzer Performance note: This creates very few new objects (one
major goal)
// let me know if there are performance requests, we can create a
harness to measure
-
- if (text == null || text.length() == 0 ||
- repl == null || repl.length == 0 ||
- with == null || with.length == 0)
- {
+
+ if (text == null || text.length() == 0 || repl == null || repl.length
== 0 || with == null || with.length == 0) {
return text;
}
@@ -3679,7 +3672,10 @@
// make sure lengths are ok, these need to be equal
if (replLength != withLength) {
- throw new IllegalArgumentException("Search and Replace array
lengths don't match: " + replLength + " vs " + withLength);
+ throw new IllegalArgumentException("Search and Replace array
lengths don't match: "
+ + replLength
+ + " vs "
+ + withLength);
}
// keep track of which still have matches
@@ -3697,7 +3693,7 @@
continue;
}
tempIndex = text.indexOf(repl[i]);
-
+
// see if we need to keep searching for this
if (tempIndex == -1) {
noMoreMatchesForReplIndex[i] = true;
@@ -3721,15 +3717,15 @@
int increase = 0;
// count the replacement text elements that are larger than their
corresponding text being replaced
- for (int i=0; i<repl.length; i++) {
+ for (int i = 0; i < repl.length; i++) {
int greater = with[i].length() - repl[i].length();
- if(greater > 0) {
+ if (greater > 0) {
increase += 3 * greater; // assume 3 matches
}
}
// have upper-bound at 20% increase, then let Java take over
- increase = Math.min(increase, text.length() / 5);
-
+ increase = Math.min(increase, text.length() / 5);
+
StringBuffer buf = new StringBuffer(text.length() + increase);
while (textIndex != -1) {
@@ -3751,8 +3747,8 @@
continue;
}
tempIndex = text.indexOf(repl[i], start);
-
- //see if we need to keep searching for this
+
+ // see if we need to keep searching for this
if (tempIndex == -1) {
noMoreMatchesForReplIndex[i] = true;
} else {
@@ -5571,14 +5567,14 @@
int shortestStrLen = Integer.MAX_VALUE;
int longestStrLen = 0;
- // find the min and max string lengths; this avoids checking to make
+ // find the min and max string lengths; this avoids checking to make
// sure we are not exceeding the length of the string each time through
// the bottom loop.
- for (int i=0; i<arrayLen; i++) {
+ for (int i = 0; i < arrayLen; i++) {
if (strs[i] == null) {
anyStringNull = true;
shortestStrLen = 0;
- } else {
+ } else {
allStringsNull = false;
shortestStrLen = Math.min(strs[i].length(), shortestStrLen);
longestStrLen = Math.max(strs[i].length(), longestStrLen);
@@ -5593,13 +5589,13 @@
// handle lists containing some nulls or some empty strings
if (shortestStrLen == 0) {
return 0;
- }
+ }
// find the position with the first difference across all strings
int firstDiff = -1;
- for (int stringPos = 0; stringPos<shortestStrLen; stringPos++) {
+ for (int stringPos = 0; stringPos < shortestStrLen; stringPos++) {
char comparisonChar = strs[0].charAt(stringPos);
- for (int arrayPos = 1; arrayPos<arrayLen; arrayPos++) {
+ for (int arrayPos = 1; arrayPos < arrayLen; arrayPos++) {
if (strs[arrayPos].charAt(stringPos) != comparisonChar) {
firstDiff = stringPos;
break;
@@ -5611,8 +5607,8 @@
}
if (firstDiff == -1 && shortestStrLen != longestStrLen) {
- // we compared all of the characters up to the length of the
- // shortest string and didn't find a match, but the string lengths
+ // we compared all of the characters up to the length of the
+ // shortest string and didn't find a match, but the string lengths
// vary, so return the length of the shortest string.
return shortestStrLen;
}
@@ -5667,7 +5663,7 @@
// there were no common initial characters
return EMPTY;
} else {
- // we found a common initial character sequence
+ // we found a common initial character sequence
return strs[0].substring(0, smallestIndexOfDiff);
}
}
