diff options
Diffstat (limited to 'BJC-Utils2/src/main/java/bjc/utils/funcutils')
11 files changed, 157 insertions, 184 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 0a1efd5..eb3695e 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/funcutils/CollectorUtils.java +++ b/BJC-Utils2/src/main/java/bjc/utils/funcutils/CollectorUtils.java @@ -25,20 +25,17 @@ public class CollectorUtils { * The final type of the first collector * @param <FinalType2> * The final type of the second collector - * @param firstCollector + * @param first * The first collector to use - * @param secondCollector + * @param second * The second collector to use * @return A collector that functions as mentioned above */ - public static <InitialType, AuxType1, AuxType2, FinalType1, - FinalType2> Collector<InitialType, - IHolder<IPair<AuxType1, AuxType2>>, - IPair<FinalType1, FinalType2>> compoundCollect( - Collector<InitialType, AuxType1, - FinalType1> firstCollector, - Collector<InitialType, AuxType2, - FinalType2> secondCollector) { - return new CompoundCollector<>(firstCollector, secondCollector); + public static <InitialType, AuxType1, AuxType2, FinalType1, FinalType2> + Collector<InitialType, IHolder<IPair<AuxType1, AuxType2>>, IPair<FinalType1, FinalType2>> + compoundCollect( + Collector<InitialType, AuxType1, FinalType1> first, + Collector<InitialType, AuxType2, FinalType2> second) { + return new CompoundCollector<>(first, second); } } 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 257f005..de5fe85 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/funcutils/CompoundCollector.java +++ b/BJC-Utils2/src/main/java/bjc/utils/funcutils/CompoundCollector.java @@ -12,77 +12,66 @@ 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; +final class CompoundCollector<InitialType, AuxType1, AuxType2, FinalType1, FinalType2> + implements Collector<InitialType, IHolder<IPair<AuxType1, AuxType2>>, IPair<FinalType1, FinalType2>> { - private Collector<InitialType, AuxType1, FinalType1> firstCollector; - private Collector<InitialType, AuxType2, - FinalType2> secondCollector; + private Set<java.util.stream.Collector.Characteristics> characteristicSet; + + private Collector<InitialType, AuxType1, FinalType1> first; + private Collector<InitialType, AuxType2, FinalType2> second; public CompoundCollector( - Collector<InitialType, AuxType1, FinalType1> firstCollector, - Collector<InitialType, AuxType2, FinalType2> secondCollector) { - this.firstCollector = firstCollector; - this.secondCollector = secondCollector; + Collector<InitialType, AuxType1, FinalType1> first, + Collector<InitialType, AuxType2, FinalType2> second) { + this.first = first; + this.second = second; - characteristicSet = firstCollector.characteristics(); - characteristicSet.addAll(secondCollector.characteristics()); + characteristicSet = first.characteristics(); + characteristicSet.addAll(second.characteristics()); } @Override - public BiConsumer<IHolder<IPair<AuxType1, AuxType2>>, - InitialType> accumulator() { - BiConsumer<AuxType1, InitialType> firstAccumulator = firstCollector - .accumulator(); - BiConsumer<AuxType2, - InitialType> secondAccumulator = secondCollector - .accumulator(); + public BiConsumer<IHolder<IPair<AuxType1, AuxType2>>, InitialType> accumulator() { + BiConsumer<AuxType1, InitialType> firstAccumulator = first.accumulator(); + BiConsumer<AuxType2, InitialType> secondAccumulator = second.accumulator(); return (state, value) -> { state.doWith((statePair) -> { - statePair.doWith((leftState, rightState) -> { - firstAccumulator.accept(leftState, value); - secondAccumulator.accept(rightState, value); + statePair.doWith((left, right) -> { + firstAccumulator.accept(left, value); + secondAccumulator.accept(right, value); }); }); }; } @Override - public Set< - java.util.stream.Collector.Characteristics> characteristics() { + public Set<java.util.stream.Collector.Characteristics> characteristics() { return characteristicSet; } @Override public BinaryOperator<IHolder<IPair<AuxType1, AuxType2>>> combiner() { - BinaryOperator<AuxType1> firstCombiner = firstCollector.combiner(); - BinaryOperator< - AuxType2> secondCombiner = secondCollector.combiner(); + BinaryOperator<AuxType1> firstCombiner = first.combiner(); + BinaryOperator<AuxType2> secondCombiner = second.combiner(); return (leftState, rightState) -> { return leftState.unwrap((leftPair) -> { return rightState.transform((rightPair) -> { - return leftPair.combine(rightPair, firstCombiner, - secondCombiner); + return leftPair.combine(rightPair, firstCombiner, secondCombiner); }); }); }; } @Override - public Function<IHolder<IPair<AuxType1, AuxType2>>, - IPair<FinalType1, FinalType2>> finisher() { + public Function<IHolder<IPair<AuxType1, AuxType2>>, IPair<FinalType1, FinalType2>> finisher() { return (state) -> { return state.unwrap((pair) -> { - return pair.bind((leftVal, rightVal) -> { + return pair.bind((left, right) -> { return new Pair<>( - firstCollector.finisher().apply(leftVal), - secondCollector.finisher().apply(rightVal)); + first.finisher().apply(left), + second.finisher().apply(right)); }); }); }; @@ -90,8 +79,10 @@ final class CompoundCollector<InitialType, AuxType1, AuxType2, FinalType1, @Override public Supplier<IHolder<IPair<AuxType1, AuxType2>>> supplier() { - return () -> new Identity<>( - new Pair<>(firstCollector.supplier().get(), - secondCollector.supplier().get())); + return () -> { + return new Identity<>(new Pair<>( + first.supplier().get(), + second.supplier().get())); + }; } -}
\ No newline at end of file +} 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 61b13ea..9be6080 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/funcutils/EnumUtils.java +++ b/BJC-Utils2/src/main/java/bjc/utils/funcutils/EnumUtils.java @@ -18,7 +18,7 @@ public class EnumUtils { * * @param <E> * The type of the enum - * @param enumClass + * @param clasz * The enum class * @param nValues * The number of values to execute the action on @@ -27,9 +27,9 @@ public class EnumUtils { * @param rnd * The source of randomness to use */ - public static <E extends Enum<E>> void doForValues(Class<E> enumClass, + public static <E extends Enum<E>> void doForValues(Class<E> clasz, int nValues, Consumer<E> action, Random rnd) { - E[] enumValues = enumClass.getEnumConstants(); + E[] enumValues = clasz.getEnumConstants(); IList<E> valueList = new FunctionalList<>(enumValues); @@ -49,15 +49,15 @@ public class EnumUtils { * * @param <E> * The type of the enum - * @param enumClass + * @param clasz * The class of the enum * @param rnd * The random source to use * @return A random value from the specified enum */ - public static <E extends Enum<E>> E getRandomValue(Class<E> enumClass, + public static <E extends Enum<E>> E getRandomValue(Class<E> clasz, Random rnd) { - E[] enumValues = enumClass.getEnumConstants(); + E[] enumValues = clasz.getEnumConstants(); return new FunctionalList<>(enumValues).randItem(rnd::nextInt); } 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 ea5c72e..6fc09ff 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/funcutils/FileUtils.java +++ b/BJC-Utils2/src/main/java/bjc/utils/funcutils/FileUtils.java @@ -19,10 +19,10 @@ public class FileUtils { * * @param root * The directory to start the traversal at - * @param traversalPredicate + * @param predicate * The predicate to determine whether or not to traverse a * directory - * @param traversalAction + * @param action * The action to invoke upon each file in the directory. * Returning true means to continue the traversal, returning * false stops it @@ -33,10 +33,9 @@ public class FileUtils { * this with all the buttons and knobs from walkFileTree */ public static void traverseDirectory(Path root, - BiPredicate<Path, BasicFileAttributes> traversalPredicate, - BiPredicate<Path, BasicFileAttributes> traversalAction) + BiPredicate<Path, BasicFileAttributes> predicate, + BiPredicate<Path, BasicFileAttributes> action) throws IOException { - Files.walkFileTree(root, new FunctionalFileVisitor( - traversalPredicate, traversalAction)); + Files.walkFileTree(root, new FunctionalFileVisitor(predicate, action)); } } 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 43603d6..679af52 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/funcutils/FuncUtils.java +++ b/BJC-Utils2/src/main/java/bjc/utils/funcutils/FuncUtils.java @@ -26,8 +26,7 @@ public class FuncUtils { * @return The function transformed into a unary function returning a * function */ - public static <A, B, C> Function<A, Function<B, C>> curry2( - BiFunction<A, B, C> func) { + public static <A, B, C> Function<A, Function<B, C>> curry2(BiFunction<A, B, C> func) { return (arg1) -> (arg2) -> { return func.apply(arg1, arg2); }; 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 2308d7c..cd833d9 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/funcutils/FunctionalFileVisitor.java +++ b/BJC-Utils2/src/main/java/bjc/utils/funcutils/FunctionalFileVisitor.java @@ -8,20 +8,20 @@ import java.nio.file.attribute.BasicFileAttributes; import java.util.function.BiPredicate; final class FunctionalFileVisitor extends SimpleFileVisitor<Path> { - private BiPredicate<Path, BasicFileAttributes> traversalPredicate; - private BiPredicate<Path, BasicFileAttributes> traversalAction; + private BiPredicate<Path, BasicFileAttributes> predicate; + private BiPredicate<Path, BasicFileAttributes> action; public FunctionalFileVisitor( - BiPredicate<Path, BasicFileAttributes> traversalPredicate, - BiPredicate<Path, BasicFileAttributes> traversalAction) { - this.traversalPredicate = traversalPredicate; - this.traversalAction = traversalAction; + BiPredicate<Path, BasicFileAttributes> predicate, + BiPredicate<Path, BasicFileAttributes> action) { + this.predicate = predicate; + this.action = action; } @Override - public FileVisitResult preVisitDirectory(Path dir, - BasicFileAttributes attrs) throws IOException { - if (traversalPredicate.test(dir, attrs)) { + public FileVisitResult preVisitDirectory( + Path dir, BasicFileAttributes attrs) throws IOException { + if (predicate.test(dir, attrs)) { return FileVisitResult.CONTINUE; } @@ -31,10 +31,10 @@ final class FunctionalFileVisitor extends SimpleFileVisitor<Path> { @Override public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException { - if (traversalAction.test(file, attrs)) { + if (action.test(file, attrs)) { return FileVisitResult.CONTINUE; } return FileVisitResult.TERMINATE; } -}
\ No newline at end of file +} 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 81781f6..229d271 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/funcutils/GroupPartIteration.java +++ b/BJC-Utils2/src/main/java/bjc/utils/funcutils/GroupPartIteration.java @@ -17,10 +17,13 @@ import bjc.utils.funcdata.IList; */ final class GroupPartIteration<E> implements Consumer<E> { private IList<IList<E>> returnedList; + private IHolder<IList<E>> currentPartition; private IList<E> rejectedItems; + private IHolder<Integer> numberInCurrentPartition; private int numberPerPartition; + private Function<E, Integer> elementCounter; public GroupPartIteration(IList<IList<E>> returned, @@ -37,26 +40,24 @@ final class GroupPartIteration<E> implements Consumer<E> { @Override public void accept(E value) { - if (numberInCurrentPartition - .unwrap((number) -> number >= numberPerPartition)) { - returnedList.add( - currentPartition.unwrap((partition) -> partition)); + if (numberInCurrentPartition.unwrap((number) -> number >= numberPerPartition)) { + returnedList.add(currentPartition.unwrap((partition) -> partition)); - currentPartition - .transform((partition) -> new FunctionalList<>()); + currentPartition.transform((partition) -> new FunctionalList<>()); numberInCurrentPartition.transform((number) -> 0); } else { int currentElementCount = elementCounter.apply(value); - if (numberInCurrentPartition.unwrap((number) -> (number - + currentElementCount) >= numberPerPartition)) { + boolean shouldReject = numberInCurrentPartition.unwrap((number) -> { + return (number + currentElementCount) >= numberPerPartition; + }); + + if (shouldReject) { rejectedItems.add(value); } else { - currentPartition - .unwrap((partition) -> partition.add(value)); - numberInCurrentPartition.transform( - (number) -> number + currentElementCount); + currentPartition.unwrap((partition) -> partition.add(value)); + numberInCurrentPartition.transform((number) -> number + currentElementCount); } } } -}
\ No newline at end of file +} 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 94571f5..4b17b41 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/funcutils/ListUtils.java +++ b/BJC-Utils2/src/main/java/bjc/utils/funcutils/ListUtils.java @@ -47,8 +47,7 @@ public class ListUtils { * The seperator to use for seperating tokens * @return The collapsed string of tokens */ - public static String collapseTokens(IList<String> input, - String seperator) { + public static String collapseTokens(IList<String> input, String seperator) { if (input == null) { throw new NullPointerException("Input must not be null"); } else if (seperator == null) { @@ -60,12 +59,13 @@ public class ListUtils { } else if (input.getSize() == 1) { return input.first(); } else { - return input.reduceAux("", (currentString, state) -> { - return state + currentString + seperator; - }, (strang) -> { - return strang.substring(0, - strang.length() - seperator.length()); - }); + return input.reduceAux("", + (currentString, state) -> { + return state + currentString + seperator; + }, + (strang) -> { + return strang.substring(0, strang.length() - seperator.length()); + }); } } @@ -84,21 +84,20 @@ public class ListUtils { 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"); + throw new NullPointerException("Set of operators must not be null"); } - IHolder<IList<String>> returnedList = new Identity<>(input); + IHolder<IList<String>> returned = new Identity<>(input); operators.forEach((operator) -> { - returnedList.transform((oldReturn) -> { - return oldReturn.flatMap((token) -> { + returned.transform((old) -> { + return old.flatMap((token) -> { return operator.merge(new TokenDeaffixer(token)); }); }); }); - return returnedList.unwrap((list) -> list); + return returned.unwrap((list) -> list); } /** @@ -108,7 +107,7 @@ public class ListUtils { * The type of items to select * @param list * The list to select from - * @param numberOfItems + * @param number * The number of items to selet * @param rng * A function that creates a random number from 0 to the @@ -117,26 +116,25 @@ public class ListUtils { * selected from the specified list without replacement */ - public static <E> IList<E> drawWithoutReplacement(IList<E> list, - int numberOfItems, Function<Integer, Integer> rng) { - IList<E> selectedItems = new FunctionalList<>( - new ArrayList<>(numberOfItems)); + public static <E> IList<E> drawWithoutReplacement( + IList<E> list, int number, Function<Integer, Integer> rng) { + IList<E> selected = new FunctionalList<>(new ArrayList<>(number)); - int totalItems = list.getSize(); + int total = list.getSize(); list.forEachIndexed((index, element) -> { - int winningChance = numberOfItems - selectedItems.getSize(); + int winningChance = number - selected.getSize(); // n - m - int totalChance = totalItems - (index - 1); + int totalChance = total - (index - 1); // N - t // Probability of selecting the t+1'th element if (NumberUtils.isProbable(winningChance, totalChance, rng)) { - selectedItems.add(element); + selected.add(element); } }); - return selectedItems; + return selected; } /** @@ -146,7 +144,7 @@ public class ListUtils { * The type of items to select * @param list * The list to select from - * @param numberOfItems + * @param number * The number of items to selet * @param rng * A function that creates a random number from 0 to the @@ -155,15 +153,14 @@ public class ListUtils { * selected from the specified list */ public static <E> IList<E> drawWithReplacement(IList<E> list, - int numberOfItems, Function<Integer, Integer> rng) { - IList<E> selectedItems = new FunctionalList<>( - new ArrayList<>(numberOfItems)); + int number, Function<Integer, Integer> rng) { + IList<E> selected = new FunctionalList<>(new ArrayList<>(number)); - for (int i = 0; i < numberOfItems; i++) { - selectedItems.add(list.randItem(rng)); + for (int i = 0; i < number; i++) { + selected.add(list.randItem(rng)); } - return selectedItems; + return selected; } /** @@ -175,23 +172,22 @@ public class ListUtils { * * @param input * The list to partition - * @param elementCounter + * @param counter * The function to determine the count for each element for - * @param numberPerPartition + * @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> elementCounter, int numberPerPartition) { + public static <E> IList<IList<E>> groupPartition( + IList<E> input, Function<E, Integer> counter, int partitionSize) { if (input == null) { throw new NullPointerException("Input list must not be null"); - } else if (elementCounter == null) { + } else if (counter == null) { throw new NullPointerException("Counter must not be null"); - } else if (numberPerPartition < 1 - || numberPerPartition > input.getSize()) { + } else if (partitionSize < 1 || partitionSize > input.getSize()) { throw new IllegalArgumentException( - "" + numberPerPartition + " is not a valid" + "" + partitionSize + " is not a valid" + " partition size. Must be between 1 and " + input.getSize()); } @@ -199,36 +195,36 @@ public class ListUtils { /* * List that holds our results */ - IList<IList<E>> returnedList = new FunctionalList<>(); + IList<IList<E>> returned = new FunctionalList<>(); /* * List that holds current partition */ - IHolder<IList<E>> currentPartition = new Identity<>( - new FunctionalList<>()); + IHolder<IList<E>> current = new Identity<>(new FunctionalList<>()); + /* * List that holds elements rejected during current pass */ - IList<E> rejectedElements = new FunctionalList<>(); + IList<E> rejected = new FunctionalList<>(); /* * The effective number of elements in the current partitition */ - IHolder<Integer> numberInCurrentPartition = new Identity<>(0); + IHolder<Integer> currentSize = new Identity<>(0); /* * Run up to a certain number of passes */ for (int numberOfIterations = 0; numberOfIterations < MAX_NTRIESPART - && !rejectedElements.isEmpty(); numberOfIterations++) { - input.forEach(new GroupPartIteration<>(returnedList, - currentPartition, rejectedElements, - numberInCurrentPartition, numberPerPartition, - elementCounter)); + && !rejected.isEmpty(); numberOfIterations++) { + input.forEach(new GroupPartIteration<>(returned, + current, rejected, + currentSize, partitionSize, + counter)); - if (rejectedElements.isEmpty()) { + if (rejected.isEmpty()) { // Nothing was rejected, so we're done - return returnedList; + return returned; } } @@ -237,11 +233,11 @@ public class ListUtils { + " iterations of partitioning) detected unpartitionable list " + input.toString() + "\nThe following elements were not partitioned: " - + rejectedElements.toString() + + rejected.toString() + "\nCurrent group in formation: " - + currentPartition.unwrap((vl) -> vl.toString()) + + current.unwrap((vl) -> vl.toString()) + "\nPreviously formed groups: " - + returnedList.toString()); + + returned.toString()); } /** @@ -255,13 +251,13 @@ public class ListUtils { */ @SafeVarargs public static <E> IList<E> mergeLists(IList<E>... lists) { - IList<E> returnedList = new FunctionalList<>(); + IList<E> returned = new FunctionalList<>(); for (IList<E> list : lists) { - list.forEach(returnedList::add); + list.forEach(returned::add); } - return returnedList; + return returned; } /** @@ -275,7 +271,7 @@ public class ListUtils { * The function to count elements with * @param size * The desired size of the list - * @param padSource + * @param padder * The function to get elements to pad with * @return The list, padded to the desired size * @throws IllegalArgumentException @@ -283,26 +279,26 @@ public class ListUtils { */ public static <E> IList<E> padList(IList<E> list, Function<E, Integer> counter, int size, - Supplier<E> padSource) { - IHolder<Integer> countHolder = new Identity<>(0); + Supplier<E> padder) { + IHolder<Integer> count = new Identity<>(0); - IList<E> ret = list.map((elm) -> { - countHolder.map((val) -> val + counter.apply(elm)); + IList<E> returned = list.map((elm) -> { + count.map((val) -> val + counter.apply(elm)); return elm; }); - if (countHolder.unwrap((val) -> val % size != 0)) { + if (count.unwrap((val) -> val % size != 0)) { // We need to pad - int needed = countHolder.unwrap((val) -> val % size); + int needed = count.unwrap((val) -> val % size); int threshold = 0; while (needed > 0 && threshold <= MAX_NTRIESPART) { - E val = padSource.get(); + E val = padder.get(); int count = counter.apply(val); if (count <= needed) { - ret.add(val); + returned.add(val); threshold = 0; @@ -319,7 +315,7 @@ public class ListUtils { } } - return ret; + return returned; } /** @@ -341,20 +337,19 @@ public class ListUtils { 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"); + throw new NullPointerException("Set of operators must not be null"); } - IHolder<IList<String>> returnedList = new Identity<>(input); + IHolder<IList<String>> returned = new Identity<>(input); operators.forEach((operator) -> { - returnedList.transform((oldReturn) -> { + returned.transform((oldReturn) -> { return oldReturn.flatMap((token) -> { return operator.merge(new TokenSplitter(token)); }); }); }); - return returnedList.getValue(); + return returned.getValue(); } } 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 419c787..24c2014 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/funcutils/NumberUtils.java +++ b/BJC-Utils2/src/main/java/bjc/utils/funcutils/NumberUtils.java @@ -26,8 +26,7 @@ public class NumberUtils { } else { int result = 1; - for (int currentSub = 0; currentSub < power + 1; - currentSub++) { + for (int currentSub = 0; currentSub < power + 1; currentSub++) { result *= value - currentSub; } @@ -38,16 +37,16 @@ public class NumberUtils { /** * Evaluates a linear probability distribution * - * @param topExp + * @param winning * The number of winning possibilities - * @param bottomExp + * @param total * The number of total possibilities * @param rng * The function to use to generate a random possibility * @return Whether or not a random possibility was a winning one */ - public static boolean isProbable(int topExp, int bottomExp, + public static boolean isProbable(int winning, int total, Function<Integer, Integer> rng) { - return rng.apply(bottomExp) < topExp; + return rng.apply(total) < winning; } } 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 7573bfb..6770df2 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/funcutils/StringUtils.java +++ b/BJC-Utils2/src/main/java/bjc/utils/funcutils/StringUtils.java @@ -9,7 +9,6 @@ import java.util.Deque; * */ public class StringUtils { - /** * Checks if the given expression contains the specified operator in a * situation that indicates its use as an infix operator. @@ -21,12 +20,10 @@ public class StringUtils { * @return Whether or not the given expression contains the specified * operator as a infix operator */ - public static boolean containsInfixOperator(String expression, - String operator) { + public static boolean containsInfixOperator(String expression, String operator) { // Bit annoying to have to use a full class name, but what are you // going to do? - return org.apache.commons.lang3.StringUtils - .countMatches(expression, operator) == 1 + return org.apache.commons.lang3.StringUtils.countMatches(expression, operator) == 1 && !expression.equalsIgnoreCase(operator) && !expression.startsWith(operator); } @@ -85,8 +82,7 @@ public class StringUtils { * @return A string version of the deque, with allowance for an empty * deque */ - public static < - ContainedType> String printDeque(Deque<ContainedType> queue) { + public static <ContainedType> String printDeque(Deque<ContainedType> queue) { return queue.isEmpty() ? "(none)" : queue.toString(); } } 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 709538b..79f6e3b 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/funcutils/TokenDeaffixer.java +++ b/BJC-Utils2/src/main/java/bjc/utils/funcutils/TokenDeaffixer.java @@ -16,23 +16,19 @@ final class TokenDeaffixer @Override public IList<String> apply(String operatorName, String operatorRegex) { if (operatorName == null) { - throw new NullPointerException( - "Operator name must not be null"); + throw new NullPointerException("Operator name must not be null"); } else if (operatorRegex == null) { - throw new NullPointerException( - "Operator regex must not be null"); + throw new NullPointerException("Operator regex must not be null"); } if (StringUtils.containsOnly(token, operatorRegex)) { return new FunctionalList<>(token); } else if (token.startsWith(operatorName)) { - return new FunctionalList<>(operatorName, - token.split(operatorRegex)[1]); + return new FunctionalList<>(operatorName, token.split(operatorRegex)[1]); } else if (token.endsWith(operatorName)) { - return new FunctionalList<>(token.split(operatorRegex)[0], - operatorName); + return new FunctionalList<>(token.split(operatorRegex)[0], operatorName); } else { return new FunctionalList<>(token); } } -}
\ No newline at end of file +} |