From c82e3b3b2de0633317ec8fc85925e91422820597 Mon Sep 17 00:00:00 2001 From: "Benjamin J. Culkin" Date: Sun, 8 Oct 2017 22:39:59 -0300 Subject: Start splitting into maven modules --- .../java/bjc/utils/examples/AbbrevMapTest.java | 59 +++ .../java/bjc/utils/examples/BinarySearchTest.java | 123 +++++ .../java/bjc/utils/examples/DelimSplitterTest.java | 504 +++++++++++++++++++++ .../java/bjc/utils/examples/ShuntTest.java | 37 ++ .../bjc/utils/examples/rangen/DiabloItemGen.java | 94 ++++ .../examples/rangen/RandomStringExamples.java | 64 +++ .../bjc/utils/examples/sample-ds-files/html.ds | 10 + .../bjc/utils/examples/sample-ds-files/json.ds | 23 + .../src/examples/java/bjc/utils/examples/test.tree | 13 + 9 files changed, 927 insertions(+) create mode 100644 base/src/examples/java/bjc/utils/examples/AbbrevMapTest.java create mode 100644 base/src/examples/java/bjc/utils/examples/BinarySearchTest.java create mode 100644 base/src/examples/java/bjc/utils/examples/DelimSplitterTest.java create mode 100644 base/src/examples/java/bjc/utils/examples/ShuntTest.java create mode 100644 base/src/examples/java/bjc/utils/examples/rangen/DiabloItemGen.java create mode 100644 base/src/examples/java/bjc/utils/examples/rangen/RandomStringExamples.java create mode 100644 base/src/examples/java/bjc/utils/examples/sample-ds-files/html.ds create mode 100644 base/src/examples/java/bjc/utils/examples/sample-ds-files/json.ds create mode 100644 base/src/examples/java/bjc/utils/examples/test.tree (limited to 'base/src/examples') diff --git a/base/src/examples/java/bjc/utils/examples/AbbrevMapTest.java b/base/src/examples/java/bjc/utils/examples/AbbrevMapTest.java new file mode 100644 index 0000000..ac4ea76 --- /dev/null +++ b/base/src/examples/java/bjc/utils/examples/AbbrevMapTest.java @@ -0,0 +1,59 @@ +package bjc.utils.examples; + +import java.util.Scanner; + +import bjc.utils.esodata.AbbrevMap; +import bjc.utils.funcutils.StringUtils; + +/** + * Test for abbreviation map. + * + * @author EVE + * + */ +public class AbbrevMapTest { + /** + * Main method. + * + * @param args + * Unused CLI args. + */ + public static void main(final String[] args) { + final Scanner scn = new Scanner(System.in); + + final AbbrevMap map = new AbbrevMap(); + + System.out.print("Enter a command (blank line to quit): "); + String ln = scn.nextLine(); + + while (!ln.equals("")) { + final String[] commParts = ln.split(" "); + + switch (commParts[0]) { + case "add": + map.addWords(commParts[1]); + break; + case "remove": + map.removeWords(commParts[1]); + break; + case "recalc": + map.recalculate(); + break; + case "check": + final String list = StringUtils.toEnglishList(map.deabbrev(commParts[1]), false); + System.out.println(list); + break; + case "debug": + System.out.println(map.toString()); + break; + default: + System.out.println("Unknown command: " + ln); + } + + System.out.print("Enter a command (blank line to quit): "); + ln = scn.nextLine(); + } + + scn.close(); + } +} diff --git a/base/src/examples/java/bjc/utils/examples/BinarySearchTest.java b/base/src/examples/java/bjc/utils/examples/BinarySearchTest.java new file mode 100644 index 0000000..758af61 --- /dev/null +++ b/base/src/examples/java/bjc/utils/examples/BinarySearchTest.java @@ -0,0 +1,123 @@ +package bjc.utils.examples; + +import java.util.Scanner; + +import bjc.utils.funcdata.bst.BinarySearchTree; +import bjc.utils.funcdata.bst.TreeLinearizationMethod; + +/** + * Example showing how to use the binary search tree. + * + * @author ben + * + */ +public class BinarySearchTest { + private static void display(final BinarySearchTree tree, final Scanner input) { + System.out.print("What order would you like the tree to be printed in (m for options): "); + char command; + + while (true) { + command = input.nextLine().charAt(0); + TreeLinearizationMethod method = null; + + switch (command) { + case 'm': + System.out.println("Possible tree printing methods: "); + System.out.println("\tp: Preorder printing (print parent first, then left & right)."); + System.out.println("\ti: Inorder printing (print left first, then parent & right)."); + System.out.println("\to: Postorder printing (print left first, then right & parent)."); + break; + case 'p': + method = TreeLinearizationMethod.PREORDER; + break; + case 'i': + method = TreeLinearizationMethod.INORDER; + break; + case 'o': + method = TreeLinearizationMethod.POSTORDER; + break; + default: + System.out.println("ERROR: Unknown command."); + } + + if (method != null) { + tree.traverse(method, (element) -> { + System.out.println("Node: " + element); + return true; + }); + + return; + } + + System.out.print("What order would you like the tree to be printed in (m for options): "); + } + } + + /** + * Main method of class + * + * @param args + * Unused CLI args + */ + public static void main(final String[] args) { + final Scanner input = new Scanner(System.in); + System.out.println("Binary Tree Constructor/Searcher"); + final BinarySearchTree tree = new BinarySearchTree<>((o1, o2) -> o1 - o2); + + char command = ' '; + while (command != 'e') { + System.out.print("Enter a command (m for help): "); + command = input.nextLine().charAt(0); + + switch (command) { + case 'm': + System.out.println("Valid commands: "); + System.out.println("\tm: Display this help message."); + System.out.println("\te: Exit this program."); + System.out.println("\ta: Add a node to the binary tree."); + System.out.println("\td: Display the binary tree."); + System.out.println("\tr: Remove a node from the binary tree."); + System.out.println("\tf: Check if a given node is in the binary tree."); + System.out.println("\tt: Trim all deleted nodes from the tree."); + System.out.println("\tb: Balance the tree (also trims dead nodes)"); + break; + case 'a': + System.out.print("Enter the letter to add to the binary tree: "); + command = input.nextLine().charAt(0); + + tree.addNode(command); + break; + case 'r': + System.out.print("Enter the letter to add to the binary tree: "); + command = input.nextLine().charAt(0); + + tree.deleteNode(command); + break; + case 'd': + display(tree, input); + break; + case 'f': + System.out.print("Enter the letter to add to the binary tree: "); + command = input.nextLine().charAt(0); + + final boolean inTree = tree.isInTree(command); + if (inTree) { + System.out.printf("Node %s was found\n", command); + } else { + System.out.printf("Node %s was not found\n", command); + } + break; + case 't': + tree.trim(); + break; + case 'b': + tree.balance(); + break; + default: + System.out.println("ERROR: Unrecognized command."); + } + } + + input.close(); + } +} diff --git a/base/src/examples/java/bjc/utils/examples/DelimSplitterTest.java b/base/src/examples/java/bjc/utils/examples/DelimSplitterTest.java new file mode 100644 index 0000000..428f276 --- /dev/null +++ b/base/src/examples/java/bjc/utils/examples/DelimSplitterTest.java @@ -0,0 +1,504 @@ +package bjc.utils.examples; + +import java.io.FileInputStream; +import java.io.FileNotFoundException; +import java.io.IOException; +import java.io.InputStream; +import java.util.Arrays; +import java.util.HashMap; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; +import java.util.Scanner; + +import bjc.utils.data.ITree; +import bjc.utils.funcdata.FunctionalList; +import bjc.utils.funcdata.IList; +import bjc.utils.funcutils.StringUtils; +import bjc.utils.parserutils.delims.DelimiterException; +import bjc.utils.parserutils.delims.DelimiterGroup; +import bjc.utils.parserutils.delims.RegexCloser; +import bjc.utils.parserutils.delims.RegexOpener; +import bjc.utils.parserutils.delims.SequenceDelimiter; +import bjc.utils.parserutils.delims.StringDelimiter; +import bjc.utils.parserutils.splitter.ConfigurableTokenSplitter; + +/** + * Test for {@link SequenceDelimiter} as well as + * {@link ConfigurableTokenSplitter} + * + * @author EVE + * + */ +public class DelimSplitterTest { + private ConfigurableTokenSplitter split; + + private StringDelimiter dlm; + + private Map mirrored; + + private Map> groups; + + boolean verbose; + + /* + * Create a new tester. + */ + private DelimSplitterTest() { + loadMirrorDB(); + + groups = new HashMap<>(); + + split = new ConfigurableTokenSplitter(true); + + dlm = new StringDelimiter(); + + verbose = true; + } + + private void loadMirrorDB() { + mirrored = new HashMap<>(); + + final InputStream stream = getClass().getResourceAsStream("/BidiMirrorDB.txt"); + + try (Scanner scn = new Scanner(stream)) { + String ln = ""; + + while (scn.hasNextLine()) { + ln = scn.nextLine(); + + if (ln.equals("")) { + continue; + } + if (ln.startsWith("#")) { + continue; + } + + final int cp1 = Integer.parseInt(ln.substring(0, 4), 16); + final int cp2 = Integer.parseInt(ln.substring(6, 10), 16); + + final char[] cpa1 = Character.toChars(cp1); + final char[] cpa2 = Character.toChars(cp2); + + final String cps1 = new String(cpa1); + final String cps2 = new String(cpa2); + + mirrored.put(cps1, cps2); + } + } + } + + /* + * Run the tester interface. + */ + private void runLoop() { + final Scanner scn = new Scanner(System.in); + + System.out.print("Enter a command (blank line to quit): "); + String inp = scn.nextLine().trim(); + System.out.println(); + + while (!inp.equals("")) { + handleCommand(inp, scn, true); + + System.out.println(); + + System.out.print("Enter a command (blank line to quit): "); + inp = scn.nextLine(); + + System.out.println(); + } + + scn.close(); + } + + /* + * Handle a input command. + */ + private void handleCommand(final String inp, final Scanner scn, final boolean isInteractive) { + if (inp.equals("")) return; + + int idx = inp.indexOf(' '); + + if (idx == -1) { + idx = inp.length(); + } + + final String command = inp.substring(0, idx); + + final String args = inp.substring(idx).trim(); + final String[] argArray = args.split(" "); + + switch (command) { + case "test": + handleTest(args, false); + break; + case "test-ws": + handleTest(args, true); + break; + case "splitter-split": + handleSplit(argArray); + break; + case "splitter-compile": + split.compile(); + if (verbose) { + System.out.println("Compiled splitter"); + } + break; + case "splitter-add": + split.addSimpleDelimiters(argArray); + if (verbose) { + System.out.println("Added delimiters " + StringUtils.toEnglishList(argArray, true)); + } + break; + case "splitter-addmulti": + split.addMultiDelimiters(argArray); + if (verbose) { + System.out.println( + "Added multi-delimiters " + StringUtils.toEnglishList(argArray, true)); + } + break; + case "splitter-addmatch": + for (final String arg : argArray) { + split.addSimpleDelimiters(arg, mirrored.get(arg)); + } + if (verbose) { + System.out.println("Added matched delimiters " + + StringUtils.toEnglishList(argArray, true)); + } + break; + case "splitter-debug": + System.out.println(split.toString()); + break; + case "splitter-reset": + split = new ConfigurableTokenSplitter(true); + if (verbose) { + System.out.println("Reset splitter"); + } + break; + + case "delims-addgroup": + for (final String arg : argArray) { + dlm.addGroup(groups.get(arg)); + } + if (verbose) { + System.out.println("Added groups " + StringUtils.toEnglishList(argArray, true)); + } + break; + case "delims-setinitial": + dlm.setInitialGroup(groups.get(argArray[0])); + if (verbose) { + System.out.println("Set initial group"); + } + break; + case "delims-debug": + System.out.println(dlm.toString()); + break; + case "delims-test": + handleDelim(args); + break; + case "delims-reset": + dlm = new StringDelimiter(); + if (verbose) { + System.out.println("Reset delimiter"); + } + break; + case "delimgroups-new": + for (final String arg : argArray) { + groups.put(arg, new DelimiterGroup<>(arg)); + } + if (verbose) { + System.out.println("Created groups " + StringUtils.toEnglishList(argArray, true)); + } + break; + case "delimgroups-edit": + for (final String arg : argArray) { + handleEditGroup(arg, scn, isInteractive); + } + break; + case "delimgroups-debug": + for (final DelimiterGroup group : groups.values()) { + System.out.println(group.toString()); + } + break; + case "delimgroups-reset": + dlm = new StringDelimiter(); + groups = new HashMap<>(); + if (verbose) { + System.out.println("Reset delimiter groups + delimiter"); + } + break; + case "load-file": + handleLoadFile(args); + break; + default: + System.out.println("Unknown command "); + } + + } + + /* + * Load script commands from a file. + */ + private void handleLoadFile(final String args) { + String pth = args; + + if (args.startsWith("\"")) { + pth = args.substring(1, args.length() - 1); + } + + try (FileInputStream fis = new FileInputStream(pth)) { + final Scanner scn = new Scanner(fis); + + while (scn.hasNextLine()) { + final String ln = scn.nextLine().trim(); + + if (ln.equals("")) { + continue; + } + if (ln.startsWith("#")) { + continue; + } + + if (verbose) { + System.out.println("\nRead command '" + ln + "' from file\n"); + } + handleCommand(ln, scn, false); + } + + scn.close(); + } catch (final FileNotFoundException fnfex) { + System.out.println("Couldn't find file '" + args + "'"); + } catch (final IOException ioex) { + System.out.println("I/O error with file '" + args + "'\nCause: " + ioex.getMessage()); + } + } + + /* + * Handle editing a group. + */ + private void handleEditGroup(final String arg, final Scanner scn, final boolean isInteractive) { + if (!groups.containsKey(arg)) { + System.out.println("No group named '" + arg + "'"); + return; + } + + final DelimiterGroup group = groups.get(arg); + + if (verbose) { + System.out.println("Editing group '" + arg + "'"); + } + if (isInteractive) { + System.out.println("Enter command (blank line to stop editing): "); + } + + String ln = scn.nextLine().trim(); + + while (!ln.equals("")) { + int idx = ln.indexOf(' '); + + if (idx == -1) { + idx = ln.length(); + } + + final String command = ln.substring(0, idx); + + final String args = ln.substring(idx).trim(); + final String[] argArray = args.split(" "); + + switch (command) { + case "add-closing": + group.addClosing(argArray); + if (verbose) { + System.out.println( + "Added closers " + StringUtils.toEnglishList(argArray, true)); + } + break; + case "add-tlexclude": + group.addTopLevelForbid(argArray); + if (verbose) { + System.out.println("Added top-level exclusions " + + StringUtils.toEnglishList(argArray, true)); + } + break; + case "add-exclude": + group.addTopLevelForbid(argArray); + if (verbose) { + System.out.println("Added nested exclusions " + + StringUtils.toEnglishList(argArray, true)); + } + break; + case "add-subgroup": + group.addSubgroup(argArray[0], Integer.parseInt(argArray[1])); + if (verbose) { + System.out.printf("Added subgroup %s with priority %s\n", argArray[0], + argArray[1]); + } + break; + case "add-implied-subgroup": + group.implySubgroup(argArray[0], argArray[1]); + if (verbose) { + System.out.printf("Made closer '%s' imply a '%s' subgroup\n", argArray[0], + argArray[1]); + } + break; + case "add-opener": + group.addOpener(argArray[0], argArray[1]); + if (verbose) { + System.out.printf("Added opener '%s' for group '%s'\n", argArray[0], + argArray[1]); + } + break; + case "add-reopener": + group.addPredOpener(new RegexOpener(argArray[0], argArray[1])); + if (verbose) { + System.out.printf("Added regex '%s' as opener for '%s'\n", argArray[1], + argArray[0]); + } + break; + case "add-recloser": + group.addPredCloser(new RegexCloser(argArray[0])); + if (verbose) { + System.out.printf("Added parameterized string '%s' as closer\n", argArray[0]); + } + break; + case "debug": + System.out.println(group.toString()); + break; + default: + System.out.println("Unknown command " + command); + } + + if (isInteractive) { + System.out.println("Enter command (blank line to stop editing): "); + } + + ln = scn.nextLine().trim(); + } + + if (verbose) { + System.out.println("Finished editing group '" + arg + "'"); + } + } + + private void handleDelim(final String args) { + try { + final ITree res = dlm.delimitSequence(args.split(" ")); + + printDelimSeq(res); + } catch (final DelimiterException dex) { + System.out.println("Expression '" + args + "' isn't properly delimited.\n\tCause: " + + dex.getMessage()); + } + } + + private void handleSplit(final String[] argArray) { + for (int i = 0; i < argArray.length; i++) { + final String arg = argArray[i]; + + final IList strangs = split.split(arg); + + System.out.printf("%d '%s' %s\n", i, arg, strangs); + } + } + + private void handleTest(final String inp, final boolean splitWS) { + IList strings; + + try { + strings = split.split(inp); + } catch (final IllegalStateException isex) { + System.out.println("Splitter must be compiled at least once before use."); + return; + } + + System.out.println("Split tokens: " + strings); + + if (splitWS) { + final List tks = new LinkedList<>(); + + for (final String strang : strings) { + tks.addAll(Arrays.asList(strang.split(" "))); + } + + strings = new FunctionalList<>(tks); + } + try { + final ITree delim = dlm.delimitSequence(strings.toArray(new String[0])); + + printDelimSeq(delim); + } catch (final DelimiterException dex) { + System.out.println("Expression isn't properly delimited."); + System.out.println("Cause: " + dex.getMessage()); + } + } + + private void printDelimSeq(final ITree delim) { + System.out.println("Delimited tokens:\n" + delim.getChild(1).toString()); + System.out.print("Delimited expr: "); + printDelimTree(delim); + System.out.println(); + System.out.println(); + + System.out.println(); + } + + private void printDelimTree(final ITree tree) { + final StringBuilder sb = new StringBuilder(); + + intPrintDelimTree(tree.getChild(1), sb); + + System.out.println(sb.toString().replaceAll("\\s+", " ")); + } + + private void intPrintDelimTree(final ITree tree, final StringBuilder sb) { + tree.doForChildren((child) -> { + intPrintDelimNode(child, sb); + }); + } + + private void intPrintDelimNode(final ITree tree, final StringBuilder sb) { + if (tree.getHead().equals("contents")) { + intPrintDelimTree(tree, sb); + return; + } + + switch (tree.getChildrenCount()) { + case 0: + sb.append(tree.getHead()); + sb.append(" "); + + break; + case 1: + intPrintDelimTree(tree.getChild(0), sb); + + break; + case 2: + intPrintDelimTree(tree.getChild(0).getChild(0), sb); + intPrintDelimNode(tree.getChild(1), sb); + + break; + case 3: + intPrintDelimNode(tree.getChild(0), sb); + + final ITree contents = tree.getChild(1); + + intPrintDelimTree(contents.getChild(0), sb); + intPrintDelimNode(tree.getChild(2), sb); + + break; + } + } + + /** + * Main method + * + * @param args + * Unused CLI args. + */ + public static void main(final String[] args) { + final DelimSplitterTest tst = new DelimSplitterTest(); + + tst.runLoop(); + } +} diff --git a/base/src/examples/java/bjc/utils/examples/ShuntTest.java b/base/src/examples/java/bjc/utils/examples/ShuntTest.java new file mode 100644 index 0000000..ed530ed --- /dev/null +++ b/base/src/examples/java/bjc/utils/examples/ShuntTest.java @@ -0,0 +1,37 @@ +package bjc.utils.examples; + +import java.util.Scanner; + +import bjc.utils.funcdata.FunctionalStringTokenizer; +import bjc.utils.funcdata.IList; +import bjc.utils.parserutils.ShuntingYard; + +/** + * Test of shunting yard + * + * @author ben + * + */ +public class ShuntTest { + /** + * Main method + * + * @param args + * Unused CLI args + */ + public static void main(final String[] args) { + final Scanner inputSource = new Scanner(System.in); + + System.out.print("Enter a expression to shunt: "); + final String line = inputSource.nextLine(); + + final ShuntingYard yard = new ShuntingYard<>(true); + + final IList preTokens = new FunctionalStringTokenizer(line).toList(strang -> strang); + final IList shuntedTokens = yard.postfix(preTokens, strang -> strang); + + System.out.println(shuntedTokens.toString()); + + inputSource.close(); + } +} diff --git a/base/src/examples/java/bjc/utils/examples/rangen/DiabloItemGen.java b/base/src/examples/java/bjc/utils/examples/rangen/DiabloItemGen.java new file mode 100644 index 0000000..250318f --- /dev/null +++ b/base/src/examples/java/bjc/utils/examples/rangen/DiabloItemGen.java @@ -0,0 +1,94 @@ +package bjc.utils.examples.rangen; + +import bjc.utils.funcdata.FunctionalStringTokenizer; +import bjc.utils.funcdata.IList; +import bjc.utils.gen.WeightedGrammar; + +/** + * Example showing how to use the weighted random number generator. + * + * @author ben + * + */ +public class DiabloItemGen { + private static WeightedGrammar rules = new WeightedGrammar<>(); + + private static void addCase(final String ruleName, final int probability, final String ruleParts) { + final IList parts = FunctionalStringTokenizer.fromString(ruleParts).toList(strang -> strang); + + rules.addCase(ruleName, probability, parts); + } + + private static void addInfixRules() { + final String rn = ""; + + addCase(rn, 60, "sword"); + addCase(rn, 50, "armor"); + addCase(rn, 40, "rune"); + addCase(rn, 30, "scroll"); + addCase(rn, 20, "potion"); + addCase(rn, 10, "helm"); + } + + private static void addItemRules() { + final String rn = ""; + + addCase(rn, 10, ""); + addCase(rn, 20, " "); + addCase(rn, 30, " "); + addCase(rn, 40, " "); + addCase(rn, 50, " "); + addCase(rn, 60, " "); + } + + private static void addPrefixRules() { + final String rn = ""; + + addCase(rn, 60, "sturdy"); + addCase(rn, 50, "fine"); + addCase(rn, 40, "strong"); + addCase(rn, 30, "azure"); + addCase(rn, 20, "crimson"); + addCase(rn, 10, "phasing"); + } + + private static void addSuffixRules() { + final String rn = ""; + + addCase(rn, 60, "of Health"); + addCase(rn, 50, "of Wealth"); + addCase(rn, 40, "of Life"); + addCase(rn, 30, "of the Jackal"); + addCase(rn, 20, "of Vitality"); + addCase(rn, 10, "of Ability"); + } + + /** + * Main Method + * + * @param args + * Unused CLI args + */ + public static void main(final String[] args) { + rules.addRule(""); + addItemRules(); + + rules.addRule(""); + addSuffixRules(); + + rules.addRule(""); + addPrefixRules(); + + rules.addRule(""); + addInfixRules(); + + for (int i = 0; i < 100; i++) { + final IList ls = rules.generateListValues("", " "); + + final StringBuilder sb = new StringBuilder(); + ls.forEach(sb::append); + + System.out.println(sb.toString().replaceAll("\\s+", " ")); + } + } +} diff --git a/base/src/examples/java/bjc/utils/examples/rangen/RandomStringExamples.java b/base/src/examples/java/bjc/utils/examples/rangen/RandomStringExamples.java new file mode 100644 index 0000000..a84f70d --- /dev/null +++ b/base/src/examples/java/bjc/utils/examples/rangen/RandomStringExamples.java @@ -0,0 +1,64 @@ +package bjc.utils.examples.rangen; + +import bjc.utils.funcdata.FunctionalList; +import bjc.utils.funcdata.FunctionalStringTokenizer; +import bjc.utils.funcdata.IList; +import bjc.utils.gen.RandomGrammar; + +/** + * Examples of random grammar + * + * @author ben + * + */ +public class RandomStringExamples { + private static RandomGrammar rg; + + private static void addRule(final String rule, final String... cases) { + final IList> cses = new FunctionalList<>(); + + for (final String strang : cases) { + final IList lst = FunctionalStringTokenizer.fromString(strang).toList(s -> s); + + cses.add(lst); + } + + rg.makeRule(rule, cses); + } + + /** + * Main method + * + * @param args + * Unused CLI args + */ + public static void main(final String[] args) { + rg = new RandomGrammar<>(); + + addRule("", " ", " thinks that I am ", + "I ", "You think that I am "); + + addRule("", "dancing", "eating", "sleeping"); + + addRule("", "", "life", "my computer", "my friends"); + + addRule("", "hate", "am jealous of", "love"); + + addRule("", "hates", "loves"); + + addRule("", "my sister", "my father", "my girlfriend", "the man next door"); + + addRule("", "creative", "intelligent"); + + addRule("", "", " with ", ""); + + for (int i = 0; i < 10; i++) { + final IList ls = rg.generateListValues("", " "); + + final StringBuilder sb = new StringBuilder(); + ls.forEach(sb::append); + + System.out.println(sb.toString().replaceAll("\\s+", " ")); + } + } +} diff --git a/base/src/examples/java/bjc/utils/examples/sample-ds-files/html.ds b/base/src/examples/java/bjc/utils/examples/sample-ds-files/html.ds new file mode 100644 index 0000000..103fa12 --- /dev/null +++ b/base/src/examples/java/bjc/utils/examples/sample-ds-files/html.ds @@ -0,0 +1,10 @@ +delimgroups-new tag initial + +delimgroups-edit tag + add-recloser + +delimgroups-edit initial + add-reopener tag <(\w+)> + +delims-addgroup tag initial +delims-setinitial initial \ No newline at end of file diff --git a/base/src/examples/java/bjc/utils/examples/sample-ds-files/json.ds b/base/src/examples/java/bjc/utils/examples/sample-ds-files/json.ds new file mode 100644 index 0000000..d110d95 --- /dev/null +++ b/base/src/examples/java/bjc/utils/examples/sample-ds-files/json.ds @@ -0,0 +1,23 @@ +splitter-addmatch ( { [ +splitter-add : , " +splitter-compile + +delimgroups-new braces brackets initial +delimgroups-edit braces + add-closing } + add-subgroup : 0 + add-subgroup , 1 + add-implied-subgroup } , + +delimgroups-edit brackets + add-subgroup , 0 + add-closing ] + add-implied-subgroup ] , + +delimgroups-edit initial + add-opener { braces + add-opener [ brackets + +delims-addgroup braces brackets initial + +delims-setinitial initial \ No newline at end of file diff --git a/base/src/examples/java/bjc/utils/examples/test.tree b/base/src/examples/java/bjc/utils/examples/test.tree new file mode 100644 index 0000000..795cc88 --- /dev/null +++ b/base/src/examples/java/bjc/utils/examples/test.tree @@ -0,0 +1,13 @@ +test 1 + 1 + 1 + 2 + 2 + 1 + +simp 1 + 2 + 3 + 4 + 3 + 2 \ No newline at end of file -- cgit v1.2.3