Update

Most of it is documentation changes.

The rest is more work on BlockReaders, as well as a simple command
language for configuring them.

1 files changed, 42 insertions, 17 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 89dc35f..30ccc5a 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/TokenTransformer.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/parserutils/TokenTransformer.java
@@ -13,8 +13,13 @@ import bjc.utils.data.Tree;
 import bjc.utils.parserutils.TreeConstructor.ConstructorState;
 import bjc.utils.parserutils.TreeConstructor.QueueFlattener;
 
+/*
+ * Handle creating ASTs from tokens.
+ */
 final class TokenTransformer<TokenType> implements Consumer<TokenType> {
-	// Handle operators
+	/*
+	 * Handle operators
+	 */
 	private final class OperatorHandler implements UnaryOperator<ConstructorState<TokenType>> {
 		private final TokenType element;
 
@@ -24,23 +29,29 @@ final class TokenTransformer<TokenType> implements Consumer<TokenType> {
 
 		@Override
 		public ConstructorState<TokenType> apply(final ConstructorState<TokenType> pair) {
-			// Replace the current AST with the result of handling
-			// an operator
+			/*
+			 * Replace the current AST with the result of handling an operator
+			 */
 			return new ConstructorState<>(pair.bindLeft(queuedASTs -> {
 				return handleOperator(queuedASTs);
 			}));
 		}
 
 		private ConstructorState<TokenType> handleOperator(final Deque<ITree<TokenType>> queuedASTs) {
-			// The AST we're going to hand back
+			/*
+			 * The AST we're going to hand back
+			 */
 			ITree<TokenType> newAST;
 
-			// Handle special operators
+			/*
+			 * Handle special operators
+			 */
 			if (isSpecialOperator.test(element)) {
 				newAST = handleSpecialOperator.apply(element).apply(queuedASTs);
 			} else {
-				// Error if we don't have enough for a binary
-				// operator
+				/*
+				 * Error if we don't have enough for a binary operator
+				 */
 				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",
@@ -49,18 +60,26 @@ final class TokenTransformer<TokenType> implements Consumer<TokenType> {
 					throw new IllegalStateException(msg);
 				}
 
-				// Grab the two operands
+				/*
+				 * Grab the two operands
+				 */
 				final ITree<TokenType> right = queuedASTs.pop();
 				final ITree<TokenType> left = queuedASTs.pop();
 
-				// Create a new AST
+				/*
+				 * Create a new AST
+				 */
 				newAST = new Tree<>(element, left, right);
 			}
 
-			// Stick it onto the stack
+			/*
+			 * Stick it onto the stack
+			 */
 			queuedASTs.push(newAST);
 
-			// Hand back the state
+			/*
+			 * Hand back the state
+			 */
 			return new ConstructorState<>(queuedASTs, newAST);
 		}
 	}
@@ -72,7 +91,9 @@ final class TokenTransformer<TokenType> implements Consumer<TokenType> {
 	private final Predicate<TokenType>				isSpecialOperator;
 	private final Function<TokenType, QueueFlattener<TokenType>>	handleSpecialOperator;
 
-	// Create a new transformer
+	/*
+	 * Create a new transformer
+	 */
 	public TokenTransformer(final IHolder<ConstructorState<TokenType>> initialState,
 			final Predicate<TokenType> operatorPredicate, final Predicate<TokenType> isSpecialOperator,
 			final Function<TokenType, QueueFlattener<TokenType>> handleSpecialOperator) {
@@ -84,17 +105,21 @@ final class TokenTransformer<TokenType> implements Consumer<TokenType> {
 
 	@Override
 	public void accept(final TokenType element) {
-		// Handle operators
+		/*
+		 * Handle operators
+		 */
 		if (operatorPredicate.test(element)) {
 			initialState.transform(new OperatorHandler(element));
 		} else {
 			final ITree<TokenType> newAST = new Tree<>(element);
 
-			// Insert the new tree into the AST
+			/*
+			 * Insert the new tree into the AST
+			 */
 			initialState.transform(pair -> {
-				// Transform the pair, ignoring the current AST
-				// in favor of the
-				// one consisting of the current element
+				/*
+				 * Transform the pair, ignoring the current AST in favor of the one consisting of the current element
+				 */
 				return new ConstructorState<>(pair.bindLeft(queue -> {
 					queue.push(newAST);