Formatting

1 files changed, 46 insertions, 29 deletions

diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcutils/StringUtils.java b/BJC-Utils2/src/main/java/bjc/utils/funcutils/StringUtils.java
index 2307f11..2afb783 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/funcutils/StringUtils.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/funcutils/StringUtils.java
@@ -18,18 +18,18 @@ public class StringUtils {
 	 * situation that indicates its use as an infix operator.
 	 * 
 	 * @param expression
-	 *            The expression to check
+	 *                The expression to check
 	 * @param operator
-	 *            The operator to see if it is contained
+	 *                The operator to see if it is contained
 	 * @return Whether or not the given expression contains the specified
 	 *         operator as a infix operator
 	 */
 	public static boolean containsInfixOperator(String expression, String operator) {
-		// Bit annoying to have to use a full class name, but what are you
+		// Bit annoying to have to use a full class name, but what are
+		// you
 		// going to do?
 		return org.apache.commons.lang3.StringUtils.countMatches(expression, operator) == 1
-			&& !expression.equalsIgnoreCase(operator)
-			&& !expression.startsWith(operator);
+				&& !expression.equalsIgnoreCase(operator) && !expression.startsWith(operator);
 	}
 
 	/**
@@ -37,9 +37,10 @@ public class StringUtils {
 	 * expression
 	 * 
 	 * @param input
-	 *            The string to check
+	 *                The string to check
 	 * @param regex
-	 *            The regex to see if the string only contains matches of
+	 *                The regex to see if the string only contains matches
+	 *                of
 	 * @return Whether or not the string consists only of multiple matches
 	 *         of the provided regex
 	 */
@@ -54,9 +55,9 @@ public class StringUtils {
 		 * This regular expression is fairly simple.
 		 * 
 		 * First, we match the beginning of the string. Then, we start a
-		 * non-capturing group whose contents are the passed in regex. That
-		 * group is then matched one or more times and the pattern matches
-		 * to the end of the string
+		 * non-capturing group whose contents are the passed in regex.
+		 * That group is then matched one or more times and the pattern
+		 * matches to the end of the string
 		 */
 		return input.matches("\\A(?:" + regex + ")+\\Z");
 	}
@@ -65,9 +66,9 @@ public class StringUtils {
 	 * Indent the string being built in a StringBuilder n levels
 	 * 
 	 * @param builder
-	 *            The builder to indent in
+	 *                The builder to indent in
 	 * @param levels
-	 *            The number of levels to indent
+	 *                The number of levels to indent
 	 */
 	public static void indentNLevels(StringBuilder builder, int levels) {
 		for (int i = 0; i < levels; i++) {
@@ -80,9 +81,9 @@ public class StringUtils {
 	 * empty
 	 * 
 	 * @param <ContainedType>
-	 *            The type in the deque
+	 *                The type in the deque
 	 * @param queue
-	 *            The deque to print
+	 *                The deque to print
 	 * @return A string version of the deque, with allowance for an empty
 	 *         deque
 	 */
@@ -93,29 +94,44 @@ public class StringUtils {
 	/*
 	 * This regex matches java-style string escapes
 	 */
-	private static String escapeString = 
-		"\\\\([btnfr\"'\\\\]"      // Match shortform escape sequences like \t or \"
-		+ "|[0-3]?[0-7]{1,2}" // Match octal escape sequences
-		+ "|u[0-9a-fA-F]{4})";  // Match unicode escape sequences
+	private static String escapeString = "\\\\([btnfr\"'\\\\]" // Match
+									// shortform
+									// escape
+									// sequences
+									// like
+									// \t or
+									// \"
+			+ "|[0-3]?[0-7]{1,2}" // Match octal escape sequences
+			+ "|u[0-9a-fA-F]{4})"; // Match unicode escape sequences
 	private static Pattern escapePatt = Pattern.compile(escapeString);
 
 	/*
 	 * This regular expression matches java style double quoted strings
 	 */
-	private static Pattern doubleQuotePatt = Pattern.compile("(\"("
-			+ "[^\\\\\"]+"                  // Match one or more characters that aren't quotes or slashes
+	private static Pattern doubleQuotePatt = Pattern.compile("(\"(" + "[^\\\\\"]+" // Match
+											// one
+											// or
+											// more
+											// characters
+											// that
+											// aren't
+											// quotes
+											// or
+											// slashes
 			+ "|" + escapeString + ")" // Match escape sequences
-			+ "*\")");                      // Match all of those things zero or more times, followed by a closing quote
+			+ "*\")"); // Match all of those things zero or more
+					// times, followed by a closing quote
 
 	/**
 	 * Remove double quoted strings from a string.
 	 *
 	 * Splits a string around instances of java-style double-quoted strings.
 	 *
-	 * @param inp The string to split.
+	 * @param inp
+	 *                The string to split.
 	 *
 	 * @return An list containing alternating bits of the string and the
-	 * embedded double-quoted strings that seperated them.
+	 *         embedded double-quoted strings that seperated them.
 	 */
 	public static List<String> removeDQuotedStrings(String inp) {
 		StringBuffer work = new StringBuffer();
@@ -123,7 +139,7 @@ public class StringUtils {
 
 		Matcher mt = doubleQuotePatt.matcher(inp);
 
-		while(mt.find()) {
+		while (mt.find()) {
 			mt.appendReplacement(work, "");
 
 			res.add(work.toString());
@@ -140,20 +156,21 @@ public class StringUtils {
 	/**
 	 * Replace escape characters with their actual equivalents.
 	 *
-	 * @param inp The string to replace escape sequences in.
+	 * @param inp
+	 *                The string to replace escape sequences in.
 	 *
 	 * @return The string with escape sequences replaced by their equivalent
-	 * characters.
+	 *         characters.
 	 */
 	public static String descapeString(String inp) {
 		StringBuffer work = new StringBuffer();
 
 		Matcher escapeFinder = escapePatt.matcher(inp);
-		while(escapeFinder.find()) {
+		while (escapeFinder.find()) {
 			String escapeSeq = escapeFinder.group();
 
 			String escapeRep = "";
-			switch(escapeSeq) {
+			switch (escapeSeq) {
 			case "\\b":
 				escapeRep = "\b";
 				break;
@@ -179,7 +196,7 @@ public class StringUtils {
 				escapeRep = "\\";
 				break;
 			default:
-				if(escapeSeq.startsWith("u")) {
+				if (escapeSeq.startsWith("u")) {
 					escapeRep = handleUnicodeEscape(escapeSeq.substring(1));
 				} else {
 					escapeRep = handleOctalEscape(escapeSeq);