General formatting cleanup and documentation update

20 files changed, 574 insertions, 183 deletions

diff --git a/BJC-Utils2/src/main/java/bjc/utils/dice/BindingDiceExpression.java b/BJC-Utils2/src/main/java/bjc/utils/dice/BindingDiceExpression.java
index a715074..9ecce97 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/dice/BindingDiceExpression.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/dice/BindingDiceExpression.java
@@ -10,10 +10,34 @@ import java.util.Map;
  *
  */
 public class BindingDiceExpression implements IDiceExpression {
-	private String			name;
+	/**
+	 * The expression being bound to a name
+	 */
 	private IDiceExpression	exp;
 
 	/**
+	 * The name to bind the expression to
+	 */
+	private String			name;
+
+	/**
+	 * Create a new dice expression binder from two expressions and an
+	 * enviroment
+	 * 
+	 * @param left
+	 *            The left side expression to get a name from. Must be a
+	 *            ReferenceDiceExpression
+	 * @param right
+	 *            The right side to bind to the name
+	 * @param env
+	 *            The enviroment to bind into
+	 */
+	public BindingDiceExpression(IDiceExpression left,
+			IDiceExpression right, Map<String, IDiceExpression> env) {
+		this(((ReferenceDiceExpression) left).getName(), right, env);
+	}
+
+	/**
 	 * Create a new dice expression binder
 	 * 
 	 * @param name
@@ -31,16 +55,21 @@ public class BindingDiceExpression implements IDiceExpression {
 		env.put(name, exp);
 	}
 
-	public BindingDiceExpression(IDiceExpression left,
-			IDiceExpression right, Map<String, IDiceExpression> env) {
-		this(((ReferenceDiceExpression) left).getName(), right, env);
-	}
-
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see bjc.utils.dice.IDiceExpression#roll()
+	 */
 	@Override
 	public int roll() {
 		return exp.roll();
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see java.lang.Object#toString()
+	 */
 	@Override
 	public String toString() {
 		return "assign[n=" + name + ", exp=" + exp.toString() + "]";
diff --git a/BJC-Utils2/src/main/java/bjc/utils/dice/ComplexDice.java b/BJC-Utils2/src/main/java/bjc/utils/dice/ComplexDice.java
index 98a510a..226f9fd 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/dice/ComplexDice.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/dice/ComplexDice.java
@@ -9,6 +9,37 @@ package bjc.utils.dice;
  */
 public class ComplexDice implements IDiceExpression {
 	/**
+	 * Create a dice from a string expression
+	 * 
+	 * @param dice
+	 *            The string to parse the dice from
+	 * @return A dice group parsed from the string
+	 */
+	public static ComplexDice fromString(String dice) {
+		/*
+		 * Split it on the dice type marker
+		 */
+		String[] strangs = dice.split("d");
+
+		try {
+			/*
+			 * Create the actual dice
+			 */
+			return new ComplexDice(
+					new ScalarDie(Integer.parseInt(strangs[0])),
+					new Die(Integer.parseInt(strangs[1])));
+		} catch (NumberFormatException nfex) {
+			/*
+			 * Tell the user the expression is invalid
+			 */
+			throw new IllegalArgumentException(
+					"Attempted to create a dice using something that's not"
+							+ " an integer: " + strangs[0] + " and "
+							+ strangs[1] + " are likely culprits.");
+		}
+	}
+
+	/**
 	 * The die being rolled
 	 */
 	private IDiceExpression	die;
@@ -34,7 +65,7 @@ public class ComplexDice implements IDiceExpression {
 	/**
 	 * Create a new collection of dice
 	 * 
-	 * @param nDce
+	 * @param nSides
 	 *            The number of dice in the collection
 	 * @param de
 	 *            The type of dice the collection is composed of
@@ -44,6 +75,11 @@ public class ComplexDice implements IDiceExpression {
 		die = new Die(de);
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see bjc.utils.dice.IDiceExpression#roll()
+	 */
 	@Override
 	public int roll() {
 		int res = 0;
@@ -60,37 +96,11 @@ public class ComplexDice implements IDiceExpression {
 		return res;
 	}
 
-	/**
-	 * Create a dice from a string expression
+	/*
+	 * (non-Javadoc)
 	 * 
-	 * @param dice
-	 *            The string to parse the dice from
-	 * @return A dice group parsed from the string
+	 * @see java.lang.Object#toString()
 	 */
-	public static ComplexDice fromString(String dice) {
-		/*
-		 * Split it on the dice type marker
-		 */
-		String[] strangs = dice.split("d");
-
-		try {
-			/*
-			 * Create the actual dice
-			 */
-			return new ComplexDice(
-					new ScalarDie(Integer.parseInt(strangs[0])),
-					new Die(Integer.parseInt(strangs[1])));
-		} catch (NumberFormatException nfex) {
-			/*
-			 * Tell the user the expression is invalid
-			 */
-			throw new IllegalArgumentException(
-					"Attempted to create a dice using something that's not"
-							+ " an integer: " + strangs[0] + " and "
-							+ strangs[1] + " are likely culprits.");
-		}
-	}
-
 	@Override
 	public String toString() {
 		if (nDice instanceof ScalarDie && die instanceof Die) {
diff --git a/BJC-Utils2/src/main/java/bjc/utils/dice/CompoundDice.java b/BJC-Utils2/src/main/java/bjc/utils/dice/CompoundDice.java
index 4e2e9f3..3393711 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/dice/CompoundDice.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/dice/CompoundDice.java
@@ -14,6 +14,7 @@ public class CompoundDice implements IDiceExpression {
 	 * The left die of the expression
 	 */
 	private IDiceExpression	l;
+
 	/**
 	 * The right die of the expression
 	 */
@@ -32,14 +33,33 @@ public class CompoundDice implements IDiceExpression {
 		this.r = r;
 	}
 
+	/**
+	 * Create a new compound dice from two dice strings
+	 * 
+	 * @param l
+	 *            The left side dice
+	 * @param r
+	 *            The right side dice
+	 */
 	public CompoundDice(String l, String r) {
 		this(ComplexDice.fromString(l), ComplexDice.fromString(r));
 	}
 
+	/**
+	 * Create a new compound dice from an array of dice strings
+	 * 
+	 * @param exps
+	 *            An array of dice strings
+	 */
 	public CompoundDice(String[] exps) {
 		this(exps[0], exps[1]);
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see bjc.utils.dice.IDiceExpression#roll()
+	 */
 	@Override
 	public int roll() {
 		/*
@@ -48,6 +68,11 @@ public class CompoundDice implements IDiceExpression {
 		return Integer.parseInt(l.roll() + "" + r.roll());
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see java.lang.Object#toString()
+	 */
 	@Override
 	public String toString() {
 		return "compound[l=" + l.toString() + ", r=" + r.toString() + "]";
diff --git a/BJC-Utils2/src/main/java/bjc/utils/dice/CompoundDiceExpression.java b/BJC-Utils2/src/main/java/bjc/utils/dice/CompoundDiceExpression.java
index 12238c8..41b1df2 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/dice/CompoundDiceExpression.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/dice/CompoundDiceExpression.java
@@ -39,6 +39,11 @@ public class CompoundDiceExpression implements IDiceExpression {
 		this.det = det;
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see bjc.utils.dice.IDiceExpression#roll()
+	 */
 	@Override
 	public int roll() {
 		/*
@@ -65,6 +70,11 @@ public class CompoundDiceExpression implements IDiceExpression {
 		}
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see java.lang.Object#toString()
+	 */
 	@Override
 	public String toString() {
 		return "dice-exp[type=" + det + ", l=" + left.toString() + ", r="
diff --git a/BJC-Utils2/src/main/java/bjc/utils/dice/DiceExpressionParser.java b/BJC-Utils2/src/main/java/bjc/utils/dice/DiceExpressionParser.java
index a7d1f8c..4113be4 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/dice/DiceExpressionParser.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/dice/DiceExpressionParser.java
@@ -21,6 +21,8 @@ public class DiceExpressionParser {
 	 * 
 	 * @param exp
 	 *            The string to parse an expression from
+	 * @param env
+	 *            The enviroment to use when parsing expressions
 	 * @return The parsed dice expression
 	 */
 	public IDiceExpression parse(String exp,
@@ -48,8 +50,8 @@ public class DiceExpressionParser {
 		/*
 		 * Shunt the expression to postfix form
 		 */
-		FunctionalList<String> ls = yard.postfix(fst.toList(s -> s),
-				s -> s);
+		FunctionalList<String> ls =
+				yard.postfix(fst.toList(s -> s), s -> s);
 
 		/*
 		 * Create a stack for building an expression from parts
diff --git a/BJC-Utils2/src/main/java/bjc/utils/dice/DiceExpressionType.java b/BJC-Utils2/src/main/java/bjc/utils/dice/DiceExpressionType.java
index 2259308..d719ae8 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/dice/DiceExpressionType.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/dice/DiceExpressionType.java
@@ -1,11 +1,35 @@
 package bjc.utils.dice;
 
-/*
+/**
  * Enumeration for basic dice expression operators
  */
 public enum DiceExpressionType {
-	ADD, DIVIDE, MULTIPLY, SUBTRACT;
+	/**
+	 * Add two expressions
+	 */
+	ADD,
 
+	/**
+	 * Divide two expressions
+	 */
+	DIVIDE,
+
+	/**
+	 * Multiply two expressions
+	 */
+	MULTIPLY,
+
+	/**
+	 * Subtract two expressions
+	 */
+	SUBTRACT;
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see java.lang.Enum#toString()
+	 */
+	@Override
 	public String toString() {
 		switch (this) {
 			case ADD:
diff --git a/BJC-Utils2/src/main/java/bjc/utils/dice/Die.java b/BJC-Utils2/src/main/java/bjc/utils/dice/Die.java
index 9575df5..0bd6964 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/dice/Die.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/dice/Die.java
@@ -29,15 +29,19 @@ public class Die implements IDiceExpression {
 		this.nSides = nSides;
 	}
 
-	/**
-	 * Roll this dice once
-	 * 
-	 * @return The result of rolling the dice
+	/*
+	 * (non-Javadoc)
+	 * @see bjc.utils.dice.IDiceExpression#roll()
 	 */
+	@Override
 	public int roll() {
 		return rng.nextInt(nSides) + 1;
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see java.lang.Object#toString()
+	 */
 	@Override
 	public String toString() {
 		return "d" + nSides;
diff --git a/BJC-Utils2/src/main/java/bjc/utils/dice/IDiceExpression.java b/BJC-Utils2/src/main/java/bjc/utils/dice/IDiceExpression.java
index 4bd0973..5ead9ad 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/dice/IDiceExpression.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/dice/IDiceExpression.java
@@ -6,9 +6,11 @@ package bjc.utils.dice;
  * @author ben
  *
  */
+@FunctionalInterface
 public interface IDiceExpression {
 	/**
 	 * Roll the dice once
+	 * 
 	 * @return The result of rowing the dice
 	 */
 	public int roll();
diff --git a/BJC-Utils2/src/main/java/bjc/utils/dice/PolyhedralDice.java b/BJC-Utils2/src/main/java/bjc/utils/dice/PolyhedralDice.java
index 511fd99..314d47b 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/dice/PolyhedralDice.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/dice/PolyhedralDice.java
@@ -1,7 +1,7 @@
 package bjc.utils.dice;
 
 /**
- * Class that produces common polyhedral dice
+ * Utility class that produces common polyhedral dice
  * 
  * @author ben
  *
@@ -52,33 +52,33 @@ public class PolyhedralDice {
 	}
 
 	/**
-	 * Produce the specified number of 10-sided dice
+	 * Produce the specified number of 4-sided dice
 	 * 
 	 * @param nDice
-	 *            The number of ten-sided dice to produce
-	 * @return A group of ten-sided dice of the specified size
+	 *            The number of four-sided dice to produce
+	 * @return A group of four-sided dice of the specified size
 	 */
 	public static IDiceExpression d4(int nDice) {
 		return new ComplexDice(nDice, 4);
 	}
 
 	/**
-	 * Produce the specified number of 10-sided dice
+	 * Produce the specified number of 6-sided dice
 	 * 
 	 * @param nDice
-	 *            The number of ten-sided dice to produce
-	 * @return A group of ten-sided dice of the specified size
+	 *            The number of six-sided dice to produce
+	 * @return A group of six-sided dice of the specified size
 	 */
 	public static IDiceExpression d6(int nDice) {
 		return new ComplexDice(nDice, 6);
 	}
 
 	/**
-	 * Produce the specified number of 10-sided dice
+	 * Produce the specified number of 8-sided dice
 	 * 
 	 * @param nDice
-	 *            The number of ten-sided dice to produce
-	 * @return A group of ten-sided dice of the specified size
+	 *            The number of eight-sided dice to produce
+	 * @return A group of eight-sided dice of the specified size
 	 */
 	public static IDiceExpression d8(int nDice) {
 		return new ComplexDice(nDice, 8);
diff --git a/BJC-Utils2/src/main/java/bjc/utils/dice/ReferenceDiceExpression.java b/BJC-Utils2/src/main/java/bjc/utils/dice/ReferenceDiceExpression.java
index d8062da..d38e0f9 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/dice/ReferenceDiceExpression.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/dice/ReferenceDiceExpression.java
@@ -11,14 +11,14 @@ import java.util.Map;
  */
 public class ReferenceDiceExpression implements IDiceExpression {
 	/**
-	 * The name of the bound variable
+	 * The enviroment to do variable dereferencing against
 	 */
-	private String							name;
+	private Map<String, IDiceExpression>	env;
 
 	/**
-	 * The enviroment to do variable dereferencing against
+	 * The name of the bound variable
 	 */
-	private Map<String, IDiceExpression>	env;
+	private String							name;
 
 	/**
 	 * Create a new reference dice expression referring to the given name
@@ -35,11 +35,30 @@ public class ReferenceDiceExpression implements IDiceExpression {
 		this.env = env;
 	}
 
+	/**
+	 * Get the name of the referenced variable
+	 * 
+	 * @return the name of the referenced variable
+	 */
+	public String getName() {
+		return name;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see bjc.utils.dice.IDiceExpression#roll()
+	 */
 	@Override
 	public int roll() {
 		return env.get(name).roll();
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see java.lang.Object#toString()
+	 */
 	@Override
 	public String toString() {
 		if (env.containsKey(name)) {
@@ -48,13 +67,4 @@ public class ReferenceDiceExpression implements IDiceExpression {
 			return name;
 		}
 	}
-
-	/**
-	 * Get the name of the referenced variable
-	 * 
-	 * @return the name of the referenced variable
-	 */
-	public String getName() {
-		return name;
-	}
 }
diff --git a/BJC-Utils2/src/main/java/bjc/utils/dice/ScalarDiceExpression.java b/BJC-Utils2/src/main/java/bjc/utils/dice/ScalarDiceExpression.java
index 2b174c8..267e6ef 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/dice/ScalarDiceExpression.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/dice/ScalarDiceExpression.java
@@ -11,6 +11,7 @@ public class ScalarDiceExpression implements IDiceExpression {
 	 * The operation to combine with
 	 */
 	private DiceExpressionType	det;
+	
 	/**
 	 * The expression to be combined
 	 */
@@ -38,6 +39,10 @@ public class ScalarDiceExpression implements IDiceExpression {
 		det = dt;
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see bjc.utils.dice.IDiceExpression#roll()
+	 */
 	@Override
 	public int roll() {
 		switch (det) {
@@ -56,6 +61,10 @@ public class ScalarDiceExpression implements IDiceExpression {
 		}
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see java.lang.Object#toString()
+	 */
 	@Override
 	public String toString() {
 		return "scalar-exp[type=" + det + ", l=" + scalar + ", r="
diff --git a/BJC-Utils2/src/main/java/bjc/utils/dice/ScalarDie.java b/BJC-Utils2/src/main/java/bjc/utils/dice/ScalarDie.java
index bef68e1..4ed99b9 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/dice/ScalarDie.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/dice/ScalarDie.java
@@ -12,11 +12,6 @@ public class ScalarDie implements IDiceExpression {
 	 */
 	private int num;
 
-	@Override
-	public int roll() {
-		return num;
-	}
-
 	/**
 	 * Create a dice with the specified number
 	 * 
@@ -27,6 +22,21 @@ public class ScalarDie implements IDiceExpression {
 		this.num = num;
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see bjc.utils.dice.IDiceExpression#roll()
+	 */
+	@Override
+	public int roll() {
+		return num;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see java.lang.Object#toString()
+	 */
 	@Override
 	public String toString() {
 		return Integer.toString(num);
diff --git a/BJC-Utils2/src/main/java/bjc/utils/dice/ast/DiceASTExpression.java b/BJC-Utils2/src/main/java/bjc/utils/dice/ast/DiceASTExpression.java
index 3b81888..aceeed0 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/dice/ast/DiceASTExpression.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/dice/ast/DiceASTExpression.java
@@ -12,48 +12,22 @@ import bjc.utils.dice.CompoundDice;
 import bjc.utils.dice.IDiceExpression;
 import bjc.utils.parserutils.AST;
 
+/**
+ * An implementation of {@link IDiceExpression} backed by an AST of
+ * {@link IDiceASTNode}s
+ * 
+ * @author ben
+ *
+ */
 public class DiceASTExpression implements IDiceExpression {
-	private AST<IDiceASTNode>				ast;
-	private Map<String, DiceASTExpression>	env;
-
-	public DiceASTExpression(AST<IDiceASTNode> ast,
-			Map<String, DiceASTExpression> env) {
-		this.ast = ast;
-		this.env = env;
-	}
-
-	private Pair<Integer, AST<IDiceASTNode>> evalLeaf(IDiceASTNode tokn) {
-		if (tokn instanceof VariableDiceNode) {
-			String varName = ((VariableDiceNode) tokn).getVariable();
-			
-			if (env.containsKey(varName)) {
-				return new Pair<>(env.get(varName).roll(), new AST<>(tokn));
-			} else {
-				// Handle special case for defining variables
-				return new Pair<>(0, new AST<>(tokn));
-			}
-		} else {
-			LiteralDiceNode lnod = (LiteralDiceNode) tokn;
-			String dat = lnod.getData();
-
-			if (StringUtils.countMatches(dat, 'c') == 1
-					&& !dat.equalsIgnoreCase("c")) {
-				String[] strangs = dat.split("c");
-				return new Pair<>(new CompoundDice(strangs).roll(),
-						new AST<>(tokn));
-			} else if (StringUtils.countMatches(dat, 'd') == 1
-					&& !dat.equalsIgnoreCase("d")) {
-				/*
-				 * Handle dice groups
-				 */
-				return new Pair<>(ComplexDice.fromString(dat).roll(),
-						new AST<>(tokn));
-			} else {
-				return new Pair<>(Integer.parseInt(dat), new AST<>(tokn));
-			}
-		}
-	}
 
+	/**
+	 * Build the map of operations to use when collapsing the AST
+	 * 
+	 * @param env
+	 *            The enviroment to evaluate bindings and such against
+	 * @return The operations to use when collapsing the AST
+	 */
 	private static
 			Map<IDiceASTNode, BinaryOperator<Pair<Integer, AST<IDiceASTNode>>>>
 			buildOperations(Map<String, DiceASTExpression> env) {
@@ -121,6 +95,83 @@ public class DiceASTExpression implements IDiceExpression {
 		return opCollapsers;
 	}
 
+	/**
+	 * The AST this expression will evaluate
+	 */
+	private AST<IDiceASTNode>				ast;
+
+	/**
+	 * The enviroment to evaluate bindings and such against
+	 */
+	private Map<String, DiceASTExpression>	env;
+
+	/**
+	 * Create a new dice expression backed by an AST
+	 * 
+	 * @param ast
+	 *            The AST backing this expression
+	 * @param env
+	 *            The enviroment to evaluate bindings against
+	 */
+	public DiceASTExpression(AST<IDiceASTNode> ast,
+			Map<String, DiceASTExpression> env) {
+		this.ast = ast;
+		this.env = env;
+	}
+
+	/**
+	 * Expand a leaf AST token into a pair for evaluation
+	 * 
+	 * @param tokn
+	 *            The token to evaluate
+	 * @return A pair consisting of the token's value and the AST it
+	 *         represents
+	 */
+	private Pair<Integer, AST<IDiceASTNode>> evalLeaf(IDiceASTNode tokn) {
+		if (tokn instanceof VariableDiceNode) {
+			String varName = ((VariableDiceNode) tokn).getVariable();
+
+			if (env.containsKey(varName)) {
+				return new Pair<>(env.get(varName).roll(),
+						new AST<>(tokn));
+			} else {
+				// Handle special case for defining variables
+				return new Pair<>(0, new AST<>(tokn));
+			}
+		} else {
+			LiteralDiceNode lnod = (LiteralDiceNode) tokn;
+			String dat = lnod.getData();
+
+			if (StringUtils.countMatches(dat, 'c') == 1
+					&& !dat.equalsIgnoreCase("c")) {
+				String[] strangs = dat.split("c");
+				return new Pair<>(new CompoundDice(strangs).roll(),
+						new AST<>(tokn));
+			} else if (StringUtils.countMatches(dat, 'd') == 1
+					&& !dat.equalsIgnoreCase("d")) {
+				/*
+				 * Handle dice groups
+				 */
+				return new Pair<>(ComplexDice.fromString(dat).roll(),
+						new AST<>(tokn));
+			} else {
+				return new Pair<>(Integer.parseInt(dat), new AST<>(tokn));
+			}
+		}
+	}
+
+	/**
+	 * Get the AST bound to this expression
+	 * @return the ast
+	 */
+	public AST<IDiceASTNode> getAst() {
+		return ast;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see bjc.utils.dice.IDiceExpression#roll()
+	 */
 	@Override
 	public int roll() {
 		Map<IDiceASTNode, BinaryOperator<Pair<Integer, AST<IDiceASTNode>>>> operations =
@@ -130,15 +181,12 @@ public class DiceASTExpression implements IDiceExpression {
 				(r) -> r.merge((left, right) -> left));
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see java.lang.Object#toString()
+	 */
 	@Override
 	public String toString() {
 		return ast.toString();
 	}
-
-	/**
-	 * @return the ast
-	 */
-	public AST<IDiceASTNode> getAst() {
-		return ast;
-	}
 }
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
index da402c3..70465a5 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/dice/ast/DiceASTFlattener.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/dice/ast/DiceASTFlattener.java
@@ -16,25 +16,25 @@ import bjc.utils.dice.ReferenceDiceExpression;
 import bjc.utils.dice.ScalarDie;
 import bjc.utils.parserutils.AST;
 
+/**
+ * Flatten an {@link AST} of {@link IDiceASTNode} into a
+ * {@link IDiceExpression}
+ * 
+ * @author ben
+ *
+ */
 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::get, (r) -> r);
-	}
-
-	private static Map<IDiceASTNode, BinaryOperator<IDiceExpression>> buildOperations(
-			Map<String, IDiceExpression> env) {
-		Map<IDiceASTNode, BinaryOperator<IDiceExpression>> opCollapsers = new HashMap<>();
+	/**
+	 * Build the operations to use for tree flattening
+	 * 
+	 * @param env
+	 *            The enviroment the tree will be flattened against
+	 * @return The operations needed for tree flattening
+	 */
+	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);
@@ -64,6 +64,13 @@ public class DiceASTFlattener {
 		return opCollapsers;
 	}
 
+	/**
+	 * Create a dice expression from a literal token
+	 * 
+	 * @param tok
+	 *            The token to convert to an expression
+	 * @return The dice expression represented by the token
+	 */
 	private static IDiceExpression expFromLiteral(LiteralDiceNode tok) {
 		String data = tok.getData();
 
@@ -80,4 +87,28 @@ public class DiceASTFlattener {
 			return new ScalarDie(Integer.parseInt(data));
 		}
 	}
+
+	/**
+	 * Flatten a AST into a dice expression
+	 * 
+	 * @param ast
+	 *            The AST to flatten
+	 * @param env
+	 *            The enviroment to flatten against
+	 * @return The AST, flattened into a dice expression
+	 */
+	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::get, (r) -> r);
+	}
 }
diff --git a/BJC-Utils2/src/main/java/bjc/utils/dice/ast/DiceASTFreezer.java b/BJC-Utils2/src/main/java/bjc/utils/dice/ast/DiceASTFreezer.java
index 04cc99b..efe37c0 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/dice/ast/DiceASTFreezer.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/dice/ast/DiceASTFreezer.java
@@ -4,7 +4,52 @@ import java.util.Map;
 
 import bjc.utils.parserutils.AST;
 
+/**
+ * Freeze references in a dice AST, replacing variable references with what
+ * the variables refer to
+ * 
+ * @author ben
+ *
+ */
 public class DiceASTFreezer {
+	/**
+	 * Expand a reference
+	 * 
+	 * @param vnode
+	 *            The node containing the reference to expand
+	 * @param env
+	 *            The enviroment to expand against
+	 * @return The expanded reference
+	 */
+	private static AST<IDiceASTNode> expandNode(VariableDiceNode vnode,
+			Map<String, AST<IDiceASTNode>> env) {
+		return env.get(vnode.getVariable());
+	}
+
+	/**
+	 * Expand a reference
+	 * 
+	 * @param vnode
+	 *            The node containing the reference to expand
+	 * @param env
+	 *            The enviroment to expand against
+	 * @return The expanded reference
+	 */
+	private static AST<IDiceASTNode> expandNode2(VariableDiceNode vnode,
+			Map<String, DiceASTExpression> env) {
+		return env.get(vnode.getVariable()).getAst();
+	}
+
+	/**
+	 * Freeze the references in an AST
+	 * 
+	 * @param tree
+	 *            The tree to freeze references in
+	 * @param env
+	 *            The enviroment to get reference values from
+	 * @return The tree with references frozen
+	 */
+	@SuppressWarnings("unused")
 	public static AST<IDiceASTNode> freezeAST(AST<IDiceASTNode> tree,
 			Map<String, AST<IDiceASTNode>> env) {
 		return tree.collapse((nod) -> {
@@ -20,6 +65,16 @@ public class DiceASTFreezer {
 		} , (r) -> r);
 	}
 
+	/**
+	 * Freeze the references in an expression backed by an AST
+	 * 
+	 * @param tree
+	 *            The tree-backed expression to freeze references in
+	 * @param env
+	 *            The enviroment to get reference values from
+	 * @return The tree with references frozen
+	 */
+	@SuppressWarnings("unused")
 	public static AST<IDiceASTNode> freezeAST(DiceASTExpression tree,
 			Map<String, DiceASTExpression> env) {
 		return tree.getAst().collapse((nod) -> {
@@ -34,14 +89,4 @@ public class DiceASTFreezer {
 			return new AST<IDiceASTNode>(op, left, right);
 		} , (r) -> r);
 	}
-
-	private static AST<IDiceASTNode> expandNode(VariableDiceNode vnode,
-			Map<String, AST<IDiceASTNode>> env) {
-		return env.get(vnode.getVariable());
-	}
-
-	private static AST<IDiceASTNode> expandNode2(VariableDiceNode vnode,
-			Map<String, DiceASTExpression> env) {
-		return env.get(vnode.getVariable()).getAst();
-	}
 }
diff --git a/BJC-Utils2/src/main/java/bjc/utils/dice/ast/DiceASTParser.java b/BJC-Utils2/src/main/java/bjc/utils/dice/ast/DiceASTParser.java
index d56ad0e..b25f5b4 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/dice/ast/DiceASTParser.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/dice/ast/DiceASTParser.java
@@ -8,7 +8,16 @@ import bjc.utils.parserutils.AST;
 import bjc.utils.parserutils.ShuntingYard;
 import bjc.utils.parserutils.TreeConstructor;
 
+/**
+ * Create an AST from a string expression
+ * 
+ * @author ben
+ *
+ */
 public class DiceASTParser {
+	/**
+	 * The yard to use for shunting expressions
+	 */
 	private static ShuntingYard<String> yard;
 
 	static {
@@ -22,14 +31,21 @@ public class DiceASTParser {
 		// expression
 	}
 
+	/**
+	 * Build an AST from a string expression
+	 * 
+	 * @param exp
+	 *            The string to build from
+	 * @return An AST built from the passed in string
+	 */
 	public AST<IDiceASTNode> buildAST(String exp) {
-		FunctionalList<String> tokens = FunctionalStringTokenizer
-				.fromString(exp).toList((s) -> s);
+		FunctionalList<String> tokens =
+				FunctionalStringTokenizer.fromString(exp).toList((s) -> s);
 
 		FunctionalList<String> shunted = yard.postfix(tokens, (s) -> s);
 
-		AST<String> rawAST = TreeConstructor.constructTree(shunted,
-				this::isOperator);
+		AST<String> rawAST =
+				TreeConstructor.constructTree(shunted, this::isOperator);
 
 		AST<IDiceASTNode> bakedAST = rawAST.transmuteAST((tok) -> {
 			if (isOperator(tok)) {
@@ -44,22 +60,14 @@ public class DiceASTParser {
 		return bakedAST;
 	}
 
-	private boolean isOperator(String tok) {
-		switch (tok) {
-			case ":=":
-			case "+":
-			case "-":
-			case "*":
-			case "/":
-			case "c":
-			case "d":
-				return true;
-			default:
-				return false;
-		}
-	}
-
-	private boolean isLiteral(String tok) {
+	/**
+	 * Check if a token represents a literal
+	 * 
+	 * @param tok
+	 *            The token to check
+	 * @return Whether or not the token represents a literal
+	 */
+	private static boolean isLiteral(String tok) {
 		if (StringUtils.countMatches(tok, 'c') == 1
 				&& !tok.equalsIgnoreCase("c")) {
 			return true;
@@ -75,4 +83,26 @@ public class DiceASTParser {
 			}
 		}
 	}
+
+	/**
+	 * Check if a token represents an operator
+	 * 
+	 * @param tok
+	 *            The token to check if it represents an operator
+	 * @return Whether or not the token represents an operator
+	 */
+	private boolean isOperator(String tok) {
+		switch (tok) {
+			case ":=":
+			case "+":
+			case "-":
+			case "*":
+			case "/":
+			case "c":
+			case "d":
+				return true;
+			default:
+				return false;
+		}
+	}
 }
diff --git a/BJC-Utils2/src/main/java/bjc/utils/dice/ast/IDiceASTNode.java b/BJC-Utils2/src/main/java/bjc/utils/dice/ast/IDiceASTNode.java
index 3fb14fe..073da89 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/dice/ast/IDiceASTNode.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/dice/ast/IDiceASTNode.java
@@ -1,5 +1,16 @@
 package bjc.utils.dice.ast;
 
+/**
+ * The interface for a node in a dice AST
+ * 
+ * @author ben
+ *
+ */
 public interface IDiceASTNode {
+	/**
+	 * Check if this node represents an operator or not
+	 * 
+	 * @return Whether or not this node represents an operator
+	 */
 	public boolean isOperator();
 }
diff --git a/BJC-Utils2/src/main/java/bjc/utils/dice/ast/LiteralDiceNode.java b/BJC-Utils2/src/main/java/bjc/utils/dice/ast/LiteralDiceNode.java
index 20358fb..b0c1400 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/dice/ast/LiteralDiceNode.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/dice/ast/LiteralDiceNode.java
@@ -1,8 +1,23 @@
 package bjc.utils.dice.ast;
 
+/**
+ * A AST node that represents a literal value
+ * 
+ * @author ben
+ *
+ */
 public class LiteralDiceNode implements IDiceASTNode {
+	/**
+	 * The value contained by this node
+	 */
 	private String data;
 
+	/**
+	 * Create a new node with the given value
+	 * 
+	 * @param data
+	 *            The value to be in this node
+	 */
 	public LiteralDiceNode(String data) {
 		this.data = data;
 	}
@@ -20,7 +35,12 @@ public class LiteralDiceNode implements IDiceASTNode {
 	public String getData() {
 		return data;
 	}
-	
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see java.lang.Object#toString()
+	 */
 	@Override
 	public String toString() {
 		return data;
diff --git a/BJC-Utils2/src/main/java/bjc/utils/dice/ast/OperatorDiceNode.java b/BJC-Utils2/src/main/java/bjc/utils/dice/ast/OperatorDiceNode.java
index 92b49b7..c4f7763 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/dice/ast/OperatorDiceNode.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/dice/ast/OperatorDiceNode.java
@@ -4,16 +4,51 @@ package bjc.utils.dice.ast;
 // 1. DiceASTExpression
 // 2. DiceASTFlattener
 // 3. DiceASTParser
+/**
+ * A node that represents an operator
+ * 
+ * @author ben
+ *
+ */
 public enum OperatorDiceNode implements IDiceASTNode {
-	ASSIGN, ADD, SUBTRACT, MULTIPLY, DIVIDE, GROUP, COMPOUND;
-	
-	@Override
-	public boolean isOperator() {
-		return true;
-	}
-	
+	/**
+	 * Represents adding two nodes
+	 */
+	ADD,
+	/**
+	 * Represents assigning one node to another
+	 */
+	ASSIGN,
+	/**
+	 * Representings combining two node values together
+	 */
+	COMPOUND,
+	/**
+	 * Represents dividing two nodes
+	 */
+	DIVIDE,
+	/**
+	 * Represents using one node a variable number of times
+	 */
+	GROUP,
+	/**
+	 * Represents multiplying two nodes
+	 */
+	MULTIPLY,
+	/**
+	 * Represents subtracting two nodes
+	 */
+	SUBTRACT;
+
+	/**
+	 * Create a operator node from a string
+	 * 
+	 * @param s
+	 *            The string to convert to a node
+	 * @return The operator corresponding to the node
+	 */
 	public static OperatorDiceNode fromString(String s) {
-		switch(s) {
+		switch (s) {
 			case ":=":
 				return ASSIGN;
 			case "+":
@@ -29,7 +64,18 @@ public enum OperatorDiceNode implements IDiceASTNode {
 			case "c":
 				return COMPOUND;
 			default:
-				throw new IllegalArgumentException(s + " is not a valid operator node");
+				throw new IllegalArgumentException(
+						s + " is not a valid operator node");
 		}
 	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see bjc.utils.dice.ast.IDiceASTNode#isOperator()
+	 */
+	@Override
+	public boolean isOperator() {
+		return true;
+	}
 }
diff --git a/BJC-Utils2/src/main/java/bjc/utils/dice/ast/VariableDiceNode.java b/BJC-Utils2/src/main/java/bjc/utils/dice/ast/VariableDiceNode.java
index 6ae3189..43a09b2 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/dice/ast/VariableDiceNode.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/dice/ast/VariableDiceNode.java
@@ -1,17 +1,27 @@
 package bjc.utils.dice.ast;
 
+/**
+ * A node that represents a variable reference
+ * 
+ * @author ben
+ *
+ */
 public class VariableDiceNode implements IDiceASTNode {
+	/**
+	 * The variable referenced by this node
+	 */
 	private String var;
 
+	/**
+	 * Create a new node representing the specified variable
+	 * 
+	 * @param data
+	 *            The name of the variable being referenced
+	 */
 	public VariableDiceNode(String data) {
 		this.var = data;
 	}
 
-	@Override
-	public boolean isOperator() {
-		return false;
-	}
-
 	/**
 	 * Get the variable referenced by this AST node
 	 * 
@@ -20,7 +30,22 @@ public class VariableDiceNode implements IDiceASTNode {
 	public String getVariable() {
 		return var;
 	}
-	
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see bjc.utils.dice.ast.IDiceASTNode#isOperator()
+	 */
+	@Override
+	public boolean isOperator() {
+		return false;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see java.lang.Object#toString()
+	 */
 	@Override
 	public String toString() {
 		return var;