diff options
Diffstat (limited to 'BJC-Utils2/src/main/java/bjc/utils/parserutils/TokenTransformer.java')
| -rw-r--r-- | BJC-Utils2/src/main/java/bjc/utils/parserutils/TokenTransformer.java | 50 |
1 files changed, 25 insertions, 25 deletions
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 -> { |