How to use

CharSet

in

org.apache.commons.lang3

/**
 * Implementation of delete and keep
 *
 * @param str String to modify characters within
 * @param set String[] set of characters to modify
 * @param expect whether to evaluate on match, or non-match
 * @return the modified String, not null
 */
private static String modify(final String str, final String[] set, final boolean expect) {
  final CharSet chars = CharSet.getInstance(set);
  final StringBuilder buffer = new StringBuilder(str.length());
  final char[] chrs = str.toCharArray();
  for (final char chr : chrs) {
    if (chars.contains(chr) == expect) {
      buffer.append(chr);
    }
  }
  return buffer.toString();
}

return new CharSet(setStrs);

/**
 * <p>Constructs a new CharSet using the set syntax.
 * Each string is merged in with the set.</p>
 *
 * @param set  Strings to merge into the initial set
 * @throws NullPointerException if set is {@code null}
 */
protected CharSet(final String... set) {
  super();
  for (final String s : set) {
    add(s);
  }
}

@Test
public void testHashCode() {
  final CharSet abc = CharSet.getInstance("abc");
  final CharSet abc2 = CharSet.getInstance("abc");
  final CharSet atoc = CharSet.getInstance("a-c");
  final CharSet atoc2 = CharSet.getInstance("a-c");
  final CharSet notatoc = CharSet.getInstance("^a-c");
  final CharSet notatoc2 = CharSet.getInstance("^a-c");
  assertEquals(abc.hashCode(), abc.hashCode());
  assertEquals(abc.hashCode(), abc2.hashCode());
  assertEquals(atoc.hashCode(), atoc.hashCode());
  assertEquals(atoc.hashCode(), atoc2.hashCode());
  assertEquals(notatoc.hashCode(), notatoc.hashCode());
  assertEquals(notatoc.hashCode(), notatoc2.hashCode());
}

@Test
public void testGetInstance_Stringarray() {
  assertNull(CharSet.getInstance((String[]) null));
  assertEquals("[]", CharSet.getInstance(new String[0]).toString());
  assertEquals("[]", CharSet.getInstance(new String[] {null}).toString());
  assertEquals("[a-e]", CharSet.getInstance(new String[] {"a-e"}).toString());
}

