@return true if any of the characters in the {@code string} answer true for the specified {@code predicate}.

@deprecated since 7.0. Use {@link #anySatisfyChar(String, CharPredicate)} instead.
184691
@Deprecated
    public static boolean anySatisfy(String string, CharPredicate predicate)
    {
        return StringIterate.anySatisfyChar(string, predicate);
    }
1150711
public static boolean parseAsKeyword(final char[] query, int offset) {
    if (query.length < (offset + 2)) {
      return false;
    }

    return (query[offset] | 32) == 'a'
        && (query[offset + 1] | 32) == 's';
  }
176513
public static boolean isLetter(String string) {
        boolean result = isNotEmpty(string);
        int idx = 0;
        int len = string.length();
        while (result) {
            if (idx >= len) {
                break;
            }
            result = isLetter(string.charAt(idx));
            idx++;
        }
        return result;
    }
593699
private boolean find(Clause clause, char[] chars, int[] cursor) {
    int start = cursor[0];
    int end = cursor[1];
    while (end - start >= clause.minlen)
      if (matchClause(clause, chars, cursor))
        return true;
      else
        cursor[0] = ++start;
    return false;
  }
374169
public static CharMatcher forPredicate(final Predicate<? super Character> predicate) {
    checkNotNull(predicate);
    if (predicate instanceof CharMatcher) {
      return (CharMatcher) predicate;
    }
    return new CharMatcher() {
      @Override public boolean matches(char c) {
        return predicate.apply(c);
      }

      @Override public boolean apply(Character character) {
        return predicate.apply(checkNotNull(character));
      }

      @Override public String toString() {
        return "CharMatcher.forPredicate(" + predicate + ")";
      }
    };
  }
741045
protected boolean isCharsetSupported(String charsetName) {
		// Charset.isSupproted throws RuntimeException if charset
		// is not supported (wow!!)
		try {
			return charsetName != null && Charset.isSupported(charsetName);
		} catch (IllegalCharsetNameException ex) {
			return false;
		}
	}
598501
public final boolean contains(CharSequence s) {

        int cp = getSingleCP(s);
        if (cp < 0) {
            return strings.contains(s.toString());
        } else {
            return contains(cp);
        }
    }
926948
public static boolean hasCharset(String ctype)
    {
        if (ctype == null)
        {
            return false;
        }
        Matcher matcher = CHARSET_PATT.matcher(ctype);
        if (matcher.find())
        {
            return true;
        }
        else
        {
            return false;
        }
    }
730627
public static boolean isLetter (char c)
    {
	// [84] Letter ::= BaseChar | Ideographic
	// [85] BaseChar ::= ... too much to repeat
	// [86] Ideographic ::= ... too much to repeat

	//
	// Optimize the typical case.
	//
	if (c >= 'a' && c <= 'z')
	    return true;
	if (c == '/')
	    return false;
	if (c >= 'A' && c <= 'Z')
	    return true;

	//
	// Since the tables are too ridiculous to use in code,
	// we're using the footnotes here to drive this test.
	//
	switch (Character.getType (c)) {
	    // app. B footnote says these are 'name start'
	    // chars' ...
	  case Character.LOWERCASE_LETTER:		// Ll
	  case Character.UPPERCASE_LETTER:		// Lu
	  case Character.OTHER_LETTER:			// Lo
	  case Character.TITLECASE_LETTER:		// Lt
	  case Character.LETTER_NUMBER:			// Nl

	    // OK, here we just have some exceptions to check...
	    return !isCompatibilityChar (c)
		    // per "5.14 of Unicode", rule out some combiners
		&& !(c >= 0x20dd && c <= 0x20e0);

	  default:
	    // check for some exceptions:  these are "alphabetic"
	    return ((c >= 0x02bb && c <=  0x02c1)
		    || c == 0x0559 || c == 0x06e5 || c == 0x06e6);
	}
    }
379584
public static boolean isJavaIdentifier( String s )
    {
        if (!Character.isJavaIdentifierStart( s.codePointAt( 0 ) )) return false;

        for (int i = 1; i < s.length(); i++)
        {
            if (!Character.isJavaIdentifierPart( s.codePointAt( i ) )) return false;
        }
        return true;
    }
214162
private static boolean hasUnsafeChars(String s) {
        for (int i = 0; i < s.length(); ++i) {
            char c = s.charAt(i);
            if (Character.isLetter(c) || c == '.')
                continue;
            else
                return true;
        }
        return false;
    }
611320
public static Parser<Void> many(CharPredicate predicate) {
    return Patterns.isChar(predicate).many().toScanner(predicate + "*");
  }
475907
@Deprecated
    public static Character detectIfNone(String string, CharPredicate predicate, String resultIfNone)
    {
        return StringIterate.detectCharIfNone(string, predicate, resultIfNone);
    }
1346417
public static int countChar(String string, CharPredicate predicate)
    {
        int count = 0;
        int size = string.length();
        for (int i = 0; i < size; i++)
        {
            if (predicate.accept(string.charAt(i)))
            {
                count++;
            }
        }
        return count;
    }
100025
@Override
    public boolean isCharsetSupported(String charset) {
        if (null == charset) {
            return false;
        }
        Boolean supported = this.supportedEncodingsCache.get(charset);
        if (supported != null) {
            return supported.booleanValue();
        }
        try {
            new String(TEST_CHAR, charset);
            supported = Boolean.TRUE;
        } catch (UnsupportedEncodingException e) {
            supported = Boolean.FALSE;
        }
        this.supportedEncodingsCache.put(charset, supported);
        return supported.booleanValue();
    }
253665
public static Parser<Void> isChar(final CharPredicate predicate) {
    return new Parser<Void>() {
      final String name = predicate.toString();

      @Override boolean apply(ParseContext ctxt) {
        if (ctxt.isEof()) {
          ctxt.missing(name);
          return false;
        }
        char c = ctxt.peekChar();
        if (predicate.isChar(c)) {
          ctxt.next();
          ctxt.result = null;
          return true;
        }
        ctxt.missing(name);
        return false;
      }

      @Override public String toString() {
        return name;
      }
    };
  }
301510
public static CharPredicate range(final char a, final char b) {
    return new CharPredicate() {
      @Override public boolean isChar(char c) {
        return c >= a && c <= b;
      }
      @Override public String toString() {
        return "[" + a + '-' + b + "]";
      }
    };
  }