A {@link CharPredicate} that returns true if all {@code CharPredicate} in
{@code predicates} evaluate to true.
199229
public static CharPredicate and(final CharPredicate... predicates) {
    if (predicates.length == 0)
      return ALWAYS;
    else if (predicates.length == 1) return predicates[0];
    return new CharPredicate() {
      @Override public boolean isChar(char c) {
        for(int i = 0;i < predicates.length;i++) {
          if (!predicates[i].isChar(c)) return false;
        }
        return true;
      }
      @Override public String toString() {
        return Strings.join(" and ", predicates);
      }
    };
  }
1337641
public boolean walkUntil(Predicate<StringWalker> predicate)
	{
		if (predicate.test(this))
			return true;
		while (nextCharacter())
			if (predicate.test(this))
				return true;
		return false;
	}
688658
public static <T> Predicate<T> iterablePresent() {
        return t -> t instanceof Iterable ? ((Iterable) t).iterator()
                                                          .hasNext()
                : false;
    }
1188942
@Deprecated
    public static boolean noneSatisfy(String string, CharPredicate predicate)
    {
        return StringIterate.noneSatisfyChar(string, predicate);
    }
1134286
public static Pattern many(final CharPredicate predicate) {
    return new Pattern() {
      @Override public int match(CharSequence src, int begin, int end) {
        return matchMany(predicate, src, end, begin, 0);
      }
      @Override public String toString() {
        return predicate + "*";
      }
    };
  }
271135
public static Character detectChar(String string, CharPredicate predicate)
    {
        int size = string.length();
        for (int i = 0; i < size; i++)
        {
            char character = string.charAt(i);
            if (predicate.accept(character))
            {
                return character;
            }
        }
        return null;
    }
387259
final public Selector Predicate() throws ParseException {
                         Selector ans;
    if (jj_2_1(2147483647)) {
      ans = ComparisonPredicate();
    } else if (jj_2_2(2147483647)) {
      ans = NullPredicate();
    } else if (jj_2_3(2147483647)) {
      ans = BetweenPredicate();
    } else if (jj_2_4(2147483647)) {
      ans = LikePredicate();
    } else if (jj_2_5(2147483647)) {
      ans = JMSSetPredicate();
    } else {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case 7:
      case 8:
      case 11:
      case TRUE:
      case FALSE:
      case IDENTIFIER:
      case QUOTED_IDENTIFIER:
      case INTEGER_LITERAL:
      case FLOATING_POINT_LITERAL:
      case STRING_LITERAL:
        ans = Expression();
        break;
      default:
        jj_la1[3] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    }
    {if (true) return ans;}
    throw new Error("Missing return statement in function");
  }
1262155
public static boolean isAlphaNumeric(String in) {
		char c = 0;
		for (int i = in.length(); i > 0; i--) {
			c = in.charAt(i - 1);
			if (!Character.isLetterOrDigit(c)) {
				return false;
			}
		}
		return true;
	}
1358731
public final boolean contains(char a) {
        for (int i = off; i < (off + len); ++i) {
            if (fb[i] == a) {
                return true;
            }
        }
        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 + ")";
      }
    };
  }
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;
        }
    }
75595
public boolean contains(char c) {
        for (int k = pos; k < len; k++) {
            if (chars[k] == c) return true;
        }
        return false;
    }
475907
@Deprecated
    public static Character detectIfNone(String string, CharPredicate predicate, String resultIfNone)
    {
        return StringIterate.detectCharIfNone(string, predicate, resultIfNone);
    }
1233382
public static boolean isChar(char c) {
		return Character.isDigit(c)||Character.isLowerCase(c)||Character.isUpperCase(c);
	}
184691
@Deprecated
    public static boolean anySatisfy(String string, CharPredicate predicate)
    {
        return StringIterate.anySatisfyChar(string, predicate);
    }
1311882
public static Character detectCharIfNone(String string, CharPredicate predicate, String resultIfNone)
    {
        Character result = StringIterate.detectChar(string, predicate);
        return result == null ? Character.valueOf(resultIfNone.charAt(0)) : result;
    }
913402
public boolean forall(PixelPredicate predicate) {
        return Arrays.stream(points()).allMatch(p -> predicate.test(p.x, p.y, pixel(p)));
    }