Add simple toggle values

14 files changed, 372 insertions, 282 deletions

diff --git a/BJC-Utils2/src/examples/java/bjc/utils/examples/DelimSplitterTest.java b/BJC-Utils2/src/examples/java/bjc/utils/examples/DelimSplitterTest.java
index 5f4ef92..8e2a98d 100644
--- a/BJC-Utils2/src/examples/java/bjc/utils/examples/DelimSplitterTest.java
+++ b/BJC-Utils2/src/examples/java/bjc/utils/examples/DelimSplitterTest.java
@@ -1,6 +1,8 @@
 package bjc.utils.examples;
 
 import bjc.utils.data.ITree;
+import bjc.utils.funcdata.FunctionalList;
+import bjc.utils.funcdata.IList;
 import bjc.utils.funcutils.StringUtils;
 import bjc.utils.parserutils.delims.DelimiterException;
 import bjc.utils.parserutils.delims.DelimiterGroup;
@@ -8,7 +10,7 @@ import bjc.utils.parserutils.delims.RegexCloser;
 import bjc.utils.parserutils.delims.RegexOpener;
 import bjc.utils.parserutils.delims.SequenceDelimiter;
 import bjc.utils.parserutils.delims.StringDelimiter;
-import bjc.utils.parserutils.splitter.SimpleTokenSplitter;
+import bjc.utils.parserutils.splitterv2.ConfigurableTokenSplitter;
 
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
@@ -28,7 +30,7 @@ import java.util.Scanner;
  *
  */
 public class DelimSplitterTest {
-	private SimpleTokenSplitter split;
+	private ConfigurableTokenSplitter split;
 
 	private StringDelimiter dlm;
 
@@ -46,7 +48,7 @@ public class DelimSplitterTest {
 
 		groups = new HashMap<>();
 
-		split = new SimpleTokenSplitter();
+		split = new ConfigurableTokenSplitter(true);
 
 		dlm = new StringDelimiter();
 
@@ -141,27 +143,21 @@ public class DelimSplitterTest {
 			}
 			break;
 		case "splitter-add":
-			split.addDelimiter(argArray);
+			split.addSimpleDelimiters(argArray);
 			if(verbose) {
 				System.out.println("Added delimiters " + StringUtils.toEnglishList(argArray, true));
 			}
 			break;
 		case "splitter-addmulti":
-			split.addMultiDelimiter(argArray);
+			split.addMultiDelimiters(argArray);
 			if(verbose) {
 				System.out.println(
 						"Added multi-delimiters " + StringUtils.toEnglishList(argArray, true));
 			}
 			break;
-		case "splitter-addnon":
-			split.addNonMatcher(argArray);
-			if(verbose) {
-				System.out.println("Added non-splitters " + StringUtils.toEnglishList(argArray, true));
-			}
-			break;
 		case "splitter-addmatch":
 			for(String arg : argArray) {
-				split.addDelimiter(arg, mirrored.get(arg));
+				split.addSimpleDelimiters(arg, mirrored.get(arg));
 			}
 			if(verbose) {
 				System.out.println("Added matched delimiters "
@@ -172,7 +168,7 @@ public class DelimSplitterTest {
 			System.out.println(split.toString());
 			break;
 		case "splitter-reset":
-			split = new SimpleTokenSplitter();
+			split = new ConfigurableTokenSplitter(true);
 			if(verbose) {
 				System.out.println("Reset splitter");
 			}
@@ -393,14 +389,14 @@ public class DelimSplitterTest {
 		for(int i = 0; i < argArray.length; i++) {
 			String arg = argArray[i];
 
-			String[] res = split.split(arg);
+			IList<String> strangs = split.split(arg);
 
-			System.out.printf("%d '%s' %s\n", i, arg, Arrays.deepToString(res));
+			System.out.printf("%d '%s' %s\n", i, arg, strangs);
 		}
 	}
 
 	private void handleTest(String inp, boolean splitWS) {
-		String[] strings;
+		IList<String> strings;
 
 		try {
 			strings = split.split(inp);
@@ -409,7 +405,7 @@ public class DelimSplitterTest {
 			return;
 		}
 
-		System.out.println("Split tokens: " + Arrays.deepToString(strings));
+		System.out.println("Split tokens: " + strings);
 
 		if(splitWS) {
 			List<String> tks = new LinkedList<>();
@@ -418,10 +414,10 @@ public class DelimSplitterTest {
 				tks.addAll(Arrays.asList(strang.split(" ")));
 			}
 
-			strings = tks.toArray(new String[0]);
+			strings = new FunctionalList<>(tks);
 		}
 		try {
-			ITree<String> delim = dlm.delimitSequence(strings);
+			ITree<String> delim = dlm.delimitSequence(strings.toArray(new String[0]));
 
 			printDelimSeq(delim);
 		} catch(DelimiterException dex) {
@@ -437,17 +433,6 @@ public class DelimSplitterTest {
 		System.out.println();
 		System.out.println();
 
-		/*
-		 * ITree<String> transform =
-		 * delim.topDownTransform(this::pickNode, this::transformNode);
-		 * System.out.println("Transformed tree:\n" +
-		 * transform.getChild(1)); System.out.println();
-		 * System.out.println();
-		 * 
-		 * System.out.print("Transformed expr: ");
-		 * printDelimTree(transform);
-		 */
-
 		System.out.println();
 	}
 
@@ -498,19 +483,6 @@ public class DelimSplitterTest {
 		}
 	}
 
-	/*
-	 * private TopDownTransformResult pickNode(String node) {
-	 * if(groups.containsKey(node) || node.equals("subgroup")) return
-	 * TopDownTransformResult.PUSHDOWN; else return
-	 * TopDownTransformResult.PASSTHROUGH; }
-	 * 
-	 * private ITree<String> transformNode(ITree<String> tree) {
-	 * if(groups.containsKey(tree.getHead())) {
-	 * 
-	 * }
-	 * 
-	 * return tree; }
-	 */
 	/**
 	 * Main method
 	 * 
diff --git a/BJC-Utils2/src/examples/java/bjc/utils/examples/TreeConstructTest.java b/BJC-Utils2/src/examples/java/bjc/utils/examples/TreeConstructTest.java
deleted file mode 100644
index a8f8134..0000000
--- a/BJC-Utils2/src/examples/java/bjc/utils/examples/TreeConstructTest.java
+++ /dev/null
@@ -1,129 +0,0 @@
-package bjc.utils.examples;
-
-import bjc.utils.data.IPair;
-import bjc.utils.data.ITree;
-import bjc.utils.data.Pair;
-import bjc.utils.data.Tree;
-import bjc.utils.funcdata.FunctionalMap;
-import bjc.utils.funcdata.FunctionalStringTokenizer;
-import bjc.utils.funcdata.IList;
-import bjc.utils.funcdata.IMap;
-import bjc.utils.funcutils.ListUtils;
-import bjc.utils.funcutils.StringUtils;
-import bjc.utils.parserutils.ShuntingYard;
-import bjc.utils.parserutils.TreeConstructor;
-import bjc.utils.parserutils.TreeConstructor.QueueFlattener;
-
-import java.util.Deque;
-import java.util.LinkedList;
-import java.util.Scanner;
-import java.util.function.Predicate;
-
-/**
- * Test of tree constructor
- *
- * @author ben
- *
- */
-public class TreeConstructTest {
-	private static final class OperatorPicker implements Predicate<String> {
-		@Override
-		public boolean test(String token) {
-			if(StringUtils.containsOnly(token, "\\["))      return true;
-			else if(StringUtils.containsOnly(token, "\\]")) return true;
-
-			switch(token) {
-			case "+":
-			case "-":
-			case "*":
-			case "/":
-				return true;
-			default:
-				return false;
-			}
-		}
-	}
-
-	/**
-	 * Main method
-	 *
-	 * @param args
-	 *                Unused CLI args
-	 */
-	@SuppressWarnings({ "resource", "deprecation" })
-	public static void main(String[] args) {
-		Scanner inputSource = new Scanner(System.in);
-
-		System.out.print("Enter a expression to parse: ");
-		String line = inputSource.nextLine();
-
-		IList<String> tokens = new FunctionalStringTokenizer(line).toList();
-
-		ShuntingYard<String> yard = new ShuntingYard<>(true);
-
-		Deque<IPair<String, String>> ops = new LinkedList<>();
-
-		ops.add(new Pair<>("+", "\\+"));
-		ops.add(new Pair<>("-", "-"));
-		ops.add(new Pair<>("*", "\\*"));
-		ops.add(new Pair<>("/", "/"));
-		ops.add(new Pair<>(":=", ":="));
-		ops.add(new Pair<>("=>", "=>"));
-
-		IList<String> semiExpandedTokens = ListUtils.splitTokens(tokens, ops);
-
-		ops = new LinkedList<>();
-		ops.add(new Pair<>("(", "\\("));
-		ops.add(new Pair<>(")", "\\)"));
-		ops.add(new Pair<>("[", "\\["));
-		ops.add(new Pair<>("]", "\\]"));
-
-		IList<String> fullyExpandedTokens = ListUtils.deAffixTokens(semiExpandedTokens, ops);
-		fullyExpandedTokens.removeIf((strang) -> strang.equals(""));
-
-		IList<String> shuntedTokens = yard.postfix(fullyExpandedTokens, (token) -> token);
-
-		System.out.println("Shunted: " + shuntedTokens.toString());
-
-		Predicate<String> specialPicker = (operator) -> {
-			if(StringUtils.containsOnly(operator, "\\["))      return true;
-			else if(StringUtils.containsOnly(operator, "\\]")) return true;
-
-			return false;
-		};
-
-		IMap<String, QueueFlattener<String>> operators
-			= new FunctionalMap<>();
-
-		operators.put("[", (queuedTrees) -> {
-			return null;
-		});
-
-		operators.put("[", (queuedTrees) -> {
-			Tree<String> openTree = new Tree<>("[");
-
-			queuedTrees.push(openTree);
-
-			return openTree;
-		});
-
-		operators.put("]", (queuedTrees) -> {
-			ITree<String> arrayTree = new Tree<>("[]");
-
-			while(!queuedTrees.peek().getHead().equals("[")) {
-				arrayTree.addChild(queuedTrees.pop());
-			}
-
-			queuedTrees.push(arrayTree);
-
-			return arrayTree;
-		});
-
-		ITree<String> constructedTree = TreeConstructor.constructTree(shuntedTokens,
-				new OperatorPicker(), specialPicker, operators::get);
-
-		System.out.println("AST: " + constructedTree.toString());
-
-		inputSource.close();
-	}
-}
diff --git a/BJC-Utils2/src/main/java/bjc/utils/PropertyDB.java b/BJC-Utils2/src/main/java/bjc/utils/PropertyDB.java
index 3f2c078..daaf423 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/PropertyDB.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/PropertyDB.java
@@ -15,11 +15,13 @@ import java.util.regex.Pattern;
  *
  */
 public class PropertyDB {
-	private static SimpleProperties regexes;
-	private static Map<String, Pattern> compiledRegexes;
+	private static SimpleProperties		regexes;
+	private static Map<String, Pattern>	compiledRegexes;
 
 	private static SimpleProperties formats;
 
+	private static final boolean LOGLOAD = false;
+
 	/*
 	 * The lock to use to ensure a read can't happen during a reload
 	 */
@@ -37,20 +39,27 @@ public class PropertyDB {
 	 */
 	public static void reloadProperties() {
 		loadLock.write(() -> {
-			System.out.println("Reading regex properties:");
+			if(LOGLOAD) {
+				System.out.println("Reading regex properties:");
+			}
 			regexes = new SimpleProperties();
 			regexes.loadFrom(PropertyDB.class.getResourceAsStream("/regexes.sprop"), false);
-			System.out.println();
+			if(LOGLOAD) {
+				regexes.outputProperties();
+				System.out.println();
+			}
 
 			compiledRegexes = new HashMap<>();
 
-			System.out.println("Reading format properties:");
+			if(LOGLOAD) {
+				System.out.println("Reading format properties:");
+			}
 			formats = new SimpleProperties();
 			formats.loadFrom(PropertyDB.class.getResourceAsStream("/formats.sprop"), false);
-			System.out.println();
-
-			if (regexes.equals(formats))
-				System.out.println("WAT");
+			if(LOGLOAD) {
+				formats.outputProperties();
+				System.out.println();
+			}
 		});
 	}
 
@@ -58,13 +67,13 @@ public class PropertyDB {
 	 * Retrieve a persisted regular expression.
 	 * 
 	 * @param key
-	 *            The name of the regular expression.
+	 *                The name of the regular expression.
 	 * 
 	 * @return The regular expression with that name.
 	 */
 	public static String getRegex(String key) {
 		return loadLock.read(() -> {
-			if (!regexes.containsKey(key)) {
+			if(!regexes.containsKey(key)) {
 				String msg = String.format("No regular expression named '%s' found", key);
 
 				throw new NoSuchElementException(msg);
@@ -79,13 +88,13 @@ public class PropertyDB {
 	 * expression.
 	 * 
 	 * @param key
-	 *            The name of the regular expression.
+	 *                The name of the regular expression.
 	 * 
 	 * @return The regular expression with that name.
 	 */
 	public static Pattern getCompiledRegex(String key) {
 		return loadLock.read(() -> {
-			if (!regexes.containsKey(key)) {
+			if(!regexes.containsKey(key)) {
 				String msg = String.format("No regular expression named '%s' found", key);
 
 				throw new NoSuchElementException(msg);
@@ -101,13 +110,13 @@ public class PropertyDB {
 	 * Retrieve a persisted format string.
 	 * 
 	 * @param key
-	 *            The name of the format string.
+	 *                The name of the format string.
 	 * 
 	 * @return The format string with that name.
 	 */
 	public static String getFormat(String key) {
 		return loadLock.read(() -> {
-			if (!formats.containsKey(key)) {
+			if(!formats.containsKey(key)) {
 				String msg = String.format("No format string named '%s' found", key);
 
 				throw new NoSuchElementException(msg);
@@ -118,13 +127,14 @@ public class PropertyDB {
 	}
 
 	/**
-	 * Retrieve a persisted format string, and apply it to a set of arguments.
+	 * Retrieve a persisted format string, and apply it to a set of
+	 * arguments.
 	 * 
 	 * @param key
-	 *            The name of the format string.
+	 *                The name of the format string.
 	 * 
 	 * @param objects
-	 *            The parameters to the format string.
+	 *                The parameters to the format string.
 	 * 
 	 * @return The format string with that name.
 	 */
diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/BooleanToggle.java b/BJC-Utils2/src/main/java/bjc/utils/data/BooleanToggle.java
new file mode 100644
index 0000000..68399a0
--- /dev/null
+++ b/BJC-Utils2/src/main/java/bjc/utils/data/BooleanToggle.java
@@ -0,0 +1,76 @@
+package bjc.utils.data;
+
+/**
+ * A simple {@link ValueToggle} that swaps between true and false.
+ * 
+ * @author EVE
+ *
+ */
+public class BooleanToggle implements Toggle<Boolean> {
+	private boolean val;
+
+	/**
+	 * Create a new, initially false, flip-flop.
+	 */
+	public BooleanToggle() {
+		this(false);
+	}
+
+	/**
+	 * Create a flip-flop with the specified initial value.
+	 * 
+	 * @param initial
+	 *                The initial value of the flip-flop.
+	 */
+	public BooleanToggle(boolean initial) {
+		val = initial;
+	}
+
+	@Override
+	public Boolean get() {
+		boolean res = val;
+
+		val = !res;
+
+		return res;
+	}
+
+	@Override
+	public Boolean peek() {
+		return val;
+	}
+
+	@Override
+	public void set(boolean vl) {
+		val = vl;
+	}
+
+	@Override
+	public int hashCode() {
+		final int prime = 31;
+
+		int result = 1;
+
+		result = prime * result + (val ? 1231 : 1237);
+
+		return result;
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if(this == obj) return true;
+		if(obj == null) return false;
+		if(!(obj instanceof BooleanToggle)) return false;
+
+		BooleanToggle other = (BooleanToggle) obj;
+
+		if(val != other.val) return false;
+
+		return true;
+	}
+
+	@Override
+	public String toString() {
+		return String.format("BooleanToggle [val=%s]", val);
+	}
+}
\ No newline at end of file
diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/Toggle.java b/BJC-Utils2/src/main/java/bjc/utils/data/Toggle.java
new file mode 100644
index 0000000..8ebc4d8
--- /dev/null
+++ b/BJC-Utils2/src/main/java/bjc/utils/data/Toggle.java
@@ -0,0 +1,35 @@
+package bjc.utils.data;
+
+/**
+ * A stateful holder that swaps between two values of the same type.
+ * 
+ * @author EVE
+ *
+ * @param <E>
+ *                The value stored in the toggle.
+ */
+public interface Toggle<E> {
+	/**
+	 * Retrieve the currently-aligned value of this toggle, and swap the
+	 * alignment.
+	 * 
+	 * @return The previously-aligned value.
+	 */
+	E get();
+
+	/**
+	 * Retrieve the currently-aligned value without altering the alignment.
+	 * 
+	 * @return The currently-aligned value.
+	 */
+	E peek();
+
+	/**
+	 * Change the alignment of the toggle.
+	 * 
+	 * @param isLeft
+	 *                Whether the toggle should be left-aligned or not.
+	 */
+	void set(boolean isLeft);
+
+}
\ No newline at end of file
diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/ValueToggle.java b/BJC-Utils2/src/main/java/bjc/utils/data/ValueToggle.java
new file mode 100644
index 0000000..5b5cb83
--- /dev/null
+++ b/BJC-Utils2/src/main/java/bjc/utils/data/ValueToggle.java
@@ -0,0 +1,58 @@
+package bjc.utils.data;
+
+/**
+ * A simple implementation of {@link Toggle}.
+ * 
+ * @author EVE
+ * 
+ * @param <E>
+ *                The type of value to toggle between.
+ */
+public class ValueToggle<E> implements Toggle<E> {
+	private final E	lft;
+	private final E	rght;
+
+	private BooleanToggle alignment;
+
+	/**
+	 * Create a new toggle.
+	 * 
+	 * All toggles start right-aligned.
+	 * 
+	 * @param left
+	 *                The value when the toggle is left-aligned.
+	 * 
+	 * @param right
+	 *                The value when the toggle is right-aligned.
+	 */
+	public ValueToggle(E left, E right) {
+		lft = left;
+
+		rght = right;
+
+		alignment = new BooleanToggle();
+	}
+
+	@Override
+	public E get() {
+		if(alignment.get()) {
+			return lft;
+		} else {
+			return rght;
+		}
+	}
+
+	@Override
+	public E peek() {
+		if(alignment.peek()) {
+			return lft;
+		} else {
+			return rght;
+		}
+	}
+
+	@Override
+	public void set(boolean isLeft) {
+		alignment.set(isLeft);
+	}
+}
diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcdata/IList.java b/BJC-Utils2/src/main/java/bjc/utils/funcdata/IList.java
index cf60ed6..d92d564 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/funcdata/IList.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/funcdata/IList.java
@@ -42,6 +42,28 @@ public interface IList<ContainedType> extends Iterable<ContainedType> {
 	}
 
 	/**
+	 * Add all of the elements in the provided array to this list.
+	 *
+	 * @param items
+	 *                The array of items to add.
+	 * 
+	 * @return True if every item was successfully added to the list, false
+	 *         otherwise.
+	 */
+	@SuppressWarnings("unchecked")
+	default boolean addAll(ContainedType... items) {
+		boolean succ = true;
+
+		for(ContainedType item : items) {
+			boolean addSucc = add(item);
+
+			succ = succ ? addSucc : false;
+		}
+
+		return succ;
+	}
+
+	/**
 	 * Check if all of the elements of this list match the specified
 	 * predicate.
 	 *
@@ -238,6 +260,19 @@ public interface IList<ContainedType> extends Iterable<ContainedType> {
 	void prepend(ContainedType item);
 
 	/**
+	 * Prepend an array of items to the list.
+	 *
+	 * @param items
+	 *                The items to prepend to the list.
+	 */
+	@SuppressWarnings("unchecked")
+	default void prependAll(ContainedType... items) {
+		for(ContainedType item : items) {
+			prepend(item);
+		}
+	}
+
+	/**
 	 * Select a random item from the list, using a default random number
 	 * generator
 	 *
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 27666dd..ad0f565 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/funcutils/ListUtils.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/funcutils/ListUtils.java
@@ -1,11 +1,9 @@
 package bjc.utils.funcutils;
 
-import bjc.utils.data.IPair;
 import bjc.utils.funcdata.FunctionalList;
 import bjc.utils.funcdata.IList;
 
 import java.util.ArrayList;
-import java.util.Deque;
 import java.util.Iterator;
 import java.util.function.Function;
 import java.util.function.Supplier;
@@ -29,40 +27,38 @@ public class ListUtils {
 	 * @return The collapsed string of tokens
 	 */
 	public static String collapseTokens(IList<String> input) {
-		if (input == null)
-			throw new NullPointerException("Input must not be null");
+		if(input == null) throw new NullPointerException("Input must not be null");
 
 		return collapseTokens(input, "");
 	}
 
 	/**
 	 * Collapse a string of tokens into a single string, adding the desired
-	 * seperator after each token
+	 * separator after each token
 	 *
 	 * @param input
 	 *                The list of tokens to collapse
 	 * @param seperator
-	 *                The seperator to use for seperating tokens
+	 *                The separator to use for separating tokens
 	 * @return The collapsed string of tokens
 	 */
 	public static String collapseTokens(IList<String> input, 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 {
 			StringBuilder state = new StringBuilder();
 
 			int i = 1;
-			for (String itm : input.toIterable()) {
+			for(String itm : input.toIterable()) {
 				state.append(itm);
 
-				if (i != input.getSize()) {
+				if(i != input.getSize()) {
 					state.append(seperator);
 				}
 
@@ -74,22 +70,6 @@ public class ListUtils {
 	}
 
 	/**
-	 * Split off affixes from tokens
-	 *
-	 * @param input
-	 *                The tokens to deaffix
-	 * @param operators
-	 *                The affixes to remove
-	 * @return The tokens that have been deaffixed
-	 *
-	 * @deprecated Replaced by SimpleTokenSplitter.
-	 */
-	@Deprecated
-	public static IList<String> deAffixTokens(IList<String> input, Deque<IPair<String, String>> operators) {
-		return null;
-	}
-
-	/**
 	 * Select a number of random items from the list without replacement
 	 *
 	 * @param <E>
@@ -113,7 +93,7 @@ public class ListUtils {
 		Iterator<E> itr = list.toIterable().iterator();
 		E element = null;
 
-		for (int index = 0; itr.hasNext(); element = itr.next()) {
+		for(int index = 0; itr.hasNext(); element = itr.next()) {
 			// n - m
 			int winningChance = number - selected.getSize();
 
@@ -121,7 +101,7 @@ public class ListUtils {
 			int totalChance = total - (index - 1);
 
 			// Probability of selecting the t+1'th element
-			if (NumberUtils.isProbable(winningChance, totalChance, rng)) {
+			if(NumberUtils.isProbable(winningChance, totalChance, rng)) {
 				selected.add(element);
 			}
 		}
@@ -147,7 +127,7 @@ public class ListUtils {
 	public static <E> IList<E> drawWithReplacement(IList<E> list, int number, Function<Integer, Integer> rng) {
 		IList<E> selected = new FunctionalList<>(new ArrayList<>(number));
 
-		for (int i = 0; i < number; i++) {
+		for(int i = 0; i < number; i++) {
 			selected.add(list.randItem(rng));
 		}
 
@@ -173,11 +153,11 @@ public class ListUtils {
 	 */
 	public static <E> IList<IList<E>> groupPartition(IList<E> input, Function<E, Integer> counter,
 			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()) {
 			String fmt = "%d is not a valid partition size. Must be between 1 and %d";
 			String msg = String.format(fmt, partitionSize, input.getSize());
 
@@ -199,13 +179,13 @@ public class ListUtils {
 		/*
 		 * Run up to a certain number of passes
 		 */
-		for (int numberOfIterations = 0; numberOfIterations < MAX_NTRIESPART
+		for(int numberOfIterations = 0; numberOfIterations < MAX_NTRIESPART
 				&& !rejected.isEmpty(); numberOfIterations++) {
 			input.forEach(it);
 
-			if (rejected.isEmpty()) // Nothing was rejected, so
-						// we're
-						// done
+			if(rejected.isEmpty()) // Nothing was rejected, so
+				// we're
+				// done
 				return returned;
 		}
 
@@ -229,8 +209,8 @@ public class ListUtils {
 	public static <E> IList<E> mergeLists(IList<E>... lists) {
 		IList<E> returned = new FunctionalList<>();
 
-		for (IList<E> list : lists) {
-			for (E itm : list.toIterable()) {
+		for(IList<E> list : lists) {
+			for(E itm : list.toIterable()) {
 				returned.add(itm);
 			}
 		}
@@ -260,22 +240,22 @@ public class ListUtils {
 
 		IList<E> returned = new FunctionalList<>();
 
-		for (E itm : list.toIterable()) {
+		for(E itm : list.toIterable()) {
 			count += counter.apply(itm);
 
 			returned.add(itm);
 		}
 
-		if (count % size != 0) {
+		if(count % size != 0) {
 			// We need to pad
 			int needed = count % size;
 			int threshold = 0;
 
-			while (needed > 0 && threshold <= MAX_NTRIESPART) {
+			while(needed > 0 && threshold <= MAX_NTRIESPART) {
 				E val = padder.get();
 				int newCount = counter.apply(val);
 
-				if (newCount <= needed) {
+				if(newCount <= needed) {
 					returned.add(val);
 
 					threshold = 0;
@@ -286,31 +266,11 @@ public class ListUtils {
 				}
 			}
 
-			if (threshold > MAX_NTRIESPART)
+			if(threshold > MAX_NTRIESPART)
 				throw new IllegalArgumentException("Heuristic (more than " + MAX_NTRIESPART
 						+ " iterations of attempting to pad) detected unpaddable list ");
 		}
 
 		return returned;
 	}
-
-	/**
-	 * 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
-	 *
-	 * @deprecated Use SimpleTokenSplitter now
-	 */
-	@Deprecated
-	public static IList<String> splitTokens(IList<String> input, Deque<IPair<String, String>> operators) {
-		return null;
-	}
 }
diff --git a/BJC-Utils2/src/main/java/bjc/utils/ioutils/RegexStringEditor.java b/BJC-Utils2/src/main/java/bjc/utils/ioutils/RegexStringEditor.java
index 2825346..4f66a99 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/ioutils/RegexStringEditor.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/ioutils/RegexStringEditor.java
@@ -1,7 +1,12 @@
 package bjc.utils.ioutils;
 
+import bjc.utils.data.Toggle;
+import bjc.utils.data.ValueToggle;
+import bjc.utils.funcdata.FunctionalList;
+import bjc.utils.funcdata.IList;
 import bjc.utils.functypes.ID;
 
+import java.util.function.BiFunction;
 import java.util.function.UnaryOperator;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
@@ -13,6 +18,8 @@ import java.util.regex.Pattern;
  *
  */
 public class RegexStringEditor {
+	private static final UnaryOperator<String> SID = ID.id();
+
 	/**
 	 * Replace every occurrence of the pattern with the result of applying
 	 * the action to the string matched by the pattern.
@@ -29,7 +36,7 @@ public class RegexStringEditor {
 	 * @return The string, with matches replaced with the action.
 	 */
 	public static String onOccurances(String input, Pattern patt, UnaryOperator<String> action) {
-		return occurances(input, patt, ID.id(), action);
+		return reduceOccurances(input, patt, SID, action);
 	}
 
 	/**
@@ -49,7 +56,7 @@ public class RegexStringEditor {
 	 *         the action.
 	 */
 	public static String betweenOccurances(String input, Pattern patt, UnaryOperator<String> action) {
-		return occurances(input, patt, action, ID.id());
+		return reduceOccurances(input, patt, action, SID);
 	}
 
 	/**
@@ -58,7 +65,7 @@ public class RegexStringEditor {
 	 * @param input
 	 *                The input string.
 	 * 
-	 * @param patt
+	 * @param rPatt
 	 *                The pattern to match against the string.
 	 * 
 	 * @param betweenAction
@@ -69,11 +76,59 @@ public class RegexStringEditor {
 	 * 
 	 * @return The string, with both actions applied.
 	 */
-	public static String occurances(String input, Pattern patt, UnaryOperator<String> betweenAction,
+	public static String reduceOccurances(String input, Pattern rPatt, UnaryOperator<String> betweenAction,
 			UnaryOperator<String> onAction) {
-		Matcher matcher = patt.matcher(input);
+		IList<String> occurances = listOccurances(input, rPatt);
+
+		Toggle<UnaryOperator<String>> actions = new ValueToggle<>(onAction, betweenAction);
+		BiFunction<String, StringBuilder, StringBuilder> reducer = (strang, state) -> {
+			return state.append(actions.get().apply(strang));
+		};
+
+		return occurances.reduceAux(new StringBuilder(), reducer, StringBuilder::toString);
+	}
+
+	/**
+	 * Execute actions between and on matches of a regular expression.
+	 * 
+	 * @param input
+	 *                The input string.
+	 * 
+	 * @param rPatt
+	 *                The pattern to match against the string.
+	 * 
+	 * @param betweenAction
+	 *                The function to execute between matches of the string.
+	 * 
+	 * @param onAction
+	 *                The function to execute on matches of the string.
+	 * 
+	 * @return The string, with both actions applied.
+	 */
+	public static IList<String> mapOccurances(String input, Pattern rPatt, UnaryOperator<String> betweenAction,
+			UnaryOperator<String> onAction) {
+		IList<String> occurances = listOccurances(input, rPatt);
+		Toggle<UnaryOperator<String>> actions = new ValueToggle<>(onAction, betweenAction);
+
+		return occurances.map(strang -> actions.get().apply(strang));
+	}
+
+	/**
+	 * Separate a string into match/non-match segments.
+	 * 
+	 * @param input
+	 *                The string to separate.
+	 * 
+	 * @param rPatt
+	 *                The pattern to use for separation.
+	 * 
+	 * @return The string, as a list of match/non-match segments,
+	 *         starting/ending with a non-match segment.
+	 */
+	public static IList<String> listOccurances(String input, Pattern rPatt) {
+		IList<String> res = new FunctionalList<>();
 
-		StringBuffer res = new StringBuffer();
+		Matcher matcher = rPatt.matcher(input);
 
 		StringBuffer work = new StringBuffer();
 
@@ -82,17 +137,17 @@ public class RegexStringEditor {
 
 			matcher.appendReplacement(work, "");
 
-			res.append(betweenAction.apply(matcher.toString()));
-			res.append(onAction.apply(match));
+			res.add(work.toString());
+			res.add(match);
 
 			work = new StringBuffer();
 		}
 
 		matcher.appendTail(work);
 
-		res.append(betweenAction.apply(work.toString()));
+		res.add(work.toString());
 
-		return res.toString();
+		return res;
 	}
 
 	/**
diff --git a/BJC-Utils2/src/main/java/bjc/utils/ioutils/SimpleProperties.java b/BJC-Utils2/src/main/java/bjc/utils/ioutils/SimpleProperties.java
index a43b16a..531e8b8 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/ioutils/SimpleProperties.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/ioutils/SimpleProperties.java
@@ -32,27 +32,25 @@ public class SimpleProperties implements Map<String, String> {
 	 * All leading/trailing spaces from the name & body are removed.
 	 * 
 	 * @param is
-	 *            The stream to read from.
+	 *                The stream to read from.
 	 * 
 	 * @param allowDuplicates
-	 *            Whether or not duplicate keys should be allowed.
+	 *                Whether or not duplicate keys should be allowed.
 	 */
 	public void loadFrom(InputStream is, boolean allowDuplicates) {
-		try (Scanner scn = new Scanner(is)) {
-			while (scn.hasNextLine()) {
+		try(Scanner scn = new Scanner(is)) {
+			while(scn.hasNextLine()) {
 				String ln = scn.nextLine().trim();
 
 				/*
 				 * Skip blank lines/comments
 				 */
-				if (ln.equals(""))
-					continue;
-				if (ln.startsWith("#"))
-					continue;
+				if(ln.equals("")) continue;
+				if(ln.startsWith("#")) continue;
 
 				int sepIdx = ln.indexOf(' ');
 
-				if (sepIdx == -1) {
+				if(sepIdx == -1) {
 					String fmt = "Properties must be a name, a space, then the body.\n\tOffending line is '%s'";
 					String msg = String.format(fmt, ln);
 
@@ -62,7 +60,7 @@ public class SimpleProperties implements Map<String, String> {
 				String name = ln.substring(0, sepIdx).trim();
 				String body = ln.substring(sepIdx).trim();
 
-				if (!allowDuplicates && containsKey(name)) {
+				if(!allowDuplicates && containsKey(name)) {
 					String msg = String.format("Duplicate key '%s'", name);
 
 					throw new IllegalStateException(msg);
@@ -71,13 +69,19 @@ public class SimpleProperties implements Map<String, String> {
 				put(name, body);
 			}
 		}
+	}
 
+	/**
+	 * Output the set of read properties.
+	 */
+	public void outputProperties() {
 		System.out.println("Read properties:");
-		for (Entry<String, String> entry : entrySet()) {
+
+		for(Entry<String, String> entry : entrySet()) {
 			System.out.printf("\t'%s'\t'%s'\n", entry.getKey(), entry.getValue());
 		}
-		System.out.println();
 
+		System.out.println();
 	}
 
 	@Override
diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/TokenUtils.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/TokenUtils.java
index 1d31522..39e0c4e 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/TokenUtils.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/parserutils/TokenUtils.java
@@ -1,5 +1,9 @@
 package bjc.utils.parserutils;
 
+import bjc.utils.funcdata.FunctionalList;
+import bjc.utils.funcdata.IList;
+import bjc.utils.parserutils.splitterv2.TokenSplitter;
+
 import java.util.LinkedList;
 import java.util.List;
 import java.util.regex.Matcher;
@@ -17,6 +21,17 @@ import static bjc.utils.PropertyDB.applyFormat;
  *         TODO add support for user defined escapes.
  */
 public class TokenUtils {
+	/**
+	 * @author EVE
+	 *
+	 */
+	public static class StringTokenSplitter implements TokenSplitter {
+		@Override
+		public IList<String> split(String input) {
+			return new FunctionalList<>(TokenUtils.removeDQuotedStrings(input));
+		}
+	}
+
 	/*
 	 * Patterns and pattern parts.
 	 */
diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/splitter/SimpleTokenSplitter.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/splitter/SimpleTokenSplitter.java
index 170c619..ccc823d 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/splitter/SimpleTokenSplitter.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/parserutils/splitter/SimpleTokenSplitter.java
@@ -1,7 +1,5 @@
 package bjc.utils.parserutils.splitter;
 
-import bjc.utils.ioutils.RegexStringEditor;
-
 import java.util.HashSet;
 import java.util.Set;
 import java.util.regex.Pattern;
@@ -10,9 +8,8 @@ import java.util.regex.Pattern;
  * Simple implementation of {@link TokenSplitter}
  * 
  * @author EVE
- *
- *         TODO rewrite using {@link RegexStringEditor}
  */
+@Deprecated
 public class SimpleTokenSplitter implements TokenSplitter {
 	/*
 	 * This string is a format template for the delimiter matching regex
diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/splitter/TokenSplitter.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/splitter/TokenSplitter.java
index e59d88e..04551a7 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/splitter/TokenSplitter.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/parserutils/splitter/TokenSplitter.java
@@ -5,6 +5,7 @@ package bjc.utils.parserutils.splitter;
  *
  * @author Ben Culkin
  */
+@Deprecated
 public interface TokenSplitter {
 	/**
 	 * Split a provided string using configured delimiters, and keeping the
diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/splitter/TwoLevelSplitter.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/splitter/TwoLevelSplitter.java
index d65b06a..1d6d0a2 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/splitter/TwoLevelSplitter.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/parserutils/splitter/TwoLevelSplitter.java
@@ -18,6 +18,7 @@ import java.util.regex.Pattern;
  * @author EVE
  *
  */
+@Deprecated
 public class TwoLevelSplitter implements TokenSplitter {
 	private SimpleTokenSplitter	high;
 	private SimpleTokenSplitter	low;