@Test
public void testContains_Char() {
  final CharSet btod = CharSet.getInstance("b-d");
  final CharSet dtob = CharSet.getInstance("d-b");
  final CharSet bcd = CharSet.getInstance("bcd");
  final CharSet bd = CharSet.getInstance("bd");
  final CharSet notbtod = CharSet.getInstance("^b-d");
  assertFalse(btod.contains('a'));
  assertTrue(btod.contains('b'));
  assertTrue(btod.contains('c'));
  assertTrue(btod.contains('d'));
  assertFalse(btod.contains('e'));
  assertFalse(bcd.contains('a'));
  assertTrue(bcd.contains('b'));
  assertTrue(bcd.contains('c'));
  assertTrue(bcd.contains('d'));
  assertFalse(bcd.contains('e'));
  assertFalse(bd.contains('a'));
  assertTrue(bd.contains('b'));
  assertFalse(bd.contains('c'));
  assertTrue(bd.contains('d'));
  assertFalse(bd.contains('e'));
  assertTrue(notbtod.contains('a'));
  assertFalse(notbtod.contains('b'));
  assertFalse(notbtod.contains('c'));
  assertFalse(notbtod.contains('d'));

set = CharSet.getInstance("a-^c");
array = set.getCharRanges();
assertTrue(ArrayUtils.contains(array, CharRange.isIn('a', '^'))); // "a-^"
assertTrue(ArrayUtils.contains(array, CharRange.is('c'))); // "c"
assertFalse(set.contains('b'));
assertTrue(set.contains('^'));
assertTrue(set.contains('_')); // between ^ and a
assertTrue(set.contains('c'));
set = CharSet.getInstance("^a-^c");
array = set.getCharRanges();
assertTrue(ArrayUtils.contains(array, CharRange.isNotIn('a', '^'))); // "^a-^"
assertTrue(ArrayUtils.contains(array, CharRange.is('c'))); // "c"
assertTrue(set.contains('b'));
assertFalse(set.contains('^'));
assertFalse(set.contains('_')); // between ^ and a
set = CharSet.getInstance("a- ^-- "); //contains everything
array = set.getCharRanges();
assertTrue(ArrayUtils.contains(array, CharRange.isIn('a', ' '))); // "a- "
assertTrue(ArrayUtils.contains(array, CharRange.isNotIn('-', ' '))); // "^-- "
assertTrue(set.contains('#'));
assertTrue(set.contains('^'));
assertTrue(set.contains('a'));
assertTrue(set.contains('*'));
assertTrue(set.contains('A'));
set = CharSet.getInstance("^-b");
array = set.getCharRanges();

set = CharSet.getInstance("-");
array = set.getCharRanges();
assertEquals(1, array.length);
assertTrue(ArrayUtils.contains(array, CharRange.is('-')));
set = CharSet.getInstance("--");
array = set.getCharRanges();
assertEquals(1, array.length);
assertTrue(ArrayUtils.contains(array, CharRange.is('-')));
set = CharSet.getInstance("---");
array = set.getCharRanges();
assertEquals(1, array.length);
assertTrue(ArrayUtils.contains(array, CharRange.is('-')));
set = CharSet.getInstance("----");
array = set.getCharRanges();
assertEquals(1, array.length);
assertTrue(ArrayUtils.contains(array, CharRange.is('-')));
set = CharSet.getInstance("-a");
array = set.getCharRanges();
assertEquals(2, array.length);
assertTrue(ArrayUtils.contains(array, CharRange.is('-')));
assertTrue(ArrayUtils.contains(array, CharRange.is('a')));
set = CharSet.getInstance("a-");
array = set.getCharRanges();
assertEquals(2, array.length);

@Test
public void testGetInstance() {
  assertSame(CharSet.EMPTY, CharSet.getInstance( (String) null));
  assertSame(CharSet.EMPTY, CharSet.getInstance(""));
  assertSame(CharSet.ASCII_ALPHA, CharSet.getInstance("a-zA-Z"));
  assertSame(CharSet.ASCII_ALPHA, CharSet.getInstance("A-Za-z"));
  assertSame(CharSet.ASCII_ALPHA_LOWER, CharSet.getInstance("a-z"));
  assertSame(CharSet.ASCII_ALPHA_UPPER, CharSet.getInstance("A-Z"));
  assertSame(CharSet.ASCII_NUMERIC, CharSet.getInstance("0-9"));
}

private int run_CharSet(final int loopCount) {
  int t = 0;
  for (int i = 0; i < loopCount; i++) {
    for (final char ch : CHAR_SAMPLES) {
      final boolean b = CharSet.ASCII_NUMERIC.contains(ch);
      t += b ? 1 : 0;
    }
  }
  return t;
}

set = CharSet.getInstance((String) null);
array = set.getCharRanges();
assertEquals("[]", set.toString());
assertEquals(0, array.length);
set = CharSet.getInstance("");
array = set.getCharRanges();
assertEquals("[]", set.toString());
assertEquals(0, array.length);
set = CharSet.getInstance("a");
array = set.getCharRanges();
assertEquals("[a]", set.toString());
assertEquals(1, array.length);
assertEquals("a", array[0].toString());
set = CharSet.getInstance("^a");
array = set.getCharRanges();
assertEquals("[^a]", set.toString());
assertEquals(1, array.length);
assertEquals("^a", array[0].toString());
set = CharSet.getInstance("a-e");
array = set.getCharRanges();
assertEquals("[a-e]", set.toString());
assertEquals(1, array.length);
assertEquals("a-e", array[0].toString());
set = CharSet.getInstance("^a-e");

@Test
public void testEquals_Object() {
  final CharSet abc = CharSet.getInstance("abc");
  final CharSet abc2 = CharSet.getInstance("abc");
  final CharSet atoc = CharSet.getInstance("a-c");
  final CharSet atoc2 = CharSet.getInstance("a-c");
  final CharSet notatoc = CharSet.getInstance("^a-c");
  final CharSet notatoc2 = CharSet.getInstance("^a-c");
  assertFalse(abc.equals(null));
  assertTrue(abc.equals(abc));
  assertTrue(abc.equals(abc2));
  assertFalse(abc.equals(atoc));
  assertFalse(abc.equals(notatoc));
  assertFalse(atoc.equals(abc));
  assertTrue(atoc.equals(atoc));
  assertTrue(atoc.equals(atoc2));
  assertFalse(atoc.equals(notatoc));
  assertFalse(notatoc.equals(abc));
  assertFalse(notatoc.equals(atoc));
  assertTrue(notatoc.equals(notatoc));
  assertTrue(notatoc.equals(notatoc2));
}

CharSet set;
CharRange[] array;
set = CharSet.getInstance("^");
array = set.getCharRanges();
assertEquals(1, array.length);
assertTrue(ArrayUtils.contains(array, CharRange.is('^'))); // "^"
set = CharSet.getInstance("^^");
array = set.getCharRanges();
assertEquals(1, array.length);
assertTrue(ArrayUtils.contains(array, CharRange.isNot('^'))); // "^^"
set = CharSet.getInstance("^^^");
array = set.getCharRanges();
assertEquals(2, array.length);
assertTrue(ArrayUtils.contains(array, CharRange.isNot('^'))); // "^^"
assertTrue(ArrayUtils.contains(array, CharRange.is('^'))); // "^"
set = CharSet.getInstance("^^^^");
array = set.getCharRanges();
assertEquals(1, array.length);
assertTrue(ArrayUtils.contains(array, CharRange.isNot('^'))); // "^^" x2
set = CharSet.getInstance("a^");
array = set.getCharRanges();
assertEquals(2, array.length);
assertTrue(ArrayUtils.contains(array, CharRange.is('a'))); // "a"
assertTrue(ArrayUtils.contains(array, CharRange.is('^'))); // "^"

@Test
public void testSerialization() {
  CharSet set = CharSet.getInstance("a");
  assertEquals(set, SerializationUtils.clone(set));
  set = CharSet.getInstance("a-e");
  assertEquals(set, SerializationUtils.clone(set));
  set = CharSet.getInstance("be-f^a-z");
  assertEquals(set, SerializationUtils.clone(set));
}

/**
 * Return true if every character is valid hex <code>0-9</code>, <code>a-f</code>, or <code>A-F</code>
 */
public static final boolean isHex(char... chars) {
  for (char c : chars) {
    if (!HEX_CHARSET.contains(c)) {
      return false;
    }
  }
  return true;
}

  return false;
final CharSet chars = CharSet.getInstance(set);
for (final char c : str.toCharArray()) {
  if (chars.contains(c)) {
    return true;

set = CharSet.getInstance("abc");
array = set.getCharRanges();
assertEquals(3, array.length);
assertTrue(ArrayUtils.contains(array, CharRange.is('a')));
set = CharSet.getInstance("a-ce-f");
array = set.getCharRanges();
assertEquals(2, array.length);
assertTrue(ArrayUtils.contains(array, CharRange.isIn('a', 'c')));
assertTrue(ArrayUtils.contains(array, CharRange.isIn('e', 'f')));
set = CharSet.getInstance("ae-f");
array = set.getCharRanges();
assertEquals(2, array.length);
assertTrue(ArrayUtils.contains(array, CharRange.is('a')));
assertTrue(ArrayUtils.contains(array, CharRange.isIn('e', 'f')));
set = CharSet.getInstance("e-fa");
array = set.getCharRanges();
assertEquals(2, array.length);
assertTrue(ArrayUtils.contains(array, CharRange.is('a')));
assertTrue(ArrayUtils.contains(array, CharRange.isIn('e', 'f')));
set = CharSet.getInstance("ae-fm-pz");
array = set.getCharRanges();
assertEquals(4, array.length);
assertTrue(ArrayUtils.contains(array, CharRange.is('a')));

/**
 * @param resultBuilder
 *            , the builder for result strings.
 * @param resultArray
 *            , the byte array to hold results.
 * @param pattern
 *            , the string that is used to construct the charset for trimming.
 */
public StringTrimmer(UTF8StringBuilder resultBuilder, GrowableArray resultArray, String pattern) {
  this.resultBuilder = resultBuilder;
  this.resultArray = resultArray;
  if (pattern != null) {
    charSet = CharSet.getInstance(pattern);
  }
}

while (startIndex < srcUtfLen) {
  char ch = srcPtr.charAt(srcStart + startIndex);
  if (!charSet.contains(ch)) {
    break;
  char ch = srcPtr.charAt(srcStart + cursorIndex);
  cursorIndex += srcPtr.charSize(srcStart + cursorIndex);
  if (!charSet.contains(ch)) {
    endIndex = cursorIndex;

/**
 * <p>Constructs a new CharSet using the set syntax.
 * Each string is merged in with the set.</p>
 *
 * @param set  Strings to merge into the initial set
 * @throws NullPointerException if set is {@code null}
 */
protected CharSet(final String... set) {
  super();
  for (final String s : set) {
    add(s);
  }
}