Formatting

1 files changed, 56 insertions, 94 deletions

diff --git a/dice-lang/src/bjc/dicelang/v1/ast/ArithmeticCollapser.java b/dice-lang/src/bjc/dicelang/v1/ast/ArithmeticCollapser.java
index 5a69bf1..1a41ce6 100644
--- a/dice-lang/src/bjc/dicelang/v1/ast/ArithmeticCollapser.java
+++ b/dice-lang/src/bjc/dicelang/v1/ast/ArithmeticCollapser.java
@@ -18,28 +18,25 @@ import bjc.utils.data.Tree;
  */
 final class ArithmeticCollapser implements IOperatorCollapser {
 	// The type of operator we're collapsing
-	private OperatorDiceNode		type;
+	private OperatorDiceNode type;
 
 	// The operator to use to collapse operators
-	private BinaryOperator<Integer>	valueOp;
+	private BinaryOperator<Integer> valueOp;
 
-	private int						initialValue;
+	private int initialValue;
 
-	public ArithmeticCollapser(OperatorDiceNode type,
-			BinaryOperator<Integer> valueOp, int initVal) {
+	public ArithmeticCollapser(OperatorDiceNode type, BinaryOperator<Integer> valueOp, int initVal) {
 		this.type = type;
 		this.valueOp = valueOp;
 		this.initialValue = initVal;
 	}
 
 	@Override
-	public IPair<IResult, ITree<IDiceASTNode>> apply(
-			IList<IPair<IResult, ITree<IDiceASTNode>>> nodes) {
-		IPair<IResult, ITree<IDiceASTNode>> initialState = new Pair<>(
-				new IntegerResult(initialValue), new Tree<>(type));
+	public IPair<IResult, ITree<IDiceASTNode>> apply(IList<IPair<IResult, ITree<IDiceASTNode>>> nodes) {
+		IPair<IResult, ITree<IDiceASTNode>> initialState = new Pair<>(new IntegerResult(initialValue),
+				new Tree<>(type));
 
-		BinaryOperator<IPair<IResult, ITree<IDiceASTNode>>> reducer = (
-				currentState, accumulatedState) -> {
+		BinaryOperator<IPair<IResult, ITree<IDiceASTNode>>> reducer = (currentState, accumulatedState) -> {
 			// Force evaluation of accumulated state to prevent
 			// certain bugs from occuring
 			// accumulatedState.merge((l, r) -> null);
@@ -47,90 +44,66 @@ final class ArithmeticCollapser implements IOperatorCollapser {
 			return reduceStates(accumulatedState, currentState);
 		};
 
-		IPair<IResult, ITree<IDiceASTNode>> reducedState = nodes
-				.reduceAux(initialState, reducer, (state) -> state);
+		IPair<IResult, ITree<IDiceASTNode>> reducedState = nodes.reduceAux(initialState, reducer,
+				(state) -> state);
 
 		return reducedState;
 	}
 
-	private IList<IResult> combineArrayResults(IResult accumulatedValue,
-			IResult currentValue) {
-		IList<IResult> currentList = ((ArrayResult) currentValue)
-				.getValue();
-		IList<IResult> accumulatedList = ((ArrayResult) accumulatedValue)
-				.getValue();
+	private IList<IResult> combineArrayResults(IResult accumulatedValue, IResult currentValue) {
+		IList<IResult> currentList = ((ArrayResult) currentValue).getValue();
+		IList<IResult> accumulatedList = ((ArrayResult) accumulatedValue).getValue();
 
 		if (currentList.getSize() != accumulatedList.getSize()) {
-			throw new UnsupportedOperationException(
-					"Can only apply operations to equal-length arrays");
+			throw new UnsupportedOperationException("Can only apply operations to equal-length arrays");
 		}
 
-		IList<IResult> resultList = currentList.combineWith(
-				accumulatedList, (currentNode, accumulatedNode) -> {
-					boolean currentNotInt = currentNode
-							.getType() != ResultType.INTEGER;
-					boolean accumulatedNotInt = accumulatedNode
-							.getType() != ResultType.INTEGER;
-
-					if (currentNotInt || accumulatedNotInt) {
-						throw new UnsupportedOperationException(
-								"Nesting of array operations isn't allowed");
-					}
-
-					int accumulatedInt = ((IntegerResult) accumulatedNode)
-							.getValue();
-					int currentInt = ((IntegerResult) currentNode)
-							.getValue();
-
-					IResult combinedValue = new IntegerResult(
-							valueOp.apply(accumulatedInt, currentInt));
-					return combinedValue;
-				});
+		IList<IResult> resultList = currentList.combineWith(accumulatedList, (currentNode, accumulatedNode) -> {
+			boolean currentNotInt = currentNode.getType() != ResultType.INTEGER;
+			boolean accumulatedNotInt = accumulatedNode.getType() != ResultType.INTEGER;
+
+			if (currentNotInt || accumulatedNotInt) {
+				throw new UnsupportedOperationException("Nesting of array operations isn't allowed");
+			}
+
+			int accumulatedInt = ((IntegerResult) accumulatedNode).getValue();
+			int currentInt = ((IntegerResult) currentNode).getValue();
+
+			IResult combinedValue = new IntegerResult(valueOp.apply(accumulatedInt, currentInt));
+			return combinedValue;
+		});
 		return resultList;
 	}
 
-	private IPair<IResult, ITree<IDiceASTNode>> doArithmeticCollapse(
-			IResult accumulatedValue, ITree<IDiceASTNode> accumulatedTree,
-			IResult currentValue) {
-		if (accumulatedValue.getType() == ResultType.DUMMY
-				|| currentValue.getType() == ResultType.DUMMY) {
-			DummyResult result = new DummyResult(
-					"Found dummy result with either accumulated dummy ("
-							+ ((DummyResult) accumulatedValue).getData()
-							+ ") or current dummy ("
-							+ ((DummyResult) currentValue).getData()
-							+ ").");
+	private IPair<IResult, ITree<IDiceASTNode>> doArithmeticCollapse(IResult accumulatedValue,
+			ITree<IDiceASTNode> accumulatedTree, IResult currentValue) {
+		if (accumulatedValue.getType() == ResultType.DUMMY || currentValue.getType() == ResultType.DUMMY) {
+			DummyResult result = new DummyResult("Found dummy result with either accumulated dummy ("
+					+ ((DummyResult) accumulatedValue).getData() + ") or current dummy ("
+					+ ((DummyResult) currentValue).getData() + ").");
 
 			return new Pair<>(result, accumulatedTree);
 		}
 
-		boolean currentIsInt = currentValue
-				.getType() == ResultType.INTEGER;
-		boolean accumulatedIsInt = accumulatedValue
-				.getType() == ResultType.INTEGER;
+		boolean currentIsInt = currentValue.getType() == ResultType.INTEGER;
+		boolean accumulatedIsInt = accumulatedValue.getType() == ResultType.INTEGER;
 
 		if (!currentIsInt) {
 			if (!accumulatedIsInt) {
-				IList<IResult> resultList = combineArrayResults(
-						accumulatedValue, currentValue);
+				IList<IResult> resultList = combineArrayResults(accumulatedValue, currentValue);
 
-				return new Pair<>(new ArrayResult(resultList),
-						accumulatedTree);
+				return new Pair<>(new ArrayResult(resultList), accumulatedTree);
 			}
 
-			IList<IResult> resultList = halfCombineLists(
-					((ArrayResult) currentValue).getValue(),
+			IList<IResult> resultList = halfCombineLists(((ArrayResult) currentValue).getValue(),
 					accumulatedValue, true);
 
-			return new Pair<>(new ArrayResult(resultList),
-					accumulatedTree);
+			return new Pair<>(new ArrayResult(resultList), accumulatedTree);
 		} else if (!accumulatedIsInt) {
-			IList<IResult> resultList = halfCombineLists(
-					((ArrayResult) accumulatedValue).getValue(),
+			IList<IResult> resultList = halfCombineLists(((ArrayResult) accumulatedValue).getValue(),
 					currentValue, false);
 
-			return new Pair<>(new ArrayResult(resultList),
-					accumulatedTree);
+			return new Pair<>(new ArrayResult(resultList), accumulatedTree);
 		}
 
 		int accumulatedInt = ((IntegerResult) accumulatedValue).getValue();
@@ -138,23 +111,19 @@ final class ArithmeticCollapser implements IOperatorCollapser {
 
 		int combinedValue = valueOp.apply(accumulatedInt, currentInt);
 
-		return new Pair<>(new IntegerResult(combinedValue),
-				accumulatedTree);
+		return new Pair<>(new IntegerResult(combinedValue), accumulatedTree);
 	}
 
-	private IList<IResult> halfCombineLists(IList<IResult> list,
-			IResult scalar, boolean scalarLeft) {
+	private IList<IResult> halfCombineLists(IList<IResult> list, IResult scalar, boolean scalarLeft) {
 		if (scalar.getType() != ResultType.INTEGER) {
-			throw new UnsupportedOperationException(
-					"Nested array operations not supported");
+			throw new UnsupportedOperationException("Nested array operations not supported");
 		}
 
 		int scalarInt = ((IntegerResult) scalar).getValue();
 
 		return list.map((element) -> {
 			if (element.getType() != ResultType.INTEGER) {
-				throw new UnsupportedOperationException(
-						"Nested array operations not supported");
+				throw new UnsupportedOperationException("Nested array operations not supported");
 			}
 
 			int elementInt = ((IntegerResult) element).getValue();
@@ -162,30 +131,23 @@ final class ArithmeticCollapser implements IOperatorCollapser {
 			IResult combinedValue;
 
 			if (scalarLeft) {
-				combinedValue = new IntegerResult(
-						valueOp.apply(scalarInt, elementInt));
+				combinedValue = new IntegerResult(valueOp.apply(scalarInt, elementInt));
 			} else {
-				combinedValue = new IntegerResult(
-						valueOp.apply(elementInt, scalarInt));
+				combinedValue = new IntegerResult(valueOp.apply(elementInt, scalarInt));
 			}
 
 			return combinedValue;
 		});
 	}
 
-	private IPair<IResult, ITree<IDiceASTNode>> reduceStates(
-			IPair<IResult, ITree<IDiceASTNode>> accumulatedState,
+	private IPair<IResult, ITree<IDiceASTNode>> reduceStates(IPair<IResult, ITree<IDiceASTNode>> accumulatedState,
 			IPair<IResult, ITree<IDiceASTNode>> currentState) {
-		return accumulatedState
-				.bind((accumulatedValue, accumulatedTree) -> {
-					return currentState
-							.bind((currentValue, currentTree) -> {
-								accumulatedTree.addChild(currentTree);
-
-								return doArithmeticCollapse(
-										accumulatedValue, accumulatedTree,
-										currentValue);
-							});
-				});
+		return accumulatedState.bind((accumulatedValue, accumulatedTree) -> {
+			return currentState.bind((currentValue, currentTree) -> {
+				accumulatedTree.addChild(currentTree);
+
+				return doArithmeticCollapse(accumulatedValue, accumulatedTree, currentValue);
+			});
+		});
 	}
 }
\ No newline at end of file