Switch functional data to use interfaces

4 files changed, 35 insertions, 25 deletions

diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/AST.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/AST.java
index 90961d5..88b4862 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/AST.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/parserutils/AST.java
@@ -183,11 +183,14 @@ public class AST<T> {
 	/**
 	 * Expand the nodes in an AST
 	 * 
+	 * This is actually equivalent to converting the tree into an ordered
+	 * list, doing a flatMap, and then reconstructing the tree
+	 * 
 	 * @param expander
 	 *            The function to use for expanding nodes
 	 * @return The expanded AST
 	 */
-	public AST<T> expand(Function<T, AST<T>> expander) {
+	public AST<T> flatMapTree(Function<T, AST<T>> expander) {
 		if (expander == null) {
 			throw new NullPointerException("Expander must not be null");
 		}
diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/RuleBasedConfigReader.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/RuleBasedConfigReader.java
index b6162e5..999503c 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/RuleBasedConfigReader.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/parserutils/RuleBasedConfigReader.java
@@ -8,6 +8,7 @@ import java.util.Scanner;
 import java.util.function.BiConsumer;
 import java.util.function.Consumer;
 
+import bjc.utils.data.IPair;
 import bjc.utils.data.Pair;
 import bjc.utils.exceptions.UnknownPragmaException;
 import bjc.utils.funcdata.FunctionalStringTokenizer;
@@ -20,9 +21,10 @@ import bjc.utils.funcdata.FunctionalStringTokenizer;
  *
  * @param <E>
  *            The type of the state object to use
+ * 
  */
 public class RuleBasedConfigReader<E> {
-	private BiConsumer<FunctionalStringTokenizer, Pair<String, E>>	startRule;
+	private BiConsumer<FunctionalStringTokenizer, IPair<String, E>>	startRule;
 	private BiConsumer<FunctionalStringTokenizer, E>				continueRule;
 	private Consumer<E>												endRule;
 
@@ -39,7 +41,7 @@ public class RuleBasedConfigReader<E> {
 	 *            The action to fire when ending a rule
 	 */
 	public RuleBasedConfigReader(
-			BiConsumer<FunctionalStringTokenizer, Pair<String, E>> startRule,
+			BiConsumer<FunctionalStringTokenizer, IPair<String, E>> startRule,
 			BiConsumer<FunctionalStringTokenizer, E> continueRule,
 			Consumer<E> endRule) {
 		this.startRule = startRule;
@@ -90,20 +92,26 @@ public class RuleBasedConfigReader<E> {
 
 			state = initialState;
 			boolean ruleOpen = false;
+
 			while (inputSource.hasNextLine()) {
 				String line = inputSource.nextLine();
 
-				if (line.equals("")) {
+				if (line.startsWith("#") || line.startsWith("//")) {
+					// It's a comment
+					continue;
+				} else if (line.equals("")) {
 					if (ruleOpen == false) {
 						// Ignore blank line without an open rule
-					}
-
-					if (endRule == null) {
-						// Nothing happens on rule end
 					} else {
-						endRule.accept(state);
-					}
+						if (endRule == null) {
+							// Nothing happens on rule end
+							ruleOpen = false;
+						} else {
+							endRule.accept(state);
+						}
 
+						ruleOpen = false;
+					}
 					continue;
 				} else if (line.startsWith("\t")) {
 					if (ruleOpen == false) {
@@ -125,9 +133,7 @@ public class RuleBasedConfigReader<E> {
 
 					String nextToken = tokenizer.nextToken();
 
-					if (nextToken.equals("#") || nextToken.equals("//")) {
-						// Do nothing, this is a comment
-					} else if (nextToken.equals("pragma")) {
+					if (nextToken.equals("pragma")) {
 						String token = tokenizer.nextToken();
 
 						pragmas.getOrDefault(token, (tokenzer, stat) -> {
@@ -181,7 +187,7 @@ public class RuleBasedConfigReader<E> {
 	 *            The action to execute on starting of a rule
 	 */
 	public void setStartRule(
-			BiConsumer<FunctionalStringTokenizer, Pair<String, E>> startRule) {
+			BiConsumer<FunctionalStringTokenizer, IPair<String, E>> startRule) {
 		if (startRule == null) {
 			throw new NullPointerException(
 					"Action on rule start must be non-null");
diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/ShuntingYard.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/ShuntingYard.java
index 1e5d487..a60cb01 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/ShuntingYard.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/parserutils/ShuntingYard.java
@@ -1,13 +1,14 @@
 package bjc.utils.parserutils;
 
 import java.util.Deque;
-import java.util.HashMap;
 import java.util.LinkedList;
-import java.util.Map;
 import java.util.function.Consumer;
 import java.util.function.Function;
 
 import bjc.utils.funcdata.FunctionalList;
+import bjc.utils.funcdata.FunctionalMap;
+import bjc.utils.funcdata.IFunctionalList;
+import bjc.utils.funcdata.IFunctionalMap;
 import bjc.utils.funcutils.StringUtils;
 
 /**
@@ -61,11 +62,11 @@ public class ShuntingYard<E> {
 	}
 
 	private final class TokenShunter implements Consumer<String> {
-		private FunctionalList<E>	output;
+		private IFunctionalList<E>	output;
 		private Deque<String>		stack;
 		private Function<String, E>	transform;
 
-		public TokenShunter(FunctionalList<E> outpt, Deque<String> stack,
+		public TokenShunter(IFunctionalList<E> outpt, Deque<String> stack,
 				Function<String, E> transform) {
 			this.output = outpt;
 			this.stack = stack;
@@ -115,13 +116,13 @@ public class ShuntingYard<E> {
 	/**
 	 * Holds all the shuntable operations
 	 */
-	private Map<String, IPrecedent> operators;
+	private IFunctionalMap<String, IPrecedent> operators;
 
 	/**
 	 * Create a new shunting yard with a default set of operators
 	 */
 	public ShuntingYard() {
-		operators = new HashMap<>();
+		operators = new FunctionalMap<>();
 
 		if (shouldConfigureBasicOperators) {
 			operators.put("+", Operator.ADD);
@@ -175,7 +176,7 @@ public class ShuntingYard<E> {
 	 *            The function to use to transform strings to tokens
 	 * @return A list of tokens in postfix notation
 	 */
-	public FunctionalList<E> postfix(FunctionalList<String> input,
+	public IFunctionalList<E> postfix(IFunctionalList<String> input,
 			Function<String, E> tokenTransformer) {
 		if (input == null) {
 			throw new NullPointerException("Input must not be null");
@@ -183,7 +184,7 @@ public class ShuntingYard<E> {
 			throw new NullPointerException("Transformer must not be null");
 		}
 
-		FunctionalList<E> output = new FunctionalList<>();
+		IFunctionalList<E> output = new FunctionalList<>();
 
 		Deque<String> stack = new LinkedList<>();
 
diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/TreeConstructor.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/TreeConstructor.java
index 6fedf87..46e4da4 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/TreeConstructor.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/parserutils/TreeConstructor.java
@@ -9,7 +9,7 @@ import java.util.function.Predicate;
 import bjc.utils.data.GenHolder;
 import bjc.utils.data.IPair;
 import bjc.utils.data.Pair;
-import bjc.utils.funcdata.FunctionalList;
+import bjc.utils.funcdata.IFunctionalList;
 
 /**
  * Creates a parse tree from a postfix expression
@@ -119,7 +119,7 @@ public class TreeConstructor {
 	 *            operator
 	 * @return A AST from the expression
 	 */
-	public static <T> AST<T> constructTree(FunctionalList<T> tokens,
+	public static <T> AST<T> constructTree(IFunctionalList<T> tokens,
 			Predicate<T> operatorPredicate) {
 		return constructTree(tokens, operatorPredicate, (op) -> false,
 				null);
@@ -149,7 +149,7 @@ public class TreeConstructor {
 	 *         interface. Maybe there's a better way to express how that
 	 *         works
 	 */
-	public static <T> AST<T> constructTree(FunctionalList<T> tokens,
+	public static <T> AST<T> constructTree(IFunctionalList<T> tokens,
 			Predicate<T> operatorPredicate, Predicate<T> isSpecialOperator,
 			Function<Deque<AST<T>>, AST<T>> handleSpecialOperator) {
 		if (tokens == null) {