diff options
Diffstat (limited to 'BJC-Utils2/src/main/java/bjc/utils/funcutils')
15 files changed, 163 insertions, 183 deletions
diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcutils/CollectorUtils.java b/BJC-Utils2/src/main/java/bjc/utils/funcutils/CollectorUtils.java index 1e5d7de..9a8cca3 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/funcutils/CollectorUtils.java +++ b/BJC-Utils2/src/main/java/bjc/utils/funcutils/CollectorUtils.java @@ -1,20 +1,20 @@ package bjc.utils.funcutils; -import java.util.stream.Collector; - import bjc.utils.data.IHolder; import bjc.utils.data.IPair; +import java.util.stream.Collector; + /** * Utilities for producing implementations of {@link Collector} - * + * * @author ben * */ public class CollectorUtils { /** * Create a collector that applies two collectors at once - * + * * @param <InitialType> * The type of the collection to collect from * @param <AuxType1> diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcutils/CompoundCollector.java b/BJC-Utils2/src/main/java/bjc/utils/funcutils/CompoundCollector.java index 1f73d0a..7e7b003 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/funcutils/CompoundCollector.java +++ b/BJC-Utils2/src/main/java/bjc/utils/funcutils/CompoundCollector.java @@ -1,5 +1,10 @@ package bjc.utils.funcutils; +import bjc.utils.data.IHolder; +import bjc.utils.data.IPair; +import bjc.utils.data.Identity; +import bjc.utils.data.Pair; + import java.util.Set; import java.util.function.BiConsumer; import java.util.function.BinaryOperator; @@ -7,18 +12,13 @@ import java.util.function.Function; import java.util.function.Supplier; import java.util.stream.Collector; -import bjc.utils.data.IHolder; -import bjc.utils.data.IPair; -import bjc.utils.data.Identity; -import bjc.utils.data.Pair; - final class CompoundCollector<InitialType, AuxType1, AuxType2, FinalType1, FinalType2> implements Collector<InitialType, IHolder<IPair<AuxType1, AuxType2>>, IPair<FinalType1, FinalType2>> { private Set<java.util.stream.Collector.Characteristics> characteristicSet; - private Collector<InitialType, AuxType1, FinalType1> first; - private Collector<InitialType, AuxType2, FinalType2> second; + private Collector<InitialType, AuxType1, FinalType1> first; + private Collector<InitialType, AuxType2, FinalType2> second; public CompoundCollector(Collector<InitialType, AuxType1, FinalType1> first, Collector<InitialType, AuxType2, FinalType2> second) { diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcutils/DoubleMatcher.java b/BJC-Utils2/src/main/java/bjc/utils/funcutils/DoubleMatcher.java index 747b39f..8d0715d 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/funcutils/DoubleMatcher.java +++ b/BJC-Utils2/src/main/java/bjc/utils/funcutils/DoubleMatcher.java @@ -8,8 +8,8 @@ import java.util.regex.Pattern; * Uses a regex from the javadoc for Double.valueOf() */ class DoubleMatcher { - private static final String Digits = "(\\p{Digit}+)"; - private static final String HexDigits = "(\\p{XDigit}+)"; + private static final String Digits = "(\\p{Digit}+)"; + private static final String HexDigits = "(\\p{XDigit}+)"; /* * an exponent is 'e' or 'E' followed by an optionally signed decimal @@ -17,7 +17,7 @@ class DoubleMatcher { */ private static final String Exp = "[eE][+-]?" + Digits; - private static final String fpRegex = ("[\\x00-\\x20]*" + // Optional + private static final String fpRegex = "[\\x00-\\x20]*" + // Optional // leading // "whitespace" "[+-]?(" + // Optional sign character @@ -64,7 +64,7 @@ class DoubleMatcher { */ "(0[xX]" + HexDigits + "?(\\.)" + HexDigits + ")" + - ")[pP][+-]?" + Digits + "))" + "[fFdD]?))" + "[\\x00-\\x20]*"); // Optional + ")[pP][+-]?" + Digits + "))" + "[fFdD]?))" + "[\\x00-\\x20]*"; // Optional // trailing // "whitespace" diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcutils/EnumUtils.java b/BJC-Utils2/src/main/java/bjc/utils/funcutils/EnumUtils.java index 82a29a2..cab444d 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/funcutils/EnumUtils.java +++ b/BJC-Utils2/src/main/java/bjc/utils/funcutils/EnumUtils.java @@ -1,21 +1,21 @@ package bjc.utils.funcutils; -import java.util.Random; -import java.util.function.Consumer; - import bjc.utils.funcdata.FunctionalList; import bjc.utils.funcdata.IList; +import java.util.Random; +import java.util.function.Consumer; + /** * Utility methods on enums - * + * * @author ben * */ public class EnumUtils { /** * Do an action for a random number of enum values - * + * * @param <E> * The type of the enum * @param clasz @@ -35,7 +35,7 @@ public class EnumUtils { int randomValueCount = enumValues.length - nValues; - for (int i = 0; i <= randomValueCount; i++) { + for(int i = 0; i <= randomValueCount; i++) { E rDir = valueList.randItem(rnd::nextInt); valueList.removeMatching(rDir); @@ -46,7 +46,7 @@ public class EnumUtils { /** * Get a random value from an enum - * + * * @param <E> * The type of the enum * @param clasz diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcutils/FileUtils.java b/BJC-Utils2/src/main/java/bjc/utils/funcutils/FileUtils.java index 35a6b3d..4c9c525 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/funcutils/FileUtils.java +++ b/BJC-Utils2/src/main/java/bjc/utils/funcutils/FileUtils.java @@ -8,15 +8,15 @@ import java.util.function.BiPredicate; /** * Utilities for doing things with files - * + * * @author ben * */ public class FileUtils { /** * Traverse a directory recursively. This is a depth-first traversal - * - * + * + * * @param root * The directory to start the traversal at * @param predicate @@ -28,7 +28,7 @@ public class FileUtils { * returning false stops it * @throws IOException * if the walk throws an exception - * + * * TODO If it becomes necessary, write another overload * for this with all the buttons and knobs from * walkFileTree diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcutils/FuncUtils.java b/BJC-Utils2/src/main/java/bjc/utils/funcutils/FuncUtils.java index 3eb086b..cb15d40 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/funcutils/FuncUtils.java +++ b/BJC-Utils2/src/main/java/bjc/utils/funcutils/FuncUtils.java @@ -6,7 +6,7 @@ import java.util.function.Function; /** * Utility things for functions - * + * * @author ben * */ @@ -14,7 +14,7 @@ public class FuncUtils { /** * Convert a binary function into a unary function that returns a * function - * + * * @param <A> * The initial type of the function * @param <B> @@ -34,14 +34,14 @@ public class FuncUtils { /** * Do the specified action the specified number of times - * + * * @param nTimes * The number of times to do the action * @param cons * The action to perform */ public static void doTimes(int nTimes, Consumer<Integer> cons) { - for (int i = 0; i < nTimes; i++) { + for(int i = 0; i < nTimes; i++) { cons.accept(i); } } diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcutils/FunctionalFileVisitor.java b/BJC-Utils2/src/main/java/bjc/utils/funcutils/FunctionalFileVisitor.java index f1240cf..c806d50 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/funcutils/FunctionalFileVisitor.java +++ b/BJC-Utils2/src/main/java/bjc/utils/funcutils/FunctionalFileVisitor.java @@ -8,8 +8,8 @@ import java.nio.file.attribute.BasicFileAttributes; import java.util.function.BiPredicate; final class FunctionalFileVisitor extends SimpleFileVisitor<Path> { - private BiPredicate<Path, BasicFileAttributes> predicate; - private BiPredicate<Path, BasicFileAttributes> action; + private BiPredicate<Path, BasicFileAttributes> predicate; + private BiPredicate<Path, BasicFileAttributes> action; public FunctionalFileVisitor(BiPredicate<Path, BasicFileAttributes> predicate, BiPredicate<Path, BasicFileAttributes> action) { @@ -19,18 +19,14 @@ final class FunctionalFileVisitor extends SimpleFileVisitor<Path> { @Override public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException { - if (predicate.test(dir, attrs)) { - return FileVisitResult.CONTINUE; - } + if(predicate.test(dir, attrs)) return FileVisitResult.CONTINUE; return FileVisitResult.SKIP_SUBTREE; } @Override public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException { - if (action.test(file, attrs)) { - return FileVisitResult.CONTINUE; - } + if(action.test(file, attrs)) return FileVisitResult.CONTINUE; return FileVisitResult.TERMINATE; } diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcutils/GroupPartIteration.java b/BJC-Utils2/src/main/java/bjc/utils/funcutils/GroupPartIteration.java index 2330a40..f736dcb 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/funcutils/GroupPartIteration.java +++ b/BJC-Utils2/src/main/java/bjc/utils/funcutils/GroupPartIteration.java @@ -1,14 +1,14 @@ package bjc.utils.funcutils; -import java.util.function.Consumer; -import java.util.function.Function; - import bjc.utils.funcdata.FunctionalList; import bjc.utils.funcdata.IList; +import java.util.function.Consumer; +import java.util.function.Function; + /** * Implements a single group partitioning pass on a list - * + * * @author ben * * @param <E> @@ -17,11 +17,11 @@ import bjc.utils.funcdata.IList; final class GroupPartIteration<E> implements Consumer<E> { private IList<IList<E>> returnedList; - public IList<E> currentPartition; - private IList<E> rejectedItems; + public IList<E> currentPartition; + private IList<E> rejectedItems; - private int numberInCurrentPartition; - private int numberPerPartition; + private int numberInCurrentPartition; + private int numberPerPartition; private Function<E, Integer> elementCounter; @@ -40,7 +40,7 @@ final class GroupPartIteration<E> implements Consumer<E> { public void accept(E value) { boolean shouldStartPartition = numberInCurrentPartition >= numberPerPartition; - if (shouldStartPartition) { + if(shouldStartPartition) { returnedList.add(currentPartition); currentPartition = new FunctionalList<>(); @@ -48,9 +48,9 @@ final class GroupPartIteration<E> implements Consumer<E> { } else { int currentElementCount = elementCounter.apply(value); - boolean shouldReject = (numberInCurrentPartition + currentElementCount) >= numberPerPartition; + boolean shouldReject = numberInCurrentPartition + currentElementCount >= numberPerPartition; - if (shouldReject) { + if(shouldReject) { rejectedItems.add(value); } else { currentPartition.add(value); diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcutils/IBuilder.java b/BJC-Utils2/src/main/java/bjc/utils/funcutils/IBuilder.java index 357ce70..a96a4d6 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/funcutils/IBuilder.java +++ b/BJC-Utils2/src/main/java/bjc/utils/funcutils/IBuilder.java @@ -2,7 +2,7 @@ package bjc.utils.funcutils; /** * Generic interface for objects that implement the builder pattern - * + * * @author ben * * @param <E> @@ -11,7 +11,7 @@ package bjc.utils.funcutils; public interface IBuilder<E> { /** * Build the object this builder is building - * + * * @return The built object * @throws IllegalStateException * if the data in the builder cannot be built into its @@ -21,7 +21,7 @@ public interface IBuilder<E> { /** * Reset the state of this builder to its initial state - * + * * @throws UnsupportedOperationException * if the builder doesn't support resetting its state */ 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 4e4ce80..483b47d 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/funcutils/ListUtils.java +++ b/BJC-Utils2/src/main/java/bjc/utils/funcutils/ListUtils.java @@ -1,19 +1,19 @@ 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; -import bjc.utils.data.IPair; -import bjc.utils.funcdata.FunctionalList; -import bjc.utils.funcdata.IList; - /** * Utilities for manipulating FunctionalLists that don't belong in the class * itself - * + * * @author ben * */ @@ -23,15 +23,13 @@ public class ListUtils { /** * Collapse a string of tokens into a single string without adding any * spaces - * + * * @param input * The list of tokens to collapse * @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, ""); } @@ -39,7 +37,7 @@ public class ListUtils { /** * Collapse a string of tokens into a single string, adding the desired * seperator after each token - * + * * @param input * The list of tokens to collapse * @param seperator @@ -47,24 +45,22 @@ public class ListUtils { * @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 { + 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); } @@ -77,24 +73,22 @@ 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 - * + * */ public static IList<String> deAffixTokens(IList<String> input, Deque<IPair<String, String>> operators) { - if (input == null) { + if(input == null) throw new NullPointerException("Input must not be null"); - } else if (operators == null) { - throw new NullPointerException("Set of operators must not be null"); - } + else if(operators == null) throw new NullPointerException("Set of operators must not be null"); IList<String> returned = input; - for (IPair<String, String> op : operators) { + for(IPair<String, String> op : operators) { returned = returned.flatMap(token -> { return op.merge(new TokenDeaffixer(token)); }); @@ -105,7 +99,7 @@ public class ListUtils { /** * Select a number of random items from the list without replacement - * + * * @param <E> * The type of items to select * @param list @@ -127,7 +121,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()) { int winningChance = number - selected.getSize(); // n - m @@ -135,7 +129,7 @@ public class ListUtils { // N - t // Probability of selecting the t+1'th element - if (NumberUtils.isProbable(winningChance, totalChance, rng)) { + if(NumberUtils.isProbable(winningChance, totalChance, rng)) { selected.add(element); } } @@ -145,7 +139,7 @@ public class ListUtils { /** * Select a number of random items from the list, with replacement - * + * * @param <E> * The type of items to select * @param list @@ -161,7 +155,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)); } @@ -171,10 +165,10 @@ public class ListUtils { /** * Partition a list into a list of lists, where each element can count * for more than one element in a partition - * + * * @param <E> * The type of elements in the list to partition - * + * * @param input * The list to partition * @param counter @@ -182,19 +176,18 @@ public class ListUtils { * for * @param partitionSize * The number of elements to put in each partition - * + * * @return A list partitioned according to the above rules */ 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()) throw new IllegalArgumentException("" + partitionSize + " is not a valid" + " partition size. Must be between 1 and " + input.getSize()); - } /* * List that holds our results @@ -211,14 +204,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; - } } throw new IllegalArgumentException("Heuristic (more than " + MAX_NTRIESPART @@ -230,7 +222,7 @@ public class ListUtils { /** * Merge the contents of a bunch of lists together into a single list - * + * * @param <E> * The type of value in this lists * @param lists @@ -241,8 +233,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); } } @@ -252,7 +244,7 @@ public class ListUtils { /** * Pad the provided list out to the desired size - * + * * @param <E> * The type of elements in the list * @param list @@ -272,22 +264,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; @@ -298,10 +290,9 @@ 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; @@ -309,28 +300,26 @@ public class ListUtils { /** * 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 - * + * */ public static IList<String> splitTokens(IList<String> input, Deque<IPair<String, String>> operators) { - if (input == null) { + if(input == null) throw new NullPointerException("Input must not be null"); - } else if (operators == null) { - throw new NullPointerException("Set of operators must not be null"); - } + else if(operators == null) throw new NullPointerException("Set of operators must not be null"); IList<String> returned = input; - for (IPair<String, String> op : operators) { + for(IPair<String, String> op : operators) { returned = returned.flatMap(token -> { return op.merge(new TokenSplitter(token)); }); diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcutils/NeoTokenSplitter.java b/BJC-Utils2/src/main/java/bjc/utils/funcutils/NeoTokenSplitter.java index 09c3ef7..6007429 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/funcutils/NeoTokenSplitter.java +++ b/BJC-Utils2/src/main/java/bjc/utils/funcutils/NeoTokenSplitter.java @@ -29,11 +29,11 @@ public class NeoTokenSplitter { */ private static String WITH_MULTI_DELIM = "((?<=%1$s+)(?!%1$s)|(?<!%1$s)(?=%1$s+))"; - private StringBuilder currPatt; - private StringBuilder currExclusionPatt; + private StringBuilder currPatt; + private StringBuilder currExclusionPatt; - private Pattern compPatt; - private Pattern exclusionPatt; + private Pattern compPatt; + private Pattern exclusionPatt; /** * Create a new token splitter. @@ -56,15 +56,12 @@ public class NeoTokenSplitter { * If the splitter isn't compiled. */ public String[] split(String inp) { - if (compPatt == null) { - throw new IllegalStateException("Token splitter has not been compiled yet"); - } + if(compPatt == null) throw new IllegalStateException("Token splitter has not been compiled yet"); /* * Don't split something that matches only an operator */ - if (exclusionPatt.matcher(inp).matches()) - return new String[] { inp }; + if(exclusionPatt.matcher(inp).matches()) return new String[] { inp }; return compPatt.split(inp); } @@ -82,7 +79,7 @@ public class NeoTokenSplitter { String quoteDelim = Pattern.quote(delim); String delimPat = String.format(WITH_DELIM, quoteDelim); - if (currPatt == null) { + if(currPatt == null) { currPatt = new StringBuilder(); currExclusionPatt = new StringBuilder(); @@ -106,7 +103,7 @@ public class NeoTokenSplitter { public void addMultiDelimiter(String delim) { String delimPat = String.format(WITH_MULTI_DELIM, "(?:" + delim + ")"); - if (currPatt == null) { + if(currPatt == null) { currPatt = new StringBuilder(); currExclusionPatt = new StringBuilder(); diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcutils/NumberUtils.java b/BJC-Utils2/src/main/java/bjc/utils/funcutils/NumberUtils.java index d3352df..d15e885 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/funcutils/NumberUtils.java +++ b/BJC-Utils2/src/main/java/bjc/utils/funcutils/NumberUtils.java @@ -4,14 +4,14 @@ import java.util.function.Function; /** * Utility functions for dealing with numbers - * + * * @author ben * */ public class NumberUtils { /** * Compute the falling factorial of a number - * + * * @param value * The number to compute * @param power @@ -19,14 +19,14 @@ public class NumberUtils { * @return The falling factorial of the number to the power */ public static int fallingFactorial(int value, int power) { - if (power == 0) { + if(power == 0) return 1; - } else if (power == 1) { + else if(power == 1) return value; - } else { + else { int result = 1; - for (int currentSub = 0; currentSub < power + 1; currentSub++) { + for(int currentSub = 0; currentSub < power + 1; currentSub++) { result *= value - currentSub; } @@ -36,7 +36,7 @@ public class NumberUtils { /** * Evaluates a linear probability distribution - * + * * @param winning * The number of winning possibilities * @param total diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcutils/StringUtils.java b/BJC-Utils2/src/main/java/bjc/utils/funcutils/StringUtils.java index 2afb783..82e2a79 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/funcutils/StringUtils.java +++ b/BJC-Utils2/src/main/java/bjc/utils/funcutils/StringUtils.java @@ -8,7 +8,7 @@ import java.util.regex.Pattern; /** * Utility methods for operations on strings - * + * * @author ben * */ @@ -16,7 +16,7 @@ public class StringUtils { /** * Checks if the given expression contains the specified operator in a * situation that indicates its use as an infix operator. - * + * * @param expression * The expression to check * @param operator @@ -35,7 +35,7 @@ public class StringUtils { /** * Check if a string consists only of one or more matches of a regular * expression - * + * * @param input * The string to check * @param regex @@ -45,15 +45,13 @@ public class StringUtils { * of the provided regex */ public static boolean containsOnly(String input, String regex) { - if (input == null) { + if(input == null) throw new NullPointerException("Input must not be null"); - } else if (regex == null) { - throw new NullPointerException("Regex must not be null"); - } + else if(regex == null) throw new NullPointerException("Regex must not be null"); /* * This regular expression is fairly simple. - * + * * First, we match the beginning of the string. Then, we start a * non-capturing group whose contents are the passed in regex. * That group is then matched one or more times and the pattern @@ -64,14 +62,14 @@ public class StringUtils { /** * Indent the string being built in a StringBuilder n levels - * + * * @param builder * The builder to indent in * @param levels * The number of levels to indent */ public static void indentNLevels(StringBuilder builder, int levels) { - for (int i = 0; i < levels; i++) { + for(int i = 0; i < levels; i++) { builder.append("\t"); } } @@ -79,7 +77,7 @@ public class StringUtils { /** * Print out a deque with a special case for easily showing a deque is * empty - * + * * @param <ContainedType> * The type in the deque * @param queue @@ -94,16 +92,23 @@ public class StringUtils { /* * This regex matches java-style string escapes */ - private static String escapeString = "\\\\([btnfr\"'\\\\]" // Match - // shortform - // escape - // sequences - // like - // \t or - // \" - + "|[0-3]?[0-7]{1,2}" // Match octal escape sequences - + "|u[0-9a-fA-F]{4})"; // Match unicode escape sequences - private static Pattern escapePatt = Pattern.compile(escapeString); + private static String escapeString = "\\\\([btnfr\"'\\\\]" // Match + // shortform + // escape + // sequences + // like + // \t + // or + // \" + + "|[0-3]?[0-7]{1,2}" // Match + // octal + // escape + // sequences + + "|u[0-9a-fA-F]{4})"; // Match + // unicode + // escape + // sequences + private static Pattern escapePatt = Pattern.compile(escapeString); /* * This regular expression matches java style double quoted strings @@ -139,7 +144,7 @@ public class StringUtils { Matcher mt = doubleQuotePatt.matcher(inp); - while (mt.find()) { + while(mt.find()) { mt.appendReplacement(work, ""); res.add(work.toString()); @@ -166,11 +171,11 @@ public class StringUtils { StringBuffer work = new StringBuffer(); Matcher escapeFinder = escapePatt.matcher(inp); - while (escapeFinder.find()) { + while(escapeFinder.find()) { String escapeSeq = escapeFinder.group(); String escapeRep = ""; - switch (escapeSeq) { + switch(escapeSeq) { case "\\b": escapeRep = "\b"; break; @@ -196,7 +201,7 @@ public class StringUtils { escapeRep = "\\"; break; default: - if (escapeSeq.startsWith("u")) { + if(escapeSeq.startsWith("u")) { escapeRep = handleUnicodeEscape(escapeSeq.substring(1)); } else { escapeRep = handleOctalEscape(escapeSeq); diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcutils/TokenDeaffixer.java b/BJC-Utils2/src/main/java/bjc/utils/funcutils/TokenDeaffixer.java index 151b7e2..f550b65 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/funcutils/TokenDeaffixer.java +++ b/BJC-Utils2/src/main/java/bjc/utils/funcutils/TokenDeaffixer.java @@ -1,10 +1,10 @@ package bjc.utils.funcutils; -import java.util.function.BiFunction; - import bjc.utils.funcdata.FunctionalList; import bjc.utils.funcdata.IList; +import java.util.function.BiFunction; + final class TokenDeaffixer implements BiFunction<String, String, IList<String>> { private String token; @@ -14,38 +14,34 @@ final class TokenDeaffixer implements BiFunction<String, String, IList<String>> @Override public IList<String> apply(String operatorName, String operatorRegex) { - if (operatorName == null) { + if(operatorName == null) throw new NullPointerException("Operator name must not be null"); - } else if (operatorRegex == null) { - throw new NullPointerException("Operator regex must not be null"); - } + else if(operatorRegex == null) throw new NullPointerException("Operator regex must not be null"); - if (StringUtils.containsOnly(token, operatorRegex)) { + if(StringUtils.containsOnly(token, operatorRegex)) return new FunctionalList<>(token); - } else if (token.startsWith(operatorName)) { - if (token.endsWith(operatorName)) { + else if(token.startsWith(operatorName)) { + if(token.endsWith(operatorName)) return new FunctionalList<>(operatorName, token.split(operatorRegex)[1], operatorName); - } return new FunctionalList<>(operatorName, token.split(operatorRegex)[1]); - } else if (token.endsWith(operatorName)) { + } else if(token.endsWith(operatorName)) return new FunctionalList<>(token.split(operatorRegex)[0], operatorName); - } else if (token.contains(operatorName)) { + else if(token.contains(operatorName)) { String[] tokenParts = token.split(operatorRegex); IList<String> returned = new FunctionalList<>(); - for (int i = 0; i < tokenParts.length; i++) { + for(int i = 0; i < tokenParts.length; i++) { returned.add(tokenParts[i]); - if (i < tokenParts.length - 1) { + if(i < tokenParts.length - 1) { returned.add(operatorName); } } return returned; - } else { + } else return new FunctionalList<>(token); - } } } diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcutils/TokenSplitter.java b/BJC-Utils2/src/main/java/bjc/utils/funcutils/TokenSplitter.java index 4176088..84f5270 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/funcutils/TokenSplitter.java +++ b/BJC-Utils2/src/main/java/bjc/utils/funcutils/TokenSplitter.java @@ -1,11 +1,11 @@ package bjc.utils.funcutils; -import java.util.Iterator; -import java.util.function.BiFunction; - import bjc.utils.funcdata.FunctionalList; import bjc.utils.funcdata.IList; +import java.util.Iterator; +import java.util.function.BiFunction; + final class TokenSplitter implements BiFunction<String, String, IList<String>> { private String tokenToSplit; @@ -15,16 +15,13 @@ final class TokenSplitter implements BiFunction<String, String, IList<String>> { @Override public IList<String> apply(String operatorName, String operatorRegex) { - if (operatorName == null) { + if(operatorName == null) throw new NullPointerException("Operator name must not be null"); - } else if (operatorRegex == null) { - throw new NullPointerException("Operator regex must not be null"); - } + else if(operatorRegex == null) throw new NullPointerException("Operator regex must not be null"); - if (tokenToSplit.contains(operatorName)) { - if (StringUtils.containsOnly(tokenToSplit, operatorRegex)) { + if(tokenToSplit.contains(operatorName)) { + if(StringUtils.containsOnly(tokenToSplit, operatorRegex)) return new FunctionalList<>(tokenToSplit); - } IList<String> splitTokens = new FunctionalList<>(tokenToSplit.split(operatorRegex)); IList<String> result = new FunctionalList<>(); @@ -34,10 +31,10 @@ final class TokenSplitter implements BiFunction<String, String, IList<String>> { String elm = itr.next(); - for (int i = 0; itr.hasNext(); elm = itr.next()) { + for(int i = 0; itr.hasNext(); elm = itr.next()) { result.add(elm); - if (i != tokenExpansionSize) { + if(i != tokenExpansionSize) { result.add(operatorName); } } |