From 7549e7d1b671738d9ebe9a6bf12b666b2bcb5b42 Mon Sep 17 00:00:00 2001
From: bculkin2442 <bjculkin@mix.wvu.edu>
Date: Mon, 21 Mar 2016 17:57:12 -0400
Subject: Built AST representation of Dice things

---
 .../java/bjc/utils/dice/ast/DiceASTFlattener.java  | 83 ++++++++++++++++++++++
 1 file changed, 83 insertions(+)
 create mode 100644 BJC-Utils2/src/main/java/bjc/utils/dice/ast/DiceASTFlattener.java

(limited to 'BJC-Utils2/src/main/java/bjc/utils/dice/ast/DiceASTFlattener.java')

diff --git a/BJC-Utils2/src/main/java/bjc/utils/dice/ast/DiceASTFlattener.java b/BJC-Utils2/src/main/java/bjc/utils/dice/ast/DiceASTFlattener.java
new file mode 100644
index 0000000..3cf1d4e
--- /dev/null
+++ b/BJC-Utils2/src/main/java/bjc/utils/dice/ast/DiceASTFlattener.java
@@ -0,0 +1,83 @@
+package bjc.utils.dice.ast;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.BinaryOperator;
+
+import org.apache.commons.lang3.StringUtils;
+
+import bjc.utils.dice.BindingDiceExpression;
+import bjc.utils.dice.ComplexDice;
+import bjc.utils.dice.CompoundDice;
+import bjc.utils.dice.CompoundDiceExpression;
+import bjc.utils.dice.DiceExpressionType;
+import bjc.utils.dice.IDiceExpression;
+import bjc.utils.dice.ReferenceDiceExpression;
+import bjc.utils.dice.ScalarDie;
+import bjc.utils.parserutils.AST;
+
+public class DiceASTFlattener {
+	public static IDiceExpression flatten(AST<IDiceASTNode> ast,
+			Map<String, IDiceExpression> env) {
+		Map<IDiceASTNode, BinaryOperator<IDiceExpression>> opCollapsers = buildOperations(
+				env);
+
+		return ast.collapse((nod) -> {
+			if (nod instanceof LiteralDiceNode) {
+				return expFromLiteral((LiteralDiceNode) nod);
+			} else {
+				return new ReferenceDiceExpression(
+						((VariableDiceNode) nod).getVariable(), env);
+			}
+		} , opCollapsers, (r) -> r);
+	}
+
+	private static Map<IDiceASTNode, BinaryOperator<IDiceExpression>> buildOperations(
+			Map<String, IDiceExpression> env) {
+		Map<IDiceASTNode, BinaryOperator<IDiceExpression>> opCollapsers = new HashMap<>();
+		opCollapsers.put(OperatorDiceNode.ADD, (left, right) -> {
+			return new CompoundDiceExpression(right, left,
+					DiceExpressionType.ADD);
+		});
+		opCollapsers.put(OperatorDiceNode.SUBTRACT, (left, right) -> {
+			return new CompoundDiceExpression(right, left,
+					DiceExpressionType.SUBTRACT);
+		});
+		opCollapsers.put(OperatorDiceNode.MULTIPLY, (left, right) -> {
+			return new CompoundDiceExpression(right, left,
+					DiceExpressionType.MULTIPLY);
+		});
+		opCollapsers.put(OperatorDiceNode.DIVIDE, (left, right) -> {
+			return new CompoundDiceExpression(right, left,
+					DiceExpressionType.DIVIDE);
+		});
+		opCollapsers.put(OperatorDiceNode.ASSIGN, (left, right) -> {
+			return new BindingDiceExpression(left, right, env);
+		});
+		opCollapsers.put(OperatorDiceNode.COMPOUND, (left, right) -> {
+			return new CompoundDice(left, right);
+		});
+		opCollapsers.put(OperatorDiceNode.GROUP, (left, right) -> {
+			return new ComplexDice(left, right);
+		});
+
+		return opCollapsers;
+	}
+
+	private static IDiceExpression expFromLiteral(LiteralDiceNode tok) {
+		String data = tok.getData();
+
+		if (StringUtils.countMatches(data, 'c') == 1
+				&& !data.equalsIgnoreCase("c")) {
+			String[] strangs = data.split("c");
+
+			return new CompoundDice(ComplexDice.fromString(strangs[0]),
+					ComplexDice.fromString(strangs[1]));
+		} else if (StringUtils.countMatches(data, 'd') == 1
+				&& !data.equalsIgnoreCase("d")) {
+			return ComplexDice.fromString(data);
+		} else {
+			return new ScalarDie(Integer.parseInt(data));
+		}
+	}
+}
-- 
cgit v1.2.3