Cleanup

7 files changed, 260 insertions, 272 deletions

diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/delims/DelimiterException.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/delims/DelimiterException.java
index 3aba434..071afb4 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/delims/DelimiterException.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/parserutils/delims/DelimiterException.java
@@ -5,12 +5,17 @@ package bjc.utils.parserutils.delims;
  */
 public class DelimiterException extends RuntimeException {
 	/**
+	 *
+	 */
+	private static final long serialVersionUID = 2079514406049040888L;
+
+	/**
 	 * Create a new generic delimiter exception.
-	 * 
+	 *
 	 * @param res
 	 *                The reason for this exception.
 	 */
-	public DelimiterException(String res) {
+	public DelimiterException(final String res) {
 		super(res);
 	}
 }
\ No newline at end of file
diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/delims/DelimiterGroup.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/delims/DelimiterGroup.java
index db6ae8c..85d4038 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/delims/DelimiterGroup.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/parserutils/delims/DelimiterGroup.java
@@ -1,12 +1,5 @@
 package bjc.utils.parserutils.delims;
 
-import bjc.utils.data.IPair;
-import bjc.utils.data.ITree;
-import bjc.utils.data.Pair;
-import bjc.utils.data.Tree;
-import bjc.utils.funcdata.FunctionalList;
-import bjc.utils.funcdata.IList;
-
 import java.util.Arrays;
 import java.util.Deque;
 import java.util.HashMap;
@@ -18,9 +11,16 @@ import java.util.Set;
 import java.util.function.BiPredicate;
 import java.util.function.Function;
 
+import bjc.utils.data.IPair;
+import bjc.utils.data.ITree;
+import bjc.utils.data.Pair;
+import bjc.utils.data.Tree;
+import bjc.utils.funcdata.FunctionalList;
+import bjc.utils.funcdata.IList;
+
 /**
  * Represents a possible delimiter group to match.
- * 
+ *
  * @author EVE
  *
  * @param <T>
@@ -29,29 +29,29 @@ import java.util.function.Function;
 public class DelimiterGroup<T> {
 	/**
 	 * Represents an instance of a delimiter group.
-	 * 
+	 *
 	 * @author EVE
 	 *
 	 */
 	public class OpenGroup {
-		private Deque<ITree<T>> contents;
+		private final Deque<ITree<T>> contents;
 
 		private IList<ITree<T>> currentGroup;
 
-		private T opener;
+		private final T opener;
 
-		private T[] params;
+		private final T[] params;
 
 		/**
 		 * Create a new instance of a delimiter group.
-		 * 
+		 *
 		 * @param open
 		 *                The item that opened this group.
-		 * 
+		 *
 		 * @param parms
 		 *                Any parameters from the opener.
 		 */
-		public OpenGroup(T open, T[] parms) {
+		public OpenGroup(final T open, final T[] parms) {
 			opener = open;
 			params = parms;
 
@@ -62,36 +62,36 @@ public class DelimiterGroup<T> {
 
 		/**
 		 * Add an item to this group instance.
-		 * 
+		 *
 		 * @param itm
 		 *                The item to add to this group instance.
 		 */
-		public void addItem(ITree<T> itm) {
+		public void addItem(final ITree<T> itm) {
 			currentGroup.add(itm);
 		}
 
 		/**
 		 * Mark a subgroup.
-		 * 
+		 *
 		 * @param marker
 		 *                The item that indicated this subgroup.
-		 * 
+		 *
 		 * @param chars
 		 *                The characteristics for building the tree.
 		 */
-		public void markSubgroup(T marker, SequenceCharacteristics<T> chars) {
-			ITree<T> subgroupContents = new Tree<>(chars.contents);
-			for(ITree<T> itm : currentGroup) {
+		public void markSubgroup(final T marker, final SequenceCharacteristics<T> chars) {
+			final ITree<T> subgroupContents = new Tree<>(chars.contents);
+			for (final ITree<T> itm : currentGroup) {
 				subgroupContents.addChild(itm);
 			}
 
-			while(!contents.isEmpty()) {
-				ITree<T> possibleSubordinate = contents.peek();
+			while (!contents.isEmpty()) {
+				final ITree<T> possibleSubordinate = contents.peek();
 
-				if(possibleSubordinate.getHead().equals(chars.subgroup)) {
-					T otherMarker = possibleSubordinate.getChild(1).getHead();
+				if (possibleSubordinate.getHead().equals(chars.subgroup)) {
+					final T otherMarker = possibleSubordinate.getChild(1).getHead();
 
-					if(subgroups.get(marker) > subgroups.get(otherMarker)) {
+					if (subgroups.get(marker) > subgroups.get(otherMarker)) {
 						subgroupContents.prependChild(contents.pop());
 					} else {
 						break;
@@ -101,7 +101,7 @@ public class DelimiterGroup<T> {
 				}
 			}
 
-			Tree<T> subgroup = new Tree<>(chars.subgroup, subgroupContents, new Tree<>(marker));
+			final Tree<T> subgroup = new Tree<>(chars.subgroup, subgroupContents, new Tree<>(marker));
 
 			//System.out.println("\tTRACE: generated subgroup\n" + subgroup + "\n\n");
 			contents.push(subgroup);
@@ -111,26 +111,26 @@ public class DelimiterGroup<T> {
 
 		/**
 		 * Convert this group into a tree.
-		 * 
+		 *
 		 * @param closer
 		 *                The item that closed this group.
-		 * 
+		 *
 		 * @param chars
 		 *                The characteristics for building the tree.
-		 * 
+		 *
 		 * @return This group as a tree.
 		 */
-		public ITree<T> toTree(T closer, SequenceCharacteristics<T> chars) {
-			if(impliedSubgroups.containsKey(closer)) {
+		public ITree<T> toTree(final T closer, final SequenceCharacteristics<T> chars) {
+			if (impliedSubgroups.containsKey(closer)) {
 				markSubgroup(impliedSubgroups.get(closer), chars);
 			}
 
-			ITree<T> res = new Tree<>(chars.contents);
+			final ITree<T> res = new Tree<>(chars.contents);
 
-			if(contents.isEmpty()) {
+			if (contents.isEmpty()) {
 				currentGroup.forEach(res::addChild);
 			} else {
-				while(!contents.isEmpty()) {
+				while (!contents.isEmpty()) {
 					res.prependChild(contents.poll());
 				}
 
@@ -142,7 +142,7 @@ public class DelimiterGroup<T> {
 
 		@Override
 		public String toString() {
-			StringBuilder builder = new StringBuilder();
+			final StringBuilder builder = new StringBuilder();
 
 			builder.append("OpenGroup [contents=");
 			builder.append(contents);
@@ -157,34 +157,30 @@ public class DelimiterGroup<T> {
 
 		/**
 		 * Check if a group is excluded at the top level of this group.
-		 * 
+		 *
 		 * @param groupName
 		 *                The group to check.
-		 * 
+		 *
 		 * @return Whether or not the provided group is excluded.
 		 */
-		public boolean excludes(T groupName) {
+		public boolean excludes(final T groupName) {
 			return topLevelExclusions.contains(groupName);
 		}
 
 		/**
 		 * Check if the provided delimiter would close this group.
-		 * 
+		 *
 		 * @param del
 		 *                The string to check as a closing delimiter.
-		 * 
+		 *
 		 * @return Whether or not the provided delimiter closes this
 		 *         group.
 		 */
-		public boolean isClosing(T del) {
-			if(closingDelimiters.contains(del)) {
-				return true;
-			}
+		public boolean isClosing(final T del) {
+			if (closingDelimiters.contains(del)) return true;
 
-			for(BiPredicate<T, T[]> pred : predClosers) {
-				if(pred.test(del, params)) {
-					return true;
-				}
+			for (final BiPredicate<T, T[]> pred : predClosers) {
+				if (pred.test(del, params)) return true;
 			}
 
 			return closingDelimiters.contains(del);
@@ -192,7 +188,7 @@ public class DelimiterGroup<T> {
 
 		/**
 		 * Get the name of the group this is an instance of.
-		 * 
+		 *
 		 * @return The name of the group this is an instance of.
 		 */
 		public T getName() {
@@ -201,7 +197,7 @@ public class DelimiterGroup<T> {
 
 		/**
 		 * Get the groups that aren't allowed at all in this group.
-		 * 
+		 *
 		 * @return The groups that aren't allowed at all in this group.
 		 */
 		public Set<T> getNestingExclusions() {
@@ -211,7 +207,7 @@ public class DelimiterGroup<T> {
 		/**
 		 * Get the groups that are allowed to open anywhere inside this
 		 * group.
-		 * 
+		 *
 		 * @return The groups allowed to open anywhere inside this
 		 *         group.
 		 */
@@ -221,36 +217,32 @@ public class DelimiterGroup<T> {
 
 		/**
 		 * Checks if a given token marks a subgroup.
-		 * 
+		 *
 		 * @param tok
 		 *                The token to check.
-		 * 
+		 *
 		 * @return Whether or not the token marks a subgroup.
 		 */
-		public boolean marksSubgroup(T tok) {
+		public boolean marksSubgroup(final T tok) {
 			return subgroups.containsKey(tok);
 		}
 
 		/**
 		 * Checks if a given token opens a group.
-		 * 
+		 *
 		 * @param marker
 		 *                The token to check.
-		 * 
+		 *
 		 * @return The name of the group T opens, or null if it doesn't
 		 *         open one.
 		 */
-		public IPair<T, T[]> doesOpen(T marker) {
-			if(openDelimiters.containsKey(marker)) {
-				return new Pair<>(openDelimiters.get(marker), null);
-			}
+		public IPair<T, T[]> doesOpen(final T marker) {
+			if (openDelimiters.containsKey(marker)) return new Pair<>(openDelimiters.get(marker), null);
 
-			for(Function<T, IPair<T, T[]>> pred : predOpeners) {
-				IPair<T, T[]> par = pred.apply(marker);
+			for (final Function<T, IPair<T, T[]>> pred : predOpeners) {
+				final IPair<T, T[]> par = pred.apply(marker);
 
-				if(par.getLeft() != null) {
-					return par;
-				}
+				if (par.getLeft() != null) return par;
 			}
 
 			return new Pair<>(null, null);
@@ -258,7 +250,7 @@ public class DelimiterGroup<T> {
 
 		/**
 		 * Check if this group starts a new nesting scope.
-		 * 
+		 *
 		 * @return Whether this group starts a new nesting scope.
 		 */
 		public boolean isForgetful() {
@@ -274,48 +266,48 @@ public class DelimiterGroup<T> {
 	/*
 	 * The delimiters that open groups at the top level of this group.
 	 */
-	private Map<T, T> openDelimiters;
+	private final Map<T, T> openDelimiters;
 
 	/*
 	 * The delimiters that open groups inside of this group.
 	 */
-	private Map<T, T> nestedOpenDelimiters;
+	private final Map<T, T> nestedOpenDelimiters;
 
 	/*
 	 * The delimiters that close this group.
 	 */
-	private Set<T> closingDelimiters;
+	private final Set<T> closingDelimiters;
 
 	/*
 	 * The groups that can't occur in the top level of this group.
 	 */
-	private Set<T> topLevelExclusions;
+	private final Set<T> topLevelExclusions;
 
 	/*
 	 * The groups that can't occur anywhere inside this group.
 	 */
-	private Set<T> groupExclusions;
+	private final Set<T> groupExclusions;
 
 	/*
 	 * Mapping from sub-group delimiters, to any sub-groups enclosed in
 	 * them.
 	 */
-	private Map<T, Integer> subgroups;
+	private final Map<T, Integer> subgroups;
 
 	/*
 	 * Subgroups implied by a particular closing delimiter
 	 */
-	private Map<T, T> impliedSubgroups;
+	private final Map<T, T> impliedSubgroups;
 
 	/*
 	 * Allows more complex openings
 	 */
-	private List<Function<T, IPair<T, T[]>>> predOpeners;
+	private final List<Function<T, IPair<T, T[]>>> predOpeners;
 
 	/*
 	 * Allow more complex closings
 	 */
-	private List<BiPredicate<T, T[]>> predClosers;
+	private final List<BiPredicate<T, T[]>> predClosers;
 
 	/*
 	 * Whether or not this group starts a new nesting set.
@@ -324,12 +316,12 @@ public class DelimiterGroup<T> {
 
 	/**
 	 * Create a new empty delimiter group.
-	 * 
+	 *
 	 * @param name
 	 *                The name of the delimiter group
 	 */
-	public DelimiterGroup(T name) {
-		if(name == null) throw new NullPointerException("Group name must not be null");
+	public DelimiterGroup(final T name) {
+		if (name == null) throw new NullPointerException("Group name must not be null");
 
 		groupName = name;
 
@@ -350,25 +342,25 @@ public class DelimiterGroup<T> {
 
 	/**
 	 * Adds one or more delimiters that close this group.
-	 * 
+	 *
 	 * @param closers
 	 *                Delimiters that close this group.
 	 */
 	@SafeVarargs
-	public final void addClosing(T... closers) {
-		List<T> closerList = Arrays.asList(closers);
+	public final void addClosing(final T... closers) {
+		final List<T> closerList = Arrays.asList(closers);
 
-		for(T closer : closerList) {
-			if(closer == null) {
+		for (final T closer : closerList) {
+			if (closer == null)
 				throw new NullPointerException("Closing delimiter must not be null");
-			} else if(closer.equals("")) {
+			else if (closer.equals(""))
 				/*
 				 * We can do this because equals works on
 				 * arbitrary objects, not just those of the same
 				 * type.
 				 */
 				throw new IllegalArgumentException("Empty string is not a valid exclusion");
-			} else {
+			else {
 				closingDelimiters.add(closer);
 			}
 		}
@@ -377,23 +369,23 @@ public class DelimiterGroup<T> {
 	/**
 	 * Adds one or more groups that cannot occur in the top level of this
 	 * group.
-	 * 
+	 *
 	 * @param exclusions
 	 *                The groups forbidden in the top level of this group.
 	 */
 	@SafeVarargs
-	public final void addTopLevelForbid(T... exclusions) {
-		for(T exclusion : exclusions) {
-			if(exclusion == null) {
+	public final void addTopLevelForbid(final T... exclusions) {
+		for (final T exclusion : exclusions) {
+			if (exclusion == null)
 				throw new NullPointerException("Exclusion must not be null");
-			} else if(exclusion.equals("")) {
+			else if (exclusion.equals(""))
 				/*
 				 * We can do this because equals works on
 				 * arbitrary objects, not just those of the same
 				 * type.
 				 */
 				throw new IllegalArgumentException("Empty string is not a valid exclusion");
-			} else {
+			else {
 				topLevelExclusions.add(exclusion);
 			}
 		}
@@ -401,23 +393,23 @@ public class DelimiterGroup<T> {
 
 	/**
 	 * Adds one or more groups that cannot occur at all in this group.
-	 * 
+	 *
 	 * @param exclusions
 	 *                The groups forbidden inside this group.
 	 */
 	@SafeVarargs
-	public final void addGroupForbid(T... exclusions) {
-		for(T exclusion : exclusions) {
-			if(exclusion == null) {
+	public final void addGroupForbid(final T... exclusions) {
+		for (final T exclusion : exclusions) {
+			if (exclusion == null)
 				throw new NullPointerException("Exclusion must not be null");
-			} else if(exclusion.equals("")) {
+			else if (exclusion.equals(""))
 				/*
 				 * We can do this because equals works on
 				 * arbitrary objects, not just those of the same
 				 * type.
 				 */
 				throw new IllegalArgumentException("Empty string is not a valid exclusion");
-			} else {
+			else {
 				groupExclusions.add(exclusion);
 			}
 		}
@@ -425,85 +417,78 @@ public class DelimiterGroup<T> {
 
 	/**
 	 * Adds sub-group markers to this group.
-	 * 
+	 *
 	 * @param subgroup
 	 *                The token to mark a sub-group.
-	 * 
+	 *
 	 * @param priority
 	 *                The priority of this sub-group.
 	 */
-	public void addSubgroup(T subgroup, int priority) {
-		if(subgroup == null) {
-			throw new NullPointerException("Subgroup marker must not be null");
-		}
+	public void addSubgroup(final T subgroup, final int priority) {
+		if (subgroup == null) throw new NullPointerException("Subgroup marker must not be null");
 
 		subgroups.put(subgroup, priority);
 	}
 
 	/**
 	 * Adds a marker that opens a group at the top level of this group.
-	 * 
+	 *
 	 * @param opener
 	 *                The marker that opens the group.
-	 * 
+	 *
 	 * @param group
 	 *                The group opened by the marker.
 	 */
-	public void addOpener(T opener, T group) {
-		if(opener == null) {
+	public void addOpener(final T opener, final T group) {
+		if (opener == null)
 			throw new NullPointerException("Opener must not be null");
-		} else if(group == null) {
-			throw new NullPointerException("Group to open must not be null");
-		}
+		else if (group == null) throw new NullPointerException("Group to open must not be null");
 
 		openDelimiters.put(opener, group);
 	}
 
 	/**
 	 * Adds a marker that opens a group inside of this group.
-	 * 
+	 *
 	 * @param opener
 	 *                The marker that opens the group.
-	 * 
+	 *
 	 * @param group
 	 *                The group opened by the marker.
 	 */
-	public void addNestedOpener(T opener, T group) {
-		if(opener == null) {
+	public void addNestedOpener(final T opener, final T group) {
+		if (opener == null)
 			throw new NullPointerException("Opener must not be null");
-		} else if(group == null) {
-			throw new NullPointerException("Group to open must not be null");
-		}
+		else if (group == null) throw new NullPointerException("Group to open must not be null");
 
 		nestedOpenDelimiters.put(opener, group);
 	}
 
 	/**
 	 * Mark a closing delimiter as implying a subgroup.
-	 * 
+	 *
 	 * @param closer
 	 *                The closing delimiter.
-	 * 
+	 *
 	 * @param subgroup
 	 *                The subgroup to imply.
 	 */
-	public void implySubgroup(T closer, T subgroup) {
-		if(closer == null) {
+	public void implySubgroup(final T closer, final T subgroup) {
+		if (closer == null)
 			throw new NullPointerException("Closer must not be null");
-		} else if(subgroup == null) {
+		else if (subgroup == null)
 			throw new NullPointerException("Subgroup must not be null");
-		} else if(!closingDelimiters.contains(closer)) {
+		else if (!closingDelimiters.contains(closer))
 			throw new IllegalArgumentException(String.format("No closing delimiter '%s' defined", closer));
-		} else if(!subgroups.containsKey(subgroup)) {
+		else if (!subgroups.containsKey(subgroup))
 			throw new IllegalArgumentException(String.format("No subgroup '%s' defined", subgroup));
-		}
 
 		impliedSubgroups.put(closer, subgroup);
 	}
 
 	@Override
 	public String toString() {
-		StringBuilder builder = new StringBuilder();
+		final StringBuilder builder = new StringBuilder();
 
 		builder.append("(");
 
@@ -512,26 +497,26 @@ public class DelimiterGroup<T> {
 		builder.append("], ");
 
 		builder.append("closingDelimiters=[");
-		for(T closer : closingDelimiters) {
+		for (final T closer : closingDelimiters) {
 			builder.append(closer + ",");
 		}
 		builder.deleteCharAt(builder.length() - 1);
 		builder.append("]");
 
-		if(topLevelExclusions != null && !topLevelExclusions.isEmpty()) {
+		if (topLevelExclusions != null && !topLevelExclusions.isEmpty()) {
 			builder.append(", ");
 			builder.append("topLevelExclusions=[");
-			for(T exclusion : topLevelExclusions) {
+			for (final T exclusion : topLevelExclusions) {
 				builder.append(exclusion + ",");
 			}
 			builder.deleteCharAt(builder.length() - 1);
 			builder.append("]");
 		}
 
-		if(groupExclusions != null && !groupExclusions.isEmpty()) {
+		if (groupExclusions != null && !groupExclusions.isEmpty()) {
 			builder.append(", ");
 			builder.append("groupExclusions=[");
-			for(T exclusion : groupExclusions) {
+			for (final T exclusion : groupExclusions) {
 				builder.append(exclusion + ",");
 			}
 			builder.deleteCharAt(builder.length() - 1);
@@ -545,47 +530,47 @@ public class DelimiterGroup<T> {
 
 	/**
 	 * Open an instance of this group.
-	 * 
+	 *
 	 * @param opener
 	 *                The item that opened this group.
-	 * 
+	 *
 	 * @param parms
 	 *                The parameters that opened this group
-	 * 
+	 *
 	 * @return An opened instance of this group.
 	 */
-	public OpenGroup open(T opener, T[] parms) {
+	public OpenGroup open(final T opener, final T[] parms) {
 		return new OpenGroup(opener, parms);
 	}
 
 	/**
 	 * Adds a predicated opener to the top level of this group.
-	 * 
+	 *
 	 * @param pred
 	 *                The predicate that defines the opener and its
 	 *                parameters.
 	 */
-	public void addPredOpener(Function<T, IPair<T, T[]>> pred) {
+	public void addPredOpener(final Function<T, IPair<T, T[]>> pred) {
 		predOpeners.add(pred);
 	}
 
 	/**
 	 * Adds a predicated closer to the top level of this group.
-	 * 
+	 *
 	 * @param pred
 	 *                The predicate that defines the closer.
 	 */
-	public void addPredCloser(BiPredicate<T, T[]> pred) {
+	public void addPredCloser(final BiPredicate<T, T[]> pred) {
 		predClosers.add(pred);
 	}
 
 	/**
 	 * Set whether or not this group starts a new nesting set.
-	 * 
+	 *
 	 * @param forgetful
 	 *                Whether this group starts a new nesting set.
 	 */
-	public void setForgetful(boolean forgetful) {
+	public void setForgetful(final boolean forgetful) {
 		this.forgetful = forgetful;
 	}
 }
\ No newline at end of file
diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/delims/RegexCloser.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/delims/RegexCloser.java
index dc94686..4b29949 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/delims/RegexCloser.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/parserutils/delims/RegexCloser.java
@@ -4,29 +4,29 @@ import java.util.function.BiPredicate;
 
 /**
  * A predicated closer for use with {@link RegexOpener}.
- * 
+ *
  * @author bjculkin
  *
  */
 public class RegexCloser implements BiPredicate<String, String[]> {
-	private String rep;
+	private final String rep;
 
 	/**
 	 * Create a new regex closer.
-	 * 
+	 *
 	 * @param closer
 	 *                The format string to use for closing.
 	 */
-	public RegexCloser(String closer) {
+	public RegexCloser(final String closer) {
 		rep = closer;
 	}
 
 	@Override
-	public boolean test(String closer, String[] params) {
+	public boolean test(final String closer, final String[] params) {
 		/*
 		 * Confirm passing an array instead of a single var-arg.
 		 */
-		String work = String.format(rep, (Object[]) params);
+		final String work = String.format(rep, (Object[]) params);
 
 		return work.equals(closer);
 	}
diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/delims/RegexOpener.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/delims/RegexOpener.java
index 7b4aac0..98c1dc1 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/delims/RegexOpener.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/parserutils/delims/RegexOpener.java
@@ -1,46 +1,46 @@
 package bjc.utils.parserutils.delims;
 
-import bjc.utils.data.IPair;
-import bjc.utils.data.Pair;
-
 import java.util.function.Function;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
+import bjc.utils.data.IPair;
+import bjc.utils.data.Pair;
+
 /**
  * A predicated opener for use with {@link RegexOpener}
- * 
+ *
  * @author bjculkin
  *
  */
 public class RegexOpener implements Function<String, IPair<String, String[]>> {
-	private String name;
+	private final String name;
 
-	private Pattern patt;
+	private final Pattern patt;
 
 	/**
 	 * Create a new regex opener.
-	 * 
+	 *
 	 * @param groupName
 	 *                The name of the opened group.
-	 * 
+	 *
 	 * @param groupRegex
 	 *                The regex that matches the opener.
 	 */
-	public RegexOpener(String groupName, String groupRegex) {
+	public RegexOpener(final String groupName, final String groupRegex) {
 		name = groupName;
 
 		patt = Pattern.compile(groupRegex);
 	}
 
 	@Override
-	public IPair<String, String[]> apply(String str) {
-		Matcher m = patt.matcher(str);
+	public IPair<String, String[]> apply(final String str) {
+		final Matcher m = patt.matcher(str);
 
 		if (m.matches()) {
-			int numGroups = m.groupCount();
+			final int numGroups = m.groupCount();
 
-			String[] parms = new String[numGroups + 1];
+			final String[] parms = new String[numGroups + 1];
 
 			for (int i = 0; i <= numGroups; i++) {
 				parms[i] = m.group(i);
diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/delims/SequenceCharacteristics.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/delims/SequenceCharacteristics.java
index 5dcda2d..882b4c5 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/delims/SequenceCharacteristics.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/parserutils/delims/SequenceCharacteristics.java
@@ -2,7 +2,7 @@ package bjc.utils.parserutils.delims;
 
 /**
  * Marks the parameters for building a sequence tree.
- * 
+ *
  * @author EVE
  *
  * @param <T>
@@ -27,7 +27,7 @@ public class SequenceCharacteristics<T> {
 
 	/**
 	 * Create a new set of parameters for building a tree.
-	 * 
+	 *
 	 * @param root
 	 *                The root marker.
 	 * @param contents
@@ -35,7 +35,7 @@ public class SequenceCharacteristics<T> {
 	 * @param subgroup
 	 *                The subgroup marker.
 	 */
-	public SequenceCharacteristics(T root, T contents, T subgroup) {
+	public SequenceCharacteristics(final T root, final T contents, final T subgroup) {
 		this.root = root;
 		this.contents = contents;
 		this.subgroup = subgroup;
@@ -46,39 +46,39 @@ public class SequenceCharacteristics<T> {
 		final int prime = 31;
 		int result = 1;
 
-		result = prime * result + ((contents == null) ? 0 : contents.hashCode());
-		result = prime * result + ((root == null) ? 0 : root.hashCode());
-		result = prime * result + ((subgroup == null) ? 0 : subgroup.hashCode());
+		result = prime * result + (contents == null ? 0 : contents.hashCode());
+		result = prime * result + (root == null ? 0 : root.hashCode());
+		result = prime * result + (subgroup == null ? 0 : subgroup.hashCode());
 
 		return result;
 	}
 
 	@Override
-	public boolean equals(Object obj) {
-		if(this == obj) return true;
-		if(obj == null) return false;
-		if(!(obj instanceof SequenceCharacteristics)) return false;
+	public boolean equals(final Object obj) {
+		if (this == obj) return true;
+		if (obj == null) return false;
+		if (!(obj instanceof SequenceCharacteristics)) return false;
 
-		SequenceCharacteristics<?> other = (SequenceCharacteristics<?>) obj;
+		final SequenceCharacteristics<?> other = (SequenceCharacteristics<?>) obj;
 
-		if(contents == null) {
-			if(other.contents != null) return false;
-		} else if(!contents.equals(other.contents)) return false;
+		if (contents == null) {
+			if (other.contents != null) return false;
+		} else if (!contents.equals(other.contents)) return false;
 
-		if(root == null) {
-			if(other.root != null) return false;
-		} else if(!root.equals(other.root)) return false;
+		if (root == null) {
+			if (other.root != null) return false;
+		} else if (!root.equals(other.root)) return false;
 
-		if(subgroup == null) {
-			if(other.subgroup != null) return false;
-		} else if(!subgroup.equals(other.subgroup)) return false;
+		if (subgroup == null) {
+			if (other.subgroup != null) return false;
+		} else if (!subgroup.equals(other.subgroup)) return false;
 
 		return true;
 	}
 
 	@Override
 	public String toString() {
-		StringBuilder builder = new StringBuilder();
+		final StringBuilder builder = new StringBuilder();
 
 		builder.append("SequenceCharacteristics [root=");
 		builder.append(root == null ? "(null)" : root);
diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/delims/SequenceDelimiter.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/delims/SequenceDelimiter.java
index e723123..48d85c1 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/delims/SequenceDelimiter.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/parserutils/delims/SequenceDelimiter.java
@@ -1,5 +1,14 @@
 package bjc.utils.parserutils.delims;
 
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import com.google.common.collect.HashMultimap;
+import com.google.common.collect.HashMultiset;
+import com.google.common.collect.Multimap;
+import com.google.common.collect.Multiset;
+
 import bjc.utils.data.IPair;
 import bjc.utils.data.ITree;
 import bjc.utils.data.Tree;
@@ -9,18 +18,9 @@ import bjc.utils.esodata.Stack;
 import bjc.utils.funcdata.IMap;
 import bjc.utils.funcutils.StringUtils;
 
-import com.google.common.collect.HashMultimap;
-import com.google.common.collect.HashMultiset;
-import com.google.common.collect.Multimap;
-import com.google.common.collect.Multiset;
-
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Map.Entry;
-
 /**
  * Convert linear sequences into trees that represent group structure.
- * 
+ *
  * @author EVE
  *
  * @param <T>
@@ -30,7 +30,7 @@ public class SequenceDelimiter<T> {
 	/*
 	 * Mapping from group names to actual groups.
 	 */
-	private Map<T, DelimiterGroup<T>> groups;
+	private final Map<T, DelimiterGroup<T>> groups;
 
 	private DelimiterGroup<T> initialGroup;
 
@@ -44,64 +44,62 @@ public class SequenceDelimiter<T> {
 	/**
 	 * Convert a linear sequence into a tree that matches the delimiter
 	 * structure.
-	 * 
+	 *
 	 * Essentially, creates a parse tree of the expression against the
 	 * following grammar while obeying the defined grouping rules.
-	 * 
+	 *
 	 * <pre>
 	 *         <tree>     -> (<data> | <subgroup> | <group>)*
 	 *         <subgroup> -> <tree> <marker>
 	 *         <group>    -> <open> <tree> <close>
-	 *         
+	 *
 	 *         <data>     -> STRING
 	 *         <open>     -> STRING
 	 *         <close>    -> STRING
 	 *         <marker>   -> STRING
 	 * </pre>
-	 * 
+	 *
 	 * @param chars
 	 *                The parameters on how to mark certain portions of the
 	 *                tree.
 	 * @param seq
 	 *                The sequence to delimit.
-	 * 
+	 *
 	 * @return The sequence as a tree that matches its group structure. Each
 	 *         node in the tree is either a data node, a subgroup node, or a
 	 *         group node.
-	 * 
+	 *
 	 *         A data node is a leaf node whose data is the string it
 	 *         represents.
-	 * 
+	 *
 	 *         A subgroup node is a node with two children, and the name of
 	 *         the sub-group as its label. The first child is the contents
 	 *         of the sub-group, and the second is the marker that started
 	 *         the subgroup. The marker is a leaf node labeled with its
 	 *         contents, and the contents contains a recursive tree.
-	 * 
+	 *
 	 *         A group node is a node with three children, and the name of
 	 *         the group as its label. The first child is the opening
 	 *         delimiter, the second is the group contents, and the third is
 	 *         the closing delimiter. The delimiters are leaf nodes labeled
 	 *         with their contents, while the group node contains a
 	 *         recursive tree.
-	 * 
+	 *
 	 * @throws DelimiterException
 	 *                 Thrown if something went wrong during sequence
 	 *                 delimitation.
-	 * 
+	 *
 	 */
-	public ITree<T> delimitSequence(SequenceCharacteristics<T> chars, @SuppressWarnings("unchecked") T... seq)
-			throws DelimiterException {
-		if(initialGroup == null) {
+	public ITree<T> delimitSequence(final SequenceCharacteristics<T> chars,
+			@SuppressWarnings("unchecked") final T... seq) throws DelimiterException {
+		if (initialGroup == null)
 			throw new NullPointerException("Initial group must be specified.");
-		} else if(chars == null) {
-			throw new NullPointerException("Sequence characteristics must not be null");
-		}
+		else if (chars == null) throw new NullPointerException("Sequence characteristics must not be null");
 
 		/*
 		 * The stack of opened and not yet closed groups.
 		 */
-		Stack<DelimiterGroup<T>.OpenGroup> groupStack = new SimpleStack<>();
+		final Stack<DelimiterGroup<T>.OpenGroup> groupStack = new SimpleStack<>();
 
 		/*
 		 * Open initial group.
@@ -111,34 +109,34 @@ public class SequenceDelimiter<T> {
 		/*
 		 * Groups that aren't allowed to be opened at the moment.
 		 */
-		Stack<Multiset<T>> forbiddenDelimiters = new SimpleStack<>();
+		final Stack<Multiset<T>> forbiddenDelimiters = new SimpleStack<>();
 		forbiddenDelimiters.push(HashMultiset.create());
 
 		/*
 		 * Groups that are allowed to be opened at the moment.
 		 */
-		Stack<Multimap<T, T>> allowedDelimiters = new SimpleStack<>();
+		final Stack<Multimap<T, T>> allowedDelimiters = new SimpleStack<>();
 		allowedDelimiters.push(HashMultimap.create());
 
 		/*
 		 * Map of who forbid what for debugging purposes.
 		 */
-		IMap<T, T> whoForbid = new PushdownMap<>();
+		final IMap<T, T> whoForbid = new PushdownMap<>();
 
-		for(int i = 0; i < seq.length; i++) {
-			T tok = seq[i];
+		for (int i = 0; i < seq.length; i++) {
+			final T tok = seq[i];
 
-			IPair<T, T[]> possibleOpenPar = groupStack.top().doesOpen(tok);
+			final IPair<T, T[]> possibleOpenPar = groupStack.top().doesOpen(tok);
 			T possibleOpen = possibleOpenPar.getLeft();
 
-			if(possibleOpen == null) {
+			if (possibleOpen == null) {
 				/*
 				 * Handle nested openers.
-				 * 
+				 *
 				 * Local openers take priority over nested ones
 				 * if they overlap.
 				 */
-				if(allowedDelimiters.top().containsKey(tok)) {
+				if (allowedDelimiters.top().containsKey(tok)) {
 					possibleOpen = allowedDelimiters.top().get(tok).iterator().next();
 				}
 			}
@@ -146,29 +144,29 @@ public class SequenceDelimiter<T> {
 			/*
 			 * If we have an opening delimiter, handle it.
 			 */
-			if(possibleOpen != null) {
-				DelimiterGroup<T> group = groups.get(possibleOpen);
+			if (possibleOpen != null) {
+				final DelimiterGroup<T> group = groups.get(possibleOpen);
 
 				/*
 				 * Error on groups that can't open in this
 				 * context.
-				 * 
+				 *
 				 * This means groups that can't occur at the
 				 * top-level of this group, as well as nested
 				 * exclusions from all enclosing groups.
 				 */
-				if(isForbidden(groupStack, forbiddenDelimiters, possibleOpen)) {
-					StringBuilder msgBuilder = new StringBuilder();
+				if (isForbidden(groupStack, forbiddenDelimiters, possibleOpen)) {
+					final StringBuilder msgBuilder = new StringBuilder();
 
 					T forbiddenBy;
 
-					if(whoForbid.containsKey(tok)) {
+					if (whoForbid.containsKey(tok)) {
 						forbiddenBy = whoForbid.get(tok);
 					} else {
 						forbiddenBy = groupStack.top().getName();
 					}
 
-					String ctxList = StringUtils.toEnglishList(groupStack.toArray(), "then");
+					final String ctxList = StringUtils.toEnglishList(groupStack.toArray(), "then");
 
 					msgBuilder.append("Group '");
 					msgBuilder.append(group);
@@ -184,13 +182,13 @@ public class SequenceDelimiter<T> {
 				/*
 				 * Add an open group.
 				 */
-				DelimiterGroup<T>.OpenGroup open = group.open(tok, possibleOpenPar.getRight());
+				final DelimiterGroup<T>.OpenGroup open = group.open(tok, possibleOpenPar.getRight());
 				groupStack.push(open);
 
 				/*
 				 * Handle 'forgetful' groups that reset nesting
 				 */
-				if(open.isForgetful()) {
+				if (open.isForgetful()) {
 					allowedDelimiters.push(HashMultimap.create());
 					forbiddenDelimiters.push(HashMultiset.create());
 				}
@@ -198,33 +196,33 @@ public class SequenceDelimiter<T> {
 				/*
 				 * Add the nested opens from this group.
 				 */
-				Multimap<T, T> currentAllowed = allowedDelimiters.top();
-				for(Entry<T, T> opener : open.getNestingOpeners().entrySet()) {
+				final Multimap<T, T> currentAllowed = allowedDelimiters.top();
+				for (final Entry<T, T> opener : open.getNestingOpeners().entrySet()) {
 					currentAllowed.put(opener.getKey(), opener.getValue());
 				}
 
 				/*
 				 * Add the nested exclusions from this group
 				 */
-				Multiset<T> currentForbidden = forbiddenDelimiters.top();
-				for(T exclusion : open.getNestingExclusions()) {
+				final Multiset<T> currentForbidden = forbiddenDelimiters.top();
+				for (final T exclusion : open.getNestingExclusions()) {
 					currentForbidden.add(exclusion);
 
 					whoForbid.put(exclusion, possibleOpen);
 				}
-			} else if(!groupStack.empty() && groupStack.top().isClosing(tok)) {
+			} else if (!groupStack.empty() && groupStack.top().isClosing(tok)) {
 				/*
 				 * Close the group.
 				 */
-				DelimiterGroup<T>.OpenGroup closed = groupStack.pop();
+				final DelimiterGroup<T>.OpenGroup closed = groupStack.pop();
 
 				groupStack.top().addItem(closed.toTree(tok, chars));
 
 				/*
 				 * Remove nested exclusions from this group.
 				 */
-				Multiset<T> currentForbidden = forbiddenDelimiters.top();
-				for(T excludedGroup : closed.getNestingExclusions()) {
+				final Multiset<T> currentForbidden = forbiddenDelimiters.top();
+				for (final T excludedGroup : closed.getNestingExclusions()) {
 					currentForbidden.remove(excludedGroup);
 
 					whoForbid.remove(excludedGroup);
@@ -233,19 +231,19 @@ public class SequenceDelimiter<T> {
 				/*
 				 * Remove the nested opens from this group.
 				 */
-				Multimap<T, T> currentAllowed = allowedDelimiters.top();
-				for(Entry<T, T> closer : closed.getNestingOpeners().entrySet()) {
+				final Multimap<T, T> currentAllowed = allowedDelimiters.top();
+				for (final Entry<T, T> closer : closed.getNestingOpeners().entrySet()) {
 					currentAllowed.remove(closer.getKey(), closer.getValue());
 				}
 
 				/*
 				 * Handle 'forgetful' groups that reset nesting.
 				 */
-				if(closed.isForgetful()) {
+				if (closed.isForgetful()) {
 					allowedDelimiters.drop();
 					forbiddenDelimiters.drop();
 				}
-			} else if(!groupStack.empty() && groupStack.top().marksSubgroup(tok)) {
+			} else if (!groupStack.empty() && groupStack.top().marksSubgroup(tok)) {
 				groupStack.top().markSubgroup(tok, chars);
 			} else {
 				groupStack.top().addItem(new Tree<>(tok));
@@ -255,14 +253,15 @@ public class SequenceDelimiter<T> {
 		/*
 		 * Error if not all groups were closed.
 		 */
-		if(groupStack.size() > 1) {
-			DelimiterGroup<T>.OpenGroup group = groupStack.top();
+		if (groupStack.size() > 1) {
+			final DelimiterGroup<T>.OpenGroup group = groupStack.top();
 
-			StringBuilder msgBuilder = new StringBuilder();
+			final StringBuilder msgBuilder = new StringBuilder();
 
-			String closingDelims = StringUtils.toEnglishList(group.getNestingExclusions().toArray(), false);
+			final String closingDelims = StringUtils.toEnglishList(group.getNestingExclusions().toArray(),
+					false);
 
-			String ctxList = StringUtils.toEnglishList(groupStack.toArray(), "then");
+			final String ctxList = StringUtils.toEnglishList(groupStack.toArray(), "then");
 
 			msgBuilder.append("Unclosed group '");
 			msgBuilder.append(group.getName());
@@ -277,35 +276,34 @@ public class SequenceDelimiter<T> {
 		return groupStack.pop().toTree(chars.root, chars);
 	}
 
-	private boolean isForbidden(Stack<DelimiterGroup<T>.OpenGroup> groupStack,
-			Stack<Multiset<T>> forbiddenDelimiters, T groupName) {
+	private boolean isForbidden(final Stack<DelimiterGroup<T>.OpenGroup> groupStack,
+			final Stack<Multiset<T>> forbiddenDelimiters, final T groupName) {
 		boolean localForbid;
 
-		if(groupStack.empty())
+		if (groupStack.empty()) {
 			localForbid = false;
-		else
+		} else {
 			localForbid = groupStack.top().excludes(groupName);
+		}
 
 		return localForbid || forbiddenDelimiters.top().contains(groupName);
 	}
 
 	/**
 	 * Add a delimiter group.
-	 * 
+	 *
 	 * @param group
 	 *                The delimiter group.
 	 */
-	public void addGroup(DelimiterGroup<T> group) {
-		if(group == null) {
-			throw new NullPointerException("Group must not be null");
-		}
+	public void addGroup(final DelimiterGroup<T> group) {
+		if (group == null) throw new NullPointerException("Group must not be null");
 
 		groups.put(group.groupName, group);
 	}
 
 	/**
 	 * Creates and adds a delimiter group using the provided settings.
-	 * 
+	 *
 	 * @param openers
 	 *                The tokens that open this group
 	 * @param groupName
@@ -313,31 +311,31 @@ public class SequenceDelimiter<T> {
 	 * @param closers
 	 *                The tokens that close this group
 	 */
-	public void addGroup(T[] openers, T groupName, @SuppressWarnings("unchecked") T... closers) {
-		DelimiterGroup<T> group = new DelimiterGroup<>(groupName);
+	public void addGroup(final T[] openers, final T groupName, @SuppressWarnings("unchecked") final T... closers) {
+		final DelimiterGroup<T> group = new DelimiterGroup<>(groupName);
 
 		group.addClosing(closers);
 
 		addGroup(group);
 
-		for(T open : openers) {
+		for (final T open : openers) {
 			group.addOpener(open, groupName);
 		}
 	}
 
 	@Override
 	public String toString() {
-		StringBuilder builder = new StringBuilder();
+		final StringBuilder builder = new StringBuilder();
 
 		builder.append("SequenceDelimiter [");
 
-		if(groups != null) {
+		if (groups != null) {
 			builder.append("groups=");
 			builder.append(groups);
 			builder.append(",");
 		}
 
-		if(initialGroup != null) {
+		if (initialGroup != null) {
 			builder.append("initialGroup=");
 			builder.append(initialGroup);
 		}
@@ -349,11 +347,11 @@ public class SequenceDelimiter<T> {
 
 	/**
 	 * Set the initial group of this delimiter.
-	 * 
+	 *
 	 * @param initialGroup
 	 *                The initial group of this delimiter.
 	 */
-	public void setInitialGroup(DelimiterGroup<T> initialGroup) {
+	public void setInitialGroup(final DelimiterGroup<T> initialGroup) {
 		this.initialGroup = initialGroup;
 	}
 }
diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/delims/StringDelimiter.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/delims/StringDelimiter.java
index 6db1c98..e3eeea5 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/delims/StringDelimiter.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/parserutils/delims/StringDelimiter.java
@@ -4,7 +4,7 @@ import bjc.utils.data.ITree;
 
 /**
  * A sequence delimiter specialized for strings.
- * 
+ *
  * @author EVE
  *
  */
@@ -14,18 +14,18 @@ public class StringDelimiter extends SequenceDelimiter<String> {
 	 * Override of
 	 * {@link SequenceDelimiter#delimitSequence(SequenceCharacteristics, Object...)}
 	 * for ease of use for strings.
-	 * 
+	 *
 	 * @param seq
 	 *                The sequence to delimit.
-	 * 
+	 *
 	 * @return The sequence as a tree.
-	 * 
+	 *
 	 * @throws DelimiterException
 	 *                 if something went wrong with delimiting the sequence.
-	 * 
+	 *
 	 * @see SequenceDelimiter
 	 */
-	public ITree<String> delimitSequence(String... seq) throws DelimiterException {
+	public ITree<String> delimitSequence(final String... seq) throws DelimiterException {
 		return super.delimitSequence(new SequenceCharacteristics<>("root", "contents", "subgroup"), seq);
 	}
 }