/** * Returns a splitter that uses the given single-character separator. For example, {@code * Splitter.on(',').split("foo,,bar")} returns an iterable containing {@code ["foo", "", "bar"]}. * * @param separator the character to recognize as a separator * @return a splitter, with default settings, that recognizes that separator */ public static Splitter on(char separator) { return on(CharMatcher.is(separator)); }
/** * Returns a {@code char} matcher that matches any BMP character present in the given character * sequence. Returns a bogus matcher if the sequence contains supplementary characters. */ public static CharMatcher anyOf(final CharSequence sequence) { switch (sequence.length()) { case 0: return none(); case 1: return is(sequence.charAt(0)); case 2: return isEither(sequence.charAt(0), sequence.charAt(1)); default: // TODO(lowasser): is it potentially worth just going ahead and building a precomputed // matcher? return new AnyOf(sequence); } }
/** * Helper method for {@link #precomputedInternal} that doesn't test if the negation is cheaper. */ @GwtIncompatible // SmallCharMatcher private static CharMatcher precomputedPositive( int totalCharacters, BitSet table, String description) { switch (totalCharacters) { case 0: return none(); case 1: return is((char) table.nextSetBit(0)); case 2: char c1 = (char) table.nextSetBit(0); char c2 = (char) table.nextSetBit(c1 + 1); return isEither(c1, c2); default: return isSmall(totalCharacters, table.length()) ? SmallCharMatcher.from(table, description) : new BitSetMatcher(table, description); } }
private void doTestTrimLeadingFrom(String in, String out) { // Try a few different matchers which all match '-' and not 'x' assertEquals(out, is('-').trimLeadingFrom(in)); assertEquals(out, is('-').or(is('#')).trimLeadingFrom(in)); assertEquals(out, isNot('x').trimLeadingFrom(in)); assertEquals(out, is('x').negate().trimLeadingFrom(in)); assertEquals(out, anyOf("-#").trimLeadingFrom(in)); assertEquals(out, anyOf("-#123").trimLeadingFrom(in)); }
private void doTestTrimTrailingFrom(String in, String out) { // Try a few different matchers which all match '-' and not 'x' assertEquals(out, is('-').trimTrailingFrom(in)); assertEquals(out, is('-').or(is('#')).trimTrailingFrom(in)); assertEquals(out, isNot('x').trimTrailingFrom(in)); assertEquals(out, is('x').negate().trimTrailingFrom(in)); assertEquals(out, anyOf("-#").trimTrailingFrom(in)); assertEquals(out, anyOf("-#123").trimTrailingFrom(in)); }
public CharLiteral(Optional<NodeLocation> location, String value) { super(location); requireNonNull(value, "value is null"); this.value = value; this.slice = utf8Slice(CharMatcher.is(' ').trimTrailingFrom(value)); }
private void doTestTrimAndCollapse(String in, String out) { // Try a few different matchers which all match '-' and not 'x' for (char replacement : new char[] {'_', '-'}) { String expected = out.replace('_', replacement); assertEqualsSame(expected, in, is('-').trimAndCollapseFrom(in, replacement)); assertEqualsSame(expected, in, is('-').or(is('#')).trimAndCollapseFrom(in, replacement)); assertEqualsSame(expected, in, isNot('x').trimAndCollapseFrom(in, replacement)); assertEqualsSame(expected, in, is('x').negate().trimAndCollapseFrom(in, replacement)); assertEqualsSame(expected, in, anyOf("-").trimAndCollapseFrom(in, replacement)); assertEqualsSame(expected, in, anyOf("-#").trimAndCollapseFrom(in, replacement)); assertEqualsSame(expected, in, anyOf("-#123").trimAndCollapseFrom(in, replacement)); } }
public static ReadMapping charReadMapping(CharType charType) { requireNonNull(charType, "charType is null"); return sliceReadMapping(charType, (resultSet, columnIndex) -> utf8Slice(CharMatcher.is(' ').trimTrailingFrom(resultSet.getString(columnIndex)))); }
private void doTestTrimFrom(String in, String out) { // Try a few different matchers which all match '-' and not 'x' assertEquals(out, is('-').trimFrom(in)); assertEquals(out, is('-').or(is('#')).trimFrom(in)); assertEquals(out, isNot('x').trimFrom(in)); assertEquals(out, is('x').negate().trimFrom(in)); assertEquals(out, anyOf("-").trimFrom(in)); assertEquals(out, anyOf("-#").trimFrom(in)); assertEquals(out, anyOf("-#123").trimFrom(in)); }
public void testReplaceFrom() { assertEquals("yoho", is('a').replaceFrom("yaha", 'o')); assertEquals("yh", is('a').replaceFrom("yaha", "")); assertEquals("yoho", is('a').replaceFrom("yaha", "o")); assertEquals("yoohoo", is('a').replaceFrom("yaha", "oo")); assertEquals("12 > 5", is('>').replaceFrom("12 > 5", ">")); }
private void doTestCollapse(String in, String out) { // Try a few different matchers which all match '-' and not 'x' // Try replacement chars that both do and do not change the value. for (char replacement : new char[] {'_', '-'}) { String expected = out.replace('_', replacement); assertEqualsSame(expected, in, is('-').collapseFrom(in, replacement)); assertEqualsSame(expected, in, is('-').collapseFrom(in, replacement)); assertEqualsSame(expected, in, is('-').or(is('#')).collapseFrom(in, replacement)); assertEqualsSame(expected, in, isNot('x').collapseFrom(in, replacement)); assertEqualsSame(expected, in, is('x').negate().collapseFrom(in, replacement)); assertEqualsSame(expected, in, anyOf("-").collapseFrom(in, replacement)); assertEqualsSame(expected, in, anyOf("-#").collapseFrom(in, replacement)); assertEqualsSame(expected, in, anyOf("-#123").collapseFrom(in, replacement)); } }
@Description("mongodb ObjectId from the given string") @ScalarFunction("objectid") @SqlType("ObjectId") public static Slice ObjectId(@SqlType(StandardTypes.VARCHAR) Slice value) { return Slices.wrappedBuffer(new ObjectId(CharMatcher.is(' ').removeFrom(value.toStringUtf8())).toByteArray()); }
private void doTestCollapseWithNoChange(String inout) { assertSame(inout, is('-').collapseFrom(inout, '_')); assertSame(inout, is('-').or(is('#')).collapseFrom(inout, '_')); assertSame(inout, isNot('x').collapseFrom(inout, '_')); assertSame(inout, is('x').negate().collapseFrom(inout, '_')); assertSame(inout, anyOf("-").collapseFrom(inout, '_')); assertSame(inout, anyOf("-#").collapseFrom(inout, '_')); assertSame(inout, anyOf("-#123").collapseFrom(inout, '_')); assertSame(inout, CharMatcher.none().collapseFrom(inout, '_')); }
public void testPrecomputedOptimizations() { // These are testing behavior that's never promised by the API. // Some matchers are so efficient that it is a waste of effort to // build a precomputed version. CharMatcher m1 = is('x'); assertSame(m1, m1.precomputed()); assertEquals(m1.toString(), m1.precomputed().toString()); CharMatcher m2 = anyOf("Az"); assertSame(m2, m2.precomputed()); assertEquals(m2.toString(), m2.precomputed().toString()); CharMatcher m3 = inRange('A', 'Z'); assertSame(m3, m3.precomputed()); assertEquals(m3.toString(), m3.precomputed().toString()); assertSame(CharMatcher.none(), CharMatcher.none().precomputed()); assertSame(CharMatcher.any(), CharMatcher.any().precomputed()); }
public void testGeneral() { doTestGeneral(is('a'), 'a', 'b'); doTestGeneral(isNot('a'), 'b', 'a'); doTestGeneral(anyOf("x"), 'x', 'z'); doTestGeneral(anyOf("xy"), 'y', 'z'); doTestGeneral(anyOf("CharMatcher"), 'C', 'z'); doTestGeneral(noneOf("CharMatcher"), 'z', 'C'); doTestGeneral(inRange('p', 'x'), 'q', 'z'); }
public void testEmpty() throws Exception { doTestEmpty(CharMatcher.any()); doTestEmpty(CharMatcher.none()); doTestEmpty(is('a')); doTestEmpty(isNot('a')); doTestEmpty(anyOf("")); doTestEmpty(anyOf("x")); doTestEmpty(anyOf("xy")); doTestEmpty(anyOf("CharMatcher")); doTestEmpty(noneOf("CharMatcher")); doTestEmpty(inRange('n', 'q')); doTestEmpty(forPredicate(Predicates.equalTo('c'))); }
@GwtIncompatible // NullPointerTester public void testNull() throws Exception { doTestNull(CharMatcher.any()); doTestNull(CharMatcher.none()); doTestNull(is('a')); doTestNull(isNot('a')); doTestNull(anyOf("")); doTestNull(anyOf("x")); doTestNull(anyOf("xy")); doTestNull(anyOf("CharMatcher")); doTestNull(noneOf("CharMatcher")); doTestNull(inRange('n', 'q')); doTestNull(forPredicate(Predicates.equalTo('c'))); }
public void testAllMatches() { doTestAllMatches(CharMatcher.any(), "blah"); doTestAllMatches(isNot('a'), "bcde"); doTestAllMatches(is('a'), "aaaa"); doTestAllMatches(noneOf("CharMatcher"), "zxqy"); doTestAllMatches(anyOf("x"), "xxxx"); doTestAllMatches(anyOf("xy"), "xyyx"); doTestAllMatches(anyOf("CharMatcher"), "ChMa"); doTestAllMatches(inRange('m', 'p'), "mom"); doTestAllMatches(forPredicate(Predicates.equalTo('c')), "ccc"); doTestAllMatches(CharMatcher.digit(), "0123456789\u0ED0\u1B59"); doTestAllMatches(CharMatcher.javaDigit(), "0123456789"); doTestAllMatches(CharMatcher.digit().and(CharMatcher.ascii()), "0123456789"); doTestAllMatches(CharMatcher.singleWidth(), "\t0123ABCdef~\u00A0\u2111"); }
public void testNoMatches() { doTestNoMatches(CharMatcher.none(), "blah"); doTestNoMatches(is('a'), "bcde"); doTestNoMatches(isNot('a'), "aaaa"); doTestNoMatches(anyOf(""), "abcd"); doTestNoMatches(anyOf("x"), "abcd"); doTestNoMatches(anyOf("xy"), "abcd"); doTestNoMatches(anyOf("CharMatcher"), "zxqy"); doTestNoMatches(noneOf("CharMatcher"), "ChMa"); doTestNoMatches(inRange('p', 'x'), "mom"); doTestNoMatches(forPredicate(Predicates.equalTo('c')), "abe"); doTestNoMatches(inRange('A', 'Z').and(inRange('F', 'K').negate()), "F1a"); doTestNoMatches(CharMatcher.digit(), "\tAz()"); doTestNoMatches(CharMatcher.javaDigit(), "\tAz()"); doTestNoMatches(CharMatcher.digit().and(CharMatcher.ascii()), "\tAz()"); doTestNoMatches(CharMatcher.singleWidth(), "\u05bf\u3000"); }
@GwtIncompatible // java.util.BitSet public void testSetBits() { doTestSetBits(CharMatcher.any()); doTestSetBits(CharMatcher.none()); doTestSetBits(is('a')); doTestSetBits(isNot('a')); doTestSetBits(anyOf("")); doTestSetBits(anyOf("x")); doTestSetBits(anyOf("xy")); doTestSetBits(anyOf("CharMatcher")); doTestSetBits(noneOf("CharMatcher")); doTestSetBits(inRange('n', 'q')); doTestSetBits(forPredicate(Predicates.equalTo('c'))); doTestSetBits(CharMatcher.ascii()); doTestSetBits(CharMatcher.digit()); doTestSetBits(CharMatcher.invisible()); doTestSetBits(CharMatcher.whitespace()); doTestSetBits(inRange('A', 'Z').and(inRange('F', 'K').negate())); }