1 files changed, 112 insertions, 98 deletions

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 463ad8b..28b61c5 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/gen/WeightedGrammar.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/gen/WeightedGrammar.java
@@ -22,7 +22,7 @@ public class WeightedGrammar<E> {
 	/**
 	 * The initial rule of the grammar
 	 */
-	protected String									initRule;
+	protected String									initialRule;
 
 	/**
 	 * The rules currently in this grammar
@@ -32,7 +32,7 @@ public class WeightedGrammar<E> {
 	/**
 	 * The random number generator used for random numbers
 	 */
-	private Random										sr;
+	private Random										rng;
 
 	/**
 	 * All of the subgrammars of this grammar
@@ -51,13 +51,13 @@ public class WeightedGrammar<E> {
 	 * Create a new weighted grammar that uses the specified source of
 	 * randomness.
 	 * 
-	 * @param src
+	 * @param source
 	 *            The source of randomness to use
 	 */
-	public WeightedGrammar(Random src) {
+	public WeightedGrammar(Random source) {
 		this();
 
-		sr = src;
+		rng = source;
 	}
 
 	/**
@@ -65,13 +65,13 @@ public class WeightedGrammar<E> {
 	 * 
 	 * @param rule
 	 *            The rule to add a case to.
-	 * @param prob
+	 * @param probability
 	 *            The probability for this rule to be chosen.
 	 * @param cse
 	 *            The case being added.
 	 */
-	public void addCase(E rule, int prob, FunctionalList<E> cse) {
-		rules.get(rule).addProb(prob, cse);
+	public void addCase(E rule, int probability, FunctionalList<E> cse) {
+		rules.get(rule).addProbability(probability, cse);
 	}
 
 	/**
@@ -104,10 +104,10 @@ public class WeightedGrammar<E> {
 	 * @return Whether or not the rule was succesfully added.
 	 */
 	public boolean addRule(E name) {
-		if (sr == null) {
-			sr = new Random();
+		if (rng == null) {
+			rng = new Random();
 		}
-		return addRule(name, new WeightedRandom<>(sr));
+		return addRule(name, new WeightedRandom<>(rng));
 	}
 
 	/**
@@ -115,15 +115,16 @@ public class WeightedGrammar<E> {
 	 * 
 	 * @param name
 	 *            The name of the rule to add.
-	 * @param rnd
+	 * @param cases
 	 *            The set of cases for the rule.
 	 * @return Whether or not the rule was succesfully added.
 	 */
-	public boolean addRule(E name, WeightedRandom<FunctionalList<E>> rnd) {
+	public boolean addRule(E name,
+			WeightedRandom<FunctionalList<E>> cases) {
 		if (rules.containsKey(name)) {
 			return false;
 		} else {
-			rules.put(name, rnd);
+			rules.put(name, cases);
 			return true;
 		}
 	}
@@ -133,15 +134,15 @@ public class WeightedGrammar<E> {
 	 * 
 	 * @param name
 	 *            The name of the subgrammar.
-	 * @param subG
+	 * @param subgrammar
 	 *            The subgrammar to add.
 	 * @return Whether or not the subgrammar was succesfully added.
 	 */
-	public boolean addSubGrammar(E name, WeightedGrammar<E> subG) {
+	public boolean addSubgrammar(E name, WeightedGrammar<E> subgrammar) {
 		if (subgrammars.containsKey(name)) {
 			return false;
 		} else {
-			subgrammars.put(name, subG);
+			subgrammars.put(name, subgrammar);
 			return true;
 		}
 	}
@@ -150,20 +151,23 @@ public class WeightedGrammar<E> {
 	 * Generate a set of debug sentences for the specified rule. Only
 	 * generates sentances one layer deep.
 	 * 
-	 * @param rl
+	 * @param ruleName
 	 *            The rule to test.
 	 * @return A set of sentances generated by the specified rule.
 	 */
-	public FunctionalList<FunctionalList<E>> debugVals(E rl) {
-		FunctionalList<FunctionalList<E>> fl = new FunctionalList<>();
+	public FunctionalList<FunctionalList<E>>
+			generateDebugValues(E ruleName) {
+		FunctionalList<FunctionalList<E>> returnedList =
+				new FunctionalList<>();
 
-		WeightedRandom<FunctionalList<E>> random = rules.get(rl);
+		WeightedRandom<FunctionalList<E>> ruleGenerator =
+				rules.get(ruleName);
 
 		for (int i = 0; i < 10; i++) {
-			fl.add(random.genVal());
+			returnedList.add(ruleGenerator.generateValue());
 		}
 
-		return fl;
+		return returnedList;
 	}
 
 	/**
@@ -172,52 +176,55 @@ public class WeightedGrammar<E> {
 	 * @param <T>
 	 *            The type of the transformed output
 	 * 
-	 * @param initRle
+	 * @param initRule
 	 *            The initial rule to start with.
-	 * @param f
+	 * @param tokenTransformer
 	 *            The function to transform grammar output into something.
 	 * @param spacer
 	 *            The spacer element to add in between output tokens.
 	 * @return A randomly generated sentance from the specified initial
 	 *         rule.
 	 */
-	public <T> FunctionalList<T> genGeneric(E initRle, Function<E, T> f,
-			T spacer) {
-		FunctionalList<T> r = new FunctionalList<>();
-
-		if (subgrammars.containsKey(initRle)) {
-			subgrammars.get(initRle).genGeneric(initRle, f, spacer)
-					.forEach(rp -> {
-						r.add(rp);
-						r.add(spacer);
+	public <T> FunctionalList<T> generateGenericValues(E initRule,
+			Function<E, T> tokenTransformer, T spacer) {
+		FunctionalList<T> returnedList = new FunctionalList<>();
+
+		if (subgrammars.containsKey(initRule)) {
+			subgrammars.get(initRule).generateGenericValues(initRule,
+					tokenTransformer, spacer).forEach(rulePart -> {
+						returnedList.add(rulePart);
+						returnedList.add(spacer);
 					});
-		} else if (rules.containsKey(initRle)) {
-			rules.get(initRle).genVal().forEach(
-					rp -> genGeneric(rp, f, spacer).forEach(rp2 -> {
-						r.add(rp2);
-						r.add(spacer);
-					}));
+		} else if (rules.containsKey(initRule)) {
+			rules.get(initRule).generateValue()
+					.forEach(rulePart -> generateGenericValues(rulePart,
+							tokenTransformer, spacer)
+									.forEach(generatedRulePart -> {
+										returnedList
+												.add(generatedRulePart);
+										returnedList.add(spacer);
+									}));
 		} else {
-			r.add(f.apply(initRle));
-			r.add(spacer);
+			returnedList.add(tokenTransformer.apply(initRule));
+			returnedList.add(spacer);
 		}
 
-		return r;
+		return returnedList;
 	}
 
 	/**
 	 * Generate a random list of grammar elements from a given initial
 	 * rule.
 	 * 
-	 * @param initRle
+	 * @param initRule
 	 *            The initial rule to start with.
 	 * @param spacer
 	 *            The item to use to space the list.
 	 * @return A list of random grammar elements generated by the specified
 	 *         rule.
 	 */
-	public FunctionalList<E> genList(E initRle, E spacer) {
-		return genGeneric(initRle, s -> s, spacer);
+	public FunctionalList<E> generateListValues(E initRule, E spacer) {
+		return generateGenericValues(initRule, strang -> strang, spacer);
 	}
 
 	/**
@@ -225,8 +232,8 @@ public class WeightedGrammar<E> {
 	 * 
 	 * @return The initial rule of this grammar
 	 */
-	public String getInitRule() {
-		return initRule;
+	public String getInitialRule() {
+		return initialRule;
 	}
 
 	/**
@@ -236,7 +243,7 @@ public class WeightedGrammar<E> {
 	 *            The name of the subgrammar to get.
 	 * @return The subgrammar with the specified name.
 	 */
-	public WeightedGrammar<E> getSubGrammar(E name) {
+	public WeightedGrammar<E> getSubgrammar(E name) {
 		return subgrammars.get(name);
 	}
 
@@ -245,80 +252,85 @@ public class WeightedGrammar<E> {
 	 * 
 	 * @return Whether or not this grammar has an initial rule
 	 */
-	public boolean hasInitRule() {
-		return initRule != null && !initRule.equalsIgnoreCase("");
+	public boolean hasInitialRule() {
+		return initialRule != null && !initialRule.equalsIgnoreCase("");
 	}
 
 	/**
 	 * Prefix a given rule with a token multiple times
 	 * 
-	 * @param rName
+	 * @param ruleName
 	 *            The name of the rule to prefix
 	 * @param prefixToken
 	 *            The token to prefix to the rules
-	 * @param addProb
+	 * @param additionalProbability
 	 *            The additional probability of the tokens
-	 * @param nTimes
+	 * @param numberOfTimes
 	 *            The number of times to prefix the token
 	 */
-	public void multiPrefixRule(E rName, E prefixToken, int addProb,
-			int nTimes) {
-		WeightedRandom<FunctionalList<E>> rule = rules.get(rName);
+	public void multiPrefixRule(E ruleName, E prefixToken,
+			int additionalProbability, int numberOfTimes) {
+		WeightedRandom<FunctionalList<E>> rule = rules.get(ruleName);
 
 		FunctionalList<Pair<Integer, FunctionalList<E>>> newResults =
 				new FunctionalList<>();
 
-		rule.getValues().forEach((par) -> {
-			FunctionalList<FunctionalList<E>> nls = new FunctionalList<>();
+		rule.getValues().forEach((pair) -> {
+			FunctionalList<FunctionalList<E>> newRule =
+					new FunctionalList<>();
 
-			// TODO bugtest this. if it works, write multiSuffixWith
-			for (int i = 1; i <= nTimes; i++) {
-				FunctionalList<E> nl =
-						par.merge((left, right) -> right.clone());
+			for (int i = 1; i <= numberOfTimes; i++) {
+				FunctionalList<E> newCase =
+						pair.merge((left, right) -> right.clone());
 
 				for (int j = 1; j <= i; j++) {
-					nl.prepend(prefixToken);
+					newCase.prepend(prefixToken);
 				}
 
-				nls.add(nl);
+				newRule.add(newCase);
 			}
 
-			nls.forEach((ls) -> newResults.add(new Pair<>(
-					par.merge((left, right) -> left) + addProb, ls)));
+			newRule.forEach(
+					(list) -> newResults
+							.add(new Pair<>(
+									pair.merge((left, right) -> left)
+											+ additionalProbability,
+									list)));
 		});
 
-		newResults.forEach((par) -> par
-				.doWith((left, right) -> addCase(rName, left, right)));
+		newResults.forEach((pair) -> pair
+				.doWith((left, right) -> addCase(ruleName, left, right)));
 	}
 
 	/**
 	 * Create a series of alternatives for a rule by prefixing them with a
 	 * given token
 	 * 
-	 * @param addProb
+	 * @param additionalProbability
 	 *            The amount to adjust the probability by
-	 * @param rName
+	 * @param ruleName
 	 *            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);
+	public void prefixRule(E ruleName, E prefixToken,
+			int additionalProbability) {
+		WeightedRandom<FunctionalList<E>> rule = rules.get(ruleName);
 
 		FunctionalList<Pair<Integer, FunctionalList<E>>> newResults =
 				new FunctionalList<>();
 
-		rule.getValues().forEach((par) -> {
-			FunctionalList<E> nl =
-					par.merge((left, right) -> right.clone());
-			nl.prepend(prefixToken);
+		rule.getValues().forEach((pair) -> {
+			FunctionalList<E> newCase =
+					pair.merge((left, right) -> right.clone());
+			newCase.prepend(prefixToken);
 
-			newResults.add(new Pair<>(
-					par.merge((left, right) -> left) + addProb, nl));
+			newResults.add(new Pair<>(pair.merge((left, right) -> left)
+					+ additionalProbability, newCase));
 		});
 
-		newResults.forEach((par) -> par
-				.doWith((left, right) -> addCase(rName, left, right)));
+		newResults.forEach((pair) -> pair
+				.doWith((left, right) -> addCase(ruleName, left, right)));
 	}
 
 	/**
@@ -327,7 +339,7 @@ public class WeightedGrammar<E> {
 	 * @param name
 	 *            The name of the rule to remove.
 	 */
-	public void removeRule(E name) {
+	public void deleteRule(E name) {
 		rules.remove(name);
 	}
 
@@ -337,7 +349,7 @@ public class WeightedGrammar<E> {
 	 * @param name
 	 *            The name of the subgrammar to remove.
 	 */
-	public void removeSubgrammar(E name) {
+	public void deleteSubgrammar(E name) {
 		subgrammars.remove(name);
 	}
 
@@ -346,7 +358,7 @@ public class WeightedGrammar<E> {
 	 * 
 	 * @return The number of rules in this grammar
 	 */
-	public int ruleCount() {
+	public int getRuleCount() {
 		return rules.size();
 	}
 
@@ -355,7 +367,7 @@ public class WeightedGrammar<E> {
 	 * 
 	 * @return The set of all rule names in this grammar
 	 */
-	public Set<E> ruleNames() {
+	public Set<E> getRuleNames() {
 		return rules.keySet();
 	}
 
@@ -363,37 +375,39 @@ public class WeightedGrammar<E> {
 	 * Set the initial rule of the graphic
 	 * 
 	 * @param initRule
+	 *            The initial rule of this grammar
 	 */
-	public void setInitRule(String initRule) {
-		this.initRule = initRule;
+	public void setInitialRule(String initRule) {
+		this.initialRule = initRule;
 	}
 
 	/**
 	 * Suffix a token to a rule
 	 * 
-	 * @param rName
+	 * @param ruleName
 	 *            The rule to suffix
 	 * @param prefixToken
 	 *            The token to prefix to the rule
-	 * @param addProb
+	 * @param additionalProbability
 	 *            Additional probability of the prefixed rule
 	 */
-	public void suffixRule(E rName, E prefixToken, int addProb) {
-		WeightedRandom<FunctionalList<E>> rule = rules.get(rName);
+	public void suffixRule(E ruleName, E prefixToken,
+			int additionalProbability) {
+		WeightedRandom<FunctionalList<E>> rule = rules.get(ruleName);
 
 		FunctionalList<Pair<Integer, FunctionalList<E>>> newResults =
 				new FunctionalList<>();
 
 		rule.getValues().forEach((par) -> {
-			FunctionalList<E> nl =
+			FunctionalList<E> newCase =
 					par.merge((left, right) -> right.clone());
-			nl.add(prefixToken);
+			newCase.add(prefixToken);
 
-			newResults.add(new Pair<>(
-					par.merge((left, right) -> left) + addProb, nl));
+			newResults.add(new Pair<>(par.merge((left, right) -> left)
+					+ additionalProbability, newCase));
 		});
 
-		newResults.forEach((par) -> par
-				.doWith((left, right) -> addCase(rName, left, right)));
+		newResults.forEach((pair) -> pair
+				.doWith((left, right) -> addCase(ruleName, left, right)));
 	}
-}
+}
\ No newline at end of file