Remove version 1 files

Remove the old, not used version 1 files from the repository. Check the
history if you care about them.

1 files changed, 0 insertions, 149 deletions

diff --git a/dice-lang/src/bjc/dicelang/v1/ast/ArithmeticCollapser.java b/dice-lang/src/bjc/dicelang/v1/ast/ArithmeticCollapser.java
deleted file mode 100644
index 28f29f0..0000000
--- a/dice-lang/src/bjc/dicelang/v1/ast/ArithmeticCollapser.java
+++ /dev/null
@@ -1,149 +0,0 @@
-package bjc.dicelang.v1.ast;
-
-import bjc.dicelang.v1.ast.nodes.IDiceASTNode;
-import bjc.dicelang.v1.ast.nodes.OperatorDiceNode;
-import bjc.utils.data.IPair;
-import bjc.utils.data.ITree;
-import bjc.utils.data.Pair;
-import bjc.utils.data.Tree;
-import bjc.utils.funcdata.IList;
-
-import java.util.function.BinaryOperator;
-
-/**
- * Responsible for collapsing arithmetic operators
- *
- * @author ben
- *
- */
-final class ArithmeticCollapser implements IOperatorCollapser {
-	// The type of operator we're collapsing
-	private OperatorDiceNode type;
-
-	// The operator to use to collapse operators
-	private BinaryOperator<Integer> valueOp;
-
-	private int initialValue;
-
-	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));
-
-		BinaryOperator<IPair<IResult, ITree<IDiceASTNode>>> reducer = (currentState, accumulatedState) -> {
-			// Force evaluation of accumulated state to prevent
-			// certain bugs from occuring
-			// accumulatedState.merge((l, r) -> null);
-
-			return reduceStates(accumulatedState, currentState);
-		};
-
-		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();
-
-		if(currentList.getSize() != accumulatedList.getSize())
-			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;
-		});
-		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() + ").");
-
-			return new Pair<>(result, accumulatedTree);
-		}
-
-		boolean currentIsInt = currentValue.getType() == ResultType.INTEGER;
-		boolean accumulatedIsInt = accumulatedValue.getType() == ResultType.INTEGER;
-
-		if(!currentIsInt) {
-			if(!accumulatedIsInt) {
-				IList<IResult> resultList = combineArrayResults(accumulatedValue, currentValue);
-
-				return new Pair<>(new ArrayResult(resultList), accumulatedTree);
-			}
-
-			IList<IResult> resultList = halfCombineLists(((ArrayResult) currentValue).getValue(),
-					accumulatedValue, true);
-
-			return new Pair<>(new ArrayResult(resultList), accumulatedTree);
-		} else if(!accumulatedIsInt) {
-			IList<IResult> resultList = halfCombineLists(((ArrayResult) accumulatedValue).getValue(),
-					currentValue, false);
-
-			return new Pair<>(new ArrayResult(resultList), accumulatedTree);
-		}
-
-		int accumulatedInt = ((IntegerResult) accumulatedValue).getValue();
-		int currentInt = ((IntegerResult) currentValue).getValue();
-
-		int combinedValue = valueOp.apply(accumulatedInt, currentInt);
-
-		return new Pair<>(new IntegerResult(combinedValue), accumulatedTree);
-	}
-
-	private IList<IResult> halfCombineLists(IList<IResult> list, IResult scalar, boolean scalarLeft) {
-		if(scalar.getType() != ResultType.INTEGER)
-			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");
-
-			int elementInt = ((IntegerResult) element).getValue();
-
-			IResult combinedValue;
-
-			if(scalarLeft) {
-				combinedValue = new IntegerResult(valueOp.apply(scalarInt, elementInt));
-			} else {
-				combinedValue = new IntegerResult(valueOp.apply(elementInt, scalarInt));
-			}
-
-			return combinedValue;
-		});
-	}
-
-	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);
-			});
-		});
-	}
-}
\ No newline at end of file