Cleanup more

1 files changed, 89 insertions, 77 deletions

diff --git a/base/src/main/java/bjc/utils/funcutils/ListUtils.java b/base/src/main/java/bjc/utils/funcutils/ListUtils.java
index c0daa1e..2441a80 100644
--- a/base/src/main/java/bjc/utils/funcutils/ListUtils.java
+++ b/base/src/main/java/bjc/utils/funcutils/ListUtils.java
@@ -10,21 +10,23 @@ import bjc.utils.funcdata.IList;
 
 /**
  * Utilities for manipulating FunctionalLists that don't belong in the class
- * itself
+ * itself.
  *
  * @author ben
- *
  */
 public class ListUtils {
+	/* The max amount of times to try to partition things. */
 	private static final int MAX_NTRIESPART = 50;
 
 	/**
 	 * Collapse a string of tokens into a single string without adding any
-	 * spaces
+	 * spaces.
 	 *
 	 * @param input
-	 *                The list of tokens to collapse
-	 * @return The collapsed string of tokens
+	 * 	The list of tokens to collapse.
+	 *
+	 * @return
+	 * 	The collapsed string of tokens.
 	 */
 	public static String collapseTokens(final IList<String> input) {
 		if (input == null) throw new NullPointerException("Input must not be null");
@@ -34,24 +36,29 @@ public class ListUtils {
 
 	/**
 	 * Collapse a string of tokens into a single string, adding the desired
-	 * separator after each token
+	 * separator after each token.
 	 *
 	 * @param input
-	 *                The list of tokens to collapse
+	 * 	The list of tokens to collapse.
+	 *
 	 * @param seperator
-	 *                The separator to use for separating tokens
-	 * @return The collapsed string of tokens
+	 * 	The separator to use for separating tokens.
+	 *
+	 * @return
+	 * 	The collapsed string of tokens.
 	 */
 	public static String collapseTokens(final IList<String> input, final String seperator) {
-		if (input == null)
+		if (input == null) {
 			throw new NullPointerException("Input must not be null");
-		else if (seperator == null) throw new NullPointerException("Seperator must not be null");
+		} else if (seperator == null) {
+			throw new NullPointerException("Seperator must not be null");
+		}
 
-		if (input.getSize() < 1)
+		if (input.getSize() < 1)  {
 			return "";
-		else if (input.getSize() == 1)
+		} else if (input.getSize() == 1) {
 			return input.first();
-		else {
+		} else {
 			final StringBuilder state = new StringBuilder();
 
 			int i = 1;
@@ -70,21 +77,25 @@ public class ListUtils {
 	}
 
 	/**
-	 * Select a number of random items from the list without replacement
+	 * Select a number of random items from the list without replacement.
 	 *
 	 * @param <E>
-	 *                The type of items to select
+	 * 	The type of items to select.
+	 *
 	 * @param list
-	 *                The list to select from
+	 * 	The list to select from.
+	 *
 	 * @param number
-	 *                The number of items to selet
+	 * 	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
+	 * 	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 <E> IList<E> drawWithoutReplacement(final IList<E> list, final int number,
 			final Function<Integer, Integer> rng) {
 		final IList<E> selected = new FunctionalList<>(new ArrayList<>(number));
@@ -95,19 +106,13 @@ public class ListUtils {
 		E element = null;
 
 		for (final int index = 0; itr.hasNext(); element = itr.next()) {
-			/*
-			 * n - m
-			 */
+			/* n - m */
 			final int winningChance = number - selected.getSize();
 
-			/*
-			 * N - t
-			 */
+			/* N - t */
 			final int totalChance = total - (index - 1);
 
-			/*
-			 * Probability of selecting the t+1'th element
-			 */
+			/* Probability of selecting the t+1'th element */
 			if (NumberUtils.isProbable(winningChance, totalChance, rng)) {
 				selected.add(element);
 			}
@@ -117,19 +122,24 @@ public class ListUtils {
 	}
 
 	/**
-	 * Select a number of random items from the list, with replacement
+	 * Select a number of random items from the list, with replacement.
 	 *
 	 * @param <E>
-	 *                The type of items to select
+	 * 	The type of items to select.
+	 *
 	 * @param list
-	 *                The list to select from
+	 * 	The list to select from.
+	 *
 	 * @param number
-	 *                The number of items to selet
+	 * 	The number of items to select.
+	 *
 	 * @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
+	 * 	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.
 	 */
 	public static <E> IList<E> drawWithReplacement(final IList<E> list, final int number,
 			final Function<Integer, Integer> rng) {
@@ -144,57 +154,51 @@ public class ListUtils {
 
 	/**
 	 * Partition a list into a list of lists, where each element can count
-	 * for more than one element in a partition
+	 * for more than one element in a partition.
 	 *
 	 * @param <E>
-	 *                The type of elements in the list to partition
+	 * 	The type of elements in the list to partition.
 	 *
 	 * @param input
-	 *                The list to partition
+	 * 	The list to partition.
+	 *
 	 * @param counter
-	 *                The function to determine the count for each element
-	 *                for
+	 * 	The function to determine the count for each element for.
+	 *
 	 * @param partitionSize
-	 *                The number of elements to put in each partition
+	 * 	The number of elements to put in each partition.
 	 *
-	 * @return A list partitioned according to the above rules
+	 * @return
+	 * 	A list partitioned according to the above rules.
 	 */
 	public static <E> IList<IList<E>> groupPartition(final IList<E> input, final Function<E, Integer> counter,
 			final int partitionSize) {
-		if (input == null)
+		if (input == null) {
 			throw new NullPointerException("Input list must not be null");
-		else if (counter == null)
+		} else if (counter == null)  {
 			throw new NullPointerException("Counter must not be null");
-		else if (partitionSize < 1 || partitionSize > input.getSize()) {
+		} else if (partitionSize < 1 || partitionSize > input.getSize()) {
 			final String fmt = "%d is not a valid partition size. Must be between 1 and %d";
 			final String msg = String.format(fmt, partitionSize, input.getSize());
 
 			throw new IllegalArgumentException(msg);
 		}
 
-		/*
-		 * List that holds our results
-		 */
+		/* List that holds our results. */
 		final IList<IList<E>> returned = new FunctionalList<>();
 
-		/*
-		 * List that holds elements rejected during current pass
-		 */
+		/* List that holds elements rejected during current pass. */
 		final IList<E> rejected = new FunctionalList<>();
 
 		final GroupPartIteration<E> it = new GroupPartIteration<>(returned, rejected, partitionSize, counter);
 
-		/*
-		 * Run up to a certain number of passes
-		 */
+		/* Run up to a certain number of passes. */
 		for (int numberOfIterations = 0; numberOfIterations < MAX_NTRIESPART
 				&& !rejected.isEmpty(); numberOfIterations++) {
 			input.forEach(it);
 
 			if (rejected.isEmpty()) {
-				/*
-				 * Nothing was rejected, so we're done
-				 */
+				/* Nothing was rejected, so we're done. */
 				return returned;
 			}
 		}
@@ -208,13 +212,16 @@ public class ListUtils {
 	}
 
 	/**
-	 * Merge the contents of a bunch of lists together into a single list
+	 * Merge the contents of a bunch of lists together into a single list.
 	 *
 	 * @param <E>
-	 *                The type of value in this lists
+	 * 	The type of value in this lists.
+	 *
 	 * @param lists
-	 *                The values in the lists to merge
-	 * @return A list containing all the elements of the lists
+	 * 	The values in the lists to merge.
+	 *
+	 * @return
+	 * 	A list containing all the elements of the lists.
 	 */
 	@SafeVarargs
 	public static <E> IList<E> mergeLists(final IList<E>... lists) {
@@ -230,21 +237,28 @@ public class ListUtils {
 	}
 
 	/**
-	 * Pad the provided list out to the desired size
+	 * Pad the provided list out to the desired size.
 	 *
 	 * @param <E>
-	 *                The type of elements in the list
+	 * 	The type of elements in the list.
+	 *
 	 * @param list
-	 *                The list to pad out
+	 * 	The list to pad out.
+	 *
 	 * @param counter
-	 *                The function to count elements with
+	 * 	The function to count elements with.
+	 *
 	 * @param size
-	 *                The desired size of the list
+	 *	The desired size of the list.
+	 *
 	 * @param padder
-	 *                The function to get elements to pad with
-	 * @return The list, padded to the desired size
+	 * 	The function to get elements to pad with.
+	 *
+	 * @return
+	 * 	The list, padded to the desired size.
+	 *
 	 * @throws IllegalArgumentException
-	 *                 if the list couldn't be padded to the desired size
+	 * 	If the list couldn't be padded to the desired size.
 	 */
 	public static <E> IList<E> padList(final IList<E> list, final Function<E, Integer> counter, final int size,
 			final Supplier<E> padder) {
@@ -259,9 +273,7 @@ public class ListUtils {
 		}
 
 		if (count % size != 0) {
-			/*
-			 * We need to pad
-			 */
+			/* We need to pad */
 			int needed = count % size;
 			int threshold = 0;