Code maintenace and changes

1 files changed, 7 insertions, 92 deletions

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 52299bb..efd0394 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/TreeConstructor.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/parserutils/TreeConstructor.java
@@ -2,18 +2,15 @@ package bjc.utils.parserutils;
 
 import java.util.Deque;
 import java.util.LinkedList;
-import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.function.Predicate;
-import java.util.function.UnaryOperator;
 
-import bjc.utils.data.experimental.IHolder;
-import bjc.utils.data.experimental.IPair;
-import bjc.utils.data.experimental.Identity;
-import bjc.utils.data.experimental.Pair;
+import bjc.utils.data.IHolder;
+import bjc.utils.data.IPair;
+import bjc.utils.data.Identity;
+import bjc.utils.data.Pair;
 import bjc.utils.funcdata.IFunctionalList;
 import bjc.utils.funcdata.ITree;
-import bjc.utils.funcdata.Tree;
 
 /**
  * Creates a parse tree from a postfix expression
@@ -22,88 +19,6 @@ import bjc.utils.funcdata.Tree;
  *
  */
 public class TreeConstructor {
-	private static final class TokenTransformer<T> implements Consumer<T> {
-		private final class OperatorHandler implements
-				UnaryOperator<IPair<Deque<ITree<T>>, ITree<T>>> {
-			private T element;
-
-			public OperatorHandler(T element) {
-				this.element = element;
-			}
-
-			@Override
-			public IPair<Deque<ITree<T>>, ITree<T>> apply(
-					IPair<Deque<ITree<T>>, ITree<T>> pair) {
-				return pair.bind((queuedASTs, currentAST) -> {
-					return handleOperator(queuedASTs);
-				});
-			}
-
-			private IPair<Deque<ITree<T>>, ITree<T>> handleOperator(
-					Deque<ITree<T>> queuedASTs) {
-				ITree<T> newAST;
-
-				if (isSpecialOperator.test(element)) {
-					newAST = handleSpecialOperator.apply(queuedASTs);
-				} else {
-					if (queuedASTs.size() < 2) {
-						throw new IllegalStateException(
-								"Attempted to parse binary operator without enough operands.\n"
-										+ "Problem operator is " + element
-										+ "\nPossible operand is: \n\t"
-										+ queuedASTs.peek());
-					}
-
-					ITree<T> rightAST = queuedASTs.pop();
-					ITree<T> leftAST = queuedASTs.pop();
-
-					newAST = new Tree<>(element, leftAST, rightAST);
-				}
-
-				queuedASTs.push(newAST);
-
-				return new Pair<>(queuedASTs, newAST);
-			}
-		}
-
-		private IHolder<IPair<Deque<ITree<T>>, ITree<T>>>	initialState;
-		private Predicate<T>								operatorPredicate;
-		private Predicate<T>								isSpecialOperator;
-		private Function<Deque<ITree<T>>, ITree<T>>			handleSpecialOperator;
-
-		public TokenTransformer(
-				IHolder<IPair<Deque<ITree<T>>, ITree<T>>> initialState,
-				Predicate<T> operatorPredicate,
-				Predicate<T> isSpecialOperator,
-				Function<Deque<ITree<T>>, ITree<T>> handleSpecialOperator) {
-			this.initialState = initialState;
-			this.operatorPredicate = operatorPredicate;
-			this.isSpecialOperator = isSpecialOperator;
-			this.handleSpecialOperator = handleSpecialOperator;
-		}
-
-		@Override
-		public void accept(T element) {
-			if (operatorPredicate.test(element)) {
-				initialState.transform(new OperatorHandler(element));
-			} else {
-				ITree<T> newAST = new Tree<>(element);
-
-				initialState.doWith((pair) -> {
-					pair.doWith((queue, currentAST) -> {
-						queue.push(newAST);
-					});
-				});
-
-				initialState.transform((pair) -> {
-					return pair.bind((queue, currentAST) -> {
-						return new Pair<>(queue, newAST);
-					});
-				});
-			}
-		}
-	}
-
 	/**
 	 * Construct a tree from a list of tokens in postfix notation
 	 * 
@@ -161,15 +76,15 @@ public class TreeConstructor {
 					"Special operator determiner must not be null");
 		}
 
-		IHolder<IPair<Deque<ITree<T>>, ITree<T>>> initialState = new Identity<>(
-				new Pair<>(new LinkedList<>(), null));
+		IHolder<IPair<Deque<ITree<T>>, ITree<T>>> initialState =
+				new Identity<>(new Pair<>(new LinkedList<>(), null));
 
 		tokens.forEach(
 				new TokenTransformer<>(initialState, operatorPredicate,
 						isSpecialOperator, handleSpecialOperator));
 
 		return initialState.unwrap((pair) -> {
-			return pair.merge((queue, currentAST) -> currentAST);
+			return pair.getRight();
 		});
 	}
 }