Grammar optimization

Grammars now only consider things in []'s as rule references

2 files changed, 114 insertions, 132 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 062802c..90b37f8 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/gen/WeightedGrammar.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/gen/WeightedGrammar.java
@@ -23,7 +23,7 @@ public class WeightedGrammar<E> {
 	/**
 	 * The initial rule of the grammar
 	 */
-	protected String							initialRule;
+	protected String initialRule;
 
 	/**
 	 * The rules currently in this grammar
@@ -33,12 +33,12 @@ public class WeightedGrammar<E> {
 	/**
 	 * The random number generator used for random numbers
 	 */
-	private Random								rng;
+	private Random rng;
 
 	/**
 	 * All of the subgrammars of this grammar
 	 */
-	protected IMap<E, WeightedGrammar<E>>		subgrammars;
+	protected IMap<E, WeightedGrammar<E>> subgrammars;
 
 	/**
 	 * Create a new weighted grammar.
@@ -59,8 +59,7 @@ public class WeightedGrammar<E> {
 		this();
 
 		if (source == null) {
-			throw new NullPointerException(
-					"Source of randomness must be non-null");
+			throw new NullPointerException("Source of randomness must be non-null");
 		}
 
 		rng = source;
@@ -97,11 +96,9 @@ public class WeightedGrammar<E> {
 	 */
 	public boolean addGrammarAlias(E name, E alias) {
 		if (name == null) {
-			throw new NullPointerException(
-					"Subgrammar name must not be null");
+			throw new NullPointerException("Subgrammar name must not be null");
 		} else if (alias == null) {
-			throw new NullPointerException(
-					"Subgrammar alias must not be null");
+			throw new NullPointerException("Subgrammar alias must not be null");
 		}
 
 		if (subgrammars.containsKey(alias)) {
@@ -170,8 +167,7 @@ public class WeightedGrammar<E> {
 	 */
 	public boolean addSubgrammar(E name, WeightedGrammar<E> subgrammar) {
 		if (name == null) {
-			throw new NullPointerException(
-					"Subgrammar name must not be null");
+			throw new NullPointerException("Subgrammar name must not be null");
 		} else if (subgrammar == null) {
 			throw new NullPointerException("Subgrammar must not be null");
 		}
@@ -213,8 +209,9 @@ public class WeightedGrammar<E> {
 	}
 
 	/**
-	 * Generate a set of debug sentences for the specified rule. Only
-	 * generates sentances one layer deep.
+	 * Generate a set of debug sentences for the specified rule.
+	 *
+	 * Only generates sentances one layer deep.
 	 * 
 	 * @param ruleName
 	 *            The rule to test.
@@ -251,11 +248,9 @@ public class WeightedGrammar<E> {
 	 * @return A randomly generated sentance from the specified initial
 	 *         rule.
 	 */
-	public <T> IList<T> generateGenericValues(E initRule,
-			Function<E, T> tokenTransformer, T spacer) {
+	public <T> IList<T> generateGenericValues(E initRule, Function<E, T> tokenTransformer, T spacer) {
 		if (initRule == null) {
-			throw new NullPointerException(
-					"Initial rule must not be null");
+			throw new NullPointerException("Initial rule must not be null");
 		} else if (tokenTransformer == null) {
 			throw new NullPointerException("Transformer must not be null");
 		} else if (spacer == null) {
@@ -265,26 +260,37 @@ public class WeightedGrammar<E> {
 		IList<T> returnedList = new FunctionalList<>();
 
 		if (subgrammars.containsKey(initRule)) {
-			subgrammars.get(initRule).generateGenericValues(initRule,
-					tokenTransformer, spacer).forEach(rulePart -> {
+			subgrammars.get(initRule)
+				.generateGenericValues(initRule, tokenTransformer, spacer)
+				.forEach(rulePart -> {
 						returnedList.add(rulePart);
 						returnedList.add(spacer);
 					});
 		} else if (rules.containsKey(initRule)) {
-			rules.get(initRule).generateValue()
-					.forEach(rulePart -> generateGenericValues(rulePart,
-							tokenTransformer, spacer)
-									.forEach(generatedRulePart -> {
-										returnedList
-												.add(generatedRulePart);
+			rules.get(initRule)
+				 .generateValue().forEach(rulePart -> {
+					 if(rulePart.matches("\\[\\S+\\]") {
+						 generateGenericValues(rulePart, tokenTransformer, spacer)
+							 .forEach(generatedRulePart -> {
+										returnedList.add(generatedRulePart);
 										returnedList.add(spacer);
-									}));
+								});
+					 } else {
+						 T transformedToken = tokenTransformer.apply(initRule);
+
+						 if (transformedToken == null) {
+							 throw new NullPointerException("Transformer created null token");
+						 }
+
+						 returnedList.add(transformedToken);
+						 returnedList.add(spacer);
+					 }
+				});
 		} else {
 			T transformedToken = tokenTransformer.apply(initRule);
 
 			if (transformedToken == null) {
-				throw new NullPointerException(
-						"Transformer created null token");
+				throw new NullPointerException("Transformer created null token");
 			}
 
 			returnedList.add(transformedToken);
@@ -345,8 +351,7 @@ public class WeightedGrammar<E> {
 	 */
 	public WeightedGrammar<E> getSubgrammar(E name) {
 		if (name == null) {
-			throw new NullPointerException(
-					"Subgrammar name must not be null");
+			throw new NullPointerException("Subgrammar name must not be null");
 		}
 
 		return subgrammars.get(name);
@@ -378,17 +383,14 @@ public class WeightedGrammar<E> {
 		if (ruleName == null) {
 			throw new NullPointerException("Rule name must not be null");
 		} else if (prefixToken == null) {
-			throw new NullPointerException(
-					"Prefix token must not be null");
+			throw new NullPointerException("Prefix token must not be null");
 		} else if (numberOfTimes < 1) {
-			throw new IllegalArgumentException(
-					"Number of times to prefix must be positive.");
+			throw new IllegalArgumentException("Number of times to prefix must be positive.");
 		}
 
 		WeightedRandom<IList<E>> rule = rules.get(ruleName);
 
-		IList<IPair<Integer,
-				IList<E>>> newResults = new FunctionalList<>();
+		IList<IPair<Integer, IList<E>>> newResults = new FunctionalList<>();
 
 		rule.getValues().forEach((pair) -> {
 			IList<IList<E>> newRule = new FunctionalList<>();
@@ -414,8 +416,7 @@ public class WeightedGrammar<E> {
 			newRule.forEach((list) -> {
 				Integer currentProb = pair.merge((left, right) -> left);
 
-				newResults.add(new Pair<>(
-						currentProb + additionalProbability, list));
+				newResults.add(new Pair<>(currentProb + additionalProbability, list));
 			});
 		});
 
@@ -437,19 +438,16 @@ public class WeightedGrammar<E> {
 	 * @param prefixToken
 	 *            The token to prefix to the rule
 	 */
-	public void prefixRule(E ruleName, E prefixToken,
-			int additionalProbability) {
+	public void prefixRule(E ruleName, E prefixToken, int additionalProbability) {
 		if (ruleName == null) {
 			throw new NullPointerException("Rule name must not be null");
 		} else if (prefixToken == null) {
-			throw new NullPointerException(
-					"Prefix token must not be null");
+			throw new NullPointerException("Prefix token must not be null");
 		}
 
 		WeightedRandom<IList<E>> rule = rules.get(ruleName);
 
-		IList<IPair<Integer,
-				IList<E>>> newResults = new FunctionalList<>();
+		IList<IPair<Integer, IList<E>>> newResults = new FunctionalList<>();
 
 		rule.getValues().forEach((pair) -> {
 			IList<E> newCase = pair.merge((left, right) -> {
@@ -464,12 +462,12 @@ public class WeightedGrammar<E> {
 
 			newCase.prepend(prefixToken);
 
-			newResults.add(new Pair<>(pair.merge((left, right) -> left)
-					+ additionalProbability, newCase));
+			newResults.add(new Pair<>(pair.merge((left, right) -> left) + additionalProbability, newCase));
 		});
 
-		newResults.forEach((pair) -> pair
-				.doWith((left, right) -> addCase(ruleName, left, right)));
+		newResults.forEach((pair) -> 
+				pair.doWith((left, right) ->
+					addCase(ruleName, left, right)));
 	}
 
 	/**
@@ -492,19 +490,16 @@ public class WeightedGrammar<E> {
 	 * @param additionalProbability
 	 *            Additional probability of the prefixed rule
 	 */
-	public void suffixRule(E ruleName, E suffixToken,
-			int additionalProbability) {
+	public void suffixRule(E ruleName, E suffixToken, int additionalProbability) {
 		if (ruleName == null) {
 			throw new NullPointerException("Rule name must not be null");
 		} else if (suffixToken == null) {
-			throw new NullPointerException(
-					"Prefix token must not be null");
+			throw new NullPointerException("Prefix token must not be null");
 		}
 
 		WeightedRandom<IList<E>> rule = rules.get(ruleName);
 
-		IList<IPair<Integer,
-				IList<E>>> newResults = new FunctionalList<>();
+		IList<IPair<Integer, IList<E>>> newResults = new FunctionalList<>();
 
 		rule.getValues().forEach((par) -> {
 			IList<E> newCase = par.merge((left, right) -> {
@@ -516,13 +511,14 @@ public class WeightedGrammar<E> {
 
 				return returnVal;
 			});
+
 			newCase.add(suffixToken);
 
-			newResults.add(new Pair<>(par.merge((left, right) -> left)
-					+ additionalProbability, newCase));
+			newResults.add(new Pair<>(par.merge((left, right) -> left) + additionalProbability, newCase));
 		});
 
-		newResults.forEach((pair) -> pair
-				.doWith((left, right) -> addCase(ruleName, left, right)));
+		newResults.forEach((pair) -> 
+				pair.doWith((left, right) ->
+					addCase(ruleName, left, right)));
 	}
-}
\ No newline at end of file
+}
diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/RuleBasedConfigReader.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/RuleBasedConfigReader.java
index 9da76f8..cbcc6d8 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/RuleBasedConfigReader.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/parserutils/RuleBasedConfigReader.java
@@ -28,40 +28,37 @@ import bjc.utils.funcdata.IMap;
 public class RuleBasedConfigReader<E> {
 	// Function to execute when starting a rule
 	// Takes the tokenizer, and a pair of the read token and application state
-	private BiConsumer<FunctionalStringTokenizer, IPair<String,
-			E>>														startRule;
+	private BiConsumer<FunctionalStringTokenizer, IPair<String, E>> start;
+	
 	// Function to use when continuing a rule
 	// Takes a tokenizer and application state
-	private BiConsumer<FunctionalStringTokenizer,
-			E>														continueRule;
+	private BiConsumer<FunctionalStringTokenizer, E> continueRule;
+
 	// Function to use when ending a rule
 	// Takes an application state
-	private Consumer<
-			E>														endRule;
+	private Consumer<E> end;
 
 	// Map of pragma names to pragma actions
 	// Pragma actions are functions taking a tokenizer and application state
-	private IMap<String, BiConsumer<FunctionalStringTokenizer,
-			E>>														pragmas;
+	private IMap<String, BiConsumer<FunctionalStringTokenizer, E>> pragmas;
 
 	/**
 	 * Create a new rule-based config reader
 	 * 
-	 * @param startRule
+	 * @param start
 	 *            The action to fire when starting a rule
 	 * @param continueRule
 	 *            The action to fire when continuing a rule
-	 * @param endRule
+	 * @param end
 	 *            The action to fire when ending a rule
 	 */
 	public RuleBasedConfigReader(
-			BiConsumer<FunctionalStringTokenizer,
-					IPair<String, E>> startRule,
+			BiConsumer<FunctionalStringTokenizer, IPair<String, E>> start,
 			BiConsumer<FunctionalStringTokenizer, E> continueRule,
-			Consumer<E> endRule) {
-		this.startRule = startRule;
+			Consumer<E> end) {
+		this.start = start;
 		this.continueRule = continueRule;
-		this.endRule = endRule;
+		this.end = end;
 
 		this.pragmas = new FunctionalMap<>();
 	}
@@ -69,50 +66,45 @@ public class RuleBasedConfigReader<E> {
 	/**
 	 * Add a pragma to this reader
 	 * 
-	 * @param pragmaName
+	 * @param name
 	 *            The name of the pragma to add
-	 * @param pragmaAction
+	 * @param action
 	 *            The function to execute when this pragma is read
 	 */
-	public void addPragma(String pragmaName,
-			BiConsumer<FunctionalStringTokenizer, E> pragmaAction) {
-		if (pragmaName == null) {
+	public void addPragma(
+			String name,
+			BiConsumer<FunctionalStringTokenizer, E> action) {
+		if (name == null) {
 			throw new NullPointerException("Pragma name must not be null");
-		} else if (pragmaAction == null) {
-			throw new NullPointerException(
-					"Pragma action must not be null");
+		} else if (action == null) {
+			throw new NullPointerException("Pragma action must not be null");
 		}
 
-		pragmas.put(pragmaName, pragmaAction);
+		pragmas.put(name, action);
 	}
 
-	private void continueRule(E state, boolean ruleOpen, String line) {
+	private void continueRule(E state, boolean isRuleOpen, String line) {
 		// Make sure our input is correct
-		if (ruleOpen == false) {
-			throw new InputMismatchException(
-					"Can't continue rule with no rule currently open");
+		if (isRuleOpen == false) {
+			throw new InputMismatchException("Cannot continue rule with no rule open");
 		} else if (continueRule == null) {
-			throw new InputMismatchException(
-					"Attempted to continue rule with rule continuation disabled."
-							+ " Check for extraneous tabs");
+			throw new InputMismatchException("Rule continuation not supported for current grammar");
 		}
 
 		// Accept the rule
-		continueRule.accept(
-				new FunctionalStringTokenizer(line.substring(1), " "),
-				state);
-		}
+		continueRule.accept(new FunctionalStringTokenizer(line.substring(1), " "), state);
+	}
 
-	private boolean endRule(E state, boolean ruleOpen) {
+	private boolean endRule(E state, boolean isRuleOpen) {
 		// Ignore blank line without an open rule
-		if (ruleOpen == false) {
+		if (isRuleOpen == false) {
 			// Do nothing
 			return false;
 		} else {
 			// Nothing happens on rule end
-			if (endRule != null) {
+			if (end != null) {
 				// Process the rule ending
-				endRule.accept(state);
+				end.accept(state);
 			}
 
 			// Return a closed rule
@@ -123,42 +115,42 @@ public class RuleBasedConfigReader<E> {
 	/**
 	 * Run a stream through this reader
 	 * 
-	 * @param inputStream
+	 * @param input
 	 *            The stream to get input
 	 * @param initialState
 	 *            The initial state of the reader
 	 * @return The final state of the reader
 	 */
-	public E fromStream(InputStream inputStream, E initialState) {
-		if (inputStream == null) {
-			throw new NullPointerException(
-					"Input stream must not be null");
+	public E fromStream(InputStream input, E initialState) {
+		if (input == null) {
+			throw new NullPointerException("Input stream must not be null");
 		}
 
 		// Application state: We're giving this back later
 		E state = initialState;
 
 		// Prepare our input source
-		try (Scanner inputSource = new Scanner(inputStream, "\n")) {
+		try (Scanner source = new Scanner(input, "\n")) {
 			// This is true when a rule's open
-			IHolder<Boolean> ruleOpen = new Identity<>(false);
+			IHolder<Boolean> isRuleOpen = new Identity<>(false);
 
 			// Do something for every line of the file
-			inputSource.forEachRemaining((line) -> {
+			source.forEachRemaining((line) -> {
 				// Skip comment lines
 				if (line.startsWith("#") || line.startsWith("//")) {
 					// It's a comment
 					return;
 				} else if (line.equals("")) {
 					// End the rule
-					ruleOpen.replace(endRule(state, ruleOpen.getValue()));
+					isRuleOpen.replace(
+							endRule(state, isRuleOpen.getValue()));
 				} else if (line.startsWith("\t")) {
 					// Continue the rule
-					continueRule(state, ruleOpen.getValue(), line);
+					continueRule(state, isRuleOpen.getValue(), line);
 				} else {
 					// Open a rule
-					ruleOpen.replace(
-							startRule(state, ruleOpen.getValue(), line));
+					isRuleOpen.replace(
+							startRule(state, isRuleOpen.getValue(), line));
 				}
 			});
 		}
@@ -182,33 +174,30 @@ public class RuleBasedConfigReader<E> {
 	/**
 	 * Set the action to execute when ending a rule
 	 * 
-	 * @param endRule
+	 * @param end
 	 *            The action to execute on ending of a rule
 	 */
-	public void setEndRule(Consumer<E> endRule) {
-		this.endRule = endRule;
+	public void setEndRule(Consumer<E> end) {
+		this.end = end;
 	}
 
 	/**
 	 * Set the action to execute when starting a rule
 	 * 
-	 * @param startRule
+	 * @param start
 	 *            The action to execute on starting of a rule
 	 */
-	public void setStartRule(BiConsumer<FunctionalStringTokenizer,
-			IPair<String, E>> startRule) {
-		if (startRule == null) {
-			throw new NullPointerException(
-					"Action on rule start must be non-null");
+	public void setStartRule(BiConsumer<FunctionalStringTokenizer, IPair<String, E>> start) {
+		if (start == null) {
+			throw new NullPointerException("Action on rule start must be non-null");
 		}
 
-		this.startRule = startRule;
+		this.start = start;
 	}
 
-	private boolean startRule(E state, boolean ruleOpen, String line) {
+	private boolean startRule(E state, boolean isRuleOpen, String line) {
 		// Create the line tokenizer
-		FunctionalStringTokenizer tokenizer = new FunctionalStringTokenizer(
-				line, " ");
+		FunctionalStringTokenizer tokenizer = new FunctionalStringTokenizer(line, " ");
 
 		// Get the initial token
 		String nextToken = tokenizer.nextToken();
@@ -220,23 +209,20 @@ public class RuleBasedConfigReader<E> {
 
 			// Handle pragmas
 			pragmas.getOrDefault(token, (tokenzer, stat) -> {
-				throw new UnknownPragmaException(
-						"Unknown pragma " + token);
+				throw new UnknownPragmaException("Unknown pragma " + token);
 			}).accept(tokenizer, state);
 		} else {
 			// Make sure input is correct
-			if (ruleOpen == true) {
-				throw new InputMismatchException("Attempted to open a"
-						+ " rule with a rule already open. Make sure rules are"
-						+ " seperated by blank lines");
+			if (isRuleOpen == true) {
+				throw new InputMismatchException("Nested rules are currently not supported");
 			}
 
 			// Start a rule
-			startRule.accept(tokenizer, new Pair<>(nextToken, state));
+			start.accept(tokenizer, new Pair<>(nextToken, state));
 
-			ruleOpen = true;
+			isRuleOpen = true;
 		}
 
-		return ruleOpen;
+		return isRuleOpen;
 	}
 }