From 889fac2bdf993dc86f64a8893c0260fdcf848acb Mon Sep 17 00:00:00 2001
From: bculkin2442 <bjculkin@mix.wvu.edu>
Date: Mon, 10 Apr 2017 16:40:33 -0400
Subject: Cleanup

---
 .../bjc/utils/parserutils/TokenTransformer.java    | 50 +++++++++++-----------
 1 file changed, 25 insertions(+), 25 deletions(-)

(limited to 'BJC-Utils2/src/main/java/bjc/utils/parserutils/TokenTransformer.java')

diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/TokenTransformer.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/TokenTransformer.java
index c441dff..89dc35f 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/TokenTransformer.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/parserutils/TokenTransformer.java
@@ -1,5 +1,11 @@
 package bjc.utils.parserutils;
 
+import java.util.Deque;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.function.UnaryOperator;
+
 import bjc.utils.data.IHolder;
 import bjc.utils.data.ITree;
 import bjc.utils.data.Pair;
@@ -7,23 +13,17 @@ import bjc.utils.data.Tree;
 import bjc.utils.parserutils.TreeConstructor.ConstructorState;
 import bjc.utils.parserutils.TreeConstructor.QueueFlattener;
 
-import java.util.Deque;
-import java.util.function.Consumer;
-import java.util.function.Function;
-import java.util.function.Predicate;
-import java.util.function.UnaryOperator;
-
 final class TokenTransformer<TokenType> implements Consumer<TokenType> {
 	// Handle operators
 	private final class OperatorHandler implements UnaryOperator<ConstructorState<TokenType>> {
-		private TokenType element;
+		private final TokenType element;
 
-		public OperatorHandler(TokenType element) {
+		public OperatorHandler(final TokenType element) {
 			this.element = element;
 		}
 
 		@Override
-		public ConstructorState<TokenType> apply(ConstructorState<TokenType> pair) {
+		public ConstructorState<TokenType> apply(final ConstructorState<TokenType> pair) {
 			// Replace the current AST with the result of handling
 			// an operator
 			return new ConstructorState<>(pair.bindLeft(queuedASTs -> {
@@ -31,18 +31,18 @@ final class TokenTransformer<TokenType> implements Consumer<TokenType> {
 			}));
 		}
 
-		private ConstructorState<TokenType> handleOperator(Deque<ITree<TokenType>> queuedASTs) {
+		private ConstructorState<TokenType> handleOperator(final Deque<ITree<TokenType>> queuedASTs) {
 			// The AST we're going to hand back
 			ITree<TokenType> newAST;
 
 			// Handle special operators
-			if(isSpecialOperator.test(element)) {
+			if (isSpecialOperator.test(element)) {
 				newAST = handleSpecialOperator.apply(element).apply(queuedASTs);
 			} else {
 				// Error if we don't have enough for a binary
 				// operator
-				if(queuedASTs.size() < 2) {
-					String msg = String.format(
+				if (queuedASTs.size() < 2) {
+					final String msg = String.format(
 							"Attempted to parse binary operator without enough operands\n\tProblem operator is: %s\n\tPossible operand is: %s",
 							element.toString(), queuedASTs.peek().toString());
 
@@ -50,8 +50,8 @@ final class TokenTransformer<TokenType> implements Consumer<TokenType> {
 				}
 
 				// Grab the two operands
-				ITree<TokenType> right = queuedASTs.pop();
-				ITree<TokenType> left = queuedASTs.pop();
+				final ITree<TokenType> right = queuedASTs.pop();
+				final ITree<TokenType> left = queuedASTs.pop();
 
 				// Create a new AST
 				newAST = new Tree<>(element, left, right);
@@ -65,17 +65,17 @@ final class TokenTransformer<TokenType> implements Consumer<TokenType> {
 		}
 	}
 
-	private IHolder<ConstructorState<TokenType>> initialState;
+	private final IHolder<ConstructorState<TokenType>> initialState;
 
-	private Predicate<TokenType> operatorPredicate;
+	private final Predicate<TokenType> operatorPredicate;
 
-	private Predicate<TokenType>				isSpecialOperator;
-	private Function<TokenType, QueueFlattener<TokenType>>	handleSpecialOperator;
+	private final Predicate<TokenType>				isSpecialOperator;
+	private final Function<TokenType, QueueFlattener<TokenType>>	handleSpecialOperator;
 
 	// Create a new transformer
-	public TokenTransformer(IHolder<ConstructorState<TokenType>> initialState,
-			Predicate<TokenType> operatorPredicate, Predicate<TokenType> isSpecialOperator,
-			Function<TokenType, QueueFlattener<TokenType>> handleSpecialOperator) {
+	public TokenTransformer(final IHolder<ConstructorState<TokenType>> initialState,
+			final Predicate<TokenType> operatorPredicate, final Predicate<TokenType> isSpecialOperator,
+			final Function<TokenType, QueueFlattener<TokenType>> handleSpecialOperator) {
 		this.initialState = initialState;
 		this.operatorPredicate = operatorPredicate;
 		this.isSpecialOperator = isSpecialOperator;
@@ -83,12 +83,12 @@ final class TokenTransformer<TokenType> implements Consumer<TokenType> {
 	}
 
 	@Override
-	public void accept(TokenType element) {
+	public void accept(final TokenType element) {
 		// Handle operators
-		if(operatorPredicate.test(element)) {
+		if (operatorPredicate.test(element)) {
 			initialState.transform(new OperatorHandler(element));
 		} else {
-			ITree<TokenType> newAST = new Tree<>(element);
+			final ITree<TokenType> newAST = new Tree<>(element);
 
 			// Insert the new tree into the AST
 			initialState.transform(pair -> {
-- 
cgit v1.2.3