Formatting changes

4 files changed, 216 insertions, 216 deletions

diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcutils/EnumUtils.java b/BJC-Utils2/src/main/java/bjc/utils/funcutils/EnumUtils.java
index 3374aa2..67fd5ec 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/funcutils/EnumUtils.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/funcutils/EnumUtils.java
@@ -14,24 +14,6 @@ import bjc.utils.funcdata.IFunctionalList;
  */
 public class EnumUtils {
 	/**
-	 * Get a random value from an enum
-	 * 
-	 * @param <E>
-	 *            The type of the enum
-	 * @param enumClass
-	 *            The class of the enum
-	 * @param rnd
-	 *            The random source to use
-	 * @return A random value from the specified enum
-	 */
-	public static <E extends Enum<E>> E getRandomValue(Class<E> enumClass,
-			Random rnd) {
-		E[] enumValues = enumClass.getEnumConstants();
-
-		return new FunctionalList<>(enumValues).randItem(rnd::nextInt);
-	}
-
-	/**
 	 * Do an action for a random number of enum values
 	 * 
 	 * @param <E>
@@ -61,4 +43,22 @@ public class EnumUtils {
 
 		valueList.forEach(action);
 	}
+
+	/**
+	 * Get a random value from an enum
+	 * 
+	 * @param <E>
+	 *            The type of the enum
+	 * @param enumClass
+	 *            The class of the enum
+	 * @param rnd
+	 *            The random source to use
+	 * @return A random value from the specified enum
+	 */
+	public static <E extends Enum<E>> E getRandomValue(Class<E> enumClass,
+			Random rnd) {
+		E[] enumValues = enumClass.getEnumConstants();
+
+		return new FunctionalList<>(enumValues).randItem(rnd::nextInt);
+	}
 }
diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcutils/FuncUtils.java b/BJC-Utils2/src/main/java/bjc/utils/funcutils/FuncUtils.java
index 2119ed7..4209e6d 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/funcutils/FuncUtils.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/funcutils/FuncUtils.java
@@ -12,20 +12,6 @@ import java.util.function.IntConsumer;
  */
 public class FuncUtils {
 	/**
-	 * Do the specified action the specified number of times
-	 * 
-	 * @param nTimes
-	 *            The number of times to do the action
-	 * @param cons
-	 *            The action to perform
-	 */
-	public static void doTimes(int nTimes, IntConsumer cons) {
-		for (int i = 0; i < nTimes; i++) {
-			cons.accept(i);
-		}
-	}
-
-	/**
 	 * Convert a binary function into a unary function that returns a
 	 * function
 	 * 
@@ -46,4 +32,18 @@ public class FuncUtils {
 			return func.apply(arg1, arg2);
 		};
 	}
+
+	/**
+	 * Do the specified action the specified number of times
+	 * 
+	 * @param nTimes
+	 *            The number of times to do the action
+	 * @param cons
+	 *            The action to perform
+	 */
+	public static void doTimes(int nTimes, IntConsumer cons) {
+		for (int i = 0; i < nTimes; i++) {
+			cons.accept(i);
+		}
+	}
 }
diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcutils/ListUtils.java b/BJC-Utils2/src/main/java/bjc/utils/funcutils/ListUtils.java
index b0c30b3..ea15a78 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/funcutils/ListUtils.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/funcutils/ListUtils.java
@@ -21,119 +21,51 @@ public class ListUtils {
 	private static final int MAX_NTRIESPART = 50;
 
 	/**
-	 * Partition a list into a list of lists, where each element can count
-	 * for more than one element in a partition
-	 * 
-	 * @param <E>
-	 *            The type of elements in the list to partition
+	 * Collapse a string of tokens into a single string without adding any
+	 * spaces
 	 * 
 	 * @param input
-	 *            The list to partition
-	 * @param elementCounter
-	 *            The function to determine the count for each element for
-	 * @param numberPerPartition
-	 *            The number of elements to put in each partition
-	 * @return A list partitioned according to the above rules
+	 *            The list of tokens to collapse
+	 * @return The collapsed string of tokens
 	 */
-	public static <E> IFunctionalList<IFunctionalList<E>> groupPartition(
-			IFunctionalList<E> input, Function<E, Integer> elementCounter,
-			int numberPerPartition) {
+	public static String collapseTokens(IFunctionalList<String> input) {
 		if (input == null) {
-			throw new NullPointerException("Input list must not be null");
-		} else if (elementCounter == null) {
-			throw new NullPointerException("Counter must not be null");
-		} else if (numberPerPartition < 1
-				|| numberPerPartition > input.getSize()) {
-			throw new IllegalArgumentException(
-					"" + numberPerPartition + " is not a valid"
-							+ " partition size. Must be between 1 and "
-							+ input.getSize());
-		}
-
-		/*
-		 * List that holds our results
-		 */
-		IFunctionalList<IFunctionalList<E>> returnedList = new FunctionalList<>();
-
-		/*
-		 * List that holds current partition
-		 */
-		IHolder<IFunctionalList<E>> currentPartition = new Identity<>(
-				new FunctionalList<>());
-		/*
-		 * List that holds elements rejected during current pass
-		 */
-		IFunctionalList<E> rejectedElements = new FunctionalList<>();
-
-		/*
-		 * The effective number of elements in the current partitition
-		 */
-		IHolder<Integer> numberInCurrentPartition = new Identity<>(0);
-
-		/*
-		 * Run up to a certain number of passes
-		 */
-		for (int numberOfIterations = 0; numberOfIterations < MAX_NTRIESPART
-				&& !rejectedElements.isEmpty(); numberOfIterations++) {
-			input.forEach(new GroupPartIteration<>(returnedList,
-					currentPartition, rejectedElements,
-					numberInCurrentPartition, numberPerPartition,
-					elementCounter));
-
-			if (rejectedElements.isEmpty()) {
-				// Nothing was rejected, so we're done
-				return returnedList;
-			}
+			throw new NullPointerException("Input must not be null");
 		}
 
-		throw new IllegalArgumentException(
-				"Heuristic (more than " + MAX_NTRIESPART
-						+ " iterations of partitioning) detected unpartitionable list "
-						+ input.toString()
-						+ "\nThe following elements were not partitioned: "
-						+ rejectedElements.toString()
-						+ "\nCurrent group in formation: "
-						+ currentPartition.unwrap((vl) -> vl.toString())
-						+ "\nPreviously formed groups: "
-						+ returnedList.toString());
+		return collapseTokens(input, "");
 	}
 
 	/**
-	 * Split tokens in a list of tokens into multiple tokens.
-	 * 
-	 * The intended use is for expression parsers so that you can enter
-	 * something like 1+1 instead of 1 + 1.
+	 * Collapse a string of tokens into a single string, adding the desired
+	 * seperator after each token
 	 * 
 	 * @param input
-	 *            The tokens to split
-	 * @param operators
-	 *            Pairs of operators to split on and regexes that match
-	 *            those operators
-	 * @return A list of tokens split on all the operators
-	 * 
+	 *            The list of tokens to collapse
+	 * @param seperator
+	 *            The seperator to use for seperating tokens
+	 * @return The collapsed string of tokens
 	 */
-	public static IFunctionalList<String> splitTokens(
-			IFunctionalList<String> input,
-			Deque<IPair<String, String>> operators) {
+	public static String collapseTokens(IFunctionalList<String> input,
+			String seperator) {
 		if (input == null) {
 			throw new NullPointerException("Input must not be null");
-		} else if (operators == null) {
-			throw new NullPointerException(
-					"Set of operators must not be null");
+		} else if (seperator == null) {
+			throw new NullPointerException("Seperator must not be null");
 		}
 
-		IHolder<IFunctionalList<String>> returnedList = new Identity<>(
-				input);
-
-		operators.forEach((operator) -> {
-			returnedList.transform((oldReturn) -> {
-				return oldReturn.flatMap((token) -> {
-					return operator.merge(new TokenSplitter(token));
-				});
+		if (input.getSize() < 1) {
+			return "";
+		} else if (input.getSize() == 1) {
+			return input.first();
+		} else {
+			return input.reduceAux("", (currentString, state) -> {
+				return state + currentString + seperator;
+			}, (strang) -> {
+				return strang.substring(0,
+						strang.length() - seperator.length());
 			});
-		});
-
-		return returnedList.getValue();
+		}
 	}
 
 	/**
@@ -168,51 +100,42 @@ public class ListUtils {
 	}
 
 	/**
-	 * Collapse a string of tokens into a single string without adding any
-	 * spaces
+	 * Select a number of random items from the list without replacement
 	 * 
-	 * @param input
-	 *            The list of tokens to collapse
-	 * @return The collapsed string of tokens
+	 * @param <E>
+	 *            The type of items to select
+	 * @param list
+	 *            The list to select from
+	 * @param numberOfItems
+	 *            The number of items to selet
+	 * @param rng
+	 *            A function that creates a random number from 0 to the
+	 *            desired number
+	 * @return A new list containing the desired number of items randomly
+	 *         selected from the specified list without replacement
 	 */
-	public static String collapseTokens(IFunctionalList<String> input) {
-		if (input == null) {
-			throw new NullPointerException("Input must not be null");
-		}
 
-		return collapseTokens(input, "");
-	}
+	public static <E> IFunctionalList<E> drawWithoutReplacement(
+			IFunctionalList<E> list, int numberOfItems,
+			Function<Integer, Integer> rng) {
+		IFunctionalList<E> selectedItems = new FunctionalList<>(
+				new ArrayList<>(numberOfItems));
 
-	/**
-	 * Collapse a string of tokens into a single string, adding the desired
-	 * seperator after each token
-	 * 
-	 * @param input
-	 *            The list of tokens to collapse
-	 * @param seperator
-	 *            The seperator to use for seperating tokens
-	 * @return The collapsed string of tokens
-	 */
-	public static String collapseTokens(IFunctionalList<String> input,
-			String seperator) {
-		if (input == null) {
-			throw new NullPointerException("Input must not be null");
-		} else if (seperator == null) {
-			throw new NullPointerException("Seperator must not be null");
-		}
+		int totalItems = list.getSize();
 
-		if (input.getSize() < 1) {
-			return "";
-		} else if (input.getSize() == 1) {
-			return input.first();
-		} else {
-			return input.reduceAux("", (currentString, state) -> {
-				return state + currentString + seperator;
-			}, (strang) -> {
-				return strang.substring(0,
-						strang.length() - seperator.length());
-			});
-		}
+		list.forEachIndexed((index, element) -> {
+			int winningChance = numberOfItems - selectedItems.getSize();
+			// n - m
+			int totalChance = totalItems - (index - 1);
+			// N - t
+
+			// Probability of selecting the t+1'th element
+			if (NumberUtils.isProbable(winningChance, totalChance, rng)) {
+				selectedItems.add(element);
+			}
+		});
+
+		return selectedItems;
 	}
 
 	/**
@@ -244,42 +167,81 @@ public class ListUtils {
 	}
 
 	/**
-	 * Select a number of random items from the list without replacement
+	 * Partition a list into a list of lists, where each element can count
+	 * for more than one element in a partition
 	 * 
 	 * @param <E>
-	 *            The type of items to select
-	 * @param list
-	 *            The list to select from
-	 * @param numberOfItems
-	 *            The number of items to selet
-	 * @param rng
-	 *            A function that creates a random number from 0 to the
-	 *            desired number
-	 * @return A new list containing the desired number of items randomly
-	 *         selected from the specified list without replacement
+	 *            The type of elements in the list to partition
+	 * 
+	 * @param input
+	 *            The list to partition
+	 * @param elementCounter
+	 *            The function to determine the count for each element for
+	 * @param numberPerPartition
+	 *            The number of elements to put in each partition
+	 * @return A list partitioned according to the above rules
 	 */
+	public static <E> IFunctionalList<IFunctionalList<E>> groupPartition(
+			IFunctionalList<E> input, Function<E, Integer> elementCounter,
+			int numberPerPartition) {
+		if (input == null) {
+			throw new NullPointerException("Input list must not be null");
+		} else if (elementCounter == null) {
+			throw new NullPointerException("Counter must not be null");
+		} else if (numberPerPartition < 1
+				|| numberPerPartition > input.getSize()) {
+			throw new IllegalArgumentException(
+					"" + numberPerPartition + " is not a valid"
+							+ " partition size. Must be between 1 and "
+							+ input.getSize());
+		}
 
-	public static <E> IFunctionalList<E> drawWithoutReplacement(
-			IFunctionalList<E> list, int numberOfItems,
-			Function<Integer, Integer> rng) {
-		IFunctionalList<E> selectedItems = new FunctionalList<>(
-				new ArrayList<>(numberOfItems));
+		/*
+		 * List that holds our results
+		 */
+		IFunctionalList<IFunctionalList<E>> returnedList = new FunctionalList<>();
 
-		int totalItems = list.getSize();
+		/*
+		 * List that holds current partition
+		 */
+		IHolder<IFunctionalList<E>> currentPartition = new Identity<>(
+				new FunctionalList<>());
+		/*
+		 * List that holds elements rejected during current pass
+		 */
+		IFunctionalList<E> rejectedElements = new FunctionalList<>();
 
-		list.forEachIndexed((index, element) -> {
-			int winningChance = numberOfItems - selectedItems.getSize();
-			// n - m
-			int totalChance = totalItems - (index - 1);
-			// N - t
+		/*
+		 * The effective number of elements in the current partitition
+		 */
+		IHolder<Integer> numberInCurrentPartition = new Identity<>(0);
 
-			// Probability of selecting the t+1'th element
-			if (NumberUtils.isProbable(winningChance, totalChance, rng)) {
-				selectedItems.add(element);
+		/*
+		 * Run up to a certain number of passes
+		 */
+		for (int numberOfIterations = 0; numberOfIterations < MAX_NTRIESPART
+				&& !rejectedElements.isEmpty(); numberOfIterations++) {
+			input.forEach(new GroupPartIteration<>(returnedList,
+					currentPartition, rejectedElements,
+					numberInCurrentPartition, numberPerPartition,
+					elementCounter));
+
+			if (rejectedElements.isEmpty()) {
+				// Nothing was rejected, so we're done
+				return returnedList;
 			}
-		});
+		}
 
-		return selectedItems;
+		throw new IllegalArgumentException(
+				"Heuristic (more than " + MAX_NTRIESPART
+						+ " iterations of partitioning) detected unpartitionable list "
+						+ input.toString()
+						+ "\nThe following elements were not partitioned: "
+						+ rejectedElements.toString()
+						+ "\nCurrent group in formation: "
+						+ currentPartition.unwrap((vl) -> vl.toString())
+						+ "\nPreviously formed groups: "
+						+ returnedList.toString());
 	}
 
 	/**
@@ -302,4 +264,42 @@ public class ListUtils {
 
 		return returnedList;
 	}
+
+	/**
+	 * Split tokens in a list of tokens into multiple tokens.
+	 * 
+	 * The intended use is for expression parsers so that you can enter
+	 * something like 1+1 instead of 1 + 1.
+	 * 
+	 * @param input
+	 *            The tokens to split
+	 * @param operators
+	 *            Pairs of operators to split on and regexes that match
+	 *            those operators
+	 * @return A list of tokens split on all the operators
+	 * 
+	 */
+	public static IFunctionalList<String> splitTokens(
+			IFunctionalList<String> input,
+			Deque<IPair<String, String>> operators) {
+		if (input == null) {
+			throw new NullPointerException("Input must not be null");
+		} else if (operators == null) {
+			throw new NullPointerException(
+					"Set of operators must not be null");
+		}
+
+		IHolder<IFunctionalList<String>> returnedList = new Identity<>(
+				input);
+
+		operators.forEach((operator) -> {
+			returnedList.transform((oldReturn) -> {
+				return oldReturn.flatMap((token) -> {
+					return operator.merge(new TokenSplitter(token));
+				});
+			});
+		});
+
+		return returnedList.getValue();
+	}
 }
\ No newline at end of file
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 728968e..2f8aa09 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/funcutils/StringUtils.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/funcutils/StringUtils.java
@@ -11,6 +11,27 @@ import java.util.Deque;
 public class StringUtils {
 
 	/**
+	 * Checks if the given expression contains the specified operator in a
+	 * situation that indicates its use as an infix operator.
+	 * 
+	 * @param expression
+	 *            The expression to check
+	 * @param operator
+	 *            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
+		// going to do?
+		return org.apache.commons.lang3.StringUtils
+				.countMatches(expression, operator) == 1
+				&& !expression.equalsIgnoreCase(operator)
+				&& !expression.startsWith(operator);
+	}
+
+	/**
 	 * Check if a string consists only of one or more matches of a regular
 	 * expression
 	 * 
@@ -40,27 +61,6 @@ public class StringUtils {
 	}
 
 	/**
-	 * Checks if the given expression contains the specified operator in a
-	 * situation that indicates its use as an infix operator.
-	 * 
-	 * @param expression
-	 *            The expression to check
-	 * @param operator
-	 *            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
-		// going to do?
-		return org.apache.commons.lang3.StringUtils
-				.countMatches(expression, operator) == 1
-				&& !expression.equalsIgnoreCase(operator)
-				&& !expression.startsWith(operator);
-	}
-
-	/**
 	 * Indent the string being built in a StringBuilder n levels
 	 * 
 	 * @param builder