diff options
Diffstat (limited to 'BJC-Utils2/src/main/java')
19 files changed, 288 insertions, 208 deletions
diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/IHolder.java b/BJC-Utils2/src/main/java/bjc/utils/data/IHolder.java index aa7d5bd..b6e752b 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/data/IHolder.java +++ b/BJC-Utils2/src/main/java/bjc/utils/data/IHolder.java @@ -21,7 +21,7 @@ public interface IHolder<T> { * The transformation to apply * @return A holder with the transformed value */ - <NewT> IHolder<NewT> map(Function<T, NewT> f); + public <NewT> IHolder<NewT> map(Function<T, NewT> f); /** * Apply the given transformation to the held value. Returns the holder @@ -31,7 +31,7 @@ public interface IHolder<T> { * The transform to apply to the value * @return The holder */ - IHolder<T> transform(Function<T, T> f); + public IHolder<T> transform(Function<T, T> f); /** * Returns a raw mapped value, not contained in a GenHolder @@ -40,6 +40,6 @@ public interface IHolder<T> { * The function to use for mapping the value * @return The mapped value outside of a GenHolder */ - <E> E unwrap(Function<T, E> f); + public <E> E unwrap(Function<T, E> f); }
\ No newline at end of file diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/IPair.java b/BJC-Utils2/src/main/java/bjc/utils/data/IPair.java index 9da7d22..fcf2b05 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/data/IPair.java +++ b/BJC-Utils2/src/main/java/bjc/utils/data/IPair.java @@ -16,7 +16,8 @@ public interface IPair<L, R> { * The function to apply to the right value. * @return A new pair containing the two modified values. */ - <L2, R2> IPair<L2, R2> apply(Function<L, L2> lf, Function<R, R2> rf); + public <L2, R2> IPair<L2, R2> apply(Function<L, L2> lf, + Function<R, R2> rf); /** * Collapse this pair to a single value. Does not change the internal @@ -26,8 +27,14 @@ public interface IPair<L, R> { * The function to use to collapse the pair. * @return The collapsed value. */ - <E> E merge(BiFunction<L, R, E> bf); - - void doWith(BiConsumer<L, R> bc); + public <E> E merge(BiFunction<L, R, E> bf); + /** + * Execute an action with the values of this pair. Has no effect on the + * internal contents + * + * @param bc + * The action to execute on the values + */ + public void doWith(BiConsumer<L, R> bc); }
\ No newline at end of file diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/IPrecedent.java b/BJC-Utils2/src/main/java/bjc/utils/data/IPrecedent.java index 98258ef..1e00a59 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/data/IPrecedent.java +++ b/BJC-Utils2/src/main/java/bjc/utils/data/IPrecedent.java @@ -12,7 +12,7 @@ public interface IPrecedent { * * @return The precedence of the attached object */ - int getPrecedence(); + public int getPrecedence(); /** * Create a new object with set precedence @@ -21,7 +21,7 @@ public interface IPrecedent { * The precedence of the object to handle * @return A new object with set precedence */ - static IPrecedent newSimplePrecedent(int prec) { + public static IPrecedent newSimplePrecedent(int prec) { return () -> prec; } }
\ No newline at end of file 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 6493dd5..150ed51 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/dice/DiceExpressionType.java +++ b/BJC-Utils2/src/main/java/bjc/utils/dice/DiceExpressionType.java @@ -1,7 +1,7 @@ package bjc.utils.dice; /* - * Enumeration for dice expression operators + * Enumeration for basic dice expression operators */ public enum DiceExpressionType { ADD, DIVIDE, MULTIPLY, SUBTRACT diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcdata/FunctionalList.java b/BJC-Utils2/src/main/java/bjc/utils/funcdata/FunctionalList.java index 3fd05da..d2f0988 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/funcdata/FunctionalList.java +++ b/BJC-Utils2/src/main/java/bjc/utils/funcdata/FunctionalList.java @@ -129,6 +129,7 @@ public class FunctionalList<E> implements Cloneable { return true; } } + return false; } @@ -203,11 +204,7 @@ public class FunctionalList<E> implements Cloneable { public <T> FunctionalList<T> flatMap(Function<E, List<T>> f) { FunctionalList<T> fl = new FunctionalList<>(this.wrap.size()); - forEach(e -> { - f.apply(e).forEach(e2 -> { - fl.add(e2); - }); - }); + forEach(e -> f.apply(e).forEach(fl::add)); return fl; } @@ -230,11 +227,13 @@ public class FunctionalList<E> implements Cloneable { * index. */ public void forEachIndexed(BiConsumer<Integer, E> c) { - int i = 0; + GenHolder<Integer> i = new GenHolder<>(0); - for (E e : wrap) { - c.accept(i++, e); - } + wrap.forEach((val) -> { + c.accept(i.unwrap(vl -> vl), val); + + i.transform((vl) -> vl + 1); + }); } /** @@ -267,7 +266,7 @@ public class FunctionalList<E> implements Cloneable { public FunctionalList<E> getMatching(Predicate<E> matchPred) { FunctionalList<E> fl = new FunctionalList<>(); - this.forEach((elem) -> { + wrap.forEach((elem) -> { if (matchPred.test(elem)) { fl.add(elem); } @@ -369,6 +368,10 @@ public class FunctionalList<E> implements Cloneable { return wrap.removeIf(remPred); } + public void removeMatching(E obj) { + removeIf((ele) -> ele.equals(obj)); + } + /** * Perform a binary search for the specified key using the provided * means of comparing elements. Since this IS a binary search, the list @@ -423,9 +426,12 @@ public class FunctionalList<E> implements Cloneable { return sb.toString(); } - public void removeMatching(E obj) { - removeIf((ele) -> { - return ele.equals(obj); - }); + /** + * Retrieve the size of the wrapped list + * + * @return The size of the wrapped list + */ + public int getSize() { + return wrap.size(); } } diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcdata/bst/BinarySearchTree.java b/BJC-Utils2/src/main/java/bjc/utils/funcdata/bst/BinarySearchTree.java index 7bf0007..7665797 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/funcdata/bst/BinarySearchTree.java +++ b/BJC-Utils2/src/main/java/bjc/utils/funcdata/bst/BinarySearchTree.java @@ -5,6 +5,7 @@ import java.util.Comparator; import java.util.List; import java.util.function.Predicate; +import bjc.utils.funcdata.FunctionalList; import bjc.utils.funcdata.bst.ITreePart.TreeLinearizationMethod; /** @@ -49,6 +50,7 @@ public class BinarySearchTree<T> { */ public void addNode(T dat) { nCount++; + if (root == null) { root = new TreeNode<T>(dat, null, null); } else { @@ -61,43 +63,34 @@ public class BinarySearchTree<T> { * time, but also O(N) space. */ public void balance() { - ArrayList<T> elms = new ArrayList<>(nCount); + FunctionalList<T> elms = new FunctionalList<>(); root.forEach(TreeLinearizationMethod.INORDER, e -> elms.add(e)); root = null; - int piv = elms.size() / 2; + int piv = elms.getSize() / 2; int adj = 0; - while ((piv - adj) >= 0 && (piv + adj) < elms.size()) { + while ((piv - adj) >= 0 && (piv + adj) < elms.getSize()) { if (root == null) { - root = new TreeNode<T>(elms.get(piv), null, null); + root = new TreeNode<T>(elms.getByIndex(piv), null, null); } else { - root.add(elms.get(piv + adj), comp); - root.add(elms.get(piv - adj), comp); + root.add(elms.getByIndex(piv + adj), comp); + root.add(elms.getByIndex(piv - adj), comp); } adj++; } if ((piv - adj) >= 0) { - root.add(elms.get(piv - adj), comp); - } else if ((piv + adj) < elms.size()) { - root.add(elms.get(piv + adj), comp); + root.add(elms.getByIndex(piv - adj), comp); + } else if ((piv + adj) < elms.getSize()) { + root.add(elms.getByIndex(piv + adj), comp); } } /** - * Get the root of the tree. - * - * @return The root of the tree. - */ - public ITreePart<T> getRoot() { - return root; - } - - /** * Soft-delete a node from the tree. Soft-deleted nodes stay in the * tree until trim()/balance() is invoked, and are not included in * traversals/finds. @@ -106,10 +99,20 @@ public class BinarySearchTree<T> { */ public void deleteNode(T dat) { nCount--; + root.delete(dat, comp); } /** + * Get the root of the tree. + * + * @return The root of the tree. + */ + public ITreePart<T> getRoot() { + return root; + } + + /** * Check if a node is in the tree * * @param dat diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcdata/bst/DirectedWalkFunction.java b/BJC-Utils2/src/main/java/bjc/utils/funcdata/bst/DirectedWalkFunction.java index 18e80be..12c87b3 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/funcdata/bst/DirectedWalkFunction.java +++ b/BJC-Utils2/src/main/java/bjc/utils/funcdata/bst/DirectedWalkFunction.java @@ -2,9 +2,11 @@ package bjc.utils.funcdata.bst; /** * Represents a function for doing a directed walk of a binary tree. + * * @author ben * * @param <T> + * The type of element stored in the walked tree */ @FunctionalInterface public interface DirectedWalkFunction<T> { @@ -16,27 +18,30 @@ public interface DirectedWalkFunction<T> { */ public enum DirectedWalkResult { /** - * Specifies that the function has succesfully completed - * - */ - SUCCESS, - /** * Specifies that the function has failed. */ FAILURE, - /** + /** * Specifies that the function wants to move left in the tree next. */ - LEFT, + LEFT, /** - * Specifies that the function wants to move right in the tree next. + * Specifies that the function wants to move right in the tree + * next. */ - RIGHT + RIGHT, + /** + * Specifies that the function has succesfully completed + * + */ + SUCCESS } /** * Perform a directed walk on a node of a tree. - * @param data The data stored in the node currently being visited + * + * @param data + * The data stored in the node currently being visited * @return The way the function wants the walk to go next. */ public DirectedWalkResult walk(T data); diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcdata/bst/ITreePart.java b/BJC-Utils2/src/main/java/bjc/utils/funcdata/bst/ITreePart.java index 0c8f12e..dfcfedd 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/funcdata/bst/ITreePart.java +++ b/BJC-Utils2/src/main/java/bjc/utils/funcdata/bst/ITreePart.java @@ -7,75 +7,109 @@ import java.util.function.Predicate; /** * A interface for the fundamental things that want to be part of a tree. + * * @author ben * - * @param <T> The data contained in this part of the tree. + * @param <T> + * The data contained in this part of the tree. */ public interface ITreePart<T> { /** * Represents the ways to linearize a tree for traversal. + * * @author ben * */ public enum TreeLinearizationMethod { /** - * Visit the left side of this tree part, the tree part itself, and then the right part. + * Visit the left side of this tree part, the tree part itself, and + * then the right part. */ - INORDER, + INORDER, /** - * Visit the left side of this tree part, the right side, and then the tree part itself. + * Visit the left side of this tree part, the right side, and then + * the tree part itself. */ - POSTORDER, + POSTORDER, /** - * Visit the tree part itself, then the left side of tthis tree part and then the right part. + * Visit the tree part itself, then the left side of tthis tree + * part and then the right part. */ PREORDER } - + /** * Add a element below this tree part somewhere. - * @param dat The element to add below this tree part - * @param comp The thing to use for comparing values to find where to insert the tree part. + * + * @param dat + * The element to add below this tree part + * @param comp + * The thing to use for comparing values to find where to + * insert the tree part. */ - void add(T dat, Comparator<T> comp); + public void add(T dat, Comparator<T> comp); + /** - * Collapses this tree part into a single value. - * Does not change the underlying tree. - * @param f The function to use to transform data into mapped form. - * @param bf The function to use to collapse data in mapped form into a single value. + * Collapses this tree part into a single value. Does not change the + * underlying tree. + * + * @param f + * The function to use to transform data into mapped form. + * @param bf + * The function to use to collapse data in mapped form into + * a single value. * @return A single value from collapsing the tree. */ - <E> E collapse(Function<T, E> f, BiFunction<E, E, E> bf); + public <E> E collapse(Function<T, E> f, BiFunction<E, E, E> bf); + /** * Check if this tre part or below it contains the specified data item - * @param data The data item to look for. - * @param cmp The comparator to use to search for the data item - * @return Whether or not the given item is contained in this tree part or its children. + * + * @param data + * The data item to look for. + * @param cmp + * The comparator to use to search for the data item + * @return Whether or not the given item is contained in this tree part + * or its children. */ - boolean contains(T data, Comparator<T> cmp); + public boolean contains(T data, Comparator<T> cmp); + /** * Get the data associated with this tree part. + * * @return The data associated with this tree part. */ - T data(); + public T data(); + /** * Remove the given node from this tree part and any of its children. - * @param dat The data item to remove. - * @param cmp The comparator to use to search for the data item. + * + * @param dat + * The data item to remove. + * @param cmp + * The comparator to use to search for the data item. */ - void delete(T dat, Comparator<T> cmp); + public void delete(T dat, Comparator<T> cmp); + /** * Execute a directed walk through the tree. - * @param ds The function to use to direct the walk through the tree. + * + * @param ds + * The function to use to direct the walk through the tree. * @return Whether the directed walk finished successfully. */ - boolean directedWalk(DirectedWalkFunction<T> ds); + public boolean directedWalk(DirectedWalkFunction<T> ds); + /** - * Execute a provided function for each element of tree it succesfully completes for - * @param tlm The way to linearize the tree for executing - * @param c The function to apply to each element, where it returning false - * terminates traversal early + * Execute a provided function for each element of tree it succesfully + * completes for + * + * @param tlm + * The way to linearize the tree for executing + * @param c + * The function to apply to each element, where it returning + * false terminates traversal early * @return Whether the traversal finished succesfully */ - boolean forEach(TreeLinearizationMethod tlm, Predicate<T> c); + public boolean forEach(TreeLinearizationMethod tlm, Predicate<T> c); } diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcdata/bst/TreeNode.java b/BJC-Utils2/src/main/java/bjc/utils/funcdata/bst/TreeNode.java index 40cc53f..e8c6c8b 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/funcdata/bst/TreeNode.java +++ b/BJC-Utils2/src/main/java/bjc/utils/funcdata/bst/TreeNode.java @@ -111,20 +111,17 @@ public class TreeNode<T> extends TreeLeaf<T> { @Override public void delete(T dat, Comparator<T> cmp) { - directedWalk(new DirectedWalkFunction<T>() { - @Override - public DirectedWalkResult walk(T ds) { - switch (cmp.compare(data, dat)) { - case -1: - return left == null ? FAILURE : LEFT; - case 0: - deleted = true; - return FAILURE; - case 1: - return right == null ? FAILURE : RIGHT; - default: - return DirectedWalkResult.FAILURE; - } + directedWalk(ds -> { + switch (cmp.compare(data, dat)) { + case -1: + return left == null ? FAILURE : LEFT; + case 0: + deleted = true; + return FAILURE; + case 1: + return right == null ? FAILURE : RIGHT; + default: + return FAILURE; } }); } 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))); } } diff --git a/BJC-Utils2/src/main/java/bjc/utils/graph/AdjacencyMap.java b/BJC-Utils2/src/main/java/bjc/utils/graph/AdjacencyMap.java index d3a420e..6420d8e 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/graph/AdjacencyMap.java +++ b/BJC-Utils2/src/main/java/bjc/utils/graph/AdjacencyMap.java @@ -148,6 +148,7 @@ public class AdjacencyMap<T> { .forEach(tgt -> ps.printf("%d ", tgt.getValue())); ps.println(); }); + ps.close(); } } diff --git a/BJC-Utils2/src/main/java/bjc/utils/gui/FileNotChosenException.java b/BJC-Utils2/src/main/java/bjc/utils/gui/FileNotChosenException.java index b972596..2876b1d 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/gui/FileNotChosenException.java +++ b/BJC-Utils2/src/main/java/bjc/utils/gui/FileNotChosenException.java @@ -4,10 +4,24 @@ import java.io.IOException; /** * Represents the user failing to choose a file. + * * @author ben * */ public class FileNotChosenException extends IOException { private static final long serialVersionUID = -8753348705210831096L; + + public FileNotChosenException() { + super(); + } + /** + * Create a new exception with the given cause + * + * @param cause + * The cause of why the exception was thrown + */ + public FileNotChosenException(String cause) { + super(cause); + } } diff --git a/BJC-Utils2/src/main/java/bjc/utils/gui/ListParameterPanel.java b/BJC-Utils2/src/main/java/bjc/utils/gui/ListParameterPanel.java index 3cdfd47..6272b5f 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/gui/ListParameterPanel.java +++ b/BJC-Utils2/src/main/java/bjc/utils/gui/ListParameterPanel.java @@ -72,15 +72,14 @@ public class ListParameterPanel<E> extends JPanel { buttonPanel.setLayout(new HLayout(3)); JButton addParam = new JButton("Add..."); + JButton editParam = new JButton("Edit..."); + JButton removeParam = new JButton("Remove..."); + addParam.addActionListener( (ev) -> ((DefaultListModel<E>) list.getModel()) .addElement(addAct.get())); - - JButton editParam = new JButton("Edit..."); editParam.addActionListener( (ev) -> editAct.accept(list.getSelectedValue())); - - JButton removeParam = new JButton("Remove..."); removeParam.addActionListener((ev) -> removeAct .accept(((DefaultListModel<E>) list.getModel()) .remove(list.getSelectedIndex()))); diff --git a/BJC-Utils2/src/main/java/bjc/utils/gui/SimpleDialogs.java b/BJC-Utils2/src/main/java/bjc/utils/gui/SimpleDialogs.java index ea48977..0acbd65 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/gui/SimpleDialogs.java +++ b/BJC-Utils2/src/main/java/bjc/utils/gui/SimpleDialogs.java @@ -78,8 +78,9 @@ public class SimpleDialogs { JPanel buttonPane = new JPanel(); JButton okButton = new JButton("Ok"); - okButton.addActionListener(e -> jd.dispose()); JButton cancelButton = new JButton("Cancel"); + + okButton.addActionListener(e -> jd.dispose()); cancelButton.addActionListener(e -> jd.dispose()); buttonPane.add(cancelButton); diff --git a/BJC-Utils2/src/main/java/bjc/utils/gui/awt/SimpleFileDialog.java b/BJC-Utils2/src/main/java/bjc/utils/gui/awt/SimpleFileDialog.java index 2e13949..c12119f 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/gui/awt/SimpleFileDialog.java +++ b/BJC-Utils2/src/main/java/bjc/utils/gui/awt/SimpleFileDialog.java @@ -23,6 +23,19 @@ public class SimpleFileDialog { * The parent of the file picker * @param title * The title of the file picker + * @return The file the user picked + */ + public static File getOpenFile(Frame par, String title) { + return getOpenFile(par, title, (String[]) null); + } + + /** + * Prompt the user to pick a file to open + * + * @param par + * The parent of the file picker + * @param title + * The title of the file picker * @param extensions * The extensions to accept as valid * @return The file the user picked @@ -48,7 +61,7 @@ public class SimpleFileDialog { } /** - * Prompt the user to pick a file to open + * Prompt the user to pick a file to save * * @param par * The parent of the file picker @@ -56,8 +69,8 @@ public class SimpleFileDialog { * The title of the file picker * @return The file the user picked */ - public static File getOpenFile(Frame par, String title) { - return getOpenFile(par, title, (String[]) null); + public static File getSaveFile(Frame par, String title) { + return getSaveFile(par, title, (String[]) null); } /** @@ -90,17 +103,4 @@ public class SimpleFileDialog { return fd.getFiles()[0]; } - - /** - * Prompt the user to pick a file to save - * - * @param par - * The parent of the file picker - * @param title - * The title of the file picker - * @return The file the user picked - */ - public static File getSaveFile(Frame par, String title) { - return getSaveFile(par, title, (String[]) null); - } } 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 1190281..d07d725 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/RuleBasedConfigReader.java +++ b/BJC-Utils2/src/main/java/bjc/utils/parserutils/RuleBasedConfigReader.java @@ -20,12 +20,12 @@ import bjc.utils.funcdata.FunctionalStringTokenizer; * type of the state object to use */ public class RuleBasedConfigReader<E> { - private Map<String, BiConsumer<FunctionalStringTokenizer, E>> pragmas; - private BiConsumer<FunctionalStringTokenizer, Pair<String, E>> startRule; private BiConsumer<FunctionalStringTokenizer, E> continueRule; private Consumer<E> endRule; + private Map<String, BiConsumer<FunctionalStringTokenizer, E>> pragmas; + /** * Create a new rule-based config reader * @@ -43,10 +43,15 @@ public class RuleBasedConfigReader<E> { this.startRule = startRule; this.continueRule = continueRule; this.endRule = endRule; - + this.pragmas = new HashMap<>(); } + public void addPragma(String pragName, + BiConsumer<FunctionalStringTokenizer, E> pragAct) { + pragmas.put(pragName, pragAct); + } + public E fromStream(InputStream is, E initState) { Scanner scn = new Scanner(is); @@ -67,7 +72,7 @@ public class RuleBasedConfigReader<E> { String nxtToken = stk.nextToken(); if (nxtToken.equals("#")) { - + // Do nothing, this is a comment } else if (nxtToken.equals("pragma")) { String tk = stk.nextToken(); @@ -87,16 +92,6 @@ public class RuleBasedConfigReader<E> { return stat; } - public void addPragma(String pragName, - BiConsumer<FunctionalStringTokenizer, E> pragAct) { - pragmas.put(pragName, pragAct); - } - - public void setStartRule( - BiConsumer<FunctionalStringTokenizer, Pair<String, E>> startRule) { - this.startRule = startRule; - } - public void setContinueRule( BiConsumer<FunctionalStringTokenizer, E> continueRule) { this.continueRule = continueRule; @@ -105,4 +100,9 @@ public class RuleBasedConfigReader<E> { public void setEndRule(Consumer<E> endRule) { this.endRule = endRule; } + + public void setStartRule( + BiConsumer<FunctionalStringTokenizer, Pair<String, E>> startRule) { + this.startRule = startRule; + } } diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/ShuntingYard.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/ShuntingYard.java index ace636e..8a036ce 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/ShuntingYard.java +++ b/BJC-Utils2/src/main/java/bjc/utils/parserutils/ShuntingYard.java @@ -19,7 +19,7 @@ import bjc.utils.funcdata.FunctionalList; */ public class ShuntingYard<E> { - private static enum Operator implements IPrecedent { + public static enum Operator implements IPrecedent { ADD(1), DIVIDE(4), MULTIPLY(3), SUBTRACT(2); private final int precedence; @@ -39,9 +39,6 @@ public class ShuntingYard<E> { } } - static { - } - /** * Holds all the shuntable operations */ @@ -64,6 +61,16 @@ public class ShuntingYard<E> { * * @param tok * The token representing the operator + */ + public void addOp(String tok, int i) { + this.addOp(tok, IPrecedent.newSimplePrecedent(i)); + } + + /** + * Add an operator to the list of shuntable operators + * + * @param tok + * The token representing the operator * @param prec * The precedence of the operator */ @@ -127,14 +134,4 @@ public class ShuntingYard<E> { public void removeOp(String tok) { ops.remove(tok); } - - /** - * Add an operator to the list of shuntable operators - * - * @param tok - * The token representing the operator - */ - public void addOp(String tok, int i) { - this.addOp(tok, IPrecedent.newSimplePrecedent(i)); - } }
\ No newline at end of file diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/UnknownPragmaException.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/UnknownPragmaException.java index fc97a44..88f38d4 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/UnknownPragmaException.java +++ b/BJC-Utils2/src/main/java/bjc/utils/parserutils/UnknownPragmaException.java @@ -2,11 +2,26 @@ package bjc.utils.parserutils; import java.util.InputMismatchException; +/** + * Represents a error from encountering a unknown pragma + * + * @author ben + * + */ public class UnknownPragmaException extends InputMismatchException { + /** + * Version id for serialization + */ + private static final long serialVersionUID = -4277573484926638662L; + + /** + * Create a new exception with the given cause + * + * @param m + * The cause for throwing this exception + */ public UnknownPragmaException(String m) { super(m); } - private static final long serialVersionUID = -4277573484926638662L; - } |