diff options
Diffstat (limited to 'BJC-Utils2/src/main/java')
12 files changed, 357 insertions, 110 deletions
diff --git a/BJC-Utils2/src/main/java/bjc/utils/PropertyDB.java b/BJC-Utils2/src/main/java/bjc/utils/PropertyDB.java index 3f2c078..daaf423 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/PropertyDB.java +++ b/BJC-Utils2/src/main/java/bjc/utils/PropertyDB.java @@ -15,11 +15,13 @@ import java.util.regex.Pattern; * */ public class PropertyDB { - private static SimpleProperties regexes; - private static Map<String, Pattern> compiledRegexes; + private static SimpleProperties regexes; + private static Map<String, Pattern> compiledRegexes; private static SimpleProperties formats; + private static final boolean LOGLOAD = false; + /* * The lock to use to ensure a read can't happen during a reload */ @@ -37,20 +39,27 @@ public class PropertyDB { */ public static void reloadProperties() { loadLock.write(() -> { - System.out.println("Reading regex properties:"); + if(LOGLOAD) { + System.out.println("Reading regex properties:"); + } regexes = new SimpleProperties(); regexes.loadFrom(PropertyDB.class.getResourceAsStream("/regexes.sprop"), false); - System.out.println(); + if(LOGLOAD) { + regexes.outputProperties(); + System.out.println(); + } compiledRegexes = new HashMap<>(); - System.out.println("Reading format properties:"); + if(LOGLOAD) { + System.out.println("Reading format properties:"); + } formats = new SimpleProperties(); formats.loadFrom(PropertyDB.class.getResourceAsStream("/formats.sprop"), false); - System.out.println(); - - if (regexes.equals(formats)) - System.out.println("WAT"); + if(LOGLOAD) { + formats.outputProperties(); + System.out.println(); + } }); } @@ -58,13 +67,13 @@ public class PropertyDB { * Retrieve a persisted regular expression. * * @param key - * The name of the regular expression. + * The name of the regular expression. * * @return The regular expression with that name. */ public static String getRegex(String key) { return loadLock.read(() -> { - if (!regexes.containsKey(key)) { + if(!regexes.containsKey(key)) { String msg = String.format("No regular expression named '%s' found", key); throw new NoSuchElementException(msg); @@ -79,13 +88,13 @@ public class PropertyDB { * expression. * * @param key - * The name of the regular expression. + * The name of the regular expression. * * @return The regular expression with that name. */ public static Pattern getCompiledRegex(String key) { return loadLock.read(() -> { - if (!regexes.containsKey(key)) { + if(!regexes.containsKey(key)) { String msg = String.format("No regular expression named '%s' found", key); throw new NoSuchElementException(msg); @@ -101,13 +110,13 @@ public class PropertyDB { * Retrieve a persisted format string. * * @param key - * The name of the format string. + * The name of the format string. * * @return The format string with that name. */ public static String getFormat(String key) { return loadLock.read(() -> { - if (!formats.containsKey(key)) { + if(!formats.containsKey(key)) { String msg = String.format("No format string named '%s' found", key); throw new NoSuchElementException(msg); @@ -118,13 +127,14 @@ public class PropertyDB { } /** - * Retrieve a persisted format string, and apply it to a set of arguments. + * Retrieve a persisted format string, and apply it to a set of + * arguments. * * @param key - * The name of the format string. + * The name of the format string. * * @param objects - * The parameters to the format string. + * The parameters to the format string. * * @return The format string with that name. */ diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/BooleanToggle.java b/BJC-Utils2/src/main/java/bjc/utils/data/BooleanToggle.java new file mode 100644 index 0000000..68399a0 --- /dev/null +++ b/BJC-Utils2/src/main/java/bjc/utils/data/BooleanToggle.java @@ -0,0 +1,76 @@ +package bjc.utils.data; + +/** + * A simple {@link ValueToggle} that swaps between true and false. + * + * @author EVE + * + */ +public class BooleanToggle implements Toggle<Boolean> { + private boolean val; + + /** + * Create a new, initially false, flip-flop. + */ + public BooleanToggle() { + this(false); + } + + /** + * Create a flip-flop with the specified initial value. + * + * @param initial + * The initial value of the flip-flop. + */ + public BooleanToggle(boolean initial) { + val = initial; + } + + @Override + public Boolean get() { + boolean res = val; + + val = !res; + + return res; + } + + @Override + public Boolean peek() { + return val; + } + + @Override + public void set(boolean vl) { + val = vl; + } + + @Override + public int hashCode() { + final int prime = 31; + + int result = 1; + + result = prime * result + (val ? 1231 : 1237); + + return result; + } + + @Override + public boolean equals(Object obj) { + if(this == obj) return true; + if(obj == null) return false; + if(!(obj instanceof BooleanToggle)) return false; + + BooleanToggle other = (BooleanToggle) obj; + + if(val != other.val) return false; + + return true; + } + + @Override + public String toString() { + return String.format("BooleanToggle [val=%s]", val); + } +}
\ No newline at end of file diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/Toggle.java b/BJC-Utils2/src/main/java/bjc/utils/data/Toggle.java new file mode 100644 index 0000000..8ebc4d8 --- /dev/null +++ b/BJC-Utils2/src/main/java/bjc/utils/data/Toggle.java @@ -0,0 +1,35 @@ +package bjc.utils.data; + +/** + * A stateful holder that swaps between two values of the same type. + * + * @author EVE + * + * @param <E> + * The value stored in the toggle. + */ +public interface Toggle<E> { + /** + * Retrieve the currently-aligned value of this toggle, and swap the + * alignment. + * + * @return The previously-aligned value. + */ + E get(); + + /** + * Retrieve the currently-aligned value without altering the alignment. + * + * @return The currently-aligned value. + */ + E peek(); + + /** + * Change the alignment of the toggle. + * + * @param isLeft + * Whether the toggle should be left-aligned or not. + */ + void set(boolean isLeft); + +}
\ No newline at end of file diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/ValueToggle.java b/BJC-Utils2/src/main/java/bjc/utils/data/ValueToggle.java new file mode 100644 index 0000000..5b5cb83 --- /dev/null +++ b/BJC-Utils2/src/main/java/bjc/utils/data/ValueToggle.java @@ -0,0 +1,58 @@ +package bjc.utils.data; + +/** + * A simple implementation of {@link Toggle}. + * + * @author EVE + * + * @param <E> + * The type of value to toggle between. + */ +public class ValueToggle<E> implements Toggle<E> { + private final E lft; + private final E rght; + + private BooleanToggle alignment; + + /** + * Create a new toggle. + * + * All toggles start right-aligned. + * + * @param left + * The value when the toggle is left-aligned. + * + * @param right + * The value when the toggle is right-aligned. + */ + public ValueToggle(E left, E right) { + lft = left; + + rght = right; + + alignment = new BooleanToggle(); + } + + @Override + public E get() { + if(alignment.get()) { + return lft; + } else { + return rght; + } + } + + @Override + public E peek() { + if(alignment.peek()) { + return lft; + } else { + return rght; + } + } + + @Override + public void set(boolean isLeft) { + alignment.set(isLeft); + } +} diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcdata/IList.java b/BJC-Utils2/src/main/java/bjc/utils/funcdata/IList.java index cf60ed6..d92d564 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/funcdata/IList.java +++ b/BJC-Utils2/src/main/java/bjc/utils/funcdata/IList.java @@ -42,6 +42,28 @@ public interface IList<ContainedType> extends Iterable<ContainedType> { } /** + * Add all of the elements in the provided array to this list. + * + * @param items + * The array of items to add. + * + * @return True if every item was successfully added to the list, false + * otherwise. + */ + @SuppressWarnings("unchecked") + default boolean addAll(ContainedType... items) { + boolean succ = true; + + for(ContainedType item : items) { + boolean addSucc = add(item); + + succ = succ ? addSucc : false; + } + + return succ; + } + + /** * Check if all of the elements of this list match the specified * predicate. * @@ -238,6 +260,19 @@ public interface IList<ContainedType> extends Iterable<ContainedType> { void prepend(ContainedType item); /** + * Prepend an array of items to the list. + * + * @param items + * The items to prepend to the list. + */ + @SuppressWarnings("unchecked") + default void prependAll(ContainedType... items) { + for(ContainedType item : items) { + prepend(item); + } + } + + /** * Select a random item from the list, using a default random number * generator * diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcutils/ListUtils.java b/BJC-Utils2/src/main/java/bjc/utils/funcutils/ListUtils.java index 27666dd..ad0f565 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/funcutils/ListUtils.java +++ b/BJC-Utils2/src/main/java/bjc/utils/funcutils/ListUtils.java @@ -1,11 +1,9 @@ package bjc.utils.funcutils; -import bjc.utils.data.IPair; import bjc.utils.funcdata.FunctionalList; import bjc.utils.funcdata.IList; import java.util.ArrayList; -import java.util.Deque; import java.util.Iterator; import java.util.function.Function; import java.util.function.Supplier; @@ -29,40 +27,38 @@ public class ListUtils { * @return The collapsed string of tokens */ public static String collapseTokens(IList<String> input) { - if (input == null) - throw new NullPointerException("Input must not be null"); + if(input == null) throw new NullPointerException("Input must not be null"); return collapseTokens(input, ""); } /** * Collapse a string of tokens into a single string, adding the desired - * seperator after each token + * separator after each token * * @param input * The list of tokens to collapse * @param seperator - * The seperator to use for seperating tokens + * The separator to use for separating tokens * @return The collapsed string of tokens */ public static String collapseTokens(IList<String> input, String seperator) { - if (input == null) + if(input == null) throw new NullPointerException("Input must not be null"); - else if (seperator == null) - throw new NullPointerException("Seperator must not be null"); + else if(seperator == null) throw new NullPointerException("Seperator must not be null"); - if (input.getSize() < 1) + if(input.getSize() < 1) return ""; - else if (input.getSize() == 1) + else if(input.getSize() == 1) return input.first(); else { StringBuilder state = new StringBuilder(); int i = 1; - for (String itm : input.toIterable()) { + for(String itm : input.toIterable()) { state.append(itm); - if (i != input.getSize()) { + if(i != input.getSize()) { state.append(seperator); } @@ -74,22 +70,6 @@ public class ListUtils { } /** - * Split off affixes from tokens - * - * @param input - * The tokens to deaffix - * @param operators - * The affixes to remove - * @return The tokens that have been deaffixed - * - * @deprecated Replaced by SimpleTokenSplitter. - */ - @Deprecated - public static IList<String> deAffixTokens(IList<String> input, Deque<IPair<String, String>> operators) { - return null; - } - - /** * Select a number of random items from the list without replacement * * @param <E> @@ -113,7 +93,7 @@ public class ListUtils { Iterator<E> itr = list.toIterable().iterator(); E element = null; - for (int index = 0; itr.hasNext(); element = itr.next()) { + for(int index = 0; itr.hasNext(); element = itr.next()) { // n - m int winningChance = number - selected.getSize(); @@ -121,7 +101,7 @@ public class ListUtils { int totalChance = total - (index - 1); // Probability of selecting the t+1'th element - if (NumberUtils.isProbable(winningChance, totalChance, rng)) { + if(NumberUtils.isProbable(winningChance, totalChance, rng)) { selected.add(element); } } @@ -147,7 +127,7 @@ public class ListUtils { public static <E> IList<E> drawWithReplacement(IList<E> list, int number, Function<Integer, Integer> rng) { IList<E> selected = new FunctionalList<>(new ArrayList<>(number)); - for (int i = 0; i < number; i++) { + for(int i = 0; i < number; i++) { selected.add(list.randItem(rng)); } @@ -173,11 +153,11 @@ public class ListUtils { */ public static <E> IList<IList<E>> groupPartition(IList<E> input, Function<E, Integer> counter, int partitionSize) { - if (input == null) + if(input == null) throw new NullPointerException("Input list must not be null"); - else if (counter == null) + else if(counter == null) throw new NullPointerException("Counter must not be null"); - else if (partitionSize < 1 || partitionSize > input.getSize()) { + else if(partitionSize < 1 || partitionSize > input.getSize()) { String fmt = "%d is not a valid partition size. Must be between 1 and %d"; String msg = String.format(fmt, partitionSize, input.getSize()); @@ -199,13 +179,13 @@ public class ListUtils { /* * Run up to a certain number of passes */ - for (int numberOfIterations = 0; numberOfIterations < MAX_NTRIESPART + for(int numberOfIterations = 0; numberOfIterations < MAX_NTRIESPART && !rejected.isEmpty(); numberOfIterations++) { input.forEach(it); - if (rejected.isEmpty()) // Nothing was rejected, so - // we're - // done + if(rejected.isEmpty()) // Nothing was rejected, so + // we're + // done return returned; } @@ -229,8 +209,8 @@ public class ListUtils { public static <E> IList<E> mergeLists(IList<E>... lists) { IList<E> returned = new FunctionalList<>(); - for (IList<E> list : lists) { - for (E itm : list.toIterable()) { + for(IList<E> list : lists) { + for(E itm : list.toIterable()) { returned.add(itm); } } @@ -260,22 +240,22 @@ public class ListUtils { IList<E> returned = new FunctionalList<>(); - for (E itm : list.toIterable()) { + for(E itm : list.toIterable()) { count += counter.apply(itm); returned.add(itm); } - if (count % size != 0) { + if(count % size != 0) { // We need to pad int needed = count % size; int threshold = 0; - while (needed > 0 && threshold <= MAX_NTRIESPART) { + while(needed > 0 && threshold <= MAX_NTRIESPART) { E val = padder.get(); int newCount = counter.apply(val); - if (newCount <= needed) { + if(newCount <= needed) { returned.add(val); threshold = 0; @@ -286,31 +266,11 @@ public class ListUtils { } } - if (threshold > MAX_NTRIESPART) + if(threshold > MAX_NTRIESPART) throw new IllegalArgumentException("Heuristic (more than " + MAX_NTRIESPART + " iterations of attempting to pad) detected unpaddable list "); } return returned; } - - /** - * Split tokens in a list of tokens into multiple tokens. - * - * The intended use is for expression parsers so that you can enter - * something like 1+1 instead of 1 + 1. - * - * @param input - * The tokens to split - * @param operators - * Pairs of operators to split on and regexes that match - * those operators - * @return A list of tokens split on all the operators - * - * @deprecated Use SimpleTokenSplitter now - */ - @Deprecated - public static IList<String> splitTokens(IList<String> input, Deque<IPair<String, String>> operators) { - return null; - } } diff --git a/BJC-Utils2/src/main/java/bjc/utils/ioutils/RegexStringEditor.java b/BJC-Utils2/src/main/java/bjc/utils/ioutils/RegexStringEditor.java index 2825346..4f66a99 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/ioutils/RegexStringEditor.java +++ b/BJC-Utils2/src/main/java/bjc/utils/ioutils/RegexStringEditor.java @@ -1,7 +1,12 @@ package bjc.utils.ioutils; +import bjc.utils.data.Toggle; +import bjc.utils.data.ValueToggle; +import bjc.utils.funcdata.FunctionalList; +import bjc.utils.funcdata.IList; import bjc.utils.functypes.ID; +import java.util.function.BiFunction; import java.util.function.UnaryOperator; import java.util.regex.Matcher; import java.util.regex.Pattern; @@ -13,6 +18,8 @@ import java.util.regex.Pattern; * */ public class RegexStringEditor { + private static final UnaryOperator<String> SID = ID.id(); + /** * Replace every occurrence of the pattern with the result of applying * the action to the string matched by the pattern. @@ -29,7 +36,7 @@ public class RegexStringEditor { * @return The string, with matches replaced with the action. */ public static String onOccurances(String input, Pattern patt, UnaryOperator<String> action) { - return occurances(input, patt, ID.id(), action); + return reduceOccurances(input, patt, SID, action); } /** @@ -49,7 +56,7 @@ public class RegexStringEditor { * the action. */ public static String betweenOccurances(String input, Pattern patt, UnaryOperator<String> action) { - return occurances(input, patt, action, ID.id()); + return reduceOccurances(input, patt, action, SID); } /** @@ -58,7 +65,7 @@ public class RegexStringEditor { * @param input * The input string. * - * @param patt + * @param rPatt * The pattern to match against the string. * * @param betweenAction @@ -69,11 +76,59 @@ public class RegexStringEditor { * * @return The string, with both actions applied. */ - public static String occurances(String input, Pattern patt, UnaryOperator<String> betweenAction, + public static String reduceOccurances(String input, Pattern rPatt, UnaryOperator<String> betweenAction, UnaryOperator<String> onAction) { - Matcher matcher = patt.matcher(input); + IList<String> occurances = listOccurances(input, rPatt); + + Toggle<UnaryOperator<String>> actions = new ValueToggle<>(onAction, betweenAction); + BiFunction<String, StringBuilder, StringBuilder> reducer = (strang, state) -> { + return state.append(actions.get().apply(strang)); + }; + + return occurances.reduceAux(new StringBuilder(), reducer, StringBuilder::toString); + } + + /** + * Execute actions between and on matches of a regular expression. + * + * @param input + * The input string. + * + * @param rPatt + * The pattern to match against the string. + * + * @param betweenAction + * The function to execute between matches of the string. + * + * @param onAction + * The function to execute on matches of the string. + * + * @return The string, with both actions applied. + */ + public static IList<String> mapOccurances(String input, Pattern rPatt, UnaryOperator<String> betweenAction, + UnaryOperator<String> onAction) { + IList<String> occurances = listOccurances(input, rPatt); + Toggle<UnaryOperator<String>> actions = new ValueToggle<>(onAction, betweenAction); + + return occurances.map(strang -> actions.get().apply(strang)); + } + + /** + * Separate a string into match/non-match segments. + * + * @param input + * The string to separate. + * + * @param rPatt + * The pattern to use for separation. + * + * @return The string, as a list of match/non-match segments, + * starting/ending with a non-match segment. + */ + public static IList<String> listOccurances(String input, Pattern rPatt) { + IList<String> res = new FunctionalList<>(); - StringBuffer res = new StringBuffer(); + Matcher matcher = rPatt.matcher(input); StringBuffer work = new StringBuffer(); @@ -82,17 +137,17 @@ public class RegexStringEditor { matcher.appendReplacement(work, ""); - res.append(betweenAction.apply(matcher.toString())); - res.append(onAction.apply(match)); + res.add(work.toString()); + res.add(match); work = new StringBuffer(); } matcher.appendTail(work); - res.append(betweenAction.apply(work.toString())); + res.add(work.toString()); - return res.toString(); + return res; } /** diff --git a/BJC-Utils2/src/main/java/bjc/utils/ioutils/SimpleProperties.java b/BJC-Utils2/src/main/java/bjc/utils/ioutils/SimpleProperties.java index a43b16a..531e8b8 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/ioutils/SimpleProperties.java +++ b/BJC-Utils2/src/main/java/bjc/utils/ioutils/SimpleProperties.java @@ -32,27 +32,25 @@ public class SimpleProperties implements Map<String, String> { * All leading/trailing spaces from the name & body are removed. * * @param is - * The stream to read from. + * The stream to read from. * * @param allowDuplicates - * Whether or not duplicate keys should be allowed. + * Whether or not duplicate keys should be allowed. */ public void loadFrom(InputStream is, boolean allowDuplicates) { - try (Scanner scn = new Scanner(is)) { - while (scn.hasNextLine()) { + try(Scanner scn = new Scanner(is)) { + while(scn.hasNextLine()) { String ln = scn.nextLine().trim(); /* * Skip blank lines/comments */ - if (ln.equals("")) - continue; - if (ln.startsWith("#")) - continue; + if(ln.equals("")) continue; + if(ln.startsWith("#")) continue; int sepIdx = ln.indexOf(' '); - if (sepIdx == -1) { + if(sepIdx == -1) { String fmt = "Properties must be a name, a space, then the body.\n\tOffending line is '%s'"; String msg = String.format(fmt, ln); @@ -62,7 +60,7 @@ public class SimpleProperties implements Map<String, String> { String name = ln.substring(0, sepIdx).trim(); String body = ln.substring(sepIdx).trim(); - if (!allowDuplicates && containsKey(name)) { + if(!allowDuplicates && containsKey(name)) { String msg = String.format("Duplicate key '%s'", name); throw new IllegalStateException(msg); @@ -71,13 +69,19 @@ public class SimpleProperties implements Map<String, String> { put(name, body); } } + } + /** + * Output the set of read properties. + */ + public void outputProperties() { System.out.println("Read properties:"); - for (Entry<String, String> entry : entrySet()) { + + for(Entry<String, String> entry : entrySet()) { System.out.printf("\t'%s'\t'%s'\n", entry.getKey(), entry.getValue()); } - System.out.println(); + System.out.println(); } @Override diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/TokenUtils.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/TokenUtils.java index 1d31522..39e0c4e 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/TokenUtils.java +++ b/BJC-Utils2/src/main/java/bjc/utils/parserutils/TokenUtils.java @@ -1,5 +1,9 @@ package bjc.utils.parserutils; +import bjc.utils.funcdata.FunctionalList; +import bjc.utils.funcdata.IList; +import bjc.utils.parserutils.splitterv2.TokenSplitter; + import java.util.LinkedList; import java.util.List; import java.util.regex.Matcher; @@ -17,6 +21,17 @@ import static bjc.utils.PropertyDB.applyFormat; * TODO add support for user defined escapes. */ public class TokenUtils { + /** + * @author EVE + * + */ + public static class StringTokenSplitter implements TokenSplitter { + @Override + public IList<String> split(String input) { + return new FunctionalList<>(TokenUtils.removeDQuotedStrings(input)); + } + } + /* * Patterns and pattern parts. */ diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/splitter/SimpleTokenSplitter.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/splitter/SimpleTokenSplitter.java index 170c619..ccc823d 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/splitter/SimpleTokenSplitter.java +++ b/BJC-Utils2/src/main/java/bjc/utils/parserutils/splitter/SimpleTokenSplitter.java @@ -1,7 +1,5 @@ package bjc.utils.parserutils.splitter; -import bjc.utils.ioutils.RegexStringEditor; - import java.util.HashSet; import java.util.Set; import java.util.regex.Pattern; @@ -10,9 +8,8 @@ import java.util.regex.Pattern; * Simple implementation of {@link TokenSplitter} * * @author EVE - * - * TODO rewrite using {@link RegexStringEditor} */ +@Deprecated public class SimpleTokenSplitter implements TokenSplitter { /* * This string is a format template for the delimiter matching regex diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/splitter/TokenSplitter.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/splitter/TokenSplitter.java index e59d88e..04551a7 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/splitter/TokenSplitter.java +++ b/BJC-Utils2/src/main/java/bjc/utils/parserutils/splitter/TokenSplitter.java @@ -5,6 +5,7 @@ package bjc.utils.parserutils.splitter; * * @author Ben Culkin */ +@Deprecated public interface TokenSplitter { /** * Split a provided string using configured delimiters, and keeping the diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/splitter/TwoLevelSplitter.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/splitter/TwoLevelSplitter.java index d65b06a..1d6d0a2 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/splitter/TwoLevelSplitter.java +++ b/BJC-Utils2/src/main/java/bjc/utils/parserutils/splitter/TwoLevelSplitter.java @@ -18,6 +18,7 @@ import java.util.regex.Pattern; * @author EVE * */ +@Deprecated public class TwoLevelSplitter implements TokenSplitter { private SimpleTokenSplitter high; private SimpleTokenSplitter low; |