private static ImmutableList<String> splitLines(String s) { // splitToList is @Beta, so we avoid it. return ImmutableList.copyOf(Splitter.onPattern("\r?\n").split(s)); }
public RegexParser( final String pattern, final Optional<String> listDelimiter ) { this.pattern = pattern; this.listSplitter = Splitter.onPattern(listDelimiter.isPresent() ? listDelimiter.get() : Parsers.DEFAULT_LIST_DELIMITER); this.valueFunction = new Function<String, Object>() { @Override public Object apply(String input) { final List retVal = StreamSupport.stream(listSplitter.split(input).spliterator(), false) .map(Strings::emptyToNull) .collect(Collectors.toList()); if (retVal.size() == 1) { return retVal.get(0); } else { return retVal; } } }; this.compiled = Pattern.compile(pattern); }
private static Splitter createSplitter(char separator, char... otherSeparators) { if (otherSeparators.length == 0) { return Splitter.on(separator).omitEmptyStrings(); } // TODO(cgdecker): When CharMatcher is out of @Beta, us Splitter.on(CharMatcher) StringBuilder patternBuilder = new StringBuilder(); patternBuilder.append("["); appendToRegex(separator, patternBuilder); for (char other : otherSeparators) { appendToRegex(other, patternBuilder); } patternBuilder.append("]"); return Splitter.onPattern(patternBuilder.toString()).omitEmptyStrings(); }
private static class CharSequenceCharSource extends CharSource { private static final Splitter LINE_SPLITTER = Splitter.onPattern("\r\n|\n|\r");
@GwtIncompatible // Splitter.onPattern public void testPatternSplitWithMultipleLetters() { Iterable<String> testPatterningMotto = Splitter.onPattern("-").split("Testing-rocks-Debugging-sucks"); assertThat(testPatterningMotto) .containsExactly("Testing", "rocks", "Debugging", "sucks") .inOrder(); }
@GwtIncompatible // Splitter.onPattern public void testPatternSplitWithDoubleDelimiter() { String doubled = "a,,b,c"; Iterable<String> letters = Splitter.onPattern(",").split(doubled); assertThat(letters).containsExactly("a", "", "b", "c").inOrder(); }
@GwtIncompatible // Splitter.onPattern public void testPatternSplitWithDoubleDelimiterAndSpace() { String doubled = "a,, b,c"; Iterable<String> letters = Splitter.onPattern(",").split(doubled); assertThat(letters).containsExactly("a", "", " b", "c").inOrder(); }
@GwtIncompatible // Splitter.onPattern public void testPatternSimpleSplitWithNoDelimiter() { String simple = "a,b,c"; Iterable<String> letters = Splitter.onPattern("foo").split(simple); assertThat(letters).containsExactly("a,b,c").inOrder(); }
@GwtIncompatible // Splitter.onPattern public void testPatternSplitWithTrailingDelimiter() { String trailing = "a,b,c,"; Iterable<String> letters = Splitter.onPattern(",").split(trailing); assertThat(letters).containsExactly("a", "b", "c", "").inOrder(); }
@GwtIncompatible // Splitter.onPattern public void testPatternSimpleSplit() { String simple = "a,b,c"; Iterable<String> letters = Splitter.onPattern(",").split(simple); assertThat(letters).containsExactly("a", "b", "c").inOrder(); }
@GwtIncompatible // Splitter.onPattern public void testPatternSplitWithLeadingDelimiter() { String leading = ",a,b,c"; Iterable<String> letters = Splitter.onPattern(",").split(leading); assertThat(letters).containsExactly("", "a", "b", "c").inOrder(); }
@GwtIncompatible // java.util.regex.Pattern @AndroidIncompatible // Bug in older versions of Android we test against, since fixed. public void testPatternSplitLookBehind() { if (!CommonPattern.isPcreLike()) { return; } String toSplit = ":foo::barbaz:"; String regexPattern = "(?<=:)"; Iterable<String> split = Splitter.onPattern(regexPattern).split(toSplit); assertThat(split).containsExactly(":", "foo:", ":", "barbaz:").inOrder(); // splits into chunks ending in : }
@GwtIncompatible // java.util.regex.Pattern @AndroidIncompatible // not clear that j.u.r.Matcher promises to handle mutations during use public void testSplitterIterableIsLazy_pattern() { if (!CommonPattern.isPcreLike()) { return; } assertSplitterIterableIsLazy(Splitter.onPattern(",")); }
final List<String> command = Splitter.onPattern(" ") .omitEmptyStrings() .splitToList(COMPOSE_EXECUTABLE + " " + cmd);
public GuavaSplitter(String patternString) { if (patternString != null) { splitter = Splitter.onPattern(patternString); } else { splitter = null; } }
public static int wordCount(String s) { if (s == null) return 0; Iterable<String> split = Splitter.onPattern("\\w+").split(s); return Iterables.size(split) - 1; }
/** * Split a string into lines in a platform-agnostic way. * * <p>Note: There will be a trailing empty string if the input string ends with a line separator. * For example: asLines("foo\n") returns ["foo", ""] */ private static List<String> asLines(String multiLineString) { return Splitter.onPattern("\\R").splitToList(multiLineString); }
/** * Split a string into lines in a platform-agnostic way. * * <p>Note: There will be a trailing empty string if the input string ends with a line separator. * For example: asLines("foo\n") returns ["foo", ""] */ private static List<String> asLines(String multiLineString) { return Splitter.onPattern("\\R").splitToList(multiLineString); } }
private List<String> parseArgumentLineOnSpace(String line) { // Split arguments on space unless return Splitter.onPattern("\\s+(?=([^\"]*\"[^\"]*\")*[^\"]*$)").splitToList(line); } }
/** * Create the dynamic set property. The guava Splitter used is created as * <code>Splitter.onPattern(delimiterRegex).omitEmptyStrings().trimResults()</code>. The default * set value will be transformed from set of strings after splitting. If defaultValue string is * null, the default set value will be an empty set. */ public DynamicSetProperty(String propName, String defaultValue, String delimiterRegex) { this.splitter = Splitter.onPattern(delimiterRegex).omitEmptyStrings().trimResults(); setup(propName, transform(split(defaultValue)), splitter); }