General code cleanup

2 files changed, 62 insertions, 61 deletions

diff --git a/BJC-Utils2/src/main/java/bjc/utils/gen/RandomGrammar.java b/BJC-Utils2/src/main/java/bjc/utils/gen/RandomGrammar.java
index 0245b17..339b3f4 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/gen/RandomGrammar.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/gen/RandomGrammar.java
@@ -6,9 +6,11 @@ import bjc.utils.funcdata.FunctionalList;
 
 /**
  * A weighted grammar where all the rules have a equal chance of occuring.
+ * 
  * @author ben
  *
- * @param <E> The type of grammar elements to use.
+ * @param <E>
+ *            The type of grammar elements to use.
  */
 public class RandomGrammar<E> extends WeightedGrammar<E> {
 
@@ -21,11 +23,14 @@ public class RandomGrammar<E> extends WeightedGrammar<E> {
 
 	/**
 	 * Add cases to a specified rule.
-	 * @param rule The name of the rule to add cases to.
-	 * @param cases The cases to add for this rule.
+	 * 
+	 * @param rule
+	 *            The name of the rule to add cases to.
+	 * @param cases
+	 *            The cases to add for this rule.
 	 */
 	@SafeVarargs
-	public final void addCases(E rule, FunctionalList<E>... cases) {		
+	public final void addCases(E rule, FunctionalList<E>... cases) {
 		for (FunctionalList<E> cse : cases) {
 			super.addCase(rule, 1, cse);
 		}
@@ -33,13 +38,16 @@ public class RandomGrammar<E> extends WeightedGrammar<E> {
 
 	/**
 	 * Create a rule with the specified name and cases.
-	 * @param rule The name of the rule to add.
-	 * @param cases The cases to add for this rule.
+	 * 
+	 * @param rule
+	 *            The name of the rule to add.
+	 * @param cases
+	 *            The cases to add for this rule.
 	 */
 	@SafeVarargs
 	public final void makeRule(E rule, FunctionalList<E>... cases) {
 		super.addRule(rule);
-		
+
 		for (FunctionalList<E> cse : cases) {
 			super.addCase(rule, 1, cse);
 		}
@@ -47,13 +55,15 @@ public class RandomGrammar<E> extends WeightedGrammar<E> {
 
 	/**
 	 * Create a rule with the specified name and cases.
-	 * @param rule The name of the rule to add.
-	 * @param cases The cases to add for this rule.
+	 * 
+	 * @param rule
+	 *            The name of the rule to add.
+	 * @param cases
+	 *            The cases to add for this rule.
 	 */
-	public void makeRule(E rule,
-			FunctionalList<FunctionalList<E>> cases) {
+	public void makeRule(E rule, FunctionalList<FunctionalList<E>> cases) {
 		super.addRule(rule);
-		
+
 		cases.forEach(cse -> super.addCase(rule, 1, cse));
 	}
 }
diff --git a/BJC-Utils2/src/main/java/bjc/utils/gen/WeightedGrammar.java b/BJC-Utils2/src/main/java/bjc/utils/gen/WeightedGrammar.java
index 7c3ea6a..623c212 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/gen/WeightedGrammar.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/gen/WeightedGrammar.java
@@ -53,6 +53,7 @@ public class WeightedGrammar<E> {
 	 */
 	public WeightedGrammar(Random src) {
 		this();
+
 		sr = src;
 	}
 
@@ -67,9 +68,7 @@ public class WeightedGrammar<E> {
 	 *            The case being added.
 	 */
 	public void addCase(E rule, int prob, FunctionalList<E> cse) {
-		WeightedRandom<FunctionalList<E>> rn = rules.get(rule);
-
-		rn.addProb(prob, cse);
+		rules.get(rule).addProb(prob, cse);
 	}
 
 	/**
@@ -231,32 +230,12 @@ public class WeightedGrammar<E> {
 	}
 
 	/**
-	 * Create a series of alternatives for a rule by prefixing them with a
-	 * given token
+	 * Check if this grammar has an initial rule
 	 * 
-	 * @param addProb
-	 *            The amount to adjust the probability by
-	 * @param rName
-	 *            The name of the rule to prefix
-	 * @param prefixToken
-	 *            The token to prefix to the rule
+	 * @return Whether or not this grammar has an initial rule
 	 */
-	public void prefixRule(E rName, E prefixToken, int addProb) {
-		WeightedRandom<FunctionalList<E>> rule = rules.get(rName);
-
-		FunctionalList<Pair<Integer, FunctionalList<E>>> newResults = new FunctionalList<>();
-
-		rule.getValues().forEach((par) -> {
-			FunctionalList<E> nl = par
-					.merge((left, right) -> right.clone());
-			nl.prepend(prefixToken);
-
-			newResults.add(new Pair<>(
-					par.merge((left, right) -> left) + addProb, nl));
-		});
-
-		newResults.forEach((par) -> par
-				.doWith((left, right) -> addCase(rName, left, right)));
+	public boolean hasInitRule() {
+		return initRule != null && !initRule.equalsIgnoreCase("");
 	}
 
 	/**
@@ -292,17 +271,41 @@ public class WeightedGrammar<E> {
 				nls.add(nl);
 			}
 
-			nls.forEach((ls) -> {
-				newResults.add(new Pair<>(
-						par.merge((left, right) -> left) + addProb, ls));
-			});
+			nls.forEach((ls) -> newResults.add(new Pair<>(
+					par.merge((left, right) -> left) + addProb, ls)));
 		});
 
-		newResults.forEach((par) -> {
-			par.doWith((left, right) -> {
-				addCase(rName, left, right);
-			});
+		newResults.forEach((par) -> par
+				.doWith((left, right) -> addCase(rName, left, right)));
+	}
+
+	/**
+	 * Create a series of alternatives for a rule by prefixing them with a
+	 * given token
+	 * 
+	 * @param addProb
+	 *            The amount to adjust the probability by
+	 * @param rName
+	 *            The name of the rule to prefix
+	 * @param prefixToken
+	 *            The token to prefix to the rule
+	 */
+	public void prefixRule(E rName, E prefixToken, int addProb) {
+		WeightedRandom<FunctionalList<E>> rule = rules.get(rName);
+
+		FunctionalList<Pair<Integer, FunctionalList<E>>> newResults = new FunctionalList<>();
+
+		rule.getValues().forEach((par) -> {
+			FunctionalList<E> nl = par
+					.merge((left, right) -> right.clone());
+			nl.prepend(prefixToken);
+
+			newResults.add(new Pair<>(
+					par.merge((left, right) -> left) + addProb, nl));
 		});
+
+		newResults.forEach((par) -> par
+				.doWith((left, right) -> addCase(rName, left, right)));
 	}
 
 	/**
@@ -376,19 +379,7 @@ public class WeightedGrammar<E> {
 					par.merge((left, right) -> left) + addProb, nl));
 		});
 
-		newResults.forEach((par) -> {
-			par.doWith((left, right) -> {
-				addCase(rName, left, right);
-			});
-		});
-	}
-
-	/**
-	 * Check if this grammar has an initial rule
-	 * 
-	 * @return Whether or not this grammar has an initial rule
-	 */
-	public boolean hasInitRule() {
-		return initRule != null && !initRule.equalsIgnoreCase("");
+		newResults.forEach((par) -> par
+				.doWith((left, right) -> addCase(rName, left, right)));
 	}
 }