From 72e8de605598f62efbd63c17897e80cec181ff2b Mon Sep 17 00:00:00 2001 From: EVE Date: Wed, 15 Mar 2017 19:06:48 -0400 Subject: Remove old splitter code, and swap naming to match. --- .../main/java/bjc/utils/funcutils/ListUtils.java | 4 +- .../java/bjc/utils/funcutils/NeoTokenSplitter.java | 157 ------------------- .../java/bjc/utils/funcutils/TokenDeaffixer.java | 47 ------ .../java/bjc/utils/funcutils/TokenSplitter.java | 168 +++++++++++++++++---- 4 files changed, 141 insertions(+), 235 deletions(-) delete mode 100644 BJC-Utils2/src/main/java/bjc/utils/funcutils/NeoTokenSplitter.java delete mode 100644 BJC-Utils2/src/main/java/bjc/utils/funcutils/TokenDeaffixer.java (limited to 'BJC-Utils2/src/main/java/bjc/utils/funcutils') 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 c231767..f55eb36 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/funcutils/ListUtils.java +++ b/BJC-Utils2/src/main/java/bjc/utils/funcutils/ListUtils.java @@ -80,7 +80,7 @@ public class ListUtils { * The affixes to remove * @return The tokens that have been deaffixed * - * @deprecated Replaced by NeoTokenSplitter. + * @deprecated Replaced by TokenSplitter. */ @Deprecated public static IList deAffixTokens(IList input, Deque> operators) { @@ -301,7 +301,7 @@ public class ListUtils { * those operators * @return A list of tokens split on all the operators * - * @deprecated Use NeoTokenSplitter now + * @deprecated Use TokenSplitter now */ @Deprecated public static IList splitTokens(IList input, Deque> operators) { diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcutils/NeoTokenSplitter.java b/BJC-Utils2/src/main/java/bjc/utils/funcutils/NeoTokenSplitter.java deleted file mode 100644 index 9da457e..0000000 --- a/BJC-Utils2/src/main/java/bjc/utils/funcutils/NeoTokenSplitter.java +++ /dev/null @@ -1,157 +0,0 @@ -package bjc.utils.funcutils; - -import java.util.regex.Pattern; - -/** - * Split a string and keep given delimiters. - * - * @author Ben Culkin - */ -public class NeoTokenSplitter { - /* - * This string is a format template for the delimiter matching regex - * - * It does two things: - * - *
    - *
  1. Match to the left of the provided delimiter by positive lookahead
    2. - *
  2. Match to the right of the provided delimiter by positive lookbehind
    3. - *
- * - * Thus, it will only match in places where the delimiter is, but won't - * actually match the delimiter, leaving split to put it into the stream - */ - private static String WITH_DELIM = "((?<=%1$s)|(?=%1$s))"; - - /* - * This string is a format template for the multi-delimiter matching - * regex. - * - * It does the same thing as the single delimiter regex, but has to have - * some negative lookahead/lookbehind assertions to avoid splitting a - * delimiter into pieces. - */ - private static String WITH_MULTI_DELIM = "((?<=%1$s+)(?!%1$s)|(?> { - private String token; - - public TokenDeaffixer(String tok) { - token = tok; - } - - @Override - public IList apply(String operatorName, String operatorRegex) { - 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"); - - if(StringUtils.containsOnly(token, operatorRegex)) - return new FunctionalList<>(token); - 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)) - return new FunctionalList<>(token.split(operatorRegex)[0], operatorName); - else if(token.contains(operatorName)) { - String[] tokenParts = token.split(operatorRegex); - - IList returned = new FunctionalList<>(); - - for(int i = 0; i < tokenParts.length; i++) { - returned.add(tokenParts[i]); - - if(i < tokenParts.length - 1) { - returned.add(operatorName); - } - } - - return returned; - } 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 84f5270..084bdae 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/funcutils/TokenSplitter.java +++ b/BJC-Utils2/src/main/java/bjc/utils/funcutils/TokenSplitter.java @@ -1,47 +1,157 @@ package bjc.utils.funcutils; -import bjc.utils.funcdata.FunctionalList; -import bjc.utils.funcdata.IList; +import java.util.regex.Pattern; -import java.util.Iterator; -import java.util.function.BiFunction; +/** + * Split a string and keep given delimiters. + * + * @author Ben Culkin + */ +public class TokenSplitter { + /* + * This string is a format template for the delimiter matching regex + * + * It does two things: + * + *
    + *
  1. Match to the left of the provided delimiter by positive lookahead
    2. + *
  2. Match to the right of the provided delimiter by positive lookbehind
    3. + *
+ * + * Thus, it will only match in places where the delimiter is, but won't + * actually match the delimiter, leaving split to put it into the stream + */ + private static String WITH_DELIM = "((?<=%1$s)|(?=%1$s))"; -final class TokenSplitter implements BiFunction> { - private String tokenToSplit; + /* + * This string is a format template for the multi-delimiter matching + * regex. + * + * It does the same thing as the single delimiter regex, but has to have + * some negative lookahead/lookbehind assertions to avoid splitting a + * delimiter into pieces. + */ + private static String WITH_MULTI_DELIM = "((?<=%1$s+)(?!%1$s)|(? apply(String operatorName, String operatorRegex) { - 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"); + /** + * Split a provided string using configured delimiters, and keeping the + * delimiters. + * + * The splitter must be compiled first. + * + * @param inp + * The string to split. + * + * @return The split string, including delimiters. + * + * @throws IllegalStateException + * If the splitter isn't compiled. + */ + public String[] split(String inp) { + if(compPatt == null) throw new IllegalStateException("Token splitter has not been compiled yet"); + + /* + * Don't split something that we should exclude from being split. + */ + if(exclusionPatt.matcher(inp).matches()) return new String[] { inp }; - if(tokenToSplit.contains(operatorName)) { - if(StringUtils.containsOnly(tokenToSplit, operatorRegex)) - return new FunctionalList<>(tokenToSplit); + return compPatt.split(inp); + } - IList splitTokens = new FunctionalList<>(tokenToSplit.split(operatorRegex)); - IList result = new FunctionalList<>(); + /** + * Adds a string as a matched delimiter to split on. + * + * Only works for fixed length delimiters. + * + * The provided string is regex-escaped before being used. + * + * @param delim + * The delimiter to match on. + */ + public void addDelimiter(String delim) { + String quoteDelim = Pattern.quote(delim); + String delimPat = String.format(WITH_DELIM, quoteDelim); - Iterator itr = splitTokens.toIterable().iterator(); - int tokenExpansionSize = splitTokens.getSize(); + if(currPatt == null) { + currPatt = new StringBuilder(); + currExclusionPatt = new StringBuilder(); - String elm = itr.next(); + currPatt.append("(?:" + delimPat + ")"); + currExclusionPatt.append("(?:" + quoteDelim + ")"); + } else { + currPatt.append("|(?:" + delimPat + ")"); + currExclusionPatt.append("|(?:" + quoteDelim + ")"); + } + } - for(int i = 0; itr.hasNext(); elm = itr.next()) { - result.add(elm); + /** + * Adds a character class as a matched delimiter to split on. + * + * The provided string should be a pattern to match one or more + * occurances of. + * + * @param delim + * The delimiter to split on. + */ + public void addMultiDelimiter(String delim) { + String delimPat = String.format(WITH_MULTI_DELIM, "(?:" + delim + ")"); - if(i != tokenExpansionSize) { - result.add(operatorName); - } - } + if(currPatt == null) { + currPatt = new StringBuilder(); + currExclusionPatt = new StringBuilder(); - return result; + currPatt.append("(?:" + delimPat + ")"); + currExclusionPatt.append("(?:(?:" + delim + ")+)"); + + } else { + currPatt.append("|(?:" + delimPat + ")"); + currExclusionPatt.append("|(?:(?:" + delim + ")+)"); } + } + + /** + * Marks strings matching the pattern delim as non-splittable. + * + * @param delim + * The regex to not splitting matching strings. + */ + public void addNonMatcher(String delim) { + if(currPatt == null) { + currPatt = new StringBuilder(); + currExclusionPatt = new StringBuilder(); - return new FunctionalList<>(tokenToSplit); + currExclusionPatt.append("(?:" + delim + ")"); + } else { + currExclusionPatt.append("|(?:" + delim + ")"); + } + } + /** + * Compiles the current set of delimiters to a pattern. + * + * Makes this splitter ready to use. + */ + public void compile() { + compPatt = Pattern.compile(currPatt.toString()); + exclusionPatt = Pattern.compile(currExclusionPatt.toString()); } } -- cgit v1.2.3