A scanner that scans greedily for 1 or more characters that satisfies the given CharPredicate.

@param predicate the predicate object.
@return the Parser object.
771029
public static Parser<Void> many1(CharPredicate predicate) {
    return Patterns.many1(predicate).toScanner(predicate + "+");
  }
94100
@Deprecated
    public static int count(String string, CodePointPredicate predicate)
    {
        return StringIterate.countCodePoint(string, predicate);
    }
516459
@SequentialOnly
    public static <T> Predicate<T> indexed(final IndexedPredicate<T> predicate) {
        return Predicates.indexed(predicate);
    }
1112474
final public Selector LikePredicate() throws ParseException {
                             Selector id; Token pat; Token esc=null; boolean neg=false;
    id = FieldRef();
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case NOT:
      jj_consume_token(NOT);
                              neg = true;
      break;
    default:
      jj_la1[17] = jj_gen;
      ;
    }
    jj_consume_token(LIKE);
    pat = jj_consume_token(STRING_LITERAL);
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case ESCAPE:
      jj_consume_token(ESCAPE);
      esc = jj_consume_token(STRING_LITERAL);
      break;
    default:
      jj_la1[18] = jj_gen;
      ;
    }
    Selector ans = ParseUtil.convertLike(id, pat.image, (esc==null) ? null : esc.image);
    if (ans == null) generateParseException();
    if (neg) {if (true) return new OperatorImpl(Operator.NOT, ans);}
    else {if (true) return ans;}
    throw new Error("Missing return statement in function");
  }
888883
@Deprecated
    public static int count(String string, final com.gs.collections.impl.block.predicate.primitive.CharPredicate predicate)
    {
        return StringIterate.countChar(string, new CharPredicate()
        {
            public boolean accept(char value)
            {
                return predicate.accept(value);
            }
        });
    }
307541
public List<List<T>> split(Predicate<? super T> predicate) {
        final List<T> a = Lists.newArrayList(), b = Lists.newArrayList();
        for (T elt: each()) {
            (predicate.apply(elt) ? a : b).add(elt);
        }
        List<List<T>> result = Lists.newArrayList();
        result.add(a);
        result.add(b);
        return result;
    }
325125
public <E extends Exception> boolean allMatch(Try.CharPredicate<E> filter) throws E {
        return allMatch(0, size(), filter);
    }
1362021
@Deprecated
    public static String select(String string, CodePointPredicate predicate)
    {
        return StringIterate.selectCodePoint(string, predicate);
    }
692138
public static Predicate parse(final String predicate) {
        return PredicateParser.parse(predicate, Thread.currentThread().getContextClassLoader());
    }
496627
public static boolean noneSatisfyCodePoint(String string, CodePointPredicate predicate)
    {
        int size = string.length();
        for (int i = 0; i < size; )
        {
            int codePoint = string.codePointAt(i);
            if (predicate.accept(codePoint))
            {
                return false;
            }
            i += Character.charCount(codePoint);
        }
        return true;
    }
405941
public static CharPredicate isChar(final char c) {
    return new CharPredicate() {
      @Override public boolean isChar(char x) {
        return x == c;
      }
      @Override public String toString() {
        return Character.toString(c);
      }
    };
  }
201840
public static Pattern times(final int min, final int max, final CharPredicate predicate) {
    Checks.checkMinMax(min, max);
    return new Pattern() {
      @Override
      public int match(CharSequence src, int begin, int end) {
        int minLen = RepeatCharPredicatePattern.matchRepeat(min, predicate, src, end, begin, 0);
        if (minLen == MISMATCH)
          return MISMATCH;
        return matchSome(max - min, predicate, src, end, begin + minLen, minLen);
      }
    };
  }
307756
public static <T> ActionPredicate<T> fromPredicate(final Predicate<T> predicate) {
	return new ActionPredicate<T>() {
	    public boolean actionPredicate(T obj) {
		return predicate.check(obj);
	    }
	};
    }
1771
public Optional<T> filter(final Predicate<? super T> predicate) {
        if (isPresent() && predicate.test(get())) {
            return this;
        }

        return empty();
    }
1140159
public static Parser<Void> notAmong(String chars) {
    if (chars.length() == 0) return ANY_CHAR;
    if (chars.length() == 1) return notChar(chars.charAt(0));
    return isChar(CharPredicates.notAmong(chars));
  }
554711
@Deprecated
    public static String reject(String string, CharPredicate predicate)
    {
        return StringIterate.rejectChar(string, predicate);
    }
560102
private Selector parsePredicate(String predicate, String fullPath) 
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      tc.entry(cclass,
               "parsePredicate",
               "predicate: " + predicate); 

    Selector parsed = null;
    try
    {
      // Preprocess predicate for special characters
      String parserInput = preProcessForSpecials(predicate);
      
      // Attempt to parse predicate with "JMS" parser
      predicateParser =  MatchParserImpl.prime(predicateParser, parserInput, true);     
      parsed = predicateParser.getSelector(parserInput);
      if (parsed.getType() == Selector.INVALID)
      {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
          tc.debug(this,cclass, "parsePredicate", "Unable to parse predicate");           
        // reset the output to null
        parsed = null;
      }
      else
      {
        postProcessSelectorTree(parsed, fullPath);
      }
    }
    catch (Exception ex)
    {
      // No FFDC Code Needed.
      // In this case we will only trace the exception that we encountered.
      // It could be that the XPath parser is able to process this predicate
      // and that we've encountered a discrepancy between the syntax of an
      // expression supported by JMS and by XPath.
      if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
        tc.debug(this,cclass, "parsePredicate", ex);   
    }
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      tc.exit(this,cclass, "parsePredicate", parsed);     
    return parsed;
  